rice 4.5.0 → 4.6.0

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>
@@ -319,11 +319,19 @@ TESTCASE(invalid_parameters)
   std::string code = R"(my_class = MyClass.new
                         my_class.run("abc", "def"))";
 
+  std::string expected = R"(Could not resolve method call for MyClass#run
+  6 overload(s) were evaluated based on the types of Ruby parameters provided:
+     std::string AnonymousNamespace::MyClass*::run(int, float)
+     std::string AnonymousNamespace::MyClass*::run(float, int)
+     std::string AnonymousNamespace::MyClass*::run()
+     std::string AnonymousNamespace::MyClass*::run(std::string)
+     std::string AnonymousNamespace::MyClass*::run(int)
+     std::string AnonymousNamespace::MyClass*::run(float))";
+
   ASSERT_EXCEPTION_CHECK(
     Exception,
     Rice::String result = m.module_eval(code),
-    ASSERT_EQUAL("Could not resolve method call for MyClass#run\n  6 overload(s) were evaluated based on the types of Ruby parameters provided.", 
-                 ex.what()));
+    ASSERT_EQUAL(expected.c_str(), ex.what()));
 }
 
 namespace
@@ -542,11 +550,15 @@ TESTCASE(int_conversion_2)
             value = 2**64
             my_class.run(value))";
 
+  std::string expected = R"(Could not resolve method call for MyClass3#run
+  2 overload(s) were evaluated based on the types of Ruby parameters provided:
+     std::string AnonymousNamespace::MyClass3*::run(short)
+     std::string AnonymousNamespace::MyClass3*::run(float))";
+
   ASSERT_EXCEPTION_CHECK(
     Exception,
     result = m.module_eval(code),
-    ASSERT_EQUAL("Could not resolve method call for MyClass3#run\n  2 overload(s) were evaluated based on the types of Ruby parameters provided.",
-    ex.what()));
+    ASSERT_EQUAL(expected.c_str(), ex.what()));
 }
 
 TESTCASE(int_conversion_3)
@@ -627,5 +639,168 @@ TESTCASE(int_conversion_5)
                         value = "54"
                         my_class.run(value))";
   String result = m.module_eval(code);
+  ASSERT_EQUAL("run<unsigned char>", result.str());
+}
+
+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);
+
+  Module m = define_module("Testing");
+
+  std::string code = R"(my_class = MyClass3.new
+                          buffer = Rice::Buffer≺unsigned char≻.new("54")
+                          my_class.run(buffer))";
+  String result = m.module_eval(code);
   ASSERT_EQUAL("run<unsigned char*>", result.str());
 }
+
+namespace
+{
+  class MyClass4
+  {
+  public:
+    static const MyClass4& constRef()
+    {
+      if (!instance_)
+      {
+        instance_ = new MyClass4();
+      }
+      return *instance_;
+    }
+  
+  private:
+    static inline MyClass4* instance_ = nullptr;
+  };
+
+  class MyClass5
+  {
+  public:
+    MyClass5(MyClass4& class4)
+    {
+      this->result = "non-const ref";
+    }
+
+    MyClass5(const MyClass4& class4)
+    {
+      this->result = "const ref";
+    }
+
+  public:
+    std::string result = "";
+  };
+}
+
+TESTCASE(NonConstRef)
+{
+  Class c4 = define_class<MyClass4>("MyClass4").
+    define_constructor(Constructor<MyClass4>());
+
+  Class c5 = define_class<MyClass5>("MyClass5").
+    define_constructor(Constructor<MyClass5, const MyClass4&>()).
+    define_constructor(Constructor<MyClass5, MyClass4&>()).
+    define_attr("result", &MyClass5::result);
+
+  Module m = define_module("Testing");
+
+  std::string code = R"(my_class4 = MyClass4.new
+                          my_class5 = MyClass5.new(my_class4)
+                          my_class5.result)";
+  String result = m.module_eval(code);
+  ASSERT_EQUAL("non-const ref", result.str());
+}
+
+TESTCASE(ConstRef)
+{
+  Class c4 = define_class<MyClass4>("MyClass4").
+    define_singleton_function("const_instance", MyClass4::constRef);
+
+  Class c5 = define_class<MyClass5>("MyClass5").
+    define_constructor(Constructor<MyClass5, const MyClass4&>()).
+    define_constructor(Constructor<MyClass5, MyClass4&>()).
+    define_attr("result", &MyClass5::result);
+
+  Module m = define_module("Testing");
+
+  std::string code = R"(my_class4 = MyClass4.const_instance
+                          my_class5 = MyClass5.new(my_class4)
+                          my_class5.result)";
+  String result = m.module_eval(code);
+  ASSERT_EQUAL("const ref", result.str());
+}
+
+namespace
+{
+  class MyClass6
+  {
+  public:
+    static const MyClass6* constPointer()
+    {
+      if (!instance_)
+      {
+        instance_ = new MyClass6();
+      }
+      return instance_;
+    }
+
+  private:
+    static inline MyClass6* instance_ = nullptr;
+  };
+
+  class MyClass7
+  {
+  public:
+    MyClass7(MyClass6* class6)
+    {
+      this->result = "non-const pointer";
+    }
+
+    MyClass7(const MyClass6* class6)
+    {
+      this->result = "const pointer";
+    }
+  public:
+    std::string result = "";
+  };
+}
+
+TESTCASE(NonConstPointer)
+{
+  Class c6 = define_class<MyClass6>("MyClass6").
+    define_constructor(Constructor<MyClass6>());
+
+  Class c7 = define_class<MyClass7>("MyClass7").
+    define_constructor(Constructor<MyClass7, const MyClass6*>()).
+    define_constructor(Constructor<MyClass7, MyClass6*>()).
+    define_attr("result", &MyClass7::result);
+
+  Module m = define_module("Testing");
+
+  std::string code = R"(my_class6 = MyClass6.new
+                          my_class7 = MyClass7.new(my_class6)
+                          my_class7.result)";
+  String result = m.module_eval(code);
+  ASSERT_EQUAL("non-const pointer", result.str());
+}
+
+TESTCASE(ConstPointer)
+{
+  Class c6 = define_class<MyClass6>("MyClass6").
+    define_singleton_function("const_instance", MyClass6::constPointer);
+
+  Class c7 = define_class<MyClass7>("MyClass7").
+    define_constructor(Constructor<MyClass7, const MyClass6*>()).
+    define_constructor(Constructor<MyClass7, MyClass6*>()).
+    define_attr("result", &MyClass7::result);
+
+  Module m = define_module("Testing");
+
+  std::string code = R"(my_class6 = MyClass6.const_instance
+                          my_class7 = MyClass7.new(my_class6)
+                          my_class7.result)";
+  String result = m.module_eval(code);
+  ASSERT_EQUAL("const pointer", result.str());
+}

data/test/test_Ownership.cpp

@@ -10,12 +10,11 @@ TESTSUITE(Ownership);
 
 namespace
 {
-  class MyClass
+  class MyCopyableClass
   {
   public:
     static inline int constructorCalls = 0;
     static inline int copyConstructorCalls = 0;
-    static inline int moveConstructorCalls = 0;
     static inline int destructorCalls = 0;
     static inline int methodCalls = 0;
 
@@ -23,7 +22,6 @@ namespace
     {
       constructorCalls = 0;
       copyConstructorCalls = 0;
-      moveConstructorCalls = 0;
       destructorCalls = 0;
       methodCalls = 0;
     }
@@ -32,22 +30,68 @@ namespace
     int flag = 0;
 
   public:
-    MyClass()
+    MyCopyableClass()
     {
       constructorCalls++;
     }
 
-    ~MyClass()
+    ~MyCopyableClass()
     {
       destructorCalls++;
     }
 
-    MyClass(const MyClass& other): flag(other.flag)
+    MyCopyableClass(const MyCopyableClass& other): flag(other.flag)
     {
       copyConstructorCalls++;
     }
 
-    MyClass(MyClass&& other) : flag(other.flag)
+    MyCopyableClass(MyCopyableClass&& other) = delete;
+
+    int32_t process()
+    {
+      methodCalls++;
+      return methodCalls;
+    }
+
+    void setFlag(int value)
+    {
+      this->flag = value;
+    }
+  };
+
+  class MyMovableClass
+  {
+  public:
+    static inline int constructorCalls = 0;
+    static inline int moveConstructorCalls = 0;
+    static inline int destructorCalls = 0;
+    static inline int methodCalls = 0;
+
+    static void reset()
+    {
+      constructorCalls = 0;
+      moveConstructorCalls = 0;
+      destructorCalls = 0;
+      methodCalls = 0;
+    }
+
+  public:
+    int flag = 0;
+
+  public:
+    MyMovableClass()
+    {
+      constructorCalls++;
+    }
+
+    ~MyMovableClass()
+    {
+      destructorCalls++;
+    }
+
+    MyMovableClass(const MyMovableClass& other) = delete;
+
+    MyMovableClass(MyMovableClass&& other) : flag(other.flag)
     {
       moveConstructorCalls++;
     }
@@ -74,47 +118,47 @@ namespace
     }
 
   public:
-    MyClass* transferPointerToRuby()
+    MyCopyableClass* transferPointerToRuby()
     {
-      return new MyClass();
+      return new MyCopyableClass();
     }
 
-    MyClass* keepPointer()
+    MyCopyableClass* keepPointer()
     {
       return this->instance();
     }
 
-    MyClass& keepReference()
+    MyCopyableClass& keepReference()
     {
       return *this->instance();
     }
 
-    MyClass value()
+    MyCopyableClass value()
     {
-      return MyClass();
+      return MyCopyableClass();
     }
 
-    MyClass moveValue()
+    MyMovableClass moveValue()
     {
-      return std::move(MyClass());
+      return MyMovableClass();
     }
 
-    void transferPointerToCpp(MyClass* myClass)
+    void transferPointerToCpp(MyCopyableClass* myClass)
     {
       delete myClass;
     }
 
-    MyClass* instance()
+    MyCopyableClass* instance()
     {
       if (!instance_)
       {
-        instance_ = new MyClass();
+        instance_ = new MyCopyableClass();
       }
       return instance_;
     }
 
   public:
-    static inline MyClass* instance_ = nullptr;
+    static inline MyCopyableClass* instance_ = nullptr;
   };
 }
 
@@ -122,10 +166,15 @@ SETUP(Ownership)
 {
   embed_ruby();
 
-  define_class<MyClass>("MyClass").
-    define_constructor(Constructor<MyClass>()).
-    define_method("process", &MyClass::process).
-    define_method("set_flag", &MyClass::setFlag);
+  define_class<MyCopyableClass>("MyCopyableClass").
+    define_constructor(Constructor<MyCopyableClass>()).
+    define_method("process", &MyCopyableClass::process).
+    define_method("set_flag", &MyCopyableClass::setFlag);
+
+  define_class<MyMovableClass>("MyMovableClass").
+    define_constructor(Constructor<MyMovableClass>()).
+    define_method("process", &MyMovableClass::process).
+    define_method("set_flag", &MyMovableClass::setFlag);
 
   define_class<Factory>("Factory").
     define_constructor(Constructor<Factory>()).
@@ -146,7 +195,7 @@ TEARDOWN(Ownership)
 TESTCASE(TransferPointerToRuby)
 {
   Factory::reset();
-  MyClass::reset();
+  MyCopyableClass::reset();
 
   Module m = define_module("TestingModule");
 
@@ -160,21 +209,20 @@ TESTCASE(TransferPointerToRuby)
   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_EQUAL(10, MyCopyableClass::constructorCalls);
+  ASSERT_EQUAL(0, MyCopyableClass::copyConstructorCalls);
+  ASSERT_EQUAL(10, MyCopyableClass::destructorCalls);
   ASSERT(!Factory::instance_);
 }
 
 TESTCASE(TransferPointerToCpp)
 {
   Factory::reset();
-  MyClass::reset();
+  MyCopyableClass::reset();
 
   Module m = define_module("TestingModule");
 
-  std::string code = R"(myClass = MyClass.new
+  std::string code = R"(myClass = MyCopyableClass.new
                         factory = Factory.new
                         factory.transfer_pointer_to_cpp(myClass))";
 
@@ -187,7 +235,7 @@ TESTCASE(TransferPointerToCpp)
 TESTCASE(KeepPointer)
 {
   Factory::reset();
-  MyClass::reset();
+  MyCopyableClass::reset();
 
   Module m = define_module("TestingModule");
 
@@ -201,17 +249,16 @@ TESTCASE(KeepPointer)
   m.module_eval(code);
   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, MyCopyableClass::constructorCalls);
+  ASSERT_EQUAL(0, MyCopyableClass::copyConstructorCalls);
+  ASSERT_EQUAL(0, MyCopyableClass::destructorCalls);
   ASSERT_EQUAL(9, Factory::instance_->flag);
 }
 
 TESTCASE(KeepReference)
 {
   Factory::reset();
-  MyClass::reset();
+  MyCopyableClass::reset();
 
   Module m = define_module("TestingModule");
 
@@ -225,17 +272,16 @@ TESTCASE(KeepReference)
   m.module_eval(code);
   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, MyCopyableClass::constructorCalls);
+  ASSERT_EQUAL(0, MyCopyableClass::copyConstructorCalls);
+  ASSERT_EQUAL(0, MyCopyableClass::destructorCalls);
   ASSERT_EQUAL(9, Factory::instance_->flag);
 }
 
 TESTCASE(CopyReference)
 {
   Factory::reset();
-  MyClass::reset();
+  MyCopyableClass::reset();
 
   Module m = define_module("TestingModule");
 
@@ -249,17 +295,16 @@ TESTCASE(CopyReference)
   m.module_eval(code);
   rb_gc_start();
 
-  ASSERT_EQUAL(1, MyClass::constructorCalls);
-  ASSERT_EQUAL(0, MyClass::copyConstructorCalls);
-  ASSERT_EQUAL(10, MyClass::moveConstructorCalls);
-  ASSERT_EQUAL(10, MyClass::destructorCalls);
+  ASSERT_EQUAL(1, MyCopyableClass::constructorCalls);
+  ASSERT_EQUAL(10, MyCopyableClass::copyConstructorCalls);
+  ASSERT_EQUAL(10, MyCopyableClass::destructorCalls);
   ASSERT_EQUAL(0, Factory::instance_->flag);
 }
 
 TESTCASE(TransferValue)
 {
   Factory::reset();
-  MyClass::reset();
+  MyCopyableClass::reset();
 
   Module m = define_module("TestingModule");
 
@@ -272,17 +317,16 @@ TESTCASE(TransferValue)
   m.module_eval(code);
   rb_gc_start();
 
-  ASSERT_EQUAL(10, MyClass::constructorCalls);
-  ASSERT_EQUAL(0, MyClass::copyConstructorCalls);
-  ASSERT_EQUAL(10, MyClass::moveConstructorCalls);
-  ASSERT_EQUAL(20, MyClass::destructorCalls);
+  ASSERT_EQUAL(10, MyCopyableClass::constructorCalls);
+  ASSERT_EQUAL(10, MyCopyableClass::copyConstructorCalls);
+  ASSERT_EQUAL(20, MyCopyableClass::destructorCalls);
   ASSERT(!Factory::instance_);
 }
 
 TESTCASE(MoveValue)
 {
   Factory::reset();
-  MyClass::reset();
+  MyCopyableClass::reset();
 
   Module m = define_module("TestingModule");
 
@@ -295,10 +339,9 @@ TESTCASE(MoveValue)
   m.module_eval(code);
   rb_gc_start();
 
-  ASSERT_EQUAL(10, MyClass::constructorCalls);
-  ASSERT_EQUAL(0, MyClass::copyConstructorCalls);
-  ASSERT_EQUAL(20, MyClass::moveConstructorCalls);
-  ASSERT_EQUAL(30, MyClass::destructorCalls);
+  ASSERT_EQUAL(10, MyMovableClass::constructorCalls);
+  ASSERT_EQUAL(10, MyMovableClass::moveConstructorCalls);
+  ASSERT_EQUAL(20, MyMovableClass::destructorCalls);
   ASSERT(!Factory::instance_);
 }
 
@@ -323,9 +366,9 @@ TESTCASE(NotCopyable)
   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";
+  const char* expected = "Rice 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";
+  const char* expected = "Rice 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

data/test/test_Proc.cpp

@@ -3,7 +3,6 @@
 #include "unittest.hpp"
 #include "embed_ruby.hpp"
 #include <rice/rice.hpp>
-#include <rice/stl.hpp>
 
 using namespace Rice;
 

data/test/test_Self.cpp

@@ -146,8 +146,8 @@ TESTCASE(SelfValue)
   ASSERT((pointer1 != pointer2));
 
   ASSERT_EQUAL(1, SelfClass::constructorCalls);
-  ASSERT_EQUAL(1, SelfClass::copyConstructorCalls);
-  ASSERT_EQUAL(1, SelfClass::moveConstructorCalls);
+  ASSERT_EQUAL(2, SelfClass::copyConstructorCalls);
+  ASSERT_EQUAL(0, SelfClass::moveConstructorCalls);
   ASSERT_EQUAL(1, SelfClass::destructorCalls);
 }
 
@@ -203,7 +203,7 @@ TESTCASE(SelfValueLambda)
   ASSERT((pointer1 != pointer2));
 
   ASSERT_EQUAL(1, SelfClass::constructorCalls);
-  ASSERT_EQUAL(1, SelfClass::copyConstructorCalls);
-  ASSERT_EQUAL(1, SelfClass::moveConstructorCalls);
+  ASSERT_EQUAL(2, SelfClass::copyConstructorCalls);
+  ASSERT_EQUAL(0, SelfClass::moveConstructorCalls);
   ASSERT_EQUAL(1, SelfClass::destructorCalls);
 }