rice 4.6.1 → 4.7.0

data/test/test_Data_Type.cpp

@@ -1,4 +1,4 @@
-#include <assert.h> 
+#include <assert.h> 
 
 #include "unittest.hpp"
 #include "embed_ruby.hpp"
@@ -457,7 +457,7 @@ TESTCASE(move_assignment)
 {
   Class c = define_class<RValue>("RValue")
     .define_constructor(Constructor<RValue>())
-    .define_method<RValue&(RValue::*)(RValue && other) noexcept>("=", &RValue::operator=);
+    .define_method<RValue&(RValue::*)(RValue&& other) noexcept>("=", &RValue::operator=);
 
   Module m(anonymous_module());
   std::string code = R"(object1 = RValue.new
@@ -554,7 +554,7 @@ namespace
   private:
     Helper* helper_ = nullptr;
   };
-} // namespace
+}
 
 TESTCASE(pointers)
 {
@@ -648,13 +648,10 @@ namespace
   private:
     BigObject** bigObjects_ = nullptr;
   };
-
 }
 
 TESTCASE(pointerToPointer)
 {
-  define_buffer<BigObject*>();
-
   Module m = define_module("DataTypePointerToPointer");
 
   Class BigObjectClass = define_class<BigObject>("BigObject")
@@ -664,9 +661,9 @@ TESTCASE(pointerToPointer)
     .define_constructor(Constructor<Processor>())
     .define_method("create", &Processor::createBigObjects)
     .define_method("sum", &Processor::sumBigObjects,
-                          Arg("bigObjects").setArray(), Arg("size"))
+                          Arg("bigObjects").setBuffer(), Arg("size"))
     .define_method("sum_const", &Processor::sumBigObjectsConst,
-                                Arg("bigObjects").setArray(), Arg("size"));
+                                Arg("bigObjects").setBuffer(), Arg("size"));
 
   std::string code = R"(count = 2
                           processor = ProcessorClass.new
@@ -782,7 +779,7 @@ namespace RangesTest
     int y;
   };
 
-  int sumRangesArray(int size, RangeCustom ranges[])
+  int sumRangesArray(RangeCustom ranges[], int size)
   {
     int result = 0;
     for (int i = 0; i < size; i++)
@@ -794,7 +791,7 @@ namespace RangesTest
     return result;
   }
 
-  int sumRanges(int size, const RangeCustom* ranges)
+  int sumRanges(const RangeCustom* ranges, int size)
   {
     int result = 0;
     for (int i = 0; i < size; i++)
@@ -806,7 +803,7 @@ namespace RangesTest
     return result;
   }
 
-  int sumRanges(int size, const RangeCustom** ranges)
+  int sumRanges(const RangeCustom** ranges, int size)
   {
     int result = 0;
     for (int i = 0; i < size; i++)
@@ -821,8 +818,6 @@ namespace RangesTest
 
 TESTCASE(array_of_ranges)
 {
-  define_buffer<RangesTest::RangeCustom>();
-
   Module m = define_module("CustomRanges");
 
   Class c = define_class_under<RangesTest::RangeCustom>(m, "RangeCustom")
@@ -831,14 +826,14 @@ TESTCASE(array_of_ranges)
     .define_attr("y", &RangesTest::RangeCustom::y);
 
   m.define_module_function("sum_ranges_array", RangesTest::sumRangesArray, 
-                                               Arg("size"), Arg("ranges[]").setArray());
+                                               Arg("ranges[]").setBuffer(), Arg("size"));
 
   std::string code = R"(range1 = RangeCustom.new(1, 2)
                         range2 = RangeCustom.new(3, 4)
                         range3 = RangeCustom.new(5, 6)
             
                         buffer = Rice::Buffer≺RangesTest꞉꞉RangeCustom≻.new([range1, range2, range3])
-                        sum_ranges_array(buffer.size, buffer))";
+                        sum_ranges_array(buffer.data, buffer.size))";
 
   Object result = m.module_eval(code);
   ASSERT_EQUAL(21, detail::From_Ruby<int>().convert(result));
@@ -846,8 +841,6 @@ TESTCASE(array_of_ranges)
 
 TESTCASE(pointer_of_ranges)
 {
-  define_buffer<RangesTest::RangeCustom>();
-
   Module m = define_module("CustomRanges");
 
   Class c = define_class_under<RangesTest::RangeCustom>(m, "RangeCustom")
@@ -855,15 +848,15 @@ TESTCASE(pointer_of_ranges)
     .define_attr("x", &RangesTest::RangeCustom::x)
     .define_attr("y", &RangesTest::RangeCustom::y);
 
-  m.define_module_function<int(*)(int, const RangesTest::RangeCustom*)>("sum_ranges", RangesTest::sumRanges,
-                                                                        Arg("size"), Arg("ranges*").setArray());
+  m.define_module_function<int(*)(const RangesTest::RangeCustom*, int)>("sum_ranges", RangesTest::sumRanges,
+                                                                        Arg("ranges").setBuffer(), Arg("size"));
 
   std::string code = R"(range1 = RangeCustom.new(1, 2)
                         range2 = RangeCustom.new(3, 4)
                         range3 = RangeCustom.new(5, 6)
 
                         buffer = Rice::Buffer≺RangesTest꞉꞉RangeCustom≻.new([range1, range2, range3])
-                        sum_ranges(buffer.size, buffer))";
+                        sum_ranges(buffer.data, buffer.size))";
 
   Object result = m.module_eval(code);
   ASSERT_EQUAL(21, detail::From_Ruby<int>().convert(result));
@@ -871,8 +864,6 @@ TESTCASE(pointer_of_ranges)
 
 TESTCASE(pointer_of_ranges_wrong)
 {
-  define_buffer<RangesTest::RangeCustom>();
-
   Module m = define_module("CustomRanges");
 
   Class c = define_class_under<RangesTest::RangeCustom>(m, "RangeCustom")
@@ -880,26 +871,24 @@ TESTCASE(pointer_of_ranges_wrong)
     .define_attr("x", &RangesTest::RangeCustom::x)
     .define_attr("y", &RangesTest::RangeCustom::y);
 
-  m.define_module_function<int(*)(int, const RangesTest::RangeCustom*)>("sum_ranges_wrong", RangesTest::sumRanges);
+  m.define_module_function<int(*)(const RangesTest::RangeCustom*, int)>("sum_ranges_wrong", RangesTest::sumRanges);
 
   std::string code = R"(range1 = RangeCustom.new(1, 2)
                         range2 = RangeCustom.new(3, 4)
                         range3 = RangeCustom.new(5, 6)
 
                         buffer = Rice::Buffer≺RangesTest꞉꞉RangeCustom≻.new([range1, range2, range3])
-                        sum_ranges_wrong(buffer.size, buffer))";
+                        sum_ranges_wrong(buffer, buffer.size))";
 
   ASSERT_EXCEPTION_CHECK(
     Rice::Exception,
     m.module_eval(code),
-    ASSERT_EQUAL("wrong argument type Rice::Buffer≺RangesTest꞉꞉RangeCustom≻ (expected CustomRanges::RangeCustom)", ex.what())
+    ASSERT_EQUAL("Wrong argument type. Expected: Rice::Pointer≺RangesTest꞉꞉RangeCustom≻. Received: Rice::Buffer≺RangesTest꞉꞉RangeCustom≻.", ex.what())
   );
 }
 
 TESTCASE(pointer_of_pointer_ranges)
 {
-  define_buffer<RangesTest::RangeCustom*>();
-
   Module m = define_module("CustomRanges");
 
   Class c = define_class_under<RangesTest::RangeCustom>(m, "RangeCustom")
@@ -907,13 +896,13 @@ TESTCASE(pointer_of_pointer_ranges)
     .define_attr("x", &RangesTest::RangeCustom::x)
     .define_attr("y", &RangesTest::RangeCustom::y);
 
-  m.define_module_function<int(*)(int, const RangesTest::RangeCustom**)>("sum_ranges", RangesTest::sumRanges);
+  m.define_module_function<int(*)(const RangesTest::RangeCustom**, int)>("sum_ranges", RangesTest::sumRanges, Arg("ranges").setBuffer());
 
   std::string code = R"(range1 = RangeCustom.new(1, 2)
                         range2 = RangeCustom.new(3, 4)
                         range3 = RangeCustom.new(5, 6)
-                        buffer = Rice::Buffer≺RangesTest꞉꞉RangeCustom≻.new([range1, range2, range3])
-                        sum_ranges(buffer.size, buffer))";
+                        buffer = Rice::Buffer≺RangesTest꞉꞉RangeCustom∗≻.new([range1, range2, range3])
+                        sum_ranges(buffer.data, buffer.size))";
 
   Object result = m.module_eval(code);
   ASSERT_EQUAL(21, detail::From_Ruby<int>().convert(result));

data/test/test_Enum.cpp

@@ -67,15 +67,13 @@ TESTCASE(assignment)
   ASSERT_EQUAL(define_color_enum().value(), colorEnum.value());
 }
 
-TESTCASE(each)
+TESTCASE(values)
 {
   Module m = define_module("Testing");
 
   Enum<Color> colorEnum = define_color_enum();
 
-  std::string code = R"(a = []
-                        Color.each { |x| a << x }
-                        a)";
+  std::string code = R"(Color.values)";
 
   Array a = m.module_eval(code);
   ASSERT_EQUAL(3u, a.size());
@@ -90,52 +88,12 @@ TESTCASE(each)
   ASSERT_EQUAL(GREEN, *enum_2);
 }
 
-TESTCASE(each_return)
-{
-  Module m = define_module("Testing");
-
-  Enum<Color> colorEnum = define_color_enum();
-
-  std::string code = R"(Color.each {|x|})";
-  Object colorEnum2 = m.module_eval(code);
-  ASSERT_EQUAL(colorEnum2, Enum<Color>().klass());
-}
-
-TESTCASE(to_enum)
-{
-  Module m = define_module("Testing");
-
-  Enum<Color> colorEnum = define_color_enum();
-
-  std::string code = R"(a = []
-                        Color.each.with_index {|x, i| a << x }
-                        a)";
-
-  Array a = m.module_eval(code);
-  ASSERT_EQUAL(3u, a.size());
-
-  Data_Object<Color> enum_0(a[0]);
-  ASSERT_EQUAL(RED, *enum_0);
-
-  Data_Object<Color> enum_1(a[1]);
-  ASSERT_EQUAL(BLACK, *enum_1);
-
-  Data_Object<Color> enum_2(a[2]);
-  ASSERT_EQUAL(GREEN, *enum_2);
-
-  code = R"(Color.each)";
-  Object enumerator = m.module_eval(code);
-  ASSERT(enumerator.is_instance_of(rb_cEnumerator));
-}
-
-TESTCASE(each_seasons)
+TESTCASE(seasons_values)
 {
   Module m = define_module("Testing");
 
   Enum<Season> rb_cSeason = define_season_enum();
-  std::string code = R"(a = []
-                        Season.each { |x| a << x }
-                        a)";
+  std::string code = R"(Season.values)";
 
   Array a = m.module_eval(code);
   ASSERT_EQUAL(4u, a.size());

data/test/test_From_Ruby.cpp

@@ -13,7 +13,6 @@ TESTSUITE(FromRuby);
 SETUP(FromRuby)
 {
   embed_ruby();
-  define_fundamental_buffer_types();
 }
 
 TEARDOWN(FromRuby)
@@ -132,93 +131,100 @@ TESTCASE(char_fixnum)
 TESTCASE(char_pointer)
 {
   Module m = define_module("Testing");
+  define_pointer<char>();
+  define_buffer<char>();
   detail::From_Ruby<char*> fromRuby;
 
-  char* expected = nullptr;
-  char* data = fromRuby.convert(Qnil);
-  ASSERT_EQUAL(expected, data);
+  char* buffer = fromRuby.convert(Qnil);
+  ASSERT_EQUAL(nullptr, buffer);
 
   std::string code = R"(Rice::Buffer≺char≻.new("my string"))";
   Object result = m.instance_eval(code);
-  data = fromRuby.convert(result.value());
-  //expected = "my string";
- // ASSERT_EQUAL(*expected, *data);
+  Object data = result.call("data");
+  buffer = fromRuby.convert(data);
+  const char* expected = "my string";
+  ASSERT_EQUAL(*expected, *buffer);
 
   code = R"(Rice::Buffer≺char≻.new([0, 127, 128, 255, 256, -128, -129, -255]))";
   result = m.instance_eval(code);
-  data = fromRuby.convert(result.value());
-
-  ASSERT_EQUAL(data[0], 0);
-  ASSERT_EQUAL(data[1], 127);
-  ASSERT_EQUAL(data[2], -128);
-  ASSERT_EQUAL(data[3], -1);
-  ASSERT_EQUAL(data[4], 0);
-  ASSERT_EQUAL(data[5], -128);
-  ASSERT_EQUAL(data[6], 127);
-  ASSERT_EQUAL(data[7], 1);
+  data = result.call("data");
+  buffer = fromRuby.convert(data);
+
+  ASSERT_EQUAL(buffer[0], 0);
+  ASSERT_EQUAL(buffer[1], 127);
+  ASSERT_EQUAL(buffer[2], -128);
+  ASSERT_EQUAL(buffer[3], -1);
+  ASSERT_EQUAL(buffer[4], 0);
+  ASSERT_EQUAL(buffer[5], -128);
+  ASSERT_EQUAL(buffer[6], 127);
+  ASSERT_EQUAL(buffer[7], 1);
 
   ASSERT_EXCEPTION_CHECK(
     Exception,
     fromRuby.convert(rb_float_new(11.11)),
-    ASSERT_EQUAL("wrong argument type Float (expected Buffer≺char‚ void≻)", ex.what())
+    ASSERT_EQUAL("wrong argument type Float (expected Pointer≺char≻)", ex.what())
   );
 }
 
 TESTCASE(signed_char_pointer)
 {
   Module m = define_module("Testing");
+  define_buffer<signed char>();
   detail::From_Ruby<signed char*> fromRuby;
 
   signed char* expected = nullptr;
-  signed char* data = fromRuby.convert(Qnil);
-  ASSERT_EQUAL(expected, data);
+  signed char* buffer = fromRuby.convert(Qnil);
+  ASSERT_EQUAL(expected, buffer);
 
   std::string code = R"(Rice::Buffer≺signed char≻.new("my string"))";
   Object result = m.instance_eval(code);
-  data = fromRuby.convert(result.value());
+  Object data = result.call("data");
+  buffer = fromRuby.convert(data);
   expected = (signed char*)"my string";
-  ASSERT_EQUAL(*expected, *data);
+  ASSERT_EQUAL(*expected, *buffer);
 
   code = R"(Rice::Buffer≺signed char≻.new([0, 127, 128, 255, 256, -128, -129, -255]))";
   result = m.instance_eval(code);
-  data = fromRuby.convert(result.value());
-
-  ASSERT_EQUAL(data[0], 0);
-  ASSERT_EQUAL(data[1], 127);
-  ASSERT_EQUAL(data[2], -128);
-  ASSERT_EQUAL(data[3], -1);
-  ASSERT_EQUAL(data[4], 0);
-  ASSERT_EQUAL(data[5], -128);
-  ASSERT_EQUAL(data[6], 127);
-  ASSERT_EQUAL(data[7], 1);
+  data = result.call("data");
+  buffer = fromRuby.convert(data);
+
+  ASSERT_EQUAL(buffer[0], 0);
+  ASSERT_EQUAL(buffer[1], 127);
+  ASSERT_EQUAL(buffer[2], -128);
+  ASSERT_EQUAL(buffer[3], -1);
+  ASSERT_EQUAL(buffer[4], 0);
+  ASSERT_EQUAL(buffer[5], -128);
+  ASSERT_EQUAL(buffer[6], 127);
+  ASSERT_EQUAL(buffer[7], 1);
 
   ASSERT_EXCEPTION_CHECK(
     Exception,
     fromRuby.convert(rb_float_new(11.11)),
-    ASSERT_EQUAL("wrong argument type Float (expected Buffer≺signed char‚ void≻)", ex.what())
+    ASSERT_EQUAL("Wrong argument type. Expected: Rice::Pointer≺signed char≻. Received: Float.", ex.what())
   );
 }
 
 TESTCASE(char_pointer_const)
 {
   Module m = define_module("Testing");
+  define_pointer<char>();
 
   std::string code = R"(Rice::Buffer≺char≻.new("my string"))";
   Object result = m.instance_eval(code);
   const char* expected = "my string";
-  const char* data = detail::From_Ruby<const char*>().convert(result.value());
+  const char* data = detail::From_Ruby<char*>().convert(result.call("data"));
   ASSERT_EQUAL(expected, data);
 
   code = R"(Rice::Buffer≺char≻.new(""))";
   result = m.instance_eval(code);
   expected = "";
-  data = detail::From_Ruby<const char*>().convert(result.value());
+  data = detail::From_Ruby<char*>().convert(result.call("data"));
   ASSERT_EQUAL(expected, data);
 
   ASSERT_EXCEPTION_CHECK(
     Exception,
-    detail::From_Ruby<char const*>().convert(rb_float_new(32.3)),
-    ASSERT_EQUAL("wrong argument type Float (expected Buffer≺char‚ void≻)", ex.what())
+    detail::From_Ruby<char*>().convert(rb_float_new(32.3)),
+    ASSERT_EQUAL("wrong argument type Float (expected Pointer≺char≻)", ex.what())
   );
 }
 
@@ -234,45 +240,46 @@ TESTCASE(unsigned_char)
 TESTCASE(unsigned_char_pointer)
 {
   Module m = define_module("Testing");
+  define_buffer<unsigned char>();
+  detail::From_Ruby<Buffer<unsigned char>*> fromRuby;
 
-  detail::From_Ruby<unsigned char*> fromRuby;
-
-  unsigned char* expected = nullptr;
-  unsigned char* data = fromRuby.convert(Qnil);
-  ASSERT_EQUAL(expected, data);
+  Buffer<unsigned char>* buffer = fromRuby.convert(Qnil);
+  ASSERT_EQUAL(nullptr, buffer);
 
   std::string code = R"(Rice::Buffer≺unsigned char≻.new([0, 127, 128, 255, 256, -128, -129, -255]))";
   Object result = m.instance_eval(code);
-  data = fromRuby.convert(result.value());
-
-  ASSERT_EQUAL(data[0], 0x0);
-  ASSERT_EQUAL(data[1], 0x7F);
-  ASSERT_EQUAL(data[2], 0x80);
-  ASSERT_EQUAL(data[3], 0xFF);
-  ASSERT_EQUAL(data[4], 0x00);
-  ASSERT_EQUAL(data[5], 0x80);
-  ASSERT_EQUAL(data[6], 0x7F);
-  ASSERT_EQUAL(data[7], 0x01);
+  buffer = fromRuby.convert(result.value());
+
+  ASSERT_EQUAL((size_t)8, buffer->size());
+  ASSERT_EQUAL(buffer->operator[](0), 0x0);
+  ASSERT_EQUAL(buffer->operator[](1), 0x7F);
+  ASSERT_EQUAL(buffer->operator[](2), 0x80);
+  ASSERT_EQUAL(buffer->operator[](3), 0xFF);
+  ASSERT_EQUAL(buffer->operator[](4), 0x00);
+  ASSERT_EQUAL(buffer->operator[](5), 0x80);
+  ASSERT_EQUAL(buffer->operator[](6), 0x7F);
+  ASSERT_EQUAL(buffer->operator[](7), 0x01);
 
   code = R"(array = [0, 127, 128, 255, 256, -128, -129, -255]
-              packed = array.pack("C*")
-              Rice::Buffer≺unsigned char≻.new(packed))";
+            packed = array.pack("C*")
+            Rice::Buffer≺unsigned char≻.new(packed))";
   result = m.instance_eval(code);
-  data = fromRuby.convert(result.value());
-
-  ASSERT_EQUAL(data[0], 0x0);
-  ASSERT_EQUAL(data[1], 0x7F);
-  ASSERT_EQUAL(data[2], 0x80);
-  ASSERT_EQUAL(data[3], 0xFF);
-  ASSERT_EQUAL(data[4], 0x00);
-  ASSERT_EQUAL(data[5], 0x80);
-  ASSERT_EQUAL(data[6], 0x7F);
-  ASSERT_EQUAL(data[7], 0x01);
+  buffer = fromRuby.convert(result.value());
+
+  ASSERT_EQUAL((size_t)8, buffer->size());
+  ASSERT_EQUAL(buffer->operator[](0), 0x0);
+  ASSERT_EQUAL(buffer->operator[](1), 0x7F);
+  ASSERT_EQUAL(buffer->operator[](2), 0x80);
+  ASSERT_EQUAL(buffer->operator[](3), 0xFF);
+  ASSERT_EQUAL(buffer->operator[](4), 0x00);
+  ASSERT_EQUAL(buffer->operator[](5), 0x80);
+  ASSERT_EQUAL(buffer->operator[](6), 0x7F);
+  ASSERT_EQUAL(buffer->operator[](7), 0x01);
 
   ASSERT_EXCEPTION_CHECK(
     Exception,
     detail::From_Ruby<const char*>().convert(rb_float_new(11.11)),
-    ASSERT_EQUAL("wrong argument type Float (expected Buffer≺char‚ void≻)", ex.what())
+    ASSERT_EQUAL("Wrong argument type. Expected: Rice::Pointer≺char≻. Received: Float.", ex.what())
   );
 }
 
@@ -284,7 +291,7 @@ TESTCASE(unsigned_char_pointer_array)
 
   std::string code = R"(arr = ["A", "B"]
                         buffer = Rice::Buffer≺unsigned char≻.new(arr)
-                        unsigned_char_pointer(buffer, buffer.size))";
+                        unsigned_char_pointer(buffer.data, buffer.size))";
 
   ASSERT_EXCEPTION_CHECK(
     Exception,
@@ -296,20 +303,20 @@ TESTCASE(unsigned_char_pointer_array)
                                char.ord
                              end  
             buffer = Rice::Buffer≺unsigned char≻.new(arr)
-            unsigned_char_pointer(buffer, buffer.size))";
+            unsigned_char_pointer(buffer.data, buffer.size))";
 
   Object result = m.module_eval(code);
   ASSERT_EQUAL("[A, B]", detail::From_Ruby<std::string>().convert(result.value()));
 
   code = R"(arr = [65, 66]
             buffer = Rice::Buffer≺unsigned char≻.new(arr)
-            unsigned_char_pointer(buffer, buffer.size))";
+            unsigned_char_pointer(buffer.data, buffer.size))";
   result = m.module_eval(code);
   ASSERT_EQUAL("[A, B]", detail::From_Ruby<std::string>().convert(result.value()));
 
   code = R"(arr = [true]
             buffer = Rice::Buffer≺unsigned char≻.new(arr)
-            unsigned_char_pointer(buffer, buffer.size))";
+            unsigned_char_pointer(buffer.ptr, buffer.size))";
 
   ASSERT_EXCEPTION_CHECK(
     Exception,
@@ -346,7 +353,7 @@ TESTCASE(double_pointer_array)
 
   std::string code = R"(arr = [1.1, 2.2, 3.3, 4.4]
                         buffer = Rice::Buffer≺double≻.new(arr)
-                        double_pointer(buffer, buffer.size))";
+                        double_pointer(buffer.data, buffer.size))";
 
   Object result = m.module_eval(code);
 
@@ -382,19 +389,19 @@ TESTCASE(float_pointer_array)
 
   std::string code = R"(arr = [4.3, 3.2, 2.1, 1.1]
                         buffer = Rice::Buffer≺float≻.new(arr)
-                        float_pointer(buffer, buffer.size))";
+                        float_pointer(buffer.data, buffer.size))";
   Object result = m.module_eval(code);
   ASSERT_EQUAL("[4.3, 3.2, 2.1, 1.1]", detail::From_Ruby<std::string>().convert(result.value()));
 
   code = R"(arr = [4, 3, 2.8, 1]
            buffer = Rice::Buffer≺float≻.new(arr)
-            float_pointer(buffer, buffer.size))";
+            float_pointer(buffer.data, buffer.size))";
   result = m.module_eval(code);
   ASSERT_EQUAL("[4, 3, 2.8, 1]", detail::From_Ruby<std::string>().convert(result.value()));
 
   code = R"(arr = [4, "bad", 2, 1]
             buffer = Rice::Buffer≺float≻.new(arr)
-            float_pointer(buffer, buffer.size))";
+            float_pointer(buffer.data, buffer.size))";
 
   ASSERT_EXCEPTION_CHECK(
     Exception,
@@ -410,17 +417,17 @@ TESTCASE(float_array_array)
   m.define_singleton_function("array_array_to_string", &arrayofArraysToString<float>);
 
   std::string code = R"(buffer = Rice::Buffer≺float∗≻.new([[1.1, 2.2], [3.3, 4.4], [5.5, 6.6]])
-                        array_array_to_string(buffer, buffer.size, 2))";
+                        array_array_to_string(buffer.data, buffer.size, 2))";
   Object result = m.module_eval(code);
   ASSERT_EQUAL("[[1.1, 2.2], [3.3, 4.4], [5.5, 6.6]]", detail::From_Ruby<std::string>().convert(result.value()));
 
   code = R"(buffer = Rice::Buffer≺float∗≻.new([[4, 3], [2.8, 1]])
-            array_array_to_string(buffer, buffer.size, 2))";
+            array_array_to_string(buffer.data, buffer.size, 2))";
   result = m.module_eval(code);
   ASSERT_EQUAL("[[4, 3], [2.8, 1]]", detail::From_Ruby<std::string>().convert(result.value()));
 
   code = R"(buffer = Rice::Buffer≺float∗≻.new([[4, "bad"], [2, 1]])
-            array_array_to_string(buffer, buffer.size, 2))";
+            array_array_to_string(buffer.data, buffer.size, 2))";
 
   ASSERT_EXCEPTION_CHECK(
     Exception,
@@ -434,7 +441,7 @@ TESTCASE(float_array_array)
   ASSERT_EXCEPTION_CHECK(
     Exception,
     m.module_eval(code),
-    ASSERT_EQUAL("wrong argument type Array (expected Buffer≺float∗‚ void≻)", ex.what())
+    ASSERT_EQUAL("Wrong argument type. Expected: Rice::Pointer≺float∗≻. Received: Array.", ex.what())
   );
 }
 
@@ -462,13 +469,13 @@ TESTCASE(int_pointer_array)
 
   std::string code = R"(arr = [4, 3, 2, 1]
                         buffer = Rice::Buffer≺int≻.new(arr)
-                        int_pointer(buffer, buffer.size))";
+                        int_pointer(buffer.data, buffer.size))";
   Object result = m.module_eval(code);
   ASSERT_EQUAL("[4, 3, 2, 1]", detail::From_Ruby<std::string>().convert(result.value()));
 
   code = R"(arr = [4.2, 3.8, 2.0, 1]
             buffer = Rice::Buffer≺int≻.new(arr)
-            int_pointer(buffer, buffer.size))";
+            int_pointer(buffer.data, buffer.size))";
   result = m.module_eval(code);
   ASSERT_EQUAL("[4, 3, 2, 1]", detail::From_Ruby<std::string>().convert(result.value()));
 }
@@ -602,8 +609,8 @@ TESTCASE(void_pointer_array)
   m.define_singleton_function("void_pointer", &voidToString<int>);
 
   std::string code = R"(arr = [4, 3, 2, 1]
-                        buffer = arr.pack("i*")
-                        void_pointer(buffer, buffer.size))";
+                        data = arr.pack("i*")
+                        void_pointer(data, data.size))";
   Object result = m.module_eval(code);
   ASSERT_EQUAL("[4, 3, 2, 1]", detail::From_Ruby<std::string>().convert(result.value()));
 }