rice 4.6.1 → 4.7.0

data/test/test_To_Ruby.cpp

@@ -1,4 +1,4 @@
-#include "unittest.hpp"
+#include "unittest.hpp"
 #include "embed_ruby.hpp"
 #include <rice/rice.hpp>
 
@@ -13,7 +13,6 @@ TESTSUITE(ToRuby);
 SETUP(ToRuby)
 {
   embed_ruby();
-  define_fundamental_buffer_types();
 }
 
 TEARDOWN(ToRuby)
@@ -210,13 +209,20 @@ TESTCASE(unsigned_char_ptr_buffer)
     .define_attr("data", &Matrix2UnsignedChar::data, Rice::AttrAccess::Read);
 
   std::string code = R"(matrix = Matrix2UnsignedChar.new
-                        buffer = matrix.ptr
+                        buffer = matrix.ptr.buffer
                         buffer.bytes(5))";
   String buffer = m.module_eval(code);
   ASSERT_EQUAL("\x1\x2\x3\x4\x5", buffer.str());
 
   code = R"(matrix = Matrix2UnsignedChar.new
-            buffer = matrix.ptr
+            ptr = matrix.ptr
+            buffer = Rice::Buffer≺unsigned char≻.new(ptr)
+            buffer.bytes(5))";
+  buffer = m.module_eval(code);
+  ASSERT_EQUAL("\x1\x2\x3\x4\x5", buffer.str());
+
+  code = R"(matrix = Matrix2UnsignedChar.new
+            buffer = matrix.ptr.buffer
             buffer.bytes(0))";
   buffer = m.module_eval(code);
   ASSERT_EQUAL("", buffer.str());
@@ -238,7 +244,7 @@ TESTCASE(unsigned_char_ptr_array)
     .define_method("ptr", &Matrix2UnsignedChar::ptr);
 
   std::string code = R"(matrix = Matrix2UnsignedChar.new
-                        buffer = matrix.ptr
+                        buffer = matrix.ptr.buffer
                         buffer.to_ary(5))";
 
   std::vector<unsigned char> expected = std::vector<unsigned char>{ 1,2,3,4,5 };
@@ -247,8 +253,8 @@ TESTCASE(unsigned_char_ptr_array)
   ASSERT_EQUAL(expected, actual);
 
   code = R"(matrix = Matrix2UnsignedChar.new
-           buffer = matrix.ptr
-           buffer.to_ary(1))";
+            buffer = matrix.ptr.buffer
+            buffer.to_ary(1))";
 
   expected = std::vector<unsigned char>{ 1 };
   array = m.module_eval(code);
@@ -266,9 +272,9 @@ TESTCASE(unsigned_char_ptr_ptr_buffer)
     .define_attr("data", &Matrix3UnsignedChar::data, Rice::AttrAccess::Read);
 
   std::string code = R"(matrix = Matrix3UnsignedChar.new
-                          buffer = matrix.ptr
-                          buffer2 = buffer.to_ary(1).first
-                          buffer2.to_ary(5))";
+                        buffer = matrix.ptr.buffer
+                        buffer2 = buffer.to_ary(1).first
+                        buffer2.to_ary(5))";
   Array array = m.module_eval(code);
   ASSERT_EQUAL(5, array.size());
 
@@ -276,7 +282,7 @@ TESTCASE(unsigned_char_ptr_ptr_buffer)
   std::vector<unsigned char> actual = array.to_vector<unsigned char>();
   ASSERT_EQUAL(expected, actual);
 }
-
+/*
 TESTCASE(unsigned_char_ptr_ptr_array)
 {
   Module m = define_module("ToRubyPtr");
@@ -286,7 +292,7 @@ TESTCASE(unsigned_char_ptr_ptr_array)
     .define_method("ptr", &Matrix3UnsignedChar::ptr);
 
   std::string code = R"(matrix = Matrix3UnsignedChar.new
-                        buffer = matrix.ptr
+                        buffer = matrix.ptr.buffer
                         buffer.to_ary(5))";
 
   Array pointers = m.module_eval(code);
@@ -312,7 +318,7 @@ TESTCASE(short_ptr_buffer)
     .define_method("ptr", &Matrix2Short::ptr);
 
   std::string code = R"(matrix = Matrix2Short.new
-                        buffer = matrix.ptr
+                        buffer = matrix.ptr.buffer
                         buffer.bytes(5))";
 
   std::string expected = "\x1\0\x2\0\x3\0\x4\0\x5\0"s;
@@ -320,7 +326,7 @@ TESTCASE(short_ptr_buffer)
   ASSERT_EQUAL(expected, buffer.str());
 
   code = R"(matrix = Matrix2Short.new
-                        buffer = matrix.ptr
+                        buffer = matrix.ptr.buffer
                         buffer.bytes(0))";
   expected = ""s;
   buffer = m.module_eval(code);
@@ -336,7 +342,7 @@ TESTCASE(short_ptr_array)
     .define_method("ptr", &Matrix2Short::ptr);
 
   std::string code = R"(matrix = Matrix2Short.new
-                        buffer = matrix.ptr
+                        buffer = matrix.ptr.buffer
                         buffer.to_ary(5))";
 
    std::vector<short> expected = std::vector<short>{1,2,3,4,5};
@@ -354,7 +360,7 @@ TESTCASE(unsigned_short_ptr_buffer)
     .define_method("ptr", &Matrix2UnsignedShort::ptr);
 
   std::string code = R"(matrix = Matrix2UnsignedShort.new
-                        buffer = matrix.ptr
+                        buffer = matrix.ptr.buffer
                         buffer.bytes(5))";
 
   std::string expected = "\x1\0\x2\0\x3\0\x4\0\x5\0"s;
@@ -362,7 +368,7 @@ TESTCASE(unsigned_short_ptr_buffer)
   ASSERT_EQUAL(expected, buffer.str());
 
   code = R"(matrix = Matrix2UnsignedShort.new
-            buffer = matrix.ptr
+            buffer = matrix.ptr.buffer
             buffer.bytes(0))";
   expected = ""s;
   buffer = m.module_eval(code);
@@ -378,7 +384,7 @@ TESTCASE(unsigned_short_ptr_array)
     .define_method("ptr", &Matrix2UnsignedShort::ptr);
 
   std::string code = R"(matrix = Matrix2UnsignedShort.new
-                        buffer = matrix.ptr
+                        buffer = matrix.ptr.buffer
                         buffer.to_ary(5))";
 
   std::vector<unsigned short> expected = std::vector<unsigned short>{ 1,2,3,4,5 };
@@ -396,7 +402,7 @@ TESTCASE(int_ptr_buffer)
     .define_method("ptr", &Matrix2Int::ptr);
 
   std::string code = R"(matrix = Matrix2Int.new
-                        buffer = matrix.ptr
+                        buffer = matrix.ptr.buffer
                         buffer.bytes(5))";
 
   std::string expected = "\x1\0\0\0\x2\0\0\0\x3\0\0\0\x4\0\0\0\x5\0\0\0"s;
@@ -404,7 +410,7 @@ TESTCASE(int_ptr_buffer)
   ASSERT_EQUAL(expected, buffer.str());
 
   code = R"(matrix = Matrix2Int.new
-            buffer = matrix.ptr
+            buffer = matrix.ptr.buffer
             buffer.bytes(0))";
   expected = ""s;
   buffer = m.module_eval(code);
@@ -420,7 +426,7 @@ TESTCASE(int_ptr_array)
     .define_method("ptr", &Matrix2Int::ptr);
 
   std::string code = R"(matrix = Matrix2Int.new
-                        buffer = matrix.ptr
+                        buffer = matrix.ptr.buffer
                         buffer.to_ary(5))";
 
   std::vector<int> expected = std::vector<int>{ 1,2,3,4,5 };
@@ -438,7 +444,7 @@ TESTCASE(float_ptr_buffer)
     .define_method("ptr", &Matrix2Float::ptr);
 
   std::string code = R"(matrix = Matrix2Float.new
-                        buffer = matrix.ptr
+                        buffer = matrix.ptr.buffer
                         buffer.bytes(5))";
 
   std::string expected = "\0\0\x80\x3f\0\0\0\x40\0\0\x40\x40\0\0\x80\x40\0\0\xa0\x40"s;
@@ -446,7 +452,7 @@ TESTCASE(float_ptr_buffer)
   ASSERT_EQUAL(expected, buffer.str());
 
  code = R"(matrix = Matrix2Float.new
-            buffer = matrix.ptr
+            buffer = matrix.ptr.buffer
             buffer.bytes(0))";
   expected = ""s;
   buffer = m.module_eval(code);
@@ -462,7 +468,7 @@ TESTCASE(float_ptr_array)
     .define_method("ptr", &Matrix2Float::ptr);
 
   std::string code = R"(matrix = Matrix2Float.new
-                        buffer = matrix.ptr
+                        buffer = matrix.ptr.buffer
                         buffer.to_ary(5))";
 
   std::vector<float> expected = std::vector<float>{ 1.0,2.0,3.0,4.0,5.0 };
@@ -480,7 +486,7 @@ TESTCASE(double_ptr_buffer)
     .define_method("ptr", &Matrix2Double::ptr);
 
   std::string code = R"(matrix = Matrix2Double.new
-                        buffer = matrix.ptr
+                        buffer = matrix.ptr.buffer
                         buffer.bytes(5))";
 
   std::string expected = "\0\0\0\0\0\0\xf0\x3f\0\0\0\0\0\0\0\x40\0\0\0\0\0\0\x08\x40\0\0\0\0\0\0\x10\x40\0\0\0\0\0\0\x14\x40"s;
@@ -489,7 +495,7 @@ TESTCASE(double_ptr_buffer)
   ASSERT_EQUAL(expected, buffer.str());
 
   code = R"(matrix = Matrix2Double.new
-            buffer = matrix.ptr
+            buffer = matrix.ptr.buffer
             buffer.bytes(0))";
   expected = ""s;
   buffer = m.module_eval(code);
@@ -505,7 +511,7 @@ TESTCASE(double_ptr_array)
     .define_method("ptr", &Matrix2Double::ptr);
 
   std::string code = R"(matrix = Matrix2Double.new
-                        buffer = matrix.ptr
+                        buffer = matrix.ptr.buffer
                         buffer.to_ary(5))";
 
   std::vector<double> expected = std::vector<double>{ 1.0,2.0,3.0,4.0,5.0 };
@@ -514,7 +520,7 @@ TESTCASE(double_ptr_array)
   ASSERT_EQUAL(expected, actual);
 
   code = R"(matrix = Matrix2Double.new
-             buffer = matrix.ptr
+             buffer = matrix.ptr.buffer
              buffer.to_ary(0))";
 
   expected = std::vector<double>{ };
@@ -522,3 +528,4 @@ TESTCASE(double_ptr_array)
   actual = array.to_vector<double>();
   ASSERT_EQUAL(expected, actual);
 }
+*/

data/test/test_Type.cpp

@@ -1,7 +1,8 @@
-#include "unittest.hpp"
+#include "unittest.hpp"
 #include "embed_ruby.hpp"
 
 #include <rice/rice.hpp>
+#include <rice/stl.hpp>
 
 #include <complex>
 
@@ -40,120 +41,322 @@ TESTCASE(FindGroup)
 {
   std::string name = "class std::vector<class cv::Vec<unsigned char, 2>, class std::allocator<class cv::Vec<unsigned char, 2> > >";
 
-  std::string group = detail::findGroup(name, 0);
+  detail::TypeMapper<int> typeMapper;
+  std::string group = typeMapper.findGroup(name, 0);
   ASSERT_EQUAL("<class cv::Vec<unsigned char, 2>, class std::allocator<class cv::Vec<unsigned char, 2> > >", group.c_str());
 
-  group = detail::findGroup(name, 18);
+  group = typeMapper.findGroup(name, 18);
   ASSERT_EQUAL("<unsigned char, 2>", group.c_str());
   
-  group = detail::findGroup(name, 49);
+  group = typeMapper.findGroup(name, 49);
   ASSERT_EQUAL("<class cv::Vec<unsigned char, 2> >", group.c_str());
 
   ASSERT_EXCEPTION_CHECK(
     std::runtime_error,
-    detail::findGroup(name, 48),
+    typeMapper.findGroup(name, 48),
       ASSERT_EQUAL("Unbalanced Group", ex.what())
   );
 }
 
-TESTCASE(CppClassName)
+TESTCASE(SimplifiedName)
 {
-  std::string typeName = detail::typeName(typeid(std::string));
-  std::string className = detail::cppClassName(typeName);
+  detail::TypeMapper<char*> typeMapper1;
+  std::string className = typeMapper1.simplifiedName();
+  ASSERT_EQUAL("char*", className.c_str());
+
+  detail::TypeMapper<char**> typeMapper2;
+  className = typeMapper2.simplifiedName();
+  ASSERT_EQUAL("char**", className.c_str());
+
+  detail::TypeMapper<double> typeMapper3;
+  className = typeMapper3.simplifiedName();
+  ASSERT_EQUAL("double", className.c_str());
+
+  detail::TypeMapper<double*> typeMapper4;
+  className = typeMapper4.simplifiedName();
+  ASSERT_EQUAL("double*", className.c_str());
+
+  detail::TypeMapper<std::string> typeMapper5;
+  className = typeMapper5.simplifiedName();
   ASSERT_EQUAL("std::string", className.c_str());
 
-  typeName = detail::typeName(typeid(std::wstring));
-  className = detail::cppClassName(typeName);
+  detail::TypeMapper<std::wstring> typeMapper6;
+  className = typeMapper6.simplifiedName();
   ASSERT_EQUAL("std::wstring", className.c_str());
 
-  typeName = detail::typeName(typeid(std::vector<std::string>));
-  className = detail::cppClassName(typeName);
+  detail::TypeMapper<std::vector<std::string>> typeMapper7;
+  className = typeMapper7.simplifiedName();
   ASSERT_EQUAL("std::vector<std::string>", className.c_str());
 
-  typeName = detail::typeName(typeid(std::vector<std::wstring>));
-  className = detail::cppClassName(typeName);
+  detail::TypeMapper<std::vector<std::wstring>> typeMapper8;
+  className = typeMapper8.simplifiedName();
   ASSERT_EQUAL("std::vector<std::wstring>", className.c_str());
 
-  typeName = detail::typeName(typeid(std::vector<double*>));
-  className = detail::cppClassName(typeName);
+  detail::TypeMapper<std::vector<double*>> typeMapper9;
+  className = typeMapper9.simplifiedName();
   ASSERT_EQUAL("std::vector<double*>", className.c_str());
 
-  typeName = detail::typeName(typeid(std::vector<double**>));
-  className = detail::cppClassName(typeName);
+  detail::TypeMapper<std::vector<double**>> typeMapper10;
+  className = typeMapper10.simplifiedName();
   ASSERT_EQUAL("std::vector<double**>", className.c_str());
 
-  typeName = detail::typeName(typeid(Outer::Inner::Vec1));
-  className = detail::cppClassName(typeName);
+  detail::TypeMapper<Outer::Inner::Vec1> typeMapper11;
+  className = typeMapper11.simplifiedName();
   ASSERT_EQUAL("std::vector<std::complex<float>>", className.c_str());
 
-  typeName = detail::typeName(typeid(Outer::Inner::Vec2));
-  className = detail::cppClassName(typeName);
+  detail::TypeMapper<Outer::Inner::Vec2> typeMapper12;
+  className = typeMapper12.simplifiedName();
   ASSERT_EQUAL("std::vector<unsigned char*>", className.c_str());
 
-  typeName = detail::typeName(typeid(Outer::Inner::Vec3));
-  className = detail::cppClassName(typeName);
+  detail::TypeMapper<Outer::Inner::Vec3> typeMapper13;
+  className = typeMapper13.simplifiedName();
   ASSERT_EQUAL("std::vector<Outer::Inner::SomeClass>", className.c_str());
 
-  typeName = detail::typeName(typeid(Outer::Inner::Map1));
-  className = detail::cppClassName(typeName);
+  detail::TypeMapper<Outer::Inner::Map1> typeMapper14;
+  className = typeMapper14.simplifiedName();
   ASSERT_EQUAL("std::map<std::string, std::vector<std::complex<float>>>", className.c_str());
 
-  typeName = detail::typeName(typeid(Outer::Inner::UnorderedMap1));
-  className = detail::cppClassName(typeName);
+  detail::TypeMapper<Outer::Inner::UnorderedMap1> typeMapper15;
+  className = typeMapper15.simplifiedName();
   ASSERT_EQUAL("std::unordered_map<std::string, std::complex<float>>", className.c_str());
 }
 
-TESTCASE(RubyClassName)
+TESTCASE(RubyName)
 {
-  std::string typeName = detail::typeName(typeid(std::string));
-  std::string className = detail::rubyClassName(typeName);
+  detail::TypeMapper<char*> typeMapper1;
+  std::string className = typeMapper1.rubyName();
+  ASSERT_EQUAL("String", className.c_str());
+
+  detail::TypeMapper<const unsigned char> typeMapper2;
+  className = typeMapper2.rubyName();
+  ASSERT_EQUAL("String", className.c_str());
+
+  detail::TypeMapper<const unsigned char*> typeMapper3;
+  className = typeMapper3.rubyName();
+  ASSERT_EQUAL("UnsignedChar", className.c_str());
+
+  detail::TypeMapper<char**> typeMapper4;
+  className = typeMapper4.rubyName();
+  ASSERT_EQUAL("Char", className.c_str());
+
+  detail::TypeMapper<double> typeMapper5;
+  className = typeMapper5.rubyName();
+  ASSERT_EQUAL("Float", className.c_str());
+
+  detail::TypeMapper<double*> typeMapper6;
+  className = typeMapper6.rubyName();
+  ASSERT_EQUAL("Double", className.c_str());
+
+  detail::TypeMapper<Buffer<double*>> typeMapper7;
+  className = typeMapper7.rubyName();
+  ASSERT_EQUAL("Buffer≺double∗≻", className.c_str());
+
+  detail::TypeMapper<std::string> typeMapper8;
+  className = typeMapper8.rubyName();
   ASSERT_EQUAL("String", className.c_str());
 
-  typeName = detail::typeName(typeid(std::wstring));
-  className = detail::rubyClassName(typeName);
+  detail::TypeMapper<std::wstring> typeMapper9;
+  className = typeMapper9.rubyName();
   ASSERT_EQUAL("Wstring", className.c_str());
 
-  typeName = detail::typeName(typeid(std::vector<std::string>));
-  className = detail::rubyClassName(typeName);
+  detail::TypeMapper<std::vector<std::string>> typeMapper10;
+  className = typeMapper10.rubyName();
   ASSERT_EQUAL("Vector≺string≻", className.c_str());
 
-  typeName = detail::typeName(typeid(std::vector<std::wstring>));
-  className = detail::rubyClassName(typeName);
+  detail::TypeMapper<std::vector<std::wstring>> typeMapper11;
+  className = typeMapper11.rubyName();
   ASSERT_EQUAL("Vector≺wstring≻", className.c_str());
 
-  typeName = detail::typeName(typeid(std::vector<double*>));
-  className = detail::rubyClassName(typeName);
+  detail::TypeMapper<std::vector<double*>> typeMapper12;
+  className = typeMapper12.rubyName();
   ASSERT_EQUAL("Vector≺double∗≻", className.c_str());
 
-  typeName = detail::typeName(typeid(std::vector<double**>));
-  className = detail::rubyClassName(typeName);
+  detail::TypeMapper<std::vector<double**>> typeMapper13;
+  className = typeMapper13.rubyName();
   ASSERT_EQUAL("Vector≺double∗∗≻", className.c_str());
 
-  typeName = detail::typeName(typeid(Outer::Inner::Vec1));
-  className = detail::rubyClassName(typeName);
+  detail::TypeMapper<Outer::Inner::Vec1> typeMapper14;
+  className = typeMapper14.rubyName();
   ASSERT_EQUAL("Vector≺complex≺float≻≻", className.c_str());
 
-  typeName = detail::typeName(typeid(Outer::Inner::Vec2));
-  className = detail::rubyClassName(typeName);
+  detail::TypeMapper<Outer::Inner::Vec2> typeMapper15;
+  className = typeMapper15.rubyName();
   ASSERT_EQUAL("Vector≺unsigned char∗≻", className.c_str());
 
-  typeName = detail::typeName(typeid(Outer::Inner::Vec3));
-  className = detail::rubyClassName(typeName);
+  detail::TypeMapper<Outer::Inner::Vec3> typeMapper16;
+  className = typeMapper16.rubyName();
   ASSERT_EQUAL("Vector≺Outer꞉꞉Inner꞉꞉SomeClass≻", className.c_str());
 
-  typeName = detail::typeName(typeid(Outer::Inner::Map1));
-  className = detail::rubyClassName(typeName);
+  detail::TypeMapper<Outer::Inner::Map1> typeMapper17;
+  className = typeMapper17.rubyName();
   ASSERT_EQUAL("Map≺string‚ vector≺complex≺float≻≻≻", className.c_str());
 
-  typeName = detail::typeName(typeid(Outer::Inner::UnorderedMap1));
-  className = detail::rubyClassName(typeName);
+  detail::TypeMapper<Outer::Inner::UnorderedMap1> typeMapper18;
+  className = typeMapper18.rubyName();
   ASSERT_EQUAL("UnorderedMap≺string‚ complex≺float≻≻", className.c_str());
+
+  detail::TypeMapper<Outer::Inner::SomeClass*> typeMapper19;
+  className = typeMapper19.rubyName();
+  ASSERT_EQUAL("SomeClass", className.c_str());
+}
+
+TESTCASE(RubyKlass)
+{
+  Module riceModule = define_module("Rice");
+
+  detail::TypeMapper<int> typeMapper1;
+  VALUE actual = typeMapper1.rubyKlass();
+  ASSERT_EQUAL(rb_cInteger, actual);
+
+  detail::TypeMapper<const int> typeMapper2;
+  actual = typeMapper2.rubyKlass();
+  ASSERT_EQUAL(rb_cInteger, actual);
+
+  detail::TypeMapper<int&> typeMapper3;
+  actual = typeMapper3.rubyKlass();
+  ASSERT_EQUAL(rb_cInteger, actual);
+
+  detail::TypeMapper<const int&> typeMapper4;
+  actual = typeMapper4.rubyKlass();
+  ASSERT_EQUAL(rb_cInteger, actual);
+
+  detail::TypeMapper<char*> typeMapper5;
+  actual = typeMapper5.rubyKlass();
+  ASSERT_EQUAL(rb_cString, actual);
+
+  detail::TypeMapper<const unsigned char> typeMapper6;
+  actual = typeMapper6.rubyKlass();
+  ASSERT_EQUAL(rb_cString, actual);
+
+  define_buffer<unsigned char>();
+  Object expected = riceModule.const_get("Buffer≺unsigned char≻");
+  detail::TypeMapper<Buffer<unsigned char>> typeMapper8;
+  actual = typeMapper8.rubyKlass();
+  ASSERT_EQUAL(expected.value(), actual);
+
+  expected = Object(rb_cObject).const_get("String");
+  detail::TypeMapper<char*> typeMapper9;
+  actual = typeMapper9.rubyKlass();
+  ASSERT_EQUAL(expected.value(), actual);
+
+  define_pointer<char*>();
+  expected = riceModule.const_get("Pointer≺char∗≻");
+  detail::TypeMapper<char**> typeMapper10;
+  actual = typeMapper10.rubyKlass();
+  ASSERT_EQUAL(expected.value(), actual);
+
+  define_pointer<char*>();
+  expected = riceModule.const_get("Pointer≺char∗≻");
+  detail::TypeMapper<const char**> typeMapper11;
+  actual = typeMapper11.rubyKlass();
+  ASSERT_EQUAL(expected.value(), actual);
+
+  define_buffer<char**>();
+  expected = riceModule.const_get("Buffer≺char∗≻");
+  detail::TypeMapper<Buffer<char*>> typeMapper12;
+  actual = typeMapper12.rubyKlass();
+  ASSERT_EQUAL(expected.value(), actual);
+
+  detail::TypeMapper<double> typeMapper13;
+  actual = typeMapper13.rubyKlass();
+  ASSERT_EQUAL(rb_cFloat, actual);
+
+  define_pointer<double>();
+  expected = riceModule.const_get("Pointer≺double≻");
+  detail::TypeMapper<volatile double*> typeMapper14;
+  actual = typeMapper14.rubyKlass();
+  ASSERT_EQUAL(expected.value(), actual);
+
+  define_pointer<double*>();
+  expected = riceModule.const_get("Pointer≺double∗≻");
+  detail::TypeMapper<const volatile double**> typeMapper15;
+  actual = typeMapper15.rubyKlass();
+  ASSERT_EQUAL(expected.value(), actual);
+
+  detail::TypeMapper<std::string> typeMapper16;
+  actual = typeMapper16.rubyKlass();
+  ASSERT_EQUAL(rb_cString, actual);
+
+  define_pointer<std::string>();
+  detail::TypeMapper<std::string*> typeMapper17;
+  expected = riceModule.const_get("Pointer≺string≻");
+  actual = typeMapper17.rubyKlass();
+  ASSERT_EQUAL(expected.value(), actual);
+
+  define_pointer<std::string*>();
+  detail::TypeMapper<std::string**> typeMapper18;
+  expected = riceModule.const_get("Pointer≺string∗≻");
+  actual = typeMapper18.rubyKlass();
+  ASSERT_EQUAL(expected.value(), actual);
+  
+  define_vector<std::string>();
+  Module stdModule("Std");
+
+  detail::TypeMapper<std::vector<std::string>> typeMapper19;
+  expected = stdModule.const_get("Vector≺string≻");
+  actual = typeMapper19.rubyKlass();
+  ASSERT_EQUAL(expected.value(), actual);
+
+  define_class<Outer::Inner::Vec1>("Vec1");
+  detail::TypeMapper<Outer::Inner::Vec1> typeMapper20;
+  expected = Object(rb_cObject).const_get("Vec1");
+  actual = typeMapper20.rubyKlass();
+  ASSERT_EQUAL(expected.value(), actual);
+
+  define_class<Outer::Inner::Map1>("Map1");
+  detail::TypeMapper<Outer::Inner::Map1> typeMapper21;
+  expected = Object(rb_cObject).const_get("Map1");
+  actual = typeMapper21.rubyKlass();
+  ASSERT_EQUAL(expected.value(), actual);
+
+  define_class<Outer::Inner::UnorderedMap1>("UnorderedMap1");
+  detail::TypeMapper<Outer::Inner::UnorderedMap1> typeMapper22;
+  expected = Object(rb_cObject).const_get("UnorderedMap1");
+  actual = typeMapper22.rubyKlass();
+  ASSERT_EQUAL(expected.value(), actual);
+ 
+  define_class<Outer::Inner::SomeClass>("SomeClass");
+  detail::TypeMapper<Outer::Inner::SomeClass**> typeMapper23;
+  expected = Object(rb_cObject).const_get("SomeClass");
+  actual = typeMapper23.rubyKlass();
+  ASSERT_EQUAL(expected.value(), actual);
+
+  using Callback_T = char*(*)(int, double, bool, char*);
+  detail::TypeMapper<Callback_T> typeMapper24;
+  expected = Object(rb_cObject).const_get("Proc");
+  actual = typeMapper24.rubyKlass();
+  ASSERT_EQUAL(expected.value(), actual);
+
+  detail::TypeMapper<std::tuple<float, float>> typeMapper25;
+  expected = Object(rb_cObject).const_get("Array");
+  actual = typeMapper25.rubyKlass();
+  ASSERT_EQUAL(expected.value(), actual);
+
+  detail::TypeMapper<std::optional<float>> typeMapper26;
+  actual = typeMapper26.rubyKlass();
+  ASSERT_EQUAL(rb_cFloat, actual);
+
+  detail::TypeMapper<std::complex<float>> typeMapper27;
+  actual = typeMapper27.rubyKlass();
+  ASSERT_EQUAL(rb_cComplex, actual);
+
+  detail::TypeMapper<std::monostate> typeMapper28;
+  actual = typeMapper28.rubyKlass();
+  ASSERT_EQUAL(rb_cNilClass, actual);
+
+  detail::TypeMapper<std::reference_wrapper<int>> typeMapper29;
+  actual = typeMapper29.rubyKlass();
+  ASSERT_EQUAL(rb_cInteger, actual);
+
+  detail::TypeMapper<std::string_view> typeMapper30;
+  actual = typeMapper30.rubyKlass();
+  ASSERT_EQUAL(rb_cString, actual);
 }
 
 TESTCASE(MakeRubyClass)
 {
-  std::string typeName = detail::typeName(typeid(Outer::Inner::Vec1));
-  std::string rubyClassName = detail::rubyClassName(typeName);
+  detail::TypeMapper<Outer::Inner::Vec1> typeMapper;
+  std::string rubyClassName = typeMapper.rubyName();
 
   Module module = define_module("Testing");
 

data/test/unittest.hpp

@@ -263,6 +263,33 @@ void assert_not_equal(
   }
 }
 
+template<typename T, typename U, typename V>
+void assert_in_delta(
+  T const& expected,
+  U const& actual,
+  V const& delta,
+  std::string const& s_t,
+  std::string const& s_u,
+  std::string const& s_delta,
+  std::string const& file,
+  size_t line)
+{
+  // Negative deltas don't make sense; treat as failure for clarity.
+  if (delta < 0)
+  {
+    throw Assertion_Failed("assert_in_delta failed: negative delta");
+  }
+  
+  T diff = std::abs(expected - actual);
+  if (!(diff <= delta))
+  {
+    std::stringstream strm;
+    strm << "assert_in_delta failed: |" << actual << " - " << expected << "| = "
+         << diff << " > " << delta;
+    throw Assertion_Failed(strm.str());
+  }
+}
+
 #define FAIL(message, expect, got) \
   do \
   { \
@@ -285,6 +312,14 @@ void assert_not_equal(
     assert_not_equal((x), (y), #x, #y, __FILE__, __LINE__); \
   } while(0)
 
+#define ASSERT_IN_DELTA(x, y, delta) \
+  do \
+  { \
+    ++assertions; \
+    assert_in_delta((x), (y), (delta), #x, #y, #delta, __FILE__, __LINE__); \
+  } while(0)
+
+
 #define ASSERT(x) \
   ASSERT_EQUAL(true, !!x);