rice 1.1.0 → 1.2.0

data/test/test_Data_Type.cpp

@@ -0,0 +1,121 @@
+#include "unittest.hpp"
+#include "rice/Data_Type.hpp"
+#include "rice/Exception.hpp"
+#include "rice/Constructor.hpp"
+
+using namespace Rice;
+
+TESTSUITE(Data_Type);
+
+/**
+ * The tests here are for the feature of taking an instance
+ * of a Ruby-subclass of a Rice wrapped class and passing
+ * that instance back into the Rice wrapper. While that
+ * might be confusing, the test code is pretty straight foward
+ * to see what we're talking about.
+ */
+
+namespace {
+
+  /**
+   * The class we will subclass in Ruby
+   */
+  class Listener {
+    public:
+      Listener() {  }
+
+      virtual ~Listener() {  }
+
+      virtual int getValue() { return 4; }
+  };
+
+  /**
+   * This class will recieve a new Listener instance
+   * from Ruby
+   */
+  class ListenerHandler {
+
+    public:
+
+      ListenerHandler() {  }
+
+      void addListener(Listener* newList) {
+        mListeners.push_back(newList);
+      }
+
+      int process() {
+        vector<Listener*>::iterator i = mListeners.begin();
+        int accum = 0; 
+        for(; i != mListeners.end(); i++) {
+          accum += (*i)->getValue();
+        }
+
+        return accum;
+      }
+
+      int listenerCount() { return mListeners.size(); }
+
+    private:
+      vector<Listener*> mListeners;
+  };
+}
+
+SETUP(Data_Type)
+{
+  ruby_init();
+
+  define_class<Listener>("Listener")
+    .define_constructor(Constructor<Listener>())
+    .define_method("get_value", &Listener::getValue);
+
+  define_class<ListenerHandler>("ListenerHandler")
+    .define_constructor(Constructor<ListenerHandler>())
+    .define_method("add_listener", &ListenerHandler::addListener)
+    .define_method("process", &ListenerHandler::process)
+    .define_method("listener_count", &ListenerHandler::listenerCount);
+
+}
+
+TESTCASE(can_send_ruby_instance_back_into_rice)
+{
+  Module m = define_module("TestingModule");
+  Object handler = m.instance_eval("@handler = ListenerHandler.new");
+
+  ASSERT_EQUAL(INT2NUM(0), handler.call("listener_count").value());
+
+  m.instance_eval("class MyListener < Listener; end;");
+  m.instance_eval("@handler.add_listener(MyListener.new)");
+
+  ASSERT_EQUAL(INT2NUM(1), handler.call("listener_count").value());
+  ASSERT_EQUAL(INT2NUM(4), handler.call("process").value());
+
+  m.instance_eval("@handler.add_listener(Listener.new)");
+
+  ASSERT_EQUAL(INT2NUM(2), handler.call("listener_count").value());
+  ASSERT_EQUAL(INT2NUM(8), handler.call("process").value());
+}
+
+/**
+ * The following test SEGFAULTs right now
+ */
+/*
+TESTCASE(no_super_in_constructor_still_works) 
+{
+  Module m = define_module("TestingModule");
+  Object handler = m.instance_eval("@handler = ListenerHandler.new");
+
+  ASSERT_EQUAL(INT2NUM(0), handler.call("listener_count").value());
+
+  // Because of this, there's a constructor but no super call
+  m.instance_eval("class MyListener < Listener; def initialize; @val = 10; end; end;");
+  m.instance_eval("@handler.add_listener(MyListener.new)");
+
+  ASSERT_EQUAL(INT2NUM(1), handler.call("listener_count").value());
+  ASSERT_EQUAL(INT2NUM(4), handler.call("process").value());
+
+  m.instance_eval("@handler.add_listener(MyListener.new)");
+
+  ASSERT_EQUAL(INT2NUM(2), handler.call("listener_count").value());
+  ASSERT_EQUAL(INT2NUM(8), handler.call("process").value());
+}
+*/

data/test/test_Director.cpp

@@ -0,0 +1,225 @@
+#include "unittest.hpp"
+#include "rice/Director.hpp"
+#include "rice/Constructor.hpp"
+#include "rice/Data_Type.hpp"
+
+#include <vector>
+#include <iostream>
+
+using namespace std;
+using namespace Rice;
+
+TESTSUITE(Director);
+
+namespace {
+  /**
+   * Abstract base class
+   */
+  class Worker {
+    public:
+      virtual ~Worker() {  }
+
+      int getNumber() { return 12; }
+
+      virtual int doSomething(int num) { return num * 4; }
+
+      virtual int process(int num) = 0;
+  };
+
+  /**
+   * Subclass that implements pure virtual
+   */
+  class MultiplyWorker : public Worker {
+    public:
+      virtual ~MultiplyWorker() { }
+
+      virtual int process(int num) { return num * 2; }
+  };
+
+  /**
+   * Class to handle workers
+   */
+  class Handler {
+    std::vector<Worker*> mWorkers;
+
+    public:
+
+      void addWorker(Worker* worker) { mWorkers.push_back(worker); }
+
+      int processWorkers(int start) {
+        std::vector<Worker*>::iterator i = mWorkers.begin();
+        int results = start;
+
+        for(; i != mWorkers.end(); i++) {
+          results = (*i)->process(results);
+        }
+
+        return results;
+      }
+  };
+
+  /**
+   * Our Director wrapper of Worker
+   */
+  class WorkerDirector : public Worker, public Rice::Director {
+    public:
+      WorkerDirector(Object self) : Director(self) { }
+
+      int process(int num) {
+        if(callIsFromRuby("process")) {
+          raisePureVirtual();
+        } else {
+          return from_ruby<int>( getSelf().call("process", num) );
+        }
+      }
+
+      int doSomething(int num) {
+        if(callIsFromRuby("do_something")) {
+          return this->Worker::doSomething(num);
+        } else {
+          return from_ruby<int>( getSelf().call("do_something", num) );
+        }
+      }
+  };
+};
+
+SETUP(Director)
+{
+  ruby_init();
+
+  // Always need to tell Rice about the base class so that
+  // casting works correctly
+  define_class<Worker>("__Worker__");
+}
+
+TESTCASE(exposes_worker_as_instantiatable_class)
+{
+  define_class<WorkerDirector, Worker>("Worker")
+    .define_constructor(Constructor<WorkerDirector, Object>())
+    .define_method("get_number", &Worker::getNumber);
+
+  Module m = define_module("Testing");
+  Object result = m.instance_eval("worker = Worker.new; worker.get_number");
+
+  ASSERT_EQUAL(12, from_ruby<int>(result.value()));
+}
+
+TESTCASE(can_call_virtual_methods_on_base_class)
+{
+  define_class<WorkerDirector, Worker>("Worker")
+    .define_constructor(Constructor<WorkerDirector, Object>())
+    .define_method("get_number", &Worker::getNumber)
+    .define_method("do_something", &WorkerDirector::doSomething);
+
+  Module m = define_module("Testing");
+
+  Object result = m.instance_eval("worker = Worker.new; worker.do_something(4)");
+
+  ASSERT_EQUAL(16, from_ruby<int>(result.value()));
+}
+
+TESTCASE(super_calls_pass_execution_up_the_inheritance_chain)
+{
+  define_class<WorkerDirector, Worker>("Worker")
+    .define_constructor(Constructor<WorkerDirector, Object>())
+    .define_method("do_something", &WorkerDirector::doSomething);
+
+  Module m = define_module("Testing");
+  m.instance_eval("class RubyWorker < Worker; def do_something(num); super * num; end; end");
+
+  Object result = m.instance_eval("worker = RubyWorker.new; worker.do_something(10)");
+
+  ASSERT_EQUAL(400, from_ruby<int>(result.value()));
+}
+
+TESTCASE(super_calls_on_pure_virtual_raise_error)
+{
+  define_class<WorkerDirector, Worker>("Worker")
+    .define_constructor(Constructor<WorkerDirector, Object>())
+    .define_method("process", &WorkerDirector::process);
+
+  Module m = define_module("Testing");
+  m.instance_eval("class RubyWorker < Worker; def process(num); super; end; end");
+
+  ASSERT_EXCEPTION_CHECK(
+      Exception,
+      m.instance_eval("worker = RubyWorker.new; worker.process(10)"),
+      ASSERT_EQUAL(
+          Object(rb_eNotImpError),
+          Object(CLASS_OF(ex.value()))
+          )
+      );
+}
+
+TESTCASE(polymorphic_calls_head_down_the_call_chain)
+{
+  define_class<Handler>("Handler")
+    .define_constructor(Constructor<Handler>())
+    .define_method("add_worker", &Handler::addWorker)
+    .define_method("process_workers", &Handler::processWorkers);
+
+  define_class<WorkerDirector, Worker>("Worker")
+    .define_constructor(Constructor<WorkerDirector, Object>())
+    .define_method("process", &WorkerDirector::process);
+
+  Module m = define_module("Testing");
+
+  m.instance_eval(
+      "class EchoWorker < Worker; def process(num); num + 2; end; end;"
+      "class DoubleWorker < Worker; def process(num); num * 2; end; end;"
+      "handler = Handler.new;"
+      "handler.add_worker(EchoWorker.new);"
+      "handler.add_worker(DoubleWorker.new);"
+  );
+
+  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()));
+}
+
+namespace {
+
+  class CallsSelf {
+    public:
+      int doIt(int in) {
+        return doItImpl(in); 
+      }
+
+      virtual int doItImpl(int in) = 0;
+  };
+
+  class CallsSelfDirector : public CallsSelf, public Director {
+
+    public:
+      CallsSelfDirector(Object self) : Director(self) { }
+
+      virtual int doItImpl(int in) {
+        if(!callIsFromRuby("do_it_impl")) {
+          return 0;
+        } else {
+          return from_ruby<int>( getSelf().call("do_it_impl", in) );
+        }
+      }
+  };
+
+}
+
+TESTCASE(mix_of_polymorphic_calls_and_inheritance_dont_cause_infinite_loops)
+{
+  define_class<CallsSelf>("__CallsSelf__");
+
+  define_class<CallsSelfDirector, CallsSelf>("CallsSelf")
+    .define_constructor(Constructor<CallsSelfDirector, Rice::Object>())
+    .define_method("do_it_impl", &CallsSelfDirector::doItImpl)
+    .define_method("do_it", &CallsSelf::doIt);
+
+  Module m = define_module("Testing");
+
+  Object result = m.instance_eval(
+      "class MySelf < CallsSelf; def do_it_impl(num); num * 10; end; end;"
+      "c = MySelf.new; c.do_it(10)"
+      );
+
+  ASSERT_EQUAL(100, from_ruby<int>(result.value()));
+}

data/test/test_Enum.cpp

@@ -2,6 +2,7 @@
 #include "rice/Enum.hpp"
 #include "rice/Array.hpp"
 #include "rice/String.hpp"
+#include "rice/Constructor.hpp"
 #include <iostream>
 
 using namespace Rice;
@@ -146,12 +147,14 @@ TESTCASE(different_objects_eql)
   ASSERT_EQUAL(true, red1 == red2);
 }
 
+/*
 TESTCASE(hash)
 {
   Enum<Color> rb_cColor = define_color_enum();
   Data_Object<Color> red(new Color(RED));
   ASSERT_EQUAL(to_ruby(int(RED)), red.call("hash"));
 }
+*/
 
 TESTCASE(from_int)
 {
@@ -160,3 +163,33 @@ TESTCASE(from_int)
   ASSERT_EQUAL(RED, *color);
 }
 
+namespace
+{
+  class Inner
+  {
+    public:
+      enum Props
+      {
+        VALUE1,
+        VALUE2,
+        VALUE3
+      };
+  };
+}
+
+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>());
+  }
+
+  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")));
+}
+

data/test/test_Module.cpp

@@ -2,6 +2,8 @@
 #include "rice/Module.hpp"
 #include "rice/Exception.hpp"
 #include "rice/Array.hpp"
+#include "rice/Arg.hpp"
+#include "rice/global_function.hpp"
 
 using namespace Rice;
 
@@ -251,3 +253,176 @@ TESTCASE(mod_name_anonymous)
   ASSERT_EQUAL(String(""), m.name());
 }
 
+/**
+ * Tests for default arguments
+ */
+namespace 
+{
+  int defaults_method_one_arg1;
+  int defaults_method_one_arg2;
+  bool defaults_method_one_arg3 = false;
+
+  void defaults_method_one(int arg1, int arg2 = 3, bool arg3 = true) 
+  {
+    defaults_method_one_arg1 = arg1;
+    defaults_method_one_arg2 = arg2;
+    defaults_method_one_arg3 = arg3;
+  }
+}
+
+TESTCASE(define_method_default_arguments)
+{
+  Module m(anonymous_module());
+  m.define_method("foo", &defaults_method_one, (Arg("arg1"), Arg("arg2") = 3, Arg("arg3") = true));
+
+  Object o = m.instance_eval("o = Object.new; o.extend(self); o");
+  o.call("foo", 2);
+
+  ASSERT_EQUAL(2, defaults_method_one_arg1);
+  ASSERT_EQUAL(3, defaults_method_one_arg2);
+  ASSERT(defaults_method_one_arg3);
+
+  o.call("foo", 11, 10);
+
+  ASSERT_EQUAL(11, defaults_method_one_arg1);
+  ASSERT_EQUAL(10, defaults_method_one_arg2);
+  ASSERT(defaults_method_one_arg3);
+
+  o.call("foo", 22, 33, false);
+
+  ASSERT_EQUAL(22, defaults_method_one_arg1);
+  ASSERT_EQUAL(33, defaults_method_one_arg2);
+  ASSERT(!defaults_method_one_arg3);
+}
+
+TESTCASE(default_arguments_still_throws_argument_error)
+{
+  Module m(anonymous_module());
+  m.define_method("foo", &defaults_method_one, (Arg("arg1"), Arg("arg2") = 3, Arg("arg3") = true));
+
+  ASSERT_EXCEPTION_CHECK(
+      Exception,
+      m.instance_eval("o = Object.new; o.extend(self); o.foo()"),
+      ASSERT_EQUAL(
+          Object(rb_eArgError),
+          Object(CLASS_OF(ex.value()))
+          )
+      );
+
+  ASSERT_EXCEPTION_CHECK(
+      Exception,
+      m.instance_eval("o = Object.new; o.extend(self); o.foo(3, 4, false, 17)"),
+      ASSERT_EQUAL(
+          Object(rb_eArgError),
+          Object(CLASS_OF(ex.value()))
+          )
+      );
+}
+
+namespace {
+  int the_one_default_arg = 0;
+  void method_with_one_default_arg(int num = 4) {
+    the_one_default_arg = num;
+  }
+}
+
+TESTCASE(defining_methods_with_single_default_argument)
+{
+  // define_method
+  Module m(anonymous_module());
+  m.define_method("foo", &method_with_one_default_arg, (Arg("num") = 4));
+  m.instance_eval("o = Object.new; o.extend(self); o.foo()");
+  ASSERT_EQUAL(4, the_one_default_arg);
+
+  the_one_default_arg = 0;
+
+  // define_singleton_method
+  Class c(anonymous_class());
+  c.define_singleton_method("foo", &method_with_one_default_arg, (Arg("num") = 4));
+  c.call("foo");
+  ASSERT_EQUAL(4, the_one_default_arg);
+
+  the_one_default_arg = 0;
+
+  // define_module_function
+  m.define_module_function("foo2", &method_with_one_default_arg, (Arg("num") = 4));
+
+  m.call("foo2");
+  ASSERT_EQUAL(4, the_one_default_arg);
+}
+
+TESTCASE(default_arguments_for_define_singleton_method)
+{
+  Class c(anonymous_class());
+  c.define_singleton_method("foo", &defaults_method_one, (Arg("arg1"), Arg("arg2") = 3, Arg("arg3") = true));
+
+  c.call("foo", 2);
+
+  ASSERT_EQUAL(2, defaults_method_one_arg1);
+  ASSERT_EQUAL(3, defaults_method_one_arg2);
+  ASSERT(defaults_method_one_arg3);
+
+  c.call("foo", 11, 10);
+
+  ASSERT_EQUAL(11, defaults_method_one_arg1);
+  ASSERT_EQUAL(10, defaults_method_one_arg2);
+  ASSERT(defaults_method_one_arg3);
+
+  c.call("foo", 22, 33, false);
+
+  ASSERT_EQUAL(22, defaults_method_one_arg1);
+  ASSERT_EQUAL(33, defaults_method_one_arg2);
+  ASSERT(!defaults_method_one_arg3);
+}
+
+TESTCASE(default_arguments_for_define_module_function)
+{
+  Module m(anonymous_module());
+  m.define_module_function("foo", &defaults_method_one, (Arg("arg1"), Arg("arg2") = 3, Arg("arg3") = true));
+
+  m.call("foo", 2);
+
+  ASSERT_EQUAL(2, defaults_method_one_arg1);
+  ASSERT_EQUAL(3, defaults_method_one_arg2);
+  ASSERT(defaults_method_one_arg3);
+
+  m.call("foo", 11, 10);
+
+  ASSERT_EQUAL(11, defaults_method_one_arg1);
+  ASSERT_EQUAL(10, defaults_method_one_arg2);
+  ASSERT(defaults_method_one_arg3);
+
+  m.call("foo", 22, 33, false);
+
+  ASSERT_EQUAL(22, defaults_method_one_arg1);
+  ASSERT_EQUAL(33, defaults_method_one_arg2);
+  ASSERT(!defaults_method_one_arg3);
+}
+
+namespace {
+  std::string with_defaults_and_references_x;
+  bool with_defaults_and_references_doIt;
+
+  void with_defaults_and_references(std::string const& x, bool doIt = false)
+  {
+    with_defaults_and_references_x = x;
+    with_defaults_and_references_doIt = doIt;
+  }
+}
+
+template<>
+std::string* from_ruby<std::string*>(Rice::Object x) {
+  return new std::string(from_ruby<char const*>(x));
+}
+
+TESTCASE(define_method_works_with_reference_arguments) 
+{
+  Module m(anonymous_module());
+  m.define_module_function("foo", &with_defaults_and_references, 
+      (Arg("x"), Arg("doIt") = false));
+
+  m.call("foo", "test");
+
+  ASSERT_EQUAL("test", with_defaults_and_references_x);
+  ASSERT(!with_defaults_and_references_doIt);
+}