rice 4.5.0 → 4.6.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>
 
@@ -6,12 +6,14 @@
 #include <cmath>
 
 using namespace Rice;
+using namespace std::string_literals;
 
 TESTSUITE(ToRuby);
 
 SETUP(ToRuby)
 {
   embed_ruby();
+  define_fundamental_buffer_types();
 }
 
 TEARDOWN(ToRuby)
@@ -150,3 +152,373 @@ TESTCASE(char_const_array_to_ruby_symbol)
 {
   ASSERT(rb_equal(Symbol("foo").value(), detail::to_ruby(":foo")));
 }
+
+namespace
+{
+  template<typename T>
+  class Matrix2
+  {
+  public:
+    T* ptr()
+    {
+      return this->data;
+    }
+
+    T data[5] = { 1,2,3,4,5 };
+  };
+
+  using Matrix2UnsignedChar = Matrix2<unsigned char>;
+  using Matrix2Char = Matrix2<char>;
+  using Matrix2UnsignedShort = Matrix2<unsigned short>;
+  using Matrix2Short = Matrix2<short>;
+  using Matrix2UnsignedInt = Matrix2<unsigned int>;
+  using Matrix2Int = Matrix2<int>;
+  using Matrix2Float = Matrix2<float>;
+  using Matrix2Double = Matrix2<double>;
+
+  template<typename T>
+  class Matrix3
+  {
+  public:
+    T** ptr()
+    {
+      return this->data;
+    }
+
+  private:
+    T one = 1;
+    T two = 2;
+    T three = 3;
+    T four = 4;
+    T five = 5;
+
+  public:
+    T* data[5] = { &one, &two, &three, &four, &five };
+
+  };
+
+  using Matrix3UnsignedChar = Matrix3<unsigned char>;
+}
+
+TESTCASE(unsigned_char_ptr_buffer)
+{
+  Module m = define_module("ToRubyPtr");
+
+  Class c = define_class_under<Matrix2UnsignedChar>(m, "Matrix2UnsignedChar")
+    .define_constructor(Constructor<Matrix2UnsignedChar>())
+    .define_method("ptr", &Matrix2UnsignedChar::ptr)
+    .define_attr("data", &Matrix2UnsignedChar::data, Rice::AttrAccess::Read);
+
+  std::string code = R"(matrix = Matrix2UnsignedChar.new
+                        buffer = matrix.ptr
+                        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
+            buffer.bytes(0))";
+  buffer = m.module_eval(code);
+  ASSERT_EQUAL("", buffer.str());
+
+  code = R"(matrix = Matrix2UnsignedChar.new
+            buffer = matrix.data
+            buffer.bytes)";
+
+  buffer = m.module_eval(code);
+  ASSERT_EQUAL("\x1\x2\x3\x4\x5", buffer.str());
+}
+
+TESTCASE(unsigned_char_ptr_array)
+{
+  Module m = define_module("ToRubyPtr");
+
+  Class c = define_class_under<Matrix2UnsignedChar>(m, "Matrix2UnsignedChar")
+    .define_constructor(Constructor<Matrix2UnsignedChar>())
+    .define_method("ptr", &Matrix2UnsignedChar::ptr);
+
+  std::string code = R"(matrix = Matrix2UnsignedChar.new
+                        buffer = matrix.ptr
+                        buffer.to_ary(5))";
+
+  std::vector<unsigned char> expected = std::vector<unsigned char>{ 1,2,3,4,5 };
+  Array array = m.module_eval(code);
+  std::vector<unsigned char> actual = array.to_vector<unsigned char>();
+  ASSERT_EQUAL(expected, actual);
+
+  code = R"(matrix = Matrix2UnsignedChar.new
+           buffer = matrix.ptr
+           buffer.to_ary(1))";
+
+  expected = std::vector<unsigned char>{ 1 };
+  array = m.module_eval(code);
+  actual = array.to_vector<unsigned char>();
+  ASSERT_EQUAL(expected, actual);
+}
+
+TESTCASE(unsigned_char_ptr_ptr_buffer)
+{
+  Module m = define_module("ToRubyPtr");
+
+  Class c = define_class_under<Matrix3UnsignedChar>(m, "Matrix3UnsignedChar")
+    .define_constructor(Constructor<Matrix3UnsignedChar>())
+    .define_method("ptr", &Matrix3UnsignedChar::ptr)
+    .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))";
+  Array array = m.module_eval(code);
+  ASSERT_EQUAL(5, array.size());
+
+  std::vector<unsigned char> expected{ 1, 2, 3, 4, 5 };
+  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");
+
+  Class c = define_class_under<Matrix3UnsignedChar>(m, "Matrix3UnsignedChar")
+    .define_constructor(Constructor<Matrix3UnsignedChar>())
+    .define_method("ptr", &Matrix3UnsignedChar::ptr);
+
+  std::string code = R"(matrix = Matrix3UnsignedChar.new
+                        buffer = matrix.ptr
+                        buffer.to_ary(5))";
+
+  Array pointers = m.module_eval(code);
+  ASSERT_EQUAL(5, pointers.size());
+
+  for (int i = 0; i < pointers.size(); i++)
+  {
+    Object buffer = pointers[i];
+    Array array = buffer.call("to_ary", 1);
+
+    std::vector<unsigned char> expected = std::vector<unsigned char>{ (unsigned char)(i + 1) };
+    std::vector<unsigned char> actual = array.to_vector<unsigned char>();
+    ASSERT_EQUAL(expected, actual);
+  }
+}
+
+TESTCASE(short_ptr_buffer)
+{
+  Module m = define_module("ToRubyPtr");
+
+  Class c = define_class_under<Matrix2Short>(m, "Matrix2Short")
+    .define_constructor(Constructor<Matrix2Short>())
+    .define_method("ptr", &Matrix2Short::ptr);
+
+  std::string code = R"(matrix = Matrix2Short.new
+                        buffer = matrix.ptr
+                        buffer.bytes(5))";
+
+  std::string expected = "\x1\0\x2\0\x3\0\x4\0\x5\0"s;
+  String buffer = m.module_eval(code);
+  ASSERT_EQUAL(expected, buffer.str());
+
+  code = R"(matrix = Matrix2Short.new
+                        buffer = matrix.ptr
+                        buffer.bytes(0))";
+  expected = ""s;
+  buffer = m.module_eval(code);
+  ASSERT_EQUAL(expected, buffer.str());
+}
+
+TESTCASE(short_ptr_array)
+{
+  Module m = define_module("ToRubyPtr");
+
+  Class c = define_class_under<Matrix2Short>(m, "Matrix2Short")
+    .define_constructor(Constructor<Matrix2Short>())
+    .define_method("ptr", &Matrix2Short::ptr);
+
+  std::string code = R"(matrix = Matrix2Short.new
+                        buffer = matrix.ptr
+                        buffer.to_ary(5))";
+
+   std::vector<short> expected = std::vector<short>{1,2,3,4,5};
+   Array array = m.module_eval(code);
+   std::vector<short> actual = array.to_vector<short>();
+   ASSERT_EQUAL(expected, actual);
+}
+
+TESTCASE(unsigned_short_ptr_buffer)
+{
+  Module m = define_module("ToRubyPtr");
+
+  Class c = define_class_under<Matrix2UnsignedShort>(m, "Matrix2UnsignedShort")
+    .define_constructor(Constructor<Matrix2UnsignedShort>())
+    .define_method("ptr", &Matrix2UnsignedShort::ptr);
+
+  std::string code = R"(matrix = Matrix2UnsignedShort.new
+                        buffer = matrix.ptr
+                        buffer.bytes(5))";
+
+  std::string expected = "\x1\0\x2\0\x3\0\x4\0\x5\0"s;
+  String buffer = m.module_eval(code);
+  ASSERT_EQUAL(expected, buffer.str());
+
+  code = R"(matrix = Matrix2UnsignedShort.new
+            buffer = matrix.ptr
+            buffer.bytes(0))";
+  expected = ""s;
+  buffer = m.module_eval(code);
+  ASSERT_EQUAL(expected, buffer.str());
+}
+
+TESTCASE(unsigned_short_ptr_array)
+{
+  Module m = define_module("ToRubyPtr");
+
+  Class c = define_class_under<Matrix2UnsignedShort>(m, "Matrix2UnsignedShort")
+    .define_constructor(Constructor<Matrix2UnsignedShort>())
+    .define_method("ptr", &Matrix2UnsignedShort::ptr);
+
+  std::string code = R"(matrix = Matrix2UnsignedShort.new
+                        buffer = matrix.ptr
+                        buffer.to_ary(5))";
+
+  std::vector<unsigned short> expected = std::vector<unsigned short>{ 1,2,3,4,5 };
+  Array array = m.module_eval(code);
+  std::vector<unsigned short> actual = array.to_vector<unsigned short>();
+  ASSERT_EQUAL(expected, actual);
+}
+
+TESTCASE(int_ptr_buffer)
+{
+  Module m = define_module("ToRubyPtr");
+
+  Class c = define_class_under<Matrix2Int>(m, "Matrix2Int")
+    .define_constructor(Constructor<Matrix2Int>())
+    .define_method("ptr", &Matrix2Int::ptr);
+
+  std::string code = R"(matrix = Matrix2Int.new
+                        buffer = matrix.ptr
+                        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;
+  String buffer = m.module_eval(code);
+  ASSERT_EQUAL(expected, buffer.str());
+
+  code = R"(matrix = Matrix2Int.new
+            buffer = matrix.ptr
+            buffer.bytes(0))";
+  expected = ""s;
+  buffer = m.module_eval(code);
+  ASSERT_EQUAL(expected, buffer.str());
+}
+
+TESTCASE(int_ptr_array)
+{
+  Module m = define_module("ToRubyPtr");
+
+  Class c = define_class_under<Matrix2Int>(m, "Matrix2Int")
+    .define_constructor(Constructor<Matrix2Int>())
+    .define_method("ptr", &Matrix2Int::ptr);
+
+  std::string code = R"(matrix = Matrix2Int.new
+                        buffer = matrix.ptr
+                        buffer.to_ary(5))";
+
+  std::vector<int> expected = std::vector<int>{ 1,2,3,4,5 };
+  Array array = m.module_eval(code);
+  std::vector<int> actual = array.to_vector<int>();
+  ASSERT_EQUAL(expected, actual);
+}
+
+TESTCASE(float_ptr_buffer)
+{
+  Module m = define_module("ToRubyPtr");
+
+  Class c = define_class_under<Matrix2Float>(m, "Matrix2Float")
+    .define_constructor(Constructor<Matrix2Float>())
+    .define_method("ptr", &Matrix2Float::ptr);
+
+  std::string code = R"(matrix = Matrix2Float.new
+                        buffer = matrix.ptr
+                        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;
+  String buffer = m.module_eval(code);
+  ASSERT_EQUAL(expected, buffer.str());
+
+ code = R"(matrix = Matrix2Float.new
+            buffer = matrix.ptr
+            buffer.bytes(0))";
+  expected = ""s;
+  buffer = m.module_eval(code);
+  ASSERT_EQUAL(expected, buffer.str());
+}
+
+TESTCASE(float_ptr_array)
+{
+  Module m = define_module("ToRubyPtr");
+
+  Class c = define_class_under<Matrix2Float>(m, "Matrix2Float")
+    .define_constructor(Constructor<Matrix2Float>())
+    .define_method("ptr", &Matrix2Float::ptr);
+
+  std::string code = R"(matrix = Matrix2Float.new
+                        buffer = matrix.ptr
+                        buffer.to_ary(5))";
+
+  std::vector<float> expected = std::vector<float>{ 1.0,2.0,3.0,4.0,5.0 };
+  Array array = m.module_eval(code);
+  std::vector<float> actual = array.to_vector<float>();
+  ASSERT_EQUAL(expected, actual);
+}
+
+TESTCASE(double_ptr_buffer)
+{
+  Module m = define_module("ToRubyPtr");
+
+  Class c = define_class_under<Matrix2Double>(m, "Matrix2Double")
+    .define_constructor(Constructor<Matrix2Double>())
+    .define_method("ptr", &Matrix2Double::ptr);
+
+  std::string code = R"(matrix = Matrix2Double.new
+                        buffer = matrix.ptr
+                        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;
+  String buffer = m.module_eval(code);
+  const char* ptr = RSTRING_PTR(buffer.value());
+  ASSERT_EQUAL(expected, buffer.str());
+
+  code = R"(matrix = Matrix2Double.new
+            buffer = matrix.ptr
+            buffer.bytes(0))";
+  expected = ""s;
+  buffer = m.module_eval(code);
+  ASSERT_EQUAL(expected, buffer.str());
+}
+
+TESTCASE(double_ptr_array)
+{
+  Module m = define_module("ToRubyPtr");
+
+  Class c = define_class_under<Matrix2Double>(m, "Matrix2Double")
+    .define_constructor(Constructor<Matrix2Double>())
+    .define_method("ptr", &Matrix2Double::ptr);
+
+  std::string code = R"(matrix = Matrix2Double.new
+                        buffer = matrix.ptr
+                        buffer.to_ary(5))";
+
+  std::vector<double> expected = std::vector<double>{ 1.0,2.0,3.0,4.0,5.0 };
+  Array array = m.module_eval(code);
+  std::vector<double> actual = array.to_vector<double>();
+  ASSERT_EQUAL(expected, actual);
+
+  code = R"(matrix = Matrix2Double.new
+             buffer = matrix.ptr
+             buffer.to_ary(0))";
+
+  expected = std::vector<double>{ };
+  array = m.module_eval(code);
+  actual = array.to_vector<double>();
+  ASSERT_EQUAL(expected, actual);
+}

data/test/test_Type.cpp

@@ -56,33 +56,104 @@ TESTCASE(FindGroup)
   );
 }
 
-TESTCASE(MakeClassName)
+TESTCASE(CppClassName)
 {
-  std::string typeName = detail::typeName(typeid(Outer::Inner::Vec1));
-  std::string className = detail::makeClassName(typeName);
-  ASSERT_EQUAL(u8"Vector≺complex≺float≻≻", className.c_str());
+  std::string typeName = detail::typeName(typeid(std::string));
+  std::string className = detail::cppClassName(typeName);
+  ASSERT_EQUAL("std::string", className.c_str());
+
+  typeName = detail::typeName(typeid(std::wstring));
+  className = detail::cppClassName(typeName);
+  ASSERT_EQUAL("std::wstring", className.c_str());
+
+  typeName = detail::typeName(typeid(std::vector<std::string>));
+  className = detail::cppClassName(typeName);
+  ASSERT_EQUAL("std::vector<std::string>", className.c_str());
+
+  typeName = detail::typeName(typeid(std::vector<std::wstring>));
+  className = detail::cppClassName(typeName);
+  ASSERT_EQUAL("std::vector<std::wstring>", className.c_str());
+
+  typeName = detail::typeName(typeid(std::vector<double*>));
+  className = detail::cppClassName(typeName);
+  ASSERT_EQUAL("std::vector<double*>", className.c_str());
+
+  typeName = detail::typeName(typeid(std::vector<double**>));
+  className = detail::cppClassName(typeName);
+  ASSERT_EQUAL("std::vector<double**>", className.c_str());
+
+  typeName = detail::typeName(typeid(Outer::Inner::Vec1));
+  className = detail::cppClassName(typeName);
+  ASSERT_EQUAL("std::vector<std::complex<float>>", className.c_str());
+
+  typeName = detail::typeName(typeid(Outer::Inner::Vec2));
+  className = detail::cppClassName(typeName);
+  ASSERT_EQUAL("std::vector<unsigned char*>", className.c_str());
+
+  typeName = detail::typeName(typeid(Outer::Inner::Vec3));
+  className = detail::cppClassName(typeName);
+  ASSERT_EQUAL("std::vector<Outer::Inner::SomeClass>", className.c_str());
+
+  typeName = detail::typeName(typeid(Outer::Inner::Map1));
+  className = detail::cppClassName(typeName);
+  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);
+  ASSERT_EQUAL("std::unordered_map<std::string, std::complex<float>>", className.c_str());
+}
+
+TESTCASE(RubyClassName)
+{
+  std::string typeName = detail::typeName(typeid(std::string));
+  std::string className = detail::rubyClassName(typeName);
+  ASSERT_EQUAL("String", className.c_str());
+
+  typeName = detail::typeName(typeid(std::wstring));
+  className = detail::rubyClassName(typeName);
+  ASSERT_EQUAL("Wstring", className.c_str());
+
+  typeName = detail::typeName(typeid(std::vector<std::string>));
+  className = detail::rubyClassName(typeName);
+  ASSERT_EQUAL("Vector≺string≻", className.c_str());
+
+  typeName = detail::typeName(typeid(std::vector<std::wstring>));
+  className = detail::rubyClassName(typeName);
+  ASSERT_EQUAL("Vector≺wstring≻", className.c_str());
+
+  typeName = detail::typeName(typeid(std::vector<double*>));
+  className = detail::rubyClassName(typeName);
+  ASSERT_EQUAL("Vector≺double∗≻", className.c_str());
+
+  typeName = detail::typeName(typeid(std::vector<double**>));
+  className = detail::rubyClassName(typeName);
+  ASSERT_EQUAL("Vector≺double∗∗≻", className.c_str());
+
+  typeName = detail::typeName(typeid(Outer::Inner::Vec1));
+  className = detail::rubyClassName(typeName);
+  ASSERT_EQUAL("Vector≺complex≺float≻≻", className.c_str());
 
   typeName = detail::typeName(typeid(Outer::Inner::Vec2));
-  className = detail::makeClassName(typeName);
-  ASSERT_EQUAL(u8"Vector≺unsigned char*≻", className.c_str());
+  className = detail::rubyClassName(typeName);
+  ASSERT_EQUAL("Vector≺unsigned char∗≻", className.c_str());
 
   typeName = detail::typeName(typeid(Outer::Inner::Vec3));
-  className = detail::makeClassName(typeName);
-  ASSERT_EQUAL(u8"Vector≺Outer꞉꞉Inner꞉꞉SomeClass≻", className.c_str());
+  className = detail::rubyClassName(typeName);
+  ASSERT_EQUAL("Vector≺Outer꞉꞉Inner꞉꞉SomeClass≻", className.c_str());
 
   typeName = detail::typeName(typeid(Outer::Inner::Map1));
-  className = detail::makeClassName(typeName);
-  ASSERT_EQUAL(u8"Map≺string≺char≻‚ vector≺complex≺float≻≻≻", className.c_str());
+  className = detail::rubyClassName(typeName);
+  ASSERT_EQUAL("Map≺string‚ vector≺complex≺float≻≻≻", className.c_str());
 
   typeName = detail::typeName(typeid(Outer::Inner::UnorderedMap1));
-  className = detail::makeClassName(typeName);
-  ASSERT_EQUAL(u8"UnorderedMap≺string≺char≻‚ complex≺float≻≻", className.c_str());
+  className = detail::rubyClassName(typeName);
+  ASSERT_EQUAL("UnorderedMap≺string‚ complex≺float≻≻", className.c_str());
 }
 
 TESTCASE(MakeRubyClass)
 {
   std::string typeName = detail::typeName(typeid(Outer::Inner::Vec1));
-  std::string rubyClassName = detail::makeClassName(typeName);
+  std::string rubyClassName = detail::rubyClassName(typeName);
 
   Module module = define_module("Testing");
 
@@ -96,5 +167,5 @@ TESTCASE(MakeRubyClass)
 
   // FIXME - fails compilation on GCC
   // Symbol element = result[0];
-  // ASSERT_EQUAL(u8"Vector≺complex≺float≻≻", element.c_str());
+  // ASSERT_EQUAL("Vector≺complex≺float≻≻", element.c_str());
 }

data/test/test_global_functions.cpp

@@ -16,8 +16,8 @@ TEARDOWN(GlobalFunctions)
   rb_gc_start();
 }
 
-namespace {
-
+namespace
+{
   bool no_args()
   {
     return true;
@@ -136,8 +136,8 @@ TESTCASE(default_arguments_for_define_global_function)
 
 TESTCASE(default_arguments_kw)
 {
-  define_global_function("defaults_method_one_kw", &defaults_method_one, 
-    Arg("arg1"), Arg("arg2"), Arg("arg3") = true);
+  define_global_function("defaults_method_one_kw", &defaults_method_one,
+    Arg("arg1"), Arg("arg2") = 3, Arg("arg3") = true);
   Module m = Module(rb_mKernel);
 
   std::string code = R"(defaults_method_one_kw(4, arg2: 5))";
@@ -151,6 +151,19 @@ TESTCASE(default_arguments_kw)
   ASSERT_EQUAL(9, defaults_method_one_arg1);
   ASSERT_EQUAL(11, defaults_method_one_arg2);
   ASSERT(!defaults_method_one_arg3);
+
+  code = R"(defaults_method_one_kw(4, arg3: false))";
+  m.instance_eval(code);
+  ASSERT_EQUAL(4, defaults_method_one_arg1);
+  ASSERT_EQUAL(3, defaults_method_one_arg2);
+  ASSERT_EQUAL(false, defaults_method_one_arg3);
+
+  code = R"(defaults_method_one_kw(arg2: 5))";
+  ASSERT_EXCEPTION_CHECK(
+    Exception,
+    m.instance_eval(code),
+    ASSERT_EQUAL("Missing argument. Name: arg1. Index: 0.", ex.what())
+  );
 }
 
 TESTCASE(default_arguments_and_returning)