7 files changed, 332 insertions, 79 deletions

diff --git a/spec/ruby/core/kernel/shared/dup_clone.rb b/spec/ruby/core/kernel/shared/dup_clone.rb
index 84ad49cbde..4fac6006e1 100644
--- a/spec/ruby/core/kernel/shared/dup_clone.rb
+++ b/spec/ruby/core/kernel/shared/dup_clone.rb
@@ -52,18 +52,6 @@ describe :kernel_dup_clone, shared: true do
     o2.original.should equal(o)
   end
 
-  ruby_version_is ''...'2.7' do
-    it "preserves tainted state from the original" do
-      o = ObjectSpecDupInitCopy.new
-      o2 = o.send(@method)
-      o.taint
-      o3 = o.send(@method)
-
-      o2.should_not.tainted?
-      o3.should.tainted?
-    end
-  end
-
   it "does not preserve the object_id" do
     o1 = ObjectSpecDupInitCopy.new
     old_object_id = o1.object_id
@@ -71,18 +59,6 @@ describe :kernel_dup_clone, shared: true do
     o2.object_id.should_not == old_object_id
   end
 
-  ruby_version_is ''...'2.7' do
-    it "preserves untrusted state from the original" do
-      o = ObjectSpecDupInitCopy.new
-      o2 = o.send(@method)
-      o.untrust
-      o3 = o.send(@method)
-
-      o2.should_not.untrusted?
-      o3.should.untrusted?
-    end
-  end
-
   it "returns nil for NilClass" do
     nil.send(@method).should == nil
   end
diff --git a/spec/ruby/core/kernel/shared/lambda.rb b/spec/ruby/core/kernel/shared/lambda.rb
index c7180e1442..c70640082a 100644
--- a/spec/ruby/core/kernel/shared/lambda.rb
+++ b/spec/ruby/core/kernel/shared/lambda.rb
@@ -4,6 +4,8 @@ describe :kernel_lambda, shared: true do
   end
 
   it "raises an ArgumentError when no block is given" do
-    -> { send(@method) }.should raise_error(ArgumentError)
+    suppress_warning do
+      -> { send(@method) }.should raise_error(ArgumentError)
+    end
   end
 end
diff --git a/spec/ruby/core/kernel/shared/load.rb b/spec/ruby/core/kernel/shared/load.rb
index 120619abef..62c5c7be9b 100644
--- a/spec/ruby/core/kernel/shared/load.rb
+++ b/spec/ruby/core/kernel/shared/load.rb
@@ -1,5 +1,6 @@
 main = self
 
+# The big difference is Kernel#load does not attempt to add an extension to the passed path, unlike Kernel#require
 describe :kernel_load, shared: true do
   before :each do
     CodeLoadingSpecs.spec_setup
@@ -10,22 +11,31 @@ describe :kernel_load, shared: true do
     CodeLoadingSpecs.spec_cleanup
   end
 
-  it "loads a non-extensioned file as a Ruby source file" do
-    path = File.expand_path "load_fixture", CODE_LOADING_DIR
-    @object.load(path).should be_true
-    ScratchPad.recorded.should == [:no_ext]
-  end
+  describe "(path resolution)" do
+    # This behavior is specific to Kernel#load, it differs for Kernel#require
+    it "loads a non-extensioned file as a Ruby source file" do
+      path = File.expand_path "load_fixture", CODE_LOADING_DIR
+      @object.load(path).should be_true
+      ScratchPad.recorded.should == [:no_ext]
+    end
 
-  it "loads a non .rb extensioned file as a Ruby source file" do
-    path = File.expand_path "load_fixture.ext", CODE_LOADING_DIR
-    @object.load(path).should be_true
-    ScratchPad.recorded.should == [:no_rb_ext]
-  end
+    it "loads a non .rb extensioned file as a Ruby source file" do
+      path = File.expand_path "load_fixture.ext", CODE_LOADING_DIR
+      @object.load(path).should be_true
+      ScratchPad.recorded.should == [:no_rb_ext]
+    end
 
-  it "loads from the current working directory" do
-    Dir.chdir CODE_LOADING_DIR do
-      @object.load("load_fixture.rb").should be_true
-      ScratchPad.recorded.should == [:loaded]
+    it "loads from the current working directory" do
+      Dir.chdir CODE_LOADING_DIR do
+        @object.load("load_fixture.rb").should be_true
+        ScratchPad.recorded.should == [:loaded]
+      end
+    end
+
+    # This behavior is specific to Kernel#load, it differs for Kernel#require
+    it "does not look for a c-extension file when passed a path without extension (when no .rb is present)" do
+      path = File.join CODE_LOADING_DIR, "a", "load_fixture"
+      -> { @object.send(@method, path) }.should raise_error(LoadError)
     end
   end
 
@@ -88,12 +98,12 @@ describe :kernel_load, shared: true do
 
   describe "when passed true for 'wrap'" do
     it "loads from an existing path" do
-      path = File.expand_path "wrap_fixture.rb", CODE_LOADING_DIR
+      path = File.expand_path "load_wrap_fixture.rb", CODE_LOADING_DIR
       @object.load(path, true).should be_true
     end
 
     it "sets the enclosing scope to an anonymous module" do
-      path = File.expand_path "wrap_fixture.rb", CODE_LOADING_DIR
+      path = File.expand_path "load_wrap_fixture.rb", CODE_LOADING_DIR
       @object.load(path, true)
 
       Object.const_defined?(:LoadSpecWrap).should be_false
@@ -103,14 +113,14 @@ describe :kernel_load, shared: true do
     end
 
     it "allows referencing outside namespaces" do
-      path = File.expand_path "wrap_fixture.rb", CODE_LOADING_DIR
+      path = File.expand_path "load_wrap_fixture.rb", CODE_LOADING_DIR
       @object.load(path, true)
 
       ScratchPad.recorded[0].should equal(String)
     end
 
     it "sets self as a copy of the top-level main" do
-      path = File.expand_path "wrap_fixture.rb", CODE_LOADING_DIR
+      path = File.expand_path "load_wrap_fixture.rb", CODE_LOADING_DIR
       @object.load(path, true)
 
       top_level = ScratchPad.recorded[2]
@@ -127,7 +137,7 @@ describe :kernel_load, shared: true do
       main_ancestors = main.singleton_class.ancestors[1..-1]
       main_ancestors.first.should == mod
 
-      path = File.expand_path "wrap_fixture.rb", CODE_LOADING_DIR
+      path = File.expand_path "load_wrap_fixture.rb", CODE_LOADING_DIR
       @object.load(path, true)
 
       top_level = ScratchPad.recorded[2]
@@ -154,6 +164,39 @@ describe :kernel_load, shared: true do
     end
   end
 
+  describe "when passed a module for 'wrap'" do
+    it "sets the enclosing scope to the supplied module" do
+      path = File.expand_path "load_wrap_fixture.rb", CODE_LOADING_DIR
+      mod = Module.new
+      @object.load(path, mod)
+
+      Object.const_defined?(:LoadSpecWrap).should be_false
+      mod.const_defined?(:LoadSpecWrap).should be_true
+
+      wrap_module = ScratchPad.recorded[1]
+      wrap_module.should == mod
+    end
+
+    it "makes constants and instance methods in the source file reachable with the supplied module" do
+      path = File.expand_path "load_wrap_fixture.rb", CODE_LOADING_DIR
+      mod = Module.new
+      @object.load(path, mod)
+
+      mod::LOAD_WRAP_SPECS_TOP_LEVEL_CONSTANT.should == 1
+      obj = Object.new
+      obj.extend(mod)
+      obj.send(:load_wrap_specs_top_level_method).should == :load_wrap_specs_top_level_method
+    end
+
+    it "makes instance methods in the source file private" do
+      path = File.expand_path "load_wrap_fixture.rb", CODE_LOADING_DIR
+      mod = Module.new
+      @object.load(path, mod)
+
+      mod.private_instance_methods.include?(:load_wrap_specs_top_level_method).should == true
+    end
+  end
+
   describe "(shell expansion)" do
     before :each do
       @env_home = ENV["HOME"]
diff --git a/spec/ruby/core/kernel/shared/method.rb b/spec/ruby/core/kernel/shared/method.rb
index 3418966b1b..8b6ab23fd3 100644
--- a/spec/ruby/core/kernel/shared/method.rb
+++ b/spec/ruby/core/kernel/shared/method.rb
@@ -15,12 +15,18 @@ describe :kernel_method, shared: true do
     m.call.should == 'class done'
   end
 
-  it "returns a method object if we repond_to_missing? method" do
+  it "returns a method object if respond_to_missing?(method) is true" do
     m = KernelSpecs::RespondViaMissing.new.send(@method, :handled_publicly)
     m.should be_an_instance_of Method
     m.call(42).should == "Done handled_publicly([42])"
   end
 
+  it "the returned method object if respond_to_missing?(method) calls #method_missing with a Symbol name" do
+    m = KernelSpecs::RespondViaMissing.new.send(@method, "handled_publicly")
+    m.should be_an_instance_of Method
+    m.call(42).should == "Done handled_publicly([42])"
+  end
+
   it "raises a NameError for an invalid method name" do
     class KernelSpecs::Foo; def bar; 'done'; end; end
     -> {
diff --git a/spec/ruby/core/kernel/shared/require.rb b/spec/ruby/core/kernel/shared/require.rb
index 28fdb5e451..52f86f73e5 100644
--- a/spec/ruby/core/kernel/shared/require.rb
+++ b/spec/ruby/core/kernel/shared/require.rb
@@ -60,7 +60,7 @@ describe :kernel_require_basic, shared: true do
       -> { @object.send(@method, nil) }.should raise_error(TypeError)
     end
 
-    it "raises a TypeError if passed a Fixnum" do
+    it "raises a TypeError if passed an Integer" do
       -> { @object.send(@method, 42) }.should raise_error(TypeError)
     end
 
@@ -160,6 +160,14 @@ describe :kernel_require_basic, shared: true do
       ScratchPad.recorded.should == [:loaded]
     end
 
+    it "accepts an Object with #to_path in $LOAD_PATH" do
+      obj = mock("to_path")
+      obj.should_receive(:to_path).at_least(:once).and_return(CODE_LOADING_DIR)
+      $LOAD_PATH << obj
+      @object.send(@method, "load_fixture.rb").should be_true
+      ScratchPad.recorded.should == [:loaded]
+    end
+
     it "does not require file twice after $LOAD_PATH change" do
       $LOAD_PATH << CODE_LOADING_DIR
       @object.require("load_fixture.rb").should be_true
@@ -204,6 +212,34 @@ end
 
 describe :kernel_require, shared: true do
   describe "(path resolution)" do
+    it "loads .rb file when passed absolute path without extension" do
+      path = File.expand_path "load_fixture", CODE_LOADING_DIR
+      @object.send(@method, path).should be_true
+      # This should _not_ be [:no_ext]
+      ScratchPad.recorded.should == [:loaded]
+    end
+
+    platform_is :linux, :darwin do
+      it "loads c-extension file when passed absolute path without extension when no .rb is present" do
+        # the error message is specific to what dlerror() returns
+        path = File.join CODE_LOADING_DIR, "a", "load_fixture"
+        -> { @object.send(@method, path) }.should raise_error(LoadError)
+      end
+    end
+
+    platform_is :darwin do
+      it "loads .bundle file when passed absolute path with .so" do
+        # the error message is specific to what dlerror() returns
+        path = File.join CODE_LOADING_DIR, "a", "load_fixture.so"
+        -> { @object.send(@method, path) }.should raise_error(LoadError)
+      end
+    end
+
+    it "does not try an extra .rb if the path already ends in .rb" do
+      path = File.join CODE_LOADING_DIR, "d", "load_fixture.rb"
+      -> { @object.send(@method, path) }.should raise_error(LoadError)
+    end
+
     # For reference see [ruby-core:24155] in which matz confirms this feature is
     # intentional for security reasons.
     it "does not load a bare filename unless the current working directory is in $LOAD_PATH" do
@@ -229,6 +265,17 @@ describe :kernel_require, shared: true do
       }.should complain(/circular require considered harmful/, verbose: true)
       ScratchPad.recorded.should == [:loaded]
     end
+
+    ruby_bug "#17340", ''...'3.3' do
+      it "loads a file concurrently" do
+        path = File.expand_path "concurrent_require_fixture.rb", CODE_LOADING_DIR
+        ScratchPad.record(@object)
+        -> {
+          @object.require(path)
+        }.should_not complain(/circular require considered harmful/, verbose: true)
+        ScratchPad.recorded.join
+      end
+    end
   end
 
   describe "(non-extensioned path)" do
@@ -243,13 +290,21 @@ describe :kernel_require, shared: true do
       ScratchPad.recorded.should == [:loaded]
     end
 
-    ruby_bug "#16926", "2.7"..."2.8" do
-      it "does not load a feature twice when $LOAD_PATH has been modified" do
-        $LOAD_PATH.replace [CODE_LOADING_DIR]
-        @object.require("load_fixture").should be_true
-        $LOAD_PATH.replace [File.expand_path("b", CODE_LOADING_DIR), CODE_LOADING_DIR]
-        @object.require("load_fixture").should be_false
-      end
+    it "does not load a feature twice when $LOAD_PATH has been modified" do
+      $LOAD_PATH.replace [CODE_LOADING_DIR]
+      @object.require("load_fixture").should be_true
+      $LOAD_PATH.replace [File.expand_path("b", CODE_LOADING_DIR), CODE_LOADING_DIR]
+      @object.require("load_fixture").should be_false
+    end
+
+    it "stores the missing path in a LoadError object" do
+      path = "abcd1234"
+
+      -> {
+        @object.send(@method, path)
+      }.should raise_error(LoadError) { |e|
+        e.path.should == path
+      }
     end
   end
 
@@ -344,6 +399,21 @@ describe :kernel_require, shared: true do
           loaded_feature = $LOADED_FEATURES.last
           ScratchPad.recorded.should == [loaded_feature]
         end
+
+        it "requires only once when a new matching file added to path" do
+          @object.require('load_fixture').should be_true
+          ScratchPad.recorded.should == [:loaded]
+
+          symlink_to_code_dir_two = tmp("codesymlinktwo")
+          File.symlink("#{CODE_LOADING_DIR}/b", symlink_to_code_dir_two)
+          begin
+            $LOAD_PATH.unshift(symlink_to_code_dir_two)
+
+            @object.require('load_fixture').should be_false
+          ensure
+            rm_r symlink_to_code_dir_two
+          end
+        end
       end
 
       describe "with symlinks in the required feature and $LOAD_PATH" do
@@ -523,18 +593,6 @@ describe :kernel_require, shared: true do
       ScratchPad.recorded.should == []
     end
 
-    it "complex, enumerator, rational and thread are already required" do
-      provided = %w[complex enumerator rational thread]
-      features = ruby_exe("puts $LOADED_FEATURES", options: '--disable-gems')
-      provided.each { |feature|
-        features.should =~ /\b#{feature}\.(rb|so|jar)$/
-      }
-
-      code = provided.map { |f| "puts require #{f.inspect}\n" }.join
-      required = ruby_exe(code, options: '--disable-gems')
-      required.should == "false\n" * provided.size
-    end
-
     it "unicode_normalize is part of core and not $LOADED_FEATURES" do
       features = ruby_exe("puts $LOADED_FEATURES", options: '--disable-gems')
       features.lines.each { |feature|
@@ -543,6 +601,23 @@ describe :kernel_require, shared: true do
 
       -> { @object.require("unicode_normalize") }.should raise_error(LoadError)
     end
+
+    it "does not load a file earlier on the $LOAD_PATH when other similar features were already loaded" do
+      Dir.chdir CODE_LOADING_DIR do
+        @object.send(@method, "../code/load_fixture").should be_true
+      end
+      ScratchPad.recorded.should == [:loaded]
+
+      $LOAD_PATH.unshift "#{CODE_LOADING_DIR}/b"
+      # This loads because the above load was not on the $LOAD_PATH
+      @object.send(@method, "load_fixture").should be_true
+      ScratchPad.recorded.should == [:loaded, :loaded]
+
+      $LOAD_PATH.unshift "#{CODE_LOADING_DIR}/c"
+      # This does not load because the above load was on the $LOAD_PATH
+      @object.send(@method, "load_fixture").should be_false
+      ScratchPad.recorded.should == [:loaded, :loaded]
+    end
   end
 
   describe "(shell expansion)" do
@@ -750,4 +825,24 @@ describe :kernel_require, shared: true do
       e.path.should == path
     }
   end
+
+  platform_is :linux, :darwin do
+    it "does not store the missing path in a LoadError object when c-extension file exists but loading fails and passed absolute path without extension" do
+      # the error message is specific to what dlerror() returns
+      path = File.join CODE_LOADING_DIR, "a", "load_fixture"
+      -> { @object.send(@method, path) }.should raise_error(LoadError) { |e|
+        e.path.should == nil
+      }
+    end
+  end
+
+  platform_is :darwin do
+    it "does not store the missing path in a LoadError object when c-extension file exists but loading fails and passed absolute path with extension" do
+      # the error message is specific to what dlerror() returns
+      path = File.join CODE_LOADING_DIR, "a", "load_fixture.bundle"
+      -> { @object.send(@method, path) }.should raise_error(LoadError) { |e|
+        e.path.should == nil
+      }
+    end
+  end
 end
diff --git a/spec/ruby/core/kernel/shared/sprintf.rb b/spec/ruby/core/kernel/shared/sprintf.rb
index ca1e6bb2ed..2b2c6c9b63 100644
--- a/spec/ruby/core/kernel/shared/sprintf.rb
+++ b/spec/ruby/core/kernel/shared/sprintf.rb
@@ -22,6 +22,7 @@ describe :kernel_sprintf, shared: true do
       @method.call("%d", "112").should == "112"
       @method.call("%d", "0127").should == "87"
       @method.call("%d", "0xc4").should == "196"
+      @method.call("%d", "0").should == "0"
     end
 
     it "raises TypeError exception if cannot convert to Integer" do
@@ -57,6 +58,11 @@ describe :kernel_sprintf, shared: true do
         it "works well with large numbers" do
           @method.call("%#{f}", 1234567890987654321).should == "1234567890987654321"
         end
+
+        it "converts to the empty string if precision is 0 and value is 0" do
+          @method.call("%.#{f}", 0).should == ""
+          @method.call("%.0#{f}", 0).should == ""
+        end
       end
     end
 
@@ -289,21 +295,64 @@ describe :kernel_sprintf, shared: true do
         @method.call("%c", "a").should == "a"
       end
 
-      it "raises ArgumentError if argument is a string of several characters" do
+      it "displays only the first character if argument is a string of several characters" do
+        @method.call("%c", "abc").should == "a"
+      end
+
+      it "displays no characters if argument is an empty string" do
+        @method.call("%c", "").should == ""
+      end
+
+      it "raises TypeError if argument is not String or Integer and cannot be converted to them" do
         -> {
-          @method.call("%c", "abc")
-        }.should raise_error(ArgumentError)
+          @method.call("%c", [])
+        }.should raise_error(TypeError, /no implicit conversion of Array into Integer/)
       end
 
-      it "raises ArgumentError if argument is an empty string" do
+      it "raises TypeError if argument is nil" do
         -> {
-          @method.call("%c", "")
-        }.should raise_error(ArgumentError)
+          @method.call("%c", nil)
+        }.should raise_error(TypeError, /no implicit conversion from nil to integer/)
       end
 
-      it "supports Unicode characters" do
-        @method.call("%c", 1286).should == "Ԇ"
-        @method.call("%c", "ش").should == "ش"
+      it "tries to convert argument to String with to_str" do
+        obj = BasicObject.new
+        def obj.to_str
+          "a"
+        end
+
+        @method.call("%c", obj).should == "a"
+      end
+
+      it "tries to convert argument to Integer with to_int" do
+        obj = BasicObject.new
+        def obj.to_int
+          90
+        end
+
+        @method.call("%c", obj).should == "Z"
+      end
+
+      it "raises TypeError if converting to String with to_str returns non-String" do
+        obj = BasicObject.new
+        def obj.to_str
+          :foo
+        end
+
+        -> {
+          @method.call("%c", obj)
+        }.should raise_error(TypeError, /can't convert BasicObject to String/)
+      end
+
+      it "raises TypeError if converting to Integer with to_int returns non-Integer" do
+        obj = BasicObject.new
+        def obj.to_int
+          :foo
+        end
+
+        -> {
+          @method.call("%c", obj)
+        }.should raise_error(TypeError, /can't convert BasicObject to Integer/)
       end
     end
 
@@ -313,6 +362,10 @@ describe :kernel_sprintf, shared: true do
         obj.should_receive(:inspect).and_return("<inspect-result>")
         @method.call("%p", obj).should == "<inspect-result>"
       end
+
+      it "substitutes 'nil' for nil" do
+        @method.call("%p", nil).should == "nil"
+      end
     end
 
     describe "s" do
@@ -320,6 +373,10 @@ describe :kernel_sprintf, shared: true do
         @method.call("%s", "abc").should == "abc"
       end
 
+      it "substitutes '' for nil" do
+        @method.call("%s", nil).should == ""
+      end
+
       it "converts argument to string with to_s" do
         obj = mock("string")
         obj.should_receive(:to_s).and_return("abc")
@@ -342,6 +399,45 @@ describe :kernel_sprintf, shared: true do
         sub_string = long_string[8, 5]
         sprintf("%.#{1 * 3}s", sub_string).should == "hel"
       end
+
+      it "formats string with precision" do
+        Kernel.format("%.3s", "hello").should == "hel"
+        Kernel.format("%-3.3s", "hello").should == "hel"
+      end
+
+      it "formats string with width" do
+        @method.call("%6s", "abc").should == "   abc"
+        @method.call("%6s", "abcdefg").should == "abcdefg"
+      end
+
+      it "formats string with width and precision" do
+        @method.call("%4.6s", "abc").should == " abc"
+        @method.call("%4.6s", "abcdefg").should == "abcdef"
+      end
+
+      it "formats nil with width" do
+        @method.call("%6s", nil).should == "      "
+      end
+
+      it "formats nil with precision" do
+        @method.call("%.6s", nil).should == ""
+      end
+
+      it "formats nil with width and precision" do
+        @method.call("%4.6s", nil).should == "    "
+      end
+
+      it "formats multibyte string with precision" do
+        Kernel.format("%.2s", "été").should == "ét"
+      end
+
+      it "preserves encoding of the format string" do
+        str = format('%s'.encode(Encoding::UTF_8), 'foobar')
+        str.encoding.should == Encoding::UTF_8
+
+        str = format('%s'.encode(Encoding::US_ASCII), 'foobar')
+        str.encoding.should == Encoding::US_ASCII
+      end
     end
 
     describe "%" do
@@ -353,7 +449,7 @@ describe :kernel_sprintf, shared: true do
 
       it "is escaped by %" do
         @method.call("%%").should == "%"
-        @method.call("%%d", 10).should == "%d"
+        @method.call("%%d").should == "%d"
       end
     end
   end
@@ -884,4 +980,8 @@ describe :kernel_sprintf, shared: true do
       }
     end
   end
+
+  it "does not raise error when passed more arguments than needed" do
+    sprintf("%s %d %c", "string", 2, "c", []).should == "string 2 c"
+  end
 end
diff --git a/spec/ruby/core/kernel/shared/sprintf_encoding.rb b/spec/ruby/core/kernel/shared/sprintf_encoding.rb
index 5ca66b9083..7ec0fe4c48 100644
--- a/spec/ruby/core/kernel/shared/sprintf_encoding.rb
+++ b/spec/ruby/core/kernel/shared/sprintf_encoding.rb
@@ -1,3 +1,5 @@
+# Keep encoding-related specs in a separate shared example to be able to skip them in IO/File/StringIO specs.
+# It's difficult to check result's encoding in the test after writing to a file/io buffer.
 describe :kernel_sprintf_encoding, shared: true do
   it "can produce a string with valid encoding" do
     string = @method.call("good day %{valid}", valid: "e")
@@ -12,20 +14,20 @@ describe :kernel_sprintf_encoding, shared: true do
   end
 
   it "returns a String in the same encoding as the format String if compatible" do
-    string = "%s".force_encoding(Encoding::KOI8_U)
+    string = "%s".dup.force_encoding(Encoding::KOI8_U)
     result = @method.call(string, "dogs")
     result.encoding.should equal(Encoding::KOI8_U)
   end
 
   it "returns a String in the argument's encoding if format encoding is more restrictive" do
-    string = "foo %s".force_encoding(Encoding::US_ASCII)
-    argument = "b\303\274r".force_encoding(Encoding::UTF_8)
+    string = "foo %s".dup.force_encoding(Encoding::US_ASCII)
+    argument = "b\303\274r".dup.force_encoding(Encoding::UTF_8)
 
     result = @method.call(string, argument)
     result.encoding.should equal(Encoding::UTF_8)
   end
 
-  it "raises Encoding::CompatibilityError if both encodings are ASCII compatible and there ano not ASCII characters" do
+  it "raises Encoding::CompatibilityError if both encodings are ASCII compatible and there are not ASCII characters" do
     string = "Ä %s".encode('windows-1252')
     argument = "Ђ".encode('windows-1251')
 
@@ -33,4 +35,33 @@ describe :kernel_sprintf_encoding, shared: true do
       @method.call(string, argument)
     }.should raise_error(Encoding::CompatibilityError)
   end
+
+  describe "%c" do
+    it "supports Unicode characters" do
+      result = @method.call("%c", 1286)
+      result.should == "Ԇ"
+      result.bytes.should == [212, 134]
+
+      result = @method.call("%c", "ش")
+      result.should == "ش"
+      result.bytes.should == [216, 180]
+    end
+
+    it "raises error when a codepoint isn't representable in an encoding of a format string" do
+      format = "%c".encode("ASCII")
+
+      -> {
+        @method.call(format, 1286)
+      }.should raise_error(RangeError, /out of char range/)
+    end
+
+    it "uses the encoding of the format string to interpret codepoints" do
+      format = "%c".dup.force_encoding("euc-jp")
+      result = @method.call(format, 9415601)
+
+      result.encoding.should == Encoding::EUC_JP
+      result.should == "é".encode(Encoding::EUC_JP)
+      result.bytes.should == [143, 171, 177]
+    end
+  end
 end