rice 4.11.4 → 4.12.0

data/test/test_Stl_Vector.cpp

@@ -31,6 +31,28 @@ namespace
       return result;
     }
   };
+
+  class VectorRValueSink
+  {
+  public:
+    explicit VectorRValueSink(std::vector<int>&& values)
+      : values_(std::move(values))
+    {
+    }
+
+    void setValues(std::vector<int>&& values)
+    {
+      values_ = std::move(values);
+    }
+
+    size_t size() const
+    {
+      return values_.size();
+    }
+
+  private:
+    std::vector<int> values_;
+  };
 }
 
 Class makeVectorClass()
@@ -83,6 +105,36 @@ TESTCASE(StringVectorData)
   ASSERT_EQUAL("World", detail::From_Ruby<std::string>().convert(array[1].value()).c_str());
 }
 
+TESTCASE(VectorRvalueParameters)
+{
+  Module m(anonymous_module());
+  define_vector<int>("IntVector");
+
+  define_class_under<VectorRValueSink>(m, "VectorRValueSink")
+    .define_constructor(Constructor<VectorRValueSink, std::vector<int>&&>(), Arg("values"))
+    .define_method("set_values", &VectorRValueSink::setValues, Arg("values"))
+    .define_method("size", &VectorRValueSink::size);
+
+  Object result = m.module_eval(R"(
+    sink = VectorRValueSink.new(Std::IntVector.new([1, 2, 3]))
+    sink.set_values(Std::IntVector.new([4, 5]))
+    sink.size
+  )");
+
+  ASSERT_EQUAL(2, detail::From_Ruby<int32_t>().convert(result));
+}
+
+TESTCASE(VectorBoolReferenceLvalueToRuby)
+{
+  std::vector<bool> values{ true };
+  auto reference = values[0];
+  const auto& ref = reference;
+  using To_Ruby_T = detail::remove_cv_recursive_t<decltype((ref))>;
+
+  VALUE result = detail::To_Ruby<To_Ruby_T>().convert(ref);
+  ASSERT_EQUAL(Qtrue, result);
+}
+
 TESTCASE(Constructors)
 {
   Module m = define_module("Testing");
@@ -504,17 +556,23 @@ TESTCASE(NotComparable)
   vec.call("push", NotComparable(2));
   vec.call("push", NotComparable(3));
 
-  Object result = vec.call("delete", NotComparable(1));
-  ASSERT(result.is_nil());
+  Object result = vec.instance_eval("respond_to?(:delete)");
+  ASSERT_EQUAL(Qfalse, result.value());
 
   result = vec.call("length");
   ASSERT_EQUAL(3u, detail::From_Ruby<size_t>().convert(result));
 
-  result = vec.call("include?", NotComparable(2));
+  result = vec.instance_eval("method(:include?).owner == self.class");
   ASSERT_EQUAL(Qfalse, result.value());
 
-  result = vec.call("index", NotComparable(3));
-  ASSERT(result.is_nil());
+  result = vec.instance_eval("respond_to?(:index)");
+  ASSERT_EQUAL(Qfalse, result.value());
+
+  result = vec.instance_eval("method(:==).owner == self.class");
+  ASSERT_EQUAL(Qfalse, result.value());
+
+  result = vec.instance_eval("method(:eql?).owner == self.class");
+  ASSERT_EQUAL(Qfalse, result.value());
 }
 
 TESTCASE(NotDefaultConstructable)
@@ -665,17 +723,78 @@ TESTCASE(ComparableButNotBool)
   vec.call("push", ComparableButNotBool(2));
   vec.call("push", ComparableButNotBool(3));
 
-  Object result = vec.call("delete", ComparableButNotBool(1));
-  ASSERT(result.is_nil());
+  Object result = vec.instance_eval("respond_to?(:delete)");
+  ASSERT_EQUAL(Qfalse, result.value());
 
   result = vec.call("length");
   ASSERT_EQUAL(3u, detail::From_Ruby<size_t>().convert(result));
 
-  result = vec.call("include?", ComparableButNotBool(2));
+  result = vec.instance_eval("method(:include?).owner == self.class");
   ASSERT_EQUAL(Qfalse, result.value());
 
-  result = vec.call("index", ComparableButNotBool(3));
-  ASSERT(result.is_nil());
+  result = vec.instance_eval("respond_to?(:index)");
+  ASSERT_EQUAL(Qfalse, result.value());
+
+  result = vec.instance_eval("method(:==).owner == self.class");
+  ASSERT_EQUAL(Qfalse, result.value());
+
+  result = vec.instance_eval("method(:eql?).owner == self.class");
+  ASSERT_EQUAL(Qfalse, result.value());
+}
+
+namespace
+{
+  class ComparableButNotComparable
+  {
+  public:
+    ComparableButNotComparable(uint32_t value) : value_(value)
+    {
+    };
+
+    bool operator==(const ComparableButNotComparable& other) const
+    {
+      return this->value_ == other.value_;
+    }
+
+    uint32_t value_;
+  };
+}
+
+namespace Rice::detail
+{
+  template<>
+  struct is_comparable<ComparableButNotComparable> : std::false_type {};
+}
+
+TESTCASE(ComparableButNotComparable)
+{
+  define_class<ComparableButNotComparable>("ComparableButNotComparable").
+    define_constructor(Constructor<ComparableButNotComparable, uint32_t>());
+
+  Class c = define_vector<ComparableButNotComparable>("ComparableButNotComparableVector");
+
+  Object vec = c.call("new");
+  vec.call("push", ComparableButNotComparable(1));
+  vec.call("push", ComparableButNotComparable(2));
+  vec.call("push", ComparableButNotComparable(3));
+
+  Object result = vec.instance_eval("respond_to?(:delete)");
+  ASSERT_EQUAL(Qfalse, result.value());
+
+  result = vec.call("length");
+  ASSERT_EQUAL(3u, detail::From_Ruby<size_t>().convert(result));
+
+  result = vec.instance_eval("method(:include?).owner == self.class");
+  ASSERT_EQUAL(Qfalse, result.value());
+
+  result = vec.instance_eval("respond_to?(:index)");
+  ASSERT_EQUAL(Qfalse, result.value());
+
+  result = vec.instance_eval("method(:==).owner == self.class");
+  ASSERT_EQUAL(Qfalse, result.value());
+
+  result = vec.instance_eval("method(:eql?).owner == self.class");
+  ASSERT_EQUAL(Qfalse, result.value());
 }
 
 TESTCASE(DefaultConstructable)
@@ -1483,4 +1602,4 @@ TESTCASE(VectorOverloadResolution)
 
   result = m.module_eval(code);
   ASSERT_EQUAL("ClassB", detail::From_Ruby<std::string>().convert(result));
-}
+}

data/test/test_String.cpp

@@ -127,3 +127,10 @@ TESTCASE(use_string_in_wrapped_function)
 {
   define_global_function("test_string_arg", &testStringArg);
 }
+
+TESTCASE(string_lvalue_to_ruby)
+{
+  String value("foo");
+
+  ASSERT_EQUAL(value.value(), detail::to_ruby(value));
+}

data/test/test_To_Ruby.cpp

@@ -26,6 +26,14 @@ TESTCASE(object_to_ruby)
   ASSERT_EQUAL(o.value(), detail::to_ruby(o));
 }
 
+TESTCASE(nullptr_lvalue_to_ruby)
+{
+  const std::nullptr_t& value = nullptr;
+  using To_Ruby_T = detail::remove_cv_recursive_t<decltype((value))>;
+
+  ASSERT_EQUAL(Qnil, detail::To_Ruby<To_Ruby_T>().convert(value));
+}
+
 TESTCASE(short_to_ruby)
 {
 #undef min
@@ -141,6 +149,14 @@ TESTCASE(char_ptr_to_ruby)
   ASSERT(rb_equal(Qnil, toRuby.convert(nullptr)));
 }
 
+TESTCASE(char_ptr_lvalue_to_ruby)
+{
+  char text[] = "foo";
+  char* value = text;
+
+  ASSERT(rb_equal(String("foo").value(), detail::to_ruby(value)));
+}
+
 TESTCASE(char_const_ptr_to_ruby)
 {
   ASSERT(rb_equal(String("").value(), detail::to_ruby((char const *)"")));
@@ -148,6 +164,13 @@ TESTCASE(char_const_ptr_to_ruby)
   ASSERT(rb_equal(String("foo").value(), detail::to_ruby("foo")));
 }
 
+TESTCASE(char_array_lvalue_to_ruby)
+{
+  char value[] = "foo";
+
+  ASSERT(rb_equal(String("foo").value(), detail::to_ruby(value)));
+}
+
 TESTCASE(char_const_array_to_ruby_symbol)
 {
   ASSERT(rb_equal(Symbol("foo").value(), detail::to_ruby(":foo")));
@@ -529,4 +552,4 @@ TESTCASE(double_ptr_array)
   actual = array.to_vector<double>();
   ASSERT_EQUAL(expected, actual);
 }
-*/
+*/

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: rice
 version: !ruby/object:Gem::Version
-  version: 4.11.4
+  version: 4.12.0
 platform: ruby
 authors:
 - Paul Brannan