rice 4.6.1 → 4.7.0

data/test/test_Buffer.cpp

@@ -43,6 +43,28 @@ TESTCASE(Char)
   ASSERT_EQUAL(9, (int)buffer.size());
 }
 
+TESTCASE(CharMethods)
+{
+  define_buffer<char>();
+  std::vector<detail::Native*> natives = detail::Registries::instance.natives.lookup(Data_Type<Buffer<char>>::klass());
+  ASSERT_EQUAL((size_t)12, natives.size());
+
+  define_buffer<char>();
+  natives = detail::Registries::instance.natives.lookup(Data_Type<Buffer<char>>::klass());
+  ASSERT_EQUAL((size_t)12, natives.size());
+}
+
+TESTCASE(CharPointerMethods)
+{
+  define_buffer<char*>();
+  std::vector<detail::Native*> natives = detail::Registries::instance.natives.lookup(Data_Type<Buffer<char*>>::klass());
+  ASSERT_EQUAL((size_t)12, natives.size());
+
+  define_buffer<char*>();
+  natives = detail::Registries::instance.natives.lookup(Data_Type<Buffer<char*>>::klass());
+  ASSERT_EQUAL((size_t)12, natives.size());
+}
+
 TESTCASE(CharArray)
 {
   define_buffer<char>();
@@ -64,6 +86,31 @@ TESTCASE(CharArray)
   ASSERT_EQUAL(data[7], 1);
 }
 
+TESTCASE(ConstChar)
+{
+  define_buffer<const char>();
+
+  Module m = define_module("BufferTesting");
+
+  std::string code = R"(Rice::Buffer≺char const≻.new("my string"))";
+  Object object = m.instance_eval(code);
+  ASSERT_EQUAL("Rice::Buffer≺char const≻", object.class_name().c_str());
+
+  String bytes = object.call("bytes");
+  ASSERT_EQUAL(std::string("my string"), bytes.str());
+
+  Array array = object.call("to_ary");
+  ASSERT_EQUAL("109, 121, 32, 115, 116, 114, 105, 110, 103", array.join(", ").c_str());
+
+  Object size = object.call("size");
+  ASSERT_EQUAL(9, detail::From_Ruby<int>().convert(size));
+
+  Data_Object<Buffer<const char>> dataObject(object);
+  Buffer<const char> buffer = std::move(*dataObject);
+  ASSERT_EQUAL(std::string("my string"), std::string(buffer.ptr(), buffer.size()));
+  ASSERT_EQUAL(9, (int)buffer.size());
+}
+
 TESTCASE(signed_char_pointer)
 {
   define_buffer<signed char>();
@@ -162,14 +209,17 @@ TESTCASE(float_array_array)
 
   ASSERT_EQUAL(3, (int)buffer.size());
 
-  const Buffer<float>& bufferInner1 = buffer[0];
-  ASSERT_EQUAL(2, (int)bufferInner1.size());
+  float* values = buffer[0];
+  ASSERT_IN_DELTA(1.1, values[0], 0.1);
+  ASSERT_IN_DELTA(2.2, values[1], 0.1);
 
-  const Buffer<float>& bufferInner2 = buffer[1];
-  ASSERT_EQUAL(2, (int)bufferInner2.size());
+  values = buffer[1];
+  ASSERT_IN_DELTA(3.3, values[0], 0.1);
+  ASSERT_IN_DELTA(4.4, values[1], 0.1);
 
-  const Buffer<float>& bufferInner3 = buffer[2];
-  ASSERT_EQUAL(2, (int)bufferInner3.size());
+  values = buffer[2];
+  ASSERT_IN_DELTA(5.5, values[0], 0.1);
+  ASSERT_IN_DELTA(6.6, values[1], 0.1);
 }
 
 TESTCASE(wrong_type)
@@ -186,6 +236,43 @@ TESTCASE(wrong_type)
   );
 }
 
+namespace
+{
+  static double Speeds[] = { 44.0, 55.0, 66.0 };
+  static double* SpeedsPtr[] = { new double(44.0), new double(55.0), new double(66.0) };
+
+  double* speeds()
+  {
+    return Speeds;
+  }
+
+  double** speedsPtr()
+  {
+    return SpeedsPtr;
+  }
+}
+
+TESTCASE(pointer_of_doubles)
+{
+  Module m = define_module("Testing").
+    define_module_function("speeds", &speeds, Return().setBuffer()).
+    define_module_function("speeds_ptr", &speedsPtr, Return().setBuffer());
+
+  std::string code = R"(buffer = Rice::Buffer≺double≻.new(speeds, 3)
+                        buffer[2])";
+
+  Object result = m.module_eval(code);
+  ASSERT_EQUAL(66.0, detail::From_Ruby<double>().convert(result));
+
+  code = R"(buffer_outer = Rice::Buffer≺double∗≻.new(speeds_ptr, 3)
+            data = buffer_outer[2]
+            buffer_inner = Rice::Buffer≺double≻.new(data, 1)
+            buffer_inner[0])";
+
+  result = m.module_eval(code);
+  ASSERT_EQUAL(66.0, detail::From_Ruby<double>().convert(result));
+}
+
 namespace
 {
   void updateRef(int& ref)
@@ -206,21 +293,21 @@ TESTCASE(update_reference)
   m.define_module_function("update_reference", &updateRef);
 
   std::string code = R"(buffer = Rice::Buffer≺int≻.new(0)
-                        update_reference(buffer)
+                        update_reference(buffer.data)
                         buffer.to_ary(1).first)";
 
   Object result = m.module_eval(code);
   ASSERT_EQUAL(4, detail::From_Ruby<int>().convert(result));
 
   code = R"(buffer = Rice::Buffer≺int≻.new(0)
-            update_reference(buffer)
+            update_reference(buffer.data)
             buffer[0])";
 
   result = m.module_eval(code);
   ASSERT_EQUAL(4, detail::From_Ruby<int>().convert(result));
 
   code = R"(buffer = Rice::Buffer≺int≻.new(0)
-            update_reference(buffer)
+            update_reference(buffer.data)
             buffer[1])";
 
   ASSERT_EXCEPTION_CHECK(
@@ -237,21 +324,21 @@ TESTCASE(update_ptr)
   m.define_module_function("update_pointer", &updatePtr);
 
   std::string code = R"(buffer = Rice::Buffer≺int≻.new(0)
-                        update_pointer(buffer)
+                        update_pointer(buffer.data)
                         buffer.to_ary(1).first)";
 
   Object result = m.module_eval(code);
   ASSERT_EQUAL(5, detail::From_Ruby<int>().convert(result));
 
   code = R"(buffer = Rice::Buffer≺int≻.new(0)
-            update_pointer(buffer)
+            update_pointer(buffer.data)
             buffer[0])";
 
   result = m.module_eval(code);
   ASSERT_EQUAL(5, detail::From_Ruby<int>().convert(result));
 
   code = R"(buffer = Rice::Buffer≺int≻.new(0)
-            update_pointer(buffer)
+            update_pointer(buffer.data)
             buffer[1])";
 
   ASSERT_EXCEPTION_CHECK(
@@ -284,6 +371,21 @@ TESTCASE(update_buffer)
   );
 }
 
+TESTCASE(update_buffer_ptr)
+{
+  define_buffer<int*>();
+
+  Module m = define_module("Testing");
+
+  std::string code = R"(buffer = Rice::Buffer≺int∗≻.new([[0, 1], [2, 3]])
+                        inner = Rice::Buffer≺int≻.new(buffer[1], 2)
+                        inner[1] = 9
+                        inner[1])";
+
+  Object result = m.module_eval(code);
+  ASSERT_EQUAL(9, detail::From_Ruby<int>().convert(result));
+}
+
 TESTCASE(to_s)
 {
   define_buffer<unsigned char>();
@@ -301,40 +403,214 @@ TESTCASE(to_s)
 
 namespace
 {
-  class MyClass
+  class MyClassBuf
   {
   public:
-    MyClass(int id) : id(id)
+    MyClassBuf(int id) : id(id)
     {
     }
 
-    MyClass& operator=(const MyClass&) = delete;
+   // MyClassBuf& operator=(const MyClassBuf&) = delete;
 
     int id;
   };
+
+  static MyClassBuf myClassBufs[] = { 1,2,3 };
+  static MyClassBuf* myClassBufsPtr[] = { new MyClassBuf(1), new MyClassBuf(2), new MyClassBuf(3) };
+
+  MyClassBuf* classBufs()
+  {
+    return myClassBufs;
+  }
+
+  MyClassBuf** classBufsPtr()
+  {
+    return myClassBufsPtr;
+  }
+
+  size_t sumIds(const MyClassBuf* myClasses, size_t count)
+  {
+    int result = 0;
+    for (size_t i = 0; i < count; i++)
+    {
+      const MyClassBuf& myClass = myClasses[i];
+      result += myClass.id;
+    }
+    return result;
+  }
+
+  size_t sumIds(const MyClassBuf** myClasses, size_t count)
+  {
+    int result = 0;
+    for (size_t i = 0; i < count; i++)
+    {
+      const MyClassBuf* myClass = myClasses[i];
+        result += myClass->id;
+    }
+    return result;
+  }
 }
 
 TESTCASE(array_of_objects)
 {
-  define_buffer<MyClass*>();
+  define_buffer<MyClassBuf>();
+
+  define_class<MyClassBuf>("MyClassBuf").
+    define_constructor(Constructor<MyClassBuf, int>()).
+    define_attr("id", &MyClassBuf::id);
+
+  std::string code = R"(array = [MyClassBuf.new(0), MyClassBuf.new(1)]
+                        buffer = Rice::Buffer≺AnonymousNamespace꞉꞉MyClassBuf≻.new(array)
+                        buffer[1].id)";
+
+  Module m = define_module("Testing");
+  Object result = m.module_eval(code);
+  ASSERT_EQUAL(1, detail::From_Ruby<int>().convert(result));
+}
+
+TESTCASE(update_array_of_objects)
+{
+  define_buffer<MyClassBuf>();
 
-  define_class<MyClass>("MyClass").
-    define_constructor(Constructor<MyClass, int>()).
-    define_attr("id", &MyClass::id);
+  define_class<MyClassBuf>("MyClassBuf").
+    define_constructor(Constructor<MyClassBuf, int>()).
+    define_attr("id", &MyClassBuf::id);
 
-  std::string code = R"(array = [MyClass.new(0), MyClass.new(1)]
-                        buffer = Rice::Buffer≺AnonymousNamespace꞉꞉MyClass∗≻.new(array)
+  std::string code = R"(array = [MyClassBuf.new(0), MyClassBuf.new(1)]
+                        buffer = Rice::Buffer≺AnonymousNamespace꞉꞉MyClassBuf≻.new(array)
+                        buffer[1] = MyClassBuf.new(8)
+                        buffer[1].id)";
+
+  Module m = define_module("Testing");
+  Object result = m.module_eval(code);
+  ASSERT_EQUAL(8, detail::From_Ruby<int>().convert(result));
+}
+
+TESTCASE(pointer_of_objects)
+{
+  define_buffer<MyClassBuf>();
+  define_buffer<MyClassBuf*>();
+
+  Module m = define_module("Testing").
+    define_module_function("class_buffs", &classBufs).
+    define_module_function("class_buffs_ptr", &classBufsPtr);
+
+  define_class<MyClassBuf>("MyClassBuf").
+    define_constructor(Constructor<MyClassBuf, int>()).
+    define_attr("id", &MyClassBuf::id);
+
+  std::string code = R"(buffer = Rice::Buffer≺AnonymousNamespace꞉꞉MyClassBuf≻.new(class_buffs, 3)
+                        buffer[1].id)";
+
+  Object result = m.module_eval(code);
+  ASSERT_EQUAL(2, detail::From_Ruby<int>().convert(result));
+
+  code = R"(buffer = Rice::Buffer≺AnonymousNamespace꞉꞉MyClassBuf∗≻.new(class_buffs_ptr, 3)
+            buffer[2].id)";
+
+  result = m.module_eval(code);
+  ASSERT_EQUAL(3, detail::From_Ruby<int>().convert(result));
+}
+
+TESTCASE(update_pointer_of_objects)
+{
+  define_buffer<MyClassBuf*>();
+
+  Module m = define_module("Testing").
+    define_module_function("class_buffs", &classBufs).
+    define_module_function("class_buffs_ptr", &classBufsPtr);
+
+  define_class<MyClassBuf>("MyClassBuf").
+    define_constructor(Constructor<MyClassBuf, int>()).
+    define_attr("id", &MyClassBuf::id);
+
+  std::string code = R"(buffer = Rice::Buffer≺AnonymousNamespace꞉꞉MyClassBuf∗≻.new(class_buffs_ptr, 3)
+                        inner = Rice::Buffer≺AnonymousNamespace꞉꞉MyClassBuf≻.new(buffer[2], 1)
+                        inner[0] = MyClassBuf.new(7)
+                        inner[0].id)";
+
+  Object result = m.module_eval(code);
+  ASSERT_EQUAL(7, detail::From_Ruby<int>().convert(result));
+
+  code = R"(buffer = Rice::Buffer≺AnonymousNamespace꞉꞉MyClassBuf∗≻.new(class_buffs_ptr, 3)
+            buffer[2] = MyClassBuf.new(9)
+            buffer[2].id)";
+
+  result = m.module_eval(code);
+  ASSERT_EQUAL(9, detail::From_Ruby<int>().convert(result));
+}
+
+TESTCASE(array_of_const_objects)
+{
+  define_buffer<const MyClassBuf*>();
+
+  define_class<MyClassBuf>("MyClassBuf").
+    define_constructor(Constructor<MyClassBuf, int>()).
+    define_attr("id", &MyClassBuf::id);
+
+  std::string code = R"(array = [MyClassBuf.new(0), MyClassBuf.new(1)]
+                        buffer = Rice::Buffer≺AnonymousNamespace꞉꞉MyClassBuf∗≻.new(array)
                         buffer[1].id)";
 
   Module m = define_module("Testing");
   Object result = m.module_eval(code);
   ASSERT_EQUAL(1, detail::From_Ruby<int>().convert(result));
 
-  code = R"(array = [MyClass.new(0), MyClass.new(1)]
-            buffer = Rice::Buffer≺AnonymousNamespace꞉꞉MyClass∗≻.new(array)
-            buffer[1] = MyClass.new(2)
-            buffer[1].id)";
+  code = R"(array = [MyClassBuf.new(0), MyClassBuf.new(1)]
+            buffer = Rice::Buffer≺AnonymousNamespace꞉꞉MyClassBuf∗≻.new(array)
+            my_class = buffer[1]
+            my_class.id)";
 
   result = m.module_eval(code);
-  ASSERT_EQUAL(2, detail::From_Ruby<int>().convert(result));
+  ASSERT_EQUAL(1, detail::From_Ruby<int>().convert(result));
+}
+
+TESTCASE(array_of_objects_ptr)
+{
+  define_buffer<MyClassBuf*>();
+
+  define_class<MyClassBuf>("MyClassBuf").
+    define_constructor(Constructor<MyClassBuf, int>()).
+    define_attr("id", &MyClassBuf::id);
+
+  std::string code = R"(array = [MyClassBuf.new(0), MyClassBuf.new(1)]
+                        buffer = Rice::Buffer≺AnonymousNamespace꞉꞉MyClassBuf∗≻.new(array)
+                        buffer[1].id)";
+
+  Module m = define_module("Testing");
+  Object result = m.module_eval(code);
+  ASSERT_EQUAL(1, detail::From_Ruby<int>().convert(result));
+
+  code = R"(array = [MyClassBuf.new(0), MyClassBuf.new(1)]
+            buffer = Rice::Buffer≺AnonymousNamespace꞉꞉MyClassBuf∗≻.new(array)
+            my_class = buffer[1]
+            my_class.id)";
+
+  result = m.module_eval(code);
+  ASSERT_EQUAL(1, detail::From_Ruby<int>().convert(result));
+}
+
+TESTCASE(pass_objects)
+{
+  Module m = define_module("Testing");
+  m.define_module_function<size_t(*)(const MyClassBuf*, size_t)>("sum_ids", &sumIds, Arg("myClasses").setBuffer());
+  m.define_module_function<size_t(*)(const MyClassBuf**, size_t)>("sum_ids_ptr", &sumIds);
+
+  define_class_under<MyClassBuf>(m, "MyClassBuf").
+    define_constructor(Constructor<MyClassBuf, int>()).
+    define_attr("id", &MyClassBuf::id);
+
+  std::string code = R"(array = [MyClassBuf.new(5), MyClassBuf.new(7)]
+                        buffer = Rice::Buffer≺AnonymousNamespace꞉꞉MyClassBuf≻.new(array)
+                        sum_ids(buffer.data, buffer.size))";
+
+  Object result = m.module_eval(code);
+  ASSERT_EQUAL(12, detail::From_Ruby<int>().convert(result));
+
+  code = R"(array = [MyClassBuf.new(5), MyClassBuf.new(7)]
+            buffer = Rice::Buffer≺AnonymousNamespace꞉꞉MyClassBuf∗≻.new(array)
+            sum_ids_ptr(buffer.data, buffer.size))";
+
+  result = m.module_eval(code);
+  ASSERT_EQUAL(12, detail::From_Ruby<int>().convert(result));
 }

data/test/test_Callback.cpp

@@ -47,12 +47,11 @@ TESTCASE(LambdaCallBack)
   ASSERT_EQUAL(globalCallback, nullptr);
 
   std::string code = R"(callback = lambda do |an_int, a_double, a_bool, a_string|
-                                      values = [an_int, a_double, a_bool, a_string]
-                                      values.map {|value| value.to_s}.join(" - ")
+                                     values = [an_int, a_double, a_bool, a_string]
+                                     values.map {|value| value.to_s}.join(" - ")
                                    end
                         register_callback(callback))";
 
-
   m.module_eval(code);
   ASSERT((globalCallback != nullptr));
 

data/test/test_Class.cpp

@@ -41,12 +41,12 @@ TESTCASE(include_module)
   ASSERT_EQUAL(&c, &c2);
   Array ancestors(c.ancestors());
   Array expected_ancestors;
-  expected_ancestors.push(c);
-  expected_ancestors.push(Module(rb_mEnumerable));
-  expected_ancestors.push(Module(rb_cObject));
-  expected_ancestors.push(Module(rb_mKernel));
+  expected_ancestors.push(c, false);
+  expected_ancestors.push(Module(rb_mEnumerable), false);
+  expected_ancestors.push(Module(rb_cObject), false);
+  expected_ancestors.push(Module(rb_mKernel), false);
 #ifdef RUBY_VM
-  expected_ancestors.push(Module(rb_cBasicObject));
+  expected_ancestors.push(Module(rb_cBasicObject), false);
 #endif
   ASSERT_EQUAL(expected_ancestors, ancestors);
 }

data/test/test_Data_Object.cpp

@@ -25,17 +25,6 @@ namespace
     int x;
   };
 
-  static MyDataType myDataTypes[] = { 1,2,3 };
-  MyDataType* dataTypes()
-  {
-    return myDataTypes;
-  }
-
-  int dataTypesCount()
-  {
-    return sizeof(myDataTypes)/sizeof(MyDataType);
-  }
-
   struct Bar
   {
   };
@@ -203,50 +192,6 @@ TESTCASE(data_object_from_ruby_copy)
   ASSERT_EQUAL(myDataType->x, detail::From_Ruby<MyDataType>().convert(wrapped_foo).x);
 }
 
-TESTCASE(data_object_return_array)
-{
-  define_buffer<MyDataType>();
-
-  Module m = define_module("DataObjectTest").
-    define_module_function("data_types", &dataTypes, Return().setArray()).
-    define_module_function("data_types_count", &dataTypesCount);
-
-  std::string code = R"(buffer = data_types
-                        count = data_types_count
-                        buffer.to_ary(count))";
-
-  Array dataTypes = m.module_eval(code);
-  ASSERT_EQUAL(3, dataTypes.size());
-
-  std::vector<MyDataType> vector = dataTypes.to_vector<MyDataType>();
-  ASSERT_EQUAL(1, vector[0].x);
-  ASSERT_EQUAL(2, vector[1].x);
-  ASSERT_EQUAL(3, vector[2].x);
-}
-
-TESTCASE(data_object_update_buffer)
-{
-  define_buffer<MyDataType>();
-
-  Class c = define_class<MyDataType>("MyDataType")
-    .define_constructor(Constructor<MyDataType, int>());
-
-  Module m = define_module("DataObjectTest").
-    define_module_function("data_types", &dataTypes, Return().setArray()).
-    define_module_function("data_types_count", &dataTypesCount);
-
-  std::string code = R"(buffer = data_types
-                        my_data_type = MyDataType.new(100)
-                        buffer.size = 3
-                        buffer[2] = my_data_type
-                        buffer)";
-
-  Object result = m.module_eval(code);
-  Data_Object<Buffer<MyDataType>> dataObject(result);
-  Buffer<MyDataType>* buffer = dataObject.get();
-  MyDataType myDataType = buffer->operator[](2);
-  ASSERT_EQUAL(100, myDataType.x);
-}
 
 TESTCASE(data_object_ruby_custom_mark)
 {