rice 4.3.3 → 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"
@@ -14,13 +14,11 @@ SETUP(Data_Type)
   embed_ruby();
 }
 
-/**
- * The tests here are for the feature of taking an instance
- * of a Ruby-subclass of a Rice wrapped class and passing
- * that instance back into the Rice wrapper. While that
- * might be confusing, the test code is pretty straight foward
- * to see what we're talking about.
- */
+TEARDOWN(Data_Type)
+{
+  Rice::detail::Registries::instance.types.clearUnverifiedTypes();
+  rb_gc_start();
+}
 
 namespace
 {
@@ -79,7 +77,7 @@ namespace
         std::to_string(f) + ", " + s + ", " + std::string(c) + ")";
     }
   };
-} // namespace
+}
 
 TESTCASE(methods_with_member_pointers)
 {
@@ -110,6 +108,59 @@ TESTCASE(methods_with_member_pointers)
   ASSERT_EQUAL("multiple_args(81, 1, 7.000000, a string, a char)", detail::From_Ruby<std::string>().convert(result.value()));
 }
 
+namespace
+{
+  class MyClassOriginal
+  {
+
+  };
+
+  namespace InnerNamespace
+  {
+    class MyClassOriginal
+    {
+    };
+  }
+}
+
+TESTCASE(define_class_twice)
+{
+  Module module(rb_cObject);
+
+  Class c1 = define_class<MyClassOriginal>("MyClassOriginal");
+  bool result = module.const_defined("MyClassOriginal");
+  ASSERT(result);
+  String name = c1.name();
+  ASSERT_EQUAL("MyClassOriginal", name.str());
+
+  Class c2 = define_class<MyClassOriginal>("MyClassDuplicate");
+  result = c2.is_equal(c1);
+  ASSERT(result);
+
+  result = module.const_defined("MyClassDuplicate");
+  name = c2.name();
+  ASSERT_EQUAL("MyClassOriginal", name.str());
+}
+
+TESTCASE(define_class_twice_under)
+{
+  Module inner = define_module("InnerNamespace");
+
+  Class c1 = define_class_under<InnerNamespace::MyClassOriginal>(inner, "MyClassOriginal");
+  bool result = inner.const_defined("MyClassOriginal");
+  ASSERT(result);
+  String name = c1.name();
+  ASSERT_EQUAL("InnerNamespace::MyClassOriginal", name.str());
+
+  Class c2 = define_class_under<InnerNamespace::MyClassOriginal>(inner, "MyClassDuplicate");
+  result = c2.is_equal(c1);
+  ASSERT(result);
+
+  result = inner.const_defined("MyClassDuplicate");
+  name = c2.name();
+  ASSERT_EQUAL("InnerNamespace::MyClassOriginal", name.str());
+}
+
 TESTCASE(incorrect_number_of_args)
 {
   Class c =
@@ -366,6 +417,57 @@ TESTCASE(define_singleton_method_returning_reference)
   ASSERT_EQUAL(result, String("foo"));
 }
 
+namespace
+{
+  class RValue
+  {
+  public:
+    RValue() {}
+
+    RValue(RValue&& other) = default;
+
+    // Move assignment operator.
+    RValue& operator=(RValue&& other) noexcept
+    {
+      return *this;
+    }
+
+    bool takesRValue(RValue&& rvalue)
+    {
+      return true;
+    }
+  };
+}
+
+TESTCASE(rvalue_parameter)
+{
+  Class c = define_class<RValue>("RValue")
+    .define_constructor(Constructor<RValue>())
+    .define_method("takes_r_value", &RValue::takesRValue);
+
+  Module m(anonymous_module());
+  std::string code = R"(rvalue = RValue.new
+                        rvalue.takes_r_value(rvalue))";
+
+  Object result = m.module_eval(code);
+  ASSERT_EQUAL(Qtrue, result.value());
+}
+
+TESTCASE(move_assignment)
+{
+  Class c = define_class<RValue>("RValue")
+    .define_constructor(Constructor<RValue>())
+    .define_method<RValue&(RValue::*)(RValue && other) noexcept>("=", &RValue::operator=);
+
+  Module m(anonymous_module());
+  std::string code = R"(object1 = RValue.new
+                        object2 = RValue.new
+                        object1 = object2)";
+
+  Object result = m.module_eval(code);
+  ASSERT_EQUAL(c, result.class_of());
+}
+
 namespace
 {
   struct MyStruct
@@ -401,115 +503,418 @@ TESTCASE(null_ptrs)
 
 namespace
 {
-  class SomeClass
+  class Helper
   {
+  public:
+
+    Helper(int value) : value_(value)
+    {
+    }
+
+    int value()
+    {
+      return this->value_;
+    }
+
+  private:
+    int value_;
   };
 
-  void undefinedArg(SomeClass& someClass)
+  class MyClass2
+  {
+  public:
+    Helper* passThrough(Helper* helper)
+    {
+      return helper;
+    }
+
+    const Helper* passThroughConst(const Helper* helper)
+    {
+      return helper;
+    }
+
+    Helper* passThrough(void* helper)
+    {
+      return static_cast<Helper*>(helper);
+    }
+
+    void* returnVoidHelper()
+    {
+      if (!this->helper_)
+        this->helper_ = new Helper(4);
+      
+      return static_cast<void*>(this->helper_);
+    }
+
+    bool checkVoidHelper(void* helper)
+    {
+      return helper == this->helper_;
+    }
+
+  private:
+    Helper* helper_ = nullptr;
+  };
+} // namespace
+
+TESTCASE(pointers)
+{
+  Class helperClass = define_class<Helper>("Helper")
+    .define_constructor(Constructor<Helper, int>())
+    .define_method("value", &Helper::value);
+
+  Class myClass = define_class<MyClass2>("MyClass2")
+    .define_constructor(Constructor<MyClass2>())
+    .define_method<Helper*(MyClass2::*)(Helper*)>("pass_through", &MyClass2::passThrough)
+    .define_method<const Helper*(MyClass2::*)(const Helper*)>("pass_through_const", &MyClass2::passThroughConst)
+    .define_method<Helper*(MyClass2::*)(void*)>("pass_through_void", &MyClass2::passThrough)
+    .define_method<void*(MyClass2::*)()>("return_void_helper", &MyClass2::returnVoidHelper)
+    .define_method<bool(MyClass2::*)(void*)>("check_void_helper", &MyClass2::checkVoidHelper);
+
+  Object helper = helperClass.call("new", 5);
+  Object object = myClass.call("new");
+
+  Object result = object.call("pass_through", nullptr);
+  ASSERT_EQUAL(Qnil, result.value());
+
+  result = object.call("pass_through", helper);
+  Object value = result.call("value");
+  ASSERT_EQUAL(5, detail::From_Ruby<int>().convert(value));
+
+  result = object.call("pass_through_const", helper);
+  value = result.call("value");
+  ASSERT_EQUAL(5, detail::From_Ruby<int>().convert(value));
+
+  result = object.call("pass_through_void", nullptr);
+  ASSERT_EQUAL(Qnil, result.value());
+
+  result = object.call("pass_through_void", helper);
+  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());
+}
+
+namespace
+{
+  class BigObject
+  {
+  public:
+    BigObject(int value): value(value)
+    {
+    }
+
+  public:
+    int value;
+  };
+
+  class Processor
+  {
+  public:
+    BigObject** createBigObjects(size_t size)
+    {
+      BigObject** result = new BigObject*[size];
+
+      for (size_t i = 0; i < size; ++i)
+      {
+        result[i] = new BigObject(i + 5);
+      }
+      return result;
+    }
+
+    int sumBigObjects(BigObject** bigObjects, size_t size)
+    {
+      int result = 0;
+
+      for (size_t i = 0; i < size; i++)
+      {
+        result += bigObjects[i]->value;
+      }
+      return result;
+    }
+
+    int sumBigObjectsConst(const BigObject**  bigObjects, size_t size)
+    {
+      int result = 0;
+
+      for (size_t i = 0; i < size; i++)
+      {
+        result += bigObjects[i]->value;
+      }
+      return result;
+    }
+
+  private:
+    BigObject** bigObjects_ = nullptr;
+  };
+
+}
+
+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,
+                          Arg("bigObjects").setArray(), Arg("size"))
+    .define_method("sum_const", &Processor::sumBigObjectsConst,
+                                Arg("bigObjects").setArray(), Arg("size"));
+
+  std::string code = R"(count = 2
+                          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));
+
+  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));
+}
+
+namespace
+{
+  class UnknownClass
+  {
+  };
+
+  void undefinedArg(UnknownClass unknownClass)
+  {
+  }
+
+  void undefinedArg(UnknownClass& unknownClass)
+  {
+  }
+
+  void undefinedArg(UnknownClass* unknownClass)
   {
   }
 
-  SomeClass undefinedReturn()
+  UnknownClass undefinedReturn()
   {
-    return SomeClass();
+    return UnknownClass();
   }
 }
 
 TESTCASE(not_defined)
 {
+  Module m = define_module("TestingDataTypeNotDefined");
+
 #ifdef _MSC_VER
-  const char* message = "Type is not defined with Rice: class `anonymous namespace'::SomeClass";
+  const char* message = "The following types are not registered with Rice:\n  class `anonymous namespace'::UnknownClass\n";
 #else
-  const char* message = "Type is not defined with Rice: (anonymous namespace)::SomeClass";
+  const char* message = "The following types are not registered with Rice:\n  (anonymous namespace)::UnknownClass\n";
 #endif
-    
-    ASSERT_EXCEPTION_CHECK(
+
+  m.define_module_function("undefined_return", &undefinedReturn);
+
+  ASSERT_EXCEPTION_CHECK(
     std::invalid_argument,
-    define_global_function("undefined_arg", &undefinedArg),
+    Rice::detail::Registries::instance.types.validateTypes(),
     ASSERT_EQUAL(message, ex.what())
   );
 
+#ifdef _MSC_VER
+  message = "Type is not registered with Rice: class `anonymous namespace'::UnknownClass";
+#else
+  message = "Type is not registered with Rice: (anonymous namespace)::UnknownClass";
+#endif
+
   ASSERT_EXCEPTION_CHECK(
-    std::invalid_argument,
-    define_global_function("undefined_return", &undefinedReturn),
+    Rice::Exception,
+    m.call("undefined_return"),
     ASSERT_EQUAL(message, ex.what())
   );
+
+#ifdef _MSC_VER
+  message = "Type is not defined with Rice: class `anonymous namespace'::UnknownClass";
+#else
+  message = "Type is not defined with Rice: (anonymous namespace)::UnknownClass";
+#endif
+
+  m.define_module_function<void(*)(UnknownClass)>("undefined_arg_value", &undefinedArg);
+
+  ASSERT_EXCEPTION_CHECK(
+    Rice::Exception,
+    m.call("undefined_arg_value", nullptr),
+    ASSERT_EQUAL(message, ex.what())
+  );
+
+  m.define_module_function<void(*)(UnknownClass&)>("undefined_arg_reference", &undefinedArg);
+
+  ASSERT_EXCEPTION_CHECK(
+    Rice::Exception,
+    m.call("undefined_arg_reference", nullptr),
+    ASSERT_EQUAL(message, ex.what())
+  );
+
+  m.define_module_function<void(*)(UnknownClass*)>("undefined_arg_pointer", &undefinedArg);
+  
+  // This actually works because we pass a nullptr
+  m.call("undefined_arg_pointer", nullptr);
 }
 
-namespace
+namespace RangesTest
 {
-  class Container
+  class RangeCustom
   {
   public:
-    size_t capacity()
+    RangeCustom(int x, int y) : x(x), y(y)
     {
-      return this->capacity_;
     }
 
-    void capacity(size_t value)
+    RangeCustom(const RangeCustom& other) = default;
+
+    int x;
+    int y;
+  };
+
+  int sumRangesArray(int size, RangeCustom ranges[])
+  {
+    int result = 0;
+    for (int i = 0; i < size; i++)
     {
-      this->capacity_ = value;
+      const RangeCustom& range = ranges[i];
+      result += range.x + range.y;
     }
 
-  private:
-    size_t capacity_;
-  };
+    return result;
+  }
+
+  int sumRanges(int size, const RangeCustom* ranges)
+  {
+    int result = 0;
+    for (int i = 0; i < size; i++)
+    {
+      const RangeCustom& range = ranges[i];
+      result += range.x + range.y;
+    }
+
+    return result;
+  }
+
+  int sumRanges(int size, const RangeCustom** ranges)
+  {
+    int result = 0;
+    for (int i = 0; i < size; i++)
+    {
+      const RangeCustom* range = ranges[i];
+      result += range->x + range->y;
+    }
+
+    return result;
+  }
 }
 
-TESTCASE(OverloadsWithTemplateParameter)
+TESTCASE(array_of_ranges)
 {
-  Class c = define_class<Container>("Container")
-    .define_constructor(Constructor<Container>())
-    .define_method<size_t(Container::*)()>("capacity", &Container::capacity)
-    .define_method<void(Container::*)(size_t)>("capacity=", &Container::capacity);
+  define_buffer<RangesTest::RangeCustom>();
 
-  
-  Module m = define_module("Testing");
+  Module m = define_module("CustomRanges");
 
-  std::string code = R"(container = Container.new
-                        container.capacity = 5
-                        container.capacity)";
+  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("sum_ranges_array", RangesTest::sumRangesArray, 
+                                               Arg("size"), Arg("ranges[]").setArray());
+
+  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(5, detail::From_Ruby<int>().convert(result.value()));
+  ASSERT_EQUAL(21, detail::From_Ruby<int>().convert(result));
 }
 
-TESTCASE(OverloadsWithUsing)
+TESTCASE(pointer_of_ranges)
 {
-  using Getter_T = size_t(Container::*)();
-  using Setter_T = void(Container::*)(size_t);
+  define_buffer<RangesTest::RangeCustom>();
 
-  Class c = define_class<Container>("Container")
-    .define_constructor(Constructor<Container>())
-    .define_method("capacity", (Getter_T)&Container::capacity)
-    .define_method("capacity=", (Setter_T)&Container::capacity);
+  Module m = define_module("CustomRanges");
 
-  Module m = define_module("Testing");
+  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", RangesTest::sumRanges,
+                                                                        Arg("size"), Arg("ranges*").setArray());
 
-  std::string code = R"(container = Container.new
-                        container.capacity = 6
-                        container.capacity)";
+  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(6, detail::From_Ruby<int>().convert(result.value()));
+  ASSERT_EQUAL(21, detail::From_Ruby<int>().convert(result));
 }
 
-TESTCASE(OverloadsWithTypedef)
+TESTCASE(pointer_of_ranges_wrong)
 {
-  typedef size_t(Container::* Getter_T)();
-  typedef void (Container::* Setter_T)(size_t);
+  define_buffer<RangesTest::RangeCustom>();
 
-  Class c = define_class<Container>("Container")
-    .define_constructor(Constructor<Container>())
-    .define_method("capacity", (Getter_T)&Container::capacity)
-    .define_method("capacity=", (Setter_T)&Container::capacity);
+  Module m = define_module("CustomRanges");
 
-  Module m = define_module("Testing");
+  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"(container = Container.new
-                        container.capacity = 7
-                        container.capacity)";
+  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*>();
+
+  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", 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(buffer.size, buffer))";
 
   Object result = m.module_eval(code);
-  ASSERT_EQUAL(7, detail::From_Ruby<int>().convert(result.value()));
-}
+  ASSERT_EQUAL(21, detail::From_Ruby<int>().convert(result));
+}

data/test/test_Director.cpp

@@ -8,6 +8,16 @@ using namespace Rice;
 
 TESTSUITE(Director);
 
+SETUP(Director)
+{
+  embed_ruby();
+}
+
+TEARDOWN(Director)
+{
+  rb_gc_start();
+}
+
 namespace {
   /**
    * Abstract base class
@@ -93,11 +103,6 @@ namespace {
   };
 };
 
-SETUP(Director)
-{
-  embed_ruby();
-}
-
 TESTCASE(exposes_worker_as_instantiatable_class)
 {
   define_class<Worker>("Worker")
@@ -191,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); 
       }