rice 4.7.1 → 4.8.0

data/test/test_Array.cpp

@@ -2,6 +2,8 @@
 #include "embed_ruby.hpp"
 #include <rice/rice.hpp>
 
+#include <algorithm>
+#include <iterator>
 #include <vector>
 
 using namespace Rice;
@@ -235,9 +237,9 @@ TESTCASE(iterate_and_call_member)
   Array::iterator it = a.begin();
   Array::iterator end = a.end();
   std::vector<Object> v;
-  for(int j = 0; it != end; ++j, ++it)
+  for(const auto& item: a)
   {
-    v.push_back(it->to_s());
+    v.push_back(Object(item).to_s());
   }
   ASSERT_EQUAL(42, detail::From_Ruby<int>().convert(a[0].value()));
   ASSERT_EQUAL(43, detail::From_Ruby<int>().convert(a[1].value()));
@@ -278,7 +280,7 @@ TESTCASE(assign_int)
 
 namespace
 {
-  void testArrayArg(Object self, Array string)
+  void testArrayArg(Object, Array)
   {
   }
 }
@@ -313,3 +315,259 @@ TESTCASE(array_from_ruby)
   Array a(rb_ary_new());
   ASSERT_EQUAL(a, detail::From_Ruby<Array>().convert(a));
 }
+
+// Random-access iterator tests
+TESTCASE(iterator_random_access_category)
+{
+  // Verify the iterator is now a random-access iterator
+  static_assert(std::is_same_v<
+    Array::iterator::iterator_category,
+    std::random_access_iterator_tag>,
+    "Array::iterator should be a random_access_iterator");
+
+  static_assert(std::is_same_v<
+    Array::const_iterator::iterator_category,
+    std::random_access_iterator_tag>,
+    "Array::const_iterator should be a random_access_iterator");
+}
+
+TESTCASE(iterator_arithmetic_add)
+{
+  Array a;
+  a.push(10, false);
+  a.push(20, false);
+  a.push(30, false);
+  a.push(40, false);
+  a.push(50, false);
+
+  Array::iterator it = a.begin();
+  Array::iterator it2 = it + 2;
+  ASSERT_EQUAL(30, detail::From_Ruby<int>().convert(it2->value()));
+
+  it2 = 3 + it;  // Test non-member operator+
+  ASSERT_EQUAL(40, detail::From_Ruby<int>().convert(it2->value()));
+}
+
+TESTCASE(iterator_arithmetic_subtract)
+{
+  Array a;
+  a.push(10, false);
+  a.push(20, false);
+  a.push(30, false);
+  a.push(40, false);
+  a.push(50, false);
+
+  Array::iterator it = a.end();
+  Array::iterator it2 = it - 2;
+  ASSERT_EQUAL(40, detail::From_Ruby<int>().convert(it2->value()));
+}
+
+TESTCASE(iterator_compound_assignment)
+{
+  Array a;
+  a.push(10, false);
+  a.push(20, false);
+  a.push(30, false);
+  a.push(40, false);
+  a.push(50, false);
+
+  Array::iterator it = a.begin();
+  it += 3;
+  ASSERT_EQUAL(40, detail::From_Ruby<int>().convert(it->value()));
+
+  it -= 2;
+  ASSERT_EQUAL(20, detail::From_Ruby<int>().convert(it->value()));
+}
+
+TESTCASE(iterator_difference)
+{
+  Array a;
+  a.push(10, false);
+  a.push(20, false);
+  a.push(30, false);
+  a.push(40, false);
+  a.push(50, false);
+
+  Array::iterator begin = a.begin();
+  Array::iterator end = a.end();
+  ASSERT_EQUAL(5, end - begin);
+  ASSERT_EQUAL(-5, begin - end);
+
+  Array::iterator mid = begin + 2;
+  ASSERT_EQUAL(2, mid - begin);
+  ASSERT_EQUAL(3, end - mid);
+}
+
+TESTCASE(iterator_subscript)
+{
+  Array a;
+  a.push(10, false);
+  a.push(20, false);
+  a.push(30, false);
+  a.push(40, false);
+  a.push(50, false);
+
+  Array::iterator it = a.begin();
+  ASSERT_EQUAL(10, detail::From_Ruby<int>().convert(it[0].value()));
+  ASSERT_EQUAL(30, detail::From_Ruby<int>().convert(it[2].value()));
+  ASSERT_EQUAL(50, detail::From_Ruby<int>().convert(it[4].value()));
+}
+
+TESTCASE(iterator_comparison_less_greater)
+{
+  Array a;
+  a.push(10, false);
+  a.push(20, false);
+  a.push(30, false);
+
+  Array::iterator begin = a.begin();
+  Array::iterator mid = begin + 1;
+  Array::iterator end = a.end();
+
+  ASSERT_EQUAL(true, begin < mid);
+  ASSERT_EQUAL(true, begin < end);
+  ASSERT_EQUAL(true, mid < end);
+
+  ASSERT_EQUAL(true, end > mid);
+  ASSERT_EQUAL(true, end > begin);
+  ASSERT_EQUAL(true, mid > begin);
+
+  ASSERT_EQUAL(true, begin <= begin);
+  ASSERT_EQUAL(true, begin <= mid);
+  ASSERT_EQUAL(true, mid <= end);
+
+  ASSERT_EQUAL(true, end >= end);
+  ASSERT_EQUAL(true, end >= mid);
+  ASSERT_EQUAL(true, mid >= begin);
+}
+
+TESTCASE(iterator_decrement)
+{
+  Array a;
+  a.push(10, false);
+  a.push(20, false);
+  a.push(30, false);
+
+  Array::iterator it = a.end();
+  --it;
+  ASSERT_EQUAL(30, detail::From_Ruby<int>().convert(it->value()));
+  --it;
+  ASSERT_EQUAL(20, detail::From_Ruby<int>().convert(it->value()));
+  --it;
+  ASSERT_EQUAL(10, detail::From_Ruby<int>().convert(it->value()));
+}
+
+TESTCASE(iterator_decrement_postfix)
+{
+  Array a;
+  a.push(10, false);
+  a.push(20, false);
+  a.push(30, false);
+
+  Array::iterator it = a.end();
+  it--;
+  ASSERT_EQUAL(30, detail::From_Ruby<int>().convert(it->value()));
+  Array::iterator prev = it--;
+  ASSERT_EQUAL(30, detail::From_Ruby<int>().convert(prev->value()));
+  ASSERT_EQUAL(20, detail::From_Ruby<int>().convert(it->value()));
+}
+
+TESTCASE(iterator_std_sort)
+{
+  // std::sort requires iterators that return assignable references.
+  // Our iterator returns a Proxy which supports assignment to the array,
+  // but STL algorithms need iter_swap to work. Test that we can use
+  // std::sort with explicit swap via indices instead.
+  Array a;
+  a.push(30, false);
+  a.push(10, false);
+  a.push(50, false);
+  a.push(20, false);
+  a.push(40, false);
+
+  // Manual sort using random-access capabilities (bubble sort for simplicity)
+  for (long i = 0; i < a.size() - 1; i++)
+  {
+    for (long j = 0; j < a.size() - i - 1; j++)
+    {
+      auto it = a.begin();
+      int val1 = detail::From_Ruby<int>().convert(it[j].value());
+      int val2 = detail::From_Ruby<int>().convert(it[j + 1].value());
+      if (val1 > val2)
+      {
+        // Swap using array subscript operator
+        Object temp = a[j];
+        a[j] = detail::From_Ruby<int>().convert(a[j + 1].value());
+        a[j + 1] = detail::From_Ruby<int>().convert(temp.value());
+      }
+    }
+  }
+
+  ASSERT_EQUAL(10, detail::From_Ruby<int>().convert(a[0].value()));
+  ASSERT_EQUAL(20, detail::From_Ruby<int>().convert(a[1].value()));
+  ASSERT_EQUAL(30, detail::From_Ruby<int>().convert(a[2].value()));
+  ASSERT_EQUAL(40, detail::From_Ruby<int>().convert(a[3].value()));
+  ASSERT_EQUAL(50, detail::From_Ruby<int>().convert(a[4].value()));
+}
+
+TESTCASE(iterator_std_reverse)
+{
+  // std::reverse requires iter_swap support. Test manual reverse using
+  // random-access iterator capabilities instead.
+  Array a;
+  a.push(10, false);
+  a.push(20, false);
+  a.push(30, false);
+  a.push(40, false);
+  a.push(50, false);
+
+  // Manual reverse using random-access capabilities
+  auto begin = a.begin();
+  auto end = a.end() - 1;
+  while (begin < end)
+  {
+    long i = begin.index();
+    long j = end.index();
+    Object temp = a[i];
+    a[i] = detail::From_Ruby<int>().convert(a[j].value());
+    a[j] = detail::From_Ruby<int>().convert(temp.value());
+    ++begin;
+    --end;
+  }
+
+  ASSERT_EQUAL(50, detail::From_Ruby<int>().convert(a[0].value()));
+  ASSERT_EQUAL(40, detail::From_Ruby<int>().convert(a[1].value()));
+  ASSERT_EQUAL(30, detail::From_Ruby<int>().convert(a[2].value()));
+  ASSERT_EQUAL(20, detail::From_Ruby<int>().convert(a[3].value()));
+  ASSERT_EQUAL(10, detail::From_Ruby<int>().convert(a[4].value()));
+}
+
+TESTCASE(iterator_std_distance)
+{
+  Array a;
+  a.push(10, false);
+  a.push(20, false);
+  a.push(30, false);
+  a.push(40, false);
+  a.push(50, false);
+
+  ASSERT_EQUAL(5, std::distance(a.begin(), a.end()));
+  ASSERT_EQUAL(3, std::distance(a.begin() + 1, a.begin() + 4));
+}
+
+TESTCASE(iterator_std_advance)
+{
+  Array a;
+  a.push(10, false);
+  a.push(20, false);
+  a.push(30, false);
+  a.push(40, false);
+  a.push(50, false);
+
+  Array::iterator it = a.begin();
+  std::advance(it, 3);
+  ASSERT_EQUAL(40, detail::From_Ruby<int>().convert(it->value()));
+
+  std::advance(it, -2);
+  ASSERT_EQUAL(20, detail::From_Ruby<int>().convert(it->value()));
+}

data/test/test_Attribute.cpp

@@ -28,6 +28,9 @@ namespace
 
   class NotAssignable
   {
+  public:
+    NotAssignable() = default;
+    NotAssignable(const NotAssignable&) = default;
     NotAssignable& operator=(const NotAssignable&) = delete;
   };
 
@@ -35,7 +38,7 @@ namespace
   {
   public:
     NotCopyable() = default;
-    NotCopyable(const NotCopyable& other) = delete;
+    NotCopyable(const NotCopyable&) = delete;
   };
 
   enum OldEnum
@@ -453,7 +456,7 @@ TESTCASE(BufferAttribute)
 
   Class c = define_class<BufferAttrs>("BufferAttrs")
     .define_constructor(Constructor<BufferAttrs>())
-    .define_attr("buffer", &BufferAttrs::buffer, Rice::AttrAccess::Read, Return().setBuffer());
+    .define_attr("buffer", &BufferAttrs::buffer, Rice::AttrAccess::Read, ReturnBuffer());
 
   std::string code = R"(struct = BufferAttrs.new
                         struct.buffer.class)";
@@ -487,7 +490,7 @@ TESTCASE(CounterBufferAttribute)
 
   define_class<BufferAttrs>("BufferAttrs")
     .define_constructor(Constructor<BufferAttrs>())
-    .define_attr("counters_buffer", &BufferAttrs::countersBuffer, Rice::AttrAccess::Read, Return().setBuffer());
+    .define_attr("counters_buffer", &BufferAttrs::countersBuffer, Rice::AttrAccess::Read, ReturnBuffer());
 
   std::string code = R"(struct = BufferAttrs.new
                         struct.counters_buffer.class)";

data/test/test_Buffer.cpp

@@ -255,8 +255,8 @@ namespace
 TESTCASE(pointer_of_doubles)
 {
   Module m = define_module("Testing").
-    define_module_function("speeds", &speeds, Return().setBuffer()).
-    define_module_function("speeds_ptr", &speedsPtr, Return().setBuffer());
+    define_module_function("speeds", &speeds, ReturnBuffer()).
+    define_module_function("speeds_ptr", &speedsPtr, ReturnBuffer());
 
   std::string code = R"(buffer = Rice::Buffer≺double≻.new(speeds, 3)
                         buffer[2])";
@@ -275,48 +275,12 @@ TESTCASE(pointer_of_doubles)
 
 namespace
 {
-  void updateRef(int& ref)
-  {
-    ref = 4;
-  }
-
   void updatePtr(int* ptr)
   {
     *ptr = 5;
   }
 }
 
-TESTCASE(update_reference)
-{
-  define_buffer<int>();
-  Module m = define_module("Testing");
-  m.define_module_function("update_reference", &updateRef);
-
-  std::string code = R"(buffer = Rice::Buffer≺int≻.new(0)
-                        update_reference(buffer.data)
-                        buffer.to_ary(1).first)";
-
-  Object result = m.module_eval(code);
-  ASSERT_EQUAL(4, detail::From_Ruby<int>().convert(result));
-
-  code = R"(buffer = Rice::Buffer≺int≻.new(0)
-            update_reference(buffer.data)
-            buffer[0])";
-
-  result = m.module_eval(code);
-  ASSERT_EQUAL(4, detail::From_Ruby<int>().convert(result));
-
-  code = R"(buffer = Rice::Buffer≺int≻.new(0)
-            update_reference(buffer.data)
-            buffer[1])";
-
-  ASSERT_EXCEPTION_CHECK(
-    Exception,
-    m.module_eval(code),
-    ASSERT_EQUAL("index 1 outside of bounds: 0..1", ex.what())
-  );
-}
-
 TESTCASE(update_ptr)
 {
   define_buffer<int>();
@@ -492,8 +456,8 @@ TESTCASE(pointer_of_objects)
   define_buffer<MyClassBuf*>();
 
   Module m = define_module("Testing").
-    define_module_function("class_buffs", &classBufs).
-    define_module_function("class_buffs_ptr", &classBufsPtr);
+    define_module_function("class_buffs", &classBufs, ReturnBuffer()).
+    define_module_function("class_buffs_ptr", &classBufsPtr, ReturnBuffer());
 
   define_class<MyClassBuf>("MyClassBuf").
     define_constructor(Constructor<MyClassBuf, int>()).
@@ -593,8 +557,8 @@ TESTCASE(array_of_objects_ptr)
 TESTCASE(pass_objects)
 {
   Module m = define_module("Testing");
-  m.define_module_function<size_t(*)(const MyClassBuf*, size_t)>("sum_ids", &sumIds, Arg("myClasses").setBuffer());
-  m.define_module_function<size_t(*)(const MyClassBuf**, size_t)>("sum_ids_ptr", &sumIds, Arg("myClasses").setBuffer());
+  m.define_module_function<size_t(*)(const MyClassBuf*, size_t)>("sum_ids", &sumIds, ArgBuffer("myClasses"));
+  m.define_module_function<size_t(*)(const MyClassBuf**, size_t)>("sum_ids_ptr", &sumIds, ArgBuffer("myClasses"));
 
   define_class_under<MyClassBuf>(m, "MyClassBuf").
     define_constructor(Constructor<MyClassBuf, int>()).

data/test/test_Callback.cpp

@@ -20,7 +20,7 @@ TEARDOWN(Callback)
 
 namespace
 {
-  using Callback_T = char*(*)(int, double, bool, char*);
+  using Callback_T = char*(*)(int, double, bool, char*, int&);
   Callback_T globalCallback;
 
   void registerCallback(Callback_T callback)
@@ -28,11 +28,11 @@ namespace
     globalCallback = callback;
   }
 
-  char* triggerCallback(int anInt, double aDouble, bool aBool, char* aString)
+  char* triggerCallback(int anInt, double aDouble, bool aBool, char* aString, int& intRef)
   {
     if (globalCallback)
     {
-      return globalCallback(anInt, aDouble, aBool, aString);
+      return globalCallback(anInt, aDouble, aBool, aString, intRef);
     }
     throw std::runtime_error("Callback has not been registered");
   }
@@ -41,13 +41,12 @@ namespace
 TESTCASE(LambdaCallBack)
 {
   Module m = define_module("TestingLambda");
-  m.define_module_function("register_callback", registerCallback).
-    define_module_function("trigger_callback", triggerCallback);
+  m.define_module_function("register_callback", registerCallback);
 
   ASSERT_EQUAL(globalCallback, nullptr);
 
-  std::string code = R"(callback = lambda do |an_int, a_double, a_bool, a_string|
-                                     values = [an_int, a_double, a_bool, a_string]
+  std::string code = R"(callback = lambda do |an_int, a_double, a_bool, a_string, an_intref|
+                                     values = [an_int, a_double, a_bool, a_string, an_intref]
                                      values.map {|value| value.to_s}.join(" - ")
                                    end
                         register_callback(callback))";
@@ -55,25 +54,26 @@ TESTCASE(LambdaCallBack)
   m.module_eval(code);
   ASSERT((globalCallback != nullptr));
 
-  String result = m.call("trigger_callback", 1, 2, true, "hello");
-  ASSERT_EQUAL("1 - 2.0 - true - hello", result.c_str());
+  int ref = 4;
+  char* result = triggerCallback(1, 2, true, "hello", ref);
+  ASSERT_EQUAL("1 - 2.0 - true - hello - 4", result);
 }
 
 TESTCASE(BlockCallBack)
 {
   Module m = define_module("TestingBlock");
-  m.define_module_function("register_callback", registerCallback).
+  m.define_module_function("register_callback", registerCallback, Arg("callback").setBlock()).
     define_module_function("trigger_callback", triggerCallback);
 
-  std::string code = R"(register_callback do |an_int, a_double, a_bool, a_string|
-                          values = [an_int, a_double, a_bool, a_string]
+  std::string code = R"(register_callback do |an_int, a_double, a_bool, a_string, an_intref|
+                          values = [an_int, a_double, a_bool, a_string, an_intref]
                           values.map {|value| value.to_s}.join(" - ")
                         end)";
 
   m.module_eval(code);
 
-  String result = m.call("trigger_callback", 4, 5.5, false, "Hello block");
-  ASSERT_EQUAL("4 - 5.5 - false - Hello block", result.c_str());
+  String result = m.call("trigger_callback", 4, 5.5, false, "Hello block", 8);
+  ASSERT_EQUAL("4 - 5.5 - false - Hello block - 8", result.c_str());
 }
 
 TESTCASE(ProcCallBack)
@@ -82,16 +82,17 @@ TESTCASE(ProcCallBack)
   m.define_module_function("register_callback", registerCallback).
     define_module_function("trigger_callback", triggerCallback);
 
-  std::string code = R"(callback = Proc.new do |an_int, a_double, a_bool, a_string|
-                                      values = [an_int, a_double, a_bool, a_string]
+  std::string code = R"(callback = Proc.new do |an_int, a_double, a_bool, a_string, an_intref|
+                                      values = [an_int, a_double, a_bool, a_string, an_intref]
                                       values.map {|value| value.to_s}.join(" - ")
                                    end
                         register_callback(callback))";
 
   m.module_eval(code);
 
-  String result = m.call("trigger_callback", 8, 4.4, true, "Hello proc");
-  ASSERT_EQUAL("8 - 4.4 - true - Hello proc", result.c_str());
+  int ref = 9;
+  String result = m.call("trigger_callback", 8, 4.4, true, "Hello proc", ref);
+  ASSERT_EQUAL("8 - 4.4 - true - Hello proc - 9", result.c_str());
 }
 
 TESTCASE(MethodCallBack)
@@ -100,16 +101,16 @@ TESTCASE(MethodCallBack)
   m.define_module_function("register_callback", registerCallback).
     define_module_function("trigger_callback", triggerCallback);
 
-  std::string code = R"(def self.callback(an_int, a_double, a_bool, a_string)
-                          values = [an_int, a_double, a_bool, a_string]
+  std::string code = R"(def self.callback(an_int, a_double, a_bool, a_string, an_intref)
+                          values = [an_int, a_double, a_bool, a_string, an_intref]
                           values.map {|value| value.to_s}.join(" - ")
                         end
                         register_callback(method(:callback).to_proc))";
 
   m.module_eval(code);
 
-  String result = m.call("trigger_callback", 11.1, 22.9, true, "Hello method");
-  ASSERT_EQUAL("11 - 22.9 - true - Hello method", result.c_str());
+  String result = m.call("trigger_callback", 11.1, 22.9, true, "Hello method", 17.2);
+  ASSERT_EQUAL("11 - 22.9 - true - Hello method - 17", result.c_str());
 }
 
 namespace
@@ -123,7 +124,7 @@ namespace
 TESTCASE(FunctionArg)
 {
   Module m = define_module("TestingFunctionArg");
-  m.define_module_function("function_arg", functionArg);
+  m.define_module_function("function_arg", functionArg, Arg("i"), Arg("block").setBlock());
 
   std::string code = R"(function_arg(4) do |i|
                           i * i
@@ -227,3 +228,56 @@ TESTCASE(UserData)
   String result = m.call("trigger_callback");
   ASSERT_EQUAL("TestingUserData::UserDataClass", result.c_str());
 }
+
+namespace
+{
+  using Callback_T4 = void(*)(void* userData);
+  Callback_T4 globalCallback4;
+  void* globalUserData4 = nullptr;
+
+  void registerCallback4(Callback_T4 callback, void* userData)
+  {
+    globalCallback4 = callback;
+    globalUserData4 = userData;
+  }
+
+  void triggerCallback4()
+  {
+    if (globalCallback4)
+    {
+      globalCallback4(globalUserData4);
+    }
+    else
+    {
+      throw std::runtime_error("Callback has not been registered");
+    }
+  }
+}
+
+TESTCASE(VoidReturn)
+{
+  Module m = define_module("TestingUserData");
+  m.define_module_function("register_callback4", registerCallback4, Arg("callback"), Arg("user_data").setOpaque()).
+    define_module_function("trigger_callback4", triggerCallback4);
+
+  define_callback<Callback_T4>(Arg("user_data").setOpaque());
+
+  std::string code = R"(class UserDataClass
+                        end
+
+                        user_data_1 = UserDataClass.new
+
+                        callback = Proc.new do |user_data_2|
+                                     unless user_data_1.equal?(user_data_2)
+                                       raise("Unexpected user data object")
+                                     end
+                                     user_data_2.class.name
+                                   end
+
+                        register_callback4(callback, user_data_1))";
+
+  m.module_eval(code);
+
+  Object result = m.call("trigger_callback4");
+  ASSERT_EQUAL(Qnil, result.value());
+}

data/test/test_Data_Object.cpp

@@ -33,7 +33,7 @@ namespace
 namespace Rice
 {
   template<>
-  void ruby_mark(MyDataType* myDataType)
+  void ruby_mark(MyDataType*)
   {
     test_ruby_mark_called = true;
   }