rice 3.0.0 → 4.0.0

data/test/test_String.cpp

@@ -1,7 +1,6 @@
 #include "unittest.hpp"
 #include "embed_ruby.hpp"
-#include "rice/String.hpp"
-#include "rice/global_function.hpp"
+#include <rice/rice.hpp>
 
 using namespace Rice;
 

data/test/test_Struct.cpp

@@ -1,8 +1,6 @@
 #include "unittest.hpp"
 #include "embed_ruby.hpp"
-#include "rice/Struct.hpp"
-#include "rice/Symbol.hpp"
-#include "rice/global_function.hpp"
+#include <rice/rice.hpp>
 
 using namespace Rice;
 
@@ -54,14 +52,6 @@ TESTCASE(copy_construct)
   ASSERT_EQUAL("z", Symbol(members[2]).c_str());
 }
 
-TESTCASE(offset_of)
-{
-  Struct s(define_3d_point());
-  ASSERT_EQUAL(0, s.offset_of("x"));
-  ASSERT_EQUAL(1, s.offset_of("y"));
-  ASSERT_EQUAL(2, s.offset_of("z"));
-}
-
 TESTCASE(new_instance_no_args)
 {
   Struct s(define_3d_point());
@@ -77,12 +67,12 @@ TESTCASE(new_instance_with_args)
   Array args(a);
   Struct s(define_3d_point());
   Struct::Instance p(s.new_instance(args));
-  ASSERT_EQUAL(to_ruby(1), Object(rb_struct_getmember(p, rb_intern("x"))));
-  ASSERT_EQUAL(to_ruby(2), Object(rb_struct_getmember(p, rb_intern("y"))));
-  ASSERT_EQUAL(to_ruby(3), Object(rb_struct_getmember(p, rb_intern("z"))));
+  ASSERT_EQUAL(detail::to_ruby(1), rb_struct_getmember(p, rb_intern("x")));
+  ASSERT_EQUAL(detail::to_ruby(2), rb_struct_getmember(p, rb_intern("y")));
+  ASSERT_EQUAL(detail::to_ruby(3), rb_struct_getmember(p, rb_intern("z")));
 }
 
-TESTCASE(swap)
+/*TESTCASE(swap)
 {
   Struct s(define_3d_point());
   Struct s2;
@@ -103,7 +93,7 @@ TESTCASE(swap)
   }
 
   s2.swap(s);
-}
+}*/
 
 TESTCASE(members)
 {
@@ -121,9 +111,9 @@ TESTCASE(construct_instance)
   Array args(a);
   Struct s(define_3d_point());
   Struct::Instance p(s, args);
-  ASSERT_EQUAL(to_ruby(1), Object(rb_struct_getmember(p, rb_intern("x"))));
-  ASSERT_EQUAL(to_ruby(2), Object(rb_struct_getmember(p, rb_intern("y"))));
-  ASSERT_EQUAL(to_ruby(3), Object(rb_struct_getmember(p, rb_intern("z"))));
+  ASSERT_EQUAL(detail::to_ruby(1), rb_struct_getmember(p, rb_intern("x")));
+  ASSERT_EQUAL(detail::to_ruby(2), rb_struct_getmember(p, rb_intern("y")));
+  ASSERT_EQUAL(detail::to_ruby(3), rb_struct_getmember(p, rb_intern("z")));
 }
 
 TESTCASE(wrap_instance)
@@ -131,9 +121,9 @@ TESTCASE(wrap_instance)
   Struct s(define_3d_point());
   Object o = s.instance_eval("new(1, 2, 3)");
   Struct::Instance p(s, o);
-  ASSERT_EQUAL(to_ruby(1), Object(rb_struct_getmember(p, rb_intern("x"))));
-  ASSERT_EQUAL(to_ruby(2), Object(rb_struct_getmember(p, rb_intern("y"))));
-  ASSERT_EQUAL(to_ruby(3), Object(rb_struct_getmember(p, rb_intern("z"))));
+  ASSERT_EQUAL(detail::to_ruby(1), rb_struct_getmember(p, rb_intern("x")));
+  ASSERT_EQUAL(detail::to_ruby(2), rb_struct_getmember(p, rb_intern("y")));
+  ASSERT_EQUAL(detail::to_ruby(3), rb_struct_getmember(p, rb_intern("z")));
 }
 
 TESTCASE(instance_bracket_identifier)
@@ -142,9 +132,9 @@ TESTCASE(instance_bracket_identifier)
   Array args(a);
   Struct s(define_3d_point());
   Struct::Instance p(s, args);
-  ASSERT_EQUAL(to_ruby(1), p[Identifier("x")]);
-  ASSERT_EQUAL(to_ruby(2), p[Identifier("y")]);
-  ASSERT_EQUAL(to_ruby(3), p[Identifier("z")]);
+  ASSERT_EQUAL(detail::to_ruby(1), p[Identifier("x")].value());
+  ASSERT_EQUAL(detail::to_ruby(2), p[Identifier("y")].value());
+  ASSERT_EQUAL(detail::to_ruby(3), p[Identifier("z")].value());
 }
 
 TESTCASE(instance_bracket_name)
@@ -153,9 +143,9 @@ TESTCASE(instance_bracket_name)
   Array args(a);
   Struct s(define_3d_point());
   Struct::Instance p(s, args);
-  ASSERT_EQUAL(to_ruby(1), p["x"]);
-  ASSERT_EQUAL(to_ruby(2), p["y"]);
-  ASSERT_EQUAL(to_ruby(3), p["z"]);
+  ASSERT_EQUAL(detail::to_ruby(1), p["x"].value());
+  ASSERT_EQUAL(detail::to_ruby(2), p["y"].value());
+  ASSERT_EQUAL(detail::to_ruby(3), p["z"].value());
 }
 
 TESTCASE(instance_bracket_index)
@@ -164,12 +154,12 @@ TESTCASE(instance_bracket_index)
   Array args(a);
   Struct s(define_3d_point());
   Struct::Instance p(s, args);
-  ASSERT_EQUAL(to_ruby(1), p[0]);
-  ASSERT_EQUAL(to_ruby(2), p[1]);
-  ASSERT_EQUAL(to_ruby(3), p[2]);
+  ASSERT_EQUAL(detail::to_ruby(1), p[0].value());
+  ASSERT_EQUAL(detail::to_ruby(2), p[1].value());
+  ASSERT_EQUAL(detail::to_ruby(3), p[2].value());
 }
 
-TESTCASE(instance_swap)
+/*TESTCASE(instance_swap)
 {
   Struct s(define_3d_point());
 
@@ -183,14 +173,14 @@ TESTCASE(instance_swap)
 
   p1.swap(p2);
 
-  ASSERT_EQUAL(to_ruby(4), Object(rb_struct_getmember(p1, rb_intern("x"))));
-  ASSERT_EQUAL(to_ruby(5), Object(rb_struct_getmember(p1, rb_intern("y"))));
-  ASSERT_EQUAL(to_ruby(6), Object(rb_struct_getmember(p1, rb_intern("z"))));
+  ASSERT_EQUAL(detail::to_ruby(4), rb_struct_getmember(p1, rb_intern("x")));
+  ASSERT_EQUAL(detail::to_ruby(5), rb_struct_getmember(p1, rb_intern("y")));
+  ASSERT_EQUAL(detail::to_ruby(6), rb_struct_getmember(p1, rb_intern("z")));
 
-  ASSERT_EQUAL(to_ruby(1), Object(rb_struct_getmember(p2, rb_intern("x"))));
-  ASSERT_EQUAL(to_ruby(2), Object(rb_struct_getmember(p2, rb_intern("y"))));
-  ASSERT_EQUAL(to_ruby(3), Object(rb_struct_getmember(p2, rb_intern("z"))));
-}
+  ASSERT_EQUAL(detail::to_ruby(1), rb_struct_getmember(p2, rb_intern("x")));
+  ASSERT_EQUAL(detail::to_ruby(2), rb_struct_getmember(p2, rb_intern("y")));
+  ASSERT_EQUAL(detail::to_ruby(3), rb_struct_getmember(p2, rb_intern("z")));
+}*/
 
 /**
  * Issue 59 - Copy constructor compilation problem.

data/test/test_Symbol.cpp

@@ -1,7 +1,6 @@
 #include "unittest.hpp"
 #include "embed_ruby.hpp"
-#include "rice/Symbol.hpp"
-#include "rice/Identifier.hpp"
+#include <rice/rice.hpp>
 
 using namespace Rice;
 

data/test/test_To_From_Ruby.cpp

@@ -1,9 +1,7 @@
 #include "unittest.hpp"
 #include "embed_ruby.hpp"
-#include "rice/to_from_ruby.hpp"
-#include "rice/String.hpp"
-#include "rice/Array.hpp"
-#include "rice/Hash.hpp"
+#include <rice/rice.hpp>
+
 #include <limits>
 #include <cmath>
 
@@ -19,411 +17,377 @@ SETUP(To_From_Ruby)
 TESTCASE(object_to_ruby)
 {
   Object o(rb_str_new2("foo"));
-  ASSERT_EQUAL(o.value(), to_ruby(o).value());
+  ASSERT_EQUAL(o.value(), detail::to_ruby(o));
 }
 
 TESTCASE(object_from_ruby)
 {
   Object o(rb_str_new2("foo"));
-  ASSERT_EQUAL(o.value(), from_ruby<Object>(o).value());
+  ASSERT_EQUAL(o, detail::From_Ruby<Object>().convert(o));
 }
 
 TESTCASE(short_to_ruby)
 {
-  ASSERT_EQUAL(INT2NUM(0), to_ruby((short)0).value());
-  ASSERT_EQUAL(INT2NUM(-1), to_ruby((short)-1).value());
-  ASSERT_EQUAL(INT2NUM(1), to_ruby((short)1).value());
-  ASSERT_EQUAL(
-      Object(INT2NUM(std::numeric_limits<short>::min())),
-      to_ruby(std::numeric_limits<short>::min()));
-  ASSERT_EQUAL(
-      Object(INT2NUM(std::numeric_limits<short>::max())),
-      to_ruby(std::numeric_limits<short>::max()));
+  ASSERT_EQUAL(INT2NUM(0), detail::to_ruby((short)0));
+  ASSERT_EQUAL(INT2NUM(-1), detail::to_ruby((short)-1));
+  ASSERT_EQUAL(INT2NUM(1), detail::to_ruby((short)1));
+  ASSERT_EQUAL(INT2NUM(std::numeric_limits<short>::min()),
+               detail::to_ruby(std::numeric_limits<short>::min()));
+  ASSERT_EQUAL(INT2NUM(std::numeric_limits<short>::max()),
+               detail::to_ruby(std::numeric_limits<short>::max()));
 }
 
 TESTCASE(short_from_ruby)
 {
-  ASSERT_EQUAL(0, from_ruby<short>(INT2NUM(0)));
-  ASSERT_EQUAL(-1, from_ruby<short>(INT2NUM(-1)));
-  ASSERT_EQUAL(1, from_ruby<short>(INT2NUM(1)));
-  ASSERT_EQUAL(
-      std::numeric_limits<short>::min(),
-      from_ruby<short>(INT2NUM(std::numeric_limits<short>::min())));
-  ASSERT_EQUAL(
-      std::numeric_limits<short>::max(),
-      from_ruby<short>(INT2NUM(std::numeric_limits<short>::max())));
+  ASSERT_EQUAL(0, detail::From_Ruby<short>().convert(INT2NUM(0)));
+  ASSERT_EQUAL(-1, detail::From_Ruby<short>().convert(INT2NUM(-1)));
+  ASSERT_EQUAL(1, detail::From_Ruby<short>().convert(INT2NUM(1)));
+  ASSERT_EQUAL(std::numeric_limits<short>::min(),
+               detail::From_Ruby<short>().convert(INT2NUM(std::numeric_limits<short>::min())));
+  ASSERT_EQUAL(std::numeric_limits<short>::max(),
+               detail::From_Ruby<short>().convert(INT2NUM(std::numeric_limits<short>::max())));
+
+  ASSERT_EXCEPTION_CHECK(
+    Exception,
+    detail::From_Ruby<short>().convert(rb_str_new2("bad value")),
+    ASSERT_EQUAL("no implicit conversion of String into Integer", ex.what())
+  );
 }
 
 TESTCASE(int_to_ruby)
 {
-  ASSERT_EQUAL(INT2NUM(0), to_ruby((int)0).value());
-  ASSERT_EQUAL(INT2NUM(-1), to_ruby((int)-1).value());
-  ASSERT_EQUAL(INT2NUM(1), to_ruby((int)1).value());
-  ASSERT_EQUAL(
-      Object(INT2NUM(std::numeric_limits<int>::min())),
-      to_ruby(std::numeric_limits<int>::min()));
-  ASSERT_EQUAL(
-      Object(INT2NUM(std::numeric_limits<int>::max())),
-      to_ruby(std::numeric_limits<int>::max()));
+  ASSERT(rb_equal(INT2NUM(0), detail::to_ruby((int)0)));
+  ASSERT(rb_equal(INT2NUM(-1), detail::to_ruby((int)-1)));
+  ASSERT(rb_equal(INT2NUM(1), detail::to_ruby((int)1)));
+  ASSERT(rb_equal(INT2NUM(std::numeric_limits<int>::min()), detail::to_ruby(std::numeric_limits<int>::min())));
+  ASSERT(rb_equal(INT2NUM(std::numeric_limits<int>::max()), detail::to_ruby(std::numeric_limits<int>::max())));
 }
 
 TESTCASE(int_from_ruby)
 {
-  ASSERT_EQUAL(0, from_ruby<int>(INT2NUM(0)));
-  ASSERT_EQUAL(-1, from_ruby<int>(INT2NUM(-1)));
-  ASSERT_EQUAL(1, from_ruby<int>(INT2NUM(1)));
-  ASSERT_EQUAL(
-      std::numeric_limits<int>::min(),
-      from_ruby<int>(INT2NUM(std::numeric_limits<int>::min())));
-  ASSERT_EQUAL(
-      std::numeric_limits<int>::max(),
-      from_ruby<int>(INT2NUM(std::numeric_limits<int>::max())));
+  ASSERT_EQUAL(0, detail::From_Ruby<int>().convert(INT2NUM(0)));
+  ASSERT_EQUAL(-1, detail::From_Ruby<int>().convert(INT2NUM(-1)));
+  ASSERT_EQUAL(1, detail::From_Ruby<int>().convert(INT2NUM(1)));
+  ASSERT_EQUAL(std::numeric_limits<int>::min(),
+               detail::From_Ruby<int>().convert(INT2NUM(std::numeric_limits<int>::min())));
+  ASSERT_EQUAL(std::numeric_limits<int>::max(),
+               detail::From_Ruby<int>().convert(INT2NUM(std::numeric_limits<int>::max())));
+
+  ASSERT_EXCEPTION_CHECK(
+    Exception,
+    detail::From_Ruby<int>().convert(rb_str_new2("bad value")),
+    ASSERT_EQUAL("no implicit conversion of String into Integer", ex.what())
+  );
 }
 
 TESTCASE(long_to_ruby)
 {
-  ASSERT_EQUAL(LONG2NUM(0), to_ruby((long)0).value());
-  ASSERT_EQUAL(LONG2NUM(-1), to_ruby((long)-1).value());
-  ASSERT_EQUAL(LONG2NUM(1), to_ruby((long)1).value());
-  ASSERT_EQUAL(
-      LONG2NUM(FIXNUM_MAX),
-      to_ruby(FIXNUM_MAX).value());
-  ASSERT_EQUAL(
-      LONG2NUM(FIXNUM_MIN),
-      to_ruby(FIXNUM_MIN).value());
-  ASSERT_EQUAL(
-      Object(LONG2NUM(std::numeric_limits<long>::min())),
-      to_ruby(std::numeric_limits<long>::min()));
-  ASSERT_EQUAL(
-      Object(LONG2NUM(std::numeric_limits<long>::max())),
-      to_ruby(std::numeric_limits<long>::max()));
+  ASSERT(rb_equal(LONG2NUM(0), detail::to_ruby((long)0)));
+  ASSERT(rb_equal(LONG2NUM(-1), detail::to_ruby((long)-1)));
+  ASSERT(rb_equal(LONG2NUM(1), detail::to_ruby((long)1)));
+  ASSERT(rb_equal(LONG2NUM(FIXNUM_MAX), detail::to_ruby(FIXNUM_MAX)));
+  ASSERT(rb_equal(LONG2NUM(FIXNUM_MIN), detail::to_ruby(FIXNUM_MIN)));
+  ASSERT(rb_equal(LONG2NUM(std::numeric_limits<long>::min()), detail::to_ruby(std::numeric_limits<long>::min())));
+  ASSERT(rb_equal(LONG2NUM(std::numeric_limits<long>::max()), detail::to_ruby(std::numeric_limits<long>::max())));
 }
 
 TESTCASE(long_from_ruby)
 {
-  ASSERT_EQUAL(0, from_ruby<long>(LONG2NUM(0)));
-  ASSERT_EQUAL(-1, from_ruby<long>(LONG2NUM(-1)));
-  ASSERT_EQUAL(1, from_ruby<long>(LONG2NUM(1)));
-  ASSERT_EQUAL(
-      FIXNUM_MIN,
-      from_ruby<long>(LONG2NUM(FIXNUM_MIN)));
-  ASSERT_EQUAL(
-      FIXNUM_MAX,
-      from_ruby<long>(LONG2NUM(FIXNUM_MAX)));
-  ASSERT_EQUAL(
-      std::numeric_limits<long>::min(),
-      from_ruby<long>(LONG2NUM(std::numeric_limits<long>::min())));
-  ASSERT_EQUAL(
-      std::numeric_limits<long>::max(),
-      from_ruby<long>(LONG2NUM(std::numeric_limits<long>::max())));
+  ASSERT_EQUAL(0, detail::From_Ruby<long>().convert(LONG2NUM(0)));
+  ASSERT_EQUAL(-1, detail::From_Ruby<long>().convert(LONG2NUM(-1)));
+  ASSERT_EQUAL(1, detail::From_Ruby<long>().convert(LONG2NUM(1)));
+  ASSERT_EQUAL(FIXNUM_MIN, detail::From_Ruby<long>().convert(LONG2NUM(FIXNUM_MIN)));
+  ASSERT_EQUAL(FIXNUM_MAX, detail::From_Ruby<long>().convert(LONG2NUM(FIXNUM_MAX)));
+  ASSERT_EQUAL(std::numeric_limits<long>::min(), detail::From_Ruby<long>().convert(LONG2NUM(std::numeric_limits<long>::min())));
+  ASSERT_EQUAL(std::numeric_limits<long>::max(), detail::From_Ruby<long>().convert(LONG2NUM(std::numeric_limits<long>::max())));
+
+  ASSERT_EXCEPTION_CHECK(
+    Exception,
+    detail::From_Ruby<long>().convert(rb_str_new2("bad value")),
+    ASSERT_EQUAL("no implicit conversion of String into Integer", ex.what())
+  );
 }
 
 TESTCASE(long_long_to_ruby)
 {
-  ASSERT_EQUAL(LL2NUM(0), to_ruby((long long)0).value());
-  ASSERT_EQUAL(LL2NUM(-1), to_ruby((long long)-1).value());
-  ASSERT_EQUAL(LL2NUM(1), to_ruby((long long)1).value());
-  ASSERT_EQUAL(
-      Object(LL2NUM(std::numeric_limits<long long>::min())),
-      to_ruby(std::numeric_limits<long long>::min()));
-  ASSERT_EQUAL(
-      Object(LL2NUM(std::numeric_limits<long long>::max())),
-      to_ruby(std::numeric_limits<long long>::max()));
+  ASSERT(rb_equal(LL2NUM(0), detail::to_ruby((long long)0)));
+  ASSERT(rb_equal(LL2NUM(-1), detail::to_ruby((long long)-1)));
+  ASSERT(rb_equal(LL2NUM(1), detail::to_ruby((long long)1)));
+  ASSERT(rb_equal(LL2NUM(std::numeric_limits<long long>::min()), detail::to_ruby(std::numeric_limits<long long>::min())));
+  ASSERT(rb_equal(LL2NUM(std::numeric_limits<long long>::max()), detail::to_ruby(std::numeric_limits<long long>::max())));
 }
 
 TESTCASE(long_long_from_ruby)
 {
-  ASSERT_EQUAL(0, from_ruby<long long>(LL2NUM(0)));
-  ASSERT_EQUAL(-1, from_ruby<long long>(LL2NUM(-1)));
-  ASSERT_EQUAL(1, from_ruby<long long>(LL2NUM(1)));
-  ASSERT_EQUAL(
-      std::numeric_limits<long long>::min(),
-      from_ruby<long long>(LL2NUM(std::numeric_limits<long long>::min())));
-  ASSERT_EQUAL(
-      std::numeric_limits<long long>::max(),
-      from_ruby<long long>(LL2NUM(std::numeric_limits<long long>::max())));
+  ASSERT_EQUAL(0, detail::From_Ruby<long long>().convert(LL2NUM(0)));
+  ASSERT_EQUAL(-1, detail::From_Ruby<long long>().convert(LL2NUM(-1)));
+  ASSERT_EQUAL(1, detail::From_Ruby<long long>().convert(LL2NUM(1)));
+  ASSERT_EQUAL(std::numeric_limits<long long>::min(),
+               detail::From_Ruby<long long>().convert(LL2NUM(std::numeric_limits<long long>::min())));
+  ASSERT_EQUAL(std::numeric_limits<long long>::max(),
+               detail::From_Ruby<long long>().convert(LL2NUM(std::numeric_limits<long long>::max())));
+
+  ASSERT_EXCEPTION_CHECK(
+    Exception,
+    detail::From_Ruby<long long>().convert(rb_str_new2("bad value")),
+    ASSERT_EQUAL("no implicit conversion from string", ex.what())
+  );
 }
 
 TESTCASE(unsigned_short_to_ruby)
 {
-  ASSERT_EQUAL(UINT2NUM(0), to_ruby((unsigned short)0).value());
-  ASSERT_EQUAL(UINT2NUM(1), to_ruby((unsigned short)1).value());
-  ASSERT_EQUAL(
-      Object(UINT2NUM(std::numeric_limits<unsigned short>::min())),
-      to_ruby(std::numeric_limits<unsigned short>::min()));
-  ASSERT_EQUAL(
-      Object(UINT2NUM(std::numeric_limits<unsigned short>::max())),
-      to_ruby(std::numeric_limits<unsigned short>::max()));
+  ASSERT(rb_equal(UINT2NUM(0), detail::to_ruby((unsigned short)0)));
+  ASSERT(rb_equal(UINT2NUM(1), detail::to_ruby((unsigned short)1)));
+  ASSERT(rb_equal(UINT2NUM(std::numeric_limits<unsigned short>::min()), detail::to_ruby(std::numeric_limits<unsigned short>::min())));
+  ASSERT(rb_equal(UINT2NUM(std::numeric_limits<unsigned short>::max()), detail::to_ruby(std::numeric_limits<unsigned short>::max())));
 }
 
 TESTCASE(unsigned_short_from_ruby)
 {
-  ASSERT_EQUAL(0u, from_ruby<unsigned short>(UINT2NUM(0)));
-  ASSERT_EQUAL(1u, from_ruby<unsigned short>(UINT2NUM(1)));
-  ASSERT_EQUAL(
-      std::numeric_limits<unsigned short>::min(),
-      from_ruby<unsigned short>(UINT2NUM(std::numeric_limits<unsigned short>::min())));
-  ASSERT_EQUAL(
-      std::numeric_limits<unsigned short>::max(),
-      from_ruby<unsigned short>(UINT2NUM(std::numeric_limits<unsigned short>::max())));
+  ASSERT_EQUAL(0u, detail::From_Ruby<unsigned short>().convert(UINT2NUM(0)));
+  ASSERT_EQUAL(1u, detail::From_Ruby<unsigned short>().convert(UINT2NUM(1)));
+  ASSERT_EQUAL(std::numeric_limits<unsigned short>::min(),
+               detail::From_Ruby<unsigned short>().convert(UINT2NUM(std::numeric_limits<unsigned short>::min())));
+  ASSERT_EQUAL(std::numeric_limits<unsigned short>::max(),
+               detail::From_Ruby<unsigned short>().convert(UINT2NUM(std::numeric_limits<unsigned short>::max())));
+
+  ASSERT_EXCEPTION_CHECK(
+    Exception,
+    detail::From_Ruby<unsigned short>().convert(rb_str_new2("bad value")),
+    ASSERT_EQUAL("no implicit conversion of String into Integer", ex.what())
+  );
 }
 
 TESTCASE(unsigned_int_to_ruby)
 {
-  ASSERT_EQUAL(UINT2NUM(0), to_ruby((unsigned int)0).value());
-  ASSERT_EQUAL(UINT2NUM(1), to_ruby((unsigned int)1).value());
-  ASSERT_EQUAL(
-      Object(UINT2NUM(std::numeric_limits<unsigned int>::min())),
-      to_ruby(std::numeric_limits<unsigned int>::min()));
-  ASSERT_EQUAL(
-      Object(UINT2NUM(std::numeric_limits<unsigned int>::max())),
-      to_ruby(std::numeric_limits<unsigned int>::max()));
+  ASSERT(rb_equal(UINT2NUM(0), detail::to_ruby((unsigned int)0)));
+  ASSERT(rb_equal(UINT2NUM(1), detail::to_ruby((unsigned int)1)));
+  ASSERT(rb_equal(UINT2NUM(std::numeric_limits<unsigned int>::min()), detail::to_ruby(std::numeric_limits<unsigned int>::min())));
+  ASSERT(rb_equal(UINT2NUM(std::numeric_limits<unsigned int>::max()), detail::to_ruby(std::numeric_limits<unsigned int>::max())));
 }
 
 TESTCASE(unsigned_int_from_ruby)
 {
-  ASSERT_EQUAL(0u, from_ruby<unsigned int>(UINT2NUM(0)));
-  ASSERT_EQUAL(1u, from_ruby<unsigned int>(UINT2NUM(1)));
-  ASSERT_EQUAL(
-      std::numeric_limits<unsigned int>::min(),
-      from_ruby<unsigned int>(UINT2NUM(std::numeric_limits<unsigned int>::min())));
-  ASSERT_EQUAL(
-      std::numeric_limits<unsigned int>::max(),
-      from_ruby<unsigned int>(UINT2NUM(std::numeric_limits<unsigned int>::max())));
+  ASSERT_EQUAL(0u, detail::From_Ruby<unsigned int>().convert(UINT2NUM(0)));
+  ASSERT_EQUAL(1u, detail::From_Ruby<unsigned int>().convert(UINT2NUM(1)));
+  ASSERT_EQUAL(std::numeric_limits<unsigned int>::min(),
+               detail::From_Ruby<unsigned int>().convert(UINT2NUM(std::numeric_limits<unsigned int>::min())));
+  ASSERT_EQUAL(std::numeric_limits<unsigned int>::max(),
+               detail::From_Ruby<unsigned int>().convert(UINT2NUM(std::numeric_limits<unsigned int>::max())));
+
+  ASSERT_EXCEPTION_CHECK(
+    Exception,
+    detail::From_Ruby<unsigned int>().convert(rb_str_new2("bad value")),
+    ASSERT_EQUAL("no implicit conversion of String into Integer", ex.what())
+  );
 }
 
 TESTCASE(unsigned_long_to_ruby)
 {
-  ASSERT_EQUAL(ULONG2NUM(0), to_ruby((unsigned long)0).value());
-  ASSERT_EQUAL(ULONG2NUM(1), to_ruby((unsigned long)1).value());
-  ASSERT_EQUAL(
-      ULONG2NUM(FIXNUM_MAX),
-      to_ruby(FIXNUM_MAX).value());
-  ASSERT_EQUAL(
-      Object(ULONG2NUM(std::numeric_limits<unsigned long>::min())),
-      to_ruby(std::numeric_limits<unsigned long>::min()));
-  ASSERT_EQUAL(
-      Object(ULONG2NUM(std::numeric_limits<unsigned long>::max())),
-      to_ruby(std::numeric_limits<unsigned long>::max()));
+  ASSERT(rb_equal(ULONG2NUM(0), detail::to_ruby((unsigned long)0)));
+  ASSERT(rb_equal(ULONG2NUM(1), detail::to_ruby((unsigned long)1)));
+  ASSERT(rb_equal(ULONG2NUM(FIXNUM_MAX), detail::to_ruby(FIXNUM_MAX)));
+  ASSERT(rb_equal(ULONG2NUM(std::numeric_limits<unsigned long>::min()), detail::to_ruby(std::numeric_limits<unsigned long>::min())));
+  ASSERT(rb_equal(ULONG2NUM(std::numeric_limits<unsigned long>::max()), detail::to_ruby(std::numeric_limits<unsigned long>::max())));
 }
 
 TESTCASE(unsigned_long_from_ruby)
 {
-  ASSERT_EQUAL(0u, from_ruby<unsigned long>(ULONG2NUM(0)));
-  ASSERT_EQUAL(1u, from_ruby<unsigned long>(ULONG2NUM(1)));
-  ASSERT_EQUAL(
-      static_cast<unsigned long>(FIXNUM_MIN),
-      from_ruby<unsigned long>(ULONG2NUM(FIXNUM_MIN)));
-  ASSERT_EQUAL(
-      std::numeric_limits<unsigned long>::min(),
-      from_ruby<unsigned long>(ULONG2NUM(std::numeric_limits<unsigned long>::min())));
-  ASSERT_EQUAL(
-      std::numeric_limits<unsigned long>::max(),
-      from_ruby<unsigned long>(ULONG2NUM(std::numeric_limits<unsigned long>::max())));
+  ASSERT_EQUAL(0u, detail::From_Ruby<unsigned long>().convert(ULONG2NUM(0)));
+  ASSERT_EQUAL(1u, detail::From_Ruby<unsigned long>().convert(ULONG2NUM(1)));
+  ASSERT_EQUAL(static_cast<unsigned long>(FIXNUM_MIN),
+               detail::From_Ruby<unsigned long>().convert(ULONG2NUM(FIXNUM_MIN)));
+  ASSERT_EQUAL(std::numeric_limits<unsigned long>::min(),
+               detail::From_Ruby<unsigned long>().convert(ULONG2NUM(std::numeric_limits<unsigned long>::min())));
+  ASSERT_EQUAL(std::numeric_limits<unsigned long>::max(),
+               detail::From_Ruby<unsigned long>().convert(ULONG2NUM(std::numeric_limits<unsigned long>::max())));
+
+  ASSERT_EXCEPTION_CHECK(
+    Exception,
+    detail::From_Ruby<unsigned long>().convert(rb_str_new2("bad value")),
+    ASSERT_EQUAL("no implicit conversion of String into Integer", ex.what())
+  );
 }
 
 TESTCASE(unsigned_long_long_to_ruby)
 {
-  ASSERT_EQUAL(ULL2NUM(0), to_ruby((unsigned long long)0).value());
-  ASSERT_EQUAL(ULL2NUM(1), to_ruby((unsigned long long)1).value());
-  ASSERT_EQUAL(
-      Object(ULL2NUM(std::numeric_limits<unsigned long long>::min())),
-      to_ruby(std::numeric_limits<unsigned long long>::min()));
-  ASSERT_EQUAL(
-      Object(ULL2NUM(std::numeric_limits<unsigned long long>::max())),
-      to_ruby(std::numeric_limits<unsigned long long>::max()));
+  ASSERT(rb_equal(ULL2NUM(0), detail::to_ruby((unsigned long long)0)));
+  ASSERT(rb_equal(ULL2NUM(1), detail::to_ruby((unsigned long long)1)));
+  ASSERT(rb_equal(ULL2NUM(std::numeric_limits<unsigned long long>::min()), detail::to_ruby(std::numeric_limits<unsigned long long>::min())));
+  ASSERT(rb_equal(ULL2NUM(std::numeric_limits<unsigned long long>::max()), detail::to_ruby(std::numeric_limits<unsigned long long>::max())));
 }
 
 TESTCASE(unsigned_long_long_from_ruby)
 {
-  ASSERT_EQUAL(0u, from_ruby<unsigned long>(ULL2NUM(0)));
-  ASSERT_EQUAL(1u, from_ruby<unsigned long>(ULL2NUM(1)));
-  ASSERT_EQUAL(
-      std::numeric_limits<unsigned long long>::min(),
-      from_ruby<unsigned long long>(ULL2NUM(std::numeric_limits<unsigned long long>::min())));
-  ASSERT_EQUAL(
-      std::numeric_limits<unsigned long long>::max(),
-      from_ruby<unsigned long long>(ULL2NUM(std::numeric_limits<unsigned long long>::max())));
+  ASSERT_EQUAL(0u, detail::From_Ruby<unsigned long>().convert(ULL2NUM(0)));
+  ASSERT_EQUAL(1u, detail::From_Ruby<unsigned long>().convert(ULL2NUM(1)));
+  ASSERT_EQUAL(std::numeric_limits<unsigned long long>::min(),
+               detail::From_Ruby<unsigned long long>().convert(ULL2NUM(std::numeric_limits<unsigned long long>::min())));
+  ASSERT_EQUAL(std::numeric_limits<unsigned long long>::max(),
+               detail::From_Ruby<unsigned long long>().convert(ULL2NUM(std::numeric_limits<unsigned long long>::max())));
+
+  ASSERT_EXCEPTION_CHECK(
+    Exception,
+    detail::From_Ruby<unsigned long long>().convert(rb_str_new2("bad value")),
+    ASSERT_EQUAL("no implicit conversion from string", ex.what())
+  );
 }
 
 TESTCASE(bool_to_ruby)
 {
-  ASSERT_EQUAL(Qfalse, to_ruby(false).value());
-  ASSERT_EQUAL(Qtrue, to_ruby(true).value());
+  ASSERT(rb_equal(Qfalse, detail::to_ruby(false)));
+  ASSERT(rb_equal(Qtrue, detail::to_ruby(true)));
 }
 
 TESTCASE(bool_from_ruby)
 {
-  ASSERT_EQUAL(false, from_ruby<bool>(Object(Qfalse)));
-  ASSERT_EQUAL(true, from_ruby<bool>(Object(Qtrue)));
+  ASSERT_EQUAL(false, detail::From_Ruby<bool>().convert(Qfalse));
+  ASSERT_EQUAL(false, detail::From_Ruby<bool>().convert(Qnil));
+  ASSERT_EQUAL(true, detail::From_Ruby<bool>().convert(Qtrue));
+  ASSERT_EQUAL(true, detail::From_Ruby<bool>().convert(rb_str_new2("some string")));
+  ASSERT_EQUAL(true, detail::From_Ruby<bool>().convert(INT2NUM(3)));
+  ASSERT_EQUAL(true, detail::From_Ruby<bool>().convert(rb_float_new(3.33)));
 }
 
 TESTCASE(float_to_ruby)
 {
-  ASSERT_EQUAL(Object(rb_float_new(0.0f)), to_ruby(0.0f));
-  ASSERT_EQUAL(Object(rb_float_new(-1.0f)), to_ruby(-1.0f));
-  ASSERT_EQUAL(Object(rb_float_new(1.0f)), to_ruby(1.0f));
-  ASSERT_EQUAL(Object(rb_float_new(0.5f)), to_ruby(0.5f));
-  ASSERT_EQUAL(
-      Object(rb_float_new(std::numeric_limits<float>::min())),
-      to_ruby(std::numeric_limits<float>::min()));
-  ASSERT_EQUAL(
-      Object(rb_float_new(std::numeric_limits<float>::max())),
-      to_ruby(std::numeric_limits<float>::max()));
-  ASSERT(
-      to_ruby(std::numeric_limits<float>::quiet_NaN()).call("nan?"));
-  ASSERT(
-      to_ruby(std::numeric_limits<float>::signaling_NaN()).call("nan?"));
-  ASSERT_EQUAL(
-      Object(rb_float_new(std::numeric_limits<float>::epsilon())),
-      to_ruby(std::numeric_limits<float>::epsilon()));
+  ASSERT(rb_equal(rb_float_new(0.0f), detail::to_ruby(0.0f)));
+  ASSERT(rb_equal(rb_float_new(-1.0f), detail::to_ruby(-1.0f)));
+  ASSERT(rb_equal(rb_float_new(1.0f), detail::to_ruby(1.0f)));
+  ASSERT(rb_equal(rb_float_new(0.5f), detail::to_ruby(0.5f)));
+  ASSERT(rb_equal(rb_float_new(std::numeric_limits<float>::min()), detail::to_ruby(std::numeric_limits<float>::min())));
+  ASSERT(rb_equal(rb_float_new(std::numeric_limits<float>::max()), detail::to_ruby(std::numeric_limits<float>::max())));
+  ASSERT(Object(detail::to_ruby(std::numeric_limits<float>::quiet_NaN())).call("nan?"));
+  ASSERT(Object(detail::to_ruby(std::numeric_limits<float>::signaling_NaN())).call("nan?"));
+  ASSERT_EQUAL(rb_float_new(std::numeric_limits<float>::epsilon()),
+               detail::to_ruby(std::numeric_limits<float>::epsilon()));
 }
 
 TESTCASE(float_from_ruby)
 {
-  ASSERT_EQUAL(0.0f, from_ruby<float>(rb_float_new(0.0f)));
-  ASSERT_EQUAL(-1.0f, from_ruby<float>(rb_float_new(-1.0f)));
-  ASSERT_EQUAL(1.0f, from_ruby<float>(rb_float_new(1.0f)));
-  ASSERT_EQUAL(
-      std::numeric_limits<float>::min(),
-      from_ruby<float>(rb_float_new(std::numeric_limits<float>::min())));
-  ASSERT_EQUAL(
-      std::numeric_limits<float>::max(),
-      from_ruby<float>(rb_float_new(std::numeric_limits<float>::max())));
-  ASSERT(
-      std::isnan(from_ruby<float>(rb_float_new(std::numeric_limits<float>::quiet_NaN()))));
-  ASSERT(
-      std::isnan(from_ruby<float>(rb_float_new(std::numeric_limits<float>::signaling_NaN()))));
-  ASSERT_EQUAL(
-      std::numeric_limits<float>::epsilon(),
-      from_ruby<float>(rb_float_new(std::numeric_limits<float>::epsilon())));
+  ASSERT_EQUAL(0.0f, detail::From_Ruby<float>().convert(rb_float_new(0.0f)));
+  ASSERT_EQUAL(-1.0f, detail::From_Ruby<float>().convert(rb_float_new(-1.0f)));
+  ASSERT_EQUAL(1.0f, detail::From_Ruby<float>().convert(rb_float_new(1.0f)));
+  ASSERT_EQUAL(std::numeric_limits<float>::min(),
+               detail::From_Ruby<float>().convert(rb_float_new(std::numeric_limits<float>::min())));
+  ASSERT_EQUAL(std::numeric_limits<float>::max(),
+               detail::From_Ruby<float>().convert(rb_float_new(std::numeric_limits<float>::max())));
+  ASSERT(std::isnan(detail::From_Ruby<float>().convert(rb_float_new(std::numeric_limits<float>::quiet_NaN()))));
+  ASSERT(std::isnan(detail::From_Ruby<float>().convert(rb_float_new(std::numeric_limits<float>::signaling_NaN()))));
+  ASSERT_EQUAL(std::numeric_limits<float>::epsilon(),
+               detail::From_Ruby<float>().convert(rb_float_new(std::numeric_limits<float>::epsilon())));
+
+  ASSERT_EXCEPTION_CHECK(
+    Exception,
+    detail::From_Ruby<float>().convert(rb_str_new2("bad value")),
+    ASSERT_EQUAL("no implicit conversion to float from string", ex.what())
+  );
 }
 
 TESTCASE(double_to_ruby)
 {
-  ASSERT_EQUAL(Object(rb_float_new(0.0f)), to_ruby(0.0f));
-  ASSERT_EQUAL(Object(rb_float_new(-1.0f)), to_ruby(-1.0f));
-  ASSERT_EQUAL(Object(rb_float_new(1.0f)), to_ruby(1.0f));
-  ASSERT_EQUAL(Object(rb_float_new(0.5f)), to_ruby(0.5f));
-  ASSERT_EQUAL(
-      Object(rb_float_new(std::numeric_limits<double>::min())),
-      to_ruby(std::numeric_limits<double>::min()));
-  ASSERT_EQUAL(
-      Object(rb_float_new(std::numeric_limits<double>::max())),
-      to_ruby(std::numeric_limits<double>::max()));
-  ASSERT(
-      to_ruby(std::numeric_limits<double>::quiet_NaN()).call("nan?"));
-  ASSERT(
-      to_ruby(std::numeric_limits<double>::signaling_NaN()).call("nan?"));
-  ASSERT_EQUAL(
-      Object(rb_float_new(std::numeric_limits<double>::epsilon())),
-      to_ruby(std::numeric_limits<double>::epsilon()));
+  ASSERT(rb_equal(rb_float_new(0.0f), detail::to_ruby(0.0f)));
+  ASSERT(rb_equal(rb_float_new(-1.0f), detail::to_ruby(-1.0f)));
+  ASSERT(rb_equal(rb_float_new(1.0f), detail::to_ruby(1.0f)));
+  ASSERT(rb_equal(rb_float_new(0.5f), detail::to_ruby(0.5f)));
+  ASSERT(rb_equal(rb_float_new(std::numeric_limits<double>::min()), detail::to_ruby(std::numeric_limits<double>::min())));
+  ASSERT(rb_equal(rb_float_new(std::numeric_limits<double>::max()), detail::to_ruby(std::numeric_limits<double>::max())));
+  ASSERT(Object(detail::to_ruby(std::numeric_limits<double>::quiet_NaN())).call("nan?"));
+  ASSERT(Object(detail::to_ruby(std::numeric_limits<double>::signaling_NaN())).call("nan?"));
+  ASSERT(rb_equal(rb_float_new(std::numeric_limits<double>::epsilon()), detail::to_ruby(std::numeric_limits<double>::epsilon())));
 }
 
 TESTCASE(double_from_ruby)
 {
-  ASSERT_EQUAL(0.0f, from_ruby<double>(rb_float_new(0.0f)));
-  ASSERT_EQUAL(-1.0f, from_ruby<double>(rb_float_new(-1.0f)));
-  ASSERT_EQUAL(1.0f, from_ruby<double>(rb_float_new(1.0f)));
-  ASSERT_EQUAL(
-      std::numeric_limits<double>::min(),
-      from_ruby<double>(rb_float_new(std::numeric_limits<double>::min())));
-  ASSERT_EQUAL(
-      std::numeric_limits<double>::max(),
-      from_ruby<double>(rb_float_new(std::numeric_limits<double>::max())));
-  ASSERT(
-      std::isnan(from_ruby<double>(rb_float_new(std::numeric_limits<double>::quiet_NaN()))));
-  ASSERT(
-      std::isnan(from_ruby<double>(rb_float_new(std::numeric_limits<double>::signaling_NaN()))));
-  ASSERT_EQUAL(
-      std::numeric_limits<double>::epsilon(),
-      from_ruby<double>(rb_float_new(std::numeric_limits<double>::epsilon())));
+  ASSERT_EQUAL(0.0, detail::From_Ruby<double>().convert(rb_float_new(0.0)));
+  ASSERT_EQUAL(-1.0, detail::From_Ruby<double>().convert(rb_float_new(-1.0)));
+  ASSERT_EQUAL(1.0, detail::From_Ruby<double>().convert(rb_float_new(1.0)));
+  ASSERT_EQUAL(std::numeric_limits<double>::min(),
+               detail::From_Ruby<double>().convert(rb_float_new(std::numeric_limits<double>::min())));
+  ASSERT_EQUAL(std::numeric_limits<double>::max(),
+               detail::From_Ruby<double>().convert(rb_float_new(std::numeric_limits<double>::max())));
+  ASSERT(std::isnan(detail::From_Ruby<double>().convert(rb_float_new(std::numeric_limits<double>::quiet_NaN()))));
+  ASSERT(std::isnan(detail::From_Ruby<double>().convert(rb_float_new(std::numeric_limits<double>::signaling_NaN()))));
+  ASSERT_EQUAL(std::numeric_limits<double>::epsilon(),
+               detail::From_Ruby<double>().convert(rb_float_new(std::numeric_limits<double>::epsilon())));
+
+  ASSERT_EXCEPTION_CHECK(
+    Exception,
+    detail::From_Ruby<double>().convert(rb_str_new2("bad value")),
+    ASSERT_EQUAL("no implicit conversion to float from string", ex.what())
+  );
 }
 
 TESTCASE(char_const_ptr_to_ruby)
 {
-  ASSERT_EQUAL(String(""), to_ruby((char const *)""));
-  ASSERT_EQUAL(String("foo"), to_ruby((char const *)"foo"));
+  ASSERT(rb_equal(String("").value(), detail::to_ruby((char const *)"")));
+  ASSERT(rb_equal(String("foo").value(), detail::to_ruby((char const *)"foo")));
 }
 
 TESTCASE(char_const_ptr_from_ruby)
 {
   char const* foo = "foo";
-  ASSERT_EQUAL("", from_ruby<char const *>(rb_str_new2("")));
-  ASSERT_EQUAL(foo, from_ruby<char const *>(rb_str_new2("foo")));
+  ASSERT_EQUAL(foo, detail::From_Ruby<char const *>().convert(rb_str_new2("foo")));
+  ASSERT_EQUAL("", detail::From_Ruby<char const*>().convert(rb_str_new2("")));
+
+  ASSERT_EXCEPTION_CHECK(
+    Exception,
+    detail::From_Ruby<char const *>().convert(rb_float_new(32.3)),
+    ASSERT_EQUAL("wrong argument type Float (expected String)", ex.what())
+  );
 }
 
 TESTCASE(char_from_ruby_single_character_string)
 {
-  ASSERT_EQUAL('x', from_ruby<char>(rb_str_new2("x")));
+  ASSERT_EQUAL('x', detail::From_Ruby<char>().convert(rb_str_new2("x")));
 }
 
 TESTCASE(char_from_ruby_longer_string)
 {
-  ASSERT_EXCEPTION(
+  ASSERT_EXCEPTION_CHECK(
     std::invalid_argument,
-    from_ruby<char>(rb_str_new2("xy"))
+    detail::From_Ruby<char>().convert(rb_str_new2("xy")),
+    ASSERT_EQUAL("from_ruby<char>: string must have length 1", ex.what())
   );
-}
-
-TESTCASE(char_from_ruby_fixnum)
-{
-  ASSERT_EQUAL('1', from_ruby<char>(INT2NUM(49)));
-}
 
-TESTCASE(char_star_from_ruby)
-{
-  const char* expected = "my string";
-  ASSERT_EQUAL(expected, from_ruby<const char*>(rb_str_new2("my string")));
-}
-
-TESTCASE(std_string_to_ruby)
-{
-  ASSERT_EQUAL(String(""), to_ruby(std::string("")));
-  ASSERT_EQUAL(String("foo"), to_ruby(std::string("foo")));
+  ASSERT_EXCEPTION_CHECK(
+    Exception,
+    detail::From_Ruby<char>().convert(rb_float_new(47.2)),
+    ASSERT_EQUAL("wrong argument type Float (expected char type)", ex.what())
+  );
 }
 
-TESTCASE(std_string_from_ruby)
+TESTCASE(char_from_ruby_fixnum)
 {
-  ASSERT_EQUAL(std::string(""), from_ruby<std::string>(rb_str_new2("")));
-  ASSERT_EQUAL(std::string("foo"), from_ruby<std::string>(rb_str_new2("foo")));
+  ASSERT_EQUAL('1', detail::From_Ruby<char>().convert(INT2NUM(49)));
 }
 
-TESTCASE(std_string_to_ruby_with_binary)
+TESTCASE(unsigned_char_from_ruby)
 {
-  Rice::String got = to_ruby(std::string("\000test", 5));
-
-  ASSERT_EQUAL(String(std::string("\000test", 5)), got);
-  ASSERT_EQUAL(5, got.length());
-}
+  unsigned char expected = -1;
+  ASSERT_EQUAL(expected, detail::From_Ruby<unsigned char>().convert(INT2NUM(-1)));
 
-TESTCASE(std_string_from_ruby_with_binary)
-{
-  std::string got = from_ruby<std::string>(rb_str_new("\000test", 5));
-  ASSERT_EQUAL(5, got.length());
-  ASSERT_EQUAL(std::string("\000test", 5), got);
-}
-
-TESTCASE(array_to_ruby)
-{
-  Array a(rb_ary_new());
-  ASSERT_EQUAL(a.value(), to_ruby(a).value());
+  ASSERT_EXCEPTION_CHECK(
+    Exception,
+    detail::From_Ruby<unsigned char>().convert(rb_float_new(1.3)),
+    ASSERT_EQUAL("wrong argument type Float (expected char type)", ex.what())
+  );
 }
 
-TESTCASE(array_from_ruby)
+TESTCASE(signed_char_from_ruby)
 {
-  Array a(rb_ary_new());
-  ASSERT_EQUAL(a.value(), from_ruby<Array>(a).value());
+  unsigned char expected = 10;
+  ASSERT_EQUAL(expected, detail::From_Ruby<signed char>().convert(INT2NUM(10)));
 }
 
-TESTCASE(hash_to_ruby)
+TESTCASE(char_star_from_ruby)
 {
-  Hash h(rb_hash_new());
-  ASSERT_EQUAL(h.value(), to_ruby(h).value());
-}
+  const char* expected = "my string";
+  ASSERT_EQUAL(expected, detail::From_Ruby<const char*>().convert(rb_str_new2("my string")));
 
-TESTCASE(hash_from_ruby)
-{
-  Hash h(rb_hash_new());
-  ASSERT_EQUAL(h.value(), from_ruby<Hash>(h).value());
-}
+  ASSERT_EXCEPTION_CHECK(
+    Exception,
+    detail::From_Ruby<const char*>().convert(rb_float_new(11.11)),
+    ASSERT_EQUAL("wrong argument type Float (expected String)", ex.what())
+  );
+}