rice 4.0.4 → 4.1.0

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_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()));
 }

data/test/test_Module.cpp

@@ -8,17 +8,23 @@ using namespace Rice;
 
 TESTSUITE(Module);
 
-SETUP(Object)
+SETUP(Module)
 {
   embed_ruby();
 }
 
-TESTCASE(construct_from_value)
+TESTCASE(FromConstant)
 {
   Module m(rb_mEnumerable);
   ASSERT_EQUAL(rb_mEnumerable, m.value());
 }
 
+TESTCASE(FromName)
+{
+  Module m("Enumerable");
+  ASSERT_EQUAL(rb_mEnumerable, m.value());
+}
+
 namespace
 {
 
@@ -41,10 +47,11 @@ void throw_silly_exception(Object self)
 
 TESTCASE(add_handler)
 {
+  register_handler<Quite_Silly_Exception>(handle_silly_exception);
+
   Module m(anonymous_module());
-  m.add_handler<Quite_Silly_Exception>(handle_silly_exception);
   m.define_singleton_method("foo", throw_silly_exception);
-  Object exc = m.instance_eval("begin; foo; rescue Exception; $!; end");
+  Object exc = m.module_eval("begin; foo; rescue Exception; $!; end");
   ASSERT_EQUAL(rb_eRuntimeError, CLASS_OF(exc));
   Exception ex(exc);
   ASSERT_EQUAL(String("SILLY"), String(ex.what()));
@@ -80,8 +87,8 @@ TESTCASE(define_method)
   Module m(anonymous_module());
   m.define_method("some_method", some_method);
   
-  Object o = m.instance_eval("$o = Object.new");
-  Object result = m.instance_eval(R"EOS($o.extend(self)
+  Object o = m.module_eval("$o = Object.new");
+  Object result = m.module_eval(R"EOS($o.extend(self)
                                         $o.some_method)EOS");
   ASSERT_EQUAL(o, result);
 }
@@ -99,7 +106,7 @@ TESTCASE(define_module_function)
   Module m(anonymous_module());
   m.define_module_function("some_function", some_function);
 
-  Object result = m.instance_eval(R"EOS(o = Object.new
+  Object result = m.module_eval(R"EOS(o = Object.new
                                    o.extend(self)
                                    o.instance_eval do
                                      some_function
@@ -130,7 +137,7 @@ TESTCASE(define_function_int)
 {
   Module m(anonymous_module());
   m.define_function("foo", function_int);
-  Object result = m.instance_eval("o = Object.new; o.extend(self); o.foo(42)");
+  Object result = m.module_eval("o = Object.new; o.extend(self); o.foo(42)");
   ASSERT_EQUAL(42, detail::From_Ruby<int>().convert(result));
 }
 
@@ -138,7 +145,7 @@ TESTCASE(define_method_int)
 {
   Module m(anonymous_module());
   m.define_method("foo", method_int);
-  Object result = m.instance_eval("o = Object.new; o.extend(self); o.foo(42)");
+  Object result = m.module_eval("o = Object.new; o.extend(self); o.foo(42)");
   ASSERT_EQUAL(42, detail::From_Ruby<int>().convert(result));
 }
 
@@ -162,7 +169,7 @@ TESTCASE(define_module_function_int)
 {
   Module m(anonymous_module());
   m.define_module_function("foo", function_int);
-  Object result = m.instance_eval("o = Object.new; o.extend(self); o.instance_eval { foo(42) }");
+  Object result = m.module_eval("o = Object.new; o.extend(self); o.instance_eval { foo(42) }");
   ASSERT_EQUAL(42, detail::From_Ruby<int>().convert(result));
 
   result = m.call("foo", 42);
@@ -175,7 +182,7 @@ TESTCASE(method_int_passed_no_args)
   m.define_method("foo", method_int);
   ASSERT_EXCEPTION_CHECK(
       Exception,
-      m.instance_eval("o = Object.new; o.extend(self); o.foo"),
+      m.module_eval("o = Object.new; o.extend(self); o.foo"),
       ASSERT_EQUAL(
           Object(rb_eArgError),
           Object(CLASS_OF(ex.value()))
@@ -204,50 +211,6 @@ TESTCASE(include_module)
   ASSERT_EQUAL(expected_ancestors, ancestors);
 }
 
-TESTCASE(const_set_get_by_id)
-{
-  Module m(anonymous_module());
-  Object v = detail::to_ruby(42);
-  Module & m2(m.const_set(rb_intern("FOO"), v));
-  ASSERT_EQUAL(&m, &m2);
-  ASSERT_EQUAL(v, m.const_get(rb_intern("FOO")));
-}
-
-TESTCASE(const_set_get_by_identifier)
-{
-  Module m(anonymous_module());
-  Object v = detail::to_ruby(42);
-  Module & m2(m.const_set(Identifier("FOO"), v));
-  ASSERT_EQUAL(&m, &m2);
-  ASSERT_EQUAL(v, m.const_get(Identifier("FOO")));
-}
-
-TESTCASE(const_set_get_by_string)
-{
-  Module m(anonymous_module());
-  Object v = detail::to_ruby(42);
-  Module & m2(m.const_set("FOO", v));
-  ASSERT_EQUAL(&m, &m2);
-  ASSERT_EQUAL(v, m.const_get("FOO"));
-}
-
-TESTCASE(remove_const)
-{
-  Module m(anonymous_module());
-  Object v = detail::to_ruby(42);
-  m.const_set("FOO", v);
-  ASSERT_EQUAL(v, m.const_get("FOO"));
-  m.remove_const("FOO");
-  ASSERT_EXCEPTION_CHECK(
-      Exception,
-      m.const_get("FOO"),
-      ASSERT_EQUAL(
-          Object(rb_eNameError),
-          Object(CLASS_OF(ex.value()))
-          )
-      );
-}
-
 TESTCASE(mod_name_anonymous)
 {
   Module m(anonymous_module());
@@ -274,7 +237,7 @@ TESTCASE(define_method_default_arguments)
   Module m(anonymous_module());
   m.define_function("foo", &defaults_method_one, Arg("arg1"), Arg("arg2") = 3, Arg("arg3") = true);
 
-  Object o = m.instance_eval("o = Object.new; o.extend(self); o");
+  Object o = m.module_eval("o = Object.new; o.extend(self); o");
   o.call("foo", 2);
 
   ASSERT_EQUAL(2, defaults_method_one_arg1);
@@ -301,7 +264,7 @@ TESTCASE(default_arguments_still_throws_argument_error)
 
   ASSERT_EXCEPTION_CHECK(
       Exception,
-      m.instance_eval("o = Object.new; o.extend(self); o.foo()"),
+      m.module_eval("o = Object.new; o.extend(self); o.foo()"),
       ASSERT_EQUAL(
           Object(rb_eArgError),
           Object(CLASS_OF(ex.value()))
@@ -310,7 +273,7 @@ TESTCASE(default_arguments_still_throws_argument_error)
 
   ASSERT_EXCEPTION_CHECK(
       Exception,
-      m.instance_eval("o = Object.new; o.extend(self); o.foo(3, 4, false, 17)"),
+      m.module_eval("o = Object.new; o.extend(self); o.foo(3, 4, false, 17)"),
       ASSERT_EQUAL(
           Object(rb_eArgError),
           Object(CLASS_OF(ex.value()))
@@ -330,7 +293,7 @@ TESTCASE(defining_methods_with_single_default_argument)
   // define_method
   Module m(anonymous_module());
   m.define_function("foo", &method_with_one_default_arg, (Arg("num") = 4));
-  m.instance_eval("o = Object.new; o.extend(self); o.foo()");
+  m.module_eval("o = Object.new; o.extend(self); o.foo()");
   ASSERT_EQUAL(4, the_one_default_arg);
 
   the_one_default_arg = 0;
@@ -448,7 +411,7 @@ TESTCASE(define_method_works_with_const_reference_return)
 
   Module m(anonymous_module());
 
-  Object result = m.instance_eval("Factory.new.get_return_test");
+  Object result = m.module_eval("Factory.new.get_return_test");
 
   ASSERT_EQUAL("ReturnTest", result.class_of().name().c_str());
 }
@@ -531,7 +494,7 @@ TESTCASE(pointers)
   Module m = define_module("TestingModule");
 
   std::string code = "with_pointers(32, true, 33.0, 34.0)";
-  m.instance_eval(code);
+  m.module_eval(code);
 
   ASSERT_EQUAL(intValue, 32);
   ASSERT_EQUAL(boolValue, true);
@@ -546,7 +509,7 @@ TESTCASE(references)
   Module m = define_module("TestingModule");
 
   std::string code = "with_references(42, true, 43.0, 44.0)";
-  m.instance_eval(code);
+  m.module_eval(code);
 
   ASSERT_EQUAL(intValue, 42);
   ASSERT_EQUAL(boolValue, true);