rice 4.3.3 → 4.6.0

data/test/test_Callback.cpp

@@ -0,0 +1,230 @@
+#include <functional>
+
+#include "unittest.hpp"
+#include "embed_ruby.hpp"
+#include <rice/rice.hpp>
+
+using namespace Rice;
+
+TESTSUITE(Callback);
+
+SETUP(Callback)
+{
+  embed_ruby();
+}
+
+TEARDOWN(Callback)
+{
+  rb_gc_start();
+}
+
+namespace
+{
+  using Callback_T = char*(*)(int, double, bool, char*);
+  Callback_T globalCallback;
+
+  void registerCallback(Callback_T callback)
+  {
+    globalCallback = callback;
+  }
+
+  char* triggerCallback(int anInt, double aDouble, bool aBool, char* aString)
+  {
+    if (globalCallback)
+    {
+      return globalCallback(anInt, aDouble, aBool, aString);
+    }
+    throw std::runtime_error("Callback has not been registered");
+  }
+}
+
+TESTCASE(LambdaCallBack)
+{
+  Module m = define_module("TestingLambda");
+  m.define_module_function("register_callback", registerCallback).
+    define_module_function("trigger_callback", triggerCallback);
+
+  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(" - ")
+                                   end
+                        register_callback(callback))";
+
+
+  m.module_eval(code);
+  ASSERT((globalCallback != nullptr));
+
+  String result = m.call("trigger_callback", 1, 2, true, "hello");
+  ASSERT_EQUAL("1 - 2.0 - true - hello", result.c_str());
+}
+
+TESTCASE(BlockCallBack)
+{
+  Module m = define_module("TestingBlock");
+  m.define_module_function("register_callback", registerCallback).
+    define_module_function("trigger_callback", triggerCallback);
+
+  std::string code = R"(register_callback 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(" - ")
+                        end)";
+
+  m.module_eval(code);
+
+  String result = m.call("trigger_callback", 4, 5.5, false, "Hello block");
+  ASSERT_EQUAL("4 - 5.5 - false - Hello block", result.c_str());
+}
+
+TESTCASE(ProcCallBack)
+{
+  Module m = define_module("TestingProc");
+  m.define_module_function("register_callback", registerCallback).
+    define_module_function("trigger_callback", triggerCallback);
+
+  std::string code = R"(callback = Proc.new 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(" - ")
+                                   end
+                        register_callback(callback))";
+
+  m.module_eval(code);
+
+  String result = m.call("trigger_callback", 8, 4.4, true, "Hello proc");
+  ASSERT_EQUAL("8 - 4.4 - true - Hello proc", result.c_str());
+}
+
+TESTCASE(MethodCallBack)
+{
+  Module m = define_module("TestingMethod");
+  m.define_module_function("register_callback", registerCallback).
+    define_module_function("trigger_callback", triggerCallback);
+
+  std::string code = R"(def self.callback(an_int, a_double, a_bool, a_string)
+                          values = [an_int, a_double, a_bool, a_string]
+                          values.map {|value| value.to_s}.join(" - ")
+                        end
+                        register_callback(method(:callback).to_proc))";
+
+  m.module_eval(code);
+
+  String result = m.call("trigger_callback", 11.1, 22.9, true, "Hello method");
+  ASSERT_EQUAL("11 - 22.9 - true - Hello method", result.c_str());
+}
+
+namespace
+{
+  int functionArg(int i, int(*f)(int))
+  {
+    return f(i);
+  }
+}
+
+TESTCASE(FunctionArg)
+{
+  Module m = define_module("TestingFunctionArg");
+  m.define_module_function("function_arg", functionArg);
+
+  std::string code = R"(function_arg(4) do |i|
+                          i * i
+                        end)";
+
+  Object result = m.module_eval(code);
+  ASSERT_EQUAL(16, detail::From_Ruby<int>().convert(result));
+}
+
+namespace
+{
+  using Callback_T2 = char*(*)();
+  std::vector<Callback_T2> callbacks;
+
+  void registerTwoCallbacks(Callback_T2 callback1, Callback_T2 callback2)
+  {
+    callbacks.push_back(callback1);
+    callbacks.push_back(callback2);
+  }
+
+  char* triggerCallback(int callBackIndex)
+  {
+    Callback_T2 callback = callbacks[callBackIndex];
+    return callback();
+  }
+}
+
+#ifdef HAVE_LIBFFI
+TESTCASE(MultipleCallbacks)
+{
+  Module m = define_module("TestingMultipleCallbacks");
+  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 
+                                  "Proc 1"
+                                end
+
+                        proc2 = Proc.new do 
+                                  "Proc 2"
+                                end
+
+                        register_callback(proc1, proc2))";
+
+  m.module_eval(code);
+
+  String result = m.call("trigger_callback", 0);
+  ASSERT_EQUAL("Proc 1", result.c_str());
+
+  result = m.call("trigger_callback", 1);
+  ASSERT_EQUAL("Proc 2", result.c_str());
+}
+#endif
+
+namespace
+{
+  using Callback_T3 = char*(*)(void* userData);
+  Callback_T3 globalCallback3;
+  void* globalUserData = nullptr;
+
+  void registerCallback3(Callback_T3 callback, void* userData)
+  {
+    globalCallback3 = callback;
+    globalUserData = userData;
+  }
+
+  char* triggerCallback3()
+  {
+    if (globalCallback3)
+    {
+      return globalCallback3(globalUserData);
+    }
+    throw std::runtime_error("Callback has not been registered");
+  }
+}
+
+TESTCASE(UserData)
+{
+  Module m = define_module("TestingUserData");
+  m.define_module_function("register_callback", registerCallback3, Arg("callback"), Arg("user_data").setOpaque()).
+    define_module_function("trigger_callback", triggerCallback3);
+
+  define_callback<Callback_T3>(Arg("user_data").setOpaque());
+
+  std::string code = R"(class UserDataClass
+                        end
+
+                        user_data_1 = UserDataClass.new
+
+                        callback = Proc.new do |user_data_2|
+                                     unless user_data_1.equal?(user_data_2)
+                                       raise("Unexpected user data object")
+                                     end
+                                     user_data_2.class.name
+                                   end
+
+                        register_callback(callback, user_data_1))";
+
+  m.module_eval(code);
+
+  String result = m.call("trigger_callback");
+  ASSERT_EQUAL("TestingUserData::UserDataClass", result.c_str());
+}

data/test/test_Class.cpp

@@ -11,6 +11,11 @@ SETUP(Class)
   embed_ruby();
 }
 
+TEARDOWN(Class)
+{
+  rb_gc_start();
+}
+
 TESTCASE(construct)
 {
   Class c(rb_cObject);
@@ -125,37 +130,6 @@ TESTCASE(module_function)
   );
 }
 
-namespace
-{
-  class Silly_Exception
-    : public std::exception
-  {
-  };
-
-  void handle_silly_exception(Silly_Exception const & ex)
-  {
-    throw Exception(rb_eRuntimeError, "SILLY");
-  }
-
-  void throw_silly_exception()
-  {
-    throw Silly_Exception();
-  }
-}
-
-TESTCASE(add_handler)
-{
-  register_handler<Silly_Exception>(handle_silly_exception);
-
-  Class c(rb_cObject);
-  c.define_function("foo", throw_silly_exception);
-
-  Object exc = detail::protect(rb_eval_string, "begin; foo; rescue Exception; $!; end");
-  ASSERT_EQUAL(rb_eRuntimeError, CLASS_OF(exc));
-  Exception ex(exc);
-  ASSERT_EQUAL("SILLY", ex.what());
-}
-
 TESTCASE(define_class)
 {
   Class object(rb_cObject);

data/test/test_Constructor.cpp

@@ -7,6 +7,16 @@ using namespace Rice;
 
 TESTSUITE(Constructor);
 
+SETUP(Constructor)
+{
+  embed_ruby();
+}
+
+TEARDOWN(Constructor)
+{
+  rb_gc_start();
+}
+
 namespace
 {
   class Default_Constructible
@@ -18,11 +28,6 @@ namespace
   };
 }
 
-SETUP(Array)
-{
-  embed_ruby();
-}
-
 TESTCASE(default_constructor)
 {
   Data_Type<Default_Constructible> rb_cDefault_Constructible(anonymous_class());
@@ -31,7 +36,6 @@ TESTCASE(default_constructor)
   ASSERT_EQUAL(rb_cDefault_Constructible, o.class_of());
 }
 
-
 namespace
 {
   class Non_Default_Constructible
@@ -125,3 +129,62 @@ TESTCASE(constructor_supports_single_default_argument)
   klass.call("new", 6);
   ASSERT_EQUAL(6, withArgX);
 }
+
+namespace
+{
+  class MyClass
+  {
+  public: 
+    MyClass() = default;
+    MyClass(const MyClass& other) = default;
+    MyClass(MyClass&& other) = default;
+    int value;
+  };
+}
+
+TESTCASE(constructor_clone)
+{
+  Class c = define_class<MyClass>("MyClass")
+    .define_constructor(Constructor<MyClass>())
+    .define_constructor(Constructor<MyClass, const MyClass&>())
+    .define_attr("value", &MyClass::value);
+
+  // Default constructor
+  Object o1 = c.call("new");
+  o1.call("value=", 7);
+  ASSERT_EQUAL(c, o1.class_of());
+
+  // Clone
+  Object o2 = o1.call("clone");
+  Object value = o2.call("value");
+  ASSERT_EQUAL(c, o2.class_of());
+  ASSERT_EQUAL(7, detail::From_Ruby<int>().convert(value));
+}
+
+TESTCASE(constructor_dup)
+{
+  Class c = define_class<MyClass>("MyClass").
+            define_constructor(Constructor<MyClass>()).
+            define_constructor(Constructor<MyClass, const MyClass&>()).
+            define_attr("value", &MyClass::value);
+
+  // Default constructor
+  Object o1 = c.call("new");
+  o1.call("value=", 7);
+  ASSERT_EQUAL(c, o1.class_of());
+
+  // Clone
+  Object o2 = o1.call("dup");
+  Object value = o2.call("value");
+  ASSERT_EQUAL(c, o2.class_of());
+  ASSERT_EQUAL(7, detail::From_Ruby<int>().convert(value));
+}
+
+TESTCASE(constructor_move)
+{
+  Data_Type<MyClass> c = define_class<MyClass>("MyClass").
+            define_constructor(Constructor<MyClass>());
+
+  // This intentionally will not compile due to a static_assert
+  //c.define_constructor(Constructor<MyClass, MyClass&&>());
+}

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
   {
   };
@@ -48,7 +57,7 @@ SETUP(Data_Object)
   if (!Data_Type<MyDataType>::is_bound())
   {
     Class object(rb_cObject);
-    if(object.const_defined("MyDataType"))
+    if (object.const_defined("MyDataType"))
     {
       object.remove_const("MyDataType");
     }
@@ -58,30 +67,35 @@ SETUP(Data_Object)
   }
 }
 
-TESTCASE(construct_from_pointer)
+TEARDOWN(Data_Object)
+{
+  rb_gc_start();
+}
+
+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()));
+  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);
   ASSERT_EQUAL(myDataType, data_object_foo.get());
   ASSERT_EQUAL(Data_Type<MyDataType>::klass(), data_object_foo.class_of());
   ASSERT_EQUAL(RTYPEDDATA(wrapped_foo), RTYPEDDATA(data_object_foo.value()));
-  ASSERT_EQUAL(myDataType, detail::unwrap<MyDataType>(wrapped_foo, Data_Type<MyDataType>::ruby_data_type()));
+  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(
@@ -95,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);
@@ -105,12 +119,12 @@ TESTCASE(copy_construct)
   ASSERT_EQUAL(myDataType, data_object_foo.get());
   ASSERT_EQUAL(Data_Type<MyDataType>::klass(), data_object_foo.class_of());
   ASSERT_EQUAL(RTYPEDDATA(wrapped_foo), RTYPEDDATA(data_object_foo.value()));
-  ASSERT_EQUAL(myDataType, detail::unwrap<MyDataType>(wrapped_foo, Data_Type<MyDataType>::ruby_data_type()));
+  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));
@@ -119,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);
@@ -133,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;
@@ -208,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