rice 4.3.3 → 4.5.0

data/test/test_Callback.cpp

@@ -0,0 +1,231 @@
+#include <functional>
+
+#include "unittest.hpp"
+#include "embed_ruby.hpp"
+#include <rice/rice.hpp>
+#include <rice/stl.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 registerCallback(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", registerCallback).
+    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

@@ -48,7 +48,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,13 +58,18 @@ SETUP(Data_Object)
   }
 }
 
+TEARDOWN(Data_Object)
+{
+  rb_gc_start();
+}
+
 TESTCASE(construct_from_pointer)
 {
   MyDataType* myDataType = new MyDataType;
   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)
@@ -76,7 +81,7 @@ TESTCASE(construct_from_ruby_object)
   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)
@@ -105,7 +110,7 @@ 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)