rice 4.6.1 → 4.7.1

data/test/test_Stl_Vector.cpp

@@ -18,7 +18,7 @@ TEARDOWN(Vector)
 {
   rb_gc_start();
 }
-
+/*
 namespace
 {
   class MyClass
@@ -65,6 +65,22 @@ TESTCASE(StringVector)
   result = vec.call("last");
   ASSERT_EQUAL("four", detail::From_Ruby<std::string>().convert(result));
 }
+*/
+TESTCASE(StringVectorData)
+{
+  Module m = define_module("Testing");
+  define_vector<std::string>();
+
+  std::string code = R"(vec = Std::Vector≺string≻.new
+                        vec.push("Hello")
+                        vec.push("World")
+                        buffer = Rice::Buffer≺string≻.new(vec.data, vec.size())
+                        [buffer[0], buffer[1]])";
+  Array array = m.module_eval(code);
+  ASSERT_EQUAL(2, array.size());
+  ASSERT_EQUAL("Hello", detail::From_Ruby<std::string>().convert(array[0].value()).c_str());
+  ASSERT_EQUAL("World", detail::From_Ruby<std::string>().convert(array[1].value()).c_str());
+}
 
 TESTCASE(Constructors)
 {
@@ -171,6 +187,7 @@ TESTCASE(BoolVector)
   ASSERT_EQUAL(Qtrue, result.value());
 
   result = vec.call("[]=", 1, false);
+  result = vec.call("[]", 1);
   ASSERT_EQUAL(Qfalse, result.value());
 
   std::string code = R"(array = self.each.to_a
@@ -224,10 +241,30 @@ TESTCASE(Indexing)
   ASSERT_EQUAL(0, detail::From_Ruby<int32_t>().convert(result));
 
   result = vec.call("[]", -4);
-  ASSERT_EQUAL(2, detail::From_Ruby<int32_t>().convert(result));
+  ASSERT_EQUAL(Qnil, result.value());
 
   result = vec.call("[]", -7);
-  ASSERT_EQUAL(2, detail::From_Ruby<int32_t>().convert(result));
+  ASSERT_EQUAL(Qnil, result.value());
+}
+
+TESTCASE(IndexingEmptyVector)
+{
+  Module m = define_module("Testing");
+
+  Class c = define_vector<std::int32_t>("IntVector");
+  Object vec = c.call("new");
+
+  Object result = vec.call("size");
+  ASSERT_EQUAL(0, detail::From_Ruby<int32_t>().convert(result));
+
+  result = vec.call("[]", 0);
+  ASSERT_EQUAL(Qnil, result.value());
+
+  result = vec.call("[]", 1);
+  ASSERT_EQUAL(Qnil, result.value());
+
+  result = vec.call("[]", -1);
+  ASSERT_EQUAL(Qnil, result.value());
 }
 
 TESTCASE(Slice)
@@ -312,8 +349,7 @@ TESTCASE(Update)
   Object result = vec.call("size");
   ASSERT_EQUAL(2, detail::From_Ruby<int32_t>().convert(result));
 
-  result = vec.call("[]=", 1, "new 2");
-  ASSERT_EQUAL("new 2", detail::From_Ruby<std::string>().convert(result));
+  vec.call("[]=", 1, "new 2");
 
   result = vec.call("[]", 1);
   ASSERT_EQUAL("new 2", detail::From_Ruby<std::string>().convert(result));
@@ -346,21 +382,35 @@ TESTCASE(Modify)
   result = vec.call("to_s");
   ASSERT_EQUAL("[11, 33, 22]", detail::From_Ruby<std::string>().convert(result));
 
+  result = vec.call("insert", -2, 34);
+
+  result = vec.call("size");
+  ASSERT_EQUAL(4, detail::From_Ruby<int32_t>().convert(result));
+
+  result = vec.call("to_s");
+  ASSERT_EQUAL("[11, 33, 34, 22]", detail::From_Ruby<std::string>().convert(result));
+
   result = vec.call("delete", 11);
   ASSERT_EQUAL(11, detail::From_Ruby<int64_t>().convert(result));
 
   result = vec.call("size");
-  ASSERT_EQUAL(2, detail::From_Ruby<int32_t>().convert(result));
+  ASSERT_EQUAL(3, detail::From_Ruby<int32_t>().convert(result));
 
   result = vec.call("delete_at", 0);
   ASSERT_EQUAL(33, detail::From_Ruby<int64_t>().convert(result));
 
   result = vec.call("size");
-  ASSERT_EQUAL(1, detail::From_Ruby<int32_t>().convert(result));
+  ASSERT_EQUAL(2, detail::From_Ruby<int32_t>().convert(result));
 
   result = vec.call("pop");
   ASSERT_EQUAL(22, detail::From_Ruby<int64_t>().convert(result));
 
+  result = vec.call("size");
+  ASSERT_EQUAL(1, detail::From_Ruby<int32_t>().convert(result));
+
+  result = vec.call("pop");
+  ASSERT_EQUAL(34, detail::From_Ruby<int32_t>().convert(result));
+
   result = vec.call("size");
   ASSERT_EQUAL(0, detail::From_Ruby<int32_t>().convert(result));
 
@@ -390,6 +440,44 @@ TESTCASE(Clone)
   ASSERT_NOT_EQUAL(vec.size(), vecClone.size());
 }
 
+
+namespace
+{
+  class SomeClass
+  {
+  public:
+    SomeClass(int value) : value(value)
+    {
+    }
+    int value;
+  };
+
+  std::vector<std::unique_ptr<SomeClass>> uniqueVector()
+  {
+    std::vector<std::unique_ptr<SomeClass>> result;
+    result.push_back(std::make_unique<SomeClass>(1));
+    result.push_back(std::make_unique<SomeClass>(2));
+    return result;
+  }
+}
+
+TESTCASE(UniqueVector)
+{
+  Module m(anonymous_module());
+
+  Class c = define_class<SomeClass>("SomeClass").
+    define_constructor(Constructor<SomeClass, int>()).
+    define_attr("value", &SomeClass::value);
+
+  m.define_module_function("unique_vector", &uniqueVector);
+
+  std::string code = R"(vector = unique_vector
+                        vector.size)";
+
+  Object result = m.module_eval(code);
+  ASSERT_EQUAL(2, detail::From_Ruby<int32_t>().convert(result));
+}
+
 namespace
 {
   class NotComparable
@@ -637,9 +725,9 @@ TESTCASE(AutoRegisterParameter)
   define_global_function("pass_complex_vector", &passComplexVector);
 
   std::string code = R"(vector = Std::Vector≺complex≺double≻≻.new
-                          vector << Complex(4.0, 4.0)
-                          vector << Complex(5.0, 5.0)
-                          pass_complex_vector(vector))";
+                        vector << Complex(4.0, 4.0)
+                        vector << Complex(5.0, 5.0)
+                        pass_complex_vector(vector))";
 
   Module m = define_module("Testing");
   Object vec = m.module_eval(code);
@@ -653,6 +741,24 @@ TESTCASE(AutoRegisterParameter)
   ASSERT_EQUAL(complexes[1], std::complex<double>(5, 5));
 }
 
+TESTCASE(AutoRegisterException)
+{
+  std::string code = R"(
+    begin
+      Std::Vector≺complex≺double≻≻.new('!!!!')
+    rescue => e
+      name = e.class.name
+      "#{e.class.name} #{e.message} #{(e.backtrace || []).join("\n")}"  # shoud not raise 'incompatible character encodings: BINARY (ASCII-8BIT) and UTF-8' ?
+    end
+    "reachable! - #{name}"
+  )";
+
+  Module m = define_module("Testing");
+  Object result = m.module_eval(code);
+  std::string actual = detail::From_Ruby<std::string>().convert(result);
+  ASSERT_EQUAL("reachable! - ArgumentError", actual);
+}
+
 namespace
 {
   std::vector<std::string> defaultVector(std::vector<std::string> strings = {"one", "two", "three"})
@@ -1005,9 +1111,8 @@ TESTCASE(StringPointerVector)
   ASSERT_EQUAL(expected, *actual);
 
   std::string code = R"(vec = vector_of_string_pointers
-                        outer_buffer = vec.data
-                        inner_buffers = outer_buffer.to_ary(2)
-                        inner_buffer = inner_buffers[1]
+                        outer_buffer = vec.data.buffer
+                        inner_buffer = Rice::Buffer≺string≻.new(outer_buffer[1])
                         inner_buffer.to_ary(1))";
   Array array = m.module_eval(code);
   ASSERT_EQUAL(1, array.size());

data/test/test_Symbol.cpp

@@ -73,3 +73,15 @@ TESTCASE(to_id)
   Symbol symbol("Foo");
   ASSERT_EQUAL(Identifier("Foo"), symbol.to_id());
 }
+
+namespace
+{
+  void testSymbolArg(Object self, Symbol string)
+  {
+  }
+}
+
+TESTCASE(use_symbol_in_wrapped_function)
+{
+  define_global_function("test_symbol_arg", &testSymbolArg);
+}

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);
 }
+*/