rice 4.3.3 → 4.5.0

data/test/test_Stl_SmartPointer.cpp

@@ -60,6 +60,15 @@ namespace
   class Factory
   {
   public:
+    static void reset()
+    {
+      Factory::instance_.reset();
+    }
+
+    ~Factory()
+    {
+    }
+
     std::unique_ptr<MyClass> transfer()
     {
       return std::make_unique<MyClass>();
@@ -87,6 +96,43 @@ namespace
     static inline std::shared_ptr<MyClass> instance_;
   };
 
+  class Sink
+  {
+  public:
+    int takeOwnership(std::unique_ptr<MyClass> ptr)
+    {
+      return ptr->flag;
+    }
+
+    long shareOwnership(std::shared_ptr<MyClass> ptr)
+    {
+      return ptr.use_count();
+    }
+
+    int updatePointer(std::unique_ptr<MyClass>& ptr, MyClass* myClass)
+    {
+      ptr.reset(myClass);
+      return ptr->flag;
+    }
+
+    int updatePointer(std::shared_ptr<MyClass>& ptr, MyClass* myClass)
+    {
+      ptr.reset(myClass);
+      return ptr->flag;
+    }
+
+    std::shared_ptr<void> makeVoidShared(MyClass* myClass)
+    {
+      return std::shared_ptr<void>(myClass);
+    }
+
+    int handleVoid(std::shared_ptr<void>& ptr)
+    {
+      MyClass* myClass = static_cast<MyClass*>(ptr.get());
+      return myClass->flag;
+    }
+  };
+
   int extractFlagUniquePtrRef(std::unique_ptr<MyClass>& myClass)
   {
     return myClass->flag;
@@ -107,7 +153,12 @@ SETUP(SmartPointer)
 {
   embed_ruby();
 
+#if RUBY_API_VERSION_MAJOR == 3 && RUBY_API_VERSION_MINOR >= 2
+  rb_eval_string("GC.stress = true");
+#endif
+
   define_class<MyClass>("MyClass").
+    define_constructor(Constructor<MyClass>()).
     define_method("set_flag", &MyClass::setFlag);
 
   define_class<Factory>("Factory").
@@ -116,6 +167,21 @@ SETUP(SmartPointer)
     define_method("share", &Factory::share).
     define_method("share_ref", &Factory::share_ref);
 
+  define_class<Sink>("Sink").
+    define_constructor(Constructor<Sink>()).
+    define_method("take_ownership", &Sink::takeOwnership).
+    define_method("share_ownership", &Sink::shareOwnership).
+    define_method<int(Sink::*)(std::unique_ptr<MyClass>&, MyClass*)>("update_pointer", &Sink::updatePointer, 
+      Arg("ptr"), Arg("myClass").takeOwnership()).
+    define_method<int(Sink::*)(std::shared_ptr<MyClass>&, MyClass*)>("update_pointer", &Sink::updatePointer,
+      Arg("ptr"), Arg("myClass").takeOwnership()).
+    define_method("make_void_shared", &Sink::makeVoidShared,
+      Arg("myClass").takeOwnership()).
+    define_method<int(Sink::*)(std::shared_ptr<void>&)>("handle_void", &Sink::handleVoid);
+
+  // Needed for shared_ptr<void>
+  define_class<void>("Void");
+
   define_global_function("extract_flag_unique_ptr_ref", &extractFlagUniquePtrRef);
   define_global_function("extract_flag_shared_ptr", &extractFlagSharedPtr);
   define_global_function("extract_flag_shared_ptr_ref", &extractFlagSharedPtrRef);
@@ -126,9 +192,18 @@ SETUP(SmartPointer)
       Arg("myClass") = std::make_shared<MyClass>());
 }
 
-TESTCASE(TransferOwnership)
+TEARDOWN(SmartPointer)
+{
+  rb_gc_start();
+#if RUBY_API_VERSION_MAJOR == 3 && RUBY_API_VERSION_MINOR >= 2
+  rb_eval_string("GC.stress = false");
+#endif
+}
+
+TESTCASE(takeOwnership)
 {
   MyClass::reset();
+  Factory::reset();
 
   Module m = define_module("TestingModule");
 
@@ -152,17 +227,19 @@ TESTCASE(TransferOwnership)
 TESTCASE(ShareOwnership)
 {
   MyClass::reset();
+  Factory::reset();
 
   Module m = define_module("TestingModule");
 
   // Create ruby objects that point to the same instance of MyClass
-  std::string code = R"(factory = Factory.new
+  std::string code = R"(ary = Array.new
+                        factory = Factory.new
                         10.times do |i|
                           my_class = factory.share
                           my_class.set_flag(i)
+                          ary << my_class
                         end)";
 
-
   ASSERT_EQUAL(0, Factory::instance_.use_count());
   m.module_eval(code);
   
@@ -177,10 +254,10 @@ TESTCASE(ShareOwnership)
   ASSERT_EQUAL(9, Factory::instance_->flag);
 }
 
-
 TESTCASE(ShareOwnership2)
 {
   MyClass::reset();
+  Factory::reset();
 
   Module m = define_module("TestingModule");
 
@@ -208,6 +285,7 @@ TESTCASE(ShareOwnership2)
 TESTCASE(UniquePtrRefParameter)
 {
   MyClass::reset();
+  Factory::reset();
 
   Module m = define_module("TestingModule");
 
@@ -223,6 +301,7 @@ TESTCASE(UniquePtrRefParameter)
 TESTCASE(SharedPtrParameter)
 {
   MyClass::reset();
+  Factory::reset();
 
   Module m = define_module("TestingModule");
 
@@ -238,6 +317,7 @@ TESTCASE(SharedPtrParameter)
 TESTCASE(SharedPtrRefParameter)
 {
   MyClass::reset();
+  Factory::reset();
 
   Module m = define_module("TestingModule");
 
@@ -253,6 +333,7 @@ TESTCASE(SharedPtrRefParameter)
 TESTCASE(SharedPtrDefaultParameter)
 {
   MyClass::reset();
+  Factory::reset();
 
   Module m = define_module("TestingModule");
 
@@ -269,6 +350,7 @@ TESTCASE(SharedPtrDefaultParameter)
 TESTCASE(SharedPtrRefDefaultParameter)
 {
   MyClass::reset();
+  Factory::reset();
 
   Module m = define_module("TestingModule");
 
@@ -278,6 +360,129 @@ TESTCASE(SharedPtrRefDefaultParameter)
                         extract_flag_shared_ptr_ref_with_default())";
 
   Object result = m.module_eval(code);
+  rb_gc_start();
+
   // The default value kicks in and ignores any previous pointer
   ASSERT_EQUAL(0, detail::From_Ruby<int>().convert(result));
-}
+
+  ASSERT_EQUAL(1, MyClass::constructorCalls);
+  ASSERT_EQUAL(0, MyClass::copyConstructorCalls);
+  ASSERT_EQUAL(0, MyClass::moveConstructorCalls);
+ // ASSERT_EQUAL(1, MyClass::destructorCalls);
+}
+
+TESTCASE(UniquePtrRoundTrip)
+{
+  MyClass::reset();
+  Factory::reset();
+
+  Module m = define_module("TestingModule");
+
+  // Create ruby objects that point to the same instance of MyClass
+  std::string code = R"(factory = Factory.new
+                        my_class = factory.transfer
+                        my_class.set_flag(5)
+                        
+                        sink = Sink.new
+                        sink.take_ownership(my_class))";
+
+  Object result = m.instance_eval(code);
+  ASSERT_EQUAL(5, detail::From_Ruby<int>().convert(result.value()));
+
+  ASSERT_EQUAL(1, MyClass::constructorCalls);
+  ASSERT_EQUAL(0, MyClass::copyConstructorCalls);
+  ASSERT_EQUAL(0, MyClass::moveConstructorCalls);
+ // ASSERT_EQUAL(1, MyClass::destructorCalls);
+}
+
+TESTCASE(UniquePtrUpdate)
+{
+  MyClass::reset();
+  Factory::reset();
+
+  Module m = define_module("TestingModule");
+
+  // Create ruby objects that point to the same instance of MyClass
+  std::string code = R"(factory = Factory.new
+                        my_class1 = factory.transfer
+                        my_class1.set_flag(5)
+                        
+                        my_class2 = MyClass.new
+                        my_class2.set_flag(11)
+
+                        sink = Sink.new
+                        sink.update_pointer(my_class1, my_class2))";
+
+  Object result = m.instance_eval(code);
+  ASSERT_EQUAL(11, detail::From_Ruby<long>().convert(result.value()));
+}
+
+TESTCASE(SharedPtrRoundTrip)
+{
+  MyClass::reset();
+  Factory::reset();
+
+  Module m = define_module("TestingModule");
+
+  // Create ruby objects that point to the same instance of MyClass
+  std::string code = R"(factory = Factory.new
+                        my_class = factory.share
+                        
+                        sink = Sink.new
+                        sink.share_ownership(my_class))";
+
+  Object result = m.instance_eval(code);
+  ASSERT_EQUAL(3, detail::From_Ruby<long>().convert(result.value()));
+
+  ASSERT_EQUAL(1, MyClass::constructorCalls);
+  ASSERT_EQUAL(0, MyClass::copyConstructorCalls);
+  ASSERT_EQUAL(0, MyClass::moveConstructorCalls);
+ // ASSERT_EQUAL(0, MyClass::destructorCalls);
+}
+
+TESTCASE(SharedPtrUpdate)
+{
+  MyClass::reset();
+  Factory::reset();
+
+  Module m = define_module("TestingModule");
+
+  // Create ruby objects that point to the same instance of MyClass
+  std::string code = R"(factory = Factory.new
+                        my_class1 = factory.share
+                        my_class1.set_flag(7)
+
+                        my_class2 = MyClass.new
+                        my_class2.set_flag(14)
+
+                        sink = Sink.new
+                        sink.update_pointer(my_class1, my_class2))";
+
+  Object result = m.instance_eval(code);
+  ASSERT_EQUAL(14, detail::From_Ruby<long>().convert(result.value()));
+}
+
+TESTCASE(SharedPtrVoid)
+{
+  MyClass::reset();
+  Factory::reset();
+
+  Module m = define_module("TestingModule");
+
+  // Create ruby objects that point to the same instance of MyClass
+  std::string code = R"(my_class = MyClass.new
+                        my_class.set_flag(9)
+                        sink = Sink.new
+                        void_ptr = sink.make_void_shared(my_class)
+                        sink.handle_void(void_ptr))";
+
+  Object result = m.instance_eval(code);
+  ASSERT_EQUAL(9, detail::From_Ruby<long>().convert(result.value()));
+
+  rb_gc_start();
+
+  ASSERT_EQUAL(1, MyClass::constructorCalls);
+  ASSERT_EQUAL(0, MyClass::copyConstructorCalls);
+  ASSERT_EQUAL(0, MyClass::moveConstructorCalls);
+ // ASSERT_EQUAL(1, MyClass::destructorCalls);
+}

data/test/test_Stl_String.cpp

@@ -15,6 +15,11 @@ SETUP(StlString)
   embed_ruby();
 }
 
+TEARDOWN(StlString)
+{
+  rb_gc_start();
+}
+
 TESTCASE(std_string_to_ruby)
 {
   ASSERT(rb_equal(String("").value(), detail::to_ruby(std::string(""))));

data/test/test_Stl_String_View.cpp

@@ -15,6 +15,11 @@ SETUP(StlStringView)
   embed_ruby();
 }
 
+TEARDOWN(StlStringView)
+{
+  rb_gc_start();
+}
+
 TESTCASE(std_string_view_to_ruby)
 {
   ASSERT(rb_equal(String("").value(), detail::to_ruby(std::string_view(""))));

data/test/test_Stl_Type.cpp

@@ -0,0 +1,147 @@
+#include "unittest.hpp"
+#include "embed_ruby.hpp"
+
+#include <rice/rice.hpp>
+#include <rice/stl.hpp>
+
+using namespace Rice;
+
+TESTSUITE(TypeInfo);
+
+SETUP(TypeInfo)
+{
+  embed_ruby();
+}
+
+TEARDOWN(TypeInfo)
+{
+  rb_gc_start();
+}
+
+namespace
+{
+  const std::type_info& typeInfo(int value)
+  {
+    return typeid(value);
+  }
+
+  const std::string typeInfoName(const std::type_info& value)
+  {
+    return value.name();
+  }
+
+  const std::type_index typeIndex(const std::type_info& value)
+  {
+    return std::type_index(value);
+  }
+}
+
+TESTCASE(TypeInfoName)
+{
+  Module m = define_module("TestingModule");
+  m.define_module_function("get_type_info", typeInfo);
+
+  std::string code = R"(int = 5
+                        type_info = get_type_info(5)
+                        type_info.name)";
+
+#ifdef _MSC_VER
+  const char* expected = "int";
+#else
+  const char* expected = "i";
+#endif
+
+  String result = m.module_eval(code);
+  ASSERT_EQUAL(expected, result.c_str());
+}
+
+TESTCASE(TypeInfoHash)
+{
+  Module m = define_module("TestingModule");
+  m.define_module_function("get_type_info", typeInfo);
+
+  std::string code = R"(int = 5
+                        type_info = get_type_info(5)
+                        type_info.hash)";
+
+  Object result = m.module_eval(code);
+  size_t hash = detail::From_Ruby<size_t>().convert(result);
+  ASSERT((hash > 0));
+}
+
+TESTCASE(TypeInfoParameter)
+{
+  Module m = define_module("TestingModule");
+  m.define_module_function("get_type_info", typeInfo).
+    define_module_function("get_type_info_name", typeInfoName);
+
+  std::string code = R"(int = 5
+                        type_info = get_type_info(5)
+                        get_type_info_name(type_info))";
+
+#ifdef _MSC_VER
+  const char* expected = "int";
+#else
+  const char* expected = "i";
+#endif
+
+  String result = m.module_eval(code);
+  ASSERT_EQUAL(expected, result.c_str());
+}
+
+TESTCASE(TypeIndexCreate)
+{
+  Module m = define_module("TestingModule");
+  m.define_module_function("get_type_info", typeInfo).
+    define_module_function("get_type_index", typeIndex);
+
+  std::string code = R"(int = 5
+                        type_info = get_type_info(5)
+                        Rice::Std::TypeIndex.new(type_info))";
+
+#ifdef _MSC_VER
+  const char* expected = "int";
+#else
+  const char* expected = "i";
+#endif
+
+  Data_Object<std::type_index> result = m.module_eval(code);
+  ASSERT_EQUAL(expected, result->name());
+}
+
+TESTCASE(TypeIndexName)
+{
+  Module m = define_module("TestingModule");
+  m.define_module_function("get_type_info", typeInfo).
+    define_module_function("get_type_index", typeIndex);
+
+  std::string code = R"(int = 5
+                        type_info = get_type_info(5)
+                        type_index = get_type_index(type_info)
+                        type_index.name)";
+
+#ifdef _MSC_VER
+  const char* expected = "int";
+#else
+  const char* expected = "i";
+#endif
+
+  String result = m.module_eval(code);
+  ASSERT_EQUAL(expected, result.str());
+}
+
+TESTCASE(TypeIndexHash)
+{
+  Module m = define_module("TestingModule");
+  m.define_module_function("get_type_info", typeInfo).
+    define_module_function("get_type_index", typeIndex);
+
+  std::string code = R"(int = 5
+                        type_info = get_type_info(5)
+                        type_index = get_type_index(type_info)
+                        type_index.hash)";
+
+  Object result = m.module_eval(code);
+  size_t hash = detail::From_Ruby<size_t>().convert(result);
+  ASSERT((hash > 0));
+}

data/test/test_Stl_Unordered_Map.cpp

@@ -1,4 +1,4 @@
-#include <complex>
+#include <complex>
 #include <memory>
 
 #include "unittest.hpp"
@@ -15,6 +15,11 @@ SETUP(UnorderedMap)
   embed_ruby();
 }
 
+TEARDOWN(UnorderedMap)
+{
+  rb_gc_start();
+}
+
 namespace
 {
 
@@ -438,7 +443,7 @@ TESTCASE(AutoRegisterReturn)
 
   Module m = define_module("Testing");
   Object unordered_map = m.module_eval("return_complex_unordered_map");
-  ASSERT_EQUAL("Rice::Std::Unordered_map__basic_string__char_char_traits__char___allocator__char_____complex__double___hash__basic_string__char_char_traits__char___allocator__char_______equal_to__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::UnorderedMap≺string≺char≻‚ complex≺double≻≻",
                unordered_map.class_name().str());
 
   std::string code = R"(unordered_map = return_complex_unordered_map
@@ -465,16 +470,16 @@ TESTCASE(AutoRegisterParameter)
 {
   define_global_function("pass_complex_unordered_map", &passComplexUnorderedMap);
 
-  std::string code = R"(unordered_map = Rice::Std::Unordered_map__basic_string__char_char_traits__char___allocator__char_____complex__double___hash__basic_string__char_char_traits__char___allocator__char_______equal_to__basic_string__char_char_traits__char___allocator__char_______allocator__pair__basic_string__char_char_traits__char___allocator__char____Const_complex__double________.new
-                        unordered_map["four"] = Complex(4.0, 4.0)
-                        unordered_map["five"] = Complex(5.0, 5.0)
-                        pass_complex_unordered_map(unordered_map))";
+  std::string code = u8R"(unordered_map = Rice::Std::UnorderedMap≺string≺char≻‚ complex≺double≻≻.new
+                          unordered_map["four"] = Complex(4.0, 4.0)
+                          unordered_map["five"] = Complex(5.0, 5.0)
+                          pass_complex_unordered_map(unordered_map))";
 
   Module m = define_module("Testing");
   Object unordered_map = m.module_eval(code);
 
   Object result = unordered_map.call("size");
-  ASSERT_EQUAL("Rice::Std::Unordered_map__basic_string__char_char_traits__char___allocator__char_____complex__double___hash__basic_string__char_char_traits__char___allocator__char_______equal_to__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::UnorderedMap≺string≺char≻‚ complex≺double≻≻",
                unordered_map.class_name().str());
   ASSERT_EQUAL(2, detail::From_Ruby<int32_t>().convert(result));
 
@@ -653,6 +658,12 @@ TESTCASE(HashToUnorderedMapWrongTypes)
                                      "two" => 79.0,
                                      "three" => 1000.0}))";
 
+  ASSERT_EXCEPTION_CHECK(
+    Exception,
+    m.module_eval(code),
+    ASSERT_EQUAL(rb_eTypeError, ex.class_of())
+  );
+
   ASSERT_EXCEPTION_CHECK(
     Exception,
     m.module_eval(code),

data/test/test_Stl_Variant.cpp

@@ -289,6 +289,11 @@ SETUP(Variant)
   makeClassVariant();
 }
 
+TEARDOWN(Variant)
+{
+  rb_gc_start();
+}
+
 TESTCASE(ClassReturns)
 {
   Module m = define_module("Testing");