rice 4.5.0 → 4.6.0

data/test/{test_Stl_SmartPointer.cpp → test_Stl_SharedPtr.cpp}

@@ -1,4 +1,4 @@
-#include "unittest.hpp"
+#include "unittest.hpp"
 #include "embed_ruby.hpp"
 #include <rice/rice.hpp>
 #include <rice/stl.hpp>
@@ -7,7 +7,7 @@
 
 using namespace Rice;
 
-TESTSUITE(SmartPointer);
+TESTSUITE(SharedPtr);
 
 namespace
 {
@@ -69,11 +69,6 @@ namespace
     {
     }
 
-    std::unique_ptr<MyClass> transfer()
-    {
-      return std::make_unique<MyClass>();
-    }
-
     std::shared_ptr<MyClass> share()
     {
       if (!instance_)
@@ -99,22 +94,11 @@ namespace
   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);
@@ -133,11 +117,6 @@ namespace
     }
   };
 
-  int extractFlagUniquePtrRef(std::unique_ptr<MyClass>& myClass)
-  {
-    return myClass->flag;
-  }
-
   int extractFlagSharedPtr(std::shared_ptr<MyClass> myClass)
   {
     return myClass->flag;
@@ -149,7 +128,7 @@ namespace
   }
 }
 
-SETUP(SmartPointer)
+SETUP(SharedPtr)
 {
   embed_ruby();
 
@@ -163,26 +142,18 @@ SETUP(SmartPointer)
 
   define_class<Factory>("Factory").
     define_constructor(Constructor<Factory>()).
-    define_method("transfer", &Factory::transfer).
     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,
+    define_method("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);
 
@@ -192,7 +163,7 @@ SETUP(SmartPointer)
       Arg("myClass") = std::make_shared<MyClass>());
 }
 
-TEARDOWN(SmartPointer)
+TEARDOWN(SharedPtr)
 {
   rb_gc_start();
 #if RUBY_API_VERSION_MAJOR == 3 && RUBY_API_VERSION_MINOR >= 2
@@ -200,30 +171,6 @@ TEARDOWN(SmartPointer)
 #endif
 }
 
-TESTCASE(takeOwnership)
-{
-  MyClass::reset();
-  Factory::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);
-  ASSERT(!Factory::instance_);
-}
-
 TESTCASE(ShareOwnership)
 {
   MyClass::reset();
@@ -282,23 +229,7 @@ TESTCASE(ShareOwnership2)
   ASSERT_EQUAL(2, Factory::instance_.use_count());
 }
 
-TESTCASE(UniquePtrRefParameter)
-{
-  MyClass::reset();
-  Factory::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(SharedPtrParameter)
+TESTCASE(PtrParameter)
 {
   MyClass::reset();
   Factory::reset();
@@ -314,7 +245,7 @@ TESTCASE(SharedPtrParameter)
   ASSERT_EQUAL(8, detail::From_Ruby<int>().convert(result));
 }
 
-TESTCASE(SharedPtrRefParameter)
+TESTCASE(RefParameter)
 {
   MyClass::reset();
   Factory::reset();
@@ -330,7 +261,7 @@ TESTCASE(SharedPtrRefParameter)
   ASSERT_EQUAL(9, detail::From_Ruby<int>().convert(result));
 }
 
-TESTCASE(SharedPtrDefaultParameter)
+TESTCASE(DefaultParameter)
 {
   MyClass::reset();
   Factory::reset();
@@ -347,7 +278,7 @@ TESTCASE(SharedPtrDefaultParameter)
   ASSERT_EQUAL(0, detail::From_Ruby<int>().convert(result));
 }
 
-TESTCASE(SharedPtrRefDefaultParameter)
+TESTCASE(RefDefaultParameter)
 {
   MyClass::reset();
   Factory::reset();
@@ -368,10 +299,10 @@ TESTCASE(SharedPtrRefDefaultParameter)
   ASSERT_EQUAL(1, MyClass::constructorCalls);
   ASSERT_EQUAL(0, MyClass::copyConstructorCalls);
   ASSERT_EQUAL(0, MyClass::moveConstructorCalls);
- // ASSERT_EQUAL(1, MyClass::destructorCalls);
+  ASSERT_EQUAL(1, MyClass::destructorCalls);
 }
 
-TESTCASE(UniquePtrRoundTrip)
+TESTCASE(RoundTrip)
 {
   MyClass::reset();
   Factory::reset();
@@ -380,22 +311,21 @@ TESTCASE(UniquePtrRoundTrip)
 
   // 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)
+                        my_class = factory.share
                         
                         sink = Sink.new
-                        sink.take_ownership(my_class))";
+                        sink.share_ownership(my_class))";
 
   Object result = m.instance_eval(code);
-  ASSERT_EQUAL(5, detail::From_Ruby<int>().convert(result.value()));
+  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(1, MyClass::destructorCalls);
+  ASSERT_EQUAL(1, MyClass::destructorCalls);
 }
 
-TESTCASE(UniquePtrUpdate)
+TESTCASE(Update)
 {
   MyClass::reset();
   Factory::reset();
@@ -404,85 +334,125 @@ TESTCASE(UniquePtrUpdate)
 
   // 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_class1 = factory.share
+                        my_class1.set_flag(7)
+
                         my_class2 = MyClass.new
-                        my_class2.set_flag(11)
+                        my_class2.set_flag(14)
 
                         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()));
+  ASSERT_EQUAL(14, detail::From_Ruby<long>().convert(result.value()));
 }
 
-TESTCASE(SharedPtrRoundTrip)
+TESTCASE(Void)
 {
   MyClass::reset();
   Factory::reset();
 
+  detail::Type<Buffer<void>>::verify();
+
   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
-                        
+  std::string code = R"(my_class = MyClass.new
+                        my_class.set_flag(9)
                         sink = Sink.new
-                        sink.share_ownership(my_class))";
+                        void_ptr = sink.make_void_shared(my_class)
+                        sink.handle_void(void_ptr))";
 
   Object result = m.instance_eval(code);
-  ASSERT_EQUAL(3, detail::From_Ruby<long>().convert(result.value()));
+  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(0, MyClass::destructorCalls);
+ // ASSERT_EQUAL(1, MyClass::destructorCalls);
 }
 
-TESTCASE(SharedPtrUpdate)
+namespace
 {
-  MyClass::reset();
-  Factory::reset();
+  std::shared_ptr<int> createPointer(int value)
+  {
+    int* sharedInt = new int(value);
+    std::shared_ptr<int> shared(sharedInt);
+    return shared;
+  }
 
-  Module m = define_module("TestingModule");
+  int getPointerValue(std::shared_ptr<int> ptr)
+  {
+    return *ptr;
+  }
 
-  // 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)
+  int updatePointerValue(std::shared_ptr<int> ptr)
+  {
+    *ptr = *ptr + 1;
+    return *ptr;
+  }
+}
 
-                        my_class2 = MyClass.new
-                        my_class2.set_flag(14)
+TESTCASE(PointerToInt)
+{
+  detail::Type<Buffer<int>>::verify();
 
-                        sink = Sink.new
-                        sink.update_pointer(my_class1, my_class2))";
+  Module m = define_module("SharedPtrInt").
+    define_module_function("create_pointer", &createPointer).
+    define_module_function("get_pointer_value", &getPointerValue);
+
+  std::string code = R"(ptr = create_pointer(44)
+                        get_pointer_value(ptr))";
 
   Object result = m.instance_eval(code);
-  ASSERT_EQUAL(14, detail::From_Ruby<long>().convert(result.value()));
+  ASSERT_EQUAL(44, detail::From_Ruby<int>().convert(result.value()));
 }
 
-TESTCASE(SharedPtrVoid)
+TESTCASE(CreatePointerToInt)
 {
-  MyClass::reset();
-  Factory::reset();
+  Module m = define_module("CreatePointerToInt").
+    define_module_function("get_pointer_value", &getPointerValue);
 
-  Module m = define_module("TestingModule");
+  define_shared_ptr<int>("SharedPtrInt");
 
-  // 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))";
+  std::string code = R"(buffer = Rice::Buffer≺int≻.new(45)
+                        ptr = Std::SharedPtrInt.new(buffer)
+                        get_pointer_value(ptr))";
 
   Object result = m.instance_eval(code);
-  ASSERT_EQUAL(9, detail::From_Ruby<long>().convert(result.value()));
+  ASSERT_EQUAL(45, detail::From_Ruby<int>().convert(result.value()));
+}
 
-  rb_gc_start();
+TESTCASE(UpdatePointerToInt)
+{
+  Module m = define_module("UpdatePointerToInt").
+    define_module_function("update_pointer_value", &updatePointerValue);
 
-  ASSERT_EQUAL(1, MyClass::constructorCalls);
-  ASSERT_EQUAL(0, MyClass::copyConstructorCalls);
-  ASSERT_EQUAL(0, MyClass::moveConstructorCalls);
- // ASSERT_EQUAL(1, MyClass::destructorCalls);
+  define_shared_ptr<int>();
+
+  std::string code = R"(buffer = Rice::Buffer≺int≻.new(45)
+                        ptr = Std::SharedPtr≺int≻.new(buffer)
+                        update_pointer_value(ptr))";
+
+  Object result = m.instance_eval(code);
+  ASSERT_EQUAL(46, detail::From_Ruby<int>().convert(result.value()));
 }
+
+TESTCASE(ReadPointerToInt)
+{
+  detail::Type<Buffer<int>>::verify();
+
+  Module m = define_module("ReadPointerToInt").
+      define_module_function("create_pointer", &createPointer);
+
+  std::string code = R"(ptr = create_pointer(50)
+                          buffer = Rice::Buffer≺int≻.new(ptr)
+                          buffer.to_ary(1))";
+
+  Array array = m.instance_eval(code);
+  std::vector<int> actual = array.to_vector<int>();
+  std::vector<int> expected { 50 };
+  ASSERT_EQUAL(expected, actual);
+}

data/test/test_Stl_Tuple.cpp

@@ -0,0 +1,116 @@
+#include "unittest.hpp"
+#include "embed_ruby.hpp"
+#include <rice/rice.hpp>
+#include <rice/stl.hpp>
+
+#include <tuple>
+#include <complex>
+
+using namespace Rice;
+using namespace std::complex_literals;
+
+TESTSUITE(Tuple);
+
+SETUP(Tuple)
+{
+  embed_ruby();
+}
+
+TEARDOWN(Tuple)
+{
+  rb_gc_start();
+}
+
+namespace
+{
+  /*inline std::ostream& operator<<(std::ostream& stream, Tuple_T const& tuple)
+  {
+    stream << "Tuple(" << "index: " << tuple.index() << ")";
+    return stream;
+  }*/
+
+  class MyTupleClass
+  {
+  public:
+    using Tuple_T = std::tuple<std::string,
+                               std::complex<double>,
+                               std::vector<int>,
+                               double,
+                               bool,
+                               int>;
+
+    Tuple_T someTuple()
+    {
+      Tuple_T result{ "Hello", 1i, std::vector<int>{1, 2, 3}, 3.3, true, 5 };
+      return result;
+    }
+
+    bool validateTuple(Tuple_T tuple)
+    {
+      ASSERT_EQUAL("Ruby", std::get<0>(tuple).c_str());
+
+      std::complex<double> complex = std::get<1>(tuple);
+      ASSERT_EQUAL(2, complex.real());
+      ASSERT_EQUAL(3, complex.imag());
+       
+      std::vector<int> vec = std::get<2>(tuple);
+      ASSERT_EQUAL(3, vec.size());
+      ASSERT_EQUAL(3, vec[0]);
+      ASSERT_EQUAL(4, vec[1]);
+      ASSERT_EQUAL(5, vec[2]);
+
+
+      ASSERT_EQUAL(4.4, std::get<3>(tuple));
+      ASSERT_EQUAL(false, std::get<4>(tuple));
+      ASSERT_EQUAL(9, std::get<5>(tuple));
+
+      return true;
+    }
+  };
+}
+
+Data_Type<MyTupleClass> defineMyTupleClass()
+{
+  return define_class<MyTupleClass>("MyTupleClass").
+    define_constructor(Constructor<MyTupleClass>()).
+    define_method("some_tuple", &MyTupleClass::someTuple).
+    define_method("validate_tuple", &MyTupleClass::validateTuple);
+}
+
+TESTCASE(TupleToRuby)
+{
+  Data_Type<MyTupleClass> klass = defineMyTupleClass();
+
+  Module m = define_module("TupleTesting");
+
+  std::string code = R"(my_class = MyTupleClass.new
+                        my_class.some_tuple)";
+
+  Array result = m.module_eval(code);
+  
+  ASSERT_EQUAL(6, result.size());
+
+  ASSERT_EQUAL("Hello", detail::From_Ruby<std::string>().convert(result[0].value()).c_str());
+  ASSERT_EQUAL(1i, detail::From_Ruby<std::complex<double>>().convert(result[1].value()));
+  
+  std::vector<int> converted = detail::From_Ruby<std::vector<int>>().convert(result[2].value());
+  ASSERT_EQUAL(3, converted.size());
+
+  ASSERT_EQUAL(3.3, detail::From_Ruby<double>().convert(result[3].value()));
+  ASSERT_EQUAL(Qtrue, result[4].value());
+  ASSERT_EQUAL(5, detail::From_Ruby<int>().convert(result[5].value()));
+}
+
+TESTCASE(TupleFromRuby)
+{
+  Data_Type<MyTupleClass> klass = defineMyTupleClass();
+
+  Module m = define_module("TupleTesting");
+
+  std::string code = R"(my_class = MyTupleClass.new
+                        array = ["Ruby", Complex(2, 3), [3, 4, 5], 4.4, false, 9]
+                        my_class.validate_tuple(array))";
+
+  Object result = m.module_eval(code);
+  ASSERT_EQUAL(Qtrue, result.value());
+}

data/test/test_Stl_Type.cpp

@@ -97,7 +97,7 @@ TESTCASE(TypeIndexCreate)
 
   std::string code = R"(int = 5
                         type_info = get_type_info(5)
-                        Rice::Std::TypeIndex.new(type_info))";
+                        Std::TypeIndex.new(type_info))";
 
 #ifdef _MSC_VER
   const char* expected = "int";