rice 4.3.2 → 4.5.0

data/test/test_Module.cpp

@@ -13,6 +13,11 @@ SETUP(Module)
   embed_ruby();
 }
 
+TEARDOWN(Module)
+{
+  rb_gc_start();
+}
+
 TESTCASE(FromConstant)
 {
   Module m(rb_mEnumerable);
@@ -27,59 +32,51 @@ TESTCASE(FromName)
 
 namespace
 {
+  class MyClass
+  {
+  public:
+    MyClass() = default;
+  };
 
-class Quite_Silly_Exception
-  : public std::exception
-{
-};
-
-void handle_silly_exception(Quite_Silly_Exception const & ex)
-{
-  throw Exception(rb_eRuntimeError, "SILLY");
-}
-
-void throw_silly_exception(Object self)
-{
-  throw Quite_Silly_Exception();
-}
-
-} // namespace
-
-TESTCASE(add_handler)
-{
-  register_handler<Quite_Silly_Exception>(handle_silly_exception);
+  bool some_function()
+  {
+    return true;
+  }
 
-  Module m(anonymous_module());
-  m.define_singleton_method("foo", throw_silly_exception);
-  Object exc = m.module_eval("begin; foo; rescue Exception; $!; end");
-  ASSERT_EQUAL(rb_eRuntimeError, CLASS_OF(exc));
-  Exception ex(exc);
-  ASSERT_EQUAL(String("SILLY"), String(ex.what()));
-}
+  Object some_method(Object o)
+  {
+    return o;
+  }
 
-namespace
-{
+  int function_int(int i)
+  {
+    return i;
+  }
 
-bool some_function()
-{
-  return true;
-}
+  int method_int(Object object, int i)
+  {
+    return i;
+  }
 
-Object some_method(Object o)
-{
-  return o;
-}
+  bool method_lvalue(MyClass& myClass)
+  {
+    return true;
+  }
 
-int function_int(int i)
-{
-  return i;
-}
+  bool method_rvalue(MyClass&& myClass)
+  {
+    return true;
+  }
 
-int method_int(Object object, int i)
-{
-  return i;
-}
+  void method_lvalue_return_void(int a, MyClass& myClass)
+  {
+    // Do nothing
+  }
 
+  void method_rvalue_return_void(int b, MyClass&& myClass)
+  {
+    // Do nothing
+  }
 } // namespace
 
 TESTCASE(define_method)
@@ -180,14 +177,18 @@ TESTCASE(method_int_passed_no_args)
 {
   Module m(anonymous_module());
   m.define_method("foo", method_int);
+
   ASSERT_EXCEPTION_CHECK(
       Exception,
       m.module_eval("o = Object.new; o.extend(self); o.foo"),
-      ASSERT_EQUAL(
-          Object(rb_eArgError),
-          Object(CLASS_OF(ex.value()))
-          )
+      ASSERT_EQUAL(Object(rb_eArgError), Object(CLASS_OF(ex.value())))
       );
+
+  ASSERT_EXCEPTION_CHECK(
+    Exception,
+    m.module_eval("o = Object.new; o.extend(self); o.foo"),
+    ASSERT_EQUAL("wrong number of arguments (given 0, expected 1)", ex.what())
+  );
 }
 
 TESTCASE(define_singleton_method_int_foo)
@@ -263,22 +264,28 @@ TESTCASE(default_arguments_still_throws_argument_error)
   m.define_function("foo", &defaults_method_one, Arg("arg1"), Arg("arg2") = 3, Arg("arg3") = true);
 
   ASSERT_EXCEPTION_CHECK(
-      Exception,
-      m.module_eval("o = Object.new; o.extend(self); o.foo()"),
-      ASSERT_EQUAL(
-          Object(rb_eArgError),
-          Object(CLASS_OF(ex.value()))
-          )
-      );
+    Exception,
+    m.module_eval("o = Object.new; o.extend(self); o.foo()"),
+    ASSERT_EQUAL(Object(rb_eArgError), Object(CLASS_OF(ex.value())))
+  );
 
   ASSERT_EXCEPTION_CHECK(
-      Exception,
-      m.module_eval("o = Object.new; o.extend(self); o.foo(3, 4, false, 17)"),
-      ASSERT_EQUAL(
-          Object(rb_eArgError),
-          Object(CLASS_OF(ex.value()))
-          )
-      );
+    Exception,
+    m.module_eval("o = Object.new; o.extend(self); o.foo()"),
+    ASSERT_EQUAL("wrong number of arguments (given 0, expected 1..3)", ex.what())
+  );
+
+  ASSERT_EXCEPTION_CHECK(
+    Exception,
+    m.module_eval("o = Object.new; o.extend(self); o.foo(3, 4, false, 17)"),
+    ASSERT_EQUAL(Object(rb_eArgError), Object(CLASS_OF(ex.value())))
+  );
+
+  ASSERT_EXCEPTION_CHECK(
+    Exception,
+    m.module_eval("o = Object.new; o.extend(self); o.foo(3, 4, false, 17)"),
+    ASSERT_EQUAL("wrong number of arguments (given 4, expected 1..3)", ex.what())
+  );
 }
 
 namespace {
@@ -515,4 +522,51 @@ TESTCASE(references)
   ASSERT_EQUAL(boolValue, true);
   ASSERT_EQUAL(floatValue, 43.0);
   ASSERT_EQUAL(doubleValue, 44.0);
-}
+}
+
+TESTCASE(lvalue_function)
+{
+  Module m(anonymous_module());
+  Class c = define_class<MyClass>("MyClass").
+            define_constructor(Constructor<MyClass>());
+
+  m.define_module_function("method_lvalue", &method_lvalue);
+  m.define_module_function("method_lvalue_return_void", &method_lvalue_return_void);
+
+  Object result = m.module_eval(R"(o = MyClass.new
+                                           method_lvalue_return_void(1, o)
+                                           method_lvalue(o))");
+
+  ASSERT_EQUAL(Qtrue, result.value());
+}
+
+TESTCASE(rvalue_function)
+{
+  Module m(anonymous_module());
+  Class c = define_class<MyClass>("MyClass").
+            define_constructor(Constructor<MyClass>());
+
+  m.define_module_function("method_rvalue", &method_rvalue);
+  m.define_module_function("method_rvalue_return_void", &method_rvalue_return_void);
+
+  Object result = m.module_eval(R"(o = MyClass.new
+                                       method_rvalue_return_void(1, o)
+                                       method_rvalue(o))");
+
+  ASSERT_EQUAL(Qtrue, result.value());
+}
+
+namespace {
+  namespace Constants {
+#define MY_PI 314
+  }
+}
+
+TESTCASE(constants)
+{
+  Module m = anonymous_module().
+             define_constant("MY_PI", MY_PI);
+
+  Object result = m.module_eval(R"(MY_PI)");
+  ASSERT_EQUAL(314, detail::From_Ruby<int>().convert(result.value()));
+}

data/test/test_Native_Registry.cpp

@@ -13,38 +13,7 @@ SETUP(NativeRegistry)
   embed_ruby();
 }
 
-TESTCASE(collisions)
+TEARDOWN(NativeRegistry)
 {
-  std::array<Class, 100> classes;
-  int scale = 1000;
-
-  for (int i = 0; i < std::size(classes); i++)
-  {
-    Class cls(anonymous_class());
-
-    for (int j = 0; j < scale; j++)
-    {
-      cls.define_function("int" + std::to_string(j), []() { return 1; });
-      cls.define_function("long" + std::to_string(j), []() { return 1L; });
-      cls.define_function("double" + std::to_string(j), []() { return 1.0; });
-      cls.define_function("float" + std::to_string(j), []() { return 1.0f; });
-      cls.define_function("bool" + std::to_string(j), []() { return true; });
-    }
-
-    classes[i] = cls;
-  }
-
-  for (auto& cls : classes)
-  {
-    auto obj = cls.call("new");
-
-    for (int j = 0; j < scale; j++)
-    {
-      obj.call("int" + std::to_string(j));
-      obj.call("long" + std::to_string(j));
-      obj.call("double" + std::to_string(j));
-      obj.call("float" + std::to_string(j));
-      obj.call("bool" + std::to_string(j));
-    }
-  }
+  rb_gc_start();
 }

data/test/test_Object.cpp

@@ -11,6 +11,11 @@ SETUP(Object)
   embed_ruby();
 }
 
+TEARDOWN(Object)
+{
+  rb_gc_start();
+}
+
 TESTCASE(default_construct)
 {
   Object o;