rice 4.6.1 → 4.7.1

data/test/test_GVL.cpp

@@ -0,0 +1,109 @@
+#include "unittest.hpp"
+#include "embed_ruby.hpp"
+#include <rice/rice.hpp>
+
+#include <chrono>
+#include <thread>
+
+using namespace Rice;
+
+TESTSUITE(GVL);
+
+SETUP(GVL)
+{
+  embed_ruby();
+}
+
+TEARDOWN(GVL)
+{
+  rb_gc_start();
+}
+
+namespace
+{
+  int slowFunction1()
+  {
+    std::this_thread::sleep_for(std::chrono::milliseconds(100));
+    return 83;
+  }
+
+  void slowFunction2()
+  {
+    std::this_thread::sleep_for(std::chrono::milliseconds(100));
+  }
+
+  void functionException()
+  {
+		throw std::runtime_error("This is an exception from functionException");
+  }
+
+  class Task
+  {
+    public:
+			Task(int id) : id_(id)
+      {
+      }
+
+      int run(bool arg1)
+      {
+        std::this_thread::sleep_for(std::chrono::milliseconds(100));
+        return this->id_;
+		  }
+
+    private:
+      int id_;
+  };
+}
+
+TESTCASE(Function)
+{
+  int result = detail::no_gvl(&slowFunction1);
+  ASSERT_EQUAL(83, result);
+}
+
+TESTCASE(FunctionViaRuby)
+{
+  Module m = define_module("Testing");
+  m.define_module_function("slow_function_1", &slowFunction1, Function().setNoGvl());
+  
+  std::string code = R"(slow_function_1)";
+  Object result = m.module_eval(code);
+  ASSERT_EQUAL(83, detail::From_Ruby<int>().convert(result));
+}
+
+TESTCASE(FunctionNoReturn)
+{
+  detail::no_gvl(&slowFunction2);
+  ASSERT_EQUAL(true, true);
+}
+
+TESTCASE(FunctionWithException)
+{
+  ASSERT_EXCEPTION_CHECK(
+    std::runtime_error,
+    detail::no_gvl(&functionException),
+    ASSERT_EQUAL("This is an exception from functionException", ex.what())
+  );
+}
+
+TESTCASE(MemberFunction)
+{
+	Task task(84);
+  int result = detail::no_gvl(&Task::run, task, false);
+  ASSERT_EQUAL(84, result);
+}
+
+TESTCASE(MemberFunctionNoGvl)
+{
+  Module m = define_module("Testing");
+
+  Class task = define_class_under<Task>(m, "Task")
+    .define_constructor(Constructor<Task, int>())
+    .define_method("run", &Task::run, Function().setNoGvl());
+
+  std::string code = R"(task = Task.new(85)
+                        task.run(true))";
+
+  Object result = m.module_eval(code);
+  ASSERT_EQUAL(85, detail::From_Ruby<int>().convert(result));
+}

data/test/test_Iterator.cpp

@@ -350,7 +350,7 @@ TESTCASE(IterateNoCopy)
   Data_Object<ContainerValues> wrapper(container);
   Array a = wrapper.instance_eval("self.to_a");
 
-  ASSERT_EQUAL(container.data_.size(), a.size());
+  ASSERT_EQUAL(container.data_.size(), (size_t)a.size());
 
   for (size_t i = 0; i < container.data_.size(); i++)
   {

data/test/test_Keep_Alive_No_Wrapper.cpp

@@ -37,10 +37,12 @@ namespace
         pets_.clear();
       }
 
-    Object getPets(void)    {
+    Object getPets(void)
+    {
       Array pets;
-      for(auto p: pets_) {
-        pets.push(p);
+      for(auto p: pets_)
+      {
+        pets.push(p, false);
       }
       return pets;
     }

data/test/test_Module.cpp

@@ -1,4 +1,4 @@
-#include "unittest.hpp"
+#include "unittest.hpp"
 #include "embed_ruby.hpp"
 
 #include <rice/rice.hpp>
@@ -11,7 +11,6 @@ TESTSUITE(Module);
 SETUP(Module)
 {
   embed_ruby();
-  define_fundamental_buffer_types();
 }
 
 TEARDOWN(Module)
@@ -208,8 +207,8 @@ TESTCASE(include_module)
   ASSERT_EQUAL(&m, &m2);
   Array ancestors(m.ancestors());
   Array expected_ancestors;
-  expected_ancestors.push(m);
-  expected_ancestors.push(Module(rb_mEnumerable));
+  expected_ancestors.push(m, false);
+  expected_ancestors.push(Module(rb_mEnumerable), false);
   ASSERT_EQUAL(expected_ancestors, ancestors);
 }
 
@@ -467,7 +466,7 @@ TESTCASE(define_method_works_with_pointers)
 
   int anInt = 3;
   Buffer<int> buffer(&anInt, 1);
-  m.call("bar", std::move(buffer), "testing");
+  m.call("bar", buffer.ptr(), "testing");
 
   ASSERT_EQUAL(3, with_pointers_x);
   ASSERT_EQUAL("testing", with_pointers_str);
@@ -503,10 +502,10 @@ TESTCASE(pointers)
 
   Module m = define_module("TestingModule");
   std::string code = R"(int_buffer = Rice::Buffer≺int≻.new(32)
-                          bool_buffer = Rice::Buffer≺bool≻.new(true)
-                          double_buffer = Rice::Buffer≺float≻.new(33.0)
-                          float_buffer = Rice::Buffer≺double≻.new(34.0)
-                          with_pointers(int_buffer, bool_buffer, double_buffer, float_buffer))";
+                        bool_buffer = Rice::Buffer≺bool≻.new(true)
+                        double_buffer = Rice::Buffer≺float≻.new(33.0)
+                        float_buffer = Rice::Buffer≺double≻.new(34.0)
+                        with_pointers(int_buffer.data, bool_buffer.data, double_buffer.data, float_buffer.data))";
 
   m.module_eval(code);
 

data/test/test_Object.cpp

@@ -194,7 +194,7 @@ TESTCASE(call_with_keywords)
   Hash keywords;
   keywords[":exception"] = false;
   Object result = m.call_kw("keywords_test", "charlie", keywords);
-  ASSERT_EQUAL("charlie", detail::From_Ruby<const char*>().convert(result.value()));
+  ASSERT_EQUAL("charlie", detail::From_Ruby<char*>().convert(result.value()));
 
   keywords[":exception"] = true;
 

data/test/test_Overloads.cpp

@@ -1,4 +1,4 @@
-#include "unittest.hpp"
+#include "unittest.hpp"
 #include "embed_ruby.hpp"
 #include <rice/rice.hpp>
 #include <rice/stl.hpp>
@@ -647,13 +647,13 @@ TESTCASE(int_conversion_6)
   Class c = define_class<MyClass3>("MyClass3").
     define_constructor(Constructor<MyClass3>()).
     define_method<std::string(MyClass3::*)(unsigned char)>("run", &MyClass3::run).
-    define_method<std::string(MyClass3::*)(unsigned char*)>("run", &MyClass3::run);
+    define_method<std::string(MyClass3::*)(unsigned char*)>("run", &MyClass3::run, Arg("value").setBuffer());
 
   Module m = define_module("Testing");
 
   std::string code = R"(my_class = MyClass3.new
-                          buffer = Rice::Buffer≺unsigned char≻.new("54")
-                          my_class.run(buffer))";
+                        buffer = Rice::Buffer≺unsigned char≻.new("54")
+                        my_class.run(buffer.data))";
   String result = m.module_eval(code);
   ASSERT_EQUAL("run<unsigned char*>", result.str());
 }
@@ -707,8 +707,8 @@ TESTCASE(NonConstRef)
   Module m = define_module("Testing");
 
   std::string code = R"(my_class4 = MyClass4.new
-                          my_class5 = MyClass5.new(my_class4)
-                          my_class5.result)";
+                        my_class5 = MyClass5.new(my_class4)
+                        my_class5.result)";
   String result = m.module_eval(code);
   ASSERT_EQUAL("non-const ref", result.str());
 }
@@ -726,8 +726,8 @@ TESTCASE(ConstRef)
   Module m = define_module("Testing");
 
   std::string code = R"(my_class4 = MyClass4.const_instance
-                          my_class5 = MyClass5.new(my_class4)
-                          my_class5.result)";
+                        my_class5 = MyClass5.new(my_class4)
+                        my_class5.result)";
   String result = m.module_eval(code);
   ASSERT_EQUAL("const ref", result.str());
 }
@@ -799,8 +799,56 @@ TESTCASE(ConstPointer)
   Module m = define_module("Testing");
 
   std::string code = R"(my_class6 = MyClass6.const_instance
-                          my_class7 = MyClass7.new(my_class6)
-                          my_class7.result)";
+                        my_class7 = MyClass7.new(my_class6)
+                        my_class7.result)";
   String result = m.module_eval(code);
   ASSERT_EQUAL("const pointer", result.str());
 }
+
+namespace
+{
+  std::string pointer(const MyClass6* data)
+  {
+    return "pointer";
+  }
+
+  std::string pointer(MyClass6* data)
+  {
+    return "pointerBuffer";
+  }
+}
+
+TESTCASE(PointerNotBuffer)
+{
+  Module m = define_module("Testing");
+
+  define_class<MyClass6>("MyClass").
+    define_constructor(Constructor<MyClass6>());
+
+  m.define_module_function<std::string(*)(const MyClass6*)>("pointer", pointer).
+    define_module_function<std::string(*)(MyClass6*)>("pointer", pointer, Arg("data").setBuffer());
+
+  std::string code = R"(my_class6 = MyClass6.new
+                        pointer(my_class6))";
+  
+  String result = m.module_eval(code);
+  ASSERT_EQUAL("pointer", result.str());
+}
+
+TESTCASE(PointerBuffer)
+{
+  Module m = define_module("Testing");
+
+  define_class<MyClass6>("MyClass").
+    define_constructor(Constructor<MyClass6>());
+
+  m.define_function<std::string(*)(const MyClass6*)>("pointer", pointer).
+    define_function<std::string(*)(MyClass6*)>("pointer", pointer, Arg("data").setBuffer());
+
+  std::string code = R"(my_class6 = MyClass6.new
+                        buffer = Rice::Buffer≺AnonymousNamespace꞉꞉MyClass6≻.new(my_class6)
+                        pointer(buffer.data))";
+
+  String result = m.module_eval(code);
+  ASSERT_EQUAL("pointerBuffer", result.str());
+}

data/test/test_Stl_Map.cpp

@@ -220,7 +220,7 @@ TESTCASE(keysAndValues)
   ASSERT_EQUAL(expected_values[2], values->operator[](2));
 }
 
-TESTCASE(Copy)
+TESTCASE(CLone)
 {
   Module m = define_module("Testing");
 
@@ -231,15 +231,15 @@ TESTCASE(Copy)
   object.call("[]=", "two", 22.2);
   std::map<std::string, double>& map = detail::From_Ruby<std::map<std::string, double>&>().convert(object);
 
-  Object result = object.call("copy");
-  std::map<std::string, double>& mapCopy = detail::From_Ruby<std::map<std::string, double>&>().convert(result);
+  Object result = object.call("clone");
+  std::map<std::string, double>& mapClone = detail::From_Ruby<std::map<std::string, double>&>().convert(result);
 
-  ASSERT_EQUAL(map.size(), mapCopy.size());
-  ASSERT_EQUAL(map["one"], mapCopy["one"]);
-  ASSERT_EQUAL(map["two"], mapCopy["two"]);
+  ASSERT_EQUAL(map.size(), mapClone.size());
+  ASSERT_EQUAL(map["one"], mapClone["one"]);
+  ASSERT_EQUAL(map["two"], mapClone["two"]);
 
-  mapCopy["three"] = 33.3;
-  ASSERT_NOT_EQUAL(map.size(), mapCopy.size());
+  mapClone["three"] = 33.3;
+  ASSERT_NOT_EQUAL(map.size(), mapClone.size());
 }
 
 TESTCASE(Iterate)

data/test/test_Stl_Multimap.cpp

@@ -218,7 +218,7 @@ TESTCASE(keysAndValues)
   ASSERT_EQUAL(expected_values[2], values->operator[](2));
 }
 
-TESTCASE(Copy)
+TESTCASE(Clone)
 {
   Module m = define_module("Testing");
 
@@ -229,10 +229,10 @@ TESTCASE(Copy)
   object.call("insert", "two", 22.2);
   std::multimap<std::string, double>& multimap = detail::From_Ruby<std::multimap<std::string, double>&>().convert(object);
 
-  Object result = object.call("copy");
-  std::multimap<std::string, double>& multimapCopy = detail::From_Ruby<std::multimap<std::string, double>&>().convert(result);
+  Object result = object.call("clone");
+  std::multimap<std::string, double>& multimapClone = detail::From_Ruby<std::multimap<std::string, double>&>().convert(result);
 
-  ASSERT_EQUAL(multimap, multimapCopy);
+  ASSERT_EQUAL(multimap, multimapClone);
 }
 
 TESTCASE(Iterate)

data/test/test_Stl_Pair.cpp

@@ -1,4 +1,4 @@
-#include <utility>
+#include <utility>
 
 #include "unittest.hpp"
 #include "embed_ruby.hpp"
@@ -59,17 +59,19 @@ TESTCASE(CreatePairConst)
   result = pair.call("second");
   ASSERT_EQUAL("pair2", detail::From_Ruby<std::string>().convert(result));
 
+#ifdef _MSC_VER
   ASSERT_EXCEPTION_CHECK(
     Exception,
     pair.call("first=", "A second value"),
-    ASSERT_EQUAL("Cannot set pair.first since it is a constant", ex.what())
+    ASSERT_EQUAL("undefined method 'first=' for an instance of Std::ConstStringPair", ex.what())
   );
 
   ASSERT_EXCEPTION_CHECK(
     Exception,
     pair.call("second=", "A second value"),
-    ASSERT_EQUAL("Cannot set pair.second since it is a constant", ex.what())
+    ASSERT_EQUAL("undefined method 'second=' for an instance of Std::ConstStringPair", ex.what())
   );
+#endif
 }
 
 namespace

data/test/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>
@@ -347,13 +347,30 @@ TESTCASE(Update)
   ASSERT_EQUAL(14, detail::From_Ruby<long>().convert(result.value()));
 }
 
+TESTCASE(Klass)
+{
+  detail::TypeMapper<std::shared_ptr<MyClass>> typeMapper;
+  Object expected = Object(rb_cObject).const_get("MyClass");
+  VALUE actual = typeMapper.rubyKlass();
+  ASSERT_EQUAL(expected.value(), actual);
+}
+
+TESTCASE(KlassSharedPtr)
+{
+  define_shared_ptr<MyClass>();
+  detail::TypeMapper<std::shared_ptr<MyClass>> typeMapper;
+
+  Module stdModule("Std");
+  Object expected = stdModule.const_get("SharedPtr≺AnonymousNamespace꞉꞉MyClass≻");
+  VALUE actual = typeMapper.rubyKlass();
+  ASSERT_EQUAL(expected.value(), actual);
+}
+
 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
@@ -397,8 +414,6 @@ namespace
 
 TESTCASE(PointerToInt)
 {
-  detail::Type<Buffer<int>>::verify();
-
   Module m = define_module("SharedPtrInt").
     define_module_function("create_pointer", &createPointer).
     define_module_function("get_pointer_value", &getPointerValue);
@@ -418,7 +433,7 @@ TESTCASE(CreatePointerToInt)
   define_shared_ptr<int>("SharedPtrInt");
 
   std::string code = R"(buffer = Rice::Buffer≺int≻.new(45)
-                        ptr = Std::SharedPtrInt.new(buffer)
+                        ptr = Std::SharedPtrInt.new(buffer.release)
                         get_pointer_value(ptr))";
 
   Object result = m.instance_eval(code);
@@ -433,7 +448,7 @@ TESTCASE(UpdatePointerToInt)
   define_shared_ptr<int>();
 
   std::string code = R"(buffer = Rice::Buffer≺int≻.new(45)
-                        ptr = Std::SharedPtr≺int≻.new(buffer)
+                        ptr = Std::SharedPtr≺int≻.new(buffer.release)
                         update_pointer_value(ptr))";
 
   Object result = m.instance_eval(code);
@@ -442,14 +457,11 @@ TESTCASE(UpdatePointerToInt)
 
 TESTCASE(ReadPointerToInt)
 {
-  detail::Type<Buffer<int>>::verify();
-
   Module m = define_module("ReadPointerToInt").
-      define_module_function("create_pointer", &createPointer);
+             define_module_function("create_pointer", &createPointer);
 
   std::string code = R"(ptr = create_pointer(50)
-                          buffer = Rice::Buffer≺int≻.new(ptr)
-                          buffer.to_ary(1))";
+                        ptr.buffer.to_ary(1))";
 
   Array array = m.instance_eval(code);
   std::vector<int> actual = array.to_vector<int>();

data/test/test_Stl_String_View.cpp

@@ -91,3 +91,13 @@ TESTCASE(std_string_view_from_ruby_refefence)
   string.instance_eval("self[1] = 'a'");
   //ASSERT_EQUAL("tast", view);
 }
+
+namespace {
+  std::string_view testStringViewReturn(Object self) {
+    return "test";
+  }
+}
+
+TESTCASE(use_string_view_in_wrapped_function) {
+  define_global_function("test_string_view_return", &testStringViewReturn);
+}

data/test/test_Stl_Tuple.cpp

@@ -54,7 +54,7 @@ namespace
       ASSERT_EQUAL(3, complex.imag());
        
       std::vector<int> vec = std::get<2>(tuple);
-      ASSERT_EQUAL(3, vec.size());
+      ASSERT_EQUAL((size_t)3, vec.size());
       ASSERT_EQUAL(3, vec[0]);
       ASSERT_EQUAL(4, vec[1]);
       ASSERT_EQUAL(5, vec[2]);

data/test/test_Stl_UniquePtr.cpp

@@ -199,4 +199,12 @@ TESTCASE(Update)
 
   Object result = m.instance_eval(code);
   ASSERT_EQUAL(11, detail::From_Ruby<long>().convert(result.value()));
+}
+
+TESTCASE(Klass)
+{
+  detail::TypeMapper<std::unique_ptr<MyClass>> typeMapper;
+  Object expected = Object(rb_cObject).const_get("MyClass");
+  VALUE actual = typeMapper.rubyKlass();
+  ASSERT_EQUAL(expected.value(), actual);
 }

data/test/test_Stl_Unordered_Map.cpp

@@ -1,4 +1,4 @@
-#include <complex>
+#include <complex>
 #include <memory>
 
 #include "unittest.hpp"
@@ -216,7 +216,7 @@ TESTCASE(KeysAndValues)
   ASSERT_EQUAL(3, values->operator[](2));
 }
 
-TESTCASE(Copy)
+TESTCASE(Clone)
 {
   Module m = define_module("Testing");
 
@@ -227,15 +227,15 @@ TESTCASE(Copy)
   object.call("[]=", "two", 22.2);
   std::unordered_map<std::string, double>& unordered_map = detail::From_Ruby<std::unordered_map<std::string, double>&>().convert(object);
 
-  Object result = object.call("copy");
-  std::unordered_map<std::string, double>& unordered_mapCopy = detail::From_Ruby<std::unordered_map<std::string, double>&>().convert(result);
+  Object result = object.call("clone");
+  std::unordered_map<std::string, double>& unordered_mapClone = detail::From_Ruby<std::unordered_map<std::string, double>&>().convert(result);
 
-  ASSERT_EQUAL(unordered_map.size(), unordered_mapCopy.size());
-  ASSERT_EQUAL(unordered_map["one"], unordered_mapCopy["one"]);
-  ASSERT_EQUAL(unordered_map["two"], unordered_mapCopy["two"]);
+  ASSERT_EQUAL(unordered_map.size(), unordered_mapClone.size());
+  ASSERT_EQUAL(unordered_map["one"], unordered_mapClone["one"]);
+  ASSERT_EQUAL(unordered_map["two"], unordered_mapClone["two"]);
 
-  unordered_mapCopy["three"] = 33.3;
-  ASSERT_NOT_EQUAL(unordered_map.size(), unordered_mapCopy.size());
+  unordered_mapClone["three"] = 33.3;
+  ASSERT_NOT_EQUAL(unordered_map.size(), unordered_mapClone.size());
 }
 
 TESTCASE(Iterate)

data/test/test_Stl_Variant.cpp

@@ -380,6 +380,14 @@ TESTCASE(RoundtripConstRef)
   ASSERT_EQUAL(Qnil, instance2.value());
 }
 
+TESTCASE(Klass)
+{
+  detail::TypeMapper<Variant_T> typeMapper;
+  Object expected = Object(rb_cObject).const_get("Object");
+  VALUE actual = typeMapper.rubyKlass();
+  ASSERT_EQUAL(expected.value(), actual);
+}
+
 namespace
 {
   class MyClass4
@@ -456,8 +464,6 @@ namespace
 
 TESTCASE(Buffer)
 {
-  define_buffer<int>();
-  define_buffer<float>();
   using namespace std::complex_literals;
 
   define_class<MyClass5>("MyClass5").
@@ -476,4 +482,4 @@ TESTCASE(Buffer)
               myclass.buffer(1).to_ary(1).first)";
   result = m.module_eval(code);
   ASSERT_EQUAL(11.0, detail::From_Ruby<float>().convert(result));
-}
+}