rice 4.11.4 → 4.12.0

data/test/test_Constructor.cpp

@@ -28,6 +28,38 @@ namespace
   };
 }
 
+namespace
+{
+  class TakesPointerParameter
+  {
+  public:
+    TakesPointerParameter(int argc, const char *const* argv, bool enabled)
+      : argc_(argc), argv_(argv), enabled_(enabled)
+    {
+    }
+
+    int argc() const
+    {
+      return argc_;
+    }
+
+    const char *firstArg() const
+    {
+      return argv_[0];
+    }
+
+    bool enabled() const
+    {
+      return enabled_;
+    }
+
+  private:
+    int argc_;
+    const char *const *argv_;
+    bool enabled_;
+  };
+}
+
 TESTCASE(default_constructor)
 {
   Data_Type<Default_Constructible> rb_cDefault_Constructible(anonymous_class());
@@ -36,6 +68,15 @@ TESTCASE(default_constructor)
   ASSERT_EQUAL(rb_cDefault_Constructible, o.class_of());
 }
 
+TESTCASE(constructor_accepts_pointer_parameters)
+{
+  Data_Type<TakesPointerParameter> rb_cTakesPointerParameter(anonymous_class());
+  rb_cTakesPointerParameter.define_constructor(
+    Constructor<TakesPointerParameter, int, const char *const*, bool>(),
+    Arg("argc"), Arg("argv"), Arg("enabled"));
+  ASSERT_EQUAL(rb_cTakesPointerParameter, rb_cTakesPointerParameter);
+}
+
 namespace
 {
   class Non_Default_Constructible
@@ -187,4 +228,102 @@ TESTCASE(constructor_move)
 
   // This intentionally will not compile due to a static_assert
   //c.define_constructor(Constructor<MyClass, MyClass&&>());
-}
+}
+
+namespace
+{
+  // Polymorphic (has virtual methods) but non-virtual destructor.
+  // Deleting through a pointer is UB in this case. Rice's
+  // Wrapper<T*>::~Wrapper should not delete such objects.
+  class PolymorphicNonVirtualDtor
+  {
+  public:
+    PolymorphicNonVirtualDtor() : value_(42) {}
+    ~PolymorphicNonVirtualDtor() = default;
+
+    virtual int value()
+    {
+      return value_;
+    }
+
+  private:
+    int value_;
+  };
+}
+
+TESTCASE(constructor_polymorphic_non_virtual_dtor)
+{
+  Data_Type<PolymorphicNonVirtualDtor> rb_cPolymorphicNonVirtualDtor(anonymous_class());
+  rb_cPolymorphicNonVirtualDtor
+    .define_constructor(Constructor<PolymorphicNonVirtualDtor>())
+    .define_method("value", &PolymorphicNonVirtualDtor::value);
+
+  Object o = rb_cPolymorphicNonVirtualDtor.call("new");
+  ASSERT_EQUAL(rb_cPolymorphicNonVirtualDtor, o.class_of());
+
+  Object value = o.call("value");
+  ASSERT_EQUAL(42, detail::From_Ruby<int>().convert(value));
+}
+
+namespace
+{
+  class MoveOnlyValue
+  {
+  public:
+    MoveOnlyValue() = default;
+    MoveOnlyValue(const MoveOnlyValue&) = delete;
+
+    MoveOnlyValue(MoveOnlyValue&& other) noexcept
+      : moved_from_(other.moved_from_)
+    {
+      other.moved_from_ = true;
+    }
+
+    bool movedFrom() const
+    {
+      return moved_from_;
+    }
+
+  private:
+    bool moved_from_ = false;
+  };
+
+  class TakesMoveOnlyValue
+  {
+  public:
+    explicit TakesMoveOnlyValue(MoveOnlyValue&& value)
+      : value_(std::move(value))
+    {
+    }
+
+    bool hasValue() const
+    {
+      return !value_.movedFrom();
+    }
+
+  private:
+    MoveOnlyValue value_;
+  };
+}
+
+TESTCASE(constructor_forwards_rvalue_arguments)
+{
+  define_class<MoveOnlyValue>("MoveOnlyValue")
+    .define_constructor(Constructor<MoveOnlyValue>())
+    .define_method("moved_from?", &MoveOnlyValue::movedFrom);
+
+  define_class<TakesMoveOnlyValue>("TakesMoveOnlyValue")
+    .define_constructor(Constructor<TakesMoveOnlyValue, MoveOnlyValue&&>())
+    .define_method("has_value?", &TakesMoveOnlyValue::hasValue);
+
+  Module m(anonymous_module());
+  Array result = m.module_eval(R"(
+    value = MoveOnlyValue.new
+    consumer = TakesMoveOnlyValue.new(value)
+    [value.moved_from?, consumer.has_value?, consumer.class.name]
+  )");
+
+  ASSERT_EQUAL(Qtrue, result[0].value());
+  ASSERT_EQUAL(Qtrue, result[1].value());
+  ASSERT_EQUAL("TakesMoveOnlyValue", String(result[2].value()).str());
+}

data/test/test_File.cpp

@@ -62,10 +62,9 @@ TESTCASE(File)
     define_module_function("read_file", readFile).
     define_module_function("close_file", closeFile);
 
-  Data_Object<FILE> file = m.call("open_file");
+  Object file = m.call("open_file");
   ASSERT((file.value() != Qnil));
-  ASSERT((file.get() != nullptr));
-
+  
   String string = m.call("read_file", file);
   ASSERT((string.length() > 1300));
 

data/test/test_From_Ruby.cpp

@@ -230,7 +230,7 @@ TESTCASE(char_pointer_const)
 
 TESTCASE(unsigned_char)
 {
-  unsigned char expected = -1;
+  unsigned char expected = static_cast<unsigned char>(-1);
   ASSERT_EQUAL(expected, detail::From_Ruby<unsigned char>().convert(INT2NUM(-1)));
 
   expected = 1;
@@ -518,8 +518,8 @@ TESTCASE(unsigned_long)
 {
   ASSERT_EQUAL(0u, detail::From_Ruby<unsigned long>().convert(ULONG2NUM(0)));
   ASSERT_EQUAL(1u, detail::From_Ruby<unsigned long>().convert(ULONG2NUM(1)));
-  ASSERT_EQUAL((unsigned long)(FIXNUM_MIN),
-    detail::From_Ruby<unsigned long>().convert(ULONG2NUM(FIXNUM_MIN)));
+  ASSERT_EQUAL(static_cast<unsigned long>(FIXNUM_MIN),
+    detail::From_Ruby<unsigned long>().convert(ULONG2NUM(static_cast<unsigned long>(FIXNUM_MIN))));
   ASSERT_EQUAL(std::numeric_limits<unsigned long>::min(),
     detail::From_Ruby<unsigned long>().convert(ULONG2NUM(std::numeric_limits<unsigned long>::min())));
   ASSERT_EQUAL(std::numeric_limits<unsigned long>::max(),

data/test/test_Hash.cpp

@@ -227,3 +227,11 @@ namespace {
 TESTCASE(use_hash_in_wrapped_function) {
   define_global_function("test_hash_arg", &testHashArg);
 }
+
+TESTCASE(hash_lvalue_to_ruby)
+{
+  Hash value;
+  value["foo"] = 42;
+
+  ASSERT_EQUAL(value.value(), detail::to_ruby(value));
+}

data/test/test_Object.cpp

@@ -187,6 +187,38 @@ TESTCASE(call_return_rice_object)
   ASSERT_EQUAL(Object(detail::to_ruby(3)), three);
 }
 
+TESTCASE(call_with_c_string_argument)
+{
+  Module m(anonymous_module());
+
+  m.module_eval(R"(
+    def self.echo(value)
+      value
+    end
+  )");
+
+  const char* value = "charlie";
+  Object result = m.call("echo", value);
+
+  ASSERT_EQUAL("charlie", detail::From_Ruby<char*>().convert(result.value()));
+}
+
+TESTCASE(call_with_string_argument)
+{
+  Module m(anonymous_module());
+
+  m.module_eval(R"(
+    def self.echo(value)
+      value
+    end
+  )");
+
+  String value("charlie");
+  Object result = m.call("echo", value);
+
+  ASSERT_EQUAL("charlie", detail::From_Ruby<char*>().convert(result.value()));
+}
+
 TESTCASE(call_with_keywords)
 {
   Module m(anonymous_module());
@@ -215,6 +247,50 @@ TESTCASE(call_with_keywords)
   );
 }
 
+namespace
+{
+  class NonCopyableObjectCallArg
+  {
+  public:
+    NonCopyableObjectCallArg() = default;
+    NonCopyableObjectCallArg(const NonCopyableObjectCallArg&) = delete;
+    NonCopyableObjectCallArg& operator=(const NonCopyableObjectCallArg&) = delete;
+
+    void setValue(int value)
+    {
+      value_ = value;
+    }
+
+    int value() const
+    {
+      return value_;
+    }
+
+  private:
+    int value_ = 0;
+  };
+}
+
+TESTCASE(call_with_noncopyable_reference_argument)
+{
+  define_class<NonCopyableObjectCallArg>("NonCopyableObjectCallArg")
+    .define_constructor(Constructor<NonCopyableObjectCallArg>())
+    .define_method("set_value", &NonCopyableObjectCallArg::setValue)
+    .define_method("value", &NonCopyableObjectCallArg::value);
+
+  Module m(anonymous_module());
+  m.module_eval(R"(
+    def self.set_value(target)
+      target.set_value(41)
+    end
+  )");
+
+  NonCopyableObjectCallArg value;
+  m.call("set_value", value);
+
+  ASSERT_EQUAL(41, value.value());
+}
+
 TESTCASE(const_set_get_by_id)
 {
   Class c(anonymous_class());

data/test/test_Overloads.cpp

@@ -17,6 +17,8 @@ namespace
   class MyClass6;
   class MyClass7;
   class MyClass8;
+  class MyClass9;
+  class MyClass10;
 }
 
 SETUP(Overloads)
@@ -31,6 +33,8 @@ SETUP(Overloads)
   Data_Type<MyClass6>::unbind();
   Data_Type<MyClass7>::unbind();
   Data_Type<MyClass8>::unbind();
+  Data_Type<MyClass9>::unbind();
+  Data_Type<MyClass10>::unbind();
   Rice::detail::Registries::instance.types.remove<MyClass>();
   Rice::detail::Registries::instance.types.remove<MyClass2>();
   Rice::detail::Registries::instance.types.remove<MyClass3>();
@@ -39,6 +43,8 @@ SETUP(Overloads)
   Rice::detail::Registries::instance.types.remove<MyClass6>();
   Rice::detail::Registries::instance.types.remove<MyClass7>();
   Rice::detail::Registries::instance.types.remove<MyClass8>();
+  Rice::detail::Registries::instance.types.remove<MyClass9>();
+  Rice::detail::Registries::instance.types.remove<MyClass10>();
   Rice::detail::Registries::instance.natives.reset(Module(rb_mKernel));
 }
 
@@ -826,6 +832,73 @@ TESTCASE(ConstRef)
   ASSERT_EQUAL("const ref", result.str());
 }
 
+namespace
+{
+  class MyClass9
+  {
+  public:
+    MyClass9() = default;
+    MyClass9(const MyClass9&) = default;
+
+    MyClass9(MyClass9&& other) noexcept
+      : moved_from_(other.moved_from_)
+    {
+      other.moved_from_ = true;
+    }
+
+    bool movedFrom() const
+    {
+      return moved_from_;
+    }
+
+  private:
+    bool moved_from_ = false;
+  };
+
+  class MyClass10
+  {
+  public:
+    MyClass10(const MyClass9&)
+    {
+      this->result = "const ref";
+    }
+
+    MyClass10(MyClass9&& value)
+      : value_(std::move(value))
+    {
+      this->result = "rvalue ref";
+    }
+
+    std::string result = "";
+
+  private:
+    MyClass9 value_;
+  };
+}
+
+TESTCASE(ConstructorRValueRefShouldNotBeatConstRefForWrappedObjects)
+{
+  Class c9 = define_class<MyClass9>("MyClass9")
+    .define_constructor(Constructor<MyClass9>())
+    .define_method("moved_from?", &MyClass9::movedFrom);
+
+  Class c10 = define_class<MyClass10>("MyClass10")
+    .define_constructor(Constructor<MyClass10, const MyClass9&>())
+    .define_constructor(Constructor<MyClass10, MyClass9&&>())
+    .define_attr("result", &MyClass10::result);
+
+  Module m = define_module("Testing");
+
+  Array result = m.module_eval(R"(
+    source = MyClass9.new
+    consumer = MyClass10.new(source)
+    [consumer.result, source.moved_from?]
+  )");
+
+  ASSERT_EQUAL("const ref", String(result[0].value()).str());
+  ASSERT_EQUAL(Qfalse, result[1].value());
+}
+
 namespace
 {
   class MyClass6
@@ -1255,4 +1328,4 @@ TESTCASE(MethodBlock)
 
   String result = m.module_eval(code);
   ASSERT_EQUAL("Method Block", result.c_str());
-}
+}

data/test/test_Proc.cpp

@@ -59,6 +59,16 @@ TESTCASE(SquareProc)
   ASSERT_EQUAL(81, detail::From_Ruby<int>().convert(result));
 }
 
+TESTCASE(SquareProcLvalueToRuby)
+{
+  auto proc = square;
+  using To_Ruby_T = detail::remove_cv_recursive_t<decltype((proc))>;
+
+  VALUE value = detail::To_Ruby<To_Ruby_T>().convert(proc);
+  Object result(value);
+  ASSERT_EQUAL(81, detail::From_Ruby<int>().convert(result.call("call", 9)));
+}
+
 TESTCASE(SquareWithBlock)
 {
   Module m = define_module("TestingModuleMakeBlock");
@@ -97,4 +107,4 @@ TESTCASE(SquareWithProc)
 
   Object result = m.module_eval(code);
   ASSERT_EQUAL(16, detail::From_Ruby<int>().convert(result));
-}
+}

data/test/test_Reference.cpp

@@ -104,6 +104,26 @@ TESTCASE(double_reference)
   ASSERT_EQUAL(2.5, detail::From_Ruby<double>().convert(result));
 }
 
+TESTCASE(double_reference_object)
+{
+  Module m = define_module("Testing");
+
+  std::string code = R"(ref = Rice::Reference≺double≻.new(2.5)
+                        ref.value)";
+  Object result = m.module_eval(code);
+  ASSERT_EQUAL(2.5, detail::From_Ruby<double>().convert(result));
+}
+
+TESTCASE(float_reference_object)
+{
+  Module m = define_module("Testing");
+  define_reference<float>();
+  std::string code = R"(ref = Rice::Reference≺float≻.new(1.25)
+                        ref.value)";
+  Object result = m.module_eval(code);
+  ASSERT_EQUAL(1.25f, detail::From_Ruby<float>().convert(result));
+}
+
 TESTCASE(bool_reference)
 {
   Module m = define_module("Testing");
@@ -178,4 +198,3 @@ TESTCASE(unsigned_long_long_reference)
   Object result = m.module_eval(code);
   ASSERT_EQUAL(73ULL, detail::From_Ruby<unsigned long long>().convert(result));
 }
-

data/test/test_Stl_Exception.cpp

@@ -95,11 +95,8 @@ TESTCASE(StlExceptionPtr)
   m.define_module_function("create_exception_ptr", createExceptionPtr).
     define_module_function("handle_exception_ptr", handleExceptionPtr);
 
-  Data_Object<std::exception_ptr> exception = m.call("create_exception_ptr");
-  VALUE value = exception.value();
-  std::exception_ptr* ptr = exception.get();
-  ASSERT((value != Qnil));
-  ASSERT((ptr != nullptr));
+  Object exception = m.call("create_exception_ptr");
+  ASSERT((exception.value() != Qnil));
 
   ASSERT_EXCEPTION_CHECK(
     Exception,

data/test/test_Stl_Function.cpp

@@ -180,12 +180,8 @@ TESTCASE(RawProc)
     invoke(proc, 5, 1)
   )";
 
-  ASSERT_EXCEPTION_CHECK(
-    Exception,
-    m.module_eval(code),
-    ASSERT_EQUAL("The Ruby object is a proc or lambda and does not wrap a C++ object", 
-                 ex.what())
-  );
+  Object result = m.module_eval(code);
+  ASSERT_EQUAL(5, detail::From_Ruby<int>().convert(result));
 }
 
 TESTCASE(ReturnVoid)
@@ -258,4 +254,73 @@ TESTCASE(ConstFunctionReference)
 
   Object result = m.module_eval(code);
   ASSERT_EQUAL(9, detail::From_Ruby<int>().convert(result));
-}
+}
+
+TESTCASE(RawProcConstFunctionReference)
+{
+  Module m = define_module("TestConstFunctionRaw");
+  m.define_module_function("invoke_const", invokeConst);
+
+  std::string code = R"(
+    proc = Proc.new do |value|
+      value * 2
+    end
+    invoke_const(proc, 9)
+  )";
+
+  Object result = m.module_eval(code);
+  ASSERT_EQUAL(18, detail::From_Ruby<int>().convert(result));
+}
+
+namespace
+{
+  class NonCopyableReferenceArg
+  {
+  public:
+    NonCopyableReferenceArg() = default;
+    NonCopyableReferenceArg(const NonCopyableReferenceArg&) = delete;
+    NonCopyableReferenceArg& operator=(const NonCopyableReferenceArg&) = delete;
+
+    void setValue(int value)
+    {
+      value_ = value;
+    }
+
+    int value() const
+    {
+      return value_;
+    }
+
+  private:
+    int value_ = 0;
+  };
+
+  void invokeReferenceFunction(std::function<void(NonCopyableReferenceArg&)> func,
+                               NonCopyableReferenceArg& value)
+  {
+    func(value);
+  }
+}
+
+TESTCASE(ReferenceParameter)
+{
+  define_stl_function<void(NonCopyableReferenceArg&)>("FunctionRef");
+
+  define_class<NonCopyableReferenceArg>("NonCopyableReferenceArg")
+    .define_constructor(Constructor<NonCopyableReferenceArg>())
+    .define_method("set_value", &NonCopyableReferenceArg::setValue)
+    .define_method("value", &NonCopyableReferenceArg::value);
+
+  Module m = define_module("TestFunctionReference");
+  m.define_module_function("invoke_reference_function", invokeReferenceFunction);
+
+  std::string code = R"(
+    value = NonCopyableReferenceArg.new
+    func = Std::FunctionRef.new(->(target) { target.set_value(37) })
+    invoke_reference_function(func, value)
+    value.value
+  )";
+
+  Object result = m.module_eval(code);
+  ASSERT_EQUAL(37, detail::From_Ruby<int>().convert(result));
+}

data/test/test_Stl_Map.cpp

@@ -345,7 +345,16 @@ TESTCASE(NotComparable)
   Object result = map.call("include?", "two");
   ASSERT_EQUAL(Qtrue, result.value());
 
-  result = map.call("value?", NotComparable(3));
+  result = map.instance_eval("respond_to?(:value?)");
+  ASSERT_EQUAL(Qfalse, result.value());
+
+  result = map.instance_eval("respond_to?(:has_value)");
+  ASSERT_EQUAL(Qfalse, result.value());
+
+  result = map.instance_eval("method(:==).owner == self.class");
+  ASSERT_EQUAL(Qfalse, result.value());
+
+  result = map.instance_eval("method(:eql?).owner == self.class");
   ASSERT_EQUAL(Qfalse, result.value());
 }
 

data/test/test_Stl_Multimap.cpp

@@ -339,7 +339,16 @@ TESTCASE(NotComparable)
   Object result = multimap.call("include?", "two");
   ASSERT_EQUAL(Qtrue, result.value());
 
-  result = multimap.call("value?", NotComparable(3));
+  result = multimap.instance_eval("respond_to?(:value?)");
+  ASSERT_EQUAL(Qfalse, result.value());
+
+  result = multimap.instance_eval("respond_to?(:has_value)");
+  ASSERT_EQUAL(Qfalse, result.value());
+
+  result = multimap.instance_eval("method(:==).owner == self.class");
+  ASSERT_EQUAL(Qfalse, result.value());
+
+  result = multimap.instance_eval("method(:eql?).owner == self.class");
   ASSERT_EQUAL(Qfalse, result.value());
 }
 
@@ -769,4 +778,4 @@ TESTCASE(KeepAliveCopyConstructor)
   ASSERT_EQUAL(2, result.size());
   ASSERT_EQUAL("instance1", detail::From_Ruby<std::string>().convert(result[0].value()));
   ASSERT_EQUAL("instance2", detail::From_Ruby<std::string>().convert(result[1].value()));
-}
+}

data/test/test_Stl_Optional.cpp

@@ -67,6 +67,15 @@ TESTCASE(OptionalReturn)
   ASSERT(result.is_nil());
 }
 
+TESTCASE(NulloptToRubyReference)
+{
+  const std::nullopt_t& nullopt = std::nullopt;
+  using To_Ruby_T = detail::remove_cv_recursive_t<decltype((nullopt))>;
+
+  VALUE result = detail::To_Ruby<To_Ruby_T>().convert(nullopt);
+  ASSERT_EQUAL(Qnil, result);
+}
+
 TESTCASE(OptionalArgument)
 {
   Module m = define_module("Testing");

data/test/test_Stl_Reference_Wrapper.cpp

@@ -75,6 +75,17 @@ TESTCASE(Return)
   ASSERT_EQUAL("A ref wrapped string", detail::From_Ruby<std::string>().convert(result));
 }
 
+TESTCASE(LvalueToRuby)
+{
+  MyClass instance;
+  std::reference_wrapper<MyClass> wrapper = std::ref(instance);
+  const std::reference_wrapper<MyClass>& ref = wrapper;
+  using To_Ruby_T = detail::remove_cv_recursive_t<decltype((ref))>;
+
+  VALUE result = detail::To_Ruby<To_Ruby_T>().convert(ref);
+  ASSERT_EQUAL(&instance, detail::unwrap<MyClass>(result, Data_Type<MyClass>::ruby_data_type(), false));
+}
+
 TESTCASE(Argument)
 {
   Module m = define_module("Testing");

data/test/test_Stl_Set.cpp

@@ -333,6 +333,18 @@ TESTCASE(Equal)
 
   result = m.instance_eval(code);
   ASSERT_EQUAL(Qfalse, result.value());
+
+  code = R"(set = Std::NotPrintableSet.new
+            set.method(:==).owner == set.class)";
+
+  result = m.instance_eval(code);
+  ASSERT_EQUAL(Qfalse, result.value());
+
+  code = R"(set = Std::NotPrintableSet.new
+            set.method(:eql?).owner == set.class)";
+
+  result = m.instance_eval(code);
+  ASSERT_EQUAL(Qfalse, result.value());
 }
 
 TESTCASE(ToArray)

data/test/test_Stl_Unordered_Map.cpp

@@ -337,7 +337,16 @@ TESTCASE(NotComparable)
   Object result = unordered_map.call("include?", "two");
   ASSERT_EQUAL(Qtrue, result.value());
 
-  result = unordered_map.call("value?", NotComparable(3));
+  result = unordered_map.instance_eval("respond_to?(:value?)");
+  ASSERT_EQUAL(Qfalse, result.value());
+
+  result = unordered_map.instance_eval("respond_to?(:has_value)");
+  ASSERT_EQUAL(Qfalse, result.value());
+
+  result = unordered_map.instance_eval("method(:==).owner == self.class");
+  ASSERT_EQUAL(Qfalse, result.value());
+
+  result = unordered_map.instance_eval("method(:eql?).owner == self.class");
   ASSERT_EQUAL(Qfalse, result.value());
 }