38 files changed, 245 insertions, 292 deletions

diff --git a/spec/ruby/core/encoding/aliases_spec.rb b/spec/ruby/core/encoding/aliases_spec.rb
index 786157981a..12c6c6cf85 100644
--- a/spec/ruby/core/encoding/aliases_spec.rb
+++ b/spec/ruby/core/encoding/aliases_spec.rb
@@ -2,24 +2,24 @@ require_relative '../../spec_helper'
 
 describe "Encoding.aliases" do
   it "returns a Hash" do
-    Encoding.aliases.should be_an_instance_of(Hash)
+    Encoding.aliases.should.instance_of?(Hash)
   end
 
   it "has Strings as keys" do
     Encoding.aliases.keys.each do |key|
-      key.should be_an_instance_of(String)
+      key.should.instance_of?(String)
     end
   end
 
   it "has Strings as values" do
     Encoding.aliases.values.each do |value|
-      value.should be_an_instance_of(String)
+      value.should.instance_of?(String)
     end
   end
 
   it "has alias names as its keys" do
-    Encoding.aliases.key?('BINARY').should be_true
-    Encoding.aliases.key?('ASCII').should be_true
+    Encoding.aliases.key?('BINARY').should == true
+    Encoding.aliases.key?('ASCII').should == true
   end
 
   it "has the names of the aliased encoding as its values" do
diff --git a/spec/ruby/core/encoding/ascii_compatible_spec.rb b/spec/ruby/core/encoding/ascii_compatible_spec.rb
index 4804300e85..04fc159bb8 100644
--- a/spec/ruby/core/encoding/ascii_compatible_spec.rb
+++ b/spec/ruby/core/encoding/ascii_compatible_spec.rb
@@ -2,10 +2,21 @@ require_relative '../../spec_helper'
 
 describe "Encoding#ascii_compatible?" do
   it "returns true if self represents an ASCII-compatible encoding" do
-    Encoding::UTF_8.ascii_compatible?.should be_true
+    Encoding::UTF_8.ascii_compatible?.should == true
   end
 
   it "returns false if self does not represent an ASCII-compatible encoding" do
-    Encoding::UTF_16LE.ascii_compatible?.should be_false
+    Encoding::UTF_16LE.ascii_compatible?.should == false
+  end
+
+  it "returns false for UTF_16 and UTF_32" do
+    Encoding::UTF_16.should_not.ascii_compatible?
+    Encoding::UTF_32.should_not.ascii_compatible?
+  end
+
+  it "is always false for dummy encodings" do
+    Encoding.list.select(&:dummy?).each do |encoding|
+      encoding.should_not.ascii_compatible?
+    end
   end
 end
diff --git a/spec/ruby/core/encoding/compatible_spec.rb b/spec/ruby/core/encoding/compatible_spec.rb
index 61a651893b..0d620e5bf3 100644
--- a/spec/ruby/core/encoding/compatible_spec.rb
+++ b/spec/ruby/core/encoding/compatible_spec.rb
@@ -1,4 +1,4 @@
-# -*- encoding: binary -*-
+# encoding: binary
 
 require_relative '../../spec_helper'
 
@@ -55,7 +55,7 @@ describe "Encoding.compatible? String, String" do
     it "returns nil if the second's Encoding is not ASCII compatible" do
       a = "abc".dup.force_encoding("UTF-8")
       b = "1234".dup.force_encoding("UTF-16LE")
-      Encoding.compatible?(a, b).should be_nil
+      Encoding.compatible?(a, b).should == nil
     end
   end
 
@@ -69,7 +69,7 @@ describe "Encoding.compatible? String, String" do
     end
 
     it "returns nil if the second encoding is ASCII compatible but neither String's encoding is ASCII only" do
-      Encoding.compatible?("\xff", "\u3042".encode("utf-8")).should be_nil
+      Encoding.compatible?("\xff", "\u3042".encode("utf-8")).should == nil
     end
   end
 
@@ -79,15 +79,15 @@ describe "Encoding.compatible? String, String" do
     end
 
     it "returns nil when the second String is US-ASCII" do
-      Encoding.compatible?(@str, "def".encode("us-ascii")).should be_nil
+      Encoding.compatible?(@str, "def".encode("us-ascii")).should == nil
     end
 
     it "returns nil when the second String is BINARY and ASCII only" do
-      Encoding.compatible?(@str, "\x7f").should be_nil
+      Encoding.compatible?(@str, "\x7f").should == nil
     end
 
     it "returns nil when the second String is BINARY but not ASCII only" do
-      Encoding.compatible?(@str, "\xff").should be_nil
+      Encoding.compatible?(@str, "\xff").should == nil
     end
 
     it "returns the Encoding when the second's Encoding is not ASCII compatible but the same as the first's Encoding" do
@@ -110,15 +110,15 @@ describe "Encoding.compatible? String, String" do
     end
 
     it "returns nil when the second's Encoding is BINARY but not ASCII only" do
-      Encoding.compatible?(@str, "\xff").should be_nil
+      Encoding.compatible?(@str, "\xff").should == nil
     end
 
     it "returns nil when the second's Encoding is invalid and ASCII only" do
-      Encoding.compatible?(@str, "\x7f\x7f".dup.force_encoding("utf-16be")).should be_nil
+      Encoding.compatible?(@str, "\x7f\x7f".dup.force_encoding("utf-16be")).should == nil
     end
 
     it "returns nil when the second's Encoding is invalid and not ASCII only" do
-      Encoding.compatible?(@str, "\xff\xff".dup.force_encoding("utf-16be")).should be_nil
+      Encoding.compatible?(@str, "\xff\xff".dup.force_encoding("utf-16be")).should == nil
     end
 
     it "returns the Encoding when the second's Encoding is invalid but the same as the first" do
@@ -171,7 +171,7 @@ describe "Encoding.compatible? String, String" do
 #     Use the following script to regenerate the matrix:
 #
 #     ```
-#       # -*- encoding: binary -*-
+#       # encoding: binary
 #
 #       ENCODINGS = [
 #         "US-ASCII",
@@ -557,6 +557,11 @@ describe "Encoding.compatible? String, Regexp" do
       [Encoding, "\x82\xa0".dup.force_encoding("shift_jis"),  Encoding::Shift_JIS],
     ].should be_computed_by(:compatible?, /abc/)
   end
+
+  it "returns the Regexp's Encoding if the String is ASCII only and the Regexp is not" do
+    r = Regexp.new("\xa4\xa2".dup.force_encoding("euc-jp"))
+    Encoding.compatible?("hello".dup.force_encoding("utf-8"), r).should == Encoding::EUC_JP
+  end
 end
 
 describe "Encoding.compatible? String, Symbol" do
@@ -584,11 +589,11 @@ end
 
 describe "Encoding.compatible? String, Encoding" do
   it "returns nil if the String's encoding is not ASCII compatible" do
-    Encoding.compatible?("abc".encode("utf-32le"), Encoding::US_ASCII).should be_nil
+    Encoding.compatible?("abc".encode("utf-32le"), Encoding::US_ASCII).should == nil
   end
 
   it "returns nil if the Encoding is not ASCII compatible" do
-    Encoding.compatible?("abc".encode("us-ascii"), Encoding::UTF_32LE).should be_nil
+    Encoding.compatible?("abc".encode("us-ascii"), Encoding::UTF_32LE).should == nil
   end
 
   it "returns the String's encoding if the Encoding is US-ASCII" do
@@ -609,7 +614,7 @@ describe "Encoding.compatible? String, Encoding" do
   end
 
   it "returns nil if the String's encoding is ASCII compatible but the string is not ASCII only" do
-    Encoding.compatible?("\u3042".encode("utf-8"), Encoding::BINARY).should be_nil
+    Encoding.compatible?("\u3042".encode("utf-8"), Encoding::BINARY).should == nil
   end
 end
 
@@ -619,6 +624,15 @@ describe "Encoding.compatible? Regexp, String" do
     Encoding.compatible?(/abc/, str).should == Encoding::US_ASCII
   end
 
+  it "returns the String's Encoding when the String is ASCII only with a different encoding" do
+    r = Regexp.new("\xa4\xa2".dup.force_encoding("euc-jp"))
+    Encoding.compatible?(r, "hello".dup.force_encoding("utf-8")).should == Encoding::UTF_8
+  end
+
+  it "returns the Regexp's Encoding if the String has the same non-ASCII encoding" do
+    r = Regexp.new("\xa4\xa2".dup.force_encoding("euc-jp"))
+    Encoding.compatible?(r, "hello".dup.force_encoding("euc-jp")).should == Encoding::EUC_JP
+  end
 end
 
 describe "Encoding.compatible? Regexp, Regexp" do
@@ -727,32 +741,32 @@ end
 
 describe "Encoding.compatible? Object, Object" do
   it "returns nil for Object, String" do
-    Encoding.compatible?(Object.new, "abc").should be_nil
+    Encoding.compatible?(Object.new, "abc").should == nil
   end
 
   it "returns nil for Object, Regexp" do
-    Encoding.compatible?(Object.new, /./).should be_nil
+    Encoding.compatible?(Object.new, /./).should == nil
   end
 
   it "returns nil for Object, Symbol" do
-    Encoding.compatible?(Object.new, :sym).should be_nil
+    Encoding.compatible?(Object.new, :sym).should == nil
   end
 
   it "returns nil for String, Object" do
-    Encoding.compatible?("abc", Object.new).should be_nil
+    Encoding.compatible?("abc", Object.new).should == nil
   end
 
   it "returns nil for Regexp, Object" do
-    Encoding.compatible?(/./, Object.new).should be_nil
+    Encoding.compatible?(/./, Object.new).should == nil
   end
 
   it "returns nil for Symbol, Object" do
-    Encoding.compatible?(:sym, Object.new).should be_nil
+    Encoding.compatible?(:sym, Object.new).should == nil
   end
 end
 
 describe "Encoding.compatible? nil, nil" do
   it "returns nil" do
-    Encoding.compatible?(nil, nil).should be_nil
+    Encoding.compatible?(nil, nil).should == nil
   end
 end
diff --git a/spec/ruby/core/encoding/converter/asciicompat_encoding_spec.rb b/spec/ruby/core/encoding/converter/asciicompat_encoding_spec.rb
index 1beb40af3f..07c7a88356 100644
--- a/spec/ruby/core/encoding/converter/asciicompat_encoding_spec.rb
+++ b/spec/ruby/core/encoding/converter/asciicompat_encoding_spec.rb
@@ -24,14 +24,14 @@ describe "Encoding::Converter.asciicompat_encoding" do
   end
 
   it "returns nil when the given encoding is ASCII compatible" do
-    Encoding::Converter.asciicompat_encoding('ASCII').should be_nil
-    Encoding::Converter.asciicompat_encoding('UTF-8').should be_nil
+    Encoding::Converter.asciicompat_encoding('ASCII').should == nil
+    Encoding::Converter.asciicompat_encoding('UTF-8').should == nil
   end
 
   it "handles encoding names who resolve to nil encodings" do
     internal = Encoding.default_internal
     Encoding.default_internal = nil
-    Encoding::Converter.asciicompat_encoding('internal').should be_nil
+    Encoding::Converter.asciicompat_encoding('internal').should == nil
     Encoding.default_internal = internal
   end
 end
diff --git a/spec/ruby/core/encoding/converter/constants_spec.rb b/spec/ruby/core/encoding/converter/constants_spec.rb
index 7d29bdb278..e2d21b5429 100644
--- a/spec/ruby/core/encoding/converter/constants_spec.rb
+++ b/spec/ruby/core/encoding/converter/constants_spec.rb
@@ -2,130 +2,130 @@ require_relative '../../../spec_helper'
 
 describe "Encoding::Converter::INVALID_MASK" do
   it "exists" do
-    Encoding::Converter.should have_constant(:INVALID_MASK)
+    Encoding::Converter.should.const_defined?(:INVALID_MASK, false)
   end
 
   it "has an Integer value" do
-    Encoding::Converter::INVALID_MASK.should be_an_instance_of(Integer)
+    Encoding::Converter::INVALID_MASK.should.instance_of?(Integer)
   end
 end
 
 describe "Encoding::Converter::INVALID_REPLACE" do
   it "exists" do
-    Encoding::Converter.should have_constant(:INVALID_REPLACE)
+    Encoding::Converter.should.const_defined?(:INVALID_REPLACE, false)
   end
 
   it "has an Integer value" do
-    Encoding::Converter::INVALID_REPLACE.should be_an_instance_of(Integer)
+    Encoding::Converter::INVALID_REPLACE.should.instance_of?(Integer)
   end
 end
 
 describe "Encoding::Converter::UNDEF_MASK" do
   it "exists" do
-    Encoding::Converter.should have_constant(:UNDEF_MASK)
+    Encoding::Converter.should.const_defined?(:UNDEF_MASK, false)
   end
 
   it "has an Integer value" do
-    Encoding::Converter::UNDEF_MASK.should be_an_instance_of(Integer)
+    Encoding::Converter::UNDEF_MASK.should.instance_of?(Integer)
   end
 end
 
 describe "Encoding::Converter::UNDEF_REPLACE" do
   it "exists" do
-    Encoding::Converter.should have_constant(:UNDEF_REPLACE)
+    Encoding::Converter.should.const_defined?(:UNDEF_REPLACE, false)
   end
 
   it "has an Integer value" do
-    Encoding::Converter::UNDEF_REPLACE.should be_an_instance_of(Integer)
+    Encoding::Converter::UNDEF_REPLACE.should.instance_of?(Integer)
   end
 end
 
 describe "Encoding::Converter::UNDEF_HEX_CHARREF" do
   it "exists" do
-    Encoding::Converter.should have_constant(:UNDEF_HEX_CHARREF)
+    Encoding::Converter.should.const_defined?(:UNDEF_HEX_CHARREF, false)
   end
 
   it "has an Integer value" do
-    Encoding::Converter::UNDEF_HEX_CHARREF.should be_an_instance_of(Integer)
+    Encoding::Converter::UNDEF_HEX_CHARREF.should.instance_of?(Integer)
   end
 end
 
 describe "Encoding::Converter::PARTIAL_INPUT" do
   it "exists" do
-    Encoding::Converter.should have_constant(:PARTIAL_INPUT)
+    Encoding::Converter.should.const_defined?(:PARTIAL_INPUT, false)
   end
 
   it "has an Integer value" do
-    Encoding::Converter::PARTIAL_INPUT.should be_an_instance_of(Integer)
+    Encoding::Converter::PARTIAL_INPUT.should.instance_of?(Integer)
   end
 end
 
 describe "Encoding::Converter::AFTER_OUTPUT" do
   it "exists" do
-    Encoding::Converter.should have_constant(:AFTER_OUTPUT)
+    Encoding::Converter.should.const_defined?(:AFTER_OUTPUT, false)
   end
 
   it "has an Integer value" do
-    Encoding::Converter::AFTER_OUTPUT.should be_an_instance_of(Integer)
+    Encoding::Converter::AFTER_OUTPUT.should.instance_of?(Integer)
   end
 end
 
 describe "Encoding::Converter::UNIVERSAL_NEWLINE_DECORATOR" do
   it "exists" do
-    Encoding::Converter.should have_constant(:UNIVERSAL_NEWLINE_DECORATOR)
+    Encoding::Converter.should.const_defined?(:UNIVERSAL_NEWLINE_DECORATOR, false)
   end
 
   it "has an Integer value" do
-    Encoding::Converter::UNIVERSAL_NEWLINE_DECORATOR.should be_an_instance_of(Integer)
+    Encoding::Converter::UNIVERSAL_NEWLINE_DECORATOR.should.instance_of?(Integer)
   end
 end
 
 describe "Encoding::Converter::CRLF_NEWLINE_DECORATOR" do
   it "exists" do
-    Encoding::Converter.should have_constant(:CRLF_NEWLINE_DECORATOR)
+    Encoding::Converter.should.const_defined?(:CRLF_NEWLINE_DECORATOR, false)
   end
 
   it "has an Integer value" do
-    Encoding::Converter::CRLF_NEWLINE_DECORATOR.should be_an_instance_of(Integer)
+    Encoding::Converter::CRLF_NEWLINE_DECORATOR.should.instance_of?(Integer)
   end
 end
 
 describe "Encoding::Converter::CR_NEWLINE_DECORATOR" do
   it "exists" do
-    Encoding::Converter.should have_constant(:CR_NEWLINE_DECORATOR)
+    Encoding::Converter.should.const_defined?(:CR_NEWLINE_DECORATOR, false)
   end
 
   it "has an Integer value" do
-    Encoding::Converter::CR_NEWLINE_DECORATOR.should be_an_instance_of(Integer)
+    Encoding::Converter::CR_NEWLINE_DECORATOR.should.instance_of?(Integer)
   end
 end
 
 describe "Encoding::Converter::XML_TEXT_DECORATOR" do
   it "exists" do
-    Encoding::Converter.should have_constant(:XML_TEXT_DECORATOR)
+    Encoding::Converter.should.const_defined?(:XML_TEXT_DECORATOR, false)
   end
 
   it "has an Integer value" do
-    Encoding::Converter::XML_TEXT_DECORATOR.should be_an_instance_of(Integer)
+    Encoding::Converter::XML_TEXT_DECORATOR.should.instance_of?(Integer)
   end
 end
 
 describe "Encoding::Converter::XML_ATTR_CONTENT_DECORATOR" do
   it "exists" do
-    Encoding::Converter.should have_constant(:XML_ATTR_CONTENT_DECORATOR)
+    Encoding::Converter.should.const_defined?(:XML_ATTR_CONTENT_DECORATOR, false)
   end
 
   it "has an Integer value" do
-    Encoding::Converter::XML_ATTR_CONTENT_DECORATOR.should be_an_instance_of(Integer)
+    Encoding::Converter::XML_ATTR_CONTENT_DECORATOR.should.instance_of?(Integer)
   end
 end
 
 describe "Encoding::Converter::XML_ATTR_QUOTE_DECORATOR" do
   it "exists" do
-    Encoding::Converter.should have_constant(:XML_ATTR_QUOTE_DECORATOR)
+    Encoding::Converter.should.const_defined?(:XML_ATTR_QUOTE_DECORATOR, false)
   end
 
   it "has an Integer value" do
-    Encoding::Converter::XML_ATTR_QUOTE_DECORATOR.should be_an_instance_of(Integer)
+    Encoding::Converter::XML_ATTR_QUOTE_DECORATOR.should.instance_of?(Integer)
   end
 end
diff --git a/spec/ruby/core/encoding/converter/convert_spec.rb b/spec/ruby/core/encoding/converter/convert_spec.rb
index 7f249d90a3..c95e88a491 100644
--- a/spec/ruby/core/encoding/converter/convert_spec.rb
+++ b/spec/ruby/core/encoding/converter/convert_spec.rb
@@ -1,11 +1,11 @@
-# -*- encoding: binary -*-
+# encoding: binary
 # frozen_string_literal: true
 require_relative '../../../spec_helper'
 
 describe "Encoding::Converter#convert" do
   it "returns a String" do
     ec = Encoding::Converter.new('ascii', 'utf-8')
-    ec.convert('glark').should be_an_instance_of(String)
+    ec.convert('glark').should.instance_of?(String)
   end
 
   it "sets the encoding of the result to the target encoding" do
@@ -34,13 +34,12 @@ describe "Encoding::Converter#convert" do
 
   it "raises UndefinedConversionError if the String contains characters invalid for the target encoding" do
     ec = Encoding::Converter.new('UTF-8', Encoding.find('macCyrillic'))
-    -> { ec.convert("\u{6543}".dup.force_encoding('UTF-8')) }.should \
-      raise_error(Encoding::UndefinedConversionError)
+    -> { ec.convert("\u{6543}".dup.force_encoding('UTF-8')) }.should.raise(Encoding::UndefinedConversionError)
   end
 
   it "raises an ArgumentError if called on a finished stream" do
     ec = Encoding::Converter.new('UTF-8', Encoding.find('macCyrillic'))
     ec.finish
-    -> { ec.convert("\u{65}") }.should raise_error(ArgumentError)
+    -> { ec.convert("\u{65}") }.should.raise(ArgumentError)
   end
 end
diff --git a/spec/ruby/core/encoding/converter/finish_spec.rb b/spec/ruby/core/encoding/converter/finish_spec.rb
index 239243430b..e13b7415f8 100644
--- a/spec/ruby/core/encoding/converter/finish_spec.rb
+++ b/spec/ruby/core/encoding/converter/finish_spec.rb
@@ -7,7 +7,7 @@ describe "Encoding::Converter#finish" do
 
   it "returns a String" do
     @ec.convert('foo')
-    @ec.finish.should be_an_instance_of(String)
+    @ec.finish.should.instance_of?(String)
   end
 
   it "returns an empty String if there is nothing more to convert" do
@@ -16,8 +16,8 @@ describe "Encoding::Converter#finish" do
   end
 
   it "returns the last part of the converted String if it hasn't already" do
-     @ec.convert("\u{9999}").should == "\e$B9a".dup.force_encoding('iso-2022-jp')
-     @ec.finish.should == "\e(B".dup.force_encoding('iso-2022-jp')
+    @ec.convert("\u{9999}").should == "\e$B9a".dup.force_encoding('iso-2022-jp')
+    @ec.finish.should == "\e(B".dup.force_encoding('iso-2022-jp')
   end
 
   it "returns a String in the destination encoding" do
diff --git a/spec/ruby/core/encoding/converter/last_error_spec.rb b/spec/ruby/core/encoding/converter/last_error_spec.rb
index 78779be70b..3984a628f5 100644
--- a/spec/ruby/core/encoding/converter/last_error_spec.rb
+++ b/spec/ruby/core/encoding/converter/last_error_spec.rb
@@ -1,54 +1,54 @@
-# -*- encoding: binary -*-
+# encoding: binary
 require_relative '../../../spec_helper'
 
 describe "Encoding::Converter#last_error" do
   it "returns nil when the no conversion has been attempted" do
     ec = Encoding::Converter.new('ascii','utf-8')
-    ec.last_error.should be_nil
+    ec.last_error.should == nil
   end
 
   it "returns nil when the last conversion did not produce an error" do
     ec = Encoding::Converter.new('ascii','utf-8')
     ec.convert('a'.dup.force_encoding('ascii'))
-    ec.last_error.should be_nil
+    ec.last_error.should == nil
   end
 
   it "returns nil when #primitive_convert last returned :destination_buffer_full" do
     ec = Encoding::Converter.new("utf-8", "iso-2022-jp")
     ec.primitive_convert(+"\u{9999}", +"", 0, 0, partial_input: false) \
       .should == :destination_buffer_full
-    ec.last_error.should be_nil
+    ec.last_error.should == nil
   end
 
   it "returns nil when #primitive_convert last returned :finished" do
     ec = Encoding::Converter.new("utf-8", "iso-8859-1")
     ec.primitive_convert("glark".dup.force_encoding('utf-8'), +"").should == :finished
-    ec.last_error.should be_nil
+    ec.last_error.should == nil
   end
 
   it "returns nil if the last conversion succeeded but the penultimate failed" do
     ec = Encoding::Converter.new("utf-8", "iso-8859-1")
     ec.primitive_convert(+"\xf1abcd", +"").should == :invalid_byte_sequence
     ec.primitive_convert("glark".dup.force_encoding('utf-8'), +"").should == :finished
-    ec.last_error.should be_nil
+    ec.last_error.should == nil
   end
 
   it "returns an Encoding::InvalidByteSequenceError when #primitive_convert last returned :invalid_byte_sequence" do
     ec = Encoding::Converter.new("utf-8", "iso-8859-1")
     ec.primitive_convert(+"\xf1abcd", +"").should == :invalid_byte_sequence
-    ec.last_error.should be_an_instance_of(Encoding::InvalidByteSequenceError)
+    ec.last_error.should.instance_of?(Encoding::InvalidByteSequenceError)
   end
 
   it "returns an Encoding::UndefinedConversionError when #primitive_convert last returned :undefined_conversion" do
     ec = Encoding::Converter.new("utf-8", "iso-8859-1")
     ec.primitive_convert(+"\u{9876}", +"").should == :undefined_conversion
-    ec.last_error.should be_an_instance_of(Encoding::UndefinedConversionError)
+    ec.last_error.should.instance_of?(Encoding::UndefinedConversionError)
   end
 
   it "returns an Encoding::InvalidByteSequenceError when #primitive_convert last returned :incomplete_input" do
     ec = Encoding::Converter.new("EUC-JP", "ISO-8859-1")
     ec.primitive_convert(+"\xa4", +"", nil, 10).should == :incomplete_input
-    ec.last_error.should be_an_instance_of(Encoding::InvalidByteSequenceError)
+    ec.last_error.should.instance_of?(Encoding::InvalidByteSequenceError)
   end
 
   it "returns an Encoding::InvalidByteSequenceError when the last call to #convert produced one" do
@@ -56,10 +56,10 @@ describe "Encoding::Converter#last_error" do
     exception = nil
     -> {
       ec.convert("\xf1abcd")
-    }.should raise_error(Encoding::InvalidByteSequenceError) { |e|
+    }.should.raise(Encoding::InvalidByteSequenceError) { |e|
       exception = e
     }
-    ec.last_error.should be_an_instance_of(Encoding::InvalidByteSequenceError)
+    ec.last_error.should.instance_of?(Encoding::InvalidByteSequenceError)
     ec.last_error.message.should == exception.message
   end
 
@@ -68,12 +68,12 @@ describe "Encoding::Converter#last_error" do
     exception = nil
     -> {
       ec.convert("\u{9899}")
-    }.should raise_error(Encoding::UndefinedConversionError) { |e|
+    }.should.raise(Encoding::UndefinedConversionError) { |e|
       exception = e
     }
-    ec.last_error.should be_an_instance_of(Encoding::UndefinedConversionError)
+    ec.last_error.should.instance_of?(Encoding::UndefinedConversionError)
     ec.last_error.message.should == exception.message
-    ec.last_error.message.should include "from UTF-8 to ISO-8859-1"
+    ec.last_error.message.should.include? "from UTF-8 to ISO-8859-1"
   end
 
   it "returns the last error of #convert with a message showing the transcoding path" do
@@ -81,11 +81,11 @@ describe "Encoding::Converter#last_error" do
     exception = nil
     -> {
       ec.convert("\xE9") # é in ISO-8859-1
-    }.should raise_error(Encoding::UndefinedConversionError) { |e|
+    }.should.raise(Encoding::UndefinedConversionError) { |e|
       exception = e
     }
-    ec.last_error.should be_an_instance_of(Encoding::UndefinedConversionError)
+    ec.last_error.should.instance_of?(Encoding::UndefinedConversionError)
     ec.last_error.message.should == exception.message
-    ec.last_error.message.should include "from ISO-8859-1 to UTF-8 to Big5"
+    ec.last_error.message.should.include? "from ISO-8859-1 to UTF-8 to Big5"
   end
 end
diff --git a/spec/ruby/core/encoding/converter/new_spec.rb b/spec/ruby/core/encoding/converter/new_spec.rb
index db9c3364d7..bbdfb48bce 100644
--- a/spec/ruby/core/encoding/converter/new_spec.rb
+++ b/spec/ruby/core/encoding/converter/new_spec.rb
@@ -1,4 +1,4 @@
-# -*- encoding: binary -*-
+# encoding: binary
 require_relative '../../../spec_helper'
 
 describe "Encoding::Converter.new" do
@@ -25,7 +25,7 @@ describe "Encoding::Converter.new" do
   it "raises an Encoding::ConverterNotFoundError if both encodings are the same" do
     -> do
       Encoding::Converter.new "utf-8", "utf-8"
-    end.should raise_error(Encoding::ConverterNotFoundError)
+    end.should.raise(Encoding::ConverterNotFoundError)
   end
 
   it "calls #to_str to convert the source encoding argument to an encoding name" do
@@ -67,25 +67,25 @@ describe "Encoding::Converter.new" do
 
     -> do
       Encoding::Converter.new("us-ascii", "utf-8", replace: obj)
-    end.should raise_error(TypeError)
+    end.should.raise(TypeError)
   end
 
   it "raises a TypeError if passed true for the replacement object" do
     -> do
       Encoding::Converter.new("us-ascii", "utf-8", replace: true)
-    end.should raise_error(TypeError)
+    end.should.raise(TypeError)
   end
 
   it "raises a TypeError if passed false for the replacement object" do
     -> do
       Encoding::Converter.new("us-ascii", "utf-8", replace: false)
-    end.should raise_error(TypeError)
+    end.should.raise(TypeError)
   end
 
   it "raises a TypeError if passed an Integer for the replacement object" do
     -> do
       Encoding::Converter.new("us-ascii", "utf-8", replace: 1)
-    end.should raise_error(TypeError)
+    end.should.raise(TypeError)
   end
 
   it "accepts an empty String for the replacement object" do
diff --git a/spec/ruby/core/encoding/converter/primitive_convert_spec.rb b/spec/ruby/core/encoding/converter/primitive_convert_spec.rb
index 63f25eddef..ab9ce6a992 100644
--- a/spec/ruby/core/encoding/converter/primitive_convert_spec.rb
+++ b/spec/ruby/core/encoding/converter/primitive_convert_spec.rb
@@ -1,4 +1,4 @@
-# -*- encoding: binary -*-
+# encoding: binary
 # frozen_string_literal: false
 require_relative '../../../spec_helper'
 
@@ -8,23 +8,23 @@ describe "Encoding::Converter#primitive_convert" do
   end
 
   it "accepts a nil source buffer" do
-    -> { @ec.primitive_convert(nil,"") }.should_not raise_error
+    -> { @ec.primitive_convert(nil,"") }.should_not.raise
   end
 
   it "accepts a String as the source buffer" do
-    -> { @ec.primitive_convert("","") }.should_not raise_error
+    -> { @ec.primitive_convert("","") }.should_not.raise
   end
 
   it "raises FrozenError when the destination buffer is a frozen String" do
-    -> { @ec.primitive_convert("", "".freeze) }.should raise_error(FrozenError)
+    -> { @ec.primitive_convert("", "".freeze) }.should.raise(FrozenError)
   end
 
   it "accepts nil for the destination byte offset" do
-    -> { @ec.primitive_convert("","", nil) }.should_not raise_error
+    -> { @ec.primitive_convert("","", nil) }.should_not.raise
   end
 
   it "accepts an integer for the destination byte offset" do
-    -> { @ec.primitive_convert("","a", 1) }.should_not raise_error
+    -> { @ec.primitive_convert("","a", 1) }.should_not.raise
   end
 
   it "calls #to_int to convert the destination byte offset" do
@@ -35,10 +35,10 @@ describe "Encoding::Converter#primitive_convert" do
   end
 
   it "raises an ArgumentError if the destination byte offset is greater than the bytesize of the destination buffer" do
-    -> { @ec.primitive_convert("","am", 0) }.should_not raise_error
-    -> { @ec.primitive_convert("","am", 1) }.should_not raise_error
-    -> { @ec.primitive_convert("","am", 2) }.should_not raise_error
-    -> { @ec.primitive_convert("","am", 3) }.should raise_error(ArgumentError)
+    -> { @ec.primitive_convert("","am", 0) }.should_not.raise
+    -> { @ec.primitive_convert("","am", 1) }.should_not.raise
+    -> { @ec.primitive_convert("","am", 2) }.should_not.raise
+    -> { @ec.primitive_convert("","am", 3) }.should.raise(ArgumentError)
   end
 
   it "uses the destination byte offset to determine where to write the result in the destination buffer" do
@@ -54,19 +54,19 @@ describe "Encoding::Converter#primitive_convert" do
   end
 
   it "accepts nil for the destination bytesize" do
-    -> { @ec.primitive_convert("","", nil, nil) }.should_not raise_error
+    -> { @ec.primitive_convert("","", nil, nil) }.should_not.raise
   end
 
   it "accepts an integer for the destination bytesize" do
-    -> { @ec.primitive_convert("","", nil, 0) }.should_not raise_error
+    -> { @ec.primitive_convert("","", nil, 0) }.should_not.raise
   end
 
   it "allows a destination bytesize value greater than the bytesize of the source buffer" do
-    -> { @ec.primitive_convert("am","", nil, 3) }.should_not raise_error
+    -> { @ec.primitive_convert("am","", nil, 3) }.should_not.raise
   end
 
   it "allows a destination bytesize value less than the bytesize of the source buffer" do
-    -> { @ec.primitive_convert("am","", nil, 1) }.should_not raise_error
+    -> { @ec.primitive_convert("am","", nil, 1) }.should_not.raise
   end
 
   it "calls #to_int to convert the destination byte size" do
diff --git a/spec/ruby/core/encoding/converter/primitive_errinfo_spec.rb b/spec/ruby/core/encoding/converter/primitive_errinfo_spec.rb
index 668eb9a924..580e2e37e1 100644
--- a/spec/ruby/core/encoding/converter/primitive_errinfo_spec.rb
+++ b/spec/ruby/core/encoding/converter/primitive_errinfo_spec.rb
@@ -1,4 +1,4 @@
-# -*- encoding: binary -*-
+# encoding: binary
 # frozen_string_literal: false
 require_relative '../../../spec_helper'
 
@@ -55,7 +55,7 @@ describe "Encoding::Converter#primitive_errinfo" do
 
   it "returns the state, source encoding, target encoding, erroneous bytes, and the read-again bytes when #convert last raised InvalidByteSequenceError" do
     ec = Encoding::Converter.new("utf-8", "iso-8859-1")
-    -> { ec.convert("\xf1abcd") }.should raise_error(Encoding::InvalidByteSequenceError)
+    -> { ec.convert("\xf1abcd") }.should.raise(Encoding::InvalidByteSequenceError)
     ec.primitive_errinfo.should ==
       [:invalid_byte_sequence, "UTF-8", "ISO-8859-1", "\xF1", "a"]
   end
@@ -63,7 +63,7 @@ describe "Encoding::Converter#primitive_errinfo" do
   it "returns the state, source encoding, target encoding, erroneous bytes, and the read-again bytes when #finish last raised InvalidByteSequenceError" do
     ec = Encoding::Converter.new("EUC-JP", "ISO-8859-1")
     ec.convert("\xa4")
-    -> { ec.finish }.should raise_error(Encoding::InvalidByteSequenceError)
+    -> { ec.finish }.should.raise(Encoding::InvalidByteSequenceError)
     ec.primitive_errinfo.should == [:incomplete_input, "EUC-JP", "UTF-8", "\xA4", ""]
   end
 end
diff --git a/spec/ruby/core/encoding/converter/putback_spec.rb b/spec/ruby/core/encoding/converter/putback_spec.rb
index e19fe6c314..a85cec5145 100644
--- a/spec/ruby/core/encoding/converter/putback_spec.rb
+++ b/spec/ruby/core/encoding/converter/putback_spec.rb
@@ -1,4 +1,4 @@
-# -*- encoding: binary -*-
+# encoding: binary
 require_relative '../../../spec_helper'
 
 describe "Encoding::Converter#putback" do
@@ -8,7 +8,7 @@ describe "Encoding::Converter#putback" do
   end
 
   it "returns a String" do
-    @ec.putback.should be_an_instance_of(String)
+    @ec.putback.should.instance_of?(String)
   end
 
   it "returns a String in the source encoding" do
diff --git a/spec/ruby/core/encoding/converter/replacement_spec.rb b/spec/ruby/core/encoding/converter/replacement_spec.rb
index ea514ca8dd..c25ec36517 100644
--- a/spec/ruby/core/encoding/converter/replacement_spec.rb
+++ b/spec/ruby/core/encoding/converter/replacement_spec.rb
@@ -33,7 +33,7 @@ describe "Encoding::Converter#replacement=" do
 
   it "raises a TypeError if assigned a non-String argument" do
     ec = Encoding::Converter.new("utf-8", "us-ascii")
-    -> { ec.replacement = nil }.should raise_error(TypeError)
+    -> { ec.replacement = nil }.should.raise(TypeError)
   end
 
   it "sets #replacement" do
@@ -47,16 +47,14 @@ describe "Encoding::Converter#replacement=" do
     ec = Encoding::Converter.new("sjis", "ascii")
     utf8_q = "\u{986}".dup.force_encoding('utf-8')
     ec.primitive_convert(utf8_q.dup, +"").should == :undefined_conversion
-    -> { ec.replacement = utf8_q }.should \
-      raise_error(Encoding::UndefinedConversionError)
+    -> { ec.replacement = utf8_q }.should.raise(Encoding::UndefinedConversionError)
   end
 
   it "does not change the replacement character if the argument cannot be converted into the destination encoding" do
     ec = Encoding::Converter.new("sjis", "ascii")
     utf8_q = "\u{986}".dup.force_encoding('utf-8')
     ec.primitive_convert(utf8_q.dup, +"").should == :undefined_conversion
-    -> { ec.replacement = utf8_q }.should \
-      raise_error(Encoding::UndefinedConversionError)
+    -> { ec.replacement = utf8_q }.should.raise(Encoding::UndefinedConversionError)
     ec.replacement.should == "?".dup.force_encoding('us-ascii')
   end
 
diff --git a/spec/ruby/core/encoding/converter/search_convpath_spec.rb b/spec/ruby/core/encoding/converter/search_convpath_spec.rb
index 0882af5539..cac44765f8 100644
--- a/spec/ruby/core/encoding/converter/search_convpath_spec.rb
+++ b/spec/ruby/core/encoding/converter/search_convpath_spec.rb
@@ -23,8 +23,8 @@ describe "Encoding::Converter.search_convpath" do
   end
 
   it "raises an Encoding::ConverterNotFoundError if no conversion path exists" do
-   -> do
-     Encoding::Converter.search_convpath(Encoding::BINARY, Encoding::Emacs_Mule)
-   end.should raise_error(Encoding::ConverterNotFoundError)
+    -> do
+      Encoding::Converter.search_convpath(Encoding::BINARY, Encoding::Emacs_Mule)
+    end.should.raise(Encoding::ConverterNotFoundError)
   end
 end
diff --git a/spec/ruby/core/encoding/default_external_spec.rb b/spec/ruby/core/encoding/default_external_spec.rb
index 9aae4976e0..2a2bd7f6ae 100644
--- a/spec/ruby/core/encoding/default_external_spec.rb
+++ b/spec/ruby/core/encoding/default_external_spec.rb
@@ -10,7 +10,7 @@ describe "Encoding.default_external" do
   end
 
   it "returns an Encoding object" do
-    Encoding.default_external.should be_an_instance_of(Encoding)
+    Encoding.default_external.should.instance_of?(Encoding)
   end
 
   it "returns the default external encoding" do
@@ -60,10 +60,10 @@ describe "Encoding.default_external=" do
   end
 
   it "raises a TypeError unless the argument is an Encoding or convertible to a String" do
-    -> { Encoding.default_external = [] }.should raise_error(TypeError)
+    -> { Encoding.default_external = [] }.should.raise(TypeError)
   end
 
   it "raises an ArgumentError if the argument is nil" do
-    -> { Encoding.default_external = nil }.should raise_error(ArgumentError)
+    -> { Encoding.default_external = nil }.should.raise(ArgumentError)
   end
 end
diff --git a/spec/ruby/core/encoding/default_internal_spec.rb b/spec/ruby/core/encoding/default_internal_spec.rb
index 855f4e9f32..38aef9dce9 100644
--- a/spec/ruby/core/encoding/default_internal_spec.rb
+++ b/spec/ruby/core/encoding/default_internal_spec.rb
@@ -10,17 +10,17 @@ describe "Encoding.default_internal" do
   end
 
   it "is nil by default" do
-    Encoding.default_internal.should be_nil
+    Encoding.default_internal.should == nil
   end
 
   it "returns an Encoding object if a default internal encoding is set" do
     Encoding.default_internal = Encoding::ASCII
-    Encoding.default_internal.should be_an_instance_of(Encoding)
+    Encoding.default_internal.should.instance_of?(Encoding)
   end
 
   it "returns nil if no default internal encoding is set" do
     Encoding.default_internal = nil
-    Encoding.default_internal.should be_nil
+    Encoding.default_internal.should == nil
   end
 
   it "returns the default internal encoding" do
@@ -60,15 +60,15 @@ describe "Encoding.default_internal=" do
     obj = mock('string')
     obj.should_receive(:to_str).at_least(1).times.and_return(1)
 
-    -> { Encoding.default_internal = obj }.should raise_error(TypeError)
+    -> { Encoding.default_internal = obj }.should.raise(TypeError)
   end
 
   it "raises a TypeError when passed an object not providing #to_str" do
-    -> { Encoding.default_internal = mock("encoding") }.should raise_error(TypeError)
+    -> { Encoding.default_internal = mock("encoding") }.should.raise(TypeError)
   end
 
   it "accepts an argument of nil to unset the default internal encoding" do
     Encoding.default_internal = nil
-    Encoding.default_internal.should be_nil
+    Encoding.default_internal.should == nil
   end
 end
diff --git a/spec/ruby/core/encoding/dummy_spec.rb b/spec/ruby/core/encoding/dummy_spec.rb
index 75ffcd5a4e..05530a8186 100644
--- a/spec/ruby/core/encoding/dummy_spec.rb
+++ b/spec/ruby/core/encoding/dummy_spec.rb
@@ -2,13 +2,24 @@ require_relative '../../spec_helper'
 
 describe "Encoding#dummy?" do
   it "returns false for proper encodings" do
-    Encoding::UTF_8.dummy?.should be_false
-    Encoding::ASCII.dummy?.should be_false
+    Encoding::UTF_8.dummy?.should == false
+    Encoding::ASCII.dummy?.should == false
   end
 
   it "returns true for dummy encodings" do
-    Encoding::ISO_2022_JP.dummy?.should be_true
-    Encoding::CP50221.dummy?.should be_true
-    Encoding::UTF_7.dummy?.should be_true
+    Encoding::ISO_2022_JP.dummy?.should == true
+    Encoding::CP50221.dummy?.should == true
+    Encoding::UTF_7.dummy?.should == true
+  end
+
+  it "returns true for UTF_16 and UTF_32" do
+    Encoding::UTF_16.should.dummy?
+    Encoding::UTF_32.should.dummy?
+  end
+
+  it "implies not #ascii_compatible?" do
+    Encoding.list.select(&:dummy?).each do |encoding|
+      encoding.should_not.ascii_compatible?
+    end
   end
 end
diff --git a/spec/ruby/core/encoding/find_spec.rb b/spec/ruby/core/encoding/find_spec.rb
index 8a0873070f..c5356560eb 100644
--- a/spec/ruby/core/encoding/find_spec.rb
+++ b/spec/ruby/core/encoding/find_spec.rb
@@ -7,18 +7,18 @@ describe "Encoding.find" do
 
   it "returns the corresponding Encoding object if given a valid encoding name" do
     @encodings.each do |enc|
-      Encoding.find(enc).should be_an_instance_of(Encoding)
+      Encoding.find(enc).should.instance_of?(Encoding)
     end
   end
 
   it "returns the corresponding Encoding object if given a valid alias name" do
     Encoding.aliases.keys.each do |enc_alias|
-      Encoding.find(enc_alias).should be_an_instance_of(Encoding)
+      Encoding.find(enc_alias).should.instance_of?(Encoding)
     end
   end
 
   it "raises a TypeError if passed a Symbol" do
-    -> { Encoding.find(:"utf-8") }.should raise_error(TypeError)
+    -> { Encoding.find(:"utf-8") }.should.raise(TypeError)
   end
 
   it "returns the passed Encoding object" do
@@ -50,7 +50,7 @@ describe "Encoding.find" do
   end
 
   it "raises an ArgumentError if the given encoding does not exist" do
-    -> { Encoding.find('dh2dh278d') }.should raise_error(ArgumentError)
+    -> { Encoding.find('dh2dh278d') }.should.raise(ArgumentError, 'unknown encoding name - dh2dh278d')
   end
 
   # Not sure how to do a better test, since locale depends on weird platform-specific stuff
diff --git a/spec/ruby/core/encoding/fixtures/classes.rb b/spec/ruby/core/encoding/fixtures/classes.rb
index 12e9a4f348..943865e8d8 100644
--- a/spec/ruby/core/encoding/fixtures/classes.rb
+++ b/spec/ruby/core/encoding/fixtures/classes.rb
@@ -1,4 +1,4 @@
-# -*- encoding: binary -*-
+# encoding: binary
 module EncodingSpecs
   class UndefinedConversionError
     def self.exception
diff --git a/spec/ruby/core/encoding/inspect_spec.rb b/spec/ruby/core/encoding/inspect_spec.rb
index df96141db9..ab7f8cf9fc 100644
--- a/spec/ruby/core/encoding/inspect_spec.rb
+++ b/spec/ruby/core/encoding/inspect_spec.rb
@@ -2,7 +2,7 @@ require_relative '../../spec_helper'
 
 describe "Encoding#inspect" do
   it "returns a String" do
-    Encoding::UTF_8.inspect.should be_an_instance_of(String)
+    Encoding::UTF_8.inspect.should.instance_of?(String)
   end
 
   ruby_version_is ""..."3.4" do
diff --git a/spec/ruby/core/encoding/invalid_byte_sequence_error/destination_encoding_name_spec.rb b/spec/ruby/core/encoding/invalid_byte_sequence_error/destination_encoding_name_spec.rb
index 2b15fc1a0f..7d3cc77c0b 100644
--- a/spec/ruby/core/encoding/invalid_byte_sequence_error/destination_encoding_name_spec.rb
+++ b/spec/ruby/core/encoding/invalid_byte_sequence_error/destination_encoding_name_spec.rb
@@ -8,8 +8,8 @@ describe "Encoding::InvalidByteSequenceError#destination_encoding_name" do
   end
 
   it "returns a String" do
-    @exception.destination_encoding_name.should be_an_instance_of(String)
-    @exception2.destination_encoding_name.should be_an_instance_of(String)
+    @exception.destination_encoding_name.should.instance_of?(String)
+    @exception2.destination_encoding_name.should.instance_of?(String)
   end
 
   it "is equal to the destination encoding name of the object that raised it" do
diff --git a/spec/ruby/core/encoding/invalid_byte_sequence_error/destination_encoding_spec.rb b/spec/ruby/core/encoding/invalid_byte_sequence_error/destination_encoding_spec.rb
index c2ed6de1d8..264c409b1c 100644
--- a/spec/ruby/core/encoding/invalid_byte_sequence_error/destination_encoding_spec.rb
+++ b/spec/ruby/core/encoding/invalid_byte_sequence_error/destination_encoding_spec.rb
@@ -8,8 +8,8 @@ describe "Encoding::InvalidByteSequenceError#destination_encoding" do
   end
 
   it "returns an Encoding object" do
-    @exception.destination_encoding.should be_an_instance_of(Encoding)
-    @exception2.destination_encoding.should be_an_instance_of(Encoding)
+    @exception.destination_encoding.should.instance_of?(Encoding)
+    @exception2.destination_encoding.should.instance_of?(Encoding)
   end
 
   it "is equal to the destination encoding of the object that raised it" do
diff --git a/spec/ruby/core/encoding/invalid_byte_sequence_error/error_bytes_spec.rb b/spec/ruby/core/encoding/invalid_byte_sequence_error/error_bytes_spec.rb
index d2fc360dce..40a9a35caf 100644
--- a/spec/ruby/core/encoding/invalid_byte_sequence_error/error_bytes_spec.rb
+++ b/spec/ruby/core/encoding/invalid_byte_sequence_error/error_bytes_spec.rb
@@ -1,4 +1,4 @@
-# -*- encoding: binary -*-
+# encoding: binary
 require_relative "../../../spec_helper"
 require_relative '../fixtures/classes'
 
@@ -9,8 +9,8 @@ describe "Encoding::InvalidByteSequenceError#error_bytes" do
   end
 
   it "returns a String" do
-    @exception.error_bytes.should be_an_instance_of(String)
-    @exception2.error_bytes.should be_an_instance_of(String)
+    @exception.error_bytes.should.instance_of?(String)
+    @exception2.error_bytes.should.instance_of?(String)
   end
 
   it "returns the bytes that caused the exception" do
diff --git a/spec/ruby/core/encoding/invalid_byte_sequence_error/incomplete_input_spec.rb b/spec/ruby/core/encoding/invalid_byte_sequence_error/incomplete_input_spec.rb
index 8a3f3de69a..143db7b6da 100644
--- a/spec/ruby/core/encoding/invalid_byte_sequence_error/incomplete_input_spec.rb
+++ b/spec/ruby/core/encoding/invalid_byte_sequence_error/incomplete_input_spec.rb
@@ -1,9 +1,9 @@
-# -*- encoding: binary -*-
+# encoding: binary
 require_relative '../../../spec_helper'
 
 describe "Encoding::InvalidByteSequenceError#incomplete_input?" do
   it "returns nil by default" do
-    Encoding::InvalidByteSequenceError.new.incomplete_input?.should be_nil
+    Encoding::InvalidByteSequenceError.new.incomplete_input?.should == nil
   end
 
   it "returns true if #primitive_convert returned :incomplete_input for the same data" do
@@ -12,7 +12,7 @@ describe "Encoding::InvalidByteSequenceError#incomplete_input?" do
     begin
       ec.convert("\xA1")
     rescue Encoding::InvalidByteSequenceError => e
-      e.incomplete_input?.should be_true
+      e.incomplete_input?.should == true
     end
   end
 
@@ -22,7 +22,7 @@ describe "Encoding::InvalidByteSequenceError#incomplete_input?" do
     begin
       ec.convert("\xfffffffff")
     rescue Encoding::InvalidByteSequenceError => e
-      e.incomplete_input?.should be_false
+      e.incomplete_input?.should == false
     end
   end
 end
diff --git a/spec/ruby/core/encoding/invalid_byte_sequence_error/readagain_bytes_spec.rb b/spec/ruby/core/encoding/invalid_byte_sequence_error/readagain_bytes_spec.rb
index a5e2824984..e4fc81aac6 100644
--- a/spec/ruby/core/encoding/invalid_byte_sequence_error/readagain_bytes_spec.rb
+++ b/spec/ruby/core/encoding/invalid_byte_sequence_error/readagain_bytes_spec.rb
@@ -1,4 +1,4 @@
-# -*- encoding: binary -*-
+# encoding: binary
 require_relative "../../../spec_helper"
 require_relative '../fixtures/classes'
 
@@ -9,8 +9,8 @@ describe "Encoding::InvalidByteSequenceError#readagain_bytes" do
   end
 
   it "returns a String" do
-    @exception.readagain_bytes.should be_an_instance_of(String)
-    @exception2.readagain_bytes.should be_an_instance_of(String)
+    @exception.readagain_bytes.should.instance_of?(String)
+    @exception2.readagain_bytes.should.instance_of?(String)
   end
 
   it "returns the bytes to be read again" do
diff --git a/spec/ruby/core/encoding/invalid_byte_sequence_error/source_encoding_name_spec.rb b/spec/ruby/core/encoding/invalid_byte_sequence_error/source_encoding_name_spec.rb
index a9464114a8..b00e1ad4e8 100644
--- a/spec/ruby/core/encoding/invalid_byte_sequence_error/source_encoding_name_spec.rb
+++ b/spec/ruby/core/encoding/invalid_byte_sequence_error/source_encoding_name_spec.rb
@@ -8,7 +8,7 @@ describe "Encoding::UndefinedConversionError#source_encoding_name" do
   end
 
   it "returns a String" do
-    @exception.source_encoding_name.should be_an_instance_of(String)
+    @exception.source_encoding_name.should.instance_of?(String)
   end
 
   it "is equal to the source encoding name of the object that raised it" do
diff --git a/spec/ruby/core/encoding/invalid_byte_sequence_error/source_encoding_spec.rb b/spec/ruby/core/encoding/invalid_byte_sequence_error/source_encoding_spec.rb
index 7fdc0a122b..32ad25dbb5 100644
--- a/spec/ruby/core/encoding/invalid_byte_sequence_error/source_encoding_spec.rb
+++ b/spec/ruby/core/encoding/invalid_byte_sequence_error/source_encoding_spec.rb
@@ -8,8 +8,8 @@ describe "Encoding::InvalidByteSequenceError#source_encoding" do
   end
 
   it "returns an Encoding object" do
-    @exception.source_encoding.should be_an_instance_of(Encoding)
-    @exception2.source_encoding.should be_an_instance_of(Encoding)
+    @exception.source_encoding.should.instance_of?(Encoding)
+    @exception2.source_encoding.should.instance_of?(Encoding)
   end
 
   it "is equal to the source encoding of the object that raised it" do
diff --git a/spec/ruby/core/encoding/list_spec.rb b/spec/ruby/core/encoding/list_spec.rb
index bd3d5b7bc0..9fe336c608 100644
--- a/spec/ruby/core/encoding/list_spec.rb
+++ b/spec/ruby/core/encoding/list_spec.rb
@@ -2,12 +2,12 @@ require_relative '../../spec_helper'
 
 describe "Encoding.list" do
   it "returns an Array" do
-    Encoding.list.should be_an_instance_of(Array)
+    Encoding.list.should.instance_of?(Array)
   end
 
   it "returns an Array of Encoding objects" do
     Encoding.list.each do |enc|
-      enc.should be_an_instance_of(Encoding)
+      enc.should.instance_of?(Encoding)
     end
   end
 
@@ -17,18 +17,18 @@ describe "Encoding.list" do
   end
 
   it "includes the default external encoding" do
-    Encoding.list.include?(Encoding.default_external).should be_true
+    Encoding.list.include?(Encoding.default_external).should == true
   end
 
   it "does not include any alias names" do
     Encoding.aliases.keys.each do |enc_alias|
-      Encoding.list.include?(enc_alias).should be_false
+      Encoding.list.include?(enc_alias).should == false
     end
   end
 
   it "includes all aliased encodings" do
     Encoding.aliases.values.each do |enc_alias|
-      Encoding.list.include?(Encoding.find(enc_alias)).should be_true
+      Encoding.list.include?(Encoding.find(enc_alias)).should == true
     end
   end
 
diff --git a/spec/ruby/core/encoding/locale_charmap_spec.rb b/spec/ruby/core/encoding/locale_charmap_spec.rb
index 8143b9083a..0d77bf227b 100644
--- a/spec/ruby/core/encoding/locale_charmap_spec.rb
+++ b/spec/ruby/core/encoding/locale_charmap_spec.rb
@@ -2,55 +2,55 @@ require_relative '../../spec_helper'
 
 describe "Encoding.locale_charmap" do
   it "returns a String" do
-    Encoding.locale_charmap.should be_an_instance_of(String)
+    Encoding.locale_charmap.should.instance_of?(String)
   end
 
-  # FIXME: Get this working on Windows
-  platform_is :linux do
-    platform_is_not :android do
-      it "returns a value based on the LC_ALL environment variable" do
-        old_lc_all = ENV['LC_ALL']
-        ENV['LC_ALL'] = 'C'
-        ruby_exe("print Encoding.locale_charmap").should == 'ANSI_X3.4-1968'
-        ENV['LC_ALL'] = old_lc_all
+  describe "when setting LC_ALL=C" do
+    before :each do
+      @old_lc_all = ENV['LC_ALL']
+    end
+
+    after :each do
+      ENV['LC_ALL'] = @old_lc_all
+    end
+
+    # FIXME: Get this working on Windows
+    platform_is :linux do
+      platform_is_not :android do
+        it "returns a value based on the LC_ALL environment variable" do
+          ENV['LC_ALL'] = 'C'
+          ruby_exe("print Encoding.locale_charmap").should == 'ANSI_X3.4-1968'
+        end
       end
     end
-  end
 
-  platform_is :freebsd, :openbsd, :darwin do
-    it "returns a value based on the LC_ALL environment variable" do
-      old_lc_all = ENV['LC_ALL']
-      ENV['LC_ALL'] = 'C'
-      ruby_exe("print Encoding.locale_charmap").should == 'US-ASCII'
-      ENV['LC_ALL'] = old_lc_all
+    platform_is :freebsd, :openbsd, :darwin do
+      it "returns a value based on the LC_ALL environment variable" do
+        ENV['LC_ALL'] = 'C'
+        ruby_exe("print Encoding.locale_charmap").should == 'US-ASCII'
+      end
     end
-  end
 
-  platform_is :netbsd do
-    it "returns a value based on the LC_ALL environment variable" do
-      old_lc_all = ENV['LC_ALL']
-      ENV['LC_ALL'] = 'C'
-      ruby_exe("print Encoding.locale_charmap").should == '646'
-      ENV['LC_ALL'] = old_lc_all
+    platform_is :netbsd do
+      it "returns a value based on the LC_ALL environment variable" do
+        ENV['LC_ALL'] = 'C'
+        ruby_exe("print Encoding.locale_charmap").should == '646'
+      end
     end
-  end
 
-  platform_is :android do
-    it "always returns UTF-8" do
-      old_lc_all = ENV['LC_ALL']
-      ENV['LC_ALL'] = 'C'
-      ruby_exe("print Encoding.locale_charmap").should == 'UTF-8'
-      ENV['LC_ALL'] = old_lc_all
+    platform_is :android do
+      it "always returns UTF-8" do
+        ENV['LC_ALL'] = 'C'
+        ruby_exe("print Encoding.locale_charmap").should == 'UTF-8'
+      end
     end
-  end
 
-  platform_is :bsd, :darwin, :linux do
-    it "is unaffected by assigning to ENV['LC_ALL'] in the same process" do
-      old_charmap = Encoding.locale_charmap
-      old_lc_all = ENV['LC_ALL']
-      ENV['LC_ALL'] = 'C'
-      Encoding.locale_charmap.should == old_charmap
-      ENV['LC_ALL'] = old_lc_all
+    platform_is :bsd, :darwin, :linux do
+      it "is unaffected by assigning to ENV['LC_ALL'] in the same process" do
+        old_charmap = Encoding.locale_charmap
+        ENV['LC_ALL'] = 'C'
+        Encoding.locale_charmap.should == old_charmap
+      end
     end
   end
 end
diff --git a/spec/ruby/core/encoding/name_list_spec.rb b/spec/ruby/core/encoding/name_list_spec.rb
index 836381c4d8..1ba8d383bc 100644
--- a/spec/ruby/core/encoding/name_list_spec.rb
+++ b/spec/ruby/core/encoding/name_list_spec.rb
@@ -2,22 +2,22 @@ require_relative '../../spec_helper'
 
 describe "Encoding.name_list" do
   it "returns an Array" do
-    Encoding.name_list.should be_an_instance_of(Array)
+    Encoding.name_list.should.instance_of?(Array)
   end
 
   it "returns encoding names as Strings" do
-    Encoding.name_list.each {|e| e.should be_an_instance_of(String) }
+    Encoding.name_list.each {|e| e.should.instance_of?(String) }
   end
 
   it "includes all aliases" do
     Encoding.aliases.keys.each do |enc_alias|
-      Encoding.name_list.include?(enc_alias).should be_true
+      Encoding.name_list.include?(enc_alias).should == true
     end
   end
 
   it "includes all non-dummy encodings" do
     Encoding.list.each do |enc|
-      Encoding.name_list.include?(enc.name).should be_true
+      Encoding.name_list.include?(enc.name).should == true
     end
   end
 end
diff --git a/spec/ruby/core/encoding/names_spec.rb b/spec/ruby/core/encoding/names_spec.rb
index 9ded043bbb..e6bcbf474a 100644
--- a/spec/ruby/core/encoding/names_spec.rb
+++ b/spec/ruby/core/encoding/names_spec.rb
@@ -4,7 +4,7 @@ describe "Encoding#names" do
   it "returns an Array" do
     Encoding.name_list.each do |name|
       e = Encoding.find(name) or next
-      e.names.should be_an_instance_of(Array)
+      e.names.should.instance_of?(Array)
     end
   end
 
@@ -12,7 +12,7 @@ describe "Encoding#names" do
     Encoding.name_list.each do |name|
       e = Encoding.find(name) or next
       e.names.each do |this_name|
-        this_name.should be_an_instance_of(String)
+        this_name.should.instance_of?(String)
       end
     end
   end
@@ -29,7 +29,7 @@ describe "Encoding#names" do
       e = Encoding.find(name) or next
       aliases = Encoding.aliases.select{|a,n| n == name}.keys
       names = e.names
-      aliases.each {|a| names.include?(a).should be_true}
+      aliases.each {|a| names.include?(a).should == true}
     end
   end
 end
diff --git a/spec/ruby/core/encoding/replicate_spec.rb b/spec/ruby/core/encoding/replicate_spec.rb
index e22673db7d..9fe0ba8747 100644
--- a/spec/ruby/core/encoding/replicate_spec.rb
+++ b/spec/ruby/core/encoding/replicate_spec.rb
@@ -1,88 +1,8 @@
-# -*- encoding: binary -*-
+# encoding: binary
 require_relative '../../spec_helper'
 
 describe "Encoding#replicate" do
-  ruby_version_is ""..."3.3" do
-    before :all do
-      @i = 0
-    end
-
-    before :each do
-      @i += 1
-      @prefix = "RS#{@i}"
-    end
-
-    it "returns a replica of ASCII" do
-      name = @prefix + '-ASCII'
-      e = suppress_warning { Encoding::ASCII.replicate(name) }
-      e.name.should == name
-      Encoding.find(name).should == e
-
-      "a".dup.force_encoding(e).valid_encoding?.should be_true
-      "\x80".dup.force_encoding(e).valid_encoding?.should be_false
-    end
-
-    it "returns a replica of UTF-8" do
-      name = @prefix + 'UTF-8'
-      e = suppress_warning { Encoding::UTF_8.replicate(name) }
-      e.name.should == name
-      Encoding.find(name).should == e
-
-      "a".dup.force_encoding(e).valid_encoding?.should be_true
-      "\u3042".dup.force_encoding(e).valid_encoding?.should be_true
-      "\x80".dup.force_encoding(e).valid_encoding?.should be_false
-    end
-
-    it "returns a replica of UTF-16BE" do
-      name = @prefix + 'UTF-16-BE'
-      e = suppress_warning { Encoding::UTF_16BE.replicate(name) }
-      e.name.should == name
-      Encoding.find(name).should == e
-
-      "a".dup.force_encoding(e).valid_encoding?.should be_false
-      "\x30\x42".dup.force_encoding(e).valid_encoding?.should be_true
-      "\x80".dup.force_encoding(e).valid_encoding?.should be_false
-    end
-
-    it "returns a replica of ISO-2022-JP" do
-      name = @prefix + 'ISO-2022-JP'
-      e = suppress_warning { Encoding::ISO_2022_JP.replicate(name) }
-      Encoding.find(name).should == e
-
-      e.name.should == name
-      e.dummy?.should be_true
-    end
-
-    # NOTE: it's unclear of the value of this (for the complexity cost of it),
-    # but it is the current CRuby behavior.
-    it "can be associated with a String" do
-      name = @prefix + '-US-ASCII'
-      e = suppress_warning { Encoding::US_ASCII.replicate(name) }
-      e.name.should == name
-      Encoding.find(name).should == e
-
-      s = "abc".dup.force_encoding(e)
-      s.encoding.should == e
-      s.encoding.name.should == name
-    end
-  end
-
-  ruby_version_is "3.2"..."3.3" do
-    it "warns about deprecation" do
-      -> {
-        Encoding::US_ASCII.replicate('MY-US-ASCII')
-      }.should complain(/warning: Encoding#replicate is deprecated and will be removed in Ruby 3.3; use the original encoding instead/)
-    end
-
-    it "raises EncodingError if too many encodings" do
-      code = '1_000.times {|i| Encoding::US_ASCII.replicate("R_#{i}") }'
-      ruby_exe(code, args: "2>&1", exit_status: 1).should.include?('too many encoding (> 256) (EncodingError)')
-    end
-  end
-
-  ruby_version_is "3.3" do
-    it "has been removed" do
-      Encoding::US_ASCII.should_not.respond_to?(:replicate, true)
-    end
+  it "has been removed" do
+    Encoding::US_ASCII.should_not.respond_to?(:replicate, true)
   end
 end
diff --git a/spec/ruby/core/encoding/shared/name.rb b/spec/ruby/core/encoding/shared/name.rb
index cd37ea06db..4d4b860a1f 100644
--- a/spec/ruby/core/encoding/shared/name.rb
+++ b/spec/ruby/core/encoding/shared/name.rb
@@ -3,7 +3,7 @@ require_relative '../../../spec_helper'
 describe :encoding_name, shared: true do
   it "returns a String" do
     Encoding.list.each do |e|
-      e.send(@method).should be_an_instance_of(String)
+      e.send(@method).should.instance_of?(String)
     end
   end
 
diff --git a/spec/ruby/core/encoding/undefined_conversion_error/destination_encoding_name_spec.rb b/spec/ruby/core/encoding/undefined_conversion_error/destination_encoding_name_spec.rb
index a51a9f46a0..bc36695ca7 100644
--- a/spec/ruby/core/encoding/undefined_conversion_error/destination_encoding_name_spec.rb
+++ b/spec/ruby/core/encoding/undefined_conversion_error/destination_encoding_name_spec.rb
@@ -7,7 +7,7 @@ describe "Encoding::UndefinedConversionError#destination_encoding_name" do
   end
 
   it "returns a String" do
-    @exception.destination_encoding_name.should be_an_instance_of(String)
+    @exception.destination_encoding_name.should.instance_of?(String)
   end
 
   it "is equal to the destination encoding name of the object that raised it" do
diff --git a/spec/ruby/core/encoding/undefined_conversion_error/destination_encoding_spec.rb b/spec/ruby/core/encoding/undefined_conversion_error/destination_encoding_spec.rb
index 905556407c..c0fcf8de58 100644
--- a/spec/ruby/core/encoding/undefined_conversion_error/destination_encoding_spec.rb
+++ b/spec/ruby/core/encoding/undefined_conversion_error/destination_encoding_spec.rb
@@ -7,7 +7,7 @@ describe "Encoding::UndefinedConversionError#destination_encoding" do
   end
 
   it "returns an Encoding object" do
-    @exception.destination_encoding.should be_an_instance_of(Encoding)
+    @exception.destination_encoding.should.instance_of?(Encoding)
   end
 
   it "is equal to the destination encoding of the object that raised it" do
diff --git a/spec/ruby/core/encoding/undefined_conversion_error/error_char_spec.rb b/spec/ruby/core/encoding/undefined_conversion_error/error_char_spec.rb
index 9cb55e6d95..333acf5ee6 100644
--- a/spec/ruby/core/encoding/undefined_conversion_error/error_char_spec.rb
+++ b/spec/ruby/core/encoding/undefined_conversion_error/error_char_spec.rb
@@ -8,8 +8,8 @@ describe "Encoding::UndefinedConversionError#error_char" do
   end
 
   it "returns a String" do
-    @exception.error_char.should be_an_instance_of(String)
-    @exception2.error_char.should be_an_instance_of(String)
+    @exception.error_char.should.instance_of?(String)
+    @exception2.error_char.should.instance_of?(String)
   end
 
   it "returns the one-character String that caused the exception" do
diff --git a/spec/ruby/core/encoding/undefined_conversion_error/source_encoding_name_spec.rb b/spec/ruby/core/encoding/undefined_conversion_error/source_encoding_name_spec.rb
index d5e60e78db..4932a25ed7 100644
--- a/spec/ruby/core/encoding/undefined_conversion_error/source_encoding_name_spec.rb
+++ b/spec/ruby/core/encoding/undefined_conversion_error/source_encoding_name_spec.rb
@@ -8,7 +8,7 @@ describe "Encoding::UndefinedConversionError#source_encoding_name" do
   end
 
   it "returns a String" do
-    @exception.source_encoding_name.should be_an_instance_of(String)
+    @exception.source_encoding_name.should.instance_of?(String)
   end
 
   it "is equal to the source encoding name of the object that raised it" do
diff --git a/spec/ruby/core/encoding/undefined_conversion_error/source_encoding_spec.rb b/spec/ruby/core/encoding/undefined_conversion_error/source_encoding_spec.rb
index de456a4b5a..cf12020ad2 100644
--- a/spec/ruby/core/encoding/undefined_conversion_error/source_encoding_spec.rb
+++ b/spec/ruby/core/encoding/undefined_conversion_error/source_encoding_spec.rb
@@ -8,8 +8,8 @@ describe "Encoding::UndefinedConversionError#source_encoding" do
   end
 
   it "returns an Encoding object" do
-    @exception.source_encoding.should be_an_instance_of(Encoding)
-    @exception2.source_encoding.should be_an_instance_of(Encoding)
+    @exception.source_encoding.should.instance_of?(Encoding)
+    @exception2.source_encoding.should.instance_of?(Encoding)
   end
 
   it "is equal to the source encoding of the object that raised it" do