rice 4.3.3 → 4.6.0

data/test/test_Ownership.cpp

@@ -10,12 +10,11 @@ TESTSUITE(Ownership);
 
 namespace
 {
-  class MyClass
+  class MyCopyableClass
   {
   public:
     static inline int constructorCalls = 0;
     static inline int copyConstructorCalls = 0;
-    static inline int moveConstructorCalls = 0;
     static inline int destructorCalls = 0;
     static inline int methodCalls = 0;
 
@@ -23,7 +22,6 @@ namespace
     {
       constructorCalls = 0;
       copyConstructorCalls = 0;
-      moveConstructorCalls = 0;
       destructorCalls = 0;
       methodCalls = 0;
     }
@@ -32,22 +30,68 @@ namespace
     int flag = 0;
 
   public:
-    MyClass()
+    MyCopyableClass()
     {
       constructorCalls++;
     }
 
-    ~MyClass()
+    ~MyCopyableClass()
     {
       destructorCalls++;
     }
 
-    MyClass(const MyClass& other): flag(other.flag)
+    MyCopyableClass(const MyCopyableClass& other): flag(other.flag)
     {
       copyConstructorCalls++;
     }
 
-    MyClass(MyClass&& other) : flag(other.flag)
+    MyCopyableClass(MyCopyableClass&& other) = delete;
+
+    int32_t process()
+    {
+      methodCalls++;
+      return methodCalls;
+    }
+
+    void setFlag(int value)
+    {
+      this->flag = value;
+    }
+  };
+
+  class MyMovableClass
+  {
+  public:
+    static inline int constructorCalls = 0;
+    static inline int moveConstructorCalls = 0;
+    static inline int destructorCalls = 0;
+    static inline int methodCalls = 0;
+
+    static void reset()
+    {
+      constructorCalls = 0;
+      moveConstructorCalls = 0;
+      destructorCalls = 0;
+      methodCalls = 0;
+    }
+
+  public:
+    int flag = 0;
+
+  public:
+    MyMovableClass()
+    {
+      constructorCalls++;
+    }
+
+    ~MyMovableClass()
+    {
+      destructorCalls++;
+    }
+
+    MyMovableClass(const MyMovableClass& other) = delete;
+
+    MyMovableClass(MyMovableClass&& other) : flag(other.flag)
     {
       moveConstructorCalls++;
     }
@@ -74,42 +118,47 @@ namespace
     }
 
   public:
-    MyClass* transferPointer()
+    MyCopyableClass* transferPointerToRuby()
     {
-      return new MyClass();
+      return new MyCopyableClass();
     }
 
-    MyClass* keepPointer()
+    MyCopyableClass* keepPointer()
     {
       return this->instance();
     }
 
-    MyClass& keepReference()
+    MyCopyableClass& keepReference()
     {
       return *this->instance();
     }
 
-    MyClass value()
+    MyCopyableClass value()
+    {
+      return MyCopyableClass();
+    }
+
+    MyMovableClass moveValue()
     {
-      return MyClass();
+      return MyMovableClass();
     }
 
-    MyClass moveValue()
+    void transferPointerToCpp(MyCopyableClass* myClass)
     {
-      return std::move(MyClass());
+      delete myClass;
     }
 
-    MyClass* instance()
+    MyCopyableClass* instance()
     {
       if (!instance_)
       {
-        instance_ = new MyClass();
+        instance_ = new MyCopyableClass();
       }
       return instance_;
     }
 
   public:
-    static inline MyClass* instance_ = nullptr;
+    static inline MyCopyableClass* instance_ = nullptr;
   };
 }
 
@@ -117,30 +166,42 @@ SETUP(Ownership)
 {
   embed_ruby();
 
-  define_class<MyClass>("MyClass").
-    define_method("process", &MyClass::process).
-    define_method("set_flag", &MyClass::setFlag);
+  define_class<MyCopyableClass>("MyCopyableClass").
+    define_constructor(Constructor<MyCopyableClass>()).
+    define_method("process", &MyCopyableClass::process).
+    define_method("set_flag", &MyCopyableClass::setFlag);
+
+  define_class<MyMovableClass>("MyMovableClass").
+    define_constructor(Constructor<MyMovableClass>()).
+    define_method("process", &MyMovableClass::process).
+    define_method("set_flag", &MyMovableClass::setFlag);
 
   define_class<Factory>("Factory").
     define_constructor(Constructor<Factory>()).
     define_method("value", &Factory::value).
     define_method("move_value", &Factory::moveValue).
-    define_method("transfer_pointer", &Factory::transferPointer, Return().takeOwnership()).
+    define_method("transfer_pointer_to_ruby", &Factory::transferPointerToRuby, Return().takeOwnership()).
+    define_method("transfer_pointer_to_cpp", &Factory::transferPointerToCpp, Arg("myClass").takeOwnership()).
     define_method("keep_pointer", &Factory::keepPointer).
     define_method("copy_reference", &Factory::keepReference, Return().takeOwnership()).
     define_method("keep_reference", &Factory::keepReference);
 }
 
-TESTCASE(TransferPointer)
+TEARDOWN(Ownership)
+{
+  rb_gc_start();
+}
+
+TESTCASE(TransferPointerToRuby)
 {
   Factory::reset();
-  MyClass::reset();
+  MyCopyableClass::reset();
 
   Module m = define_module("TestingModule");
 
   std::string code = R"(factory = Factory.new
                         10.times do |i|
-                          my_class = factory.transfer_pointer
+                          my_class = factory.transfer_pointer_to_ruby
                           my_class.set_flag(i)
                           my_class = nil
                         end)";
@@ -148,17 +209,33 @@ TESTCASE(TransferPointer)
   m.module_eval(code);
   rb_gc_start();
 
-  ASSERT_EQUAL(10, MyClass::constructorCalls);
-  ASSERT_EQUAL(0, MyClass::copyConstructorCalls);
-  ASSERT_EQUAL(0, MyClass::moveConstructorCalls);
-  ASSERT_EQUAL(10, MyClass::destructorCalls);
+  ASSERT_EQUAL(10, MyCopyableClass::constructorCalls);
+  ASSERT_EQUAL(0, MyCopyableClass::copyConstructorCalls);
+  ASSERT_EQUAL(10, MyCopyableClass::destructorCalls);
   ASSERT(!Factory::instance_);
 }
 
+TESTCASE(TransferPointerToCpp)
+{
+  Factory::reset();
+  MyCopyableClass::reset();
+
+  Module m = define_module("TestingModule");
+
+  std::string code = R"(myClass = MyCopyableClass.new
+                        factory = Factory.new
+                        factory.transfer_pointer_to_cpp(myClass))";
+
+  m.module_eval(code);
+  rb_gc_start();
+
+  ASSERT(true);
+}
+
 TESTCASE(KeepPointer)
 {
   Factory::reset();
-  MyClass::reset();
+  MyCopyableClass::reset();
 
   Module m = define_module("TestingModule");
 
@@ -172,17 +249,16 @@ TESTCASE(KeepPointer)
   m.module_eval(code);
   rb_gc_start();
 
-  ASSERT_EQUAL(1, MyClass::constructorCalls);
-  ASSERT_EQUAL(0, MyClass::copyConstructorCalls);
-  ASSERT_EQUAL(0, MyClass::moveConstructorCalls);
-  ASSERT_EQUAL(0, MyClass::destructorCalls);
+  ASSERT_EQUAL(1, MyCopyableClass::constructorCalls);
+  ASSERT_EQUAL(0, MyCopyableClass::copyConstructorCalls);
+  ASSERT_EQUAL(0, MyCopyableClass::destructorCalls);
   ASSERT_EQUAL(9, Factory::instance_->flag);
 }
 
 TESTCASE(KeepReference)
 {
   Factory::reset();
-  MyClass::reset();
+  MyCopyableClass::reset();
 
   Module m = define_module("TestingModule");
 
@@ -196,17 +272,16 @@ TESTCASE(KeepReference)
   m.module_eval(code);
   rb_gc_start();
 
-  ASSERT_EQUAL(1, MyClass::constructorCalls);
-  ASSERT_EQUAL(0, MyClass::copyConstructorCalls);
-  ASSERT_EQUAL(0, MyClass::moveConstructorCalls);
-  ASSERT_EQUAL(0, MyClass::destructorCalls);
+  ASSERT_EQUAL(1, MyCopyableClass::constructorCalls);
+  ASSERT_EQUAL(0, MyCopyableClass::copyConstructorCalls);
+  ASSERT_EQUAL(0, MyCopyableClass::destructorCalls);
   ASSERT_EQUAL(9, Factory::instance_->flag);
 }
 
 TESTCASE(CopyReference)
 {
   Factory::reset();
-  MyClass::reset();
+  MyCopyableClass::reset();
 
   Module m = define_module("TestingModule");
 
@@ -220,17 +295,16 @@ TESTCASE(CopyReference)
   m.module_eval(code);
   rb_gc_start();
 
-  ASSERT_EQUAL(1, MyClass::constructorCalls);
-  ASSERT_EQUAL(0, MyClass::copyConstructorCalls);
-  ASSERT_EQUAL(10, MyClass::moveConstructorCalls);
-  ASSERT_EQUAL(10, MyClass::destructorCalls);
+  ASSERT_EQUAL(1, MyCopyableClass::constructorCalls);
+  ASSERT_EQUAL(10, MyCopyableClass::copyConstructorCalls);
+  ASSERT_EQUAL(10, MyCopyableClass::destructorCalls);
   ASSERT_EQUAL(0, Factory::instance_->flag);
 }
 
 TESTCASE(TransferValue)
 {
   Factory::reset();
-  MyClass::reset();
+  MyCopyableClass::reset();
 
   Module m = define_module("TestingModule");
 
@@ -243,17 +317,16 @@ TESTCASE(TransferValue)
   m.module_eval(code);
   rb_gc_start();
 
-  ASSERT_EQUAL(10, MyClass::constructorCalls);
-  ASSERT_EQUAL(0, MyClass::copyConstructorCalls);
-  ASSERT_EQUAL(10, MyClass::moveConstructorCalls);
-  ASSERT_EQUAL(20, MyClass::destructorCalls);
+  ASSERT_EQUAL(10, MyCopyableClass::constructorCalls);
+  ASSERT_EQUAL(10, MyCopyableClass::copyConstructorCalls);
+  ASSERT_EQUAL(20, MyCopyableClass::destructorCalls);
   ASSERT(!Factory::instance_);
 }
 
 TESTCASE(MoveValue)
 {
   Factory::reset();
-  MyClass::reset();
+  MyCopyableClass::reset();
 
   Module m = define_module("TestingModule");
 
@@ -266,9 +339,42 @@ TESTCASE(MoveValue)
   m.module_eval(code);
   rb_gc_start();
 
-  ASSERT_EQUAL(10, MyClass::constructorCalls);
-  ASSERT_EQUAL(0, MyClass::copyConstructorCalls);
-  ASSERT_EQUAL(20, MyClass::moveConstructorCalls);
-  ASSERT_EQUAL(30, MyClass::destructorCalls);
+  ASSERT_EQUAL(10, MyMovableClass::constructorCalls);
+  ASSERT_EQUAL(10, MyMovableClass::moveConstructorCalls);
+  ASSERT_EQUAL(20, MyMovableClass::destructorCalls);
   ASSERT(!Factory::instance_);
 }
+
+namespace
+{
+  class MyClassNotCopyable
+  {
+  public:
+    MyClassNotCopyable() = default;
+    MyClassNotCopyable(const MyClassNotCopyable& other) = delete;
+    MyClassNotCopyable(MyClassNotCopyable&& other) = delete;
+    int value;
+  };
+}
+
+TESTCASE(NotCopyable)
+{
+  Class c = define_class<MyClassNotCopyable>("MyClassNotCopyable")
+    .define_constructor(Constructor<MyClassNotCopyable>())
+    .define_attr("value", &MyClassNotCopyable::value);
+
+  MyClassNotCopyable instance;
+
+#ifdef _MSC_VER
+  const char* expected = "Rice was directed to take ownership of a C++ object but it does not have an accessible copy or move constructor. Type: class `anonymous namespace'::MyClassNotCopyable";
+#else
+  const char* expected = "Rice was directed to take ownership of a C++ object but it does not have an accessible copy or move constructor. Type: (anonymous namespace)::MyClassNotCopyable";
+#endif
+
+  // Trying to take ownership should fail
+  ASSERT_EXCEPTION_CHECK(
+    std::runtime_error,
+    Data_Object<MyClassNotCopyable>(instance, true),
+    ASSERT_EQUAL(expected, ex.what())
+  );
+}

data/test/test_Proc.cpp

@@ -0,0 +1,44 @@
+#include <functional>
+
+#include "unittest.hpp"
+#include "embed_ruby.hpp"
+#include <rice/rice.hpp>
+
+using namespace Rice;
+
+TESTSUITE(Proc);
+
+SETUP(Proc)
+{
+  embed_ruby();
+}
+
+TEARDOWN(Proc)
+{
+  rb_gc_start();
+}
+
+namespace
+{
+  int square(int i)
+  {
+    return i * i;
+  }
+
+  auto squareProc()
+  {
+    return square;
+  }
+}
+
+TESTCASE(SquareProc)
+{
+  Module m = define_module("TestingModuleMakeProc");
+  m.define_module_function("square_proc", squareProc);
+
+  std::string code = R"(proc = square_proc
+                        proc.call(9))";
+
+  Object result = m.module_eval(code);
+  ASSERT_EQUAL(81, detail::From_Ruby<int>().convert(result));
+}

data/test/test_Self.cpp

@@ -89,6 +89,11 @@ SETUP(Self)
       });
 }
 
+TEARDOWN(Self)
+{
+  rb_gc_start();
+}
+
 TESTCASE(SelfPointer)
 {
   SelfClass::reset();
@@ -141,8 +146,8 @@ TESTCASE(SelfValue)
   ASSERT((pointer1 != pointer2));
 
   ASSERT_EQUAL(1, SelfClass::constructorCalls);
-  ASSERT_EQUAL(1, SelfClass::copyConstructorCalls);
-  ASSERT_EQUAL(1, SelfClass::moveConstructorCalls);
+  ASSERT_EQUAL(2, SelfClass::copyConstructorCalls);
+  ASSERT_EQUAL(0, SelfClass::moveConstructorCalls);
   ASSERT_EQUAL(1, SelfClass::destructorCalls);
 }
 
@@ -198,7 +203,7 @@ TESTCASE(SelfValueLambda)
   ASSERT((pointer1 != pointer2));
 
   ASSERT_EQUAL(1, SelfClass::constructorCalls);
-  ASSERT_EQUAL(1, SelfClass::copyConstructorCalls);
-  ASSERT_EQUAL(1, SelfClass::moveConstructorCalls);
+  ASSERT_EQUAL(2, SelfClass::copyConstructorCalls);
+  ASSERT_EQUAL(0, SelfClass::moveConstructorCalls);
   ASSERT_EQUAL(1, SelfClass::destructorCalls);
 }

data/test/test_Stl_Exception.cpp

@@ -0,0 +1,109 @@
+#include <complex>
+#include <memory>
+
+#include "unittest.hpp"
+#include "embed_ruby.hpp"
+#include <rice/rice.hpp>
+#include <rice/stl.hpp>
+
+using namespace Rice;
+
+TESTSUITE(StlException);
+
+SETUP(StlException)
+{
+  embed_ruby();
+}
+
+TEARDOWN(StlException)
+{
+  rb_gc_start();
+}
+
+namespace
+{
+  class MyException: public std::exception
+  {
+  };
+
+  void raiseMyException()
+  {
+    throw MyException();
+  }
+
+}
+
+TESTCASE(StlExceptionCreate)
+{
+  Class MyExceptionKlass = define_class<MyException, std::exception>("MyException");
+
+  auto handler = [MyExceptionKlass]()
+    {
+      try
+      {
+        throw;
+      }
+      catch (const MyException& exception)
+      {
+        Data_Object<MyException> wrapper(exception, true);
+        rb_exc_raise(wrapper.value());
+      }
+    };
+  detail::Registries::instance.handlers.set(handler);
+
+  Module m = define_module("Testing");
+  m.define_singleton_function("raise_my_exception", &raiseMyException);
+
+  std::string code = R"(begin
+                          raise_my_exception
+                        rescue MyException => exception
+                          $!
+                        end)";
+
+  Object object = m.instance_eval(code);
+  ASSERT_EQUAL(MyExceptionKlass.value(), object.class_of().value());
+}
+
+namespace
+{
+  std::exception_ptr createExceptionPtr()
+  {
+    std::exception_ptr eptr;
+
+    try
+    {
+      [[maybe_unused]]
+      char ch = std::string().at(1); // this generates a std::out_of_range
+    }
+    catch (...)
+    {
+      eptr = std::current_exception(); // capture
+    }
+
+    return eptr;
+  }
+
+  void handleExceptionPtr(std::exception_ptr eptr)
+  {
+    std::rethrow_exception(eptr);
+  }
+}
+
+TESTCASE(StlExceptionPtr)
+{
+  Module m = define_module("TestingModule");
+  m.define_module_function("create_exception_ptr", createExceptionPtr).
+    define_module_function("handle_exception_ptr", handleExceptionPtr);
+
+  Data_Object<std::exception_ptr> exception = m.call("create_exception_ptr");
+  VALUE value = exception.value();
+  std::exception_ptr* ptr = exception.get();
+  ASSERT((value != Qnil));
+  ASSERT((ptr != nullptr));
+
+  ASSERT_EXCEPTION_CHECK(
+    Exception,
+    m.call("handle_exception_ptr", exception),
+    ASSERT_EQUAL(rb_eIndexError, ex.class_of())
+  );
+}