rice 3.0.0 → 4.0.3

data/test/test_Object.cpp

@@ -1,9 +1,6 @@
 #include "unittest.hpp"
 #include "embed_ruby.hpp"
-#include "rice/Object.hpp"
-#include "rice/Class.hpp"
-#include "rice/String.hpp"
-#include "rice/Array.hpp"
+#include <rice/rice.hpp>
 
 using namespace Rice;
 
@@ -28,9 +25,34 @@ TESTCASE(construct_with_value)
 
 TESTCASE(copy_construct)
 {
-  Object o(INT2NUM(42));
-  Object o2(o);
-  ASSERT_EQUAL(INT2NUM(42), o2.value());
+  Object o1(INT2NUM(42));
+  Object o2(o1);
+  ASSERT_EQUAL(o2.value(), o1.value());
+}
+
+TESTCASE(copy_assign)
+{
+  Object o1(INT2NUM(42));
+  Object o2(INT2NUM(43));
+  o2 = o1;
+  ASSERT_EQUAL(o2.value(), o1.value());
+}
+
+TESTCASE(move_construct)
+{
+  Object o1(INT2NUM(42));
+  Object o2(std::move(o1));
+  ASSERT_EQUAL(o2.value(), INT2NUM(42));
+  ASSERT_EQUAL(o1.value(), Qnil);
+}
+
+TESTCASE(move_assign)
+{
+  Object o1(INT2NUM(42));
+  Object o2(INT2NUM(43));
+  o2 = std::move(o1);
+  ASSERT_EQUAL(o2.value(), INT2NUM(42));
+  ASSERT_EQUAL(o1.value(), Qnil);
 }
 
 TESTCASE(test)
@@ -64,7 +86,7 @@ TESTCASE(is_nil)
 
 TESTCASE(implicit_conversion_to_value)
 {
-  // g++ 3.3.3 can't handle constructor-style inside the assert, which
+  // Compilers (g++, msvc) can't handle constructor-style inside the assert, which
   // is why we use cast-style here.
   ASSERT_EQUAL(Qtrue, (VALUE)Object(Qtrue));
   ASSERT_EQUAL(INT2NUM(42), (VALUE)Object(INT2NUM(42)));
@@ -122,20 +144,11 @@ TESTCASE(is_frozen)
   ASSERT(o.is_frozen());
 }
 
-TESTCASE(swap)
-{
-  Object o1(INT2NUM(42));
-  Object o2(rb_ary_new());
-  o1.swap(o2);
-  ASSERT_EQUAL(to_ruby(42), o2);
-  ASSERT_EQUAL(Class(rb_cArray), o1.class_of());
-}
-
 TESTCASE(instance_eval)
 {
   Object o(Class(rb_cObject).call("new"));
   o.iv_set("@foo", 42);
-  ASSERT_EQUAL(to_ruby(42), o.instance_eval("@foo"));
+  ASSERT_EQUAL(detail::to_ruby(42), o.instance_eval("@foo").value());
 }
 
 TESTCASE(rb_type)
@@ -149,12 +162,19 @@ TESTCASE(rb_type)
 
 TESTCASE(call_no_arguments)
 {
-  Object three = to_ruby(3).call("to_s");
+  Object three = Object(detail::to_ruby(3)).call("to_s");
   ASSERT_EQUAL(String("3"), three);
 }
 
 TESTCASE(call_return_rice_object)
 {
-  Object three = to_ruby(1).call("+", 2);
-  ASSERT_EQUAL(to_ruby(3), three);
+  Object three = Object(detail::to_ruby(1)).call("+", 2);
+  ASSERT_EQUAL(Object(detail::to_ruby(3)), three);
 }
+
+/*TESTCASE(test_mark)
+{
+  Object o(INT2NUM(42));
+  rb_gc_start();
+  ASSERT_EQUAL(42, detail::From_Ruby<int>::convert(o.value()));
+}*/

data/test/test_Ownership.cpp

@@ -0,0 +1,275 @@
+#include "unittest.hpp"
+#include "embed_ruby.hpp"
+#include <rice/rice.hpp>
+
+#include <memory>
+
+using namespace Rice;
+
+TESTSUITE(Ownership);
+
+namespace
+{
+  class MyClass
+  {
+  public:
+    static inline uint32_t constructorCalls = 0;
+    static inline uint32_t copyConstructorCalls = 0;
+    static inline uint32_t moveConstructorCalls = 0;
+    static inline uint32_t destructorCalls = 0;
+    static inline uint32_t methodCalls = 0;
+
+    static void reset()
+    {
+      constructorCalls = 0;
+      copyConstructorCalls = 0;
+      moveConstructorCalls = 0;
+      destructorCalls = 0;
+      methodCalls = 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++;
+    }
+
+    int32_t process()
+    {
+      methodCalls++;
+      return methodCalls;
+    }
+
+    void setFlag(int value)
+    {
+      this->flag = value;
+    }
+  };
+
+  class Factory
+  {
+  public:
+    static void reset()
+    {
+      delete Factory::instance_;
+      Factory::instance_ = nullptr;
+    }
+
+  public:
+    MyClass* transferPointer()
+    {
+      return new MyClass();
+    }
+
+    MyClass* keepPointer()
+    {
+      return this->instance();
+    }
+
+    MyClass& keepReference()
+    {
+      return *this->instance();
+    }
+
+    MyClass value()
+    {
+      return MyClass();
+    }
+
+    MyClass moveValue()
+    {
+      return std::move(MyClass());
+    }
+
+    MyClass* instance()
+    {
+      if (!instance_)
+      {
+        instance_ = new MyClass();
+      }
+      return instance_;
+    }
+
+  public:
+    static inline MyClass* instance_ = nullptr;
+  };
+}
+
+SETUP(Ownership)
+{
+  embed_ruby();
+
+  define_class<MyClass>("MyClass").
+    define_method("process", &MyClass::process).
+    define_method("set_flag", &MyClass::setFlag);
+
+  define_class<Factory>("Factory").
+    define_constructor(Constructor<Factory>()).
+    define_method("value", &Factory::value).
+    define_method("move_value", &Factory::moveValue).
+    define_method("transfer_pointer", &Factory::transferPointer, Return().takeOwnership()).
+    define_method("keep_pointer", &Factory::keepPointer).
+    define_method("copy_reference", &Factory::keepReference, Return().takeOwnership()).
+    define_method("keep_reference", &Factory::keepReference);
+}
+
+TESTCASE(TransferPointer)
+{
+  Factory::reset();
+  MyClass::reset();
+
+  Module m = define_module("TestingModule");
+
+  std::string code = R"(factory = Factory.new
+                        10.times do |i|
+                          my_class = factory.transfer_pointer
+                          my_class.set_flag(i)
+                          my_class = nil
+                        end)";
+
+  m.instance_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(KeepPointer)
+{
+  Factory::reset();
+  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
+                        10.times do |i|
+                          my_class = factory.keep_pointer
+                          my_class.set_flag(i)
+                        end)";
+
+  m.instance_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(9, Factory::instance_->flag);
+}
+
+TESTCASE(KeepReference)
+{
+  Factory::reset();
+  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
+                        10.times do |i|
+                          my_class = factory.keep_reference
+                          my_class.set_flag(i)
+                        end)";
+
+  m.instance_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(9, Factory::instance_->flag);
+}
+
+TESTCASE(CopyReference)
+{
+  Factory::reset();
+  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
+                        10.times do |i|
+                          my_class = factory.copy_reference
+                          my_class.set_flag(i)
+                        end)";
+
+  m.instance_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(0, Factory::instance_->flag);
+}
+
+/*TESTCASE(TransferValue)
+{
+  Factory::reset();
+  MyClass::reset();
+
+  Module m = define_module("TestingModule");
+
+  std::string code = R"(factory = Factory.new
+                        10.times do |i|
+                          my_class = factory.value
+                          my_class.set_flag(i)
+                        end)";
+
+  m.instance_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(!Factory::instance_);
+}
+
+TESTCASE(MoveValue)
+{
+  Factory::reset();
+  MyClass::reset();
+
+  Module m = define_module("TestingModule");
+
+  std::string code = R"(factory = Factory.new
+                        10.times do |i|
+                          my_class = factory.move_value
+                          my_class.set_flag(i)
+                        end)";
+
+  m.instance_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(!Factory::instance_);
+}
+*/

data/test/test_Self.cpp

@@ -0,0 +1,205 @@
+#include "unittest.hpp"
+#include "embed_ruby.hpp"
+#include <rice/rice.hpp>
+
+#include <memory>
+
+using namespace Rice;
+
+TESTSUITE(Self);
+
+namespace
+{
+  class SelfClass
+  {
+  public:
+    static inline uint32_t constructorCalls = 0;
+    static inline uint32_t copyConstructorCalls = 0;
+    static inline uint32_t moveConstructorCalls = 0;
+    static inline uint32_t destructorCalls = 0;
+    static inline uint32_t methodCalls = 0;
+
+    static void reset()
+    {
+      constructorCalls = 0;
+      copyConstructorCalls = 0;
+      moveConstructorCalls = 0;
+      destructorCalls = 0;
+      methodCalls = 0;
+    }
+
+  public:
+    SelfClass()
+    {
+      constructorCalls++;
+    }
+
+    ~SelfClass()
+    {
+      destructorCalls++;
+    }
+
+    SelfClass(const SelfClass& other)
+    {
+      copyConstructorCalls++;
+    }
+
+    SelfClass(SelfClass&& other)
+    {
+      moveConstructorCalls++;
+    }
+
+    SelfClass* selfPointer()
+    {
+      return this;
+    }
+
+    SelfClass& selfReference()
+    {
+      return *this;
+    }
+
+    SelfClass selfValue()
+    {
+      return *this;
+    }
+  };
+}
+
+SETUP(Self)
+{
+  embed_ruby();
+
+  define_class<SelfClass>("SelfClass").
+    define_constructor(Constructor<SelfClass>()).
+    define_method("self_reference", &SelfClass::selfReference).
+    define_method("self_pointer", &SelfClass::selfPointer).
+    define_method("self_value", &SelfClass::selfValue).
+    define_method("self_reference_lambda", [](SelfClass& self) -> SelfClass&
+      {
+        return self;
+      }).
+    define_method("self_pointer_lambda", [](SelfClass& self)
+      {
+        return &self;
+      }).
+    define_method("self_value_lambda", [](SelfClass& self)
+      {
+        return self;
+      });
+}
+
+TESTCASE(SelfPointer)
+{
+  SelfClass::reset();
+
+  Module m = define_module("TestingModule");
+  Object selfClass1 = m.instance_eval("SelfClass.new");
+  Object selfClass2 = selfClass1.call("self_pointer");
+  ASSERT(selfClass2.is_equal(selfClass1));
+
+  SelfClass* pointer1 = detail::From_Ruby<SelfClass*>().convert(selfClass1);
+  SelfClass* pointer2 = detail::From_Ruby<SelfClass*>().convert(selfClass2);
+  ASSERT((pointer1 == pointer2));
+
+  ASSERT_EQUAL(1, SelfClass::constructorCalls);
+  ASSERT_EQUAL(0, SelfClass::copyConstructorCalls);
+  ASSERT_EQUAL(0, SelfClass::moveConstructorCalls);
+  ASSERT_EQUAL(0, SelfClass::destructorCalls);
+}
+
+TESTCASE(SelfReference)
+{
+  SelfClass::reset();
+
+  Module m = define_module("TestingModule");
+  Object selfClass1 = m.instance_eval("SelfClass.new");
+  Object selfClass2 = selfClass1.call("self_reference");
+  ASSERT(selfClass2.is_equal(selfClass1));
+
+  SelfClass* pointer1 = detail::From_Ruby<SelfClass*>().convert(selfClass1);
+  SelfClass* pointer2 = detail::From_Ruby<SelfClass*>().convert(selfClass2);
+  ASSERT((pointer1 == pointer2));
+
+  ASSERT_EQUAL(1, SelfClass::constructorCalls);
+  ASSERT_EQUAL(0, SelfClass::copyConstructorCalls);
+  ASSERT_EQUAL(0, SelfClass::moveConstructorCalls);
+  ASSERT_EQUAL(0, SelfClass::destructorCalls);
+}
+
+TESTCASE(SelfValue)
+{
+  SelfClass::reset();
+
+  Module m = define_module("TestingModule");
+  Object selfClass1 = m.instance_eval("SelfClass.new");
+  Object selfClass2 = selfClass1.call("self_value");
+  ASSERT(!selfClass2.is_equal(selfClass1));
+
+  SelfClass* pointer1 = detail::From_Ruby<SelfClass*>().convert(selfClass1);
+  SelfClass* pointer2 = detail::From_Ruby<SelfClass*>().convert(selfClass2);
+  ASSERT((pointer1 != pointer2));
+
+  ASSERT_EQUAL(1, SelfClass::constructorCalls);
+  ASSERT_EQUAL(1, SelfClass::copyConstructorCalls);
+  ASSERT_EQUAL(1, SelfClass::moveConstructorCalls);
+  ASSERT_EQUAL(1, SelfClass::destructorCalls);
+}
+
+TESTCASE(SelfPointerLambda)
+{
+  SelfClass::reset();
+
+  Module m = define_module("TestingModule");
+  Object selfClass1 = m.instance_eval("SelfClass.new");
+  Object selfClass2 = selfClass1.call("self_pointer_lambda");
+  ASSERT(selfClass2.is_equal(selfClass1));
+
+  SelfClass* pointer1 = detail::From_Ruby<SelfClass*>().convert(selfClass1);
+  SelfClass* pointer2 = detail::From_Ruby<SelfClass*>().convert(selfClass2);
+  ASSERT((pointer1 == pointer2));
+
+  ASSERT_EQUAL(1, SelfClass::constructorCalls);
+  ASSERT_EQUAL(0, SelfClass::copyConstructorCalls);
+  ASSERT_EQUAL(0, SelfClass::moveConstructorCalls);
+  // TODO: re-enable this. It fails regularly on Ubuntu + Ruby 2.7, and nothing else.
+  // ASSERT_EQUAL(0, SelfClass::destructorCalls);
+}
+
+TESTCASE(SelfReferenceLambda)
+{
+  SelfClass::reset();
+
+  Module m = define_module("TestingModule");
+  Object selfClass1 = m.instance_eval("SelfClass.new");
+  Object selfClass2 = selfClass1.call("self_reference_lambda");
+  ASSERT(selfClass2.is_equal(selfClass1));
+
+  SelfClass* pointer1 = detail::From_Ruby<SelfClass*>().convert(selfClass1);
+  SelfClass* pointer2 = detail::From_Ruby<SelfClass*>().convert(selfClass2);
+  ASSERT((pointer1 == pointer2));
+
+  ASSERT_EQUAL(1, SelfClass::constructorCalls);
+  ASSERT_EQUAL(0, SelfClass::copyConstructorCalls);
+  ASSERT_EQUAL(0, SelfClass::moveConstructorCalls);
+  ASSERT_EQUAL(0, SelfClass::destructorCalls);
+}
+
+TESTCASE(SelfValueLambda)
+{
+  SelfClass::reset();
+
+  Module m = define_module("TestingModule");
+  Object selfClass1 = m.instance_eval("SelfClass.new");
+  Object selfClass2 = selfClass1.call("self_value_lambda");
+  ASSERT(!selfClass2.is_equal(selfClass1));
+
+  SelfClass* pointer1 = detail::From_Ruby<SelfClass*>().convert(selfClass1);
+  SelfClass* pointer2 = detail::From_Ruby<SelfClass*>().convert(selfClass2);
+  ASSERT((pointer1 != pointer2));
+
+  ASSERT_EQUAL(1, SelfClass::constructorCalls);
+  ASSERT_EQUAL(1, SelfClass::copyConstructorCalls);
+  ASSERT_EQUAL(1, SelfClass::moveConstructorCalls);
+  ASSERT_EQUAL(1, SelfClass::destructorCalls);
+}

data/test/test_Stl_Optional.cpp

@@ -0,0 +1,90 @@
+#include "unittest.hpp"
+#include "embed_ruby.hpp"
+#include <rice/rice.hpp>
+#include <rice/stl.hpp>
+
+#include <optional>
+
+using namespace Rice;
+
+TESTSUITE(Optional);
+
+namespace
+{
+  class MyClass
+  {
+  public:
+    std::optional<std::string> optionalReturn(bool flag)
+    {
+      if (flag)
+      {
+        return std::string("Here is a value");
+      }
+      else
+      {
+        return std::nullopt;
+      }
+    }
+
+    int optionalArgument(std::optional<int32_t> data)
+    {
+      return data ? data.value() : 7;
+    }
+
+    std::optional<double> optional_ = std::nullopt;
+  };
+}
+
+Class makeOptionalClass()
+{
+  return define_class<MyClass>("MyClass").
+    define_constructor(Constructor<MyClass>()).
+    define_method("optional_return", &MyClass::optionalReturn).
+    define_method("optional_argument", &MyClass::optionalArgument).
+    define_attr("optional_attr", &MyClass::optional_);
+}
+
+SETUP(Optional)
+{
+  embed_ruby();
+  makeOptionalClass();
+}
+
+TESTCASE(OptionalReturn)
+{
+  Module m = define_module("Testing");
+  Object myClass = m.instance_eval("MyClass.new");
+
+  Object result = myClass.call("optional_return", true);
+  ASSERT_EQUAL("Here is a value", detail::From_Ruby<std::string>().convert(result));
+
+  result = myClass.call("optional_return", false);
+  ASSERT_EQUAL(Qnil, result.value());
+}
+
+TESTCASE(OptionalArgument)
+{
+  Module m = define_module("Testing");
+  Object myClass = m.instance_eval("MyClass.new");
+
+  Object result = myClass.call("optional_argument", 77);
+  ASSERT_EQUAL(77, detail::From_Ruby<int32_t>().convert(result));
+
+  result = myClass.call("optional_argument", std::nullopt);
+  ASSERT_EQUAL(7, detail::From_Ruby<int32_t>().convert(result));
+}
+
+TESTCASE(OptionalAttribute)
+{
+  Module m = define_module("Testing");
+  Object myClass = m.instance_eval("MyClass.new");
+
+  Object result = myClass.call("optional_attr");
+  ASSERT_EQUAL(Qnil, result.value());
+
+  result = myClass.call("optional_attr=", 77.7);
+  ASSERT_EQUAL(77.7, detail::From_Ruby<double>().convert(result));
+
+  result = myClass.call("optional_attr=", std::nullopt);
+  ASSERT_EQUAL(Qnil, result.value());
+}