rice 4.7.1 → 4.8.0

data/test/test_Data_Type.cpp

@@ -20,7 +20,7 @@ TEARDOWN(Data_Type)
   rb_gc_start();
 }
 
-namespace
+/*namespace
 {
   class MyClass
   {
@@ -38,7 +38,7 @@ namespace
       multiple_args_called = false;
     }
 
-    static Object singleton_method_object_int(Object object, int anInt)
+    static Object singleton_method_object_int(Object object, int)
     {
       return object;
     }
@@ -427,12 +427,12 @@ namespace
     RValue(RValue&& other) = default;
 
     // Move assignment operator.
-    RValue& operator=(RValue&& other) noexcept
+    RValue& operator=(RValue&&) noexcept
     {
       return *this;
     }
 
-    bool takesRValue(RValue&& rvalue)
+    bool takesRValue(RValue&&)
     {
       return true;
     }
@@ -499,7 +499,7 @@ TESTCASE(null_ptrs)
 
   result = o.call("set", nullptr);
   ASSERT_EQUAL(Qnil, result.value());
-}
+}*/
 
 namespace
 {
@@ -595,7 +595,7 @@ TESTCASE(pointers)
   result = object.call("check_void_helper", helper);
   ASSERT_EQUAL(Qtrue, result.value());
 }
-
+/*
 namespace
 {
   class BigObject
@@ -612,11 +612,11 @@ namespace
   class Processor
   {
   public:
-    BigObject** createBigObjects(size_t size)
+    BigObject** createBigObjects(int size)
     {
       BigObject** result = new BigObject*[size];
 
-      for (size_t i = 0; i < size; ++i)
+      for (int i = 0; i < size; ++i)
       {
         result[i] = new BigObject(i + 5);
       }
@@ -661,14 +661,14 @@ TESTCASE(pointerToPointer)
     .define_constructor(Constructor<Processor>())
     .define_method("create", &Processor::createBigObjects)
     .define_method("sum", &Processor::sumBigObjects,
-                          Arg("bigObjects").setBuffer(), Arg("size"))
+                          ArgBuffer("bigObjects"), Arg("size"))
     .define_method("sum_const", &Processor::sumBigObjectsConst,
-                                Arg("bigObjects").setBuffer(), Arg("size"));
+      ArgBuffer("bigObjects"), Arg("size"));
 
   std::string code = R"(count = 2
-                          processor = ProcessorClass.new
-                          big_objects = processor.create(count)
-                          processor.sum(big_objects, count))";
+                        processor = ProcessorClass.new
+                        big_objects = processor.create(count)
+                        processor.sum(big_objects, count))";
 
   Object result = m.module_eval(code);
   ASSERT_EQUAL(11, detail::From_Ruby<int>().convert(result));
@@ -688,15 +688,15 @@ namespace
   {
   };
 
-  void undefinedArg(UnknownClass unknownClass)
+  void undefinedArg(UnknownClass)
   {
   }
 
-  void undefinedArg(UnknownClass& unknownClass)
+  void undefinedArg(UnknownClass&)
   {
   }
 
-  void undefinedArg(UnknownClass* unknownClass)
+  void undefinedArg(UnknownClass*)
   {
   }
 
@@ -773,8 +773,6 @@ namespace RangesTest
     {
     }
 
-    RangeCustom(const RangeCustom& other) = default;
-
     int x;
     int y;
   };
@@ -826,7 +824,7 @@ TESTCASE(array_of_ranges)
     .define_attr("y", &RangesTest::RangeCustom::y);
 
   m.define_module_function("sum_ranges_array", RangesTest::sumRangesArray, 
-                                               Arg("ranges[]").setBuffer(), Arg("size"));
+                           ArgBuffer("ranges[]"), Arg("size"));
 
   std::string code = R"(range1 = RangeCustom.new(1, 2)
                         range2 = RangeCustom.new(3, 4)
@@ -849,7 +847,7 @@ TESTCASE(pointer_of_ranges)
     .define_attr("y", &RangesTest::RangeCustom::y);
 
   m.define_module_function<int(*)(const RangesTest::RangeCustom*, int)>("sum_ranges", RangesTest::sumRanges,
-                                                                        Arg("ranges").setBuffer(), Arg("size"));
+                                                                        ArgBuffer("ranges"), Arg("size"));
 
   std::string code = R"(range1 = RangeCustom.new(1, 2)
                         range2 = RangeCustom.new(3, 4)
@@ -872,7 +870,7 @@ TESTCASE(pointer_of_ranges_wrong)
     .define_attr("y", &RangesTest::RangeCustom::y);
 
   m.define_module_function<int(*)(const RangesTest::RangeCustom*, int)>("sum_ranges_wrong", RangesTest::sumRanges,
-                                  Arg("ranges").setBuffer());
+                                  ArgBuffer("ranges"));
 
   std::string code = R"(range1 = RangeCustom.new(1, 2)
                         range2 = RangeCustom.new(3, 4)
@@ -897,7 +895,7 @@ TESTCASE(pointer_of_pointer_ranges)
     .define_attr("x", &RangesTest::RangeCustom::x)
     .define_attr("y", &RangesTest::RangeCustom::y);
 
-  m.define_module_function<int(*)(const RangesTest::RangeCustom**, int)>("sum_ranges", RangesTest::sumRanges, Arg("ranges").setBuffer());
+  m.define_module_function<int(*)(const RangesTest::RangeCustom**, int)>("sum_ranges", RangesTest::sumRanges, ArgBuffer("ranges"));
 
   std::string code = R"(range1 = RangeCustom.new(1, 2)
                         range2 = RangeCustom.new(3, 4)
@@ -908,3 +906,4 @@ TESTCASE(pointer_of_pointer_ranges)
   Object result = m.module_eval(code);
   ASSERT_EQUAL(21, detail::From_Ruby<int>().convert(result));
 }
+*/

data/test/test_Director.cpp

@@ -85,10 +85,9 @@ namespace {
         return detail::From_Ruby<int>().convert( getSelf().call("process", num) );
       }
 
-      int default_process(int num)
+      int default_process(int)
       {
         raisePureVirtual();
-        return 0;
       }
 
       virtual int doSomething(int num)
@@ -222,10 +221,9 @@ namespace {
         return detail::From_Ruby<int>().convert( getSelf().call("do_it_impl", in) );
       }
 
-      int default_doItImpl(int in)
+      int default_doItImpl(int)
       {
         raisePureVirtual();
-        return 0;
       }
   };
 

data/test/test_Enum.cpp

@@ -76,7 +76,7 @@ TESTCASE(values)
   std::string code = R"(Color.values)";
 
   Array a = m.module_eval(code);
-  ASSERT_EQUAL(3u, a.size());
+  ASSERT_EQUAL(3, a.size());
 
   Data_Object<Color> enum_0(a[0]);
   ASSERT_EQUAL(RED, *enum_0);
@@ -96,7 +96,7 @@ TESTCASE(seasons_values)
   std::string code = R"(Season.values)";
 
   Array a = m.module_eval(code);
-  ASSERT_EQUAL(4u, a.size());
+  ASSERT_EQUAL(4, a.size());
 
   Data_Object<Season> enum_0(a[0]);
   ASSERT_EQUAL(Season::Spring, *enum_0);
@@ -198,8 +198,33 @@ TESTCASE(eql)
   Module m = define_module("Testing");
 
   Enum<Color> colorEnum = define_color_enum();
-  ASSERT_EQUAL(detail::to_ruby(false), m.module_eval("Color::RED == Color::BLACK").value());
-  ASSERT_EQUAL(detail::to_ruby(true), m.module_eval("Color::GREEN == Color::GREEN").value());
+  ASSERT_EQUAL(Qfalse, m.module_eval("Color::RED == Color::BLACK").value());
+  ASSERT_EQUAL(Qtrue, m.module_eval("Color::GREEN == Color::GREEN").value());
+}
+
+TESTCASE(case_eql)
+{
+  Module m = define_module("Testing");
+
+  Enum<Color> colorEnum = define_color_enum();
+
+ /* Object result = m.module_eval("Color::RED === Color::BLACK");
+  ASSERT_EQUAL(Qfalse, result.value());
+
+  result = m.module_eval("Color::GREEN === Color::GREEN");
+  ASSERT_EQUAL(Qtrue, result.value());*/
+
+  Object result = m.module_eval("Color::RED === 0");
+  ASSERT_EQUAL(Qtrue, result.value());
+  
+  result = m.module_eval("0 == Color::RED");
+  ASSERT_EQUAL(Qtrue, result.value());
+
+  result = m.module_eval("Color::RED === 1");
+  ASSERT_EQUAL(Qfalse, result.value());
+
+  result = m.module_eval("1 == Color::RED");
+  ASSERT_EQUAL(Qfalse, result.value());
 }
 
 TESTCASE(compare_equal)
@@ -207,8 +232,12 @@ TESTCASE(compare_equal)
   Enum<Color> colorEnum = define_color_enum();
   Object color1 = colorEnum.const_get("RED");
   Object color2 = colorEnum.const_get("RED");
+
   Object result = color1.call("<=>", color2);
   ASSERT_EQUAL(0, detail::From_Ruby<int>().convert(result));
+
+  result = color1.call("<=>", 0);
+  ASSERT_EQUAL(0, detail::From_Ruby<int>().convert(result));
 }
 
 TESTCASE(compare_less)
@@ -398,7 +427,7 @@ namespace
 {
   enum class Undefined { A, B, C };
 
-  void undefinedArg(Undefined undefined)
+  void undefinedArg(Undefined)
   {
   }
 

data/test/test_File.cpp

@@ -26,6 +26,12 @@ namespace
   {
     std::filesystem::path path = __FILE__;
     FILE* fptr = fopen(path.string().c_str(), "rb");
+    if (!fptr)
+    {
+      int err = errno;
+      throw std::runtime_error("Failed to open file '" + path.string() + "': " +
+        std::strerror(err) + " (errno=" + std::to_string(err) + ")");
+    }
     return fptr;
   }
 
@@ -41,12 +47,10 @@ namespace
     return result.str();
   }
 
-  bool closeFile(FILE* fptr)
+  bool closeFile(FILE*)
   {
-    // Ruby override fclose and replaces it with rb_w32_fclose which causes a segementation fault. Oy!
-#ifndef _MSC_VER
-    fclose(fptr);
-#endif
+    // crashes on windows due to Ruby overriding and mixing UCRTs
+    //fclose(fptr);
     return true;
   }
 }

data/test/test_From_Ruby.cpp

@@ -83,7 +83,7 @@ TESTCASE(bool)
 {
   ASSERT_EQUAL(detail::Convertible::Exact, detail::From_Ruby<bool>().is_convertible(Qfalse));
   ASSERT_EQUAL(detail::Convertible::Exact, detail::From_Ruby<bool>().is_convertible(Qtrue));
-  ASSERT_EQUAL(detail::Convertible::Cast, detail::From_Ruby<bool>().is_convertible(Qnil));
+  ASSERT_EQUAL(detail::Convertible::Exact, detail::From_Ruby<bool>().is_convertible(Qnil));
   ASSERT_EQUAL(detail::Convertible::None, detail::From_Ruby<bool>().is_convertible(INT2NUM(3)));
   ASSERT_EQUAL(detail::Convertible::None, detail::From_Ruby<bool>().is_convertible(rb_float_new(3.33)));
   ASSERT_EQUAL(detail::Convertible::None, detail::From_Ruby<bool>().is_convertible(rb_str_new2("some string")));
@@ -327,6 +327,7 @@ TESTCASE(unsigned_char_pointer_array)
 
 TESTCASE(double)
 {
+#undef min
   ASSERT_EQUAL(0.0, detail::From_Ruby<double>().convert(rb_float_new(0.0)));
   ASSERT_EQUAL(-1.0, detail::From_Ruby<double>().convert(rb_float_new(-1.0)));
   ASSERT_EQUAL(1.0, detail::From_Ruby<double>().convert(rb_float_new(1.0)));
@@ -414,7 +415,7 @@ TESTCASE(float_array_array)
 {
   Module m = define_module("Testing");
 
-  m.define_singleton_function("array_array_to_string", &arrayofArraysToString<float>, Arg("buffer").setBuffer());
+  m.define_singleton_function("array_array_to_string", &arrayofArraysToString<float>, ArgBuffer("buffer"));
 
   std::string code = R"(buffer = Rice::Buffer≺float∗≻.new([[1.1, 2.2], [3.3, 4.4], [5.5, 6.6]])
                         array_array_to_string(buffer.data, buffer.size, 2))";
@@ -517,7 +518,7 @@ 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(static_cast<unsigned long>(FIXNUM_MIN),
+  ASSERT_EQUAL((unsigned long)(FIXNUM_MIN),
     detail::From_Ruby<unsigned long>().convert(ULONG2NUM(FIXNUM_MIN)));
   ASSERT_EQUAL(std::numeric_limits<unsigned long>::min(),
     detail::From_Ruby<unsigned long>().convert(ULONG2NUM(std::numeric_limits<unsigned long>::min())));

data/test/test_GVL.cpp

@@ -44,7 +44,7 @@ namespace
       {
       }
 
-      int run(bool arg1)
+      int run(bool)
       {
         std::this_thread::sleep_for(std::chrono::milliseconds(100));
         return this->id_;
@@ -64,7 +64,7 @@ TESTCASE(Function)
 TESTCASE(FunctionViaRuby)
 {
   Module m = define_module("Testing");
-  m.define_module_function("slow_function_1", &slowFunction1, Function().setNoGvl());
+  m.define_module_function("slow_function_1", &slowFunction1, NoGVL());
   
   std::string code = R"(slow_function_1)";
   Object result = m.module_eval(code);
@@ -99,7 +99,7 @@ TESTCASE(MemberFunctionNoGvl)
 
   Class task = define_class_under<Task>(m, "Task")
     .define_constructor(Constructor<Task, int>())
-    .define_method("run", &Task::run, Function().setNoGvl());
+    .define_method("run", &Task::run, NoGVL());
 
   std::string code = R"(task = Task.new(85)
                         task.run(true))";

data/test/test_Hash.cpp

@@ -210,7 +210,7 @@ TESTCASE(iterate_and_change)
  */
 
 namespace {
-  void testHashArg(Object self, Hash string) {
+  void testHashArg(Object, Hash) {
   }
 }
 

data/test/test_Iterator.cpp

@@ -50,7 +50,7 @@ TESTCASE(define_array_iterator)
   Object wrapped_container = Data_Object<Container>(container);
 
   Array a = wrapped_container.instance_eval("a = []; each() { |x| a << x }; a");
-  ASSERT_EQUAL(3u, a.size());
+  ASSERT_EQUAL(3, a.size());
   ASSERT_EQUAL(Object(detail::to_ruby(1)), a[0]);
   ASSERT_EQUAL(Object(detail::to_ruby(2)), a[1]);
   ASSERT_EQUAL(Object(detail::to_ruby(3)), a[2]);
@@ -152,16 +152,16 @@ TESTCASE(iterator_value)
   Data_Object<ContainerValues> wrapper(container);
 
   Array a = wrapper.instance_eval("each.to_a");
-  ASSERT_EQUAL(3u, a.size());
+  ASSERT_EQUAL(3, a.size());
 
   Data_Object<Data> wrappedData(a[0]);
-  ASSERT_EQUAL(1, wrappedData->index);
+  ASSERT_EQUAL(1u, wrappedData->index);
 
   wrappedData = (Data_Object<Data>)a[1];
-  ASSERT_EQUAL(2, wrappedData->index);
+  ASSERT_EQUAL(2u, wrappedData->index);
 
   wrappedData = (Data_Object<Data>)a[2];
-  ASSERT_EQUAL(3, wrappedData->index);
+  ASSERT_EQUAL(3u, wrappedData->index);
 }
 
 TESTCASE(const_iterator_value)
@@ -185,13 +185,13 @@ TESTCASE(const_iterator_value)
   Array a = m.module_eval(code);
 
   Data_Object<Data> wrappedData(a[0]);
-  ASSERT_EQUAL(1, wrappedData->index);
+  ASSERT_EQUAL(1u, wrappedData->index);
 
   wrappedData = (Data_Object<Data>)a[1];
-  ASSERT_EQUAL(2, wrappedData->index);
+  ASSERT_EQUAL(2u, wrappedData->index);
 
   wrappedData = (Data_Object<Data>)a[2];
-  ASSERT_EQUAL(3, wrappedData->index);
+  ASSERT_EQUAL(3u, wrappedData->index);
 }
 
 TESTCASE(iterator_pointer)
@@ -218,13 +218,13 @@ TESTCASE(iterator_pointer)
   Array a = m.module_eval(code);
 
   Data_Object<Data> wrappedData(a[0]);
-  ASSERT_EQUAL(1, wrappedData->index);
+  ASSERT_EQUAL(1u, wrappedData->index);
 
   wrappedData = (Data_Object<Data>)a[1];
-  ASSERT_EQUAL(2, wrappedData->index);
+  ASSERT_EQUAL(2u, wrappedData->index);
 
   wrappedData = (Data_Object<Data>)a[2];
-  ASSERT_EQUAL(3, wrappedData->index);
+  ASSERT_EQUAL(3u, wrappedData->index);
 }
 
 TESTCASE(two_iterator_pointer)
@@ -254,25 +254,25 @@ TESTCASE(two_iterator_pointer)
 
   Array a = m.module_eval(code);
 
-  ASSERT_EQUAL(6u, a.size());
+  ASSERT_EQUAL(6, a.size());
 
   Data_Object<Data> wrappedData(a[0]);
-  ASSERT_EQUAL(1, wrappedData->index);
+  ASSERT_EQUAL(1u, wrappedData->index);
 
   wrappedData = (Data_Object<Data>)a[1];
-  ASSERT_EQUAL(2, wrappedData->index);
+  ASSERT_EQUAL(2u, wrappedData->index);
 
   wrappedData = (Data_Object<Data>)a[2];
-  ASSERT_EQUAL(3, wrappedData->index);
+  ASSERT_EQUAL(3u, wrappedData->index);
 
   wrappedData = (Data_Object<Data>)a[3];
-  ASSERT_EQUAL(3, wrappedData->index);
+  ASSERT_EQUAL(3u, wrappedData->index);
 
   wrappedData = (Data_Object<Data>)a[4];
-  ASSERT_EQUAL(2, wrappedData->index);
+  ASSERT_EQUAL(2u, wrappedData->index);
 
   wrappedData = (Data_Object<Data>)a[5];
-  ASSERT_EQUAL(1, wrappedData->index);
+  ASSERT_EQUAL(1u, wrappedData->index);
 }
 
 TESTCASE(map)
@@ -293,7 +293,7 @@ TESTCASE(map)
                         end)";
 
   Array a = m.module_eval(code);
-  ASSERT_EQUAL(3u, a.size());
+  ASSERT_EQUAL(3, a.size());
 
   Object element = a[0];
   ASSERT_EQUAL(2, detail::From_Ruby<int>().convert(element));
@@ -323,7 +323,7 @@ TESTCASE(to_enum)
 
   Array a = m.module_eval(code);
 
-  ASSERT_EQUAL(3u, a.size());
+  ASSERT_EQUAL(3, a.size());
 
   Object element = a[0];
   ASSERT_EQUAL(2, detail::From_Ruby<int>().convert(element));
@@ -335,6 +335,38 @@ TESTCASE(to_enum)
   ASSERT_EQUAL(6, detail::From_Ruby<int>().convert(element));
 }
 
+TESTCASE(to_a)
+{
+  define_class<Data>("Data")
+    .define_constructor(Constructor<Data, uint32_t>())
+    .define_attr("index", &Data::index, Rice::AttrAccess::Read);
+
+  define_class<ContainerPointers>("ContainerPointers")
+    .define_constructor(Constructor<ContainerPointers>())
+    .define_iterator(&ContainerPointers::begin, &ContainerPointers::end);
+
+  Module m = define_module("TestingModule");
+
+  std::string code = R"(container = ContainerPointers.new
+                        container.to_a)";
+
+  Array a = m.module_eval(code);
+
+  ASSERT_EQUAL(3, a.size());
+
+  Object element = a[0];
+  Object index = element.call("index");
+  ASSERT_EQUAL(1, detail::From_Ruby<int>().convert(index));
+
+  element = a[1];
+  index = element.call("index");
+  ASSERT_EQUAL(2, detail::From_Ruby<int>().convert(index));
+
+  element = a[2];
+  index = element.call("index");
+  ASSERT_EQUAL(3, detail::From_Ruby<int>().convert(index));
+}
+
 TESTCASE(IterateNoCopy)
 {
   define_class<Data>("Data")
@@ -355,7 +387,7 @@ TESTCASE(IterateNoCopy)
   for (size_t i = 0; i < container.data_.size(); i++)
   {
     Data& expected = container.data_[i];
-    Data_Object<Data> actual(a[i]);
+    Data_Object<Data> actual(a[(long)i]);
     ASSERT_EQUAL(&expected, &(*actual));
   }
-}
+}

data/test/test_Keep_Alive.cpp

@@ -131,7 +131,7 @@ namespace
   };
 }
 
-Object getColumn(Module& m, uint32_t index)
+Object getColumn(Module& m, uint32_t)
 {
   Object connection = m.module_eval("Connection.new");
   return connection.call("getColumn", 3);

data/test/test_Keep_Alive_No_Wrapper.cpp

@@ -80,7 +80,7 @@ TESTCASE(test_keep_alive_no_wrapper)
   ASSERT_EXCEPTION_CHECK(
     Exception,
     m.module_eval("@zoo.get_pets.each do |pet| puts pet.name; end"),
-    ASSERT_EQUAL("When calling the method `get_pets' we could not find the wrapper for the 'Array' return type. You should not use keepAlive() on a Return or Arg that is a builtin Rice type.",
+    ASSERT_EQUAL("wrong argument type Array (expected wrapped C++ object)",
                  ex.what())
   );
 }

data/test/test_Module.cpp

@@ -53,27 +53,27 @@ namespace
     return i;
   }
 
-  int method_int(Object object, int i)
+  int method_int(Object, int i)
   {
     return i;
   }
 
-  bool method_lvalue(MyClass& myClass)
+  bool method_lvalue(MyClass&)
   {
     return true;
   }
 
-  bool method_rvalue(MyClass&& myClass)
+  bool method_rvalue(MyClass&&)
   {
     return true;
   }
 
-  void method_lvalue_return_void(int a, MyClass& myClass)
+  void method_lvalue_return_void(int, MyClass&)
   {
     // Do nothing
   }
 
-  void method_rvalue_return_void(int b, MyClass&& myClass)
+  void method_rvalue_return_void(int, MyClass&&)
   {
     // Do nothing
   }