rice 2.1.1 → 4.0.0

data/test/test_Director.cpp

@@ -1,13 +1,10 @@
 #include "unittest.hpp"
-#include "rice/Exception.hpp"
-#include "rice/Director.hpp"
-#include "rice/Constructor.hpp"
-#include "rice/Data_Type.hpp"
+#include "embed_ruby.hpp"
+#include <rice/rice.hpp>
 
 #include <vector>
 #include <iostream>
 
-using namespace std;
 using namespace Rice;
 
 TESTSUITE(Director);
@@ -16,9 +13,10 @@ namespace {
   /**
    * Abstract base class
    */
-  class Worker {
+  class Worker
+  {
     public:
-      virtual ~Worker() {  }
+      virtual ~Worker() = default;
 
       int getNumber() { return 12; }
 
@@ -40,18 +38,24 @@ namespace {
   /**
    * Class to handle workers
    */
-  class Handler {
+  class Handler
+  {
     std::vector<Worker*> mWorkers;
 
     public:
 
-      void addWorker(Worker* worker) { mWorkers.push_back(worker); }
+      void addWorker(Worker* worker)
+      {
+        mWorkers.push_back(worker);
+      }
 
-      int processWorkers(int start) {
+      int processWorkers(int start)
+      {
         std::vector<Worker*>::iterator i = mWorkers.begin();
         int results = start;
 
-        for(; i != mWorkers.end(); i++) {
+        for(; i != mWorkers.end(); i++)
+        {
           results = (*i)->process(results);
         }
 
@@ -62,24 +66,29 @@ namespace {
   /**
    * Our Director wrapper of Worker
    */
-  class WorkerDirector : public Worker, public Rice::Director {
+  class WorkerDirector : public Worker, public Rice::Director
+  {
     public:
       WorkerDirector(Object self) : Director(self) { }
 
-      virtual int process(int num) {
-        return from_ruby<int>( getSelf().call("process", num) );
+      virtual int process(int num)
+      {
+        return detail::From_Ruby<int>().convert( getSelf().call("process", num) );
       }
 
-      int default_process(int num) {
+      int default_process(int num)
+      {
         raisePureVirtual();
         return 0;
       }
 
-      virtual int doSomething(int num) {
-        return from_ruby<int>( getSelf().call("do_something", num) );
+      virtual int doSomething(int num)
+      {
+        return detail::From_Ruby<int>().convert( getSelf().call("do_something", num) );
       }
 
-      int default_doSomething(int num) {
+      int default_doSomething(int num)
+      {
         return Worker::doSomething(num);
       }
   };
@@ -87,7 +96,7 @@ namespace {
 
 SETUP(Director)
 {
-  ruby_init();
+  embed_ruby();
 }
 
 TESTCASE(exposes_worker_as_instantiatable_class)
@@ -100,7 +109,7 @@ TESTCASE(exposes_worker_as_instantiatable_class)
   Module m = define_module("Testing");
   Object result = m.instance_eval("worker = Worker.new; worker.get_number");
 
-  ASSERT_EQUAL(12, from_ruby<int>(result.value()));
+  ASSERT_EQUAL(12, detail::From_Ruby<int>().convert(result.value()));
 }
 
 TESTCASE(can_call_virtual_methods_on_base_class)
@@ -115,7 +124,7 @@ TESTCASE(can_call_virtual_methods_on_base_class)
 
   Object result = m.instance_eval("worker = Worker.new; worker.do_something(4)");
 
-  ASSERT_EQUAL(16, from_ruby<int>(result.value()));
+  ASSERT_EQUAL(16, detail::From_Ruby<int>().convert(result.value()));
 }
 
 TESTCASE(super_calls_pass_execution_up_the_inheritance_chain)
@@ -130,7 +139,7 @@ TESTCASE(super_calls_pass_execution_up_the_inheritance_chain)
 
   Object result = m.instance_eval("worker = RubyWorker.new; worker.do_something(10)");
 
-  ASSERT_EQUAL(400, from_ruby<int>(result.value()));
+  ASSERT_EQUAL(400, detail::From_Ruby<int>().convert(result.value()));
 }
 
 TESTCASE(super_calls_on_pure_virtual_raise_error)
@@ -157,7 +166,7 @@ TESTCASE(polymorphic_calls_head_down_the_call_chain)
 {
   define_class<Handler>("Handler")
     .define_constructor(Constructor<Handler>())
-    .define_method("add_worker", &Handler::addWorker)
+    .define_method("add_worker", &Handler::addWorker, Arg("worker").keepAlive())
     .define_method("process_workers", &Handler::processWorkers);
 
   define_class<Worker>("Worker")
@@ -178,7 +187,7 @@ TESTCASE(polymorphic_calls_head_down_the_call_chain)
   Object result = m.instance_eval("$handler.process_workers(5)");
 
   // Hit's EchoWorker, so 5 + 2, then passes that to DoubleWorker, so 7 * 2 = 14
-  ASSERT_EQUAL(14, from_ruby<int>(result.value()));
+  ASSERT_EQUAL(14, detail::From_Ruby<int>().convert(result.value()));
 }
 
 namespace {
@@ -194,23 +203,26 @@ namespace {
       virtual int doItImpl(int in) = 0;
   };
 
-  class CallsSelfDirector : public CallsSelf, public Director {
-
+  class CallsSelfDirector : public CallsSelf, public Director
+  {
     public:
       CallsSelfDirector(Object self) : Director(self) { }
       virtual ~CallsSelfDirector() { }
 
-      virtual int doItImpl(int in) {
-        return from_ruby<int>( getSelf().call("do_it_impl", in) );
+      virtual int doItImpl(int in)
+      {
+        return detail::From_Ruby<int>().convert( getSelf().call("do_it_impl", in) );
       }
 
-      int default_doItImpl(int in) {
+      int default_doItImpl(int in)
+      {
         raisePureVirtual();
         return 0;
       }
   };
 
-  struct MyCallsSelf : CallsSelf {
+  struct MyCallsSelf : CallsSelf
+  {
     MyCallsSelf() { }
     virtual ~MyCallsSelf() { }
 
@@ -218,19 +230,21 @@ namespace {
   };
 
   // Abstract type return types handled properly
-  CallsSelf* getCallsSelf() {
+  CallsSelf* getCallsSelf()
+  {
     return new MyCallsSelf();
   }
 
   // Abstract type Argument types handled properly
-  int doItOnPointer(CallsSelf* obj, int in) {
+  int doItOnPointer(CallsSelf* obj, int in)
+  {
     return obj->doIt(in);
   }
 
-  int doItOnReference(CallsSelf& obj, int in) {
+  int doItOnReference(CallsSelf& obj, int in)
+  {
     return obj.doIt(in);
   }
-
 }
 
 TESTCASE(mix_of_polymorphic_calls_and_inheritance_dont_cause_infinite_loops)
@@ -248,7 +262,7 @@ TESTCASE(mix_of_polymorphic_calls_and_inheritance_dont_cause_infinite_loops)
       "c = MySelf.new; c.do_it(10)"
       );
 
-  ASSERT_EQUAL(100, from_ruby<int>(result.value()));
+  ASSERT_EQUAL(100, detail::From_Ruby<int>().convert(result.value()));
 }
 
 TESTCASE(director_class_super_classes_get_type_bound)
@@ -262,8 +276,9 @@ 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("cs = Testing::get_calls_self; cs.do_it(3);");
-  ASSERT_EQUAL(36, from_ruby<int>(result.value()));
+  Object result = m.instance_eval(R"(cs = Testing::get_calls_self
+                                     cs.do_it(3))");
+  ASSERT_EQUAL(36, detail::From_Ruby<int>().convert(result.value()));
 }
 
 TESTCASE(director_allows_abstract_types_used_as_parameters_pointers)
@@ -283,9 +298,9 @@ TESTCASE(director_allows_abstract_types_used_as_parameters_pointers)
       "Testing::do_it_on_pointer(c, 5)"
       );
 
-  ASSERT_EQUAL(50, from_ruby<int>(result.value()));
+  ASSERT_EQUAL(50, detail::From_Ruby<int>().convert(result.value()));
 }
-/*
+
 TESTCASE(director_allows_abstract_types_used_as_parameters_reference)
 {
   Module m = define_module("Testing");
@@ -303,6 +318,5 @@ TESTCASE(director_allows_abstract_types_used_as_parameters_reference)
       "Testing::do_it_on_ref(c, 3)"
       );
 
-  ASSERT_EQUAL(30, from_ruby<int>(result.value()));
-}
-*/
+  ASSERT_EQUAL(30, detail::From_Ruby<int>().convert(result.value()));
+}

data/test/test_Enum.cpp

@@ -1,11 +1,10 @@
-#include "unittest.hpp"
-#include "rice/Enum.hpp"
-#include "rice/Array.hpp"
-#include "rice/String.hpp"
-#include "rice/Constructor.hpp"
-#include "rice/global_function.hpp"
 #include <iostream>
 
+#include "unittest.hpp"
+#include "embed_ruby.hpp"
+
+#include <rice/rice.hpp>
+
 using namespace Rice;
 
 TESTSUITE(Enum);
@@ -22,144 +21,202 @@ namespace
       .define_value("GREEN", GREEN);
     return colors;
   }
+  
+  enum class Season { Spring, Summer, Fall, Winter };
+
+  // This is needed to make unittest compile (it uses ostream to report errors)
+  inline std::ostream& operator<<(std::ostream& os, const Season& season)
+  {
+    os << static_cast<std::underlying_type_t<Season>>(season);
+    return os;
+  }
+
+  Enum<Season> define_season_enum()
+  {
+    static Enum<Season> seasons = define_enum<Season>("Season")
+      .define_value("Spring", Season::Spring)
+      .define_value("Summer", Season::Summer)
+      .define_value("Fall", Season::Fall)
+      .define_value("Winter", Season::Winter);
+
+    return seasons;
+  }
 }
 
 SETUP(Enum)
 {
-  ruby_init();
+  embed_ruby();
 }
 
 TESTCASE(copy_construct)
 {
-  Enum<Color> rb_cColor(define_color_enum());
-  ASSERT_EQUAL(define_color_enum().value(), rb_cColor.value());
+  Enum<Color> colorEnum(define_color_enum());
+  ASSERT_EQUAL(define_color_enum().value(), colorEnum.value());
 }
 
 TESTCASE(assignment)
 {
-  Enum<Color> rb_cColor;
-  rb_cColor = define_color_enum();
-  ASSERT_EQUAL(define_color_enum().value(), rb_cColor.value());
+  Enum<Color> colorEnum;
+  colorEnum = define_color_enum();
+  ASSERT_EQUAL(define_color_enum().value(), colorEnum.value());
 }
 
 TESTCASE(each)
 {
-  Enum<Color> rb_cColor = define_color_enum();
-  Array a = protect(rb_eval_string, "a = []; Color.each { |x| a << x }; a");
+  Module m = define_module("Testing");
+
+  Enum<Color> colorEnum = define_color_enum();
+
+  std::string code = R"(a = []
+                        Color.each { |x| a << x }
+                        a)";
+  Array a = m.instance_eval(code);
   ASSERT_EQUAL(3u, a.size());
-  ASSERT_EQUAL(RED, from_ruby<Color>(a[0]));
-  ASSERT_EQUAL(BLACK, from_ruby<Color>(a[1]));
-  ASSERT_EQUAL(GREEN, from_ruby<Color>(a[2]));
+
+  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);
+}
+
+TESTCASE(each_seasons)
+{
+  Module m = define_module("Testing");
+
+  Enum<Season> rb_cSeason = define_season_enum();
+  std::string code = R"(a = []
+                        Season.each { |x| a << x }
+                        a)";
+
+  Array a = m.instance_eval(code);
+  ASSERT_EQUAL(4u, a.size());
+
+  Data_Object<Season> enum_0(a[0]);
+  ASSERT_EQUAL(Season::Spring, *enum_0);
+
+  Data_Object<Season> enum_1(a[1]);
+  ASSERT_EQUAL(Season::Summer, *enum_1);
+
+  Data_Object<Season> enum_2(a[2]);
+  ASSERT_EQUAL(Season::Fall, *enum_2);
+
+  Data_Object<Season> enum_3(a[3]);
+  ASSERT_EQUAL(Season::Winter, *enum_3);
 }
 
 TESTCASE(to_s)
 {
-  Enum<Color> rb_cColor = define_color_enum();
-  ASSERT_EQUAL(String("RED"), String(protect(rb_eval_string, "Color::RED.to_s")));
-  ASSERT_EQUAL(String("BLACK"), String(protect(rb_eval_string, "Color::BLACK.to_s")));
-  ASSERT_EQUAL(String("GREEN"), String(protect(rb_eval_string, "Color::GREEN.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")));
 }
 
 TESTCASE(to_i)
 {
-  Enum<Color> rb_cColor = define_color_enum();
-  ASSERT_EQUAL(to_ruby(int(RED)), Object(protect(rb_eval_string, "Color::RED.to_i")));
-  ASSERT_EQUAL(to_ruby(int(BLACK)), Object(protect(rb_eval_string, "Color::BLACK.to_i")));
-  ASSERT_EQUAL(to_ruby(int(GREEN)), Object(protect(rb_eval_string, "Color::GREEN.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());
 }
 
 TESTCASE(inspect)
 {
-  Enum<Color> rb_cColor = define_color_enum();
-  ASSERT_EQUAL(String("#<Color::RED>"), String(protect(rb_eval_string, "Color::RED.inspect")));
-  ASSERT_EQUAL(String("#<Color::BLACK>"), String(protect(rb_eval_string, "Color::BLACK.inspect")));
-  ASSERT_EQUAL(String("#<Color::GREEN>"), String(protect(rb_eval_string, "Color::GREEN.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")));
 }
 
 TESTCASE(compare)
 {
-  Enum<Color> rb_cColor = define_color_enum();
-  ASSERT_EQUAL(to_ruby(-1), Object(protect(rb_eval_string, "Color::RED <=> Color::BLACK")));
-  ASSERT_EQUAL(to_ruby(1), Object(protect(rb_eval_string, "Color::GREEN <=> Color::RED")));
-  ASSERT_EQUAL(to_ruby(0), Object(protect(rb_eval_string, "Color::BLACK <=> Color::BLACK")));
+  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());
 }
 
 TESTCASE(eql)
 {
-  Enum<Color> rb_cColor = define_color_enum();
-  ASSERT_EQUAL(to_ruby(false), Object(protect(rb_eval_string, "Color::RED == Color::BLACK")));
-  ASSERT_EQUAL(to_ruby(true), Object(protect(rb_eval_string, "Color::GREEN == Color::GREEN")));
-}
+  Module m = define_module("Testing");
 
-TESTCASE(invalid_to_s)
-{
-  Enum<Color> rb_cColor = define_color_enum();
-  Data_Object<Color> invalid(new Color(static_cast<Color>(42)));
-  ASSERT_EQUAL(String("INVALID(42)"), invalid.to_s());
+  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());
 }
 
-TESTCASE(invalid_to_i)
+TESTCASE(compare_equal)
 {
-  Enum<Color> rb_cColor = define_color_enum();
-  Data_Object<Color> invalid(new Color(static_cast<Color>(42)));
-  ASSERT_EQUAL(to_ruby(42), invalid.call("to_i"));
+  Enum<Color> colorEnum = define_color_enum();
+  Object color1 = colorEnum.const_get("RED");
+  Object color2 = colorEnum.const_get("RED");
+  Object result = color1.call("<=>", color2);
+  ASSERT_EQUAL(0, detail::From_Ruby<int>().convert(result));
 }
 
-TESTCASE(invalid_inspect)
+TESTCASE(compare_less)
 {
-  Enum<Color> rb_cColor = define_color_enum();
-  Data_Object<Color> invalid(new Color(static_cast<Color>(42)));
-  ASSERT_EQUAL(String("#<Color::INVALID(42)>"), invalid.inspect());
+  Enum<Color> colorEnum = define_color_enum();
+  Object color1 = colorEnum.const_get("RED");
+  Object color2 = colorEnum.const_get("BLACK");
+  Object result = color1.call("<=>", color2);
+  ASSERT_EQUAL(-1, detail::From_Ruby<int>().convert(result));
 }
 
-TESTCASE(invalid_compare)
+TESTCASE(compare_more)
 {
-  Enum<Color> rb_cColor = define_color_enum();
-  Data_Object<Color> invalid(new Color(static_cast<Color>(42)));
-  Data_Object<Color> red(new Color(RED));
-  ASSERT_EQUAL(1, invalid.compare(red));
-  ASSERT_EQUAL(-1, red.compare(invalid));
-  ASSERT_EQUAL(0, invalid.compare(invalid));
+  Enum<Color> colorEnum = define_color_enum();
+  Object color1 = colorEnum.const_get("GREEN");
+  Object color2 = colorEnum.const_get("BLACK");
+  Object result = color1.call("<=>", color2);
+  ASSERT_EQUAL(1, detail::From_Ruby<int>().convert(result));
 }
 
-TESTCASE(invalid_eql)
+TESTCASE(different_objects_eql)
 {
-  Enum<Color> rb_cColor = define_color_enum();
-  Data_Object<Color> invalid(new Color(static_cast<Color>(42)));
-  Data_Object<Color> red(new Color(RED));
-  ASSERT_EQUAL(false, invalid == red);
-  ASSERT_EQUAL(false, red == invalid);
-  ASSERT_EQUAL(true, invalid == invalid);
+  Enum<Color> colorEnum = define_color_enum();
+  Object black1 = colorEnum.const_get("BLACK");
+  Object black2 = colorEnum.const_get("BLACK");
+  Object result = black1.call("==", black2);
+  ASSERT_EQUAL(Qtrue, result.value());
 }
 
-TESTCASE(different_objects_compare)
+TESTCASE(hash)
 {
-  Enum<Color> rb_cColor = define_color_enum();
-  Data_Object<Color> red1(new Color(RED));
-  Data_Object<Color> red2(new Color(RED));
-  ASSERT_EQUAL(0, red1.compare(red2));
+  Enum<Color> colorEnum = define_color_enum();
+  Object color = colorEnum.const_get("GREEN");
+  Object result = color.call("hash");
+  ASSERT_EQUAL((int)Color::GREEN, detail::From_Ruby<int>().convert(result));
 }
 
-TESTCASE(different_objects_eql)
+TESTCASE(from_int)
 {
-  Enum<Color> rb_cColor = define_color_enum();
-  Data_Object<Color> red1(new Color(RED));
-  Data_Object<Color> red2(new Color(RED));
-  ASSERT_EQUAL(true, red1 == red2);
+  Enum<Color> colorEnum = define_color_enum();
+  Object result = colorEnum.call("from_int", 2);
+  ASSERT_EQUAL(result, colorEnum.const_get("GREEN"));
 }
 
-TESTCASE(hash)
+TESTCASE(from_int_invalid)
 {
-  Enum<Color> rb_cColor = define_color_enum();
-  Data_Object<Color> red(new Color(RED));
-  ASSERT_EQUAL(to_ruby(int(RED)), red.call("hash"));
-}
+  Enum<Color> colorEnum = define_color_enum();
 
-TESTCASE(from_int)
-{
-  Enum<Color> rb_cColor = define_color_enum();
-  Data_Object<Color> color(rb_cColor.call("from_int", int(RED)));
-  ASSERT_EQUAL(RED, *color);
+  ASSERT_EXCEPTION_CHECK(
+    Exception,
+    Object result = colorEnum.call("from_int", 22),
+    ASSERT_EQUAL("Unknown enum value: 22", ex.what())
+  );
 }
 
 namespace
@@ -178,38 +235,107 @@ namespace
 
 TESTCASE(nested_enums)
 {
+  Data_Type<Inner> inner = define_class<Inner>("Inner");
+  define_enum<Inner::Props>("Props", inner)
+    .define_value("VALUE1", Inner::VALUE1)
+    .define_value("VALUE2", Inner::VALUE2)
+    .define_value("VALUE3", Inner::VALUE3);
+  inner.define_constructor(Constructor<Inner>());
+
+  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());
+}
+
+namespace
+{
+  Color myFavoriteColor()
   {
-    Data_Type<Inner> inner = define_class<Inner>("Inner");
-    define_enum<Inner::Props>("Props", inner)
-      .define_value("VALUE1", Inner::VALUE1)
-      .define_value("VALUE2", Inner::VALUE2)
-      .define_value("VALUE3", Inner::VALUE3);
-    inner.define_constructor(Constructor<Inner>());
+    return RED;
   }
 
-  ASSERT_EQUAL(to_ruby(int(0)), Object(protect(rb_eval_string, "Inner::Props::VALUE1.to_i")));
-  ASSERT_EQUAL(to_ruby(int(1)), Object(protect(rb_eval_string, "Inner::Props::VALUE2.to_i")));
-  ASSERT_EQUAL(to_ruby(int(2)), Object(protect(rb_eval_string, "Inner::Props::VALUE3.to_i")));
+  bool isMyFavoriteColor(Color aColor)
+  {
+    return aColor == RED;
+  }
+}
+
+TESTCASE(using_enums)
+{
+  Enum<Color> colorEnum = define_color_enum();
+  colorEnum.define_singleton_function("my_favorite_color", &myFavoriteColor)
+       .define_singleton_function("is_my_favorite_color", &isMyFavoriteColor)
+       .define_singleton_function("is_my_favorite_color", &isMyFavoriteColor)
+       .define_method("is_my_favorite_color", &isMyFavoriteColor);
+
+  Module m = define_module("Testing");
+
+  Object result = m.instance_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)");
+  ASSERT_EQUAL(Qtrue, result.value());
+
+  result = m.instance_eval("Color.is_my_favorite_color(Color::BLACK)");
+  ASSERT_EQUAL(Qfalse, result.value());
+
+  result = m.instance_eval("Color::RED.is_my_favorite_color");
+  ASSERT_EQUAL(Qtrue, result.value());
+
+  result = m.instance_eval("Color::BLACK.is_my_favorite_color");
+  ASSERT_EQUAL(Qfalse, result.value());
 }
 
 namespace
 {
-  Color getEnum()
+  Color defaultColor(Color aColor = BLACK)
   {
-    return GREEN;
+    return aColor;
   }
 }
 
-TESTCASE(return_enum_value_to_ruby)
+TESTCASE(default_argument)
 {
-  Enum<Color> rb_cColor = define_color_enum();
-  define_global_function("get_enum", &getEnum);
+  define_global_function("default_color", &defaultColor, Arg("aColor") = Color::BLACK);
 
-  ASSERT_EQUAL(
-    Data_Object<Color>(protect(rb_eval_string, "Color::GREEN")),
-    Data_Object<Color>(protect(rb_eval_string, "get_enum"))
-  );
+  Module m = define_module("Testing");
+  Object result = m.instance_eval("default_color");
+  ASSERT_EQUAL(Color::BLACK, detail::From_Ruby<Color>().convert(result.value()));
+}
+
+namespace
+{
+  enum class Undefined { A, B, C };
+
+  void undefinedArg(Undefined undefined)
+  {
+  }
 
-  ASSERT_EQUAL(String("GREEN"), String(protect(rb_eval_string, "get_enum.to_s")));
-  ASSERT_EQUAL(String("#<Color::GREEN>"), String(protect(rb_eval_string, "get_enum.inspect")));
+  Undefined undefinedReturn()
+  {
+    return Undefined::B;
+  }
 }
+
+TESTCASE(not_defined)
+{
+#ifdef _MSC_VER
+  const char* message = "Type is not defined with Rice: enum `anonymous namespace'::Undefined";
+#else
+  const char* message = "Type is not defined with Rice: (anonymous namespace)::Undefined";
+#endif
+
+  ASSERT_EXCEPTION_CHECK(
+    std::invalid_argument,
+    define_global_function("undefined_arg", &undefinedArg),
+    ASSERT_EQUAL(message, ex.what())
+  );
+
+  ASSERT_EXCEPTION_CHECK(
+    std::invalid_argument,
+    define_global_function("undefined_return", &undefinedReturn),
+    ASSERT_EQUAL(message, ex.what())
+  );
+}