rice 4.3.3 → 4.6.0

data/test/test_Keep_Alive.cpp

@@ -1,7 +1,6 @@
 #include "unittest.hpp"
 #include "embed_ruby.hpp"
 #include <rice/rice.hpp>
-#include <rice/stl.hpp>
 
 using namespace Rice;
 
@@ -60,6 +59,11 @@ SETUP(Keep_Alive)
   embed_ruby();
 }
 
+TEARDOWN(Keep_Alive)
+{
+  rb_gc_start();
+}
+
 TESTCASE(test_arg)
 {
   define_class<Listener>("Listener")
@@ -107,7 +111,10 @@ namespace
     {
     }
 
-    std::string name();
+    uint32_t index()
+    {
+      return this->index_;
+    }
 
   private:
     Connection& connection_;
@@ -121,20 +128,7 @@ namespace
     {
       return Column(*this, index);
     }
-
-    std::string getName(uint32_t index)
-    {
-      return this->prefix_ + std::to_string(index);
-    }
-
-  private:
-    std::string prefix_ = "column_";
   };
-
-  std::string Column::name()
-  {
-    return this->connection_.getName(this->index_);
-  }
 }
 
 Object getColumn(Module& m, uint32_t index)
@@ -146,7 +140,7 @@ Object getColumn(Module& m, uint32_t index)
 TESTCASE(test_return)
 {
   define_class<Column>("Column")
-    .define_method("name", &Column::name);
+    .define_method("index", &Column::index);
 
   define_class<Connection>("Connection")
     .define_constructor(Constructor<Connection>())
@@ -156,6 +150,6 @@ TESTCASE(test_return)
 
   Object column = getColumn(m, 3);
   rb_gc_start();
-  String name = column.call("name");
-  ASSERT_EQUAL("column_3", name.c_str());
-}
+  Object index = column.call("index");
+  ASSERT_EQUAL(3, detail::From_Ruby<int>().convert(index));
+}

data/test/test_Keep_Alive_No_Wrapper.cpp

@@ -1,7 +1,6 @@
 #include "unittest.hpp"
 #include "embed_ruby.hpp"
 #include <rice/rice.hpp>
-#include <rice/stl.hpp>
 
 using namespace Rice;
 
@@ -56,6 +55,11 @@ SETUP(Keep_Alive_No_Wrapper)
   embed_ruby();
 }
 
+TEARDOWN(Keep_Alive_No_Wrapper)
+{
+  rb_gc_start();
+}
+
 TESTCASE(test_keep_alive_no_wrapper)
 {
   define_class<Animal>("Animal")

data/test/test_Memory_Management.cpp

@@ -11,6 +11,11 @@ SETUP(Memory_Management)
   embed_ruby();
 }
 
+TEARDOWN(Memory_Management)
+{
+  rb_gc_start();
+}
+
 namespace
 {
   class TestClass {

data/test/test_Module.cpp

@@ -1,4 +1,4 @@
-#include "unittest.hpp"
+#include "unittest.hpp"
 #include "embed_ruby.hpp"
 
 #include <rice/rice.hpp>
@@ -11,6 +11,12 @@ TESTSUITE(Module);
 SETUP(Module)
 {
   embed_ruby();
+  define_fundamental_buffer_types();
+}
+
+TEARDOWN(Module)
+{
+  rb_gc_start();
 }
 
 TESTCASE(FromConstant)
@@ -27,59 +33,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 +178,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("Missing argument. Name: arg_0. Index: 0.", ex.what())
+  );
 }
 
 TESTCASE(define_singleton_method_int_foo)
@@ -263,22 +265,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("Missing argument. Name: arg1. Index: 0.", 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 3)", ex.what())
+  );
 }
 
 namespace {
@@ -457,7 +465,9 @@ TESTCASE(define_method_works_with_pointers)
   Module m(anonymous_module());
   m.define_module_function("bar", &with_pointers);
 
-  m.call("bar", 3, "testing");
+  int anInt = 3;
+  Buffer<int> buffer(&anInt, 1);
+  m.call("bar", std::move(buffer), "testing");
 
   ASSERT_EQUAL(3, with_pointers_x);
   ASSERT_EQUAL("testing", with_pointers_str);
@@ -492,8 +502,12 @@ TESTCASE(pointers)
   define_global_function("with_pointers", &withPointers);
 
   Module m = define_module("TestingModule");
+  std::string code = R"(int_buffer = Rice::Buffer≺int≻.new(32)
+                          bool_buffer = Rice::Buffer≺bool≻.new(true)
+                          double_buffer = Rice::Buffer≺float≻.new(33.0)
+                          float_buffer = Rice::Buffer≺double≻.new(34.0)
+                          with_pointers(int_buffer, bool_buffer, double_buffer, float_buffer))";
 
-  std::string code = "with_pointers(32, true, 33.0, 34.0)";
   m.module_eval(code);
 
   ASSERT_EQUAL(intValue, 32);
@@ -515,4 +529,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

@@ -2,7 +2,6 @@
 #include "embed_ruby.hpp"
 
 #include <rice/rice.hpp>
-#include <rice/stl.hpp>
 
 using namespace Rice;
 
@@ -13,38 +12,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;