rice 4.0.4 → 4.2.0

data/test/test_Director.cpp

@@ -3,7 +3,6 @@
 #include <rice/rice.hpp>
 
 #include <vector>
-#include <iostream>
 
 using namespace Rice;
 
@@ -107,7 +106,7 @@ TESTCASE(exposes_worker_as_instantiatable_class)
     .define_method("get_number", &Worker::getNumber);
 
   Module m = define_module("Testing");
-  Object result = m.instance_eval("worker = Worker.new; worker.get_number");
+  Object result = m.module_eval("worker = Worker.new; worker.get_number");
 
   ASSERT_EQUAL(12, detail::From_Ruby<int>().convert(result.value()));
 }
@@ -122,7 +121,7 @@ TESTCASE(can_call_virtual_methods_on_base_class)
 
   Module m = define_module("Testing");
 
-  Object result = m.instance_eval("worker = Worker.new; worker.do_something(4)");
+  Object result = m.module_eval("worker = Worker.new; worker.do_something(4)");
 
   ASSERT_EQUAL(16, detail::From_Ruby<int>().convert(result.value()));
 }
@@ -135,9 +134,9 @@ TESTCASE(super_calls_pass_execution_up_the_inheritance_chain)
     .define_method("do_something", &WorkerDirector::default_doSomething);
 
   Module m = define_module("Testing");
-  m.instance_eval("class RubyWorker < Worker; def do_something(num); super * num; end; end");
+  m.module_eval("class RubyWorker < Worker; def do_something(num); super * num; end; end");
 
-  Object result = m.instance_eval("worker = RubyWorker.new; worker.do_something(10)");
+  Object result = m.module_eval("worker = RubyWorker.new; worker.do_something(10)");
 
   ASSERT_EQUAL(400, detail::From_Ruby<int>().convert(result.value()));
 }
@@ -150,11 +149,11 @@ TESTCASE(super_calls_on_pure_virtual_raise_error)
     .define_method("process", &WorkerDirector::default_process);
 
   Module m = define_module("Testing");
-  m.instance_eval("class RubyWorker < Worker; def process(num); super; end; end");
+  m.module_eval("class RubyWorker < Worker; def process(num); super; end; end");
 
   ASSERT_EXCEPTION_CHECK(
       Exception,
-      m.instance_eval("worker = RubyWorker.new; worker.process(10)"),
+      m.module_eval("worker = RubyWorker.new; worker.process(10)"),
       ASSERT_EQUAL(
           Object(rb_eNotImpError),
           Object(CLASS_OF(ex.value()))
@@ -176,7 +175,7 @@ TESTCASE(polymorphic_calls_head_down_the_call_chain)
 
   Module m = define_module("Testing");
 
-  m.instance_eval(
+  m.module_eval(
       "class EchoWorker < Worker; def process(num); num + 2; end; end;"
       "class DoubleWorker < Worker; def process(num); num * 2; end; end;"
       "$handler = Handler.new;"
@@ -184,7 +183,7 @@ TESTCASE(polymorphic_calls_head_down_the_call_chain)
       "$handler.add_worker(DoubleWorker.new);"
   );
 
-  Object result = m.instance_eval("$handler.process_workers(5)");
+  Object result = m.module_eval("$handler.process_workers(5)");
 
   // Hit's EchoWorker, so 5 + 2, then passes that to DoubleWorker, so 7 * 2 = 14
   ASSERT_EQUAL(14, detail::From_Ruby<int>().convert(result.value()));
@@ -257,7 +256,7 @@ TESTCASE(mix_of_polymorphic_calls_and_inheritance_dont_cause_infinite_loops)
 
   Module m = define_module("Testing");
 
-  Object result = m.instance_eval(
+  Object result = m.module_eval(
       "class MySelf < CallsSelf; def do_it_impl(num); num * 10; end; end;"
       "c = MySelf.new; c.do_it(10)"
       );
@@ -276,7 +275,7 @@ TESTCASE(director_class_super_classes_get_type_bound)
     .define_method("do_it_impl", &CallsSelfDirector::default_doItImpl)
     .define_method("do_it", &CallsSelf::doIt);
 
-  Object result = m.instance_eval(R"(cs = Testing::get_calls_self
+  Object result = m.module_eval(R"(cs = Testing::get_calls_self
                                      cs.do_it(3))");
   ASSERT_EQUAL(36, detail::From_Ruby<int>().convert(result.value()));
 }
@@ -292,7 +291,7 @@ TESTCASE(director_allows_abstract_types_used_as_parameters_pointers)
     .define_method("do_it_impl", &CallsSelfDirector::default_doItImpl)
     .define_method("do_it", &CallsSelf::doIt);
 
-  Object result = m.instance_eval(
+  Object result = m.module_eval(
       "class MySelf < CallsSelf; def do_it_impl(num); num * 10; end; end;"
       "c = MySelf.new;"
       "Testing::do_it_on_pointer(c, 5)"
@@ -312,7 +311,7 @@ TESTCASE(director_allows_abstract_types_used_as_parameters_reference)
     .define_method("do_it_impl", &CallsSelfDirector::default_doItImpl)
     .define_method("do_it", &CallsSelf::doIt);
 
-  Object result = m.instance_eval(
+  Object result = m.module_eval(
       "class MySelf < CallsSelf; def do_it_impl(num); num * 10; end; end;"
       "c = MySelf.new;"
       "Testing::do_it_on_ref(c, 3)"

data/test/test_Enum.cpp

@@ -70,7 +70,8 @@ TESTCASE(each)
   std::string code = R"(a = []
                         Color.each { |x| a << x }
                         a)";
-  Array a = m.instance_eval(code);
+
+  Array a = m.module_eval(code);
   ASSERT_EQUAL(3u, a.size());
 
   Data_Object<Color> enum_0(a[0]);
@@ -83,6 +84,44 @@ 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)
 {
   Module m = define_module("Testing");
@@ -92,7 +131,7 @@ TESTCASE(each_seasons)
                         Season.each { |x| a << x }
                         a)";
 
-  Array a = m.instance_eval(code);
+  Array a = m.module_eval(code);
   ASSERT_EQUAL(4u, a.size());
 
   Data_Object<Season> enum_0(a[0]);
@@ -113,9 +152,9 @@ TESTCASE(to_s)
   Module m = define_module("Testing");
 
   Enum<Color> colorEnum = define_color_enum();
-  ASSERT_EQUAL(String("RED"), String(m.instance_eval("Color::RED.to_s")));
-  ASSERT_EQUAL(String("BLACK"), String(m.instance_eval("Color::BLACK.to_s")));
-  ASSERT_EQUAL(String("GREEN"), String(m.instance_eval("Color::GREEN.to_s")));
+  ASSERT_EQUAL(String("RED"), String(m.module_eval("Color::RED.to_s")));
+  ASSERT_EQUAL(String("BLACK"), String(m.module_eval("Color::BLACK.to_s")));
+  ASSERT_EQUAL(String("GREEN"), String(m.module_eval("Color::GREEN.to_s")));
 }
 
 TESTCASE(to_i)
@@ -123,9 +162,9 @@ TESTCASE(to_i)
   Module m = define_module("Testing");
 
   Enum<Color> colorEnum = define_color_enum();
-  ASSERT_EQUAL(detail::to_ruby(int(RED)), m.instance_eval("Color::RED.to_i").value());
-  ASSERT_EQUAL(detail::to_ruby(int(BLACK)), m.instance_eval("Color::BLACK.to_i").value());
-  ASSERT_EQUAL(detail::to_ruby(int(GREEN)), m.instance_eval("Color::GREEN.to_i").value());
+  ASSERT_EQUAL(detail::to_ruby(int(RED)), m.module_eval("Color::RED.to_i").value());
+  ASSERT_EQUAL(detail::to_ruby(int(BLACK)), m.module_eval("Color::BLACK.to_i").value());
+  ASSERT_EQUAL(detail::to_ruby(int(GREEN)), m.module_eval("Color::GREEN.to_i").value());
 }
 
 TESTCASE(inspect)
@@ -133,9 +172,9 @@ TESTCASE(inspect)
   Module m = define_module("Testing");
 
   Enum<Color> colorEnum = define_color_enum();
-  ASSERT_EQUAL(String("#<Color::RED>"), String(m.instance_eval("Color::RED.inspect")));
-  ASSERT_EQUAL(String("#<Color::BLACK>"), String(m.instance_eval("Color::BLACK.inspect")));
-  ASSERT_EQUAL(String("#<Color::GREEN>"), String(m.instance_eval("Color::GREEN.inspect")));
+  ASSERT_EQUAL(String("#<Color::RED>"), String(m.module_eval("Color::RED.inspect")));
+  ASSERT_EQUAL(String("#<Color::BLACK>"), String(m.module_eval("Color::BLACK.inspect")));
+  ASSERT_EQUAL(String("#<Color::GREEN>"), String(m.module_eval("Color::GREEN.inspect")));
 }
 
 TESTCASE(compare)
@@ -143,9 +182,9 @@ TESTCASE(compare)
   Module m = define_module("Testing");
 
   Enum<Color> colorEnum = define_color_enum();
-  ASSERT_EQUAL(detail::to_ruby(-1), m.instance_eval("Color::RED <=> Color::BLACK").value());
-  ASSERT_EQUAL(detail::to_ruby(1), m.instance_eval("Color::GREEN <=> Color::RED").value());
-  ASSERT_EQUAL(detail::to_ruby(0), m.instance_eval("Color::BLACK <=> Color::BLACK").value());
+  ASSERT_EQUAL(detail::to_ruby(-1), m.module_eval("Color::RED <=> Color::BLACK").value());
+  ASSERT_EQUAL(detail::to_ruby(1), m.module_eval("Color::GREEN <=> Color::RED").value());
+  ASSERT_EQUAL(detail::to_ruby(0), m.module_eval("Color::BLACK <=> Color::BLACK").value());
 }
 
 TESTCASE(eql)
@@ -153,8 +192,8 @@ TESTCASE(eql)
   Module m = define_module("Testing");
 
   Enum<Color> colorEnum = define_color_enum();
-  ASSERT_EQUAL(detail::to_ruby(false), m.instance_eval("Color::RED == Color::BLACK").value());
-  ASSERT_EQUAL(detail::to_ruby(true), m.instance_eval("Color::GREEN == Color::GREEN").value());
+  ASSERT_EQUAL(detail::to_ruby(false), m.module_eval("Color::RED == Color::BLACK").value());
+  ASSERT_EQUAL(detail::to_ruby(true), m.module_eval("Color::GREEN == Color::GREEN").value());
 }
 
 TESTCASE(compare_equal)
@@ -244,9 +283,9 @@ TESTCASE(nested_enums)
 
   Module m = define_module("Testing");
 
-  ASSERT_EQUAL(detail::to_ruby(int(0)), m.instance_eval("Inner::Props::VALUE1.to_i").value());
-  ASSERT_EQUAL(detail::to_ruby(int(1)), m.instance_eval("Inner::Props::VALUE2.to_i").value());
-  ASSERT_EQUAL(detail::to_ruby(int(2)), m.instance_eval("Inner::Props::VALUE3.to_i").value());
+  ASSERT_EQUAL(detail::to_ruby(int(0)), m.module_eval("Inner::Props::VALUE1.to_i").value());
+  ASSERT_EQUAL(detail::to_ruby(int(1)), m.module_eval("Inner::Props::VALUE2.to_i").value());
+  ASSERT_EQUAL(detail::to_ruby(int(2)), m.module_eval("Inner::Props::VALUE3.to_i").value());
 }
 
 namespace
@@ -272,19 +311,19 @@ TESTCASE(using_enums)
 
   Module m = define_module("Testing");
 
-  Object result = m.instance_eval("Color.my_favorite_color");
+  Object result = m.module_eval("Color.my_favorite_color");
   ASSERT_EQUAL(RED, detail::From_Ruby<Color>().convert(result.value()));
 
-  result = m.instance_eval("Color.is_my_favorite_color(Color::RED)");
+  result = m.module_eval("Color.is_my_favorite_color(Color::RED)");
   ASSERT_EQUAL(Qtrue, result.value());
 
-  result = m.instance_eval("Color.is_my_favorite_color(Color::BLACK)");
+  result = m.module_eval("Color.is_my_favorite_color(Color::BLACK)");
   ASSERT_EQUAL(Qfalse, result.value());
 
-  result = m.instance_eval("Color::RED.is_my_favorite_color");
+  result = m.module_eval("Color::RED.is_my_favorite_color");
   ASSERT_EQUAL(Qtrue, result.value());
 
-  result = m.instance_eval("Color::BLACK.is_my_favorite_color");
+  result = m.module_eval("Color::BLACK.is_my_favorite_color");
   ASSERT_EQUAL(Qfalse, result.value());
 }
 
@@ -301,7 +340,7 @@ TESTCASE(default_argument)
   define_global_function("default_color", &defaultColor, Arg("aColor") = Color::BLACK);
 
   Module m = define_module("Testing");
-  Object result = m.instance_eval("default_color");
+  Object result = m.module_eval("default_color");
   ASSERT_EQUAL(Color::BLACK, detail::From_Ruby<Color>().convert(result.value()));
 }
 
@@ -338,4 +377,4 @@ TESTCASE(not_defined)
     define_global_function("undefined_return", &undefinedReturn),
     ASSERT_EQUAL(message, ex.what())
   );
-}
+}

data/test/test_Inheritance.cpp

@@ -94,7 +94,7 @@ TESTCASE(return_base_pointer)
 
   Module m = define_module("Testing");
 
-  Object notification = m.instance_eval("make_notification(NotificationType::Email)");
+  Object notification = m.module_eval("make_notification(NotificationType::Email)");
   String temp = notification.class_of().name();
   std::string temp2 = detail::From_Ruby<std::string>().convert(temp);
 
@@ -103,7 +103,7 @@ TESTCASE(return_base_pointer)
   ASSERT(!rb_obj_is_kind_of(notification, rcPushNotification));
   ASSERT(rb_obj_is_instance_of(notification, rcEmailNotification));
 
-  notification = m.instance_eval("make_notification(NotificationType::Push)");
+  notification = m.module_eval("make_notification(NotificationType::Push)");
   ASSERT(rb_obj_is_kind_of(notification, rcNotification));
   ASSERT(!rb_obj_is_kind_of(notification, rcEmailNotification));
   ASSERT(rb_obj_is_kind_of(notification, rcPushNotification));
@@ -123,11 +123,11 @@ TESTCASE(base_pointer_method_call)
 
   Module m = define_module("Testing");
 
-  Object message = m.instance_eval(R"EOS(notification = EmailNotification.new
+  Object message = m.module_eval(R"EOS(notification = EmailNotification.new
                                          notification.message)EOS");
   ASSERT_EQUAL("Email", detail::From_Ruby<std::string>().convert(message));
 
-  message = m.instance_eval(R"EOS(notification = PushNotification.new
+  message = m.module_eval(R"EOS(notification = PushNotification.new
                                   notification.message)EOS");
   ASSERT_EQUAL("Push", detail::From_Ruby<std::string>().convert(message));
 }
@@ -146,11 +146,11 @@ TESTCASE(base_pointer_function_argument)
   define_global_function("process_notification", &processNotification);
 
   Module m = define_module("Testing");
-  Object message = m.instance_eval(R"EOS(notification = EmailNotification.new
+  Object message = m.module_eval(R"EOS(notification = EmailNotification.new
                                          process_notification(notification))EOS");
   ASSERT_EQUAL("Email", detail::From_Ruby<std::string>().convert(message));
 
-  message = m.instance_eval(R"EOS(notification = PushNotification.new
+  message = m.module_eval(R"EOS(notification = PushNotification.new
                                   process_notification(notification))EOS");
   ASSERT_EQUAL("Push", detail::From_Ruby<std::string>().convert(message));
 }
@@ -170,11 +170,11 @@ TESTCASE(module_base_pointer_method_call)
 
   Module m = define_module("Testing");
 
-  Object message = m.instance_eval(R"EOS(notification = Inheritance::EmailNotification.new
+  Object message = m.module_eval(R"EOS(notification = Inheritance::EmailNotification.new
                                          notification.message)EOS");
   ASSERT_EQUAL("Email", detail::From_Ruby<std::string>().convert(message));
 
-  message = m.instance_eval(R"EOS(notification = Inheritance::PushNotification.new
+  message = m.module_eval(R"EOS(notification = Inheritance::PushNotification.new
                                   notification.message)EOS");
   ASSERT_EQUAL("Push", detail::From_Ruby<std::string>().convert(message));
 }
@@ -214,7 +214,7 @@ TESTCASE(base_pointer_constructor)
 
   Module m = define_module("Testing");
 
-  Object result = m.instance_eval(R"EOS(notification = PushNotification.new
+  Object result = m.module_eval(R"EOS(notification = PushNotification.new
                                         processor = Processor.new(notification)
                                         processor.process)EOS");
   ASSERT_EQUAL("Push", detail::From_Ruby<std::string>().convert(result));

data/test/test_Iterator.cpp

@@ -55,6 +55,11 @@ namespace
 {
   struct Data
   {
+    Data(uint32_t value)
+    {
+      this->index = value;
+    }
+
     uint32_t index;
   };
 
@@ -76,6 +81,16 @@ namespace
       return this->data_.end();
     }
 
+    std::vector<Data>::const_iterator cbegin() const
+    {
+      return this->data_.cbegin();
+    }
+
+    std::vector<Data>::const_iterator cend() const
+    {
+      return this->data_.cend();
+    }
+
     std::vector<Data> data_;
   };
 
@@ -105,6 +120,16 @@ namespace
       return this->data_.end();
     }
 
+    std::vector<Data*>::reverse_iterator rbegin()
+    {
+      return this->data_.rbegin();
+    }
+
+    std::vector<Data*>::reverse_iterator rend()
+    {
+      return this->data_.rend();
+    }
+
     std::vector<Data*> data_;
   };
 }
@@ -144,6 +169,29 @@ TESTCASE(iterator_value)
   ASSERT_EQUAL(Object(detail::to_ruby(3)), a[2]);
 }
 
+TESTCASE(const_iterator_value)
+{
+  define_class<ContainerValues>("ContainerValues")
+    .define_constructor(Constructor<ContainerValues>())
+    .define_iterator(&ContainerValues::cbegin, &ContainerValues::cend);
+
+  Module m = define_module("TestingModule");
+
+  std::string code = R"(result = []
+                        container = ContainerValues.new
+                        container.each do |x|
+                          result << x
+                        end
+                        result)";
+
+  Array result = m.module_eval(code);
+
+  ASSERT_EQUAL(3u, result.size());
+  ASSERT_EQUAL(Object(detail::to_ruby(1)), result[0]);
+  ASSERT_EQUAL(Object(detail::to_ruby(2)), result[1]);
+  ASSERT_EQUAL(Object(detail::to_ruby(3)), result[2]);
+}
+
 TESTCASE(iterator_pointer)
 {
   define_class<ContainerPointers>("ContainerPointers")
@@ -153,9 +201,90 @@ TESTCASE(iterator_pointer)
   ContainerPointers* container = new ContainerPointers();
   Object wrapper = Data_Object<ContainerPointers>(container);
 
-  Array a = wrapper.instance_eval("a = []; each() { |x| a << x }; a");
-  ASSERT_EQUAL(3u, 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]);
+  Module m = define_module("TestingModule");
+
+  std::string code = R"(result = []
+                        container = ContainerPointers.new
+                        container.each do |x|
+                          result << x
+                        end
+                        result)";
+
+  Array result = m.module_eval(code);
+
+  ASSERT_EQUAL(3u, result.size());
+  ASSERT_EQUAL(Object(detail::to_ruby(1)), result[0]);
+  ASSERT_EQUAL(Object(detail::to_ruby(2)), result[1]);
+  ASSERT_EQUAL(Object(detail::to_ruby(3)), result[2]);
 }
+
+TESTCASE(two_iterator_pointer)
+{
+  define_class<ContainerPointers>("ContainerPointers")
+    .define_constructor(Constructor<ContainerPointers>())
+    .define_iterator(&ContainerPointers::begin, &ContainerPointers::end)
+    .define_iterator(&ContainerPointers::rbegin, &ContainerPointers::rend, "reach");
+
+  ContainerPointers* container = new ContainerPointers();
+  Object wrapper = Data_Object<ContainerPointers>(container);
+
+  Module m = define_module("TestingModule");
+
+  std::string code = R"(result = []
+                        container = ContainerPointers.new
+                        container.each do |x|
+                          result << x
+                        end
+                        container.reach do |x|
+                          result << x
+                        end
+                        result)";
+
+  Array result = m.module_eval(code);
+
+  ASSERT_EQUAL(6u, result.size());
+  ASSERT_EQUAL(Object(detail::to_ruby(1)), result[0]);
+  ASSERT_EQUAL(Object(detail::to_ruby(2)), result[1]);
+  ASSERT_EQUAL(Object(detail::to_ruby(3)), result[2]);
+  ASSERT_EQUAL(Object(detail::to_ruby(3)), result[3]);
+  ASSERT_EQUAL(Object(detail::to_ruby(2)), result[4]);
+  ASSERT_EQUAL(Object(detail::to_ruby(1)), result[5]);
+}
+
+TESTCASE(map)
+{
+  define_class<ContainerPointers>("ContainerPointers")
+    .define_constructor(Constructor<ContainerPointers>())
+    .define_iterator(&ContainerPointers::begin, &ContainerPointers::end);
+
+  Module m = define_module("Testing");
+
+  std::string code = R"(container = ContainerPointers.new
+                        container.map do |x|
+                          x * 2
+                        end)";
+
+  Array result = m.module_eval(code);
+
+  ASSERT_EQUAL(3u, result.size());
+  ASSERT_EQUAL(Object(detail::to_ruby(2)), result[0]);
+  ASSERT_EQUAL(Object(detail::to_ruby(4)), result[1]);
+  ASSERT_EQUAL(Object(detail::to_ruby(6)), result[2]);
+}
+
+TESTCASE(to_enum)
+{
+  Module m = define_module("TestingModule");
+
+  std::string code = R"(container = ContainerPointers.new
+                        container.each.map do |x|
+                          x * 2
+                        end)";
+
+  Array result = m.module_eval(code);
+
+  ASSERT_EQUAL(3u, result.size());
+  ASSERT_EQUAL(Object(detail::to_ruby(2)), result[0]);
+  ASSERT_EQUAL(Object(detail::to_ruby(4)), result[1]);
+  ASSERT_EQUAL(Object(detail::to_ruby(6)), result[2]);
+}

data/test/test_Keep_Alive.cpp

@@ -16,7 +16,7 @@ namespace
   };
 
   /**
-   * This class will recieve a new Listener instance
+   * This class will receive a new Listener instance
    * from Ruby
    */
   class ListenerContainer
@@ -73,14 +73,14 @@ TESTCASE(test_arg)
     .define_method("listener_count", &ListenerContainer::listenerCount);
 
   Module m = define_module("TestingModule");
-  Object handler = m.instance_eval("@handler = ListenerContainer.new");
+  Object handler = m.module_eval("@handler = ListenerContainer.new");
 
   ASSERT_EQUAL(INT2NUM(0), handler.call("listener_count").value());
 
-  m.instance_eval(R"EOS(class MyListener < Listener
+  m.module_eval(R"EOS(class MyListener < Listener
                         end)EOS");
 
-  m.instance_eval("@handler.add_listener(MyListener.new)");
+  m.module_eval("@handler.add_listener(MyListener.new)");
 
   // Without keep alive, this GC will crash the program because MyListener is no longer in scope
   rb_gc_start();
@@ -90,7 +90,7 @@ TESTCASE(test_arg)
 
   // Without keep alive, this GC will crash the program because MyListener is no longer in scope
   rb_gc_start();
-  m.instance_eval("@handler.add_listener(Listener.new)");
+  m.module_eval("@handler.add_listener(Listener.new)");
 
   ASSERT_EQUAL(INT2NUM(2), handler.call("listener_count").value());
   ASSERT_EQUAL(INT2NUM(8), handler.call("process").value());
@@ -139,7 +139,7 @@ namespace
 
 Object getColumn(Module& m, uint32_t index)
 {
-  Object connection = m.instance_eval("Connection.new");
+  Object connection = m.module_eval("Connection.new");
   return connection.call("getColumn", 3);
 }
 
@@ -158,4 +158,4 @@ TESTCASE(test_return)
   rb_gc_start();
   String name = column.call("name");
   ASSERT_EQUAL("column_3", name.c_str());
-}
+}

data/test/test_Keep_Alive_No_Wrapper.cpp

@@ -0,0 +1,80 @@
+#include "unittest.hpp"
+#include "embed_ruby.hpp"
+#include <rice/rice.hpp>
+#include <rice/stl.hpp>
+
+using namespace Rice;
+
+TESTSUITE(Keep_Alive_No_Wrapper);
+
+namespace
+{
+  class Animal
+  {
+    public:
+      Animal(char const * name) : name_(name) {}
+      char const * getName() { return name_; }
+      virtual ~Animal() = default;
+    private:
+      char const * name_;
+  };
+
+  class Zoo
+  {
+    public:
+      Zoo(void)
+      {
+        pets_.push_back(new Animal("Bear"));
+        pets_.push_back(new Animal("Tiger"));
+        pets_.push_back(new Animal("Lion"));
+      }
+
+      ~Zoo()
+      {
+        for(auto pet : pets_)
+        {
+         delete pet;
+        }
+        pets_.clear();
+      }
+
+    Object getPets(void)    {
+      Array pets;
+      for(auto p: pets_) {
+        pets.push(p);
+      }
+      return pets;
+    }
+
+    private:
+      std::vector<Animal*> pets_;
+  };
+}
+
+SETUP(Keep_Alive_No_Wrapper)
+{
+  embed_ruby();
+}
+
+TESTCASE(test_keep_alive_no_wrapper)
+{
+  define_class<Animal>("Animal")
+    .define_constructor(Constructor<Animal, char const *>())
+    .define_method("get_name", &Animal::getName);
+
+  define_class<Zoo>("Zoo")
+    .define_constructor(Constructor<Zoo>())
+    .define_method("get_pets", &Zoo::getPets, Return().keepAlive());
+
+  Module m = define_module("TestingModule");
+  Object zoo = m.module_eval("@zoo = Zoo.new");
+
+  // get_pets returns an Array (builtin type) so Return().keepAlive()
+  // shall 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.",
+                 ex.what())
+  );
+}

data/test/test_Memory_Management.cpp

@@ -44,6 +44,6 @@ TESTCASE(allows_copy_contructors_to_work)
 
   Module m = define_module("TestingModule");
 
-  Object result = m.instance_eval("return_test_class.tmp");
+  Object result = m.module_eval("return_test_class.tmp");
   ASSERT_EQUAL(8.0, detail::From_Ruby<double>().convert(result.value()));
 }