rice 4.3.2 → 4.5.0

data/test/test_Stl_Vector.cpp

@@ -1,4 +1,4 @@
-#include <complex>
+#include <complex>
 
 #include "unittest.hpp"
 #include "embed_ruby.hpp"
@@ -14,9 +14,13 @@ SETUP(Vector)
   embed_ruby();
 }
 
-namespace
+TEARDOWN(Vector)
 {
+  rb_gc_start();
+}
 
+namespace
+{
   class MyClass
   {
   public:
@@ -136,6 +140,42 @@ TESTCASE(Indexing)
   ASSERT_EQUAL(2, detail::From_Ruby<int32_t>().convert(result));
 }
 
+TESTCASE(Slice)
+{
+  Module m = define_module("Testing");
+
+  Class c = define_vector<std::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");
@@ -385,6 +425,49 @@ 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<std::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").
@@ -443,7 +526,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(u8"Rice::Std::Vector≺complex≺double≻≻", vec.class_name().str());
 
   std::string code = R"(vector = return_complex_vector
                         complex = vector.last
@@ -469,16 +552,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 = u8R"(vector = Rice::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(u8"Rice::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);
@@ -869,3 +952,42 @@ TESTCASE(MyClass2PointerVector)
  MyClass2* pMyClass = (*result)[0];
  ASSERT_EQUAL("Hello MyClass2", pMyClass->name);
 }
+
+TESTCASE(BoolVector)
+{
+  Class boolVecClass = define_vector<std::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));
+}

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"));

data/test/test_Template.cpp

@@ -0,0 +1,192 @@
+#include <assert.h> 
+
+#include "unittest.hpp"
+#include "embed_ruby.hpp"
+#include <rice/rice.hpp>
+#include <rice/stl.hpp>
+
+using namespace Rice;
+
+TESTSUITE(Template);
+
+SETUP(Template)
+{
+  embed_ruby();
+}
+
+TEARDOWN(Template)
+{
+  rb_gc_start();
+}
+
+namespace
+{
+  template<typename T>
+  class MyVector
+  {
+  public:
+    MyVector() = default;
+
+    void add(T& element)
+    {
+      this->vector_.push_back(element);
+      this->empty = false;
+    }
+
+    size_t size()
+    {
+      return this->vector_.size();
+    }
+
+    bool empty = true;
+  private:
+    std::vector<T> vector_;
+  };
+}
+
+template<typename Data_Type_T, typename T>
+void MyVector_builder(Data_Type_T& klass)
+{
+  klass.define_constructor(Constructor<MyVector<T>>())
+    .define_method("add", &MyVector<T>::add)
+    .define_method("size", &MyVector<T>::size)
+    .define_attr("empty", &MyVector<T>::empty, Rice::AttrAccess::Read);
+}
+
+TESTCASE(my_vector)
+{
+  Class C1 = define_class<MyVector<int>>("MyVecInt").
+             define(&MyVector_builder<Data_Type<MyVector<int>>, int>);
+
+  Object o1 = C1.create();
+  Object result1 = o1.instance_eval("empty");
+  ASSERT_EQUAL(Qtrue, result1.value());
+
+  result1 = o1.instance_eval("size");
+  ASSERT_EQUAL(0, detail::From_Ruby<int>().convert(result1.value()));
+
+  o1.call("add", 5);
+  result1 = o1.instance_eval("empty");
+  ASSERT_EQUAL(Qfalse, o1.instance_eval("empty").value());
+
+  result1 = o1.instance_eval("size");
+  ASSERT_EQUAL(1, detail::From_Ruby<int>().convert(result1.value()));
+
+  Class C2 = define_class<MyVector< std::string>>("MyVecInt").
+             define(&MyVector_builder<Data_Type<MyVector<std::string>>, std::string>);
+
+  Object o2 = C2.create();
+  Object result2 = o2.instance_eval("empty");
+  ASSERT_EQUAL(Qtrue, result2.value());
+
+  result2 = o2.instance_eval("size");
+  ASSERT_EQUAL(0, detail::From_Ruby<int>().convert(result2.value()));
+
+  o2.call("add", "five");
+  result2 = o2.instance_eval("empty");
+  ASSERT_EQUAL(Qfalse, result2.value());
+
+  result2 = o2.instance_eval("size");
+  ASSERT_EQUAL(1, detail::From_Ruby<int>().convert(result2.value()));
+}
+
+namespace
+{
+  template<typename T, int Rows, int Columns>
+  class Matrix
+  {
+  public:
+    int rows() const
+    {
+      return Rows;
+    }
+
+    int cols() const
+    {
+      return Columns;
+    }
+  };
+
+  template<typename T, int N>
+  class Scalar : public Matrix<T, N, 1>
+  {
+  public:
+    int size() const
+    {
+      return N;
+    }
+  };
+}
+
+template<typename Data_Type_T, typename T, int Rows, int Columns>
+void Matrix_builder(Data_Type_T& klass)
+{
+  klass.define_constructor(Constructor<Matrix<T, Rows, Columns>>())
+    .define_method("rows", &Matrix<T, Rows, Columns>::rows)
+    .define_method("cols", &Matrix<T, Rows, Columns>::cols);
+}
+
+template<typename Data_Type_T, typename T, int N>
+void Scalar_builder(Data_Type_T& klass)
+{
+  klass.define_constructor(Constructor<Scalar<T, N>>())
+    .define_method("size", &Scalar<T, N>::size);
+}
+
+TESTCASE(matrix)
+{
+  Class C = define_class<Matrix<float, 5, 4>>("Matrixf54").
+    define(&Matrix_builder<Data_Type<Matrix<float, 5, 4>>, float, 5, 4>);
+
+  Object o = C.create();
+
+  Object result = o.instance_eval("cols");
+  ASSERT_EQUAL(4, detail::From_Ruby<int>().convert(result.value()));
+}
+
+TESTCASE(duplicate_template)
+{
+  Class C1 = define_class<Matrix<float, 6, 4>>("MatrixFirst").
+    define(&Matrix_builder<Data_Type<Matrix<float, 6, 4>>, float, 6, 4>);
+
+  String name = C1.name();
+  ASSERT_EQUAL("MatrixFirst", name.str());
+
+  Object aClass1 = Object(rb_cObject).instance_eval("MatrixFirst");
+  bool result = aClass1.is_equal(C1);
+  ASSERT(result);
+
+  Class C2 = define_class<Matrix<float, 6, 4>>("MatrixSecond").
+    define(&Matrix_builder<Data_Type<Matrix<float, 6, 4>>, float, 6, 4>);
+
+  // The first definition name is the one that wins!
+  name = C2.name();
+  ASSERT_EQUAL("MatrixFirst", name.str());
+
+  Object aClass2 = Object(rb_cObject).instance_eval("MatrixSecond");
+  result = aClass2.is_equal(C2);
+  ASSERT(result);
+
+  result = C1.is_equal(C2);
+  ASSERT(result);
+}
+
+TESTCASE(template_inheritance)
+{
+  Class MatrixClass = define_class<Matrix<float, 5, 1>>("Matrixf51").
+    define(&Matrix_builder<Data_Type<Matrix<float, 5, 1>>, float, 5, 1>);
+
+  Class ScalarClass = define_class<Scalar<float, 5>, Matrix<float, 5, 1>>("Scalarf5").
+    define(&Scalar_builder<Data_Type<Scalar<float, 5>>, float, 5>);
+
+  Object o = ScalarClass.create();
+
+  Object result = o.instance_eval("size");
+  ASSERT_EQUAL(5, detail::From_Ruby<int>().convert(result.value()));
+
+  result = o.instance_eval("rows");
+  ASSERT_EQUAL(5, detail::From_Ruby<int>().convert(result.value()));
+
+  result = o.instance_eval("cols");
+  ASSERT_EQUAL(1, detail::From_Ruby<int>().convert(result.value()));
+}

data/test/test_To_Ruby.cpp

@@ -0,0 +1,152 @@
+#include "unittest.hpp"
+#include "embed_ruby.hpp"
+#include <rice/rice.hpp>
+
+#include <limits>
+#include <cmath>
+
+using namespace Rice;
+
+TESTSUITE(ToRuby);
+
+SETUP(ToRuby)
+{
+  embed_ruby();
+}
+
+TEARDOWN(ToRuby)
+{
+  rb_gc_start();
+}
+
+TESTCASE(object_to_ruby)
+{
+  Object o(rb_str_new2("foo"));
+  ASSERT_EQUAL(o.value(), detail::to_ruby(o));
+}
+
+TESTCASE(short_to_ruby)
+{
+  ASSERT_EQUAL(INT2NUM(0), detail::to_ruby((short)0));
+  ASSERT_EQUAL(INT2NUM(-1), detail::to_ruby((short)-1));
+  ASSERT_EQUAL(INT2NUM(1), detail::to_ruby((short)1));
+  ASSERT_EQUAL(INT2NUM(std::numeric_limits<short>::min()),
+               detail::to_ruby(std::numeric_limits<short>::min()));
+  ASSERT_EQUAL(INT2NUM(std::numeric_limits<short>::max()),
+               detail::to_ruby(std::numeric_limits<short>::max()));
+}
+
+TESTCASE(int_to_ruby)
+{
+  ASSERT(rb_equal(INT2NUM(0), detail::to_ruby((int)0)));
+  ASSERT(rb_equal(INT2NUM(-1), detail::to_ruby((int)-1)));
+  ASSERT(rb_equal(INT2NUM(1), detail::to_ruby((int)1)));
+  ASSERT(rb_equal(INT2NUM(std::numeric_limits<int>::min()), detail::to_ruby(std::numeric_limits<int>::min())));
+  ASSERT(rb_equal(INT2NUM(std::numeric_limits<int>::max()), detail::to_ruby(std::numeric_limits<int>::max())));
+}
+
+TESTCASE(long_to_ruby)
+{
+  ASSERT(rb_equal(LONG2NUM(0), detail::to_ruby((long)0)));
+  ASSERT(rb_equal(LONG2NUM(-1), detail::to_ruby((long)-1)));
+  ASSERT(rb_equal(LONG2NUM(1), detail::to_ruby((long)1)));
+  ASSERT(rb_equal(LONG2NUM(FIXNUM_MAX), detail::to_ruby(FIXNUM_MAX)));
+  ASSERT(rb_equal(LONG2NUM(FIXNUM_MIN), detail::to_ruby(FIXNUM_MIN)));
+  ASSERT(rb_equal(LONG2NUM(std::numeric_limits<long>::min()), detail::to_ruby(std::numeric_limits<long>::min())));
+  ASSERT(rb_equal(LONG2NUM(std::numeric_limits<long>::max()), detail::to_ruby(std::numeric_limits<long>::max())));
+}
+
+TESTCASE(long_long_to_ruby)
+{
+  ASSERT(rb_equal(LL2NUM(0), detail::to_ruby((long long)0)));
+  ASSERT(rb_equal(LL2NUM(-1), detail::to_ruby((long long)-1)));
+  ASSERT(rb_equal(LL2NUM(1), detail::to_ruby((long long)1)));
+  ASSERT(rb_equal(LL2NUM(std::numeric_limits<long long>::min()), detail::to_ruby(std::numeric_limits<long long>::min())));
+  ASSERT(rb_equal(LL2NUM(std::numeric_limits<long long>::max()), detail::to_ruby(std::numeric_limits<long long>::max())));
+}
+
+TESTCASE(unsigned_short_to_ruby)
+{
+  ASSERT(rb_equal(UINT2NUM(0), detail::to_ruby((unsigned short)0)));
+  ASSERT(rb_equal(UINT2NUM(1), detail::to_ruby((unsigned short)1)));
+  ASSERT(rb_equal(UINT2NUM(std::numeric_limits<unsigned short>::min()), detail::to_ruby(std::numeric_limits<unsigned short>::min())));
+  ASSERT(rb_equal(UINT2NUM(std::numeric_limits<unsigned short>::max()), detail::to_ruby(std::numeric_limits<unsigned short>::max())));
+}
+
+TESTCASE(unsigned_int_to_ruby)
+{
+  ASSERT(rb_equal(UINT2NUM(0), detail::to_ruby((unsigned int)0)));
+  ASSERT(rb_equal(UINT2NUM(1), detail::to_ruby((unsigned int)1)));
+  ASSERT(rb_equal(UINT2NUM(std::numeric_limits<unsigned int>::min()), detail::to_ruby(std::numeric_limits<unsigned int>::min())));
+  ASSERT(rb_equal(UINT2NUM(std::numeric_limits<unsigned int>::max()), detail::to_ruby(std::numeric_limits<unsigned int>::max())));
+}
+
+TESTCASE(unsigned_long_to_ruby)
+{
+  ASSERT(rb_equal(ULONG2NUM(0), detail::to_ruby((unsigned long)0)));
+  ASSERT(rb_equal(ULONG2NUM(1), detail::to_ruby((unsigned long)1)));
+  ASSERT(rb_equal(ULONG2NUM(FIXNUM_MAX), detail::to_ruby(FIXNUM_MAX)));
+  ASSERT(rb_equal(ULONG2NUM(std::numeric_limits<unsigned long>::min()), detail::to_ruby(std::numeric_limits<unsigned long>::min())));
+  ASSERT(rb_equal(ULONG2NUM(std::numeric_limits<unsigned long>::max()), detail::to_ruby(std::numeric_limits<unsigned long>::max())));
+}
+
+TESTCASE(unsigned_long_long_to_ruby)
+{
+  ASSERT(rb_equal(ULL2NUM(0), detail::to_ruby((unsigned long long)0)));
+  ASSERT(rb_equal(ULL2NUM(1), detail::to_ruby((unsigned long long)1)));
+  ASSERT(rb_equal(ULL2NUM(std::numeric_limits<unsigned long long>::min()), detail::to_ruby(std::numeric_limits<unsigned long long>::min())));
+  ASSERT(rb_equal(ULL2NUM(std::numeric_limits<unsigned long long>::max()), detail::to_ruby(std::numeric_limits<unsigned long long>::max())));
+}
+
+TESTCASE(bool_to_ruby)
+{
+  ASSERT(rb_equal(Qfalse, detail::to_ruby(false)));
+  ASSERT(rb_equal(Qtrue, detail::to_ruby(true)));
+}
+
+TESTCASE(float_to_ruby)
+{
+  ASSERT(rb_equal(rb_float_new(0.0f), detail::to_ruby(0.0f)));
+  ASSERT(rb_equal(rb_float_new(-1.0f), detail::to_ruby(-1.0f)));
+  ASSERT(rb_equal(rb_float_new(1.0f), detail::to_ruby(1.0f)));
+  ASSERT(rb_equal(rb_float_new(0.5f), detail::to_ruby(0.5f)));
+  ASSERT(rb_equal(rb_float_new(std::numeric_limits<float>::min()), detail::to_ruby(std::numeric_limits<float>::min())));
+  ASSERT(rb_equal(rb_float_new(std::numeric_limits<float>::max()), detail::to_ruby(std::numeric_limits<float>::max())));
+  ASSERT(Object(detail::to_ruby(std::numeric_limits<float>::quiet_NaN())).call("nan?"));
+  ASSERT(Object(detail::to_ruby(std::numeric_limits<float>::signaling_NaN())).call("nan?"));
+  ASSERT_EQUAL(rb_float_new(std::numeric_limits<float>::epsilon()),
+               detail::to_ruby(std::numeric_limits<float>::epsilon()));
+}
+
+TESTCASE(double_to_ruby)
+{
+  ASSERT(rb_equal(rb_float_new(0.0f), detail::to_ruby(0.0f)));
+  ASSERT(rb_equal(rb_float_new(-1.0f), detail::to_ruby(-1.0f)));
+  ASSERT(rb_equal(rb_float_new(1.0f), detail::to_ruby(1.0f)));
+  ASSERT(rb_equal(rb_float_new(0.5f), detail::to_ruby(0.5f)));
+  ASSERT(rb_equal(rb_float_new(std::numeric_limits<double>::min()), detail::to_ruby(std::numeric_limits<double>::min())));
+  ASSERT(rb_equal(rb_float_new(std::numeric_limits<double>::max()), detail::to_ruby(std::numeric_limits<double>::max())));
+  ASSERT(Object(detail::to_ruby(std::numeric_limits<double>::quiet_NaN())).call("nan?"));
+  ASSERT(Object(detail::to_ruby(std::numeric_limits<double>::signaling_NaN())).call("nan?"));
+  ASSERT(rb_equal(rb_float_new(std::numeric_limits<double>::epsilon()), detail::to_ruby(std::numeric_limits<double>::epsilon())));
+}
+
+TESTCASE(char_ptr_to_ruby)
+{
+  detail::To_Ruby<char*> toRuby;
+  ASSERT(rb_equal(String("").value(), toRuby.convert("")));
+  ASSERT(rb_equal(String("A string").value(), toRuby.convert("A string")));
+  ASSERT(rb_equal(Qnil, toRuby.convert(nullptr)));
+}
+
+TESTCASE(char_const_ptr_to_ruby)
+{
+  ASSERT(rb_equal(String("").value(), detail::to_ruby((char const *)"")));
+  ASSERT(rb_equal(String("foo").value(), detail::to_ruby((char const *)"foo")));
+  ASSERT(rb_equal(String("foo").value(), detail::to_ruby("foo")));
+}
+
+TESTCASE(char_const_array_to_ruby_symbol)
+{
+  ASSERT(rb_equal(Symbol("foo").value(), detail::to_ruby(":foo")));
+}

data/test/test_Tracking.cpp

@@ -87,6 +87,7 @@ SETUP(Tracking)
 TEARDOWN(Tracking)
 {
   detail::Registries::instance.instances.isEnabled = true;
+  rb_gc_start();
 }
 
 TESTCASE(TransferPointer)

data/test/test_Type.cpp

@@ -0,0 +1,100 @@
+#include "unittest.hpp"
+#include "embed_ruby.hpp"
+
+#include <rice/rice.hpp>
+
+#include <complex>
+
+using namespace Rice;
+
+TESTSUITE(Type);
+
+namespace Outer
+{
+  namespace Inner
+  {
+    using Vec1 = std::vector<std::complex<float>>;
+    using Vec2 = std::vector<unsigned char*>;
+    using Map1 = std::map<std::string, std::vector<std::complex<float>>>;
+    using UnorderedMap1 = std::unordered_map<std::string, std::complex<float>>;
+
+    class SomeClass
+    {
+    };
+
+    using Vec3 = std::vector<SomeClass>;
+  }
+}
+
+SETUP(Type)
+{
+  embed_ruby();
+}
+
+TEARDOWN(Type)
+{
+  rb_gc_start();
+}
+
+TESTCASE(FindGroup)
+{
+  std::string name = "class std::vector<class cv::Vec<unsigned char, 2>, class std::allocator<class cv::Vec<unsigned char, 2> > >";
+
+  std::string group = detail::findGroup(name, 0);
+  ASSERT_EQUAL("<class cv::Vec<unsigned char, 2>, class std::allocator<class cv::Vec<unsigned char, 2> > >", group.c_str());
+
+  group = detail::findGroup(name, 18);
+  ASSERT_EQUAL("<unsigned char, 2>", group.c_str());
+  
+  group = detail::findGroup(name, 49);
+  ASSERT_EQUAL("<class cv::Vec<unsigned char, 2> >", group.c_str());
+
+  ASSERT_EXCEPTION_CHECK(
+    std::runtime_error,
+    detail::findGroup(name, 48),
+      ASSERT_EQUAL("Unbalanced Group", ex.what())
+  );
+}
+
+TESTCASE(MakeClassName)
+{
+  std::string typeName = detail::typeName(typeid(Outer::Inner::Vec1));
+  std::string className = detail::makeClassName(typeName);
+  ASSERT_EQUAL(u8"Vector≺complex≺float≻≻", className.c_str());
+
+  typeName = detail::typeName(typeid(Outer::Inner::Vec2));
+  className = detail::makeClassName(typeName);
+  ASSERT_EQUAL(u8"Vector≺unsigned char*≻", className.c_str());
+
+  typeName = detail::typeName(typeid(Outer::Inner::Vec3));
+  className = detail::makeClassName(typeName);
+  ASSERT_EQUAL(u8"Vector≺Outer꞉꞉Inner꞉꞉SomeClass≻", className.c_str());
+
+  typeName = detail::typeName(typeid(Outer::Inner::Map1));
+  className = detail::makeClassName(typeName);
+  ASSERT_EQUAL(u8"Map≺string≺char≻‚ vector≺complex≺float≻≻≻", className.c_str());
+
+  typeName = detail::typeName(typeid(Outer::Inner::UnorderedMap1));
+  className = detail::makeClassName(typeName);
+  ASSERT_EQUAL(u8"UnorderedMap≺string≺char≻‚ complex≺float≻≻", className.c_str());
+}
+
+TESTCASE(MakeRubyClass)
+{
+  std::string typeName = detail::typeName(typeid(Outer::Inner::Vec1));
+  std::string rubyClassName = detail::makeClassName(typeName);
+
+  Module module = define_module("Testing");
+
+  Identifier id(rubyClassName);
+  define_class_under<Outer::Inner::Vec1>(module, id);
+  
+  std::string code = R"(Testing.constants.grep(/Vector/).sort)";
+  
+  Array result = module.module_eval(code);
+  ASSERT_EQUAL(1, result.size());
+
+  // FIXME - fails compilation on GCC
+  // Symbol element = result[0];
+  // ASSERT_EQUAL(u8"Vector≺complex≺float≻≻", element.c_str());
+}