rice 4.7.1 → 4.9.0

data/test/test_Iterator.cpp

@@ -50,7 +50,7 @@ TESTCASE(define_array_iterator)
   Object wrapped_container = Data_Object<Container>(container);
 
   Array a = wrapped_container.instance_eval("a = []; each() { |x| a << x }; a");
-  ASSERT_EQUAL(3u, a.size());
+  ASSERT_EQUAL(3, a.size());
   ASSERT_EQUAL(Object(detail::to_ruby(1)), a[0]);
   ASSERT_EQUAL(Object(detail::to_ruby(2)), a[1]);
   ASSERT_EQUAL(Object(detail::to_ruby(3)), a[2]);
@@ -152,16 +152,16 @@ TESTCASE(iterator_value)
   Data_Object<ContainerValues> wrapper(container);
 
   Array a = wrapper.instance_eval("each.to_a");
-  ASSERT_EQUAL(3u, a.size());
+  ASSERT_EQUAL(3, a.size());
 
   Data_Object<Data> wrappedData(a[0]);
-  ASSERT_EQUAL(1, wrappedData->index);
+  ASSERT_EQUAL(1u, wrappedData->index);
 
   wrappedData = (Data_Object<Data>)a[1];
-  ASSERT_EQUAL(2, wrappedData->index);
+  ASSERT_EQUAL(2u, wrappedData->index);
 
   wrappedData = (Data_Object<Data>)a[2];
-  ASSERT_EQUAL(3, wrappedData->index);
+  ASSERT_EQUAL(3u, wrappedData->index);
 }
 
 TESTCASE(const_iterator_value)
@@ -185,13 +185,13 @@ TESTCASE(const_iterator_value)
   Array a = m.module_eval(code);
 
   Data_Object<Data> wrappedData(a[0]);
-  ASSERT_EQUAL(1, wrappedData->index);
+  ASSERT_EQUAL(1u, wrappedData->index);
 
   wrappedData = (Data_Object<Data>)a[1];
-  ASSERT_EQUAL(2, wrappedData->index);
+  ASSERT_EQUAL(2u, wrappedData->index);
 
   wrappedData = (Data_Object<Data>)a[2];
-  ASSERT_EQUAL(3, wrappedData->index);
+  ASSERT_EQUAL(3u, wrappedData->index);
 }
 
 TESTCASE(iterator_pointer)
@@ -218,13 +218,13 @@ TESTCASE(iterator_pointer)
   Array a = m.module_eval(code);
 
   Data_Object<Data> wrappedData(a[0]);
-  ASSERT_EQUAL(1, wrappedData->index);
+  ASSERT_EQUAL(1u, wrappedData->index);
 
   wrappedData = (Data_Object<Data>)a[1];
-  ASSERT_EQUAL(2, wrappedData->index);
+  ASSERT_EQUAL(2u, wrappedData->index);
 
   wrappedData = (Data_Object<Data>)a[2];
-  ASSERT_EQUAL(3, wrappedData->index);
+  ASSERT_EQUAL(3u, wrappedData->index);
 }
 
 TESTCASE(two_iterator_pointer)
@@ -254,25 +254,25 @@ TESTCASE(two_iterator_pointer)
 
   Array a = m.module_eval(code);
 
-  ASSERT_EQUAL(6u, a.size());
+  ASSERT_EQUAL(6, a.size());
 
   Data_Object<Data> wrappedData(a[0]);
-  ASSERT_EQUAL(1, wrappedData->index);
+  ASSERT_EQUAL(1u, wrappedData->index);
 
   wrappedData = (Data_Object<Data>)a[1];
-  ASSERT_EQUAL(2, wrappedData->index);
+  ASSERT_EQUAL(2u, wrappedData->index);
 
   wrappedData = (Data_Object<Data>)a[2];
-  ASSERT_EQUAL(3, wrappedData->index);
+  ASSERT_EQUAL(3u, wrappedData->index);
 
   wrappedData = (Data_Object<Data>)a[3];
-  ASSERT_EQUAL(3, wrappedData->index);
+  ASSERT_EQUAL(3u, wrappedData->index);
 
   wrappedData = (Data_Object<Data>)a[4];
-  ASSERT_EQUAL(2, wrappedData->index);
+  ASSERT_EQUAL(2u, wrappedData->index);
 
   wrappedData = (Data_Object<Data>)a[5];
-  ASSERT_EQUAL(1, wrappedData->index);
+  ASSERT_EQUAL(1u, wrappedData->index);
 }
 
 TESTCASE(map)
@@ -293,7 +293,7 @@ TESTCASE(map)
                         end)";
 
   Array a = m.module_eval(code);
-  ASSERT_EQUAL(3u, a.size());
+  ASSERT_EQUAL(3, a.size());
 
   Object element = a[0];
   ASSERT_EQUAL(2, detail::From_Ruby<int>().convert(element));
@@ -323,7 +323,7 @@ TESTCASE(to_enum)
 
   Array a = m.module_eval(code);
 
-  ASSERT_EQUAL(3u, a.size());
+  ASSERT_EQUAL(3, a.size());
 
   Object element = a[0];
   ASSERT_EQUAL(2, detail::From_Ruby<int>().convert(element));
@@ -335,6 +335,38 @@ TESTCASE(to_enum)
   ASSERT_EQUAL(6, detail::From_Ruby<int>().convert(element));
 }
 
+TESTCASE(to_a)
+{
+  define_class<Data>("Data")
+    .define_constructor(Constructor<Data, uint32_t>())
+    .define_attr("index", &Data::index, Rice::AttrAccess::Read);
+
+  define_class<ContainerPointers>("ContainerPointers")
+    .define_constructor(Constructor<ContainerPointers>())
+    .define_iterator(&ContainerPointers::begin, &ContainerPointers::end);
+
+  Module m = define_module("TestingModule");
+
+  std::string code = R"(container = ContainerPointers.new
+                        container.to_a)";
+
+  Array a = m.module_eval(code);
+
+  ASSERT_EQUAL(3, a.size());
+
+  Object element = a[0];
+  Object index = element.call("index");
+  ASSERT_EQUAL(1, detail::From_Ruby<int>().convert(index));
+
+  element = a[1];
+  index = element.call("index");
+  ASSERT_EQUAL(2, detail::From_Ruby<int>().convert(index));
+
+  element = a[2];
+  index = element.call("index");
+  ASSERT_EQUAL(3, detail::From_Ruby<int>().convert(index));
+}
+
 TESTCASE(IterateNoCopy)
 {
   define_class<Data>("Data")
@@ -355,7 +387,7 @@ TESTCASE(IterateNoCopy)
   for (size_t i = 0; i < container.data_.size(); i++)
   {
     Data& expected = container.data_[i];
-    Data_Object<Data> actual(a[i]);
+    Data_Object<Data> actual(a[(long)i]);
     ASSERT_EQUAL(&expected, &(*actual));
   }
-}
+}

data/test/test_Keep_Alive.cpp

@@ -131,7 +131,7 @@ namespace
   };
 }
 
-Object getColumn(Module& m, uint32_t index)
+Object getColumn(Module& m, uint32_t)
 {
   Object connection = m.module_eval("Connection.new");
   return connection.call("getColumn", 3);

data/test/test_Keep_Alive_No_Wrapper.cpp

@@ -75,12 +75,16 @@ TESTCASE(test_keep_alive_no_wrapper)
   Module m = define_module("TestingModule");
   Object zoo = m.module_eval("@zoo = Zoo.new");
 
+  std::string code = R"(@zoo.get_pets.each do |pet|
+                          puts pet.get_name
+                        end)";
+
   // get_pets returns an Array (builtin type) so Return().keepAlive()
-  // shall result in std::runtime_error
+  // should result in std::runtime_error
   ASSERT_EXCEPTION_CHECK(
     Exception,
-    m.module_eval("@zoo.get_pets.each do |pet| puts pet.name; end"),
-    ASSERT_EQUAL("When calling the method `get_pets' we could not find the wrapper for the 'Array' return type. You should not use keepAlive() on a Return or Arg that is a builtin Rice type.",
+    m.module_eval(code),
+    ASSERT_EQUAL("wrong argument type Array (expected wrapped C++ object)",
                  ex.what())
   );
 }

data/test/test_Module.cpp

@@ -53,27 +53,27 @@ namespace
     return i;
   }
 
-  int method_int(Object object, int i)
+  int method_int(Object, int i)
   {
     return i;
   }
 
-  bool method_lvalue(MyClass& myClass)
+  bool method_lvalue(MyClass&)
   {
     return true;
   }
 
-  bool method_rvalue(MyClass&& myClass)
+  bool method_rvalue(MyClass&&)
   {
     return true;
   }
 
-  void method_lvalue_return_void(int a, MyClass& myClass)
+  void method_lvalue_return_void(int, MyClass&)
   {
     // Do nothing
   }
 
-  void method_rvalue_return_void(int b, MyClass&& myClass)
+  void method_rvalue_return_void(int, MyClass&&)
   {
     // Do nothing
   }