rice 4.7.1 → 4.8.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

@@ -182,9 +182,9 @@ TESTCASE(ShareOwnership)
   std::string code = R"(ary = Array.new
                         factory = Factory.new
                         10.times do |i|
-                          my_class = factory.share
-                          my_class.set_flag(i)
-                          ary << my_class
+                          ptr = factory.share
+                          ptr.get.set_flag(i)
+                          ary << ptr
                         end)";
 
   ASSERT_EQUAL(0, Factory::instance_.use_count());
@@ -211,8 +211,8 @@ TESTCASE(ShareOwnership2)
   // 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)
+                          ptr = factory.share
+                          ptr.get.set_flag(i)
                         end)";
 
   Factory factory;
@@ -222,9 +222,9 @@ TESTCASE(ShareOwnership2)
   // 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)");
+  wrapper.instance_eval("share_ref.get.set_flag(1)");
 
-  ASSERT_EQUAL(3, Factory::instance_.use_count());
+  ASSERT_EQUAL(2, Factory::instance_.use_count());
   rb_gc_start();
   ASSERT_EQUAL(2, Factory::instance_.use_count());
 }
@@ -237,9 +237,9 @@ TESTCASE(PtrParameter)
   Module m = define_module("TestingModule");
 
   std::string code = R"(factory = Factory.new
-                        my_class = factory.share
-                        my_class.set_flag(8)
-                        extract_flag_shared_ptr(my_class))";
+                        ptr = factory.share
+                        ptr.get.set_flag(8)
+                        extract_flag_shared_ptr(ptr))";
 
   Object result = m.module_eval(code);
   ASSERT_EQUAL(8, detail::From_Ruby<int>().convert(result));
@@ -253,9 +253,9 @@ TESTCASE(RefParameter)
   Module m = define_module("TestingModule");
 
   std::string code = R"(factory = Factory.new
-                        my_class = factory.share
-                        my_class.set_flag(9)
-                        extract_flag_shared_ptr_ref(my_class))";
+                        ptr = factory.share
+                        ptr.get.set_flag(9)
+                        extract_flag_shared_ptr_ref(ptr))";
 
   Object result = m.module_eval(code);
   ASSERT_EQUAL(9, detail::From_Ruby<int>().convert(result));
@@ -269,8 +269,8 @@ TESTCASE(DefaultParameter)
   Module m = define_module("TestingModule");
 
   std::string code = R"(factory = Factory.new
-                        my_class = factory.share
-                        my_class.set_flag(7)
+                        ptr = factory.share
+                        ptr.get.set_flag(7)
                         extract_flag_shared_ptr_with_default())";
 
   Object result = m.module_eval(code);
@@ -286,8 +286,8 @@ TESTCASE(RefDefaultParameter)
   Module m = define_module("TestingModule");
 
   std::string code = R"(factory = Factory.new
-                        my_class = factory.share
-                        my_class.set_flag(7)
+                        ptr = factory.share
+                        ptr.get.set_flag(7)
                         extract_flag_shared_ptr_ref_with_default())";
 
   Object result = m.module_eval(code);
@@ -334,14 +334,14 @@ TESTCASE(Update)
 
   // Create ruby objects that point to the same instance of MyClass
   std::string code = R"(factory = Factory.new
-                        my_class1 = factory.share
-                        my_class1.set_flag(7)
+                        ptr1 = factory.share
+                        ptr1.get.set_flag(7)
 
-                        my_class2 = MyClass.new
-                        my_class2.set_flag(14)
+                        myclass = MyClass.new
+                        myclass.set_flag(14)
 
                         sink = Sink.new
-                        sink.update_pointer(my_class1, my_class2))";
+                        sink.update_pointer(ptr1, myclass))";
 
   Object result = m.instance_eval(code);
   ASSERT_EQUAL(14, detail::From_Ruby<long>().convert(result.value()));
@@ -349,8 +349,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);
 }
@@ -400,11 +402,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 +430,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 +458,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 +471,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))";
@@ -461,7 +485,7 @@ TESTCASE(ReadPointerToInt)
              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>();

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

data/test/test_Stl_Variant.cpp

@@ -21,12 +21,6 @@ namespace
     int
   >;
 
-  inline std::ostream& operator<<(std::ostream& stream, Intrinsic_Variant_T const& variant)
-  {
-    stream << "Variant(" << "index: " << variant.index() << ")";
-    return stream;
-  }
-
   class MyClass
   {
   public:
@@ -111,7 +105,6 @@ namespace
   public:
     MyClass1()
     {
-      int a = 1;
     }
 
     std::string sayHello()
@@ -125,7 +118,6 @@ namespace
   public:
     MyClass2()
     {
-      int a = 2;
     }
 
     std::string sayHello()
@@ -207,7 +199,7 @@ TESTCASE(IntrinsicReturns)
 
   result = myClass.call("variant_vector");
   std::vector<int> converted = detail::From_Ruby<std::vector<int>>().convert(result);
-  ASSERT_EQUAL(3, converted.size());
+  ASSERT_EQUAL(3u, converted.size());
 
   result = myClass.call("variant_double");
   ASSERT_EQUAL(3.3, detail::From_Ruby<double>().convert(result));
@@ -334,9 +326,9 @@ TESTCASE(Roundtrip)
 /* This test case runs successfully on MSVC but not g++. Having stepped through the code with
   GDB, this sure seems due to a bug with g++. The issue is this variable in created operator():
 
-        Arg_Ts nativeValues = this->getNativeValues(rubyValues, indices);
+        Parameter_Ts nativeValues = this->getNativeValues(rubyValues, indices);
 
- And is then passed to invokeNativeFunction as a const Arg_Ts& nativeArgs where Arg_Ts& is
+ And is then passed to invokeNativeFunction as a const Parameter_Ts& nativeArgs where Parameter_Ts& is
  std::tuple with one element, a reference to a variant. So it doesn't change and the address
  of the variable doesn't change. But for some reason g++ resets the
  the std::variant index to 0 thus breaking the test. Maybe something to do with storing
@@ -416,19 +408,19 @@ TESTCASE(VariantWithTwoVectors)
                           my_class.variant_index(vector))";
 
   Object result = m.module_eval(code);
-  ASSERT_EQUAL(0, detail::From_Ruby<size_t>().convert(result));
+  ASSERT_EQUAL(0u, detail::From_Ruby<size_t>().convert(result));
 
   code = R"(vector = Std::Vector≺int≻.new
               vector.push_back(4)
               my_class = MyClass4.new
               my_class.variant_index(vector))";
   result = m.module_eval(code);
-  ASSERT_EQUAL(1, detail::From_Ruby<size_t>().convert(result));
+  ASSERT_EQUAL(1u, detail::From_Ruby<size_t>().convert(result));
 
   code = R"(my_class = MyClass4.new
               my_class.variant_index(["x", "y", "z"]))";
   result = m.module_eval(code);
-  ASSERT_EQUAL(0, detail::From_Ruby<size_t>().convert(result));
+  ASSERT_EQUAL(0u, detail::From_Ruby<size_t>().convert(result));
 
   code = R"(my_class = MyClass4.new
               my_class.variant_index([5, 6]))";