rice 4.6.1 → 4.7.0

data/test/test_GVL.cpp

@@ -0,0 +1,109 @@
+#include "unittest.hpp"
+#include "embed_ruby.hpp"
+#include <rice/rice.hpp>
+
+#include <chrono>
+#include <thread>
+
+using namespace Rice;
+
+TESTSUITE(GVL);
+
+SETUP(GVL)
+{
+  embed_ruby();
+}
+
+TEARDOWN(GVL)
+{
+  rb_gc_start();
+}
+
+namespace
+{
+  int slowFunction1()
+  {
+    std::this_thread::sleep_for(std::chrono::milliseconds(100));
+    return 83;
+  }
+
+  void slowFunction2()
+  {
+    std::this_thread::sleep_for(std::chrono::milliseconds(100));
+  }
+
+  void functionException()
+  {
+		throw std::runtime_error("This is an exception from functionException");
+  }
+
+  class Task
+  {
+    public:
+			Task(int id) : id_(id)
+      {
+      }
+
+      int run(bool arg1)
+      {
+        std::this_thread::sleep_for(std::chrono::milliseconds(100));
+        return this->id_;
+		  }
+
+    private:
+      int id_;
+  };
+}
+
+TESTCASE(Function)
+{
+  int result = detail::no_gvl(&slowFunction1);
+  ASSERT_EQUAL(83, result);
+}
+
+TESTCASE(FunctionViaRuby)
+{
+  Module m = define_module("Testing");
+  m.define_module_function("slow_function_1", &slowFunction1, Function().setNoGvl());
+  
+  std::string code = R"(slow_function_1)";
+  Object result = m.module_eval(code);
+  ASSERT_EQUAL(83, detail::From_Ruby<int>().convert(result));
+}
+
+TESTCASE(FunctionNoReturn)
+{
+  detail::no_gvl(&slowFunction2);
+  ASSERT_EQUAL(true, true);
+}
+
+TESTCASE(FunctionWithException)
+{
+  ASSERT_EXCEPTION_CHECK(
+    std::runtime_error,
+    detail::no_gvl(&functionException),
+    ASSERT_EQUAL("This is an exception from functionException", ex.what())
+  );
+}
+
+TESTCASE(MemberFunction)
+{
+	Task task(84);
+  int result = detail::no_gvl(&Task::run, task, false);
+  ASSERT_EQUAL(84, result);
+}
+
+TESTCASE(MemberFunctionNoGvl)
+{
+  Module m = define_module("Testing");
+
+  Class task = define_class_under<Task>(m, "Task")
+    .define_constructor(Constructor<Task, int>())
+    .define_method("run", &Task::run, Function().setNoGvl());
+
+  std::string code = R"(task = Task.new(85)
+                        task.run(true))";
+
+  Object result = m.module_eval(code);
+  ASSERT_EQUAL(85, detail::From_Ruby<int>().convert(result));
+}

data/test/test_Iterator.cpp

@@ -350,7 +350,7 @@ TESTCASE(IterateNoCopy)
   Data_Object<ContainerValues> wrapper(container);
   Array a = wrapper.instance_eval("self.to_a");
 
-  ASSERT_EQUAL(container.data_.size(), a.size());
+  ASSERT_EQUAL(container.data_.size(), (size_t)a.size());
 
   for (size_t i = 0; i < container.data_.size(); i++)
   {

data/test/test_Keep_Alive_No_Wrapper.cpp

@@ -37,10 +37,12 @@ namespace
         pets_.clear();
       }
 
-    Object getPets(void)    {
+    Object getPets(void)
+    {
       Array pets;
-      for(auto p: pets_) {
-        pets.push(p);
+      for(auto p: pets_)
+      {
+        pets.push(p, false);
       }
       return pets;
     }

data/test/test_Module.cpp

@@ -1,4 +1,4 @@
-#include "unittest.hpp"
+#include "unittest.hpp"
 #include "embed_ruby.hpp"
 
 #include <rice/rice.hpp>
@@ -11,7 +11,6 @@ TESTSUITE(Module);
 SETUP(Module)
 {
   embed_ruby();
-  define_fundamental_buffer_types();
 }
 
 TEARDOWN(Module)
@@ -208,8 +207,8 @@ TESTCASE(include_module)
   ASSERT_EQUAL(&m, &m2);
   Array ancestors(m.ancestors());
   Array expected_ancestors;
-  expected_ancestors.push(m);
-  expected_ancestors.push(Module(rb_mEnumerable));
+  expected_ancestors.push(m, false);
+  expected_ancestors.push(Module(rb_mEnumerable), false);
   ASSERT_EQUAL(expected_ancestors, ancestors);
 }
 
@@ -467,7 +466,7 @@ TESTCASE(define_method_works_with_pointers)
 
   int anInt = 3;
   Buffer<int> buffer(&anInt, 1);
-  m.call("bar", std::move(buffer), "testing");
+  m.call("bar", buffer.ptr(), "testing");
 
   ASSERT_EQUAL(3, with_pointers_x);
   ASSERT_EQUAL("testing", with_pointers_str);
@@ -503,10 +502,10 @@ TESTCASE(pointers)
 
   Module m = define_module("TestingModule");
   std::string code = R"(int_buffer = Rice::Buffer≺int≻.new(32)
-                          bool_buffer = Rice::Buffer≺bool≻.new(true)
-                          double_buffer = Rice::Buffer≺float≻.new(33.0)
-                          float_buffer = Rice::Buffer≺double≻.new(34.0)
-                          with_pointers(int_buffer, bool_buffer, double_buffer, float_buffer))";
+                        bool_buffer = Rice::Buffer≺bool≻.new(true)
+                        double_buffer = Rice::Buffer≺float≻.new(33.0)
+                        float_buffer = Rice::Buffer≺double≻.new(34.0)
+                        with_pointers(int_buffer.data, bool_buffer.data, double_buffer.data, float_buffer.data))";
 
   m.module_eval(code);
 

data/test/test_Object.cpp

@@ -194,7 +194,7 @@ TESTCASE(call_with_keywords)
   Hash keywords;
   keywords[":exception"] = false;
   Object result = m.call_kw("keywords_test", "charlie", keywords);
-  ASSERT_EQUAL("charlie", detail::From_Ruby<const char*>().convert(result.value()));
+  ASSERT_EQUAL("charlie", detail::From_Ruby<char*>().convert(result.value()));
 
   keywords[":exception"] = true;
 

data/test/test_Overloads.cpp

@@ -1,4 +1,4 @@
-#include "unittest.hpp"
+#include "unittest.hpp"
 #include "embed_ruby.hpp"
 #include <rice/rice.hpp>
 #include <rice/stl.hpp>
@@ -652,8 +652,8 @@ TESTCASE(int_conversion_6)
   Module m = define_module("Testing");
 
   std::string code = R"(my_class = MyClass3.new
-                          buffer = Rice::Buffer≺unsigned char≻.new("54")
-                          my_class.run(buffer))";
+                        buffer = Rice::Buffer≺unsigned char≻.new("54")
+                        my_class.run(buffer.data))";
   String result = m.module_eval(code);
   ASSERT_EQUAL("run<unsigned char*>", result.str());
 }

data/test/test_Stl_Map.cpp

@@ -220,7 +220,7 @@ TESTCASE(keysAndValues)
   ASSERT_EQUAL(expected_values[2], values->operator[](2));
 }
 
-TESTCASE(Copy)
+TESTCASE(CLone)
 {
   Module m = define_module("Testing");
 
@@ -231,15 +231,15 @@ TESTCASE(Copy)
   object.call("[]=", "two", 22.2);
   std::map<std::string, double>& map = detail::From_Ruby<std::map<std::string, double>&>().convert(object);
 
-  Object result = object.call("copy");
-  std::map<std::string, double>& mapCopy = detail::From_Ruby<std::map<std::string, double>&>().convert(result);
+  Object result = object.call("clone");
+  std::map<std::string, double>& mapClone = detail::From_Ruby<std::map<std::string, double>&>().convert(result);
 
-  ASSERT_EQUAL(map.size(), mapCopy.size());
-  ASSERT_EQUAL(map["one"], mapCopy["one"]);
-  ASSERT_EQUAL(map["two"], mapCopy["two"]);
+  ASSERT_EQUAL(map.size(), mapClone.size());
+  ASSERT_EQUAL(map["one"], mapClone["one"]);
+  ASSERT_EQUAL(map["two"], mapClone["two"]);
 
-  mapCopy["three"] = 33.3;
-  ASSERT_NOT_EQUAL(map.size(), mapCopy.size());
+  mapClone["three"] = 33.3;
+  ASSERT_NOT_EQUAL(map.size(), mapClone.size());
 }
 
 TESTCASE(Iterate)

data/test/test_Stl_Multimap.cpp

@@ -218,7 +218,7 @@ TESTCASE(keysAndValues)
   ASSERT_EQUAL(expected_values[2], values->operator[](2));
 }
 
-TESTCASE(Copy)
+TESTCASE(Clone)
 {
   Module m = define_module("Testing");
 
@@ -229,10 +229,10 @@ TESTCASE(Copy)
   object.call("insert", "two", 22.2);
   std::multimap<std::string, double>& multimap = detail::From_Ruby<std::multimap<std::string, double>&>().convert(object);
 
-  Object result = object.call("copy");
-  std::multimap<std::string, double>& multimapCopy = detail::From_Ruby<std::multimap<std::string, double>&>().convert(result);
+  Object result = object.call("clone");
+  std::multimap<std::string, double>& multimapClone = detail::From_Ruby<std::multimap<std::string, double>&>().convert(result);
 
-  ASSERT_EQUAL(multimap, multimapCopy);
+  ASSERT_EQUAL(multimap, multimapClone);
 }
 
 TESTCASE(Iterate)

data/test/test_Stl_Pair.cpp

@@ -1,4 +1,4 @@
-#include <utility>
+#include <utility>
 
 #include "unittest.hpp"
 #include "embed_ruby.hpp"
@@ -59,17 +59,19 @@ TESTCASE(CreatePairConst)
   result = pair.call("second");
   ASSERT_EQUAL("pair2", detail::From_Ruby<std::string>().convert(result));
 
+#ifdef _MSC_VER
   ASSERT_EXCEPTION_CHECK(
     Exception,
     pair.call("first=", "A second value"),
-    ASSERT_EQUAL("Cannot set pair.first since it is a constant", ex.what())
+    ASSERT_EQUAL("undefined method 'first=' for an instance of Std::ConstStringPair", ex.what())
   );
 
   ASSERT_EXCEPTION_CHECK(
     Exception,
     pair.call("second=", "A second value"),
-    ASSERT_EQUAL("Cannot set pair.second since it is a constant", ex.what())
+    ASSERT_EQUAL("undefined method 'second=' for an instance of Std::ConstStringPair", ex.what())
   );
+#endif
 }
 
 namespace

data/test/test_Stl_SharedPtr.cpp

@@ -1,4 +1,4 @@
-#include "unittest.hpp"
+#include "unittest.hpp"
 #include "embed_ruby.hpp"
 #include <rice/rice.hpp>
 #include <rice/stl.hpp>
@@ -347,13 +347,30 @@ TESTCASE(Update)
   ASSERT_EQUAL(14, detail::From_Ruby<long>().convert(result.value()));
 }
 
+TESTCASE(Klass)
+{
+  detail::TypeMapper<std::shared_ptr<MyClass>> typeMapper;
+  Object expected = Object(rb_cObject).const_get("MyClass");
+  VALUE actual = typeMapper.rubyKlass();
+  ASSERT_EQUAL(expected.value(), actual);
+}
+
+TESTCASE(KlassSharedPtr)
+{
+  define_shared_ptr<MyClass>();
+  detail::TypeMapper<std::shared_ptr<MyClass>> typeMapper;
+
+  Module stdModule("Std");
+  Object expected = stdModule.const_get("SharedPtr≺AnonymousNamespace꞉꞉MyClass≻");
+  VALUE actual = typeMapper.rubyKlass();
+  ASSERT_EQUAL(expected.value(), actual);
+}
+
 TESTCASE(Void)
 {
   MyClass::reset();
   Factory::reset();
 
-  detail::Type<Buffer<void>>::verify();
-
   Module m = define_module("TestingModule");
 
   // Create ruby objects that point to the same instance of MyClass
@@ -397,8 +414,6 @@ namespace
 
 TESTCASE(PointerToInt)
 {
-  detail::Type<Buffer<int>>::verify();
-
   Module m = define_module("SharedPtrInt").
     define_module_function("create_pointer", &createPointer).
     define_module_function("get_pointer_value", &getPointerValue);
@@ -418,7 +433,7 @@ TESTCASE(CreatePointerToInt)
   define_shared_ptr<int>("SharedPtrInt");
 
   std::string code = R"(buffer = Rice::Buffer≺int≻.new(45)
-                        ptr = Std::SharedPtrInt.new(buffer)
+                        ptr = Std::SharedPtrInt.new(buffer.release)
                         get_pointer_value(ptr))";
 
   Object result = m.instance_eval(code);
@@ -433,7 +448,7 @@ TESTCASE(UpdatePointerToInt)
   define_shared_ptr<int>();
 
   std::string code = R"(buffer = Rice::Buffer≺int≻.new(45)
-                        ptr = Std::SharedPtr≺int≻.new(buffer)
+                        ptr = Std::SharedPtr≺int≻.new(buffer.release)
                         update_pointer_value(ptr))";
 
   Object result = m.instance_eval(code);
@@ -442,14 +457,11 @@ TESTCASE(UpdatePointerToInt)
 
 TESTCASE(ReadPointerToInt)
 {
-  detail::Type<Buffer<int>>::verify();
-
   Module m = define_module("ReadPointerToInt").
-      define_module_function("create_pointer", &createPointer);
+             define_module_function("create_pointer", &createPointer);
 
   std::string code = R"(ptr = create_pointer(50)
-                          buffer = Rice::Buffer≺int≻.new(ptr)
-                          buffer.to_ary(1))";
+                        ptr.buffer.to_ary(1))";
 
   Array array = m.instance_eval(code);
   std::vector<int> actual = array.to_vector<int>();

data/test/test_Stl_Tuple.cpp

@@ -54,7 +54,7 @@ namespace
       ASSERT_EQUAL(3, complex.imag());
        
       std::vector<int> vec = std::get<2>(tuple);
-      ASSERT_EQUAL(3, vec.size());
+      ASSERT_EQUAL((size_t)3, vec.size());
       ASSERT_EQUAL(3, vec[0]);
       ASSERT_EQUAL(4, vec[1]);
       ASSERT_EQUAL(5, vec[2]);

data/test/test_Stl_UniquePtr.cpp

@@ -199,4 +199,12 @@ TESTCASE(Update)
 
   Object result = m.instance_eval(code);
   ASSERT_EQUAL(11, detail::From_Ruby<long>().convert(result.value()));
+}
+
+TESTCASE(Klass)
+{
+  detail::TypeMapper<std::unique_ptr<MyClass>> typeMapper;
+  Object expected = Object(rb_cObject).const_get("MyClass");
+  VALUE actual = typeMapper.rubyKlass();
+  ASSERT_EQUAL(expected.value(), actual);
 }

data/test/test_Stl_Unordered_Map.cpp

@@ -1,4 +1,4 @@
-#include <complex>
+#include <complex>
 #include <memory>
 
 #include "unittest.hpp"
@@ -216,7 +216,7 @@ TESTCASE(KeysAndValues)
   ASSERT_EQUAL(3, values->operator[](2));
 }
 
-TESTCASE(Copy)
+TESTCASE(Clone)
 {
   Module m = define_module("Testing");
 
@@ -227,15 +227,15 @@ TESTCASE(Copy)
   object.call("[]=", "two", 22.2);
   std::unordered_map<std::string, double>& unordered_map = detail::From_Ruby<std::unordered_map<std::string, double>&>().convert(object);
 
-  Object result = object.call("copy");
-  std::unordered_map<std::string, double>& unordered_mapCopy = detail::From_Ruby<std::unordered_map<std::string, double>&>().convert(result);
+  Object result = object.call("clone");
+  std::unordered_map<std::string, double>& unordered_mapClone = detail::From_Ruby<std::unordered_map<std::string, double>&>().convert(result);
 
-  ASSERT_EQUAL(unordered_map.size(), unordered_mapCopy.size());
-  ASSERT_EQUAL(unordered_map["one"], unordered_mapCopy["one"]);
-  ASSERT_EQUAL(unordered_map["two"], unordered_mapCopy["two"]);
+  ASSERT_EQUAL(unordered_map.size(), unordered_mapClone.size());
+  ASSERT_EQUAL(unordered_map["one"], unordered_mapClone["one"]);
+  ASSERT_EQUAL(unordered_map["two"], unordered_mapClone["two"]);
 
-  unordered_mapCopy["three"] = 33.3;
-  ASSERT_NOT_EQUAL(unordered_map.size(), unordered_mapCopy.size());
+  unordered_mapClone["three"] = 33.3;
+  ASSERT_NOT_EQUAL(unordered_map.size(), unordered_mapClone.size());
 }
 
 TESTCASE(Iterate)

data/test/test_Stl_Variant.cpp

@@ -380,6 +380,14 @@ TESTCASE(RoundtripConstRef)
   ASSERT_EQUAL(Qnil, instance2.value());
 }
 
+TESTCASE(Klass)
+{
+  detail::TypeMapper<Variant_T> typeMapper;
+  Object expected = Object(rb_cObject).const_get("Object");
+  VALUE actual = typeMapper.rubyKlass();
+  ASSERT_EQUAL(expected.value(), actual);
+}
+
 namespace
 {
   class MyClass4
@@ -456,8 +464,6 @@ namespace
 
 TESTCASE(Buffer)
 {
-  define_buffer<int>();
-  define_buffer<float>();
   using namespace std::complex_literals;
 
   define_class<MyClass5>("MyClass5").
@@ -476,4 +482,4 @@ TESTCASE(Buffer)
               myclass.buffer(1).to_ary(1).first)";
   result = m.module_eval(code);
   ASSERT_EQUAL(11.0, detail::From_Ruby<float>().convert(result));
-}
+}

data/test/test_Stl_Vector.cpp

@@ -18,7 +18,7 @@ TEARDOWN(Vector)
 {
   rb_gc_start();
 }
-
+/*
 namespace
 {
   class MyClass
@@ -65,6 +65,22 @@ TESTCASE(StringVector)
   result = vec.call("last");
   ASSERT_EQUAL("four", detail::From_Ruby<std::string>().convert(result));
 }
+*/
+TESTCASE(StringVectorData)
+{
+  Module m = define_module("Testing");
+  define_vector<std::string>();
+
+  std::string code = R"(vec = Std::Vector≺string≻.new
+                        vec.push("Hello")
+                        vec.push("World")
+                        buffer = Rice::Buffer≺string≻.new(vec.data, vec.size())
+                        [buffer[0], buffer[1]])";
+  Array array = m.module_eval(code);
+  ASSERT_EQUAL(2, array.size());
+  ASSERT_EQUAL("Hello", detail::From_Ruby<std::string>().convert(array[0].value()).c_str());
+  ASSERT_EQUAL("World", detail::From_Ruby<std::string>().convert(array[1].value()).c_str());
+}
 
 TESTCASE(Constructors)
 {
@@ -171,6 +187,7 @@ TESTCASE(BoolVector)
   ASSERT_EQUAL(Qtrue, result.value());
 
   result = vec.call("[]=", 1, false);
+  result = vec.call("[]", 1);
   ASSERT_EQUAL(Qfalse, result.value());
 
   std::string code = R"(array = self.each.to_a
@@ -224,10 +241,30 @@ TESTCASE(Indexing)
   ASSERT_EQUAL(0, detail::From_Ruby<int32_t>().convert(result));
 
   result = vec.call("[]", -4);
-  ASSERT_EQUAL(2, detail::From_Ruby<int32_t>().convert(result));
+  ASSERT_EQUAL(Qnil, result.value());
 
   result = vec.call("[]", -7);
-  ASSERT_EQUAL(2, detail::From_Ruby<int32_t>().convert(result));
+  ASSERT_EQUAL(Qnil, result.value());
+}
+
+TESTCASE(IndexingEmptyVector)
+{
+  Module m = define_module("Testing");
+
+  Class c = define_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("[]", 0);
+  ASSERT_EQUAL(Qnil, result.value());
+
+  result = vec.call("[]", 1);
+  ASSERT_EQUAL(Qnil, result.value());
+
+  result = vec.call("[]", -1);
+  ASSERT_EQUAL(Qnil, result.value());
 }
 
 TESTCASE(Slice)
@@ -312,8 +349,7 @@ TESTCASE(Update)
   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));
+  vec.call("[]=", 1, "new 2");
 
   result = vec.call("[]", 1);
   ASSERT_EQUAL("new 2", detail::From_Ruby<std::string>().convert(result));
@@ -346,21 +382,35 @@ TESTCASE(Modify)
   result = vec.call("to_s");
   ASSERT_EQUAL("[11, 33, 22]", detail::From_Ruby<std::string>().convert(result));
 
+  result = vec.call("insert", -2, 34);
+
+  result = vec.call("size");
+  ASSERT_EQUAL(4, detail::From_Ruby<int32_t>().convert(result));
+
+  result = vec.call("to_s");
+  ASSERT_EQUAL("[11, 33, 34, 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));
+  ASSERT_EQUAL(3, 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));
+  ASSERT_EQUAL(2, 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(1, detail::From_Ruby<int32_t>().convert(result));
+
+  result = vec.call("pop");
+  ASSERT_EQUAL(34, detail::From_Ruby<int32_t>().convert(result));
+
   result = vec.call("size");
   ASSERT_EQUAL(0, detail::From_Ruby<int32_t>().convert(result));
 
@@ -390,6 +440,44 @@ TESTCASE(Clone)
   ASSERT_NOT_EQUAL(vec.size(), vecClone.size());
 }
 
+
+namespace
+{
+  class SomeClass
+  {
+  public:
+    SomeClass(int value) : value(value)
+    {
+    }
+    int value;
+  };
+
+  std::vector<std::unique_ptr<SomeClass>> uniqueVector()
+  {
+    std::vector<std::unique_ptr<SomeClass>> result;
+    result.push_back(std::make_unique<SomeClass>(1));
+    result.push_back(std::make_unique<SomeClass>(2));
+    return result;
+  }
+}
+
+TESTCASE(UniqueVector)
+{
+  Module m(anonymous_module());
+
+  Class c = define_class<SomeClass>("SomeClass").
+    define_constructor(Constructor<SomeClass, int>()).
+    define_attr("value", &SomeClass::value);
+
+  m.define_module_function("unique_vector", &uniqueVector);
+
+  std::string code = R"(vector = unique_vector
+                        vector.size)";
+
+  Object result = m.module_eval(code);
+  ASSERT_EQUAL(2, detail::From_Ruby<int32_t>().convert(result));
+}
+
 namespace
 {
   class NotComparable
@@ -637,9 +725,9 @@ TESTCASE(AutoRegisterParameter)
   define_global_function("pass_complex_vector", &passComplexVector);
 
   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))";
+                        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);
@@ -653,6 +741,24 @@ TESTCASE(AutoRegisterParameter)
   ASSERT_EQUAL(complexes[1], std::complex<double>(5, 5));
 }
 
+TESTCASE(AutoRegisterException)
+{
+  std::string code = R"(
+    begin
+      Std::Vector≺complex≺double≻≻.new('!!!!')
+    rescue => e
+      name = e.class.name
+      "#{e.class.name} #{e.message} #{(e.backtrace || []).join("\n")}"  # shoud not raise 'incompatible character encodings: BINARY (ASCII-8BIT) and UTF-8' ?
+    end
+    "reachable! - #{name}"
+  )";
+
+  Module m = define_module("Testing");
+  Object result = m.module_eval(code);
+  std::string actual = detail::From_Ruby<std::string>().convert(result);
+  ASSERT_EQUAL("reachable! - ArgumentError", actual);
+}
+
 namespace
 {
   std::vector<std::string> defaultVector(std::vector<std::string> strings = {"one", "two", "three"})
@@ -1005,9 +1111,8 @@ TESTCASE(StringPointerVector)
   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]
+                        outer_buffer = vec.data.buffer
+                        inner_buffer = Rice::Buffer≺string≻.new(outer_buffer[1])
                         inner_buffer.to_ary(1))";
   Array array = m.module_eval(code);
   ASSERT_EQUAL(1, array.size());