rice 4.5.0 → 4.6.0

data/test/test_Buffer.cpp

@@ -0,0 +1,285 @@
+#include "unittest.hpp"
+#include "embed_ruby.hpp"
+#include <rice/rice.hpp>
+
+#include <limits>
+#include <cmath>
+
+using namespace Rice;
+
+TESTSUITE(Buffer);
+
+SETUP(Buffer)
+{
+  embed_ruby();
+}
+
+TEARDOWN(Buffer)
+{
+  rb_gc_start();
+}
+
+TESTCASE(Char)
+{
+  define_buffer<char>();
+
+  Module m = define_module("BufferTesting");
+
+  std::string code = R"(Rice::Buffer≺char≻.new("my string"))";
+  Object result = m.instance_eval(code);
+
+  ASSERT_EQUAL("Rice::Buffer≺char≻", result.class_name().c_str());
+  ASSERT_EQUAL("my string", String(result.call("bytes")).c_str());
+
+  Array array = result.call("to_ary");
+  ASSERT_EQUAL("109, 121, 32, 115, 116, 114, 105, 110, 103", array.join(", ").c_str());
+
+  Object size = result.call("size");
+  ASSERT_EQUAL(9, detail::From_Ruby<int>().convert(size));
+
+  Data_Object<Buffer<char>> dataObject(result);
+  Buffer<char> buffer = std::move(*dataObject);
+  ASSERT_EQUAL("my string", buffer.ptr());
+  ASSERT_EQUAL(9, (int)buffer.size());
+}
+
+TESTCASE(CharArray)
+{
+  define_buffer<char>();
+
+  Module m = define_module("BufferTesting");
+
+  std::string code = R"(Rice::Buffer≺char≻.new([0, 127, 128, 255, 256, -128, -129, -255]))";
+  Data_Object<Buffer<char>> result = m.instance_eval(code);
+  Buffer<char> buffer = std::move(*result);
+  char* data = buffer.ptr();
+
+  ASSERT_EQUAL(data[0], 0);
+  ASSERT_EQUAL(data[1], 127);
+  ASSERT_EQUAL(data[2], -128);
+  ASSERT_EQUAL(data[3], -1);
+  ASSERT_EQUAL(data[4], 0);
+  ASSERT_EQUAL(data[5], -128);
+  ASSERT_EQUAL(data[6], 127);
+  ASSERT_EQUAL(data[7], 1);
+}
+
+TESTCASE(signed_char_pointer)
+{
+  define_buffer<signed char>();
+  Module m = define_module("Testing");
+
+  std::string code = R"(Rice::Buffer≺signed char≻.new("my string"))";
+  Data_Object<Buffer<signed char>> result = m.instance_eval(code);
+  Buffer<signed char> buffer = std::move(*result);
+  signed char* data = buffer.ptr();
+
+  signed char* expected = (signed char*)"my string";
+  ASSERT_EQUAL(*expected, *data);
+
+  code = R"(Rice::Buffer≺signed char≻.new([0, 127, 128, 255, 256, -128, -129, -255]))";
+  result = m.instance_eval(code);
+  buffer = std::move(*result);
+  data = buffer.ptr();
+
+  ASSERT_EQUAL(data[0], 0);
+  ASSERT_EQUAL(data[1], 127);
+  ASSERT_EQUAL(data[2], -128);
+  ASSERT_EQUAL(data[3], -1);
+  ASSERT_EQUAL(data[4], 0);
+  ASSERT_EQUAL(data[5], -128);
+  ASSERT_EQUAL(data[6], 127);
+  ASSERT_EQUAL(data[7], 1);
+}
+
+TESTCASE(char_pointer_const)
+{
+  define_buffer<char>();
+  Module m = define_module("Testing");
+
+  std::string code = R"(Rice::Buffer≺char≻.new("my string"))";
+
+  Data_Object<Buffer<char>> result = m.instance_eval(code);
+  Buffer<char> buffer = std::move(*result);
+  char* data = buffer.ptr();
+
+  const char* expected = "my string";
+  ASSERT_EQUAL(expected, data);
+
+  code = R"(Rice::Buffer≺char≻.new(""))";
+  result = m.instance_eval(code);
+  buffer = std::move(*result);
+  data = buffer.ptr();
+
+  expected = "";
+  ASSERT_EQUAL(expected, data);
+}
+
+TESTCASE(unsigned_char_pointer)
+{
+  define_buffer<unsigned char>();
+  Module m = define_module("Testing");
+
+  std::string code = R"(Rice::Buffer≺unsigned char≻.new([0, 127, 128, 255, 256, -128, -129, -255]))";
+  Data_Object<Buffer<unsigned char>> result = m.instance_eval(code);
+  Buffer<unsigned char> buffer = std::move(*result);
+  unsigned char* data = buffer.ptr();
+
+  ASSERT_EQUAL(data[0], 0x0);
+  ASSERT_EQUAL(data[1], 0x7F);
+  ASSERT_EQUAL(data[2], 0x80);
+  ASSERT_EQUAL(data[3], 0xFF);
+  ASSERT_EQUAL(data[4], 0x00);
+  ASSERT_EQUAL(data[5], 0x80);
+  ASSERT_EQUAL(data[6], 0x7F);
+  ASSERT_EQUAL(data[7], 0x01);
+
+  code = R"(array = [0, 127, 128, 255, 256, -128, -129, -255]
+              packed = array.pack("C*")
+              Rice::Buffer≺unsigned char≻.new(packed))";
+  result = m.instance_eval(code);
+  buffer = std::move(*result);
+  data = buffer.ptr();
+
+  ASSERT_EQUAL(data[0], 0x0);
+  ASSERT_EQUAL(data[1], 0x7F);
+  ASSERT_EQUAL(data[2], 0x80);
+  ASSERT_EQUAL(data[3], 0xFF);
+  ASSERT_EQUAL(data[4], 0x00);
+  ASSERT_EQUAL(data[5], 0x80);
+  ASSERT_EQUAL(data[6], 0x7F);
+  ASSERT_EQUAL(data[7], 0x01);
+}
+
+TESTCASE(float_array_array)
+{
+  define_buffer<float*>();
+  Module m = define_module("Testing");
+
+  std::string code = R"(Rice::Buffer≺float∗≻.new([[1.1, 2.2], [3.3, 4.4], [5.5, 6.6]]))";
+  Data_Object<Buffer<float*>> result = m.instance_eval(code);
+  Buffer<float*> buffer = std::move(*result);
+
+  ASSERT_EQUAL(3, (int)buffer.size());
+
+  const Buffer<float>& bufferInner1 = buffer[0];
+  ASSERT_EQUAL(2, (int)bufferInner1.size());
+
+  const Buffer<float>& bufferInner2 = buffer[1];
+  ASSERT_EQUAL(2, (int)bufferInner2.size());
+
+  const Buffer<float>& bufferInner3 = buffer[2];
+  ASSERT_EQUAL(2, (int)bufferInner3.size());
+}
+
+TESTCASE(wrong_type)
+{
+  define_buffer<float*>();
+  Module m = define_module("Testing");
+
+  std::string code = R"(Rice::Buffer≺float∗≻.new([[4, "bad"], [2, 1]]))";
+
+  ASSERT_EXCEPTION_CHECK(
+    Exception,
+    m.module_eval(code),
+    ASSERT_EQUAL("can't convert String into Float", ex.what())
+  );
+}
+
+namespace
+{
+  void updateRef(int& ref)
+  {
+    ref = 4;
+  }
+
+  void updatePtr(int* ptr)
+  {
+    *ptr = 5;
+  }
+}
+
+TESTCASE(update_reference)
+{
+  define_buffer<int>();
+  Module m = define_module("Testing");
+  m.define_module_function("update_reference", &updateRef);
+
+  std::string code = R"(buffer = Rice::Buffer≺int≻.new(0)
+                        update_reference(buffer)
+                        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)
+            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)
+            buffer[1])";
+
+  ASSERT_EXCEPTION_CHECK(
+    Exception,
+    m.module_eval(code),
+    ASSERT_EQUAL("index 1 outside of bounds: 0..1", ex.what())
+  );
+}
+
+TESTCASE(update_ptr)
+{
+  define_buffer<int>();
+  Module m = define_module("Testing");
+  m.define_module_function("update_pointer", &updatePtr);
+
+  std::string code = R"(buffer = Rice::Buffer≺int≻.new(0)
+                        update_pointer(buffer)
+                        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)
+            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)
+            buffer[1])";
+
+  ASSERT_EXCEPTION_CHECK(
+    Exception,
+    m.module_eval(code),
+    ASSERT_EQUAL("index 1 outside of bounds: 0..1", ex.what())
+  );
+}
+
+TESTCASE(update_buffer)
+{
+  define_buffer<int>();
+  Module m = define_module("Testing");
+
+  std::string code = R"(buffer = Rice::Buffer≺int≻.new(0)
+                        buffer[0] = 8
+                        buffer[0])";
+
+  Object result = m.module_eval(code);
+  ASSERT_EQUAL(8, detail::From_Ruby<int>().convert(result));
+
+  code = R"(buffer = Rice::Buffer≺int≻.new(0)
+            buffer[1] = 9
+            buffer[1])";
+
+  ASSERT_EXCEPTION_CHECK(
+    Exception,
+    m.module_eval(code),
+    ASSERT_EQUAL("index 1 outside of bounds: 0..1", ex.what())
+  );
+}

data/test/test_Callback.cpp

@@ -3,7 +3,6 @@
 #include "unittest.hpp"
 #include "embed_ruby.hpp"
 #include <rice/rice.hpp>
-#include <rice/stl.hpp>
 
 using namespace Rice;
 
@@ -140,7 +139,7 @@ namespace
   using Callback_T2 = char*(*)();
   std::vector<Callback_T2> callbacks;
 
-  void registerCallback(Callback_T2 callback1, Callback_T2 callback2)
+  void registerTwoCallbacks(Callback_T2 callback1, Callback_T2 callback2)
   {
     callbacks.push_back(callback1);
     callbacks.push_back(callback2);
@@ -157,7 +156,7 @@ namespace
 TESTCASE(MultipleCallbacks)
 {
   Module m = define_module("TestingMultipleCallbacks");
-  m.define_module_function<void(*)(Callback_T2, Callback_T2)>("register_callback", registerCallback).
+  m.define_module_function<void(*)(Callback_T2, Callback_T2)>("register_callback", registerTwoCallbacks).
     define_module_function<char*(*)(int)>("trigger_callback", triggerCallback);
 
   std::string code = R"(proc1 = Proc.new do 

data/test/test_Data_Object.cpp

@@ -1,5 +1,3 @@
-#include <ruby/version.h>
-
 #include "unittest.hpp"
 #include "embed_ruby.hpp"
 #include <rice/rice.hpp>
@@ -15,7 +13,7 @@ namespace
 
   struct MyDataType
   {
-    MyDataType() : x(42)
+    MyDataType(int value) : x(value)
     {
     }
 
@@ -27,6 +25,17 @@ namespace
     int x;
   };
 
+  static MyDataType myDataTypes[] = { 1,2,3 };
+  MyDataType* dataTypes()
+  {
+    return myDataTypes;
+  }
+
+  int dataTypesCount()
+  {
+    return sizeof(myDataTypes)/sizeof(MyDataType);
+  }
+
   struct Bar
   {
   };
@@ -63,18 +72,18 @@ TEARDOWN(Data_Object)
   rb_gc_start();
 }
 
-TESTCASE(construct_from_pointer)
+TESTCASE(data_object_construct_from_pointer)
 {
-  MyDataType* myDataType = new MyDataType;
+  MyDataType* myDataType = new MyDataType(42);
   Data_Object<MyDataType> wrapped_foo(myDataType);
   ASSERT_EQUAL(myDataType, wrapped_foo.get());
   ASSERT_EQUAL(Data_Type<MyDataType>::klass(), wrapped_foo.class_of());
   ASSERT_EQUAL(myDataType, detail::unwrap<MyDataType>(wrapped_foo, Data_Type<MyDataType>::ruby_data_type(), false));
 }
 
-TESTCASE(construct_from_ruby_object)
+TESTCASE(data_object_construct_from_ruby_object)
 {
-  MyDataType * myDataType = new MyDataType;
+  MyDataType * myDataType = new MyDataType(42);
   VALUE wrapped_foo = detail::wrap(Data_Type<MyDataType>::klass(), Data_Type<MyDataType>::ruby_data_type(), myDataType, true);
 
   Data_Object<MyDataType> data_object_foo(wrapped_foo);
@@ -84,9 +93,9 @@ TESTCASE(construct_from_ruby_object)
   ASSERT_EQUAL(myDataType, detail::unwrap<MyDataType>(wrapped_foo, Data_Type<MyDataType>::ruby_data_type(), false));
 }
 
-TESTCASE(construct_from_ruby_object_and_wrong_class)
+TESTCASE(data_object_construct_from_ruby_object_and_wrong_class)
 {
-  MyDataType * myDataType = new MyDataType;
+  MyDataType * myDataType = new MyDataType(42);
   VALUE wrapped_foo = detail::wrap(Data_Type<MyDataType>::klass(), Data_Type<MyDataType>::ruby_data_type(), myDataType, true);
 
   ASSERT_EXCEPTION_CHECK(
@@ -100,9 +109,9 @@ TESTCASE(construct_from_ruby_object_and_wrong_class)
     ASSERT_EQUAL("Wrong argument type. Expected: Bar. Received: MyDataType.", ex.what()));
 }
 
-TESTCASE(copy_construct)
+TESTCASE(data_object_copy_construct)
 {
-  MyDataType * myDataType = new MyDataType;
+  MyDataType * myDataType = new MyDataType(42);
   VALUE wrapped_foo = detail::wrap(Data_Type<MyDataType>::klass(), Data_Type<MyDataType>::ruby_data_type(), myDataType, true);
   Data_Object<MyDataType> orig_data_object_foo(wrapped_foo);
   Data_Object<MyDataType> data_object_foo(orig_data_object_foo);
@@ -113,9 +122,9 @@ TESTCASE(copy_construct)
   ASSERT_EQUAL(myDataType, detail::unwrap<MyDataType>(wrapped_foo, Data_Type<MyDataType>::ruby_data_type(), false));
 }
 
-TESTCASE(move_construct)
+TESTCASE(data_object_move_construct)
 {
-  MyDataType* myDataType = new MyDataType;
+  MyDataType* myDataType = new MyDataType(42);
 
   Data_Object<MyDataType> wrapper1(myDataType);
   Data_Object<MyDataType> wrapper2(std::move(wrapper1));
@@ -124,12 +133,12 @@ TESTCASE(move_construct)
   ASSERT((wrapper1.get() == nullptr));
 }
 
-TESTCASE(move_assign)
+TESTCASE(data_object_move_assign)
 {
-  MyDataType* foo1 = new MyDataType;
+  MyDataType* foo1 = new MyDataType(42);
   Data_Object<MyDataType> wrapper1(foo1);
 
-  MyDataType* foo2 = new MyDataType;
+  MyDataType* foo2 = new MyDataType(42);
   Data_Object<MyDataType> wrapper2(foo2);
 
   wrapper2 = std::move(wrapper1);
@@ -138,74 +147,119 @@ TESTCASE(move_assign)
   ASSERT((wrapper1.get() == nullptr));
 }
 
-TESTCASE(dereference)
+TESTCASE(data_object_dereference)
 {
   Data_Type<MyDataType> rb_cFoo;
-  MyDataType * myDataType = new MyDataType;
+  MyDataType * myDataType = new MyDataType(42);
   Data_Object<MyDataType> wrapped_foo(myDataType);
   ASSERT_EQUAL(myDataType, &*wrapped_foo);
 }
 
-TESTCASE(arrow)
+TESTCASE(data_object_arrow)
 {
   Data_Type<MyDataType> rb_cFoo;
-  MyDataType * myDataType = new MyDataType;
+  MyDataType * myDataType = new MyDataType(42);
   Data_Object<MyDataType> wrapped_foo(myDataType);
   ASSERT_EQUAL(42, myDataType->x);
 }
 
-TESTCASE(get)
+TESTCASE(data_object_get)
 {
   Data_Type<MyDataType> rb_cFoo;
-  MyDataType * myDataType = new MyDataType;
+  MyDataType * myDataType = new MyDataType(42);
   Data_Object<MyDataType> wrapped_foo(myDataType);
   ASSERT_EQUAL(myDataType, wrapped_foo.get());
 }
 
-TESTCASE(to_ruby)
+TESTCASE(data_object_to_ruby)
 {
   Data_Type<MyDataType> rb_cFoo;
-  MyDataType * myDataType = new MyDataType;
+  MyDataType * myDataType = new MyDataType(42);
   Data_Object<MyDataType> wrapped_foo(myDataType);
   ASSERT_EQUAL(String("MyDataType"), wrapped_foo.class_name());
 }
 
-TESTCASE(from_ruby)
+TESTCASE(data_object_from_ruby)
 {
   Data_Type<MyDataType> rb_cFoo;
-  MyDataType* myDataType = new MyDataType();
+  MyDataType* myDataType = new MyDataType(42);
   Data_Object<MyDataType> wrapped_foo(myDataType);
   ASSERT_EQUAL(myDataType, wrapped_foo.get());
 }
 
-TESTCASE(from_ruby_const_ref)
+TESTCASE(data_object_from_ruby_const_ref)
 {
   Data_Type<MyDataType> rb_cFoo;
-  MyDataType * myDataType = new MyDataType;
+  MyDataType * myDataType = new MyDataType(42);
   Data_Object<MyDataType> wrapped_foo(myDataType);
   ASSERT_EQUAL(myDataType->x, detail::From_Ruby<MyDataType const &>().convert(wrapped_foo).x);
 }
 
-TESTCASE(from_ruby_copy)
+TESTCASE(data_object_from_ruby_copy)
 {
   Data_Type<MyDataType> rb_cFoo;
-  MyDataType * myDataType = new MyDataType;
+  MyDataType * myDataType = new MyDataType(42);
   Data_Object<MyDataType> wrapped_foo(myDataType);
   ASSERT_EQUAL(myDataType->x, detail::From_Ruby<MyDataType>().convert(wrapped_foo).x);
 }
 
-TESTCASE(ruby_custom_mark)
+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->get(2);
+  ASSERT_EQUAL(100, myDataType.x);
+}
+
+TESTCASE(data_object_ruby_custom_mark)
 {
   test_ruby_mark_called = false;
 
-  MyDataType* myDataType = new MyDataType;
+  MyDataType* myDataType = new MyDataType(42);
   Data_Object<MyDataType> wrapped_foo(myDataType);
   rb_gc_start();
 
   ASSERT_EQUAL(true, test_ruby_mark_called);
 }
 
-TESTCASE(ruby_custom_free)
+TESTCASE(data_object_ruby_custom_free)
 {
   test_ruby_mark_called = false;
   test_destructor_called = false;
@@ -213,7 +267,7 @@ TESTCASE(ruby_custom_free)
   {
     // Put this code in a block so wrapped_foo is destroyed at the end of it.
     // That will set its value field to Qnil allowing myDataType to be freed
-    MyDataType* myDataType = new MyDataType;
+    MyDataType* myDataType = new MyDataType(42);
     Data_Object<MyDataType> wrapped_foo(myDataType, true);
 
     // Force a mark