rice 3.0.0 → 4.0.0

data/test/test_Stl_Vector.cpp

@@ -0,0 +1,652 @@
+#include <complex>
+#include <memory>
+
+#include "unittest.hpp"
+#include "embed_ruby.hpp"
+#include <rice/rice.hpp>
+#include <rice/stl.hpp>
+
+using namespace Rice;
+
+TESTSUITE(Vector);
+
+SETUP(Vector)
+{
+  embed_ruby();
+}
+
+namespace
+{
+
+  class MyClass
+  {
+  public:
+    std::vector<std::string> stringVector()
+    {
+      std::vector<std::string> result{ "One", "Two", "Three" };
+      return result;
+    }
+  };
+}
+
+Class makeVectorClass()
+{
+  Class c= define_class<MyClass>("MyClass").
+    define_constructor(Constructor<MyClass>()).
+    define_method("stringVector", &MyClass::stringVector);
+
+  return c;
+}
+
+TESTCASE(StringVector)
+{
+  Module m = define_module("Testing");
+
+  Class c = define_vector<std::vector<std::string>>("StringVector");
+
+  Object vec = m.instance_eval("$vector = StringVector.new");
+  Object result = vec.call("size");
+  ASSERT_EQUAL(0, detail::From_Ruby<int32_t>().convert(result));
+
+  m.instance_eval("$vector << 'one' << 'two' << 'two' << 'three'");
+  result = vec.call("size");
+  ASSERT_EQUAL(4, detail::From_Ruby<int32_t>().convert(result));
+
+  m.instance_eval("$vector.append('four')");
+  result = vec.call("size");
+  ASSERT_EQUAL(5, detail::From_Ruby<int32_t>().convert(result));
+
+  result = vec.call("first");
+  ASSERT_EQUAL("one", detail::From_Ruby<std::string>().convert(result));
+
+  result = vec.call("last");
+  ASSERT_EQUAL("four", detail::From_Ruby<std::string>().convert(result));
+}
+
+TESTCASE(WrongType)
+{
+  Module m = define_module("Testing");
+
+  Class c = define_vector<std::vector<std::string>>("StringVector");
+
+  Object vec = m.instance_eval("$vector = StringVector.new");
+  ASSERT_EXCEPTION_CHECK(
+    Exception,
+    m.instance_eval("$vector << 1"),
+    ASSERT_EQUAL("wrong argument type Integer (expected String)", ex.what()));
+}
+
+TESTCASE(Empty)
+{
+  Module m = define_module("Testing");
+
+  Class c = define_vector<std::vector<std::int32_t>>("IntVector");
+  Object vec = c.call("new");
+
+  Object result = vec.call("size");
+  ASSERT_EQUAL(0, detail::From_Ruby<int32_t>().convert(result));
+
+  result = vec.call("empty?");
+  ASSERT_EQUAL(Qtrue, result.value());
+
+  result = vec.call("first");
+  ASSERT_EQUAL(Qnil, result.value());
+
+  result = vec.call("last");
+  ASSERT_EQUAL(Qnil, result.value());
+}
+
+TESTCASE(Indexing)
+{
+  Module m = define_module("Testing");
+
+  Class c = define_vector<std::vector<std::int32_t>>("IntVector");
+  Object vec = c.call("new");
+  vec.call("push", 0);
+  vec.call("push", 1);
+  vec.call("push", 2);
+  
+  Object result = vec.call("size");
+  ASSERT_EQUAL(3, detail::From_Ruby<int32_t>().convert(result));
+
+  result = vec.call("[]", 0);
+  ASSERT_EQUAL(0, detail::From_Ruby<int32_t>().convert(result));
+
+  result = vec.call("[]", 1);
+  ASSERT_EQUAL(1, detail::From_Ruby<int32_t>().convert(result));
+
+  result = vec.call("[]", 2);
+  ASSERT_EQUAL(2, detail::From_Ruby<int32_t>().convert(result));
+
+  result = vec.call("[]", 3);
+  ASSERT_EQUAL(Qnil, result.value());
+
+  result = vec.call("[]", -1);
+  ASSERT_EQUAL(2, detail::From_Ruby<int32_t>().convert(result));
+
+  result = vec.call("[]", -2);
+  ASSERT_EQUAL(1, detail::From_Ruby<int32_t>().convert(result));
+
+  result = vec.call("[]", -3);
+  ASSERT_EQUAL(0, detail::From_Ruby<int32_t>().convert(result));
+
+  result = vec.call("[]", -4);
+  ASSERT_EQUAL(2, detail::From_Ruby<int32_t>().convert(result));
+
+  result = vec.call("[]", -7);
+  ASSERT_EQUAL(2, detail::From_Ruby<int32_t>().convert(result));
+}
+
+TESTCASE(Sizing)
+{
+  Module m = define_module("Testing");
+
+  Class c = define_vector<std::vector<std::int32_t>>("IntVector");
+  Object vec = c.call("new");
+  vec.call("resize", 10);
+
+  Object result = vec.call("size");
+  ASSERT_EQUAL(10, 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(ToString)
+{
+  Module m = define_module("Testing");
+
+  Class c = define_vector<std::vector<std::int32_t>>("IntVector");
+  Object vec = c.call("new");
+  vec.call("resize", 3);
+
+  Object result = vec.call("to_s");
+  ASSERT_EQUAL("[0, 0, 0]", detail::From_Ruby<std::string>().convert(result));
+
+  vec.call("clear");
+
+  result = vec.call("to_s");
+  ASSERT_EQUAL("[]", detail::From_Ruby<std::string>().convert(result));
+}
+
+TESTCASE(Update)
+{
+  Module m = define_module("Testing");
+
+  Class c = define_vector<std::vector<std::string>>("StringVector");
+  Object vec = c.call("new");
+  vec.call("push", "original 1");
+  vec.call("push", "original 2");
+
+  Object result = vec.call("size");
+  ASSERT_EQUAL(2, detail::From_Ruby<int32_t>().convert(result));
+
+  result = vec.call("[]=", 1, "new 2");
+  ASSERT_EQUAL("new 2", detail::From_Ruby<std::string>().convert(result));
+
+  result = vec.call("[]", 1);
+  ASSERT_EQUAL("new 2", detail::From_Ruby<std::string>().convert(result));
+
+  ASSERT_EXCEPTION_CHECK(
+    Exception,
+    result = vec.call("[]=", 99999, "new 2"),
+    ASSERT_EQUAL("Invalid index: 99999", ex.what()));
+}
+
+TESTCASE(Modify)
+{
+  Module m = define_module("Testing");
+
+  Class c = define_vector<std::vector<int64_t>>("Int64Vector");
+  Object vec = c.call("new");
+
+  Object result = vec.call("push", 11);
+  ASSERT(result.is_equal(vec));
+
+  result = vec.call("push", 22);
+  ASSERT(result.is_equal(vec));
+
+  result = vec.call("size");
+  ASSERT_EQUAL(2, detail::From_Ruby<int32_t>().convert(result));
+
+  result = vec.call("insert", 1, 33);
+  ASSERT(result.is_equal(vec));
+
+  result = vec.call("to_s");
+  ASSERT_EQUAL("[11, 33, 22]", detail::From_Ruby<std::string>().convert(result));
+
+  result = vec.call("delete", 11);
+  ASSERT_EQUAL(11, detail::From_Ruby<int64_t>().convert(result));
+
+  result = vec.call("size");
+  ASSERT_EQUAL(2, detail::From_Ruby<int32_t>().convert(result));
+
+  result = vec.call("delete_at", 0);
+  ASSERT_EQUAL(33, detail::From_Ruby<int64_t>().convert(result));
+
+  result = vec.call("size");
+  ASSERT_EQUAL(1, detail::From_Ruby<int32_t>().convert(result));
+
+  result = vec.call("pop");
+  ASSERT_EQUAL(22, detail::From_Ruby<int64_t>().convert(result));
+
+  result = vec.call("size");
+  ASSERT_EQUAL(0, detail::From_Ruby<int32_t>().convert(result));
+
+  result = vec.call("pop");
+  ASSERT_EQUAL(Qnil, result.value());
+}
+
+TESTCASE(Copy)
+{
+  Module m = define_module("Testing");
+
+  Class c = define_vector<std::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);
+
+  ASSERT_EQUAL(vec.size(), vecCopy.size());
+  ASSERT_EQUAL(vec[0], vecCopy[0]);
+  ASSERT_EQUAL(vec[1], vecCopy[1]);
+
+  vecCopy.push_back(33.3);
+  ASSERT_NOT_EQUAL(vec.size(), vecCopy.size());
+}
+
+TESTCASE(Iterate)
+{
+  Module m = define_module("Testing");
+  Class c = define_vector<std::vector<double>>("DoubleVector");
+
+  std::string code = R"(vector = DoubleVector.new
+                        vector << 5.0 << 6.0 << 7.0
+                        updated = vector.map do |value|
+                                    value * 2.0
+                                  end)";
+
+  Array result = m.instance_eval(code);
+  ASSERT_EQUAL(3, result.size());
+  ASSERT_EQUAL(10.0, detail::From_Ruby<double>().convert(result[0].value()));
+  ASSERT_EQUAL(12.0, detail::From_Ruby<double>().convert(result[1].value()));
+  ASSERT_EQUAL(14.0, detail::From_Ruby<double>().convert(result[2].value()));
+}
+
+namespace
+{
+  class NotComparable
+  {
+  public:
+    NotComparable(uint32_t value) : value_(value)
+    {
+    };
+
+    uint32_t value_;
+  };
+}
+
+TESTCASE(NotComparable)
+{
+  define_class<NotComparable>("NotComparable").
+    define_constructor(Constructor<NotComparable, uint32_t>());
+
+  Class c = define_vector<std::vector<NotComparable>>("NotComparableVector");
+
+  Object vec = c.call("new");
+  vec.call("push", NotComparable(1));
+  vec.call("push", NotComparable(2));
+  vec.call("push", NotComparable(3));
+
+  Object result = vec.call("delete", NotComparable(1));
+  ASSERT_EQUAL(Qnil, result.value());
+
+  result = vec.call("length");
+  ASSERT_EQUAL(3, detail::From_Ruby<size_t>().convert(result));
+
+  result = vec.call("include?", NotComparable(2));
+  ASSERT_EQUAL(Qfalse, result.value());
+
+  result = vec.call("index", NotComparable(3));
+  ASSERT_EQUAL(Qnil, result.value());
+}
+
+TESTCASE(NotDefaultConstructable)
+{
+  define_class<NotComparable>("NotComparable").
+    define_constructor(Constructor<NotComparable, uint32_t>());
+    
+  Class c = define_vector<std::vector<NotComparable>>("NotComparableVector");
+  Object vec = c.call("new");
+
+  Object result = vec.call("resize", 10);
+  ASSERT_EQUAL(Qnil, result.value());
+
+  result = vec.call("length");
+  ASSERT_EQUAL(0, detail::From_Ruby<size_t>().convert(result));
+}
+
+TESTCASE(NotPrintable)
+{
+  define_class<NotComparable>("NotComparable").
+    define_constructor(Constructor<NotComparable, uint32_t>());
+
+  Class c = define_vector<std::vector<NotComparable>>("NotComparableVector");
+
+  Object vec = c.call("new");
+  vec.call("push", NotComparable(1));
+  vec.call("push", NotComparable(2));
+  vec.call("push", NotComparable(3));
+
+  Object result = vec.call("to_s");
+  ASSERT_EQUAL("[Not printable]", detail::From_Ruby<std::string>().convert(result));
+}
+
+namespace
+{
+  class Comparable
+  {
+  public:
+    Comparable(uint32_t value) : value_(value)
+    {
+    };
+
+    bool operator==(const Comparable& other)
+    {
+      return this->value_ == other.value_;
+    }
+
+    uint32_t value_;
+  };
+
+  inline std::ostream& operator<<(std::ostream& stream, Comparable const& comparable)
+  {
+    stream << "Comparable(" << std::to_string(comparable.value_) << ")";
+    return stream;
+  }
+}
+
+TESTCASE(Comparable)
+{
+  define_class<Comparable>("IsComparable").
+    define_constructor(Constructor<Comparable, uint32_t>());
+
+  Class c = define_vector<std::vector<Comparable>>("ComparableVector");
+
+  Object vec = c.call("new");
+  
+  Comparable comparable1(1);
+  vec.call("push", comparable1);
+
+  Comparable comparable2(2);
+  vec.call("push", comparable2);
+
+  Comparable comparable3(3);
+  vec.call("push", comparable3);
+
+  Object result = vec.call("delete", Comparable(1));
+  Comparable comparable = detail::From_Ruby<Comparable>().convert(result);
+  ASSERT_EQUAL(1, comparable.value_);
+
+  result = vec.call("length");
+  ASSERT_EQUAL(2, detail::From_Ruby<size_t>().convert(result));
+
+  result = vec.call("include?", Comparable(2));
+  ASSERT_EQUAL(Qtrue, result.value());
+
+  result = vec.call("index", Comparable(3));
+  ASSERT_EQUAL(1, detail::From_Ruby<size_t>().convert(result.value()));
+}
+
+TESTCASE(DefaultConstructable)
+{
+  define_class<Comparable>("IsComparable").
+    define_constructor(Constructor<Comparable, uint32_t>());
+
+  Class c = define_vector<std::vector<Comparable>>("ComparableVector");
+  Object vec = c.call("new");
+
+  Object result = vec.call("resize", 10);
+  ASSERT_EQUAL(Qnil, result.value());
+
+  result = vec.call("length");
+  ASSERT_EQUAL(0, detail::From_Ruby<size_t>().convert(result));
+}
+
+TESTCASE(Printable)
+{
+  define_class<Comparable>("IsComparable").
+    define_constructor(Constructor<Comparable, uint32_t>());
+
+  Class c = define_vector<std::vector<Comparable>>("ComparableVector");
+
+  Object vec = c.call("new");
+  vec.call("push", Comparable(1));
+  vec.call("push", Comparable(2));
+  vec.call("push", Comparable(3));
+
+  Object result = vec.call("to_s");
+  ASSERT_EQUAL("[Comparable(1), Comparable(2), Comparable(3)]", detail::From_Ruby<std::string>().convert(result));
+}
+
+namespace
+{
+  std::vector<std::complex<uint32_t>> returnComplexVector()
+  {
+    std::complex<uint32_t> complex1(1, 1);
+    std::complex<uint32_t> complex2(2, 2);
+    std::complex<uint32_t> complex3(3, 3);
+
+    std::vector<std::complex<uint32_t>> result;
+    result.push_back(complex1);
+    result.push_back(complex2);
+    result.push_back(complex3);
+    return result;
+  }
+
+  std::vector<std::complex<double>> passComplexVector(std::vector<std::complex<double>>& complexes)
+  {
+    return complexes;
+  }
+}
+
+TESTCASE(AutoRegisterReturn)
+{
+  define_global_function("return_complex_vector", &returnComplexVector);
+
+  Module m = define_module("Testing");
+  Object vec = m.instance_eval("return_complex_vector");
+  ASSERT_EQUAL("Rice::Std::Vector__complex__unsignedInt___allocator__complex__unsignedInt______", vec.class_name().str());
+
+  std::string code = R"(vector = return_complex_vector
+                        complex = vector.last
+                        complex == Complex(3, 3))";
+
+  Object result = m.instance_eval(code);
+  ASSERT_EQUAL(Qtrue, result.value());
+}
+
+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))";
+
+  Module m = define_module("Testing");
+  Object vec = m.instance_eval(code);
+
+  Object result = vec.call("size");
+  ASSERT_EQUAL("Rice::Std::Vector__complex__double___allocator__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);
+  ASSERT_EQUAL(complexes[0], std::complex<double>(4, 4));
+  ASSERT_EQUAL(complexes[1], std::complex<double>(5, 5));
+}
+
+namespace
+{
+  std::vector<std::string> defaultVector(std::vector<std::string> strings = {"one", "two", "three"})
+  {
+    return strings;
+  }
+}
+
+TESTCASE(DefaultValue)
+{
+  define_vector<std::vector<std::string>>("StringVector");
+  define_global_function("default_vector", &defaultVector, Arg("strings") = std::vector<std::string> { "one", "two", "three" });
+
+  Module m = define_module("Testing");
+  Object result = m.instance_eval("default_vector");
+  std::vector<std::string> actual = detail::From_Ruby<std::vector<std::string>>().convert(result);
+
+  std::vector<std::string> expected{ "one", "two", "three" };
+
+  ASSERT_EQUAL(expected.size(), actual.size());
+  ASSERT_EQUAL(expected[0], actual[0]);
+  ASSERT_EQUAL(expected[1], actual[1]);
+  ASSERT_EQUAL(expected[2], actual[2]);
+}
+
+namespace
+{
+  std::vector<int> ints;
+  std::vector<float> floats;
+  std::vector<std::string> strings;
+
+  void arrayToVector(std::vector<int> aInts, std::vector<float> aFloats, std::vector<std::string> aStrings)
+  {
+    ints = aInts;
+    floats = aFloats;
+    strings = aStrings;
+  }
+
+  void arrayToVectorRefs(std::vector<int>& aInts, std::vector<float>& aFloats, std::vector<std::string>& aStrings)
+  {
+    ints = aInts;
+    floats = aFloats;
+    strings = aStrings;
+  }
+
+  void arrayToVectorPointers(std::vector<int>* aInts, std::vector<float>* aFloats, std::vector<std::string>* aStrings)
+  {
+    ints = *aInts;
+    floats = *aFloats;
+    strings = *aStrings;
+  }
+}
+
+TESTCASE(ArrayToVector)
+{
+  define_global_function("array_to_vector", &arrayToVector);
+
+  Module m = define_module("Testing");
+
+  std::string code = "array_to_vector([7, 9, 1_000_000], [49.0, 78.0, 999.0], %w[one two three])";
+  m.instance_eval(code);
+
+  ASSERT_EQUAL(3, ints.size());
+  ASSERT_EQUAL(7, ints[0]);
+  ASSERT_EQUAL(9, ints[1]);
+  ASSERT_EQUAL(1'000'000, ints[2]);
+
+  ASSERT_EQUAL(3, floats.size());
+  ASSERT_EQUAL(49.0, floats[0]);
+  ASSERT_EQUAL(78.0, floats[1]);
+  ASSERT_EQUAL(999.0, floats[2]);
+
+  ASSERT_EQUAL(3, strings.size());
+  ASSERT_EQUAL("one", strings[0]);
+  ASSERT_EQUAL("two", strings[1]);
+  ASSERT_EQUAL("three", strings[2]);
+}
+
+TESTCASE(ArrayToVectorRefs)
+{
+  define_global_function("array_to_vector_refs", &arrayToVectorRefs);
+
+  Module m = define_module("Testing");
+
+  std::string code = "array_to_vector_refs([8, 10, 1_000_001], [50.0, 79.0, 1_000.0], %w[eleven twelve thirteen])";
+  m.instance_eval(code);
+
+  ASSERT_EQUAL(3, ints.size());
+  ASSERT_EQUAL(8, ints[0]);
+  ASSERT_EQUAL(10, ints[1]);
+  ASSERT_EQUAL(1'000'001, ints[2]);
+
+  ASSERT_EQUAL(3, floats.size());
+  ASSERT_EQUAL(50.0, floats[0]);
+  ASSERT_EQUAL(79.0, floats[1]);
+  ASSERT_EQUAL(1'000.0, floats[2]);
+
+  ASSERT_EQUAL(3, strings.size());
+  ASSERT_EQUAL("eleven", strings[0]);
+  ASSERT_EQUAL("twelve", strings[1]);
+  ASSERT_EQUAL("thirteen", strings[2]);
+}
+
+TESTCASE(ArrayToVectorPointers)
+{
+  define_global_function("array_to_vector_pointers", &arrayToVectorPointers);
+
+  Module m = define_module("Testing");
+
+  std::string code = "array_to_vector_pointers([9, 11, 1_000_002], [51.0, 80.0, 1_001.0], %w[fourteen fifteen sixteen])";
+  m.instance_eval(code);
+
+  ASSERT_EQUAL(3, ints.size());
+  ASSERT_EQUAL(9, ints[0]);
+  ASSERT_EQUAL(11, ints[1]);
+  ASSERT_EQUAL(1'000'002, ints[2]);
+
+  ASSERT_EQUAL(3, floats.size());
+  ASSERT_EQUAL(51.0, floats[0]);
+  ASSERT_EQUAL(80.0, floats[1]);
+  ASSERT_EQUAL(1'001.0, floats[2]);
+
+  ASSERT_EQUAL(3, strings.size());
+  ASSERT_EQUAL("fourteen", strings[0]);
+  ASSERT_EQUAL("fifteen", strings[1]);
+  ASSERT_EQUAL("sixteen", strings[2]);
+}
+
+TESTCASE(ArrayToVectorWrongTypes)
+{
+  define_global_function("array_to_vector", &arrayToVector);
+
+  Module m = define_module("Testing");
+
+  std::string code = "array_to_vector([7, 9, 1_000_000], [49.0, 78.0, 999.0], [50.0, 79.0, 1000.0])";
+
+  ASSERT_EXCEPTION_CHECK(
+    Exception,
+    m.instance_eval(code),
+    ASSERT_EQUAL("wrong argument type Float (expected String)", ex.what())
+  );
+}
+
+TESTCASE(ArrayToVectorMixedTypes)
+{
+  define_global_function("array_to_vector", &arrayToVector);
+
+  Module m = define_module("Testing");
+
+  std::string code = "array_to_vector([7, 'nine', true], [49.0, 78.0, 999.0], %w[one two three])";
+
+  ASSERT_EXCEPTION_CHECK(
+    Exception,
+    m.instance_eval(code),
+    ASSERT_EQUAL("no implicit conversion of String into Integer", ex.what())
+  );
+}