rice 3.0.0 → 4.0.0

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());
+}

data/test/test_Stl_Pair.cpp

@@ -0,0 +1,144 @@
+#include <utility>
+
+#include "unittest.hpp"
+#include "embed_ruby.hpp"
+#include <rice/rice.hpp>
+#include <rice/stl.hpp>
+
+using namespace Rice;
+
+TESTSUITE(Pair);
+
+SETUP(Pair)
+{
+  embed_ruby();
+}
+
+TESTCASE(CreatePair)
+{
+  Module m = define_module("Testing");
+
+  Class c = define_pair<std::pair<int32_t, std::optional<std::string>>>("IntStringPair");
+
+  Object pair = c.call("new", 0, nullptr);
+
+  Object result = pair.call("first");
+  ASSERT_EQUAL(0, detail::From_Ruby<int32_t>().convert(result));
+
+  result = pair.call("second");
+  ASSERT_EQUAL(Qnil, result.value());
+
+  result = pair.call("first=", 77);
+  ASSERT_EQUAL(77, detail::From_Ruby<int32_t>().convert(result));
+
+  result = pair.call("first");
+  ASSERT_EQUAL(77, detail::From_Ruby<int32_t>().convert(result));
+
+  result = pair.call("second=", "A second value");
+  ASSERT_EQUAL("A second value", detail::From_Ruby<std::string>().convert(result));
+
+  result = pair.call("second");
+  ASSERT_EQUAL("A second value", detail::From_Ruby<std::string>().convert(result));
+}
+
+namespace
+{
+  class SomeClass
+  {
+  public:
+    std::pair<std::string, double> pair()
+    {
+      return pair_;
+    }
+
+    std::pair<std::string, double> setPair(std::pair<std::string, double> value)
+    {
+      pair_ = value;
+      return pair_;
+    }
+
+    std::pair<std::string, double> pair_{ "first value", 2.0 };
+  };
+}
+
+// This test passes everywhere except for Ruby 2.7 on Windows
+// and I don't know why. Throws a "bad any_cast" from MethodData::data
+#ifndef _WIN32
+TESTCASE(AutoRegister)
+{
+  Module m = define_module("Testing");
+
+  Class c = define_class<SomeClass>("SomeClass").
+    define_constructor(Constructor<SomeClass>()).
+    define_method("pair", &SomeClass::pair).
+    define_method("pair=", &SomeClass::setPair);
+
+  Object someClass = c.call("new");
+
+  Object pair = someClass.call("pair");
+  String name = pair.class_name();
+  ASSERT_EQUAL("Rice::Std::Pair__basic_string__char_char_traits__char___allocator__char_____double__", detail::From_Ruby<std::string>().convert(name));
+
+  Class pairKlass1 = pair.class_of();
+  Class pairKlass2 = Data_Type<std::pair<std::string, double>>::klass();
+  ASSERT_EQUAL(pairKlass1, pairKlass2);
+
+  Object result = pair.call("first");
+  ASSERT_EQUAL("first value", detail::From_Ruby<std::string>().convert(result));
+
+  result = pair.call("second");
+  ASSERT_EQUAL(2.0, detail::From_Ruby<float>().convert(result));
+
+  Object newPair = pairKlass1.call("new", "New value", 3.2);
+
+  pair = someClass.call("pair=", newPair);
+
+  result = newPair.call("first");
+  ASSERT_EQUAL("New value", detail::From_Ruby<std::string>().convert(result));
+
+  result = newPair.call("second");
+  ASSERT_EQUAL(3.2, detail::From_Ruby<double>().convert(result));
+}
+#endif
+
+namespace
+{
+  struct SomeStruct
+  {
+    int32_t value = 5;
+  };
+}
+
+TESTCASE(ReferenceReturned)
+{
+  Class structKlass = define_class<SomeStruct>("SomeStruct").
+    define_constructor(Constructor<SomeStruct>()).
+    define_attr("value", &SomeStruct::value);
+
+  define_pair<std::pair<char, SomeStruct>>("CharSomeStructPair");
+
+  std::pair<char, SomeStruct> aPair;
+  aPair.first = 'a';
+
+  Data_Object<std::pair<char, SomeStruct>> rubyPair(&aPair);
+
+  Object result = rubyPair.call("first");
+  ASSERT_EQUAL('a', detail::From_Ruby<char>().convert(result));
+
+  result = rubyPair.call("first=", 'b');
+  ASSERT_EQUAL('b', aPair.first);
+
+  result = rubyPair.call("first");
+  ASSERT_EQUAL('b', detail::From_Ruby<char>().convert(result));
+
+  Object rubyStruct = rubyPair.call("second");
+  result = rubyStruct.call("value");
+  ASSERT_EQUAL(5, detail::From_Ruby<int32_t>().convert(result));
+
+  rubyStruct.call("value=", 8);
+  ASSERT_EQUAL(8, aPair.second.value);
+
+  rubyStruct = rubyPair.call("second");
+  result = rubyStruct.call("value");
+  ASSERT_EQUAL(8, detail::From_Ruby<int32_t>().convert(result));
+}

data/test/test_Stl_SmartPointer.cpp

@@ -0,0 +1,200 @@
+#include "unittest.hpp"
+#include "embed_ruby.hpp"
+#include <rice/rice.hpp>
+#include <rice/stl.hpp>
+
+#include <memory>
+
+using namespace Rice;
+
+TESTSUITE(SmartPointer);
+
+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>();
+    }
+
+    std::shared_ptr<MyClass> share()
+    {
+      if (!instance_)
+      {
+        instance_ = std::make_shared<MyClass>();
+      }
+      return instance_;
+    }
+
+  public:
+    static inline std::shared_ptr<MyClass> instance_;
+  };
+
+  int extractFlagUniquePtrRef(std::unique_ptr<MyClass>& myClass)
+  {
+    return myClass->flag;
+  }
+
+  int extractFlagSharedPtr(std::shared_ptr<MyClass> myClass)
+  {
+    return myClass->flag;
+  }
+
+  int extractFlagSharedPtrRef(std::shared_ptr<MyClass>& myClass)
+  {
+    return myClass->flag;
+  }
+}
+
+SETUP(SmartPointer)
+{
+  embed_ruby();
+
+  define_class<MyClass>("MyClass").
+    define_method("set_flag", &MyClass::setFlag);
+
+  define_class<Factory>("Factory").
+    define_constructor(Constructor<Factory>()).
+    define_method("transfer", &Factory::transfer).
+    define_method("share", &Factory::share);
+
+  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);
+}
+
+TESTCASE(TransferOwnership)
+{
+  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.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(ShareOwnership)
+{
+  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.share
+                          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(UniquePtrRefParameter)
+{
+  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.instance_eval(code);
+}
+
+TESTCASE(SharedPtrParameter)
+{
+  MyClass::reset();
+
+  Module m = define_module("TestingModule");
+
+  std::string code = R"(factory = Factory.new
+                        my_class = factory.share
+                        my_class.set_flag(7)
+                        extract_flag_shared_ptr(my_class))";
+ 
+  Object result = m.instance_eval(code);
+}
+
+TESTCASE(SharedPtrRefParameter)
+{
+  MyClass::reset();
+
+  Module m = define_module("TestingModule");
+
+  std::string code = R"(factory = Factory.new
+                        my_class = factory.share
+                        my_class.set_flag(7)
+                        extract_flag_shared_ptr_ref(my_class))";
+
+  Object result = m.instance_eval(code);
+}

data/test/test_Stl_String.cpp

@@ -0,0 +1,74 @@
+#include "unittest.hpp"
+#include "embed_ruby.hpp"
+#include <rice/rice.hpp>
+#include <ruby/encoding.h>
+#include <rice/stl.hpp>
+
+#include <optional>
+
+using namespace Rice;
+
+TESTSUITE(StlString);
+
+SETUP(StlString)
+{
+  embed_ruby();
+}
+
+TESTCASE(std_string_to_ruby)
+{
+  ASSERT(rb_equal(String("").value(), detail::to_ruby(std::string(""))));
+  ASSERT(rb_equal(String("foo").value(), detail::to_ruby(std::string("foo"))));
+}
+
+TESTCASE(std_string_to_ruby_encoding)
+{
+  VALUE value = detail::to_ruby(std::string("Some String"));
+  Object object(value);
+  Object encoding = object.call("encoding");
+  Object encodingName = encoding.call("name");
+  ASSERT_EQUAL("ASCII-8BIT", detail::From_Ruby<std::string>().convert(encodingName));
+}
+
+TESTCASE(std_string_to_ruby_encoding_utf8)
+{
+  rb_encoding* defaultEncoding = rb_default_external_encoding();
+  
+  VALUE utf8Encoding = rb_enc_from_encoding(rb_utf8_encoding());
+  rb_enc_set_default_external(utf8Encoding);
+
+  VALUE value = detail::to_ruby(std::string("Some String"));
+  Object object(value);
+  Object encoding = object.call("encoding");
+  Object encodingName = encoding.call("name");
+  ASSERT_EQUAL("UTF-8", detail::From_Ruby<std::string>().convert(encodingName));
+
+  rb_enc_set_default_external(rb_enc_from_encoding(defaultEncoding));
+}
+
+TESTCASE(std_string_from_ruby)
+{
+  ASSERT_EQUAL(std::string(""), detail::From_Ruby<std::string>().convert(rb_str_new2("")));
+  ASSERT_EQUAL(std::string("foo"), detail::From_Ruby<std::string>().convert(rb_str_new2("foo")));
+
+  ASSERT_EXCEPTION_CHECK(
+    Exception,
+    detail::From_Ruby<std::string>().convert(rb_float_new(15.512)),
+    ASSERT_EQUAL("wrong argument type Float (expected String)", ex.what())
+  );
+}
+
+TESTCASE(std_string_to_ruby_with_binary)
+{
+  Rice::String got = detail::to_ruby(std::string("\000test", 5));
+
+  ASSERT_EQUAL(String(std::string("\000test", 5)), got);
+  ASSERT_EQUAL(5ul, got.length());
+}
+
+TESTCASE(std_string_from_ruby_with_binary)
+{
+  std::string got = detail::From_Ruby<std::string>().convert(rb_str_new("\000test", 5));
+  ASSERT_EQUAL(5ul, got.length());
+  ASSERT_EQUAL(std::string("\000test", 5), got);
+}