rice 4.3.3 → 4.6.0

data/test/test_Stl_Vector.cpp

@@ -14,9 +14,13 @@ SETUP(Vector)
   embed_ruby();
 }
 
-namespace
+TEARDOWN(Vector)
 {
+  rb_gc_start();
+}
 
+namespace
+{
   class MyClass
   {
   public:
@@ -41,9 +45,9 @@ TESTCASE(StringVector)
 {
   Module m = define_module("Testing");
 
-  Class c = define_vector<std::vector<std::string>>("StringVector");
+  Class c = define_vector<std::string>("StringVector");
 
-  Object vec = m.module_eval("$vector = StringVector.new");
+  Object vec = m.module_eval("$vector = Std::StringVector.new");
   Object result = vec.call("size");
   ASSERT_EQUAL(0, detail::From_Ruby<int32_t>().convert(result));
 
@@ -62,13 +66,64 @@ TESTCASE(StringVector)
   ASSERT_EQUAL("four", detail::From_Ruby<std::string>().convert(result));
 }
 
-TESTCASE(WrongType)
+TESTCASE(Constructors)
+{
+  Module m = define_module("Testing");
+
+  Class c = define_vector<int>("IntVector");
+
+  // Default constructor
+  std::string code = R"(Std::IntVector.new)";
+  Object vec = m.module_eval(code);
+  Object result = vec.call("size");
+  ASSERT_EQUAL(0, detail::From_Ruby<int32_t>().convert(result));
+
+  detail::From_Ruby<int> fromRuby;
+
+  // Constructor with specific size and default construtible values
+  code = R"(Std::IntVector.new(3))";
+  vec = m.module_eval(code);
+  result = vec.call("size");
+  ASSERT_EQUAL(3, fromRuby.convert(result));
+  Object element = vec.call("[]", 0);
+  ASSERT_EQUAL(0, fromRuby.convert(element));
+  element = vec.call("[]", 1);
+  ASSERT_EQUAL(0, fromRuby.convert(element));
+  element = vec.call("[]", 2);
+  ASSERT_EQUAL(0, fromRuby.convert(element));
+
+  // Constructor with specific size and value
+  code = R"(Std::IntVector.new(3, 5))";
+  vec = m.module_eval(code);
+  result = vec.call("size");
+  ASSERT_EQUAL(3, fromRuby.convert(result));
+  element = vec.call("[]", 0);
+  ASSERT_EQUAL(5, fromRuby.convert(element));
+  element = vec.call("[]", 1);
+  ASSERT_EQUAL(5, fromRuby.convert(element));
+  element = vec.call("[]", 2);
+  ASSERT_EQUAL(5, fromRuby.convert(element));
+
+  // Custom constructor
+  code = R"(Std::IntVector.new([1, 2, 3]))";
+  vec = m.module_eval(code);
+  result = vec.call("size");
+  ASSERT_EQUAL(3, fromRuby.convert(result));
+  element = vec.call("[]", 0);
+  ASSERT_EQUAL(1, fromRuby.convert(element));
+  element = vec.call("[]", 1);
+  ASSERT_EQUAL(2, fromRuby.convert(element));
+  element = vec.call("[]", 2);
+  ASSERT_EQUAL(3, fromRuby.convert(element));
+}
+
+TESTCASE(WrongElementType)
 {
   Module m = define_module("Testing");
 
-  Class c = define_vector<std::vector<std::string>>("StringVector");
+  Class c = define_vector<std::string>("StringVector");
 
-  Object vec = m.module_eval("$vector = StringVector.new");
+  Object vec = m.module_eval("$vector = Std::StringVector.new");
   ASSERT_EXCEPTION_CHECK(
     Exception,
     m.module_eval("$vector << 1"),
@@ -79,7 +134,7 @@ TESTCASE(Empty)
 {
   Module m = define_module("Testing");
 
-  Class c = define_vector<std::vector<std::int32_t>>("IntVector");
+  Class c = define_vector<std::int32_t>("IntVector");
   Object vec = c.call("new");
 
   Object result = vec.call("size");
@@ -95,11 +150,50 @@ TESTCASE(Empty)
   ASSERT_EQUAL(Qnil, result.value());
 }
 
+TESTCASE(BoolVector)
+{
+  Class boolVecClass = define_vector<bool>("BoolVector");
+
+  Object vec = boolVecClass.call("new");
+  vec.call("resize", 3, true);
+
+  Object result = vec.call("size");
+  ASSERT_EQUAL(3, detail::From_Ruby<int32_t>().convert(result));
+  result = vec.call("first");
+  ASSERT_EQUAL(Qtrue, result.value());
+
+  Object enumerable = vec.call("each");
+  Object arr = enumerable.call("to_a");
+  Object size = arr.call("size");
+  ASSERT_EQUAL(3, detail::From_Ruby<int32_t>().convert(size));
+
+  result = vec.call("[]", 0);
+  ASSERT_EQUAL(Qtrue, result.value());
+
+  result = vec.call("[]=", 1, false);
+  ASSERT_EQUAL(Qfalse, result.value());
+
+  std::string code = R"(array = self.each.to_a
+                        array == [true, false, true])";
+
+  result = vec.instance_eval(code);
+  ASSERT_EQUAL(Qtrue, result.value());
+
+  result = vec.call("delete", 1);
+  ASSERT_EQUAL(Qtrue, result.value());
+  result = vec.call("size");
+  ASSERT_EQUAL(2, detail::From_Ruby<int32_t>().convert(result));
+
+  vec.call("clear");
+  result = vec.call("size");
+  ASSERT_EQUAL(0, detail::From_Ruby<int32_t>().convert(result));
+}
+
 TESTCASE(Indexing)
 {
   Module m = define_module("Testing");
 
-  Class c = define_vector<std::vector<std::int32_t>>("IntVector");
+  Class c = define_vector<std::int32_t>("IntVector");
   Object vec = c.call("new");
   vec.call("push", 0);
   vec.call("push", 1);
@@ -136,11 +230,47 @@ TESTCASE(Indexing)
   ASSERT_EQUAL(2, detail::From_Ruby<int32_t>().convert(result));
 }
 
+TESTCASE(Slice)
+{
+  Module m = define_module("Testing");
+
+  Class c = define_vector<std::int32_t>("IntVector");
+  Object vec = c.call("new");
+  vec.call("push", 7);
+  vec.call("push", 8);
+  vec.call("push", 9);
+  vec.call("push", 10);
+  vec.call("push", 11);
+  vec.call("push", 12);
+
+  Array result = vec.call("[]", 3, 1);
+  std::vector<std::int32_t> slice = result.to_vector<int32_t>();
+  ASSERT_EQUAL(1, slice.size());
+  ASSERT_EQUAL(10, slice[0]);
+
+  result = vec.call("[]", 3, 2);
+  slice = result.to_vector<int32_t>();
+  ASSERT_EQUAL(2, slice.size());
+  ASSERT_EQUAL(10, slice[0]);
+  ASSERT_EQUAL(11, slice[1]);
+
+  result = vec.call("[]", 4, 10);
+  slice = result.to_vector<int32_t>();
+  ASSERT_EQUAL(2, slice.size());
+  ASSERT_EQUAL(11, slice[0]);
+  ASSERT_EQUAL(12, slice[1]);
+
+  result = vec.call("[]", -1, 2);
+  slice = result.to_vector<int32_t>();
+  ASSERT_EQUAL(1, slice.size());
+  ASSERT_EQUAL(12, slice[0]);
+}
+
 TESTCASE(Sizing)
 {
   Module m = define_module("Testing");
 
-  Class c = define_vector<std::vector<std::int32_t>>("IntVector");
+  Class c = define_vector<std::int32_t>("IntVector");
   Object vec = c.call("new");
   vec.call("resize", 10);
 
@@ -157,7 +287,7 @@ TESTCASE(ToString)
 {
   Module m = define_module("Testing");
 
-  Class c = define_vector<std::vector<std::int32_t>>("IntVector");
+  Class c = define_vector<std::int32_t>("IntVector");
   Object vec = c.call("new");
   vec.call("resize", 3);
 
@@ -174,7 +304,7 @@ TESTCASE(Update)
 {
   Module m = define_module("Testing");
 
-  Class c = define_vector<std::vector<std::string>>("StringVector");
+  Class c = define_vector<std::string>("StringVector");
   Object vec = c.call("new");
   vec.call("push", "original 1");
   vec.call("push", "original 2");
@@ -198,7 +328,7 @@ TESTCASE(Modify)
 {
   Module m = define_module("Testing");
 
-  Class c = define_vector<std::vector<int64_t>>("Int64Vector");
+  Class c = define_vector<int64_t>("Int64Vector");
   Object vec = c.call("new");
 
   Object result = vec.call("push", 11);
@@ -238,26 +368,26 @@ TESTCASE(Modify)
   ASSERT_EQUAL(Qnil, result.value());
 }
 
-TESTCASE(Copy)
+TESTCASE(Clone)
 {
   Module m = define_module("Testing");
 
-  Class c = define_vector<std::vector<double>>("DoubleVector");
+  Class c = define_vector<double>("DoubleVector");
   Object object = c.call("new");
 
   object.call("push", 11.1);
   object.call("push", 22.2);
   std::vector<double>& vec = detail::From_Ruby<std::vector<double>&>().convert(object);
 
-  Object result = object.call("copy");
-  std::vector<double>& vecCopy = detail::From_Ruby<std::vector<double>&>().convert(result);
+  Object result = object.call("clone");
+  std::vector<double>& vecClone = detail::From_Ruby<std::vector<double>&>().convert(result);
 
-  ASSERT_EQUAL(vec.size(), vecCopy.size());
-  ASSERT_EQUAL(vec[0], vecCopy[0]);
-  ASSERT_EQUAL(vec[1], vecCopy[1]);
+  ASSERT_EQUAL(vec.size(), vecClone.size());
+  ASSERT_EQUAL(vec[0], vecClone[0]);
+  ASSERT_EQUAL(vec[1], vecClone[1]);
 
-  vecCopy.push_back(33.3);
-  ASSERT_NOT_EQUAL(vec.size(), vecCopy.size());
+  vecClone.push_back(33.3);
+  ASSERT_NOT_EQUAL(vec.size(), vecClone.size());
 }
 
 namespace
@@ -278,7 +408,7 @@ TESTCASE(NotComparable)
   define_class<NotComparable>("NotComparable").
     define_constructor(Constructor<NotComparable, uint32_t>());
 
-  Class c = define_vector<std::vector<NotComparable>>("NotComparableVector");
+  Class c = define_vector<NotComparable>("NotComparableVector");
 
   Object vec = c.call("new");
   vec.call("push", NotComparable(1));
@@ -303,7 +433,7 @@ TESTCASE(NotDefaultConstructable)
   define_class<NotComparable>("NotComparable").
     define_constructor(Constructor<NotComparable, uint32_t>());
     
-  Class c = define_vector<std::vector<NotComparable>>("NotComparableVector");
+  Class c = define_vector<NotComparable>("NotComparableVector");
   Object vec = c.call("new");
 
   Object result = vec.call("resize", 10);
@@ -318,7 +448,7 @@ TESTCASE(NotPrintable)
   define_class<NotComparable>("NotComparable").
     define_constructor(Constructor<NotComparable, uint32_t>());
 
-  Class c = define_vector<std::vector<NotComparable>>("NotComparableVector");
+  Class c = define_vector<NotComparable>("NotComparableVector");
 
   Object vec = c.call("new");
   vec.call("push", NotComparable(1));
@@ -338,7 +468,7 @@ namespace
     {
     };
 
-    bool operator==(const Comparable& other)
+    bool operator==(const Comparable& other) const
     {
       return this->value_ == other.value_;
     }
@@ -358,7 +488,7 @@ TESTCASE(Comparable)
   define_class<Comparable>("IsComparable").
     define_constructor(Constructor<Comparable, uint32_t>());
 
-  Class c = define_vector<std::vector<Comparable>>("ComparableVector");
+  Class c = define_vector<Comparable>("ComparableVector");
 
   Object vec = c.call("new");
   
@@ -385,12 +515,55 @@ TESTCASE(Comparable)
   ASSERT_EQUAL(1, detail::From_Ruby<size_t>().convert(result.value()));
 }
 
+namespace
+{
+  class ComparableButNotBool
+  {
+  public:
+    ComparableButNotBool(uint32_t value) : value_(value)
+    {
+    };
+
+    std::string operator==(const ComparableButNotBool& other)
+    {
+      return "not a boolean";
+    }
+
+    uint32_t value_;
+  };
+}
+
+TESTCASE(ComparableButNotBool)
+{
+  define_class<ComparableButNotBool>("IsComparableButNotBool").
+    define_constructor(Constructor<ComparableButNotBool, uint32_t>());
+
+  Class c = define_vector<ComparableButNotBool>("ComparableButNotBoolVector");
+
+  Object vec = c.call("new");
+  vec.call("push", ComparableButNotBool(1));
+  vec.call("push", ComparableButNotBool(2));
+  vec.call("push", ComparableButNotBool(3));
+
+  Object result = vec.call("delete", ComparableButNotBool(1));
+  ASSERT_EQUAL(Qnil, result.value());
+
+  result = vec.call("length");
+  ASSERT_EQUAL(3u, detail::From_Ruby<size_t>().convert(result));
+
+  result = vec.call("include?", ComparableButNotBool(2));
+  ASSERT_EQUAL(Qfalse, result.value());
+
+  result = vec.call("index", ComparableButNotBool(3));
+  ASSERT_EQUAL(Qnil, result.value());
+}
+
 TESTCASE(DefaultConstructable)
 {
   define_class<Comparable>("IsComparable").
     define_constructor(Constructor<Comparable, uint32_t>());
 
-  Class c = define_vector<std::vector<Comparable>>("ComparableVector");
+  Class c = define_vector<Comparable>("ComparableVector");
   Object vec = c.call("new");
 
   Object result = vec.call("resize", 10);
@@ -405,7 +578,7 @@ TESTCASE(Printable)
   define_class<Comparable>("IsComparable").
     define_constructor(Constructor<Comparable, uint32_t>());
 
-  Class c = define_vector<std::vector<Comparable>>("ComparableVector");
+  Class c = define_vector<Comparable>("ComparableVector");
 
   Object vec = c.call("new");
   vec.call("push", Comparable(1));
@@ -443,7 +616,7 @@ TESTCASE(AutoRegisterReturn)
 
   Module m = define_module("Testing");
   Object vec = m.module_eval("return_complex_vector");
-  ASSERT_EQUAL("Rice::Std::Vector__complex__double___allocator__complex__double______", vec.class_name().str());
+  ASSERT_EQUAL("Std::Vector≺complex≺double≻≻", vec.class_name().str());
 
   std::string code = R"(vector = return_complex_vector
                         complex = vector.last
@@ -453,14 +626,8 @@ TESTCASE(AutoRegisterReturn)
   ASSERT_EQUAL(Qtrue, result.value());
 
   // Now register this same vector
-  define_vector<std::vector<std::complex<double>>>("ComplexVector");
-  code = R"(vector = ComplexVector.new)";
-  result = m.module_eval(code);
-  ASSERT(result.is_instance_of(vec.class_of()));
-
-  // Now register it again in the module
-  define_vector_under<std::vector<std::complex<double>>>(m, "ComplexVector2");
-  code = R"(vector = Testing::ComplexVector2.new)";
+  define_vector<std::complex<double>>("ComplexVector");
+  code = R"(vector = Std::ComplexVector.new)";
   result = m.module_eval(code);
   ASSERT(result.is_instance_of(vec.class_of()));
 }
@@ -469,16 +636,16 @@ TESTCASE(AutoRegisterParameter)
 {
   define_global_function("pass_complex_vector", &passComplexVector);
 
-  std::string code = R"(vector = Rice::Std::Vector__complex__double___allocator__complex__double______.new
-                        vector << Complex(4.0, 4.0)
-                        vector << Complex(5.0, 5.0)
-                        pass_complex_vector(vector))";
+  std::string code = R"(vector = Std::Vector≺complex≺double≻≻.new
+                          vector << Complex(4.0, 4.0)
+                          vector << Complex(5.0, 5.0)
+                          pass_complex_vector(vector))";
 
   Module m = define_module("Testing");
   Object vec = m.module_eval(code);
 
   Object result = vec.call("size");
-  ASSERT_EQUAL("Rice::Std::Vector__complex__double___allocator__complex__double______", vec.class_name().str());
+  ASSERT_EQUAL("Std::Vector≺complex≺double≻≻", vec.class_name().str());
   ASSERT_EQUAL(2, detail::From_Ruby<int32_t>().convert(result));
 
   std::vector<std::complex<double>> complexes = detail::From_Ruby<std::vector<std::complex<double>>>().convert(vec);
@@ -496,7 +663,7 @@ namespace
 
 TESTCASE(DefaultValue)
 {
-  define_vector<std::vector<std::string>>("StringVector");
+  define_vector<std::string>("StringVector");
   define_global_function("default_vector", &defaultVector, Arg("strings") = std::vector<std::string> { "one", "two", "three" });
 
   Module m = define_module("Testing");
@@ -515,10 +682,10 @@ TESTCASE(ToArray)
 {
   Module m = define_module("Testing");
   
-  Class c = define_vector<std::vector<std::string>>("StringVector").
+  Class c = define_vector<std::string>("StringVector").
     define_constructor(Constructor<std::vector<std::string>>());
 
-  std::string code = R"(vector = StringVector.new
+  std::string code = R"(vector = Std::StringVector.new
                         vector << "abc"
                         vector << "def"
                         vector << "ghi"
@@ -694,15 +861,15 @@ namespace
     stream << "Vector";
     return stream;
   }
-}
 
-void createFactoryClass()
-{
-  define_class<Factory>("Factory").
-    define_constructor(Constructor<Factory>()).
-    define_method("pointer", &Factory::returnPointer).
-    define_method("reference", &Factory::returnReference).
-    define_method("value", &Factory::returnValue);
+  void createFactoryClass()
+  {
+    define_class<Factory>("Factory").
+      define_constructor(Constructor<Factory>()).
+      define_method("pointer", &Factory::returnPointer).
+      define_method("reference", &Factory::returnReference).
+      define_method("value", &Factory::returnValue);
+  }
 }
 
 TESTCASE(Returns)
@@ -726,9 +893,9 @@ TESTCASE(Returns)
 TESTCASE(Iterate)
 {
   Module m = define_module("Testing");
-  Class c = define_vector<std::vector<double>>("DoubleVector");
+  Class c = define_vector<double>("DoubleVector");
 
-  std::string code = R"(vector = DoubleVector.new
+  std::string code = R"(vector = Std::DoubleVector.new
                         vector << 5.0 << 6.0 << 7.0
                         updated = vector.map do |value|
                                     value * 2.0
@@ -815,8 +982,12 @@ namespace
   std::vector<std::string*> vectorOfStringPointers()
   {
     std::vector<std::string*> result;
-    std::string* pString = new std::string("Hello");
-    result.push_back(pString);
+    std::string* pString1 = new std::string("Hello");
+    result.push_back(pString1);
+
+    std::string* pString2 = new std::string("World");
+    result.push_back(pString2);
+
     return result;
   }
 }
@@ -827,11 +998,20 @@ TESTCASE(StringPointerVector)
 
   Module m(rb_mKernel);
   Data_Object<std::vector<std::string*>> vec = m.call("vector_of_string_pointers");
-  ASSERT_EQUAL(1, vec->size());
+  ASSERT_EQUAL(2, vec->size());
 
   std::string expected("Hello");
   std::string* actual = (*vec)[0];
   ASSERT_EQUAL(expected, *actual);
+
+  std::string code = R"(vec = vector_of_string_pointers
+                        outer_buffer = vec.data
+                        inner_buffers = outer_buffer.to_ary(2)
+                        inner_buffer = inner_buffers[1]
+                        inner_buffer.to_ary(1))";
+  Array array = m.module_eval(code);
+  ASSERT_EQUAL(1, array.size());
+  ASSERT_EQUAL("World", detail::From_Ruby<std::string>().convert(array[0].value()).c_str());
 }
 
 namespace
@@ -869,3 +1049,71 @@ TESTCASE(MyClass2PointerVector)
  MyClass2* pMyClass = (*result)[0];
  ASSERT_EQUAL("Hello MyClass2", pMyClass->name);
 }
+
+namespace
+{
+  bool typeCheckValue(std::vector<std::string> vec)
+  {
+    return true;
+  }
+
+  bool typeCheckRef(std::vector<std::string>& vec)
+  {
+    return true;
+  }
+
+  bool typeCheckPtr(std::vector<std::string>* vec)
+  {
+    return true;
+  }
+}
+
+TESTCASE(TypeCheck)
+{
+  define_vector<int>("Vector≺int≻");
+  define_vector<std::string>("Vector≺string≻");
+
+  Module m(anonymous_module());
+  m.define_module_function("check_value", &typeCheckValue).
+    define_module_function("check_ref", &typeCheckRef).
+    define_module_function("check_ptr", &typeCheckPtr);
+
+  std::string code = R"(vec = Std::Vector≺string≻.new
+                        check_value(vec))";
+  Object result = m.module_eval(code);
+  ASSERT_EQUAL(Qtrue, result.value());
+
+  code = R"(vec = Std::Vector≺string≻.new
+            check_ref(vec))";
+  result = m.module_eval(code);
+  ASSERT_EQUAL(Qtrue, result.value());
+
+  code = R"(vec = Std::Vector≺string≻.new
+            check_ptr(vec))";
+  result = m.module_eval(code);
+  ASSERT_EQUAL(Qtrue, result.value());
+
+  code = R"(vec = Std::Vector≺int≻.new
+            check_value(vec))";
+
+  ASSERT_EXCEPTION_CHECK(
+    Exception,
+    result = m.module_eval(code),
+    ASSERT_EQUAL("wrong argument type Std::Vector≺int≻ (expected Std::Vector≺string≻)", ex.what()));
+
+  code = R"(vec = Std::Vector≺int≻.new
+            check_ref(vec))";
+
+  ASSERT_EXCEPTION_CHECK(
+    Exception,
+    result = m.module_eval(code),
+    ASSERT_EQUAL("wrong argument type Std::Vector≺int≻ (expected Std::Vector≺string≻)", ex.what()));
+
+  code = R"(vec = Std::Vector≺int≻.new
+            check_ptr(vec))";
+
+  ASSERT_EXCEPTION_CHECK(
+    Exception,
+    result = m.module_eval(code),
+    ASSERT_EQUAL("wrong argument type Std::Vector≺int≻ (expected Std::Vector≺string≻)", ex.what()));
+}

data/test/test_String.cpp

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

data/test/test_Struct.cpp

@@ -24,6 +24,11 @@ SETUP(Struct)
   embed_ruby();
 }
 
+TEARDOWN(Struct)
+{
+  rb_gc_start();
+}
+
 TESTCASE(default_construct)
 {
   Struct s;

data/test/test_Symbol.cpp

@@ -11,6 +11,11 @@ SETUP(Symbol)
   embed_ruby();
 }
 
+TEARDOWN(Symbol)
+{
+  rb_gc_start();
+}
+
 TESTCASE(construct_from_symbol)
 {
   VALUE v = ID2SYM(rb_intern("foo"));