1 files changed, 209 insertions, 63 deletions

diff --git a/spec/ruby/optional/capi/string_spec.rb b/spec/ruby/optional/capi/string_spec.rb
index 3a47fa9762..72f20ee6a5 100644
--- a/spec/ruby/optional/capi/string_spec.rb
+++ b/spec/ruby/optional/capi/string_spec.rb
@@ -1,4 +1,5 @@
 # encoding: utf-8
+# frozen_string_literal: false
 require_relative 'spec_helper'
 require_relative '../../shared/string/times'
 
@@ -47,7 +48,7 @@ describe "C-API String function" do
   [Encoding::BINARY, Encoding::UTF_8].each do |enc|
     describe "rb_str_set_len on a #{enc.name} String" do
       before :each do
-        @str = "abcdefghij".force_encoding(enc)
+        @str = "abcdefghij".dup.force_encoding(enc)
         # Make sure to unshare the string
         @s.rb_str_modify(@str)
       end
@@ -99,7 +100,7 @@ describe "C-API String function" do
 
   describe "rb_str_set_len on a UTF-16 String" do
     before :each do
-      @str = "abcdefghij".force_encoding(Encoding::UTF_16BE)
+      @str = "abcdefghij".dup.force_encoding(Encoding::UTF_16BE)
       # Make sure to unshare the string
       @s.rb_str_modify(@str)
     end
@@ -112,7 +113,7 @@ describe "C-API String function" do
 
   describe "rb_str_set_len on a UTF-32 String" do
     before :each do
-      @str = "abcdefghijkl".force_encoding(Encoding::UTF_32BE)
+      @str = "abcdefghijkl".dup.force_encoding(Encoding::UTF_32BE)
       # Make sure to unshare the string
       @s.rb_str_modify(@str)
     end
@@ -190,11 +191,19 @@ describe "C-API String function" do
     end
 
     it "returns a new String object filled with \\0 bytes" do
-      s = @s.rb_str_tmp_new(4)
-      s.encoding.should == Encoding::BINARY
-      s.bytesize.should == 4
-      s.size.should == 4
-      s.should == "\x00\x00\x00\x00"
+      lens = [4]
+
+      ruby_version_is "4.0" do
+        lens << 100
+      end
+
+      lens.each do |len|
+        s = @s.rb_str_tmp_new(len)
+        s.encoding.should == Encoding::BINARY
+        s.bytesize.should == len
+        s.size.should == len
+        s.should == "\x00" * len
+      end
     end
   end
 
@@ -231,7 +240,7 @@ describe "C-API String function" do
 
   describe "rb_usascii_str_new" do
     it "creates a new String with US-ASCII Encoding from a char buffer of len characters" do
-      str = "abc".force_encoding("us-ascii")
+      str = "abc".dup.force_encoding("us-ascii")
       result = @s.rb_usascii_str_new("abcdef", 3)
       result.should == str
       result.encoding.should == Encoding::US_ASCII
@@ -247,14 +256,14 @@ describe "C-API String function" do
 
     it "returns US-ASCII string for non-US-ASCII string literal" do
       str = @s.rb_usascii_str_new_lit_non_ascii
-      str.should == "r\xC3\xA9sum\xC3\xA9".force_encoding(Encoding::US_ASCII)
+      str.should == "r\xC3\xA9sum\xC3\xA9".dup.force_encoding(Encoding::US_ASCII)
       str.encoding.should == Encoding::US_ASCII
     end
   end
 
   describe "rb_usascii_str_new_cstr" do
     it "creates a new String with US-ASCII Encoding" do
-      str = "abc".force_encoding("us-ascii")
+      str = "abc".dup.force_encoding("us-ascii")
       result = @s.rb_usascii_str_new_cstr("abc")
       result.should == str
       result.encoding.should == Encoding::US_ASCII
@@ -418,7 +427,7 @@ describe "C-API String function" do
 
   describe "rb_enc_str_buf_cat" do
     it "concatenates a C string literal to a ruby string with the given encoding" do
-      input = "hello ".force_encoding(Encoding::US_ASCII)
+      input = "hello ".dup.force_encoding(Encoding::US_ASCII)
       result = @s.rb_enc_str_buf_cat(input, "résumé", Encoding::UTF_8)
       result.should == "hello résumé"
       result.encoding.should == Encoding::UTF_8
@@ -448,6 +457,20 @@ describe "C-API String function" do
     end
   end
 
+  describe "rb_str_strlen" do
+    it 'returns 0 as the length of an empty string' do
+      @s.rb_str_strlen('').should == 0
+    end
+
+    it 'returns the number of characters in a string' do
+      @s.rb_str_strlen('hello').should == 5
+    end
+
+    it 'returns the number of characters in a string with multi-byte characters' do
+      @s.rb_str_strlen('こんにちは').should == 5
+    end
+  end
+
   describe "rb_str_split" do
     it "splits strings over a splitter" do
       @s.rb_str_split("Hello,Goodbye").should == ["Hello", "Goodbye"]
@@ -498,29 +521,10 @@ describe "C-API String function" do
     end
   end
 
-  describe "rb_fstring" do
-    it 'returns self if the String is frozen' do
-      input  = 'foo'.freeze
-      output = @s.rb_fstring(input)
-
-      output.should equal(input)
-      output.should.frozen?
-    end
-
-    it 'returns a frozen copy if the String is not frozen' do
-      input  = 'foo'
-      output = @s.rb_fstring(input)
-
-      output.should.frozen?
-      output.should_not equal(input)
-      output.should == 'foo'
-    end
-  end
-
   describe "rb_str_subseq" do
     it "returns a byte-indexed substring" do
-      str = "\x00\x01\x02\x03\x04".force_encoding("binary")
-      @s.rb_str_subseq(str, 1, 2).should == "\x01\x02".force_encoding("binary")
+      str = "\x00\x01\x02\x03\x04".dup.force_encoding("binary")
+      @s.rb_str_subseq(str, 1, 2).should == "\x01\x02".dup.force_encoding("binary")
     end
   end
 
@@ -731,7 +735,7 @@ describe "C-API String function" do
     end
 
     it "increases the size of the string" do
-      expected = "test".force_encoding("US-ASCII")
+      expected = "test".dup.force_encoding("US-ASCII")
       str = @s.rb_str_resize(expected.dup, 12)
       str.size.should == 12
       str.bytesize.should == 12
@@ -862,11 +866,11 @@ describe "C-API String function" do
 #     it "transcodes a String to Encoding.default_internal if it is set" do
 #       Encoding.default_internal = Encoding::EUC_JP
 #
-#  -      a = "\xE3\x81\x82\xe3\x82\x8c".force_encoding("utf-8")
+#  -      a = "\xE3\x81\x82\xe3\x82\x8c".dup.force_encoding("utf-8")
 #  +      a = [0xE3, 0x81, 0x82, 0xe3, 0x82, 0x8c].pack('C6').force_encoding("utf-8")
 #         s = @s.rb_external_str_new_with_enc(a, a.bytesize, Encoding::UTF_8)
 #  -
-#  -      s.should == "\xA4\xA2\xA4\xEC".force_encoding("euc-jp")
+#  -      s.should == "\xA4\xA2\xA4\xEC".dup.force_encoding("euc-jp")
 #  +      x = [0xA4, 0xA2, 0xA4, 0xEC].pack('C4')#.force_encoding('binary')
 #  +      s.should == x
 #         s.encoding.should equal(Encoding::EUC_JP)
@@ -886,7 +890,7 @@ describe "C-API String function" do
   describe "rb_locale_str_new" do
     it "returns a String with 'locale' encoding" do
       s = @s.rb_locale_str_new("abc", 3)
-      s.should == "abc".force_encoding(Encoding.find("locale"))
+      s.should == "abc".dup.force_encoding(Encoding.find("locale"))
       s.encoding.should equal(Encoding.find("locale"))
     end
   end
@@ -894,33 +898,37 @@ describe "C-API String function" do
   describe "rb_locale_str_new_cstr" do
     it "returns a String with 'locale' encoding" do
       s = @s.rb_locale_str_new_cstr("abc")
-      s.should == "abc".force_encoding(Encoding.find("locale"))
+      s.should == "abc".dup.force_encoding(Encoding.find("locale"))
       s.encoding.should equal(Encoding.find("locale"))
     end
   end
 
   describe "rb_str_conv_enc" do
     it "returns the original String when to encoding is not specified" do
-      a = "abc".force_encoding("us-ascii")
+      a = "abc".dup.force_encoding("us-ascii")
       @s.rb_str_conv_enc(a, Encoding::US_ASCII, nil).should equal(a)
     end
 
     it "returns the original String if a transcoding error occurs" do
-      a = [0xEE].pack('C').force_encoding("utf-8")
-      @s.rb_str_conv_enc(a, Encoding::UTF_8, Encoding::EUC_JP).should equal(a)
+      a = [0xEE].pack('C').force_encoding(Encoding::UTF_8)
+      @s.rb_str_conv_enc(a, Encoding::UTF_8, Encoding::EUC_JP).should.equal?(a)
+      a.encoding.should == Encoding::UTF_8
+
+      a = "\x80".b
+      @s.rb_str_conv_enc(a, Encoding::BINARY, Encoding::UTF_8).should.equal?(a)
+      a.encoding.should == Encoding::BINARY
     end
 
     it "returns a transcoded String" do
-      a = "\xE3\x81\x82\xE3\x82\x8C".force_encoding("utf-8")
+      a = "\xE3\x81\x82\xE3\x82\x8C".dup.force_encoding(Encoding::UTF_8)
       result = @s.rb_str_conv_enc(a, Encoding::UTF_8, Encoding::EUC_JP)
-      x = [0xA4, 0xA2, 0xA4, 0xEC].pack('C4').force_encoding('utf-8')
-      result.should == x.force_encoding("euc-jp")
-      result.encoding.should equal(Encoding::EUC_JP)
+      result.should == [0xA4, 0xA2, 0xA4, 0xEC].pack('C4').force_encoding(Encoding::EUC_JP)
+      result.encoding.should == Encoding::EUC_JP
     end
 
     describe "when the String encoding is equal to the destination encoding" do
       it "returns the original String" do
-        a = "abc".force_encoding("us-ascii")
+        a = "abc".dup.force_encoding("us-ascii")
         @s.rb_str_conv_enc(a, Encoding::US_ASCII, Encoding::US_ASCII).should equal(a)
       end
 
@@ -930,7 +938,7 @@ describe "C-API String function" do
       end
 
       it "returns the origin String if the destination encoding is BINARY" do
-        a = "abc".force_encoding("binary")
+        a = "abc".dup.force_encoding("binary")
         @s.rb_str_conv_enc(a, Encoding::US_ASCII, Encoding::BINARY).should equal(a)
       end
     end
@@ -938,7 +946,7 @@ describe "C-API String function" do
 
   describe "rb_str_conv_enc_opts" do
     it "returns the original String when to encoding is not specified" do
-      a = "abc".force_encoding("us-ascii")
+      a = "abc".dup.force_encoding("us-ascii")
       @s.rb_str_conv_enc_opts(a, Encoding::US_ASCII, nil, 0, nil).should equal(a)
     end
 
@@ -949,7 +957,7 @@ describe "C-API String function" do
     end
 
     it "returns a transcoded String" do
-      a = "\xE3\x81\x82\xE3\x82\x8C".force_encoding("utf-8")
+      a = "\xE3\x81\x82\xE3\x82\x8C".dup.force_encoding("utf-8")
       result = @s.rb_str_conv_enc_opts(a, Encoding::UTF_8, Encoding::EUC_JP, 0, nil)
       x = [0xA4, 0xA2, 0xA4, 0xEC].pack('C4').force_encoding('utf-8')
       result.should == x.force_encoding("euc-jp")
@@ -958,7 +966,7 @@ describe "C-API String function" do
 
     describe "when the String encoding is equal to the destination encoding" do
       it "returns the original String" do
-        a = "abc".force_encoding("us-ascii")
+        a = "abc".dup.force_encoding("us-ascii")
         @s.rb_str_conv_enc_opts(a, Encoding::US_ASCII,
                                 Encoding::US_ASCII, 0, nil).should equal(a)
       end
@@ -970,7 +978,7 @@ describe "C-API String function" do
       end
 
       it "returns the origin String if the destination encoding is BINARY" do
-        a = "abc".force_encoding("binary")
+        a = "abc".dup.force_encoding("binary")
         @s.rb_str_conv_enc_opts(a, Encoding::US_ASCII,
                                 Encoding::BINARY, 0, nil).should equal(a)
       end
@@ -988,7 +996,7 @@ describe "C-API String function" do
   describe "rb_str_export_locale" do
     it "returns the original String with the locale encoding" do
       s = @s.rb_str_export_locale("abc")
-      s.should == "abc".force_encoding(Encoding.find("locale"))
+      s.should == "abc".dup.force_encoding(Encoding.find("locale"))
       s.encoding.should equal(Encoding.find("locale"))
     end
   end
@@ -1012,7 +1020,7 @@ describe "C-API String function" do
       result = @s.rb_str_export_to_enc(source, Encoding::UTF_8)
       source.bytes.should == [0, 255]
     end
-end
+  end
 
   describe "rb_sprintf" do
     it "replaces the parts like sprintf" do
@@ -1040,11 +1048,19 @@ end
       @s.rb_sprintf3(true.class).should == s
     end
 
-    ruby_bug "#19167", ""..."3.2" do
-      it "formats a TrueClass VALUE as 'true' if sign specified in format" do
-        s = 'Result: TrueClass.'
-        @s.rb_sprintf4(true.class).should == s
-      end
+    it "formats a TrueClass VALUE as 'true' if sign specified in format" do
+      s = 'Result: TrueClass.'
+      @s.rb_sprintf4(true.class).should == s
+    end
+
+    it "formats nil using to_s if sign not specified in format" do
+      s = 'Result: .'
+      @s.rb_sprintf3(nil).should == s
+    end
+
+    it "formats nil using inspect if sign specified in format" do
+      s = 'Result: nil.'
+      @s.rb_sprintf4(nil).should == s
     end
 
     it "truncates a string to a supplied precision if that is shorter than the string" do
@@ -1114,7 +1130,7 @@ end
     end
 
     it "tries to convert the passed argument to a string by calling #to_s" do
-      @s.rb_String({"bar" => "foo"}).should == '{"bar"=>"foo"}'
+      @s.rb_String({"bar" => "foo"}).should == {"bar" => "foo"}.to_s
     end
   end
 
@@ -1203,28 +1219,158 @@ end
 
   describe "rb_str_locktmp" do
     it "raises an error when trying to lock an already locked string" do
-      str = "test"
+      str = +"test"
       @s.rb_str_locktmp(str).should == str
       -> { @s.rb_str_locktmp(str) }.should raise_error(RuntimeError, 'temporal locking already locked string')
     end
 
     it "locks a string so that modifications would raise an error" do
-      str = "test"
+      str = +"test"
       @s.rb_str_locktmp(str).should == str
       -> { str.upcase! }.should raise_error(RuntimeError, 'can\'t modify string; temporarily locked')
     end
+
+    ruby_version_is "4.0" do
+      it "raises FrozenError if string is frozen" do
+        str = -"rb_str_locktmp"
+        -> { @s.rb_str_locktmp(str) }.should raise_error(FrozenError)
+
+        str = +"rb_str_locktmp"
+        str.freeze
+        -> { @s.rb_str_locktmp(str) }.should raise_error(FrozenError)
+      end
+    end
   end
 
   describe "rb_str_unlocktmp" do
     it "unlocks a locked string" do
-      str = "test"
+      str = +"test"
       @s.rb_str_locktmp(str)
       @s.rb_str_unlocktmp(str).should == str
       str.upcase!.should == "TEST"
     end
 
     it "raises an error when trying to unlock an already unlocked string" do
-      -> { @s.rb_str_unlocktmp("test") }.should raise_error(RuntimeError, 'temporal unlocking already unlocked string')
+      -> { @s.rb_str_unlocktmp(+"test") }.should raise_error(RuntimeError, 'temporal unlocking already unlocked string')
+    end
+
+    ruby_version_is "4.0" do
+      it "raises FrozenError if string is frozen" do
+        str = -"rb_str_locktmp"
+        -> { @s.rb_str_unlocktmp(str) }.should raise_error(FrozenError)
+
+        str = +"rb_str_locktmp"
+        str.freeze
+        -> { @s.rb_str_unlocktmp(str) }.should raise_error(FrozenError)
+      end
+    end
+  end
+
+  describe "rb_enc_interned_str_cstr" do
+    it "returns a frozen string" do
+      str = "hello"
+      val = @s.rb_enc_interned_str_cstr(str, Encoding::US_ASCII)
+
+      val.should.is_a?(String)
+      val.encoding.should == Encoding::US_ASCII
+      val.should.frozen?
+    end
+
+    it "returns the same frozen string" do
+      str = "hello"
+      result1 = @s.rb_enc_interned_str_cstr(str, Encoding::US_ASCII)
+      result2 = @s.rb_enc_interned_str_cstr(str, Encoding::US_ASCII)
+      result1.should.equal?(result2)
+    end
+
+    it "returns different frozen strings for different encodings" do
+      str = "hello"
+      result1 = @s.rb_enc_interned_str_cstr(str, Encoding::US_ASCII)
+      result2 = @s.rb_enc_interned_str_cstr(str, Encoding::UTF_8)
+      result1.should_not.equal?(result2)
+    end
+
+    it "returns the same string as String#-@" do
+      @s.rb_enc_interned_str_cstr("hello", Encoding::UTF_8).should.equal?(-"hello")
+    end
+
+    ruby_bug "#20322", ""..."3.4" do
+      it "uses the default encoding if encoding is null" do
+        str = "hello"
+        val = @s.rb_enc_interned_str_cstr(str, nil)
+        val.encoding.should == Encoding::ASCII_8BIT
+      end
+    end
+  end
+
+  describe "rb_enc_interned_str" do
+    it "returns a frozen string" do
+      str = "hello"
+      val = @s.rb_enc_interned_str(str, str.bytesize, Encoding::US_ASCII)
+
+      val.should.is_a?(String)
+      val.encoding.should == Encoding::US_ASCII
+      val.should.frozen?
+    end
+
+    it "returns the same frozen string" do
+      str = "hello"
+      result1 = @s.rb_enc_interned_str(str, str.bytesize, Encoding::US_ASCII)
+      result2 = @s.rb_enc_interned_str(str, str.bytesize, Encoding::US_ASCII)
+      result1.should.equal?(result2)
+    end
+
+    it "returns different frozen strings for different encodings" do
+      str = "hello"
+      result1 = @s.rb_enc_interned_str(str, str.bytesize, Encoding::US_ASCII)
+      result2 = @s.rb_enc_interned_str(str, str.bytesize, Encoding::UTF_8)
+      result1.should_not.equal?(result2)
+    end
+
+    it 'returns the same string when using non-ascii characters' do
+      str = 'こんにちは'
+      result1 = @s.rb_enc_interned_str(str, str.bytesize, Encoding::UTF_8)
+      result2 = @s.rb_enc_interned_str(str, str.bytesize, Encoding::UTF_8)
+      result1.should.equal?(result2)
+    end
+
+    it "returns the same string as String#-@" do
+      str = "hello"
+      @s.rb_enc_interned_str(str, str.bytesize, Encoding::UTF_8).should.equal?(-str)
+    end
+
+    ruby_bug "#20322", ""..."3.4" do
+      it "uses the default encoding if encoding is null" do
+        str = "hello"
+        val = @s.rb_enc_interned_str(str, str.bytesize, nil)
+        val.encoding.should == Encoding::ASCII_8BIT
+      end
+    end
+  end
+
+  describe "rb_str_to_interned_str" do
+    it "returns a frozen string" do
+      str = "hello"
+      result = @s.rb_str_to_interned_str(str)
+      result.should.is_a?(String)
+      result.should.frozen?
+    end
+
+    it "returns the same frozen string" do
+      str = "hello"
+      result1 = @s.rb_str_to_interned_str(str)
+      result2 = @s.rb_str_to_interned_str(str)
+      result1.should.equal?(result2)
+    end
+
+    it "returns different frozen strings for different encodings" do
+      result1 = @s.rb_str_to_interned_str("hello".dup.force_encoding(Encoding::US_ASCII))
+      result2 = @s.rb_str_to_interned_str("hello".dup.force_encoding(Encoding::UTF_8))
+      result1.should_not.equal?(result2)
+    end
+
+    it "returns the same string as String#-@" do
+      @s.rb_str_to_interned_str("hello").should.equal?(-"hello")
     end
   end
 end