Update to ruby/spec@ec84479

21 files changed, 445 insertions, 300 deletions

diff --git a/spec/ruby/optional/capi/basic_object_spec.rb b/spec/ruby/optional/capi/basic_object_spec.rb
new file mode 100644
index 0000000000..2922a421da
--- /dev/null
+++ b/spec/ruby/optional/capi/basic_object_spec.rb
@@ -0,0 +1,24 @@
+require_relative 'spec_helper'
+
+load_extension("basic_object")
+
+describe "C-API basic object" do
+  before :each do
+    @s = CApiBasicObjectSpecs.new
+  end
+
+  describe "RBASIC_CLASS" do
+    it "returns the class of an object" do
+      c = Class.new
+      o = c.new
+      @s.RBASIC_CLASS(o).should == c
+    end
+
+    it "returns the singleton class" do
+      o = Object.new
+      @s.RBASIC_CLASS(o).should == Object
+      singleton_class = o.singleton_class
+      @s.RBASIC_CLASS(o).should == singleton_class
+    end
+  end
+end
diff --git a/spec/ruby/optional/capi/constants_spec.rb b/spec/ruby/optional/capi/constants_spec.rb
index 11a328a91f..3d7f0cebd6 100644
--- a/spec/ruby/optional/capi/constants_spec.rb
+++ b/spec/ruby/optional/capi/constants_spec.rb
@@ -11,10 +11,22 @@ describe "C-API constant" do
     @s.rb_cArray.should == Array
   end
 
+  specify "rb_cBasicObject references the BasicObject class" do
+    @s.rb_cBasicObject.should == BasicObject
+  end
+
+  specify "rb_cBinding references the Binding class" do
+    @s.rb_cBinding.should == Binding
+  end
+
   specify "rb_cClass references the Class class" do
     @s.rb_cClass.should == Class
   end
 
+  specify "rb_cComplex references the Complex class" do
+    @s.rb_cComplex.should == Complex
+  end
+
   specify "rb_mComparable references the Comparable module" do
     @s.rb_mComparable.should == Comparable
   end
@@ -25,10 +37,22 @@ describe "C-API constant" do
     end
   end
 
+  specify "rb_cDir references the Dir class" do
+    @s.rb_cDir.should == Dir
+  end
+
+  specify "rb_cEncoding references the Encoding class" do
+    @s.rb_cEncoding.should == Encoding
+  end
+
   specify "rb_mEnumerable references the Enumerable module" do
     @s.rb_mEnumerable.should == Enumerable
   end
 
+  specify "rb_cEnumerator references the Enumerator class" do
+    @s.rb_cEnumerator.should == Enumerator
+  end
+
   specify "rb_cFalseClass references the FalseClass class" do
     @s.rb_cFalseClass.should == FalseClass
   end
@@ -37,10 +61,18 @@ describe "C-API constant" do
     @s.rb_cFile.should == File
   end
 
+  specify "rb_mFileTest references the FileTest module" do
+    @s.rb_mFileTest.should == FileTest
+  end
+
   specify "rb_cFloat references the Float class" do
     @s.rb_cFloat.should == Float
   end
 
+  specify "rb_mGC references the GC module" do
+    @s.rb_mGC.should == GC
+  end
+
   specify "rb_cHash references the Hash class" do
     @s.rb_cHash.should == Hash
   end
@@ -57,10 +89,21 @@ describe "C-API constant" do
     @s.rb_mKernel.should == Kernel
   end
 
+  # On 2.4 with require 'mathn', Math is redefined as CMath
+  ruby_version_is "2.5" do
+    specify "rb_mMath references the Math module" do
+      @s.rb_mMath.should == Math
+    end
+  end
+
   specify "rb_cMatch references the MatchData class" do
     @s.rb_cMatch.should == MatchData
   end
 
+  specify "rb_cMethod references the Method class" do
+    @s.rb_cMethod.should == Method
+  end
+
   specify "rb_cModule references the Module class" do
     @s.rb_cModule.should == Module
   end
@@ -77,14 +120,34 @@ describe "C-API constant" do
     @s.rb_cObject.should == Object
   end
 
+  specify "rb_cProc references the Proc class" do
+    @s.rb_cProc.should == Proc
+  end
+
+  specify "rb_mProcess references the Process module" do
+    @s.rb_mProcess.should == Process
+  end
+
+  specify "rb_cRandom references the Random class" do
+    @s.rb_cRandom.should == Random
+  end
+
   specify "rb_cRange references the Range class" do
     @s.rb_cRange.should == Range
   end
 
+  specify "rb_cRational references the Rational class" do
+    @s.rb_cRational.should == Rational
+  end
+
   specify "rb_cRegexp references the Regexp class" do
     @s.rb_cRegexp.should == Regexp
   end
 
+  specify "rb_cStat references the File::Stat class" do
+    @s.rb_cStat.should == File::Stat
+  end
+
   specify "rb_cString references the String class" do
     @s.rb_cString.should == String
   end
@@ -109,18 +172,9 @@ describe "C-API constant" do
     @s.rb_cTrueClass.should == TrueClass
   end
 
-  specify "rb_cProc references the Proc class" do
-    @s.rb_cProc.should == Proc
-  end
-
-  specify "rb_cMethod references the Method class" do
-    @s.rb_cMethod.should == Method
+  specify "rb_cUnboundMethod references the UnboundMethod class" do
+    @s.rb_cUnboundMethod.should == UnboundMethod
   end
-
-  specify "rb_cDir references the Dir class" do
-    @s.rb_cDir.should == Dir
-  end
-
 end
 
 describe "C-API exception constant" do
@@ -132,6 +186,14 @@ describe "C-API exception constant" do
     @s.rb_eArgError.should == ArgumentError
   end
 
+  specify "rb_eEncodingError references the EncodingError class" do
+    @s.rb_eEncodingError.should == EncodingError
+  end
+
+  specify "rb_eEncCompatError references the Encoding::CompatibilityError" do
+    @s.rb_eEncCompatError.should == Encoding::CompatibilityError
+  end
+
   specify "rb_eEOFError references the EOFError class" do
     @s.rb_eEOFError.should == EOFError
   end
@@ -144,10 +206,22 @@ describe "C-API exception constant" do
     @s.rb_eException.should == Exception
   end
 
+  specify "rb_eFatal references the fatal class" do
+    fatal = @s.rb_eFatal
+    fatal.should be_kind_of(Class)
+    fatal.should < Exception
+  end
+
   specify "rb_eFloatDomainError references the FloatDomainError class" do
     @s.rb_eFloatDomainError.should == FloatDomainError
   end
 
+  ruby_version_is "2.5" do
+    specify "rb_eFrozenError references the FrozenError class" do
+      @s.rb_eFrozenError.should == FrozenError
+    end
+  end
+
   specify "rb_eIndexError references the IndexError class" do
     @s.rb_eIndexError.should == IndexError
   end
@@ -160,6 +234,10 @@ describe "C-API exception constant" do
     @s.rb_eIOError.should == IOError
   end
 
+  specify "rb_eKeyError references the KeyError class" do
+    @s.rb_eKeyError.should == KeyError
+  end
+
   specify "rb_eLoadError references the LoadError class" do
     @s.rb_eLoadError.should == LoadError
   end
@@ -172,10 +250,6 @@ describe "C-API exception constant" do
     @s.rb_eMathDomainError.should == Math::DomainError
   end
 
-  specify "rb_eEncCompatError references the Encoding::CompatibilityError" do
-    @s.rb_eEncCompatError.should == Encoding::CompatibilityError
-  end
-
   specify "rb_eNameError references the NameError class" do
     @s.rb_eNameError.should == NameError
   end
@@ -220,6 +294,10 @@ describe "C-API exception constant" do
     @s.rb_eStandardError.should == StandardError
   end
 
+  specify "rb_eStopIteration references the StopIteration class" do
+    @s.rb_eStopIteration.should == StopIteration
+  end
+
   specify "rb_eSyntaxError references the SyntaxError class" do
     @s.rb_eSyntaxError.should == SyntaxError
   end
diff --git a/spec/ruby/optional/capi/encoding_spec.rb b/spec/ruby/optional/capi/encoding_spec.rb
index b74a360760..430c2dfcc6 100644
--- a/spec/ruby/optional/capi/encoding_spec.rb
+++ b/spec/ruby/optional/capi/encoding_spec.rb
@@ -257,6 +257,14 @@ describe "C-API Encoding function" do
 
       @s.rb_to_encoding(obj).should == "UTF-8"
     end
+
+    describe "when the rb_encoding struct is stored in native memory" do
+      it "can still read the name of the encoding" do
+        address = @s.rb_to_encoding_native_store(Encoding::UTF_8)
+        address.should be_kind_of(Integer)
+        @s.rb_to_encoding_native_name(address).should == "UTF-8"
+      end
+    end
   end
 
   describe "rb_to_encoding_index" do
diff --git a/spec/ruby/optional/capi/ext/basic_object_spec.c b/spec/ruby/optional/capi/ext/basic_object_spec.c
new file mode 100644
index 0000000000..1618670ceb
--- /dev/null
+++ b/spec/ruby/optional/capi/ext/basic_object_spec.c
@@ -0,0 +1,19 @@
+#include "ruby.h"
+#include "rubyspec.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+static VALUE basic_object_spec_RBASIC_CLASS(VALUE self, VALUE obj) {
+  return RBASIC_CLASS(obj);
+}
+
+void Init_basic_object_spec(void) {
+  VALUE cls = rb_define_class("CApiBasicObjectSpecs", rb_cObject);
+  rb_define_method(cls, "RBASIC_CLASS", basic_object_spec_RBASIC_CLASS, 1);
+}
+
+#ifdef __cplusplus
+}
+#endif
diff --git a/spec/ruby/optional/capi/ext/constants_spec.c b/spec/ruby/optional/capi/ext/constants_spec.c
index 6f1e03f549..598d30a0be 100644
--- a/spec/ruby/optional/capi/ext/constants_spec.c
+++ b/spec/ruby/optional/capi/ext/constants_spec.c
@@ -5,292 +5,151 @@
 extern "C" {
 #endif
 
-static VALUE constants_spec_rb_cArray(VALUE self) {
-  return rb_cArray;
-}
-
-static VALUE constants_spec_rb_cClass(VALUE self) {
-  return rb_cClass;
-}
-
-static VALUE constants_spec_rb_cData(VALUE self) {
-  return rb_cData;
-}
-
-static VALUE constants_spec_rb_cFalseClass(VALUE self) {
-  return rb_cFalseClass;
-}
-
-static VALUE constants_spec_rb_cFile(VALUE self) {
-  return rb_cFile;
-}
-
-static VALUE constants_spec_rb_cFloat(VALUE self) {
-  return rb_cFloat;
-}
-
-static VALUE constants_spec_rb_cHash(VALUE self) {
-  return rb_cHash;
-}
-
-static VALUE constants_spec_rb_cInteger(VALUE self) {
-  return rb_cInteger;
-}
-
-static VALUE constants_spec_rb_cIO(VALUE self) {
-  return rb_cIO;
-}
-
-static VALUE constants_spec_rb_cModule(VALUE self) {
-  return rb_cModule;
-}
-
-static VALUE constants_spec_rb_cMatch(VALUE self) {
-  return rb_cMatch;
-}
-
-static VALUE constants_spec_rb_cNilClass(VALUE self) {
-  return rb_cNilClass;
-}
-
-static VALUE constants_spec_rb_cNumeric(VALUE self) {
-  return rb_cNumeric;
-}
-
-static VALUE constants_spec_rb_cObject(VALUE self) {
-  return rb_cObject;
-}
-
-static VALUE constants_spec_rb_cRange(VALUE self) {
-  return rb_cRange;
-}
-
-static VALUE constants_spec_rb_cRegexp(VALUE self) {
-  return rb_cRegexp;
-}
-
-static VALUE constants_spec_rb_cString(VALUE self) {
-  return rb_cString;
-}
-
-static VALUE constants_spec_rb_cStruct(VALUE self) {
-  return rb_cStruct;
-}
-
-static VALUE constants_spec_rb_cSymbol(VALUE self) {
-  return rb_cSymbol;
-}
-
-static VALUE constants_spec_rb_cTime(VALUE self) {
-  return rb_cTime;
-}
-
-static VALUE constants_spec_rb_cThread(VALUE self) {
-  return rb_cThread;
-}
-
-static VALUE constants_spec_rb_cTrueClass(VALUE self) {
-  return rb_cTrueClass;
-}
-
-static VALUE constants_spec_rb_cProc(VALUE self) {
-  return rb_cProc;
-}
-
-static VALUE constants_spec_rb_cMethod(VALUE self) {
-  return rb_cMethod;
-}
-
-static VALUE constants_spec_rb_cEnumerator(VALUE self) {
-  return rb_cEnumerator;
-}
-
-static VALUE constants_spec_rb_mComparable(VALUE self) {
-  return rb_mComparable;
-}
-
-static VALUE constants_spec_rb_mEnumerable(VALUE self) {
-  return rb_mEnumerable;
-}
-
-static VALUE constants_spec_rb_mKernel(VALUE self) {
-  return rb_mKernel;
-}
-
-static VALUE constants_spec_rb_eArgError(VALUE self) {
-  return rb_eArgError;
-}
-
-static VALUE constants_spec_rb_eEOFError(VALUE self) {
-  return rb_eEOFError;
-}
-
-static VALUE constants_spec_rb_mErrno(VALUE self) {
-  return rb_mErrno;
-}
-
-static VALUE constants_spec_rb_eException(VALUE self) {
-  return rb_eException;
-}
-
-static VALUE constants_spec_rb_eFloatDomainError(VALUE self) {
-  return rb_eFloatDomainError;
-}
-
-static VALUE constants_spec_rb_eIndexError(VALUE self) {
-  return rb_eIndexError;
-}
-
-static VALUE constants_spec_rb_eInterrupt(VALUE self) {
-  return rb_eInterrupt;
-}
-
-static VALUE constants_spec_rb_eIOError(VALUE self) {
-  return rb_eIOError;
-}
-
-static VALUE constants_spec_rb_eLoadError(VALUE self) {
-  return rb_eLoadError;
-}
-
-static VALUE constants_spec_rb_eLocalJumpError(VALUE self) {
-  return rb_eLocalJumpError;
-}
-
-static VALUE constants_spec_rb_eNameError(VALUE self) {
-  return rb_eNameError;
-}
-
-static VALUE constants_spec_rb_eNoMemError(VALUE self) {
-  return rb_eNoMemError;
-}
-
-static VALUE constants_spec_rb_eNoMethodError(VALUE self) {
-  return rb_eNoMethodError;
-}
-
-static VALUE constants_spec_rb_eNotImpError(VALUE self) {
-  return rb_eNotImpError;
-}
-
-static VALUE constants_spec_rb_eRangeError(VALUE self) {
-  return rb_eRangeError;
-}
-
-static VALUE constants_spec_rb_eRegexpError(VALUE self) {
-  return rb_eRegexpError;
-}
-
-static VALUE constants_spec_rb_eRuntimeError(VALUE self) {
-  return rb_eRuntimeError;
-}
-
-static VALUE constants_spec_rb_eScriptError(VALUE self) {
-  return rb_eScriptError;
-}
-
-static VALUE constants_spec_rb_eSecurityError(VALUE self) {
-  return rb_eSecurityError;
-}
-
-static VALUE constants_spec_rb_eSignal(VALUE self) {
-  return rb_eSignal;
-}
-
-static VALUE constants_spec_rb_eStandardError(VALUE self) {
-  return rb_eStandardError;
-}
-
-static VALUE constants_spec_rb_eSyntaxError(VALUE self) {
-  return rb_eSyntaxError;
-}
-
-static VALUE constants_spec_rb_eSystemCallError(VALUE self) {
-  return rb_eSystemCallError;
-}
-
-static VALUE constants_spec_rb_eSystemExit(VALUE self) {
-  return rb_eSystemExit;
-}
-
-static VALUE constants_spec_rb_eSysStackError(VALUE self) {
-  return rb_eSysStackError;
-}
-
-static VALUE constants_spec_rb_eTypeError(VALUE self) {
-  return rb_eTypeError;
-}
-
-static VALUE constants_spec_rb_eThreadError(VALUE self) {
-  return rb_eThreadError;
-}
-
-static VALUE constants_spec_rb_eZeroDivError(VALUE self) {
-  return rb_eZeroDivError;
-}
-
-static VALUE constants_spec_rb_eMathDomainError(VALUE self) {
-  return rb_eMathDomainError;
-}
-
-static VALUE constants_spec_rb_eEncCompatError(VALUE self) {
-  return rb_eEncCompatError;
-}
-
-static VALUE constants_spec_rb_mWaitReadable(VALUE self) {
-  return rb_mWaitReadable;
-}
-
-static VALUE constants_spec_rb_mWaitWritable(VALUE self) {
-  return rb_mWaitWritable;
-}
-
-static VALUE constants_spec_rb_cDir(VALUE self) {
-  return rb_cDir;
-}
+#define defconstfunc(name) \
+static VALUE constants_spec_##name(VALUE self) { return name; }
+
+defconstfunc(rb_cArray)
+defconstfunc(rb_cBasicObject)
+defconstfunc(rb_cBinding)
+defconstfunc(rb_cClass)
+defconstfunc(rb_cComplex)
+defconstfunc(rb_mComparable)
+defconstfunc(rb_cData)
+defconstfunc(rb_cDir)
+defconstfunc(rb_cEncoding)
+defconstfunc(rb_mEnumerable)
+defconstfunc(rb_cEnumerator)
+defconstfunc(rb_cFalseClass)
+defconstfunc(rb_cFile)
+defconstfunc(rb_mFileTest)
+defconstfunc(rb_cFloat)
+defconstfunc(rb_mGC)
+defconstfunc(rb_cHash)
+defconstfunc(rb_cInteger)
+defconstfunc(rb_cIO)
+defconstfunc(rb_mKernel)
+defconstfunc(rb_mMath)
+defconstfunc(rb_cMatch)
+defconstfunc(rb_cMethod)
+defconstfunc(rb_cModule)
+defconstfunc(rb_cNilClass)
+defconstfunc(rb_cNumeric)
+defconstfunc(rb_cObject)
+defconstfunc(rb_cProc)
+defconstfunc(rb_mProcess)
+defconstfunc(rb_cRandom)
+defconstfunc(rb_cRange)
+defconstfunc(rb_cRational)
+defconstfunc(rb_cRegexp)
+defconstfunc(rb_cStat)
+defconstfunc(rb_cString)
+defconstfunc(rb_cStruct)
+defconstfunc(rb_cSymbol)
+defconstfunc(rb_cTime)
+defconstfunc(rb_cThread)
+defconstfunc(rb_cTrueClass)
+defconstfunc(rb_cUnboundMethod)
+defconstfunc(rb_eArgError)
+defconstfunc(rb_eEncodingError)
+defconstfunc(rb_eEncCompatError)
+defconstfunc(rb_eEOFError)
+defconstfunc(rb_mErrno)
+defconstfunc(rb_eException)
+defconstfunc(rb_eFatal)
+defconstfunc(rb_eFloatDomainError)
+#ifdef RUBY_VERSION_IS_2_5
+defconstfunc(rb_eFrozenError)
+#endif
+defconstfunc(rb_eIndexError)
+defconstfunc(rb_eInterrupt)
+defconstfunc(rb_eIOError)
+defconstfunc(rb_eKeyError)
+defconstfunc(rb_eLoadError)
+defconstfunc(rb_eLocalJumpError)
+defconstfunc(rb_eMathDomainError)
+defconstfunc(rb_eNameError)
+defconstfunc(rb_eNoMemError)
+defconstfunc(rb_eNoMethodError)
+defconstfunc(rb_eNotImpError)
+defconstfunc(rb_eRangeError)
+defconstfunc(rb_eRegexpError)
+defconstfunc(rb_eRuntimeError)
+defconstfunc(rb_eScriptError)
+defconstfunc(rb_eSecurityError)
+defconstfunc(rb_eSignal)
+defconstfunc(rb_eStandardError)
+defconstfunc(rb_eStopIteration)
+defconstfunc(rb_eSyntaxError)
+defconstfunc(rb_eSystemCallError)
+defconstfunc(rb_eSystemExit)
+defconstfunc(rb_eSysStackError)
+defconstfunc(rb_eTypeError)
+defconstfunc(rb_eThreadError)
+defconstfunc(rb_mWaitReadable)
+defconstfunc(rb_mWaitWritable)
+defconstfunc(rb_eZeroDivError)
 
 void Init_constants_spec(void) {
   VALUE cls = rb_define_class("CApiConstantsSpecs", rb_cObject);
   rb_define_method(cls, "rb_cArray", constants_spec_rb_cArray, 0);
-
+  rb_define_method(cls, "rb_cBasicObject", constants_spec_rb_cBasicObject, 0);
+  rb_define_method(cls, "rb_cBinding", constants_spec_rb_cBinding, 0);
   rb_define_method(cls, "rb_cClass", constants_spec_rb_cClass, 0);
+  rb_define_method(cls, "rb_cComplex", constants_spec_rb_cComplex, 0);
+  rb_define_method(cls, "rb_mComparable", constants_spec_rb_mComparable, 0);
   rb_define_method(cls, "rb_cData", constants_spec_rb_cData, 0);
+  rb_define_method(cls, "rb_cDir", constants_spec_rb_cDir, 0);
+  rb_define_method(cls, "rb_cEncoding", constants_spec_rb_cEncoding, 0);
+  rb_define_method(cls, "rb_mEnumerable", constants_spec_rb_mEnumerable, 0);
+  rb_define_method(cls, "rb_cEnumerator", constants_spec_rb_cEnumerator, 0);
   rb_define_method(cls, "rb_cFalseClass", constants_spec_rb_cFalseClass, 0);
   rb_define_method(cls, "rb_cFile", constants_spec_rb_cFile, 0);
-
+  rb_define_method(cls, "rb_mFileTest", constants_spec_rb_mFileTest, 0);
   rb_define_method(cls, "rb_cFloat", constants_spec_rb_cFloat, 0);
+  rb_define_method(cls, "rb_mGC", constants_spec_rb_mGC, 0);
   rb_define_method(cls, "rb_cHash", constants_spec_rb_cHash, 0);
   rb_define_method(cls, "rb_cInteger", constants_spec_rb_cInteger, 0);
   rb_define_method(cls, "rb_cIO", constants_spec_rb_cIO, 0);
+  rb_define_method(cls, "rb_mKernel", constants_spec_rb_mKernel, 0);
+  rb_define_method(cls, "rb_mMath", constants_spec_rb_mMath, 0);
   rb_define_method(cls, "rb_cMatch", constants_spec_rb_cMatch, 0);
+  rb_define_method(cls, "rb_cMethod", constants_spec_rb_cMethod, 0);
   rb_define_method(cls, "rb_cModule", constants_spec_rb_cModule, 0);
   rb_define_method(cls, "rb_cNilClass", constants_spec_rb_cNilClass, 0);
   rb_define_method(cls, "rb_cNumeric", constants_spec_rb_cNumeric, 0);
   rb_define_method(cls, "rb_cObject", constants_spec_rb_cObject, 0);
+  rb_define_method(cls, "rb_cProc", constants_spec_rb_cProc, 0);
+  rb_define_method(cls, "rb_mProcess", constants_spec_rb_mProcess, 0);
+  rb_define_method(cls, "rb_cRandom", constants_spec_rb_cRandom, 0);
   rb_define_method(cls, "rb_cRange", constants_spec_rb_cRange, 0);
+  rb_define_method(cls, "rb_cRational", constants_spec_rb_cRational, 0);
   rb_define_method(cls, "rb_cRegexp", constants_spec_rb_cRegexp, 0);
+  rb_define_method(cls, "rb_cStat", constants_spec_rb_cStat, 0);
   rb_define_method(cls, "rb_cString", constants_spec_rb_cString, 0);
   rb_define_method(cls, "rb_cStruct", constants_spec_rb_cStruct, 0);
   rb_define_method(cls, "rb_cSymbol", constants_spec_rb_cSymbol, 0);
   rb_define_method(cls, "rb_cTime", constants_spec_rb_cTime, 0);
   rb_define_method(cls, "rb_cThread", constants_spec_rb_cThread, 0);
   rb_define_method(cls, "rb_cTrueClass", constants_spec_rb_cTrueClass, 0);
-  rb_define_method(cls, "rb_cProc", constants_spec_rb_cProc, 0);
-  rb_define_method(cls, "rb_cMethod", constants_spec_rb_cMethod, 0);
-  rb_define_method(cls, "rb_cEnumerator", constants_spec_rb_cEnumerator, 0);
-  rb_define_method(cls, "rb_mComparable", constants_spec_rb_mComparable, 0);
-  rb_define_method(cls, "rb_mEnumerable", constants_spec_rb_mEnumerable, 0);
-  rb_define_method(cls, "rb_mKernel", constants_spec_rb_mKernel, 0);
+  rb_define_method(cls, "rb_cUnboundMethod", constants_spec_rb_cUnboundMethod, 0);
   rb_define_method(cls, "rb_eArgError", constants_spec_rb_eArgError, 0);
+  rb_define_method(cls, "rb_eEncodingError", constants_spec_rb_eEncodingError, 0);
+  rb_define_method(cls, "rb_eEncCompatError", constants_spec_rb_eEncCompatError, 0);
   rb_define_method(cls, "rb_eEOFError", constants_spec_rb_eEOFError, 0);
   rb_define_method(cls, "rb_mErrno", constants_spec_rb_mErrno, 0);
   rb_define_method(cls, "rb_eException", constants_spec_rb_eException, 0);
+  rb_define_method(cls, "rb_eFatal", constants_spec_rb_eFatal, 0);
   rb_define_method(cls, "rb_eFloatDomainError", constants_spec_rb_eFloatDomainError, 0);
+  #ifdef RUBY_VERSION_IS_2_5
+  rb_define_method(cls, "rb_eFrozenError", constants_spec_rb_eFrozenError, 0);
+  #endif
   rb_define_method(cls, "rb_eIndexError", constants_spec_rb_eIndexError, 0);
   rb_define_method(cls, "rb_eInterrupt", constants_spec_rb_eInterrupt, 0);
   rb_define_method(cls, "rb_eIOError", constants_spec_rb_eIOError, 0);
+  rb_define_method(cls, "rb_eKeyError", constants_spec_rb_eKeyError, 0);
   rb_define_method(cls, "rb_eLoadError", constants_spec_rb_eLoadError, 0);
   rb_define_method(cls, "rb_eLocalJumpError", constants_spec_rb_eLocalJumpError, 0);
+  rb_define_method(cls, "rb_eMathDomainError", constants_spec_rb_eMathDomainError, 0);
   rb_define_method(cls, "rb_eNameError", constants_spec_rb_eNameError, 0);
   rb_define_method(cls, "rb_eNoMemError", constants_spec_rb_eNoMemError, 0);
   rb_define_method(cls, "rb_eNoMethodError", constants_spec_rb_eNoMethodError, 0);
@@ -302,18 +161,16 @@ void Init_constants_spec(void) {
   rb_define_method(cls, "rb_eSecurityError", constants_spec_rb_eSecurityError, 0);
   rb_define_method(cls, "rb_eSignal", constants_spec_rb_eSignal, 0);
   rb_define_method(cls, "rb_eStandardError", constants_spec_rb_eStandardError, 0);
+  rb_define_method(cls, "rb_eStopIteration", constants_spec_rb_eStopIteration, 0);
   rb_define_method(cls, "rb_eSyntaxError", constants_spec_rb_eSyntaxError, 0);
   rb_define_method(cls, "rb_eSystemCallError", constants_spec_rb_eSystemCallError, 0);
   rb_define_method(cls, "rb_eSystemExit", constants_spec_rb_eSystemExit, 0);
   rb_define_method(cls, "rb_eSysStackError", constants_spec_rb_eSysStackError, 0);
   rb_define_method(cls, "rb_eTypeError", constants_spec_rb_eTypeError, 0);
   rb_define_method(cls, "rb_eThreadError", constants_spec_rb_eThreadError, 0);
-  rb_define_method(cls, "rb_eZeroDivError", constants_spec_rb_eZeroDivError, 0);
-  rb_define_method(cls, "rb_eMathDomainError", constants_spec_rb_eMathDomainError, 0);
-  rb_define_method(cls, "rb_eEncCompatError", constants_spec_rb_eEncCompatError, 0);
   rb_define_method(cls, "rb_mWaitReadable", constants_spec_rb_mWaitReadable, 0);
   rb_define_method(cls, "rb_mWaitWritable", constants_spec_rb_mWaitWritable, 0);
-  rb_define_method(cls, "rb_cDir", constants_spec_rb_cDir, 0);
+  rb_define_method(cls, "rb_eZeroDivError", constants_spec_rb_eZeroDivError, 0);
 }
 
 #ifdef __cplusplus
diff --git a/spec/ruby/optional/capi/ext/encoding_spec.c b/spec/ruby/optional/capi/ext/encoding_spec.c
index 52ed4fdb2e..6b3a8be01a 100644
--- a/spec/ruby/optional/capi/ext/encoding_spec.c
+++ b/spec/ruby/optional/capi/ext/encoding_spec.c
@@ -175,6 +175,21 @@ static VALUE encoding_spec_rb_to_encoding(VALUE self, VALUE obj) {
   return rb_str_new2(rb_to_encoding(obj)->name);
 }
 
+static rb_encoding** native_rb_encoding_pointer;
+
+static VALUE encoding_spec_rb_to_encoding_native_store(VALUE self, VALUE obj) {
+  rb_encoding* enc = rb_to_encoding(obj);
+  VALUE address = SIZET2NUM((size_t) native_rb_encoding_pointer);
+  *native_rb_encoding_pointer = enc;
+  return address;
+}
+
+static VALUE encoding_spec_rb_to_encoding_native_name(VALUE self, VALUE address) {
+  rb_encoding** ptr = (rb_encoding**) NUM2SIZET(address);
+  rb_encoding* enc = *ptr;
+  return rb_str_new2(enc->name);
+}
+
 static VALUE encoding_spec_rb_to_encoding_index(VALUE self, VALUE obj) {
   return INT2NUM(rb_to_encoding_index(obj));
 }
@@ -205,7 +220,10 @@ static VALUE encoding_spec_rb_enc_str_asciionly_p(VALUE self, VALUE str) {
 }
 
 void Init_encoding_spec(void) {
-  VALUE cls = rb_define_class("CApiEncodingSpecs", rb_cObject);
+  VALUE cls;
+  native_rb_encoding_pointer = (rb_encoding**) malloc(sizeof(rb_encoding*));
+
+  cls = rb_define_class("CApiEncodingSpecs", rb_cObject);
   rb_define_method(cls, "ENC_CODERANGE_ASCIIONLY",
                    encoding_spec_ENC_CODERANGE_ASCIIONLY, 1);
 
@@ -247,6 +265,8 @@ void Init_encoding_spec(void) {
   rb_define_method(cls, "ENCODING_SET", encoding_spec_ENCODING_SET, 2);
   rb_define_method(cls, "rb_enc_to_index", encoding_spec_rb_enc_to_index, 1);
   rb_define_method(cls, "rb_to_encoding", encoding_spec_rb_to_encoding, 1);
+  rb_define_method(cls, "rb_to_encoding_native_store", encoding_spec_rb_to_encoding_native_store, 1);
+  rb_define_method(cls, "rb_to_encoding_native_name", encoding_spec_rb_to_encoding_native_name, 1);
   rb_define_method(cls, "rb_to_encoding_index", encoding_spec_rb_to_encoding_index, 1);
   rb_define_method(cls, "rb_enc_nth", encoding_spec_rb_enc_nth, 2);
   rb_define_method(cls, "rb_enc_codepoint_len", encoding_spec_rb_enc_codepoint_len, 1);
diff --git a/spec/ruby/optional/capi/ext/float_spec.c b/spec/ruby/optional/capi/ext/float_spec.c
index 34be917965..3db05cef8c 100644
--- a/spec/ruby/optional/capi/ext/float_spec.c
+++ b/spec/ruby/optional/capi/ext/float_spec.c
@@ -25,12 +25,21 @@ static VALUE float_spec_RFLOAT_VALUE(VALUE self, VALUE float_h) {
   return rb_float_new(RFLOAT_VALUE(float_h));
 }
 
+static VALUE float_spec_RB_FLOAT_TYPE_P(VALUE self, VALUE val) {
+  if (RB_FLOAT_TYPE_P(val)) {
+    return Qtrue;
+  } else {
+    return Qfalse;
+  }
+}
+
 void Init_float_spec(void) {
   VALUE cls = rb_define_class("CApiFloatSpecs", rb_cObject);
   rb_define_method(cls, "new_zero", float_spec_new_zero, 0);
   rb_define_method(cls, "new_point_five", float_spec_new_point_five, 0);
   rb_define_method(cls, "rb_Float", float_spec_rb_Float, 1);
   rb_define_method(cls, "RFLOAT_VALUE", float_spec_RFLOAT_VALUE, 1);
+  rb_define_method(cls, "RB_FLOAT_TYPE_P", float_spec_RB_FLOAT_TYPE_P, 1);
 }
 
 #ifdef __cplusplus
diff --git a/spec/ruby/optional/capi/ext/gc_spec.c b/spec/ruby/optional/capi/ext/gc_spec.c
index 4611617c18..7dc9c347c7 100644
--- a/spec/ruby/optional/capi/ext/gc_spec.c
+++ b/spec/ruby/optional/capi/ext/gc_spec.c
@@ -29,6 +29,10 @@ static VALUE gc_spec_rb_gc(VALUE self) {
   return Qnil;
 }
 
+static VALUE gc_spec_rb_gc_latest_gc_info(VALUE self, VALUE hash_or_key){
+  return rb_gc_latest_gc_info(hash_or_key);
+}
+
 static VALUE gc_spec_rb_gc_adjust_memory_usage(VALUE self, VALUE diff) {
   rb_gc_adjust_memory_usage(NUM2SSIZET(diff));
   return Qnil;
@@ -54,6 +58,7 @@ void Init_gc_spec(void) {
   rb_define_method(cls, "rb_gc", gc_spec_rb_gc, 0);
   rb_define_method(cls, "rb_gc_adjust_memory_usage", gc_spec_rb_gc_adjust_memory_usage, 1);
   rb_define_method(cls, "rb_gc_register_mark_object", gc_spec_rb_gc_register_mark_object, 1);
+  rb_define_method(cls, "rb_gc_latest_gc_info", gc_spec_rb_gc_latest_gc_info, 1);
 }
 
 #ifdef __cplusplus
diff --git a/spec/ruby/optional/capi/ext/globals_spec.c b/spec/ruby/optional/capi/ext/globals_spec.c
index 75860d3774..28a9633f98 100644
--- a/spec/ruby/optional/capi/ext/globals_spec.c
+++ b/spec/ruby/optional/capi/ext/globals_spec.c
@@ -68,6 +68,10 @@ static VALUE global_spec_rb_defout(VALUE self) {
   return rb_defout;
 }
 
+static VALUE global_spec_rb_fs(VALUE self) {
+  return rb_fs;
+}
+
 static VALUE global_spec_rb_rs(VALUE self) {
   return rb_rs;
 }
@@ -109,6 +113,7 @@ void Init_globals_spec(void) {
   rb_define_method(cls, "rb_stdout", global_spec_rb_stdout, 0);
   rb_define_method(cls, "rb_stderr", global_spec_rb_stderr, 0);
   rb_define_method(cls, "rb_defout", global_spec_rb_defout, 0);
+  rb_define_method(cls, "rb_fs", global_spec_rb_fs, 0);
   rb_define_method(cls, "rb_rs", global_spec_rb_rs, 0);
   rb_define_method(cls, "rb_default_rs", global_spec_rb_default_rs, 0);
   rb_define_method(cls, "rb_output_rs", global_spec_rb_output_rs, 0);
diff --git a/spec/ruby/optional/capi/ext/kernel_spec.c b/spec/ruby/optional/capi/ext/kernel_spec.c
index 13d9598125..351a68e7f0 100644
--- a/spec/ruby/optional/capi/ext/kernel_spec.c
+++ b/spec/ruby/optional/capi/ext/kernel_spec.c
@@ -180,6 +180,21 @@ VALUE kernel_spec_rb_rescue2(int argc, VALUE *args, VALUE self) {
       kernel_spec_call_proc_raise, raise_array, args[4], args[5], (VALUE)0);
 }
 
+VALUE kernel_spec_rb_rescue2_wrong_terminator_arg_type(int argc, VALUE *args, VALUE self) {
+  VALUE main_array, raise_array;
+
+  main_array = rb_ary_new();
+  rb_ary_push(main_array, args[0]);
+  rb_ary_push(main_array, args[1]);
+
+  raise_array = rb_ary_new();
+  rb_ary_push(raise_array, args[2]);
+  rb_ary_push(raise_array, args[3]);
+
+  return rb_rescue2(kernel_spec_call_proc, main_array,
+      kernel_spec_call_proc_raise, raise_array, args[4], args[5], 0);
+}
+
 static VALUE kernel_spec_rb_protect_yield(VALUE self, VALUE obj, VALUE ary) {
   int status = 0;
   VALUE res = rb_protect(rb_yield, obj, &status);
@@ -191,6 +206,10 @@ static VALUE kernel_spec_rb_protect_yield(VALUE self, VALUE obj, VALUE ary) {
   return res;
 }
 
+static VALUE kernel_spec_rb_protect_null_status(VALUE self, VALUE obj) {
+  return rb_protect(rb_yield, obj, NULL);
+}
+
 static VALUE kernel_spec_rb_eval_string_protect(VALUE self, VALUE str, VALUE ary) {
   int status = 0;
   VALUE res = rb_eval_string_protect(RSTRING_PTR(str), &status);
@@ -281,7 +300,7 @@ static VALUE kernel_spec_rb_exec_recursive(VALUE self, VALUE obj) {
 }
 
 static void write_io(VALUE io) {
-  rb_funcall(io, rb_intern("write"), 1, rb_str_new2("e"));
+  rb_funcall(io, rb_intern("write"), 1, rb_str_new2("in write_io"));
 }
 
 static VALUE kernel_spec_rb_set_end_proc(VALUE self, VALUE io) {
@@ -335,7 +354,9 @@ void Init_kernel_spec(void) {
   rb_define_method(cls, "rb_throw_obj", kernel_spec_rb_throw_obj, 2);
   rb_define_method(cls, "rb_rescue", kernel_spec_rb_rescue, 4);
   rb_define_method(cls, "rb_rescue2", kernel_spec_rb_rescue2, -1);
+  rb_define_method(cls, "rb_rescue2_wrong_arg_type", kernel_spec_rb_rescue2_wrong_terminator_arg_type, -1);
   rb_define_method(cls, "rb_protect_yield", kernel_spec_rb_protect_yield, 2);
+  rb_define_method(cls, "rb_protect_null_status", kernel_spec_rb_protect_null_status, 1);
   rb_define_method(cls, "rb_eval_string_protect", kernel_spec_rb_eval_string_protect, 2);
   rb_define_method(cls, "rb_catch", kernel_spec_rb_catch, 2);
   rb_define_method(cls, "rb_catch_obj", kernel_spec_rb_catch_obj, 2);
diff --git a/spec/ruby/optional/capi/ext/language_spec.c b/spec/ruby/optional/capi/ext/language_spec.c
index 5aeac63f53..749c188956 100644
--- a/spec/ruby/optional/capi/ext/language_spec.c
+++ b/spec/ruby/optional/capi/ext/language_spec.c
@@ -24,9 +24,17 @@ static VALUE language_spec_switch(VALUE self, VALUE value) {
   }
 }
 
+/* Defining a local variable rb_mProcess which already exists as a global variable
+ * For instance eventmachine does this in Init_rubyeventmachine() */
+static VALUE language_spec_global_local_var(VALUE self) {
+  VALUE rb_mProcess = rb_const_get(rb_cObject, rb_intern("Process"));
+  return rb_mProcess;
+}
+
 void Init_language_spec(void) {
   VALUE cls = rb_define_class("CApiLanguageSpecs", rb_cObject);
   rb_define_method(cls, "switch", language_spec_switch, 1);
+  rb_define_method(cls, "global_local_var", language_spec_global_local_var, 0);
 }
 
 #ifdef __cplusplus
diff --git a/spec/ruby/optional/capi/ext/object_spec.c b/spec/ruby/optional/capi/ext/object_spec.c
index c95e1b553f..477105aacc 100644
--- a/spec/ruby/optional/capi/ext/object_spec.c
+++ b/spec/ruby/optional/capi/ext/object_spec.c
@@ -348,9 +348,9 @@ static VALUE object_spec_rb_class_inherited_p(VALUE self, VALUE mod, VALUE arg)
 static VALUE speced_allocator(VALUE klass) {
   VALUE flags = 0;
   VALUE instance;
-  if (rb_class_inherited_p(klass, rb_cString)) {
+  if (RTEST(rb_class_inherited_p(klass, rb_cString))) {
     flags = T_STRING;
-  } else if (rb_class_inherited_p(klass, rb_cArray)) {
+  } else if (RTEST(rb_class_inherited_p(klass, rb_cArray))) {
     flags = T_ARRAY;
   } else {
     flags = T_OBJECT;
diff --git a/spec/ruby/optional/capi/ext/rubyspec.h b/spec/ruby/optional/capi/ext/rubyspec.h
index cce3af22f2..32724b1667 100644
--- a/spec/ruby/optional/capi/ext/rubyspec.h
+++ b/spec/ruby/optional/capi/ext/rubyspec.h
@@ -31,6 +31,10 @@
 #define RUBY_VERSION_IS_2_6
 #endif
 
+#if RUBY_VERSION_MAJOR > 2 || (RUBY_VERSION_MAJOR == 2 && RUBY_VERSION_MINOR >= 5)
+#define RUBY_VERSION_IS_2_5
+#endif
+
 #if RUBY_VERSION_MAJOR > 2 || (RUBY_VERSION_MAJOR == 2 && RUBY_VERSION_MINOR >= 4)
 #define RUBY_VERSION_IS_2_4
 #endif
diff --git a/spec/ruby/optional/capi/ext/string_spec.c b/spec/ruby/optional/capi/ext/string_spec.c
index 74ff2d6503..cef0e872bb 100644
--- a/spec/ruby/optional/capi/ext/string_spec.c
+++ b/spec/ruby/optional/capi/ext/string_spec.c
@@ -69,6 +69,16 @@ VALUE string_spec_rb_str_buf_new2(VALUE self) {
   return rb_str_buf_new2("hello\0invisible");
 }
 
+VALUE string_spec_rb_str_tmp_new(VALUE self, VALUE len) {
+  VALUE str = rb_str_tmp_new(NUM2LONG(len));
+  rb_obj_reveal(str, rb_cString);
+  return str;
+}
+
+VALUE string_spec_rb_str_tmp_new_klass(VALUE self, VALUE len) {
+  return RBASIC_CLASS(rb_str_tmp_new(NUM2LONG(len)));
+}
+
 VALUE string_spec_rb_str_buf_cat(VALUE self, VALUE str) {
   const char *question_mark = "?";
   rb_str_buf_cat(str, question_mark, strlen(question_mark));
@@ -296,7 +306,7 @@ VALUE string_spec_RSTRING_PTR_iterate_uint32(VALUE self, VALUE str) {
 }
 
 VALUE string_spec_RSTRING_PTR_short_memcpy(VALUE self, VALUE str) {
-  // Short memcpy operations may be optimised by the compiler to a single write.
+  /* Short memcpy operations may be optimised by the compiler to a single write. */
   if (RSTRING_LEN(str) >= 8) {
     memcpy(RSTRING_PTR(str), "Infinity", 8);
   }
@@ -451,6 +461,8 @@ void Init_string_spec(void) {
   rb_define_method(cls, "rb_str_buf_new", string_spec_rb_str_buf_new, 2);
   rb_define_method(cls, "rb_str_capacity", string_spec_rb_str_capacity, 1);
   rb_define_method(cls, "rb_str_buf_new2", string_spec_rb_str_buf_new2, 0);
+  rb_define_method(cls, "rb_str_tmp_new", string_spec_rb_str_tmp_new, 1);
+  rb_define_method(cls, "rb_str_tmp_new_klass", string_spec_rb_str_tmp_new_klass, 1);
   rb_define_method(cls, "rb_str_buf_cat", string_spec_rb_str_buf_cat, 1);
   rb_define_method(cls, "rb_str_cat", string_spec_rb_str_cat, 1);
   rb_define_method(cls, "rb_str_cat2", string_spec_rb_str_cat2, 1);
diff --git a/spec/ruby/optional/capi/float_spec.rb b/spec/ruby/optional/capi/float_spec.rb
index 8381945315..4b98902b59 100644
--- a/spec/ruby/optional/capi/float_spec.rb
+++ b/spec/ruby/optional/capi/float_spec.rb
@@ -27,4 +27,17 @@ describe "CApiFloatSpecs" do
       f.should eql(101.99)
     end
   end
+
+  describe "RB_FLOAT_TYPE_P" do
+    it "returns true for floats" do
+      @f.RB_FLOAT_TYPE_P(2.0).should == true
+    end
+
+    it "returns false for non-floats" do
+      @f.RB_FLOAT_TYPE_P(nil).should == false
+      @f.RB_FLOAT_TYPE_P(10).should == false
+      @f.RB_FLOAT_TYPE_P("string").should == false
+      @f.RB_FLOAT_TYPE_P(Object.new).should == false
+    end
+  end
 end
diff --git a/spec/ruby/optional/capi/gc_spec.rb b/spec/ruby/optional/capi/gc_spec.rb
index 528dd291ba..23e2b7c9ab 100644
--- a/spec/ruby/optional/capi/gc_spec.rb
+++ b/spec/ruby/optional/capi/gc_spec.rb
@@ -64,4 +64,24 @@ describe "CApiGCSpecs" do
       @f.rb_gc_register_mark_object(Object.new).should be_nil
     end
   end
+
+  describe "rb_gc_latest_gc_info" do
+    it "raises a TypeError when hash or symbol not given" do
+      -> { @f.rb_gc_latest_gc_info("foo") }.should raise_error(TypeError)
+    end
+
+    it "raises an ArgumentError when unknown symbol given" do
+      -> { @f.rb_gc_latest_gc_info(:unknown) }.should raise_error(ArgumentError)
+    end
+
+    it "returns the populated hash when a hash is given" do
+      h = {}
+      @f.rb_gc_latest_gc_info(h).should == h
+      h.size.should_not == 0
+    end
+
+    it "returns a value when symbol is given" do
+      @f.rb_gc_latest_gc_info(:state).should be_kind_of(Symbol)
+    end
+  end
 end
diff --git a/spec/ruby/optional/capi/globals_spec.rb b/spec/ruby/optional/capi/globals_spec.rb
index 1e8ab0938f..cc6f6ef3a8 100644
--- a/spec/ruby/optional/capi/globals_spec.rb
+++ b/spec/ruby/optional/capi/globals_spec.rb
@@ -53,13 +53,32 @@ describe "CApiGlobalSpecs" do
     $hooked_gvar.should == 4
   end
 
+  describe "rb_fs" do
+    before :each do
+      @field_separator = $;
+    end
+
+    after :each do
+      suppress_warning { $; = @field_separator }
+    end
+
+    it "returns nil by default" do
+      @f.rb_fs.should == nil
+    end
+
+    it "returns the value of $;" do
+      suppress_warning { $; = "foo" }
+      @f.rb_fs.should == "foo"
+    end
+  end
+
   describe "rb_rs" do
     before :each do
       @dollar_slash = $/
     end
 
     after :each do
-      suppress_warning {$/ = @dollar_slash}
+      suppress_warning { $/ = @dollar_slash }
     end
 
     it "returns \\n by default" do
@@ -67,7 +86,7 @@ describe "CApiGlobalSpecs" do
     end
 
     it "returns the value of $/" do
-      suppress_warning {$/ = "foo"}
+      suppress_warning { $/ = "foo" }
       @f.rb_rs.should == "foo"
     end
   end
@@ -121,7 +140,7 @@ describe "CApiGlobalSpecs" do
         $stdout = STDOUT
       end
 
-      it "returns $stdout" do
+      it "is an alias of rb_stdout" do
         $stdout = @stream
         @f.rb_defout.should equal($stdout)
       end
diff --git a/spec/ruby/optional/capi/kernel_spec.rb b/spec/ruby/optional/capi/kernel_spec.rb
index 5c272947ab..7795baacb6 100644
--- a/spec/ruby/optional/capi/kernel_spec.rb
+++ b/spec/ruby/optional/capi/kernel_spec.rb
@@ -1,6 +1,6 @@
 require_relative 'spec_helper'
 
-load_extension("kernel")
+kernel_path = load_extension("kernel")
 
 describe "C-API Kernel function" do
   before :each do
@@ -295,6 +295,11 @@ describe "C-API Kernel function" do
       proof[0].should == 23
       proof[1].should == nil
     end
+
+    it "accepts NULL as status and returns nil if it failed" do
+      @s.rb_protect_null_status(42) { |x| x + 1 }.should == 43
+      @s.rb_protect_null_status(42) { |x| raise }.should == nil
+    end
   end
 
   describe "rb_eval_string_protect" do
@@ -386,6 +391,18 @@ describe "C-API Kernel function" do
         @s.rb_rescue2(type_error_proc, :no_exc, proc, :exc, ArgumentError, RuntimeError)
       }.should raise_error(TypeError)
     end
+
+    it "works when the terminating argument has not been sizes as a VALUE" do
+      proc = -> x { x }
+      arg_error_proc = -> *_ { raise ArgumentError, '' }
+      run_error_proc = -> *_ { raise RuntimeError, '' }
+      type_error_proc = -> *_ { raise TypeError, '' }
+      @s.rb_rescue2_wrong_arg_type(arg_error_proc, :no_exc, proc, :exc, ArgumentError, RuntimeError).should == :exc
+      @s.rb_rescue2_wrong_arg_type(run_error_proc, :no_exc, proc, :exc, ArgumentError, RuntimeError).should == :exc
+      -> {
+        @s.rb_rescue2_wrong_arg_type(type_error_proc, :no_exc, proc, :exc, ArgumentError, RuntimeError)
+      }.should raise_error(TypeError)
+    end
   end
 
   describe "rb_catch" do
@@ -514,25 +531,9 @@ describe "C-API Kernel function" do
     end
   end
 
-  platform_is_not :windows do
-    describe "rb_set_end_proc" do
-      before :each do
-        @r, @w = IO.pipe
-      end
-
-      after :each do
-        @r.close
-        @w.close
-        Process.wait @pid
-      end
-
-      it "runs a C function on shutdown" do
-        @pid = fork {
-          @s.rb_set_end_proc(@w)
-        }
-
-        @r.read(1).should == "e"
-      end
+  describe "rb_set_end_proc" do
+    it "runs a C function on shutdown" do
+      ruby_exe("require #{kernel_path.inspect}; CApiKernelSpecs.new.rb_set_end_proc(STDOUT)").should == "in write_io"
     end
   end
 
@@ -592,7 +593,7 @@ describe "C-API Kernel function" do
       end
     end
 
-    it "can call a public method with 10 arguments" do
+    it "can call a public method with 15 arguments" do
       @s.rb_funcall_many_args(@obj, :many_args).should == 15.downto(1).to_a
     end
   end
diff --git a/spec/ruby/optional/capi/language_spec.rb b/spec/ruby/optional/capi/language_spec.rb
index 7605332fbd..f59b87f2a1 100644
--- a/spec/ruby/optional/capi/language_spec.rb
+++ b/spec/ruby/optional/capi/language_spec.rb
@@ -28,4 +28,10 @@ describe "C language construct" do
       @s.switch(Object.new).should == :default
     end
   end
+
+  describe "local variable assignment with the same name as a global" do
+    it "works for rb_mProcess" do
+      @s.global_local_var.should.equal?(Process)
+    end
+  end
 end
diff --git a/spec/ruby/optional/capi/spec_helper.rb b/spec/ruby/optional/capi/spec_helper.rb
index 30e6196d05..74a6325fe0 100644
--- a/spec/ruby/optional/capi/spec_helper.rb
+++ b/spec/ruby/optional/capi/spec_helper.rb
@@ -127,7 +127,9 @@ def setup_make
 end
 
 def load_extension(name)
-  require compile_extension(name)
+  ext_path = compile_extension(name)
+  require ext_path
+  ext_path
 rescue LoadError => e
   if %r{/usr/sbin/execerror ruby "\(ld 3 1 main ([/a-zA-Z0-9_\-.]+_spec\.so)"} =~ e.message
     system('/usr/sbin/execerror', "#{RbConfig::CONFIG["bindir"]}/ruby", "(ld 3 1 main #{$1}")
diff --git a/spec/ruby/optional/capi/string_spec.rb b/spec/ruby/optional/capi/string_spec.rb
index 243765cdbe..224d63f886 100644
--- a/spec/ruby/optional/capi/string_spec.rb
+++ b/spec/ruby/optional/capi/string_spec.rb
@@ -158,6 +158,20 @@ describe "C-API String function" do
     end
   end
 
+  describe "rb_str_tmp_new" do
+    it "returns a hidden string (RBasic->klass is NULL)" do
+      @s.rb_str_tmp_new_klass(4).should == false
+    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"
+    end
+  end
+
   describe "rb_str_new" do
     it "creates a new String with BINARY Encoding" do
       @s.rb_str_new("", 0).encoding.should == Encoding::BINARY