rice 4.3.3 → 4.5.0

data/test/test_Ownership.cpp

@@ -74,7 +74,7 @@ namespace
     }
 
   public:
-    MyClass* transferPointer()
+    MyClass* transferPointerToRuby()
     {
       return new MyClass();
     }
@@ -99,6 +99,11 @@ namespace
       return std::move(MyClass());
     }
 
+    void transferPointerToCpp(MyClass* myClass)
+    {
+      delete myClass;
+    }
+
     MyClass* instance()
     {
       if (!instance_)
@@ -118,6 +123,7 @@ SETUP(Ownership)
   embed_ruby();
 
   define_class<MyClass>("MyClass").
+    define_constructor(Constructor<MyClass>()).
     define_method("process", &MyClass::process).
     define_method("set_flag", &MyClass::setFlag);
 
@@ -125,13 +131,19 @@ SETUP(Ownership)
     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();
@@ -140,7 +152,7 @@ TESTCASE(TransferPointer)
 
   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)";
@@ -155,6 +167,23 @@ TESTCASE(TransferPointer)
   ASSERT(!Factory::instance_);
 }
 
+TESTCASE(TransferPointerToCpp)
+{
+  Factory::reset();
+  MyClass::reset();
+
+  Module m = define_module("TestingModule");
+
+  std::string code = R"(myClass = MyClass.new
+                        factory = Factory.new
+                        factory.transfer_pointer_to_cpp(myClass))";
+
+  m.module_eval(code);
+  rb_gc_start();
+
+  ASSERT(true);
+}
+
 TESTCASE(KeepPointer)
 {
   Factory::reset();
@@ -272,3 +301,37 @@ TESTCASE(MoveValue)
   ASSERT_EQUAL(30, MyClass::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 = "Ruby 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 = "Ruby 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,45 @@
+#include <functional>
+
+#include "unittest.hpp"
+#include "embed_ruby.hpp"
+#include <rice/rice.hpp>
+#include <rice/stl.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();

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())
+  );
+}

data/test/test_Stl_Map.cpp

@@ -1,10 +1,11 @@
-#include <complex>
+#include <complex>
 #include <memory>
 
 #include "unittest.hpp"
 #include "embed_ruby.hpp"
 #include <rice/rice.hpp>
 #include <rice/stl.hpp>
+#include <ruby/version.h>
 
 using namespace Rice;
 
@@ -15,9 +16,13 @@ SETUP(Map)
   embed_ruby();
 }
 
-namespace
+TEARDOWN(Map)
 {
+  rb_gc_start();
+}
 
+namespace
+{
   class MyClass
   {
   public:
@@ -253,7 +258,11 @@ TESTCASE(Iterate)
   ASSERT_EQUAL(3u, result.size());
 
   std::string result_string = result.to_s().str();
+#if RUBY_API_VERSION_MAJOR == 3 && RUBY_API_VERSION_MINOR >= 4
+  ASSERT_EQUAL("{\"five\" => 10, \"seven\" => 14, \"six\" => 12}", result_string);
+#else
   ASSERT_EQUAL("{\"five\"=>10, \"seven\"=>14, \"six\"=>12}", result_string);
+#endif
 }
 
 TESTCASE(ToEnum)
@@ -276,7 +285,12 @@ TESTCASE(ToEnum)
   ASSERT_EQUAL(3u, result.size());
 
   std::string result_string = result.to_s().str();
+
+#if RUBY_API_VERSION_MAJOR == 3 && RUBY_API_VERSION_MINOR >= 4
+  ASSERT_EQUAL("{\"five\" => 10, \"seven\" => 14, \"six\" => 12}", result_string);
+#else
   ASSERT_EQUAL("{\"five\"=>10, \"seven\"=>14, \"six\"=>12}", result_string);
+#endif
 }
 
 TESTCASE(ToEnumSize)
@@ -433,7 +447,7 @@ TESTCASE(AutoRegisterReturn)
 
   Module m = define_module("Testing");
   Object map = m.module_eval("return_complex_map");
-  ASSERT_EQUAL("Rice::Std::Map__basic_string__char_char_traits__char___allocator__char_____complex__double___less__basic_string__char_char_traits__char___allocator__char_______allocator__pair__basic_string__char_char_traits__char___allocator__char____Const_complex__double________",
+  ASSERT_EQUAL(u8"Rice::Std::Map≺string≺char≻‚ complex≺double≻≻",
                map.class_name().str());
 
   std::string code = R"(map = return_complex_map
@@ -460,16 +474,16 @@ TESTCASE(AutoRegisterParameter)
 {
   define_global_function("pass_complex_map", &passComplexMap);
 
-  std::string code = R"(map = Rice::Std::Map__basic_string__char_char_traits__char___allocator__char_____complex__double___less__basic_string__char_char_traits__char___allocator__char_______allocator__pair__basic_string__char_char_traits__char___allocator__char____Const_complex__double________.new
-                        map["four"] = Complex(4.0, 4.0)
-                        map["five"] = Complex(5.0, 5.0)
-                        pass_complex_map(map))";
+  std::string code = u8R"(map = Rice::Std::Map≺string≺char≻‚ complex≺double≻≻.new
+                          map["four"] = Complex(4.0, 4.0)
+                          map["five"] = Complex(5.0, 5.0)
+                          pass_complex_map(map))";
 
   Module m = define_module("Testing");
   Object map = m.module_eval(code);
 
   Object result = map.call("size");
-  ASSERT_EQUAL("Rice::Std::Map__basic_string__char_char_traits__char___allocator__char_____complex__double___less__basic_string__char_char_traits__char___allocator__char_______allocator__pair__basic_string__char_char_traits__char___allocator__char____Const_complex__double________",
+  ASSERT_EQUAL(u8"Rice::Std::Map≺string≺char≻‚ complex≺double≻≻",
                map.class_name().str());
   ASSERT_EQUAL(2, detail::From_Ruby<int32_t>().convert(result));
 

data/test/test_Stl_Optional.cpp

@@ -50,6 +50,11 @@ SETUP(Optional)
   makeOptionalClass();
 }
 
+TEARDOWN(Optional)
+{
+  rb_gc_start();
+}
+
 TESTCASE(OptionalReturn)
 {
   Module m = define_module("Testing");

data/test/test_Stl_Pair.cpp

@@ -1,4 +1,4 @@
-#include <utility>
+#include <utility>
 
 #include "unittest.hpp"
 #include "embed_ruby.hpp"
@@ -14,6 +14,11 @@ SETUP(Pair)
   embed_ruby();
 }
 
+TEARDOWN(Pair)
+{
+  rb_gc_start();
+}
+
 TESTCASE(CreatePair)
 {
   Module m = define_module("Testing");
@@ -102,7 +107,7 @@ TESTCASE(AutoRegister)
 
   Object pair = someClass.call("pair");
   String name = pair.class_name();
-  ASSERT_EQUAL("Rice::Std::Pair__basic_string__char_char_traits__char___allocator__char_____double__", detail::From_Ruby<std::string>().convert(name));
+  ASSERT_EQUAL(u8"Rice::Std::Pair≺string≺char≻‚ double≻", detail::From_Ruby<std::string>().convert(name));
 
   Class pairKlass1 = pair.class_of();
   Class pairKlass2 = Data_Type<std::pair<std::string, double>>::klass();

data/test/test_Stl_Reference_Wrapper.cpp

@@ -61,6 +61,11 @@ SETUP(ReferenceWrapper)
   makeReferenceWrapperClass();
 }
 
+TEARDOWN(ReferenceWrapper)
+{
+  rb_gc_start();
+}
+
 TESTCASE(Return)
 {
   Module m = define_module("Testing");