rice 4.5.0 → 4.6.0

data/test/test_Data_Type.cpp

@@ -1,4 +1,4 @@
-#include <assert.h> 
+#include <assert.h> 
 
 #include "unittest.hpp"
 #include "embed_ruby.hpp"
@@ -19,7 +19,7 @@ TEARDOWN(Data_Type)
   Rice::detail::Registries::instance.types.clearUnverifiedTypes();
   rb_gc_start();
 }
-/*
+
 namespace
 {
   class MyClass
@@ -77,7 +77,7 @@ namespace
         std::to_string(f) + ", " + s + ", " + std::string(c) + ")";
     }
   };
-} // namespace
+}
 
 TESTCASE(methods_with_member_pointers)
 {
@@ -558,8 +558,6 @@ namespace
 
 TESTCASE(pointers)
 {
-  Class voidClass = define_class<void>("Void");
-
   Class helperClass = define_class<Helper>("Helper")
     .define_constructor(Constructor<Helper, int>())
     .define_method("value", &Helper::value);
@@ -593,9 +591,9 @@ TESTCASE(pointers)
   value = result.call("value");
   ASSERT_EQUAL(5, detail::From_Ruby<int>().convert(value));
 
-   helper = object.call("return_void_helper");
-   result = object.call("check_void_helper", helper);
-   ASSERT_EQUAL(Qtrue, result.value());
+  helper = object.call("return_void_helper");
+  result = object.call("check_void_helper", helper);
+  ASSERT_EQUAL(Qtrue, result.value());
 }
 
 namespace
@@ -618,7 +616,7 @@ namespace
     {
       BigObject** result = new BigObject*[size];
 
-      for (int i = 0; i < size; ++i)
+      for (size_t i = 0; i < size; ++i)
       {
         result[i] = new BigObject(i + 5);
       }
@@ -629,7 +627,7 @@ namespace
     {
       int result = 0;
 
-      for (int i = 0; i < size; i++)
+      for (size_t i = 0; i < size; i++)
       {
         result += bigObjects[i]->value;
       }
@@ -640,7 +638,7 @@ namespace
     {
       int result = 0;
 
-      for (int i = 0; i < size; i++)
+      for (size_t i = 0; i < size; i++)
       {
         result += bigObjects[i]->value;
       }
@@ -655,23 +653,35 @@ namespace
 
 TESTCASE(pointerToPointer)
 {
+  define_buffer<BigObject*>();
+
+  Module m = define_module("DataTypePointerToPointer");
+
   Class BigObjectClass = define_class<BigObject>("BigObject")
     .define_attr("value", &BigObject::value);
 
   Class ProcessorClass = define_class<Processor>("ProcessorClass")
     .define_constructor(Constructor<Processor>())
     .define_method("create", &Processor::createBigObjects)
-    .define_method("sum", &Processor::sumBigObjects)
-    .define_method("sum_const", &Processor::sumBigObjectsConst);
+    .define_method("sum", &Processor::sumBigObjects,
+                          Arg("bigObjects").setArray(), Arg("size"))
+    .define_method("sum_const", &Processor::sumBigObjectsConst,
+                                Arg("bigObjects").setArray(), Arg("size"));
 
-  size_t size = 2;
-  Data_Object<Processor> processor = ProcessorClass.call("new");
-  Data_Object<BigObject> bigObjects = processor.call("create", size);
+  std::string code = R"(count = 2
+                          processor = ProcessorClass.new
+                          big_objects = processor.create(count)
+                          processor.sum(big_objects, count))";
 
-  Object result = processor.call("sum", bigObjects, size);
+  Object result = m.module_eval(code);
   ASSERT_EQUAL(11, detail::From_Ruby<int>().convert(result));
 
-  result = processor.call("sum_const", bigObjects, size);
+  code = R"(count = 2
+              processor = ProcessorClass.new
+              big_objects = processor.create(count)
+              processor.sum_const(big_objects, count))";
+
+  result = m.module_eval(code);
   ASSERT_EQUAL(11, detail::From_Ruby<int>().convert(result));
 }
 
@@ -743,7 +753,7 @@ TESTCASE(not_defined)
     ASSERT_EQUAL(message, ex.what())
   );
 
-  m.define_module_function<void(*)(UnknownClass)>("undefined_arg_reference", &undefinedArg);
+  m.define_module_function<void(*)(UnknownClass&)>("undefined_arg_reference", &undefinedArg);
 
   ASSERT_EXCEPTION_CHECK(
     Rice::Exception,
@@ -756,52 +766,52 @@ TESTCASE(not_defined)
   // This actually works because we pass a nullptr
   m.call("undefined_arg_pointer", nullptr);
 }
-*/
-namespace
+
+namespace RangesTest
 {
-  class Range
+  class RangeCustom
   {
   public:
-    Range(int x, int y) : x(x), y(y)
+    RangeCustom(int x, int y) : x(x), y(y)
     {
     }
 
-    Range(const Range& other) = default;
+    RangeCustom(const RangeCustom& other) = default;
 
     int x;
     int y;
   };
 
-  int sumRangesArray(int size, Range ranges[])
+  int sumRangesArray(int size, RangeCustom ranges[])
   {
     int result = 0;
     for (int i = 0; i < size; i++)
     {
-      const Range& range = ranges[i];
+      const RangeCustom& range = ranges[i];
       result += range.x + range.y;
     }
 
     return result;
   }
 
-  int sumRanges(int size, const Range* ranges)
+  int sumRanges(int size, const RangeCustom* ranges)
   {
     int result = 0;
     for (int i = 0; i < size; i++)
     {
-      const Range& range = ranges[i];
+      const RangeCustom& range = ranges[i];
       result += range.x + range.y;
     }
 
     return result;
   }
 
-  int sumRanges(int size, const Range** ranges)
+  int sumRanges(int size, const RangeCustom** ranges)
   {
     int result = 0;
     for (int i = 0; i < size; i++)
     {
-      const Range* range = ranges[i];
+      const RangeCustom* range = ranges[i];
       result += range->x + range->y;
     }
 
@@ -811,22 +821,24 @@ namespace
 
 TESTCASE(array_of_ranges)
 {
-  Module m = define_module("ArrayOfRanges");
-
-  Class c = define_class_under<Range>(m, "Range")
-    .define_constructor(Constructor<Range, int, int>())
-    .define_attr("x", &Range::x)
-    .define_attr("y", &Range::y);
+  define_buffer<RangesTest::RangeCustom>();
 
-  m.define_module_function("sum_ranges", sumRangesArray);
+  Module m = define_module("CustomRanges");
 
-  std::string code = R"(range1 = Range.new(1, 2)
-                        range2 = Range.new(3, 4)
-                        range3 = Range.new(5, 6)
+  Class c = define_class_under<RangesTest::RangeCustom>(m, "RangeCustom")
+    .define_constructor(Constructor<RangesTest::RangeCustom, int, int>())
+    .define_attr("x", &RangesTest::RangeCustom::x)
+    .define_attr("y", &RangesTest::RangeCustom::y);
 
-                        ranges = [range1, range2, range3]
+  m.define_module_function("sum_ranges_array", RangesTest::sumRangesArray, 
+                                               Arg("size"), Arg("ranges[]").setArray());
 
-                        sum_ranges(ranges.count, ranges))";
+  std::string code = R"(range1 = RangeCustom.new(1, 2)
+                        range2 = RangeCustom.new(3, 4)
+                        range3 = RangeCustom.new(5, 6)
+            
+                        buffer = Rice::Buffer≺RangesTest꞉꞉RangeCustom≻.new([range1, range2, range3])
+                        sum_ranges_array(buffer.size, buffer))";
 
   Object result = m.module_eval(code);
   ASSERT_EQUAL(21, detail::From_Ruby<int>().convert(result));
@@ -834,45 +846,74 @@ TESTCASE(array_of_ranges)
 
 TESTCASE(pointer_of_ranges)
 {
-  Module m = define_module("PointerOfRanges");
+  define_buffer<RangesTest::RangeCustom>();
 
-  Class c = define_class_under<Range>(m, "Range")
-    .define_constructor(Constructor<Range, int, int>())
-    .define_attr("x", &Range::x)
-    .define_attr("y", &Range::y);
+  Module m = define_module("CustomRanges");
 
-  m.define_module_function<int(*)(int, const Range*)>("sum_ranges", sumRanges);
+  Class c = define_class_under<RangesTest::RangeCustom>(m, "RangeCustom")
+    .define_constructor(Constructor<RangesTest::RangeCustom, int, int>())
+    .define_attr("x", &RangesTest::RangeCustom::x)
+    .define_attr("y", &RangesTest::RangeCustom::y);
 
-  std::string code = R"(range1 = Range.new(1, 2)
-                        range2 = Range.new(3, 4)
-                        range3 = Range.new(5, 6)
+  m.define_module_function<int(*)(int, const RangesTest::RangeCustom*)>("sum_ranges", RangesTest::sumRanges,
+                                                                        Arg("size"), Arg("ranges*").setArray());
 
-                        ranges = [range1, range2, range3]
+  std::string code = R"(range1 = RangeCustom.new(1, 2)
+                        range2 = RangeCustom.new(3, 4)
+                        range3 = RangeCustom.new(5, 6)
 
-                        sum_ranges(ranges.count, ranges))";
+                        buffer = Rice::Buffer≺RangesTest꞉꞉RangeCustom≻.new([range1, range2, range3])
+                        sum_ranges(buffer.size, buffer))";
 
   Object result = m.module_eval(code);
   ASSERT_EQUAL(21, detail::From_Ruby<int>().convert(result));
 }
 
-TESTCASE(pointer_of_pointer_ranges)
+TESTCASE(pointer_of_ranges_wrong)
 {
-  Module m = define_module("PointerOfPointersOfRanges");
+  define_buffer<RangesTest::RangeCustom>();
 
-  Class c = define_class_under<Range>(m, "Range")
-    .define_constructor(Constructor<Range, int, int>())
-    .define_attr("x", &Range::x)
-    .define_attr("y", &Range::y);
+  Module m = define_module("CustomRanges");
+
+  Class c = define_class_under<RangesTest::RangeCustom>(m, "RangeCustom")
+    .define_constructor(Constructor<RangesTest::RangeCustom, int, int>())
+    .define_attr("x", &RangesTest::RangeCustom::x)
+    .define_attr("y", &RangesTest::RangeCustom::y);
+
+  m.define_module_function<int(*)(int, const RangesTest::RangeCustom*)>("sum_ranges_wrong", RangesTest::sumRanges);
+
+  std::string code = R"(range1 = RangeCustom.new(1, 2)
+                        range2 = RangeCustom.new(3, 4)
+                        range3 = RangeCustom.new(5, 6)
+
+                        buffer = Rice::Buffer≺RangesTest꞉꞉RangeCustom≻.new([range1, range2, range3])
+                        sum_ranges_wrong(buffer.size, buffer))";
+
+  ASSERT_EXCEPTION_CHECK(
+    Rice::Exception,
+    m.module_eval(code),
+    ASSERT_EQUAL("wrong argument type Rice::Buffer≺RangesTest꞉꞉RangeCustom≻ (expected CustomRanges::RangeCustom)", ex.what())
+  );
+}
+
+TESTCASE(pointer_of_pointer_ranges)
+{
+  define_buffer<RangesTest::RangeCustom*>();
 
-  m.define_module_function<int(*)(int, const Range**)>("sum_ranges", sumRanges);
+  Module m = define_module("CustomRanges");
 
-  std::string code = R"(range1 = Range.new(1, 2)
-                        range2 = Range.new(3, 4)
-                        range3 = Range.new(5, 6)
+  Class c = define_class_under<RangesTest::RangeCustom>(m, "RangeCustom")
+    .define_constructor(Constructor<RangesTest::RangeCustom, int, int>())
+    .define_attr("x", &RangesTest::RangeCustom::x)
+    .define_attr("y", &RangesTest::RangeCustom::y);
 
-                        ranges = [range1, range2, range3]
+  m.define_module_function<int(*)(int, const RangesTest::RangeCustom**)>("sum_ranges", RangesTest::sumRanges);
 
-                        sum_ranges(ranges.count, ranges))";
+  std::string code = R"(range1 = RangeCustom.new(1, 2)
+                        range2 = RangeCustom.new(3, 4)
+                        range3 = RangeCustom.new(5, 6)
+                        buffer = Rice::Buffer≺RangesTest꞉꞉RangeCustom≻.new([range1, range2, range3])
+                        sum_ranges(buffer.size, buffer))";
 
   Object result = m.module_eval(code);
   ASSERT_EQUAL(21, detail::From_Ruby<int>().convert(result));

data/test/test_Director.cpp

@@ -196,11 +196,15 @@ TESTCASE(polymorphic_calls_head_down_the_call_chain)
 
 namespace {
 
-  class CallsSelf {
+  class CallsSelf
+  {
     public:
-      virtual ~CallsSelf() { }
+      virtual ~CallsSelf()
+      {
+      }
 
-      int doIt(int in) {
+      int doIt(int in)
+      {
         return doItImpl(in); 
       }
 

data/test/test_Enum.cpp

@@ -20,7 +20,6 @@ TEARDOWN(Enum)
   rb_gc_start();
 }
 
-
 namespace
 {
   enum Color { RED, BLACK, GREEN };
@@ -164,7 +163,11 @@ TESTCASE(bitset_operators)
   Object value = m.module_eval(code);
   ASSERT_EQUAL(1, detail::From_Ruby<int>().convert(value));
 
-  code = R"(Season::Summer | Season::Fall)";
+  code = R"(Season::Spring | Season::Summer)";
+  value = m.module_eval(code);
+  ASSERT_EQUAL(1, detail::From_Ruby<int>().convert(value));
+
+  code = R"(Season::Spring | Season::Summer | Season::Fall)";
   value = m.module_eval(code);
   ASSERT_EQUAL(3, detail::From_Ruby<int>().convert(value));
 

data/test/test_File.cpp

@@ -25,7 +25,7 @@ namespace
   FILE* openFile()
   {
     std::filesystem::path path = __FILE__;
-    FILE* fptr = fopen(path.u8string().c_str(), "rb");
+    FILE* fptr = fopen(path.string().c_str(), "rb");
     return fptr;
   }