rice 4.3.3 → 4.6.0

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)
+                        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_UniquePtr.cpp

@@ -0,0 +1,202 @@
+#include "unittest.hpp"
+#include "embed_ruby.hpp"
+#include <rice/rice.hpp>
+#include <rice/stl.hpp>
+
+#include <memory>
+
+using namespace Rice;
+
+TESTSUITE(UniquePtr);
+
+namespace
+{
+  class MyClass
+  {
+  public:
+    static inline int32_t constructorCalls = 0;
+    static inline int32_t copyConstructorCalls = 0;
+    static inline int32_t moveConstructorCalls = 0;
+    static inline int32_t destructorCalls = 0;
+
+    static void reset()
+    {
+      constructorCalls = 0;
+      copyConstructorCalls = 0;
+      moveConstructorCalls = 0;
+      destructorCalls = 0;
+    }
+
+  public:
+    int flag = 0;
+
+  public:
+    MyClass()
+    {
+      constructorCalls++;
+    }
+
+    ~MyClass()
+    {
+      destructorCalls++;
+    }
+
+    MyClass(const MyClass& other): flag(other.flag)
+    {
+      copyConstructorCalls++;
+    }
+
+    MyClass(MyClass&& other) : flag(other.flag)
+    {
+      moveConstructorCalls++;
+    }
+
+    void setFlag(int value)
+    {
+      this->flag = value;
+    }
+  };
+
+  class Factory
+  {
+  public:
+    std::unique_ptr<MyClass> transfer()
+    {
+      return std::make_unique<MyClass>();
+    }
+  };
+
+  class Sink
+  {
+  public:
+    int takeOwnership(std::unique_ptr<MyClass> ptr)
+    {
+      return ptr->flag;
+    }
+
+    int updatePointer(std::unique_ptr<MyClass>& ptr, MyClass* myClass)
+    {
+      ptr.reset(myClass);
+      return ptr->flag;
+    }
+  };
+
+  int extractFlagUniquePtrRef(std::unique_ptr<MyClass>& myClass)
+  {
+    return myClass->flag;
+  }
+}
+
+SETUP(UniquePtr)
+{
+  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").
+    define_constructor(Constructor<Factory>()).
+    define_method("transfer", &Factory::transfer);
+
+  define_class<Sink>("Sink").
+    define_constructor(Constructor<Sink>()).
+    define_method("take_ownership", &Sink::takeOwnership).
+    define_method("update_pointer", &Sink::updatePointer,
+      Arg("ptr"), Arg("myClass").takeOwnership());
+
+  define_global_function("extract_flag_unique_ptr_ref", &extractFlagUniquePtrRef);
+}
+
+TEARDOWN(UniquePtr)
+{
+  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();
+
+  Module m = define_module("TestingModule");
+
+  std::string code = R"(factory = Factory.new
+                        10.times do |i|
+                          my_class = factory.transfer
+                          my_class.set_flag(i)
+                          my_class = nil
+                        end)";
+
+  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);
+}
+
+TESTCASE(RefParameter)
+{
+  MyClass::reset();
+
+  Module m = define_module("TestingModule");
+
+  std::string code = R"(factory = Factory.new
+                        my_class = factory.transfer
+                        my_class.set_flag(7)
+                        extract_flag_unique_ptr_ref(my_class))";
+
+  Object result = m.module_eval(code);
+  ASSERT_EQUAL(7, detail::From_Ruby<int>().convert(result));
+}
+
+TESTCASE(RoundTrip)
+{
+  MyClass::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(Update)
+{
+  MyClass::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()));
+}

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
 {
 
@@ -42,9 +47,9 @@ TESTCASE(StringUnorderedMap)
 {
   Module m = define_module("Testing");
 
-  Class c = define_unordered_map<std::unordered_map<std::string, std::string>>("StringUnorderedMap");
+  Class c = define_unordered_map<std::string, std::string>("StringUnorderedMap");
 
-  Object unordered_map = m.module_eval("$unordered_map = StringUnorderedMap.new");
+  Object unordered_map = m.module_eval("$unordered_map = Std::StringUnorderedMap.new");
   Object result = unordered_map.call("size");
   ASSERT_EQUAL(0, detail::From_Ruby<int32_t>().convert(result));
 
@@ -61,8 +66,8 @@ TESTCASE(WrongType)
 {
   Module m = define_module("Testing");
 
-  Class c = define_unordered_map<std::unordered_map<std::string, std::string>>("StringUnorderedMap");
-  Object unordered_map = m.module_eval("$unordered_map = StringUnorderedMap.new");
+  Class c = define_unordered_map<std::string, std::string>("StringUnorderedMap");
+  Object unordered_map = m.module_eval("$unordered_map = Std::StringUnorderedMap.new");
 
   ASSERT_EXCEPTION_CHECK(
     Exception,
@@ -79,7 +84,7 @@ TESTCASE(Empty)
 {
   Module m = define_module("Testing");
 
-  Class c = define_unordered_map<std::unordered_map<std::string, std::int32_t>>("IntUnorderedMap");
+  Class c = define_unordered_map<std::string, std::int32_t>("IntUnorderedMap");
   Data_Object<std::unordered_map<std::string, std::int32_t>> unordered_map = c.call("new");
 
   Object result = unordered_map.call("size");
@@ -93,7 +98,7 @@ TESTCASE(Include)
 {
   Module m = define_module("Testing");
 
-  Class c = define_unordered_map<std::unordered_map<std::string, std::int32_t>>("IntUnorderedMap");
+  Class c = define_unordered_map<std::string, std::int32_t>("IntUnorderedMap");
   Data_Object<std::unordered_map<std::string, std::int32_t>> unordered_map = c.call("new");
   unordered_map.call("[]=", "one", 1);
   unordered_map.call("[]=", "two", 2);
@@ -112,7 +117,7 @@ TESTCASE(Value)
 {
   Module m = define_module("Testing");
 
-  Class c = define_unordered_map<std::unordered_map<std::string, std::int32_t>>("IntUnorderedMap");
+  Class c = define_unordered_map<std::string, std::int32_t>("IntUnorderedMap");
   Data_Object<std::unordered_map<std::string, std::int32_t>> unordered_map = c.call("new");
   unordered_map.call("[]=", "one", 1);
   unordered_map.call("[]=", "two", 2);
@@ -128,7 +133,7 @@ TESTCASE(ToString)
 {
   Module m = define_module("Testing");
 
-  Class c = define_unordered_map<std::unordered_map<std::string, std::int32_t>>("IntUnorderedMap");
+  Class c = define_unordered_map<std::string, std::int32_t>("IntUnorderedMap");
   Data_Object<std::unordered_map<std::string, std::int32_t>> unordered_map = c.call("new");
   unordered_map.call("[]=", "one", 1);
   unordered_map.call("[]=", "two", 2);
@@ -146,7 +151,7 @@ TESTCASE(Update)
 {
   Module m = define_module("Testing");
 
-  Class c = define_unordered_map<std::unordered_map<std::string, std::string>>("StringUnorderedMap");
+  Class c = define_unordered_map<std::string, std::string>("StringUnorderedMap");
   Data_Object<std::unordered_map<std::string, std::string>> unordered_map = c.call("new");
   unordered_map.call("[]=", "one", "original 1");
   unordered_map.call("[]=", "two", "original 2");
@@ -168,7 +173,7 @@ TESTCASE(Modify)
 {
   Module m = define_module("Testing");
 
-  Class c = define_unordered_map<std::unordered_map<std::string, int64_t>>("Int64UnorderedMap");
+  Class c = define_unordered_map<std::string, int64_t>("Int64UnorderedMap");
   Data_Object<std::unordered_map<std::string, std::int64_t>> unordered_map = c.call("new");
 
   Object result = unordered_map.call("[]=", "one", 3232323232);
@@ -187,7 +192,7 @@ TESTCASE(KeysAndValues)
 {
   Module m = define_module("Testing");
 
-  Class c = define_unordered_map<std::unordered_map<std::string, int32_t>>("Int32UnorderedMap");
+  Class c = define_unordered_map<std::string, int32_t>("Int32UnorderedMap");
   Data_Object<std::unordered_map<std::string, std::int32_t>> unordered_map = c.call("new");
 
   unordered_map.call("[]=", "one", 1);
@@ -215,7 +220,7 @@ TESTCASE(Copy)
 {
   Module m = define_module("Testing");
 
-  Class c = define_unordered_map<std::unordered_map<std::string, double>>("DoubleUnorderedMap");
+  Class c = define_unordered_map<std::string, double>("DoubleUnorderedMap");
   Object object = c.call("new");
 
   object.call("[]=", "one", 11.1);
@@ -236,9 +241,9 @@ TESTCASE(Copy)
 TESTCASE(Iterate)
 {
   Module m = define_module("Testing");
-  Class c = define_unordered_map<std::unordered_map<std::string, int>>("IntUnorderedMap");
+  Class c = define_unordered_map<std::string, int>("IntUnorderedMap");
 
-  std::string code = R"(unordered_map = IntUnorderedMap.new
+  std::string code = R"(unordered_map = Std::IntUnorderedMap.new
                         unordered_map["five"] = 5
                         unordered_map["six"] = 6
                         unordered_map["seven"] = 7
@@ -260,9 +265,9 @@ TESTCASE(Iterate)
 TESTCASE(ToEnum)
 {
   Module m = define_module("Testing");
-  Class c = define_unordered_map<std::unordered_map<std::string, int>>("IntUnorderedMap");
+  Class c = define_unordered_map<std::string, int>("IntUnorderedMap");
 
-  std::string code = R"(unordered_map = IntUnorderedMap.new
+  std::string code = R"(unordered_map = Std::IntUnorderedMap.new
                         unordered_map["five"] = 5
                         unordered_map["six"] = 6
                         unordered_map["seven"] = 7
@@ -285,9 +290,9 @@ TESTCASE(ToEnum)
 TESTCASE(ToEnumSize)
 {
   Module m = define_module("TestingModule");
-  Class c = define_unordered_map<std::unordered_map<std::string, int>>("IntUnorderedMap");
+  Class c = define_unordered_map<std::string, int>("IntUnorderedMap");
 
-  std::string code = R"(map = IntUnorderedMap.new
+  std::string code = R"(map = Std::IntUnorderedMap.new
                         map["five"] = 5
                         map["six"] = 6
                         map["seven"] = 7
@@ -322,7 +327,7 @@ TESTCASE(NotComparable)
   define_class<NotComparable>("NotComparable").
     define_constructor(Constructor<NotComparable, uint32_t>());
 
-  Class c = define_unordered_map<std::unordered_map<std::string, NotComparable>>("NotComparableUnorderedMap");
+  Class c = define_unordered_map<std::string, NotComparable>("NotComparableUnorderedMap");
 
   Data_Object<std::unordered_map<std::string, NotComparable>> unordered_map = c.call("new");
   unordered_map.call("[]=", "one", NotComparable(1));
@@ -341,7 +346,7 @@ TESTCASE(NotPrintable)
   define_class<NotComparable>("NotComparable").
     define_constructor(Constructor<NotComparable, uint32_t>());
 
-  Class c = define_unordered_map<std::unordered_map<std::string, NotComparable>>("NotComparableUnorderedMap");
+  Class c = define_unordered_map<std::string, NotComparable>("NotComparableUnorderedMap");
 
   Data_Object<std::unordered_map<std::string, NotComparable>> unordered_map = c.call("new");
   unordered_map.call("[]=", "one", NotComparable(1));
@@ -382,7 +387,7 @@ TESTCASE(Comparable)
   define_class<Comparable>("IsComparable").
     define_constructor(Constructor<Comparable, uint32_t>());
 
-  Class c = define_unordered_map<std::unordered_map<std::string, Comparable>>("ComparableUnorderedMap");
+  Class c = define_unordered_map<std::string, Comparable>("ComparableUnorderedMap");
 
   Data_Object<std::unordered_map<std::string, Comparable>> unordered_map = c.call("new");
   
@@ -399,7 +404,7 @@ TESTCASE(Printable)
   define_class<Comparable>("IsComparable").
     define_constructor(Constructor<Comparable, uint32_t>());
 
-  Class c = define_unordered_map<std::unordered_map<std::string, Comparable>>("ComparableUnorderedMap");
+  Class c = define_unordered_map<std::string, Comparable>("ComparableUnorderedMap");
 
   Data_Object<std::unordered_map<std::string, Comparable>> unordered_map = c.call("new");
   unordered_map.call("[]=", "one", Comparable(1));
@@ -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("Std::UnorderedMap≺string‚ complex≺double≻≻",
                unordered_map.class_name().str());
 
   std::string code = R"(unordered_map = return_complex_unordered_map
@@ -449,14 +454,8 @@ TESTCASE(AutoRegisterReturn)
   ASSERT_EQUAL(Qtrue, result.value());
 
   // Now register the unordered_map again
-  define_unordered_map<std::unordered_map<std::string, std::complex<double>>>("ComplexUnorderedMap");
-  code = R"(unordered_map = ComplexUnorderedMap.new)";
-  result = m.module_eval(code);
-  ASSERT(result.is_instance_of(unordered_map.class_of()));
-
-  // And again in the module
-  define_unordered_map_under<std::unordered_map<std::string, std::complex<double>>>(m, "ComplexUnorderedMap2");
-  code = R"(unordered_map = Testing::ComplexUnorderedMap2.new)";
+  define_unordered_map<std::string, std::complex<double>>("ComplexUnorderedMap");
+  code = R"(unordered_map = Std::ComplexUnorderedMap.new)";
   result = m.module_eval(code);
   ASSERT(result.is_instance_of(unordered_map.class_of()));
 }
@@ -465,16 +464,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 = R"(unordered_map = Std::UnorderedMap≺string‚ 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("Std::UnorderedMap≺string‚ complex≺double≻≻",
                unordered_map.class_name().str());
   ASSERT_EQUAL(2, detail::From_Ruby<int32_t>().convert(result));
 
@@ -493,7 +492,7 @@ namespace
 
 TESTCASE(DefaultValue)
 {
-  define_unordered_map<std::unordered_map<std::string, std::string>>("StringUnorderedMap");
+  define_unordered_map<std::string, std::string>("StringUnorderedMap");
   define_global_function("default_unordered_map", &defaultUnorderedMap, Arg("strings") = std::unordered_map<std::string, std::string>{ {"one", "value 1"}, {"two", "value 2"}, {"three", "value 3"} });
 
   Module m = define_module("Testing");
@@ -653,6 +652,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),