rice 4.7.1 → 4.9.0

data/test/test_Reference.cpp

@@ -0,0 +1,181 @@
+#include "unittest.hpp"
+#include "embed_ruby.hpp"
+#include <rice/rice.hpp>
+
+using namespace Rice;
+
+TESTSUITE(Reference);
+
+SETUP(Reference)
+{
+  embed_ruby();
+}
+
+TEARDOWN(Reference)
+{
+  rb_gc_start();
+}
+
+namespace
+{
+  void updateIntRef(int& ref)
+  {
+    ref = 42;
+  }
+
+  int readIntRef(int& ref)
+  {
+    return ref;
+  }
+
+  double readDoubleRef(double& ref)
+  {
+    return ref;
+  }
+
+  bool readBoolRef(bool& ref)
+  {
+    return ref;
+  }
+
+  char readCharRef(char& ref)
+  {
+    return ref;
+  }
+
+  long readLongRef(long& ref)
+  {
+    return ref;
+  }
+
+  long long readLongLongRef(long long& ref)
+  {
+    return ref;
+  }
+
+  unsigned long long readUnsignedLongLongRef(unsigned long long& ref)
+  {
+    return ref;
+  }
+}
+
+TESTCASE(pass_fundamental_to_reference)
+{
+  Module m = define_module("Testing");
+  m.define_module_function("read_int_ref", &readIntRef);
+
+  std::string code = R"(read_int_ref(7))";
+  Object result = m.module_eval(code);
+  ASSERT_EQUAL(7, detail::From_Ruby<int>().convert(result));
+}
+
+TESTCASE(pass_reference_object)
+{
+  Module m = define_module("Testing");
+  m.define_module_function("read_int_ref", &readIntRef);
+
+  std::string code = R"(ref = Rice::Reference≺int≻.new(7)
+                        read_int_ref(ref))";
+
+  Object result = m.module_eval(code);
+  ASSERT_EQUAL(7, detail::From_Ruby<int>().convert(result));
+}
+
+TESTCASE(modify_reference_object)
+{
+  Module m = define_module("Testing");
+  m.define_module_function("update_int_ref", &updateIntRef);
+
+  std::string code = R"(ref = Rice::Reference≺int≻.new(7)
+                        update_int_ref(ref)
+                        ref.value)";
+
+  Object result = m.module_eval(code);
+  ASSERT_EQUAL(42, detail::From_Ruby<int>().convert(result));
+}
+
+TESTCASE(double_reference)
+{
+  Module m = define_module("Testing");
+  m.define_module_function("read_double_ref", &readDoubleRef);
+
+  std::string code = R"(read_double_ref(2.5))";
+  Object result = m.module_eval(code);
+  ASSERT_EQUAL(2.5, detail::From_Ruby<double>().convert(result));
+}
+
+TESTCASE(bool_reference)
+{
+  Module m = define_module("Testing");
+  m.define_module_function("read_bool_ref", &readBoolRef);
+
+  std::string code = R"(read_bool_ref(true))";
+  Object result = m.module_eval(code);
+  ASSERT_EQUAL(Qtrue, result.value());
+
+  code = R"(read_bool_ref(false))";
+  result = m.module_eval(code);
+  ASSERT_EQUAL(Qfalse, result.value());
+}
+
+TESTCASE(reference_preserves_value)
+{
+  Module m = define_module("Testing");
+  m.define_module_function("read_int_ref", &readIntRef);
+
+  std::string code = R"(read_int_ref(0))";
+  Object result = m.module_eval(code);
+  ASSERT_EQUAL(0, detail::From_Ruby<int>().convert(result));
+
+  code = R"(read_int_ref(-1))";
+  result = m.module_eval(code);
+  ASSERT_EQUAL(-1, detail::From_Ruby<int>().convert(result));
+
+  code = R"(read_int_ref(1000000))";
+  result = m.module_eval(code);
+  ASSERT_EQUAL(1000000, detail::From_Ruby<int>().convert(result));
+}
+
+TESTCASE(char_reference)
+{
+  Module m = define_module("Testing");
+  m.define_module_function("read_char_ref", &readCharRef);
+
+  std::string code = R"(read_char_ref(65))";
+  Object result = m.module_eval(code);
+  ASSERT_EQUAL('A', detail::From_Ruby<char>().convert(result));
+}
+
+TESTCASE(long_reference)
+{
+  Module m = define_module("Testing");
+  m.define_module_function("read_long_ref", &readLongRef);
+
+  std::string code = R"(read_long_ref(123456789))";
+  Object result = m.module_eval(code);
+  ASSERT_EQUAL(123456789, detail::From_Ruby<long>().convert(result));
+}
+
+TESTCASE(long_long_reference)
+{
+  Module m = define_module("Testing");
+  m.define_module_function("read_long_long_ref", &readLongLongRef);
+
+  std::string code = R"(read_long_long_ref(9223372036854775807))";
+  Object result = m.module_eval(code);
+  ASSERT_EQUAL(9223372036854775807LL, detail::From_Ruby<long long>().convert(result));
+}
+
+TESTCASE(unsigned_long_long_reference)
+{
+  // Special case: VALUE is unsigned long long on Windows x64, so we can't
+  // use Reference<unsigned long long>. Instead, the old pattern is used
+  // which stores the converted value directly.
+  Module m = define_module("Testing");
+  m.define_module_function("read_unsigned_long_long_ref", &readUnsignedLongLongRef);
+
+  std::string code = R"(read_unsigned_long_long_ref(73))";
+  Object result = m.module_eval(code);
+  ASSERT_EQUAL(73ULL, detail::From_Ruby<unsigned long long>().convert(result));
+}
+

data/test/test_Self.cpp

@@ -39,12 +39,12 @@ namespace
       destructorCalls++;
     }
 
-    SelfClass(const SelfClass& other)
+    SelfClass(const SelfClass&)
     {
       copyConstructorCalls++;
     }
 
-    SelfClass(SelfClass&& other)
+    SelfClass(SelfClass&&)
     {
       moveConstructorCalls++;
     }

data/test/test_Stl_Set.cpp

@@ -349,7 +349,7 @@ TESTCASE(ToArray)
                         set.to_a)";
 
   Array array = m.module_eval(code);
-  ASSERT_EQUAL(3u, array.size());
+  ASSERT_EQUAL(3, array.size());
 
   ASSERT_EQUAL("abc", detail::From_Ruby<std::string>().convert(array[0].value()));
   ASSERT_EQUAL("def", detail::From_Ruby<std::string>().convert(array[1].value()));
@@ -507,11 +507,11 @@ namespace
     static inline std::set<std::string> instance_{ "one", "two", "three" };
   };
 
-  std::ostream& operator<<(std::ostream& stream, const std::set<std::string>& set)
+ /* std::ostream& operator<<(std::ostream& stream, const std::set<std::string>& set)
   {
-    stream << "Set";
+    stream << set;
     return stream;
-  }
+  }*/
 
   void createFactoryClass()
   {
@@ -645,7 +645,7 @@ TESTCASE(StringPointerSet)
 
   Module m(rb_mKernel);
   Data_Object<std::set<std::string*>> set = m.call("set_of_string_pointers");
-  ASSERT_EQUAL(1, set->size());
+  ASSERT_EQUAL(1u, set->size());
 
   std::string expected = "Hello";
   const std::string* actual = *set->begin();
@@ -682,7 +682,7 @@ TESTCASE(MyClass2PointerSet)
 
   Module m(rb_mKernel);
   Data_Object<std::set<MyClass2*>> result = m.call("set_of_myclass2_pointers");
-  ASSERT_EQUAL(1, result->size());
+  ASSERT_EQUAL(1u, result->size());
 
  MyClass2* pMyClass = *result->begin();
  ASSERT_EQUAL("Hello MyClass2", pMyClass->name);

data/test/test_Stl_SharedPtr.cpp

@@ -29,6 +29,8 @@ namespace
 
   public:
     int flag = 0;
+    std::string name = "default";
+    int threshold = 0;
 
   public:
     MyClass()
@@ -57,6 +59,17 @@ namespace
     }
   };
 
+  class MyClassInherited : public MyClass
+  {
+  public:
+    int extra = 0;
+
+    void setExtra(int value)
+    {
+      this->extra = value;
+    }
+  };
+
   class Factory
   {
   public:
@@ -87,6 +100,11 @@ namespace
       return instance_;
     }
 
+    std::shared_ptr<MyClassInherited> share_inherited()
+    {
+      return std::make_shared<MyClassInherited>();
+    }
+
   public:
     static inline std::shared_ptr<MyClass> instance_;
   };
@@ -138,12 +156,20 @@ SETUP(SharedPtr)
 
   define_class<MyClass>("MyClass").
     define_constructor(Constructor<MyClass>()).
-    define_method("set_flag", &MyClass::setFlag);
+    define_method("set_flag", &MyClass::setFlag).
+    define_attr("name", &MyClass::name, Rice::AttrAccess::Read).
+    define_attr("threshold", &MyClass::threshold);
+
+  define_class<MyClassInherited, MyClass>("MyClassInherited").
+    define_constructor(Constructor<MyClassInherited>()).
+    define_method("set_extra", &MyClassInherited::setExtra).
+    define_attr("extra", &MyClassInherited::extra);
 
   define_class<Factory>("Factory").
     define_constructor(Constructor<Factory>()).
     define_method("share", &Factory::share).
-    define_method("share_ref", &Factory::share_ref);
+    define_method("share_ref", &Factory::share_ref).
+    define_method("share_inherited", &Factory::share_inherited);
 
   define_class<Sink>("Sink").
     define_constructor(Constructor<Sink>()).
@@ -173,8 +199,8 @@ TEARDOWN(SharedPtr)
 
 TESTCASE(ShareOwnership)
 {
-  MyClass::reset();
   Factory::reset();
+  MyClass::reset();
 
   Module m = define_module("TestingModule");
 
@@ -203,8 +229,8 @@ TESTCASE(ShareOwnership)
 
 TESTCASE(ShareOwnership2)
 {
-  MyClass::reset();
   Factory::reset();
+  MyClass::reset();
 
   Module m = define_module("TestingModule");
 
@@ -215,24 +241,25 @@ TESTCASE(ShareOwnership2)
                           my_class.set_flag(i)
                         end)";
 
-  Factory factory;
-  std::shared_ptr<MyClass> myClass = factory.share();
-  ASSERT_EQUAL(2, Factory::instance_.use_count());
-
-  // Call some ruby code
-  Data_Object<Factory> wrapper(factory);
-  ASSERT_EQUAL(2, Factory::instance_.use_count());
-  wrapper.instance_eval("self.share_ref.set_flag(1)");
+  ASSERT_EQUAL(0, Factory::instance_.use_count());
+  m.module_eval(code);
 
-  ASSERT_EQUAL(3, Factory::instance_.use_count());
+  ASSERT_EQUAL(11, Factory::instance_.use_count());
   rb_gc_start();
-  ASSERT_EQUAL(2, Factory::instance_.use_count());
+  ASSERT_EQUAL(1, Factory::instance_.use_count());
+
+  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(PtrParameter)
 {
-  MyClass::reset();
   Factory::reset();
+  MyClass::reset();
 
   Module m = define_module("TestingModule");
 
@@ -247,8 +274,8 @@ TESTCASE(PtrParameter)
 
 TESTCASE(RefParameter)
 {
-  MyClass::reset();
   Factory::reset();
+  MyClass::reset();
 
   Module m = define_module("TestingModule");
 
@@ -263,8 +290,8 @@ TESTCASE(RefParameter)
 
 TESTCASE(DefaultParameter)
 {
-  MyClass::reset();
   Factory::reset();
+  MyClass::reset();
 
   Module m = define_module("TestingModule");
 
@@ -280,8 +307,8 @@ TESTCASE(DefaultParameter)
 
 TESTCASE(RefDefaultParameter)
 {
-  MyClass::reset();
   Factory::reset();
+  MyClass::reset();
 
   Module m = define_module("TestingModule");
 
@@ -299,13 +326,13 @@ TESTCASE(RefDefaultParameter)
   ASSERT_EQUAL(1, MyClass::constructorCalls);
   ASSERT_EQUAL(0, MyClass::copyConstructorCalls);
   ASSERT_EQUAL(0, MyClass::moveConstructorCalls);
-  ASSERT_EQUAL(1, MyClass::destructorCalls);
+  ASSERT_EQUAL(0, MyClass::destructorCalls);
 }
 
 TESTCASE(RoundTrip)
 {
-  MyClass::reset();
   Factory::reset();
+  MyClass::reset();
 
   Module m = define_module("TestingModule");
 
@@ -322,13 +349,13 @@ TESTCASE(RoundTrip)
   ASSERT_EQUAL(1, MyClass::constructorCalls);
   ASSERT_EQUAL(0, MyClass::copyConstructorCalls);
   ASSERT_EQUAL(0, MyClass::moveConstructorCalls);
-  ASSERT_EQUAL(1, MyClass::destructorCalls);
+  ASSERT_EQUAL(0, MyClass::destructorCalls);
 }
 
 TESTCASE(Update)
 {
-  MyClass::reset();
   Factory::reset();
+  MyClass::reset();
 
   Module m = define_module("TestingModule");
 
@@ -349,8 +376,10 @@ TESTCASE(Update)
 
 TESTCASE(Klass)
 {
+  define_shared_ptr<MyClass>(); 
   detail::TypeMapper<std::shared_ptr<MyClass>> typeMapper;
-  Object expected = Object(rb_cObject).const_get("MyClass");
+  Module aModule("Std");
+  Object expected = aModule.const_get("SharedPtr≺AnonymousNamespace꞉꞉MyClass≻");
   VALUE actual = typeMapper.rubyKlass();
   ASSERT_EQUAL(expected.value(), actual);
 }
@@ -368,8 +397,8 @@ TESTCASE(KlassSharedPtr)
 
 TESTCASE(Void)
 {
-  MyClass::reset();
   Factory::reset();
+  MyClass::reset();
 
   Module m = define_module("TestingModule");
 
@@ -400,11 +429,23 @@ namespace
     return shared;
   }
 
+  const std::shared_ptr<int> createConstPointer(int value)
+  {
+    int* sharedInt = new int(value);
+    const std::shared_ptr<int> shared(sharedInt);
+    return shared;
+  }
+
   int getPointerValue(std::shared_ptr<int> ptr)
   {
     return *ptr;
   }
 
+  int getConstPointerValue(const std::shared_ptr<int>& ptr)
+  {
+    return *ptr;
+  }
+
   int updatePointerValue(std::shared_ptr<int> ptr)
   {
     *ptr = *ptr + 1;
@@ -416,13 +457,27 @@ TESTCASE(PointerToInt)
 {
   Module m = define_module("SharedPtrInt").
     define_module_function("create_pointer", &createPointer).
-    define_module_function("get_pointer_value", &getPointerValue);
+    define_module_function("create_const_pointer", &createConstPointer).
+    define_module_function("get_pointer_value", &getPointerValue).
+    define_module_function("get_const_pointer_value", &getConstPointerValue);
 
   std::string code = R"(ptr = create_pointer(44)
                         get_pointer_value(ptr))";
 
   Object result = m.instance_eval(code);
   ASSERT_EQUAL(44, detail::From_Ruby<int>().convert(result.value()));
+
+  code = R"(ptr = create_const_pointer(45)
+            get_const_pointer_value(ptr))";
+
+  result = m.instance_eval(code);
+  ASSERT_EQUAL(45, detail::From_Ruby<int>().convert(result.value()));
+
+  code = R"(ptr = create_const_pointer(46)
+            get_pointer_value(ptr))";
+
+  result = m.instance_eval(code);
+  ASSERT_EQUAL(46, detail::From_Ruby<int>().convert(result.value()));
 }
 
 TESTCASE(CreatePointerToInt)
@@ -430,10 +485,8 @@ TESTCASE(CreatePointerToInt)
   Module m = define_module("CreatePointerToInt").
     define_module_function("get_pointer_value", &getPointerValue);
 
-  define_shared_ptr<int>("SharedPtrInt");
-
   std::string code = R"(buffer = Rice::Buffer≺int≻.new(45)
-                        ptr = Std::SharedPtrInt.new(buffer.release)
+                        ptr = Std::SharedPtr≺int≻.new(buffer.release)
                         get_pointer_value(ptr))";
 
   Object result = m.instance_eval(code);
@@ -445,8 +498,6 @@ TESTCASE(UpdatePointerToInt)
   Module m = define_module("UpdatePointerToInt").
     define_module_function("update_pointer_value", &updatePointerValue);
 
-  define_shared_ptr<int>();
-
   std::string code = R"(buffer = Rice::Buffer≺int≻.new(45)
                         ptr = Std::SharedPtr≺int≻.new(buffer.release)
                         update_pointer_value(ptr))";
@@ -458,13 +509,101 @@ TESTCASE(UpdatePointerToInt)
 TESTCASE(ReadPointerToInt)
 {
   Module m = define_module("ReadPointerToInt").
-             define_module_function("create_pointer", &createPointer);
+    define_module_function("create_pointer", &createPointer);
 
   std::string code = R"(ptr = create_pointer(50)
-                        ptr.buffer.to_ary(1))";
+                        ptr.get.buffer.to_ary(1))";
 
   Array array = m.instance_eval(code);
   std::vector<int> actual = array.to_vector<int>();
-  std::vector<int> expected { 50 };
+  std::vector<int> expected{ 50 };
   ASSERT_EQUAL(expected, actual);
+}
+
+TESTCASE(AttributeForwarding)
+{
+  Factory::reset();
+  MyClass::reset();
+
+  Module m = define_module("TestingModule");
+
+  // Test read-only attribute
+  std::string code = R"(factory = Factory.new
+                        ptr = factory.share
+                        ptr.name)";
+
+  Object result = m.module_eval(code);
+  ASSERT_EQUAL("default", detail::From_Ruby<std::string>().convert(result));
+
+  // Test read/write attribute - read
+  code = R"(factory = Factory.new
+            ptr = factory.share
+            ptr.threshold)";
+
+  result = m.module_eval(code);
+  ASSERT_EQUAL(0, detail::From_Ruby<int>().convert(result));
+
+  // Test read/write attribute - write and read back
+  code = R"(factory = Factory.new
+            ptr = factory.share
+            ptr.threshold = 42
+            ptr.threshold)";
+
+  result = m.module_eval(code);
+  ASSERT_EQUAL(42, detail::From_Ruby<int>().convert(result));
+}
+
+TESTCASE(InheritedForwarding)
+{
+  Factory::reset();
+  MyClass::reset();
+
+  Module m = define_module("TestingModule");
+
+  // Test inherited method from MyClass via forwarding
+  std::string code = R"(factory = Factory.new
+                        $ptr = factory.share_inherited
+                        $ptr.set_flag(99))";
+
+  m.module_eval(code);
+
+  // Verify via C++ that set_flag worked
+  std::shared_ptr<MyClassInherited>* ptr = detail::From_Ruby<std::shared_ptr<MyClassInherited>*>().convert(
+    m.module_eval("$ptr"));
+  ASSERT_EQUAL(99, (*ptr)->flag);
+
+  // Test inherited read-only attribute from MyClass
+  code = R"(factory = Factory.new
+            ptr = factory.share_inherited
+            ptr.name)";
+
+  Object result = m.module_eval(code);
+  ASSERT_EQUAL("default", detail::From_Ruby<std::string>().convert(result));
+
+  // Test inherited read/write attribute from MyClass
+  code = R"(factory = Factory.new
+            ptr = factory.share_inherited
+            ptr.threshold = 77
+            ptr.threshold)";
+
+  result = m.module_eval(code);
+  ASSERT_EQUAL(77, detail::From_Ruby<int>().convert(result));
+
+  // Test own method on MyClassInherited via forwarding
+  code = R"(factory = Factory.new
+            ptr = factory.share_inherited
+            ptr.set_extra(123)
+            ptr.extra)";
+
+  result = m.module_eval(code);
+  ASSERT_EQUAL(123, detail::From_Ruby<int>().convert(result));
+
+  // Test own attribute on MyClassInherited via forwarding
+  code = R"(factory = Factory.new
+            ptr = factory.share_inherited
+            ptr.extra = 456
+            ptr.extra)";
+
+  result = m.module_eval(code);
+  ASSERT_EQUAL(456, detail::From_Ruby<int>().convert(result));
 }

data/test/test_Stl_String_View.cpp

@@ -93,11 +93,13 @@ TESTCASE(std_string_view_from_ruby_refefence)
 }
 
 namespace {
-  std::string_view testStringViewReturn(Object self) {
+  std::string_view testStringViewReturn(Object)
+  {
     return "test";
   }
 }
 
-TESTCASE(use_string_view_in_wrapped_function) {
+TESTCASE(use_string_view_in_wrapped_function)
+{
   define_global_function("test_string_view_return", &testStringViewReturn);
 }

data/test/test_Stl_Tuple.cpp

@@ -94,7 +94,7 @@ TESTCASE(TupleToRuby)
   ASSERT_EQUAL(1i, detail::From_Ruby<std::complex<double>>().convert(result[1].value()));
   
   std::vector<int> converted = detail::From_Ruby<std::vector<int>>().convert(result[2].value());
-  ASSERT_EQUAL(3, converted.size());
+  ASSERT_EQUAL(3u, converted.size());
 
   ASSERT_EQUAL(3.3, detail::From_Ruby<double>().convert(result[3].value()));
   ASSERT_EQUAL(Qtrue, result[4].value());