rice 4.7.1 → 4.8.0

data/test/test_Overloads.cpp

@@ -28,6 +28,8 @@ TEARDOWN(Overloads)
   Rice::detail::Registries::instance.types.remove<MyClass>();
   Rice::detail::Registries::instance.types.remove<MyClass2>();
   Rice::detail::Registries::instance.types.remove<MyClass3>();
+  Rice::detail::Registries::instance.natives.reset(Module(rb_mKernel));
+
   rb_gc_start();
 }
 
@@ -116,31 +118,62 @@ namespace
     return "run<void>";
   }
 
-  std::string run(int a)
+  std::string run(int)
   {
     return "run<int>";
   }
 
-  std::string run(float a)
+  std::string run(float)
   {
     return "run<float>";
   }
 
-  std::string run(std::string a)
+  std::string run(std::string)
   {
     return "run<string>";
   }
 
-  std::string run(int a, float b = 1.0)
+  std::string run(int, float = 1.0)
   {
     return "run<int,float>";
   }
 
-  std::string run(float a, int b = 1)
+  std::string run(float, int = 1)
   {
     return "run<float,int>";
   }
-} // namespace
+
+  // Signed vs unsigned overloads
+  std::string run(unsigned int)
+  {
+    return "run<unsigned int>";
+  }
+
+  std::string run(short)
+  {
+    return "run<short>";
+  }
+
+  std::string run(unsigned short)
+  {
+    return "run<unsigned short>";
+  }
+
+  std::string run(long long)
+  {
+    return "run<long long>";
+  }
+
+  std::string run(unsigned long long)
+  {
+    return "run<unsigned long long>";
+  }
+
+  std::string run(double)
+  {
+    return "run<double>";
+  }
+}
 
 void create_globals()
 {
@@ -212,27 +245,27 @@ namespace
       return "run<void>";
     }
 
-    std::string run(int a)
+    std::string run(int)
     {
       return "run<int>";
     }
 
-    std::string run(float a)
+    std::string run(float)
     {
       return "run<float>";
     }
 
-    std::string run(std::string a)
+    std::string run(std::string)
     {
       return "run<string>";
     }
 
-    std::string run(int a, float b = 1.0)
+    std::string run(int, float = 1.0)
     {
       return "run<int,float>";
     }
 
-    std::string run(float a, int b = 1)
+    std::string run(float, int = 1)
     {
       return "run<float,int>";
     }
@@ -321,10 +354,10 @@ TESTCASE(invalid_parameters)
 
   std::string expected = R"(Could not resolve method call for MyClass#run
   6 overload(s) were evaluated based on the types of Ruby parameters provided:
-     std::string AnonymousNamespace::MyClass*::run(int, float)
-     std::string AnonymousNamespace::MyClass*::run(float, int)
      std::string AnonymousNamespace::MyClass*::run()
      std::string AnonymousNamespace::MyClass*::run(std::string)
+     std::string AnonymousNamespace::MyClass*::run(int, float)
+     std::string AnonymousNamespace::MyClass*::run(float, int)
      std::string AnonymousNamespace::MyClass*::run(int)
      std::string AnonymousNamespace::MyClass*::run(float))";
 
@@ -344,27 +377,27 @@ namespace
       this->constructor = "constructor<void>";
     }
 
-    MyClass2(int a)
+    MyClass2(int)
     {
       this->constructor = "constructor<int>";
     }
 
-    MyClass2(float a)
+    MyClass2(float)
     {
       this->constructor = "constructor<float>";
     }
 
-    MyClass2(std::string a)
+    MyClass2(std::string)
     {
       this->constructor = "constructor<string>";
     }
 
-    MyClass2(int a, float b)
+    MyClass2(int, float)
     {
       this->constructor = "constructor<int,float>";
     }
 
-    MyClass2(float a, int b)
+    MyClass2(float, int)
     {
       this->constructor = "constructor<float,int>";
     }
@@ -446,55 +479,65 @@ namespace
   class MyClass3
   {
   public:
-    std::string run(char value)
+    std::string run(char)
     {
       return "run<char>";
     }
 
-    std::string run(unsigned char value)
+    std::string run(unsigned char)
     {
       return "run<unsigned char>";
     }
 
-    std::string run(char* value)
+    std::string run(char*)
     {
       return "run<char*>";
     }
 
-    std::string run(unsigned char* value)
+    std::string run(unsigned char*)
     {
       return "run<unsigned char*>";
     }
 
-    std::string run(short value)
+    std::string run(short)
     {
       return "run<short>";
     }
 
-    std::string run(int value)
+    std::string run(int)
     {
       return "run<int>";
     }
 
-    std::string run(float value)
+    std::string run(float)
     {
       return "run<float>";
     }
 
-    std::string run(double value)
+    std::string run(double)
     {
       return "run<double>";
     }
 
-    std::string run(long value)
+    std::string run(long)
     {
       return "run<long>";
     }
 
-    std::string run(long long value)
+    std::string run(long long)
     {
       return "run<long long>";
     }
+
+    std::string run(int&)
+    {
+      return "run<int&>";
+    }
+
+    std::string run(int*)
+    {
+      return "run<int*>";
+    }
   };
 } // namespace
 
@@ -515,7 +558,15 @@ TESTCASE(int_conversion_1)
                         value = 1
                         my_class.run(value))";
   String result = m.module_eval(code);
-  ASSERT_EQUAL("run<long>", result.str());
+
+  if constexpr (sizeof(long) == sizeof(int))
+  {
+    ASSERT_EQUAL("run<long long>", result.str());
+  }
+  else
+  {
+    ASSERT_EQUAL("run<long>", result.str());
+  }
 
   code = R"(my_class = MyClass3.new
             value = 2**60
@@ -529,6 +580,33 @@ TESTCASE(int_conversion_1)
 #endif
 
   ASSERT_EQUAL(expected, result.str());
+
+  code = R"(my_class = MyClass3.new
+            value = 2**64
+            my_class.run(value))";
+
+#ifdef _MSC_VER 
+  std::string expected2 = R"(Could not resolve method call for MyClass3#run
+  5 overload(s) were evaluated based on the types of Ruby parameters provided:
+     std::string AnonymousNamespace::MyClass3*::run(char*)
+     std::string AnonymousNamespace::MyClass3*::run(unsigned char*)
+     std::string AnonymousNamespace::MyClass3*::run(short)
+     std::string AnonymousNamespace::MyClass3*::run(long)
+     std::string AnonymousNamespace::MyClass3*::run(__int64))";
+#else
+  std::string expected2 = R"(Could not resolve method call for MyClass3#run
+  5 overload(s) were evaluated based on the types of Ruby parameters provided:
+     std::string AnonymousNamespace::MyClass3*::run(char*)
+     std::string AnonymousNamespace::MyClass3*::run(unsigned char*)
+     std::string AnonymousNamespace::MyClass3*::run(short)
+     std::string AnonymousNamespace::MyClass3*::run(long)
+     std::string AnonymousNamespace::MyClass3*::run(long long))";
+#endif
+
+  ASSERT_EXCEPTION_CHECK(
+    Exception,
+    result = m.module_eval(code),
+    ASSERT_EQUAL(expected2, ex.what()));
 }
 
 TESTCASE(int_conversion_2)
@@ -544,21 +622,14 @@ TESTCASE(int_conversion_2)
                         value = 1
                         my_class.run(value))";
   String result = m.module_eval(code);
-  ASSERT_EQUAL("run<float>", result.str());
+  ASSERT_EQUAL("run<short>", result.str());
 
   code = R"(my_class = MyClass3.new
             value = 2**64
             my_class.run(value))";
 
-  std::string expected = R"(Could not resolve method call for MyClass3#run
-  2 overload(s) were evaluated based on the types of Ruby parameters provided:
-     std::string AnonymousNamespace::MyClass3*::run(short)
-     std::string AnonymousNamespace::MyClass3*::run(float))";
-
-  ASSERT_EXCEPTION_CHECK(
-    Exception,
-    result = m.module_eval(code),
-    ASSERT_EQUAL(expected.c_str(), ex.what()));
+  result = m.module_eval(code);
+  ASSERT_EQUAL("run<float>", result.str());
 }
 
 TESTCASE(int_conversion_3)
@@ -647,7 +718,7 @@ TESTCASE(int_conversion_6)
   Class c = define_class<MyClass3>("MyClass3").
     define_constructor(Constructor<MyClass3>()).
     define_method<std::string(MyClass3::*)(unsigned char)>("run", &MyClass3::run).
-    define_method<std::string(MyClass3::*)(unsigned char*)>("run", &MyClass3::run, Arg("value").setBuffer());
+    define_method<std::string(MyClass3::*)(unsigned char*)>("run", &MyClass3::run, ArgBuffer("value"));
 
   Module m = define_module("Testing");
 
@@ -658,6 +729,28 @@ TESTCASE(int_conversion_6)
   ASSERT_EQUAL("run<unsigned char*>", result.str());
 }
 
+TESTCASE(int_conversion_7)
+{
+  Class c = define_class<MyClass3>("MyClass3").
+    define_constructor(Constructor<MyClass3>()).
+    define_method<std::string(MyClass3::*)(int&)>("run", &MyClass3::run).
+    define_method<std::string(MyClass3::*)(int*)>("run", &MyClass3::run);
+
+  Module m = define_module("Testing");
+
+  std::string code = R"(my_class = MyClass3.new
+                        buffer = Rice::Buffer≺int≻.new("99")
+                        my_class.run(buffer.data))";
+  String result = m.module_eval(code);
+  ASSERT_EQUAL("run<int*>", result.str());
+
+  code = R"(my_class = MyClass3.new
+            ref = Rice::Reference≺int≻.new(99)
+            my_class.run(ref))";
+  result = m.module_eval(code);
+  ASSERT_EQUAL("run<int&>", result.str());
+}
+
 namespace
 {
   class MyClass4
@@ -679,12 +772,12 @@ namespace
   class MyClass5
   {
   public:
-    MyClass5(MyClass4& class4)
+    MyClass5(MyClass4&)
     {
       this->result = "non-const ref";
     }
 
-    MyClass5(const MyClass4& class4)
+    MyClass5(const MyClass4&)
     {
       this->result = "const ref";
     }
@@ -753,12 +846,12 @@ namespace
   class MyClass7
   {
   public:
-    MyClass7(MyClass6* class6)
+    MyClass7(MyClass6*)
     {
       this->result = "non-const pointer";
     }
 
-    MyClass7(const MyClass6* class6)
+    MyClass7(const MyClass6*)
     {
       this->result = "const pointer";
     }
@@ -807,12 +900,12 @@ TESTCASE(ConstPointer)
 
 namespace
 {
-  std::string pointer(const MyClass6* data)
+  std::string pointer(const MyClass6*)
   {
     return "pointer";
   }
 
-  std::string pointer(MyClass6* data)
+  std::string pointer(MyClass6*)
   {
     return "pointerBuffer";
   }
@@ -826,7 +919,7 @@ TESTCASE(PointerNotBuffer)
     define_constructor(Constructor<MyClass6>());
 
   m.define_module_function<std::string(*)(const MyClass6*)>("pointer", pointer).
-    define_module_function<std::string(*)(MyClass6*)>("pointer", pointer, Arg("data").setBuffer());
+    define_module_function<std::string(*)(MyClass6*)>("pointer", pointer, ArgBuffer("data"));
 
   std::string code = R"(my_class6 = MyClass6.new
                         pointer(my_class6))";
@@ -843,7 +936,7 @@ TESTCASE(PointerBuffer)
     define_constructor(Constructor<MyClass6>());
 
   m.define_function<std::string(*)(const MyClass6*)>("pointer", pointer).
-    define_function<std::string(*)(MyClass6*)>("pointer", pointer, Arg("data").setBuffer());
+    define_function<std::string(*)(MyClass6*)>("pointer", pointer, ArgBuffer("data"));
 
   std::string code = R"(my_class6 = MyClass6.new
                         buffer = Rice::Buffer≺AnonymousNamespace꞉꞉MyClass6≻.new(my_class6)
@@ -852,3 +945,207 @@ TESTCASE(PointerBuffer)
   String result = m.module_eval(code);
   ASSERT_EQUAL("pointerBuffer", result.str());
 }
+
+namespace
+{
+  class Pixel
+  {
+  public:
+    Pixel(uint32_t rgb)
+    {
+      this->rgb = rgb;
+    }
+
+    Pixel(uint8_t red, uint8_t green, uint8_t blue)
+    {
+      this->rgb = (red << 16) | (green << 8) | blue;
+    }
+
+    uint32_t rgb = 0;
+  };
+}
+
+TESTCASE(FloatToIntConversionWithOverload)
+{
+  Module m = define_module("Testing");
+
+  // Define overloaded functions: one takes int, one takes no args
+  // There is NO float overload
+  m.define_module_function("hello_int_resolve", [](int x) -> int { return x; });
+  m.define_module_function("hello_int_resolve", []() -> int { return 0; });
+
+  // Calling with an integer should work
+  std::string code = R"(hello_int_resolve(1))";
+  Object result = m.module_eval(code);
+  ASSERT_EQUAL(1, detail::From_Ruby<int>().convert(result.value()));
+
+  // Calling with no args should work
+  code = R"(hello_int_resolve())";
+  result = m.module_eval(code);
+  ASSERT_EQUAL(0, detail::From_Ruby<int>().convert(result.value()));
+
+  // Calling with a float should convert to int (lossy but allowed)
+  code = R"(hello_int_resolve(1.7))";
+  result = m.module_eval(code);
+  ASSERT_EQUAL(1, detail::From_Ruby<int>().convert(result.value()));
+}
+
+TESTCASE(Keywords)
+{
+  Module m = define_module("Testing");
+
+  define_class<Pixel>("Pixel").
+    define_constructor(Constructor<Pixel, uint32_t>()).
+    define_constructor(Constructor<Pixel, uint8_t, uint8_t, uint8_t>(), Arg("red"), Arg("green"), Arg("blue")).
+    define_attr("rgb", &Pixel::rgb);
+
+  std::string code = R"(pixel = Pixel.new(0xFFFFFF)
+                        pixel.rgb)";
+
+  Object result = m.module_eval(code);
+  ASSERT_EQUAL(0xFFFFFFull, detail::From_Ruby<size_t>().convert(result.value()));
+
+  code = R"(pixel = Pixel.new(128, 128, 128)
+            pixel.rgb)";
+
+  result = m.module_eval(code);
+  ASSERT_EQUAL(0x808080ull, detail::From_Ruby<size_t>().convert(result.value()));
+
+  code = R"(pixel = Pixel.new(green: 80, red: 160, blue: 40)
+            pixel.rgb)";
+
+  result = m.module_eval(code);
+  ASSERT_EQUAL(0xA05028ull, detail::From_Ruby<size_t>().convert(result.value()));
+}
+
+// ========== Signed vs Unsigned Preference Tests ==========
+
+// Test: int should be preferred over unsigned int for Ruby Integer
+TESTCASE(SignedPreferredOverUnsigned_Int)
+{
+  Module m = define_module("Testing");
+
+  define_global_function<std::string(*)(int)>("run", &run);
+  define_global_function<std::string(*)(unsigned int)>("run", &run);
+
+  std::string code = R"(run(42))";
+  String result = m.module_eval(code);
+  ASSERT_EQUAL("run<int>", result.str());
+}
+
+// Test: short should be preferred over unsigned short for Ruby Integer
+TESTCASE(SignedPreferredOverUnsigned_Short)
+{
+  Module m = define_module("Testing");
+
+  define_global_function<std::string(*)(short)>("run", &run);
+  define_global_function<std::string(*)(unsigned short)>("run", &run);
+
+  std::string code = R"(run(42))";
+  String result = m.module_eval(code);
+  ASSERT_EQUAL("run<short>", result.str());
+}
+
+// Test: long long should be preferred over unsigned long long for Ruby Integer
+TESTCASE(SignedPreferredOverUnsigned_LongLong)
+{
+  Module m = define_module("Testing");
+
+  define_global_function<std::string(*)(long long)>("run", &run);
+  define_global_function<std::string(*)(unsigned long long)>("run", &run);
+
+  std::string code = R"(run(42))";
+  String result = m.module_eval(code);
+  ASSERT_EQUAL("run<long long>", result.str());
+}
+
+// Test: int should be preferred over float for Ruby Integer
+TESTCASE(IntPreferredOverFloat_ForInteger)
+{
+  Module m = define_module("Testing");
+
+  define_global_function<std::string(*)(int)>("run", &run);
+  define_global_function<std::string(*)(float)>("run", &run);
+
+  std::string code = R"(run(42))";
+  String result = m.module_eval(code);
+  ASSERT_EQUAL("run<int>", result.str());
+}
+
+// Test: float should be preferred over int for Ruby Float
+TESTCASE(FloatPreferredOverInt_ForFloat)
+{
+  Module m = define_module("Testing");
+
+  define_global_function<std::string(*)(int)>("run", &run);
+  define_global_function<std::string(*)(float)>("run", &run);
+
+  std::string code = R"(run(3.14))";
+  String result = m.module_eval(code);
+  ASSERT_EQUAL("run<float>", result.str());
+}
+
+// Test: unsigned int should be preferred over float for Ruby Integer (integers prefer integer types)
+TESTCASE(UnsignedIntPreferredOverFloat_ForInteger)
+{
+  Module m = define_module("Testing");
+
+  define_global_function<std::string(*)(unsigned int)>("run", &run);
+  define_global_function<std::string(*)(float)>("run", &run);
+
+  std::string code = R"(run(42))";
+  String result = m.module_eval(code);
+  ASSERT_EQUAL("run<unsigned int>", result.str());
+}
+
+// Test: double should be preferred over float for Ruby Float
+TESTCASE(DoublePreferredOverFloat_ForFloat)
+{
+  Module m = define_module("Testing");
+
+  define_global_function<std::string(*)(double)>("run", &run);
+  define_global_function<std::string(*)(float)>("run", &run);
+
+  std::string code = R"(run(3.14))";
+  String result = m.module_eval(code);
+  ASSERT_EQUAL("run<double>", result.str());
+}
+
+// Test: long long should be preferred over double for Ruby Integer
+TESTCASE(LongLongPreferredOverDouble_ForInteger)
+{
+  Module m = define_module("Testing");
+
+  define_global_function<std::string(*)(long long)>("run", &run);
+  define_global_function<std::string(*)(double)>("run", &run);
+
+  std::string code = R"(run(42))";
+  String result = m.module_eval(code);
+  ASSERT_EQUAL("run<long long>", result.str());
+}
+
+// Test: double should be preferred over long long for Ruby Float
+TESTCASE(DoublePreferredOverLongLong_ForFloat)
+{
+  Module m = define_module("Testing");
+
+  define_global_function<std::string(*)(long long)>("run", &run);
+  define_global_function<std::string(*)(double)>("run", &run);
+
+  std::string code = R"(run(3.14))";
+  String result = m.module_eval(code);
+  ASSERT_EQUAL("run<double>", result.str());
+}
+
+// Test: unsigned long long should be preferred over double for Ruby Integer (integers prefer integer types)
+TESTCASE(UnsignedLongLongPreferredOverDouble_ForInteger)
+{
+  Module m = define_module("Testing");
+
+  define_global_function<std::string(*)(unsigned long long)>("run", &run);
+  define_global_function<std::string(*)(double)>("run", &run);
+
+  std::string code = R"(run(42))";
+  String result = m.module_eval(code);
+  ASSERT_EQUAL("run<unsigned long long>", result.str());
+}

data/test/test_Proc.cpp

@@ -20,11 +20,24 @@ TEARDOWN(Proc)
 
 namespace
 {
+  int squareWithBlock(int i)
+  {
+    VALUE result = detail::protect(rb_yield, detail::To_Ruby<int>().convert(i));
+    return detail::From_Ruby<int>().convert(result);
+  }
+
+  int squareWithProc(int i, VALUE proc)
+  {
+    VALUE result = detail::protect(rb_funcall, proc, rb_intern("call"), 1, detail::To_Ruby<int>().convert(i));
+    return detail::From_Ruby<int>().convert(result);
+  }
+
   int square(int i)
   {
     return i * i;
   }
 
+  // Returns a function pointer that Ruby wraps in NativeProc
   auto squareProc()
   {
     return square;
@@ -42,3 +55,44 @@ TESTCASE(SquareProc)
   Object result = m.module_eval(code);
   ASSERT_EQUAL(81, detail::From_Ruby<int>().convert(result));
 }
+
+TESTCASE(SquareWithBlock)
+{
+  Module m = define_module("TestingModuleMakeBlock");
+  m.define_module_function("square_with_block", squareWithBlock);
+
+  std::string code = R"(square_with_block(7) do |i|
+                          i * i
+                        end)";
+
+  Object result = m.module_eval(code);
+  ASSERT_EQUAL(49, detail::From_Ruby<int>().convert(result));
+}
+
+TESTCASE(SquareWithCapturedBlock)
+{
+  Module m = define_module("TestingModuleMakeBlock");
+  m.define_module_function("square_with_captured_block", squareWithProc, Arg("i"), Arg("proc").setBlock());
+
+  std::string code = R"(square_with_captured_block(4) do |i|
+                          i * i
+                        end)";
+
+  Object result = m.module_eval(code);
+  ASSERT_EQUAL(16, detail::From_Ruby<int>().convert(result));
+}
+
+TESTCASE(SquareWithProc)
+{
+  Module m = define_module("TestingModuleMakeBlock");
+  m.define_module_function("square_with_proc", squareWithProc, Arg("i"), Arg("proc").setBlock());
+
+  std::string code = R"(proc = Proc.new do |i|
+                          i * i
+                        end
+                        square_with_proc(4, proc))";
+
+  Object result = m.module_eval(code);
+  ASSERT_EQUAL(16, detail::From_Ruby<int>().convert(result));
+}
+