rice 4.5.0 → 4.6.0

data/test/test_Stl_Vector.cpp

@@ -1,4 +1,4 @@
-#include <complex>
+#include <complex>
 
 #include "unittest.hpp"
 #include "embed_ruby.hpp"
@@ -45,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));
 
@@ -66,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<std::vector<std::string>>("StringVector");
+  Class c = define_vector<int>("IntVector");
 
-  Object vec = m.module_eval("$vector = StringVector.new");
+  // 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::string>("StringVector");
+
+  Object vec = m.module_eval("$vector = Std::StringVector.new");
   ASSERT_EXCEPTION_CHECK(
     Exception,
     m.module_eval("$vector << 1"),
@@ -83,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");
@@ -99,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);
@@ -144,7 +234,7 @@ TESTCASE(Slice)
 {
   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", 7);
   vec.call("push", 8);
@@ -180,7 +270,7 @@ 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);
 
@@ -197,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);
 
@@ -214,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");
@@ -238,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);
@@ -278,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
@@ -318,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));
@@ -343,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);
@@ -358,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));
@@ -378,7 +468,7 @@ namespace
     {
     };
 
-    bool operator==(const Comparable& other)
+    bool operator==(const Comparable& other) const
     {
       return this->value_ == other.value_;
     }
@@ -398,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");
   
@@ -448,7 +538,7 @@ TESTCASE(ComparableButNotBool)
   define_class<ComparableButNotBool>("IsComparableButNotBool").
     define_constructor(Constructor<ComparableButNotBool, uint32_t>());
 
-  Class c = define_vector<std::vector<ComparableButNotBool>>("ComparableButNotBoolVector");
+  Class c = define_vector<ComparableButNotBool>("ComparableButNotBoolVector");
 
   Object vec = c.call("new");
   vec.call("push", ComparableButNotBool(1));
@@ -473,7 +563,7 @@ 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);
@@ -488,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));
@@ -526,7 +616,7 @@ TESTCASE(AutoRegisterReturn)
 
   Module m = define_module("Testing");
   Object vec = m.module_eval("return_complex_vector");
-  ASSERT_EQUAL(u8"Rice::Std::Vector≺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
@@ -536,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()));
 }
@@ -552,7 +636,7 @@ TESTCASE(AutoRegisterParameter)
 {
   define_global_function("pass_complex_vector", &passComplexVector);
 
-  std::string code = u8R"(vector = Rice::Std::Vector≺complex≺double≻≻.new
+  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))";
@@ -561,7 +645,7 @@ TESTCASE(AutoRegisterParameter)
   Object vec = m.module_eval(code);
 
   Object result = vec.call("size");
-  ASSERT_EQUAL(u8"Rice::Std::Vector≺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);
@@ -579,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");
@@ -598,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"
@@ -777,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)
@@ -809,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
@@ -898,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;
   }
 }
@@ -910,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
@@ -953,41 +1050,70 @@ TESTCASE(MyClass2PointerVector)
  ASSERT_EQUAL("Hello MyClass2", pMyClass->name);
 }
 
-TESTCASE(BoolVector)
+namespace
 {
-  Class boolVecClass = define_vector<std::vector<bool>>("BoolVector");
+  bool typeCheckValue(std::vector<std::string> vec)
+  {
+    return true;
+  }
 
-  Object vec = boolVecClass.call("new");
-  vec.call("resize", 3, true);
+  bool typeCheckRef(std::vector<std::string>& vec)
+  {
+    return true;
+  }
 
-  Object result = vec.call("size");
-  ASSERT_EQUAL(3, detail::From_Ruby<int32_t>().convert(result));
-  result = vec.call("first");
+  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());
 
-  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));
+  code = R"(vec = Std::Vector≺string≻.new
+            check_ref(vec))";
+  result = m.module_eval(code);
+  ASSERT_EQUAL(Qtrue, result.value());
 
-  result = vec.call("[]", 0);
+  code = R"(vec = Std::Vector≺string≻.new
+            check_ptr(vec))";
+  result = m.module_eval(code);
   ASSERT_EQUAL(Qtrue, result.value());
 
-  result = vec.call("[]=", 1, false);
-  ASSERT_EQUAL(Qfalse, result.value());
+  code = R"(vec = Std::Vector≺int≻.new
+            check_value(vec))";
 
-  std::string code = R"(array = self.each.to_a
-                        array == [true, false, true])";
+  ASSERT_EXCEPTION_CHECK(
+    Exception,
+    result = m.module_eval(code),
+    ASSERT_EQUAL("wrong argument type Std::Vector≺int≻ (expected Std::Vector≺string≻)", ex.what()));
 
-  result = vec.instance_eval(code);
-  ASSERT_EQUAL(Qtrue, result.value());
+  code = R"(vec = Std::Vector≺int≻.new
+            check_ref(vec))";
 
-  result = vec.call("delete", 1);
-  ASSERT_EQUAL(Qtrue, result.value());
-  result = vec.call("size");
-  ASSERT_EQUAL(2, detail::From_Ruby<int32_t>().convert(result));
+  ASSERT_EXCEPTION_CHECK(
+    Exception,
+    result = m.module_eval(code),
+    ASSERT_EQUAL("wrong argument type Std::Vector≺int≻ (expected Std::Vector≺string≻)", ex.what()));
 
-  vec.call("clear");
-  result = vec.call("size");
-  ASSERT_EQUAL(0, detail::From_Ruby<int32_t>().convert(result));
-}
+  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()));
+}