rice 4.3.3 → 4.5.0

data/test/test_Data_Type.cpp

@@ -14,14 +14,12 @@ 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
 {
   class MyClass
@@ -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,377 @@ TESTCASE(null_ptrs)
 
 namespace
 {
-  class SomeClass
+  class Helper
+  {
+  public:
+
+    Helper(int value) : value_(value)
+    {
+    }
+
+    int value()
+    {
+      return this->value_;
+    }
+
+  private:
+    int value_;
+  };
+
+  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 voidClass = define_class<void>("Void");
+
+  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");
 
-  void undefinedArg(SomeClass& someClass)
+  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 (int i = 0; i < size; ++i)
+      {
+        result[i] = new BigObject(i + 5);
+      }
+      return result;
+    }
+
+    int sumBigObjects(BigObject** bigObjects, size_t size)
+    {
+      int result = 0;
+
+      for (int i = 0; i < size; i++)
+      {
+        result += bigObjects[i]->value;
+      }
+      return result;
+    }
+
+    int sumBigObjectsConst(const BigObject**  bigObjects, size_t size)
+    {
+      int result = 0;
+
+      for (int i = 0; i < size; i++)
+      {
+        result += bigObjects[i]->value;
+      }
+      return result;
+    }
+
+  private:
+    BigObject** bigObjects_ = nullptr;
+  };
+
+}
+
+TESTCASE(pointerToPointer)
+{
+  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);
+
+  size_t size = 2;
+  Data_Object<Processor> processor = ProcessorClass.call("new");
+  Data_Object<BigObject> bigObjects = processor.call("create", size);
+
+  Object result = processor.call("sum", bigObjects, size);
+  ASSERT_EQUAL(11, detail::From_Ruby<int>().convert(result));
+
+  result = processor.call("sum_const", bigObjects, size);
+  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
 {
-  class Container
+  class Range
   {
   public:
-    size_t capacity()
+    Range(int x, int y) : x(x), y(y)
     {
-      return this->capacity_;
     }
 
-    void capacity(size_t value)
+    Range(const Range& other) = default;
+
+    int x;
+    int y;
+  };
+
+  int sumRangesArray(int size, Range ranges[])
+  {
+    int result = 0;
+    for (int i = 0; i < size; i++)
     {
-      this->capacity_ = value;
+      const Range& range = ranges[i];
+      result += range.x + range.y;
     }
 
-  private:
-    size_t capacity_;
-  };
+    return result;
+  }
+
+  int sumRanges(int size, const Range* ranges)
+  {
+    int result = 0;
+    for (int i = 0; i < size; i++)
+    {
+      const Range& range = ranges[i];
+      result += range.x + range.y;
+    }
+
+    return result;
+  }
+
+  int sumRanges(int size, const Range** ranges)
+  {
+    int result = 0;
+    for (int i = 0; i < size; i++)
+    {
+      const Range* 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);
+  Module m = define_module("ArrayOfRanges");
 
-  
-  Module m = define_module("Testing");
+  Class c = define_class_under<Range>(m, "Range")
+    .define_constructor(Constructor<Range, int, int>())
+    .define_attr("x", &Range::x)
+    .define_attr("y", &Range::y);
+
+  m.define_module_function("sum_ranges", sumRangesArray);
 
-  std::string code = R"(container = Container.new
-                        container.capacity = 5
-                        container.capacity)";
+  std::string code = R"(range1 = Range.new(1, 2)
+                        range2 = Range.new(3, 4)
+                        range3 = Range.new(5, 6)
+
+                        ranges = [range1, range2, range3]
+
+                        sum_ranges(ranges.count, ranges))";
 
   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);
+  Module m = define_module("PointerOfRanges");
 
-  Class c = define_class<Container>("Container")
-    .define_constructor(Constructor<Container>())
-    .define_method("capacity", (Getter_T)&Container::capacity)
-    .define_method("capacity=", (Setter_T)&Container::capacity);
+  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("Testing");
+  m.define_module_function<int(*)(int, const Range*)>("sum_ranges", sumRanges);
 
-  std::string code = R"(container = Container.new
-                        container.capacity = 6
-                        container.capacity)";
+  std::string code = R"(range1 = Range.new(1, 2)
+                        range2 = Range.new(3, 4)
+                        range3 = Range.new(5, 6)
+
+                        ranges = [range1, range2, range3]
+
+                        sum_ranges(ranges.count, ranges))";
 
   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_pointer_ranges)
 {
-  typedef size_t(Container::* Getter_T)();
-  typedef void (Container::* Setter_T)(size_t);
+  Module m = define_module("PointerOfPointersOfRanges");
 
-  Class c = define_class<Container>("Container")
-    .define_constructor(Constructor<Container>())
-    .define_method("capacity", (Getter_T)&Container::capacity)
-    .define_method("capacity=", (Setter_T)&Container::capacity);
+  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("Testing");
+  m.define_module_function<int(*)(int, const Range**)>("sum_ranges", sumRanges);
 
-  std::string code = R"(container = Container.new
-                        container.capacity = 7
-                        container.capacity)";
+  std::string code = R"(range1 = Range.new(1, 2)
+                        range2 = Range.new(3, 4)
+                        range3 = Range.new(5, 6)
+
+                        ranges = [range1, range2, range3]
+
+                        sum_ranges(ranges.count, ranges))";
 
   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")