rice 1.2.0 → 1.3.0

data/test/ext/t1/extconf.rb

@@ -0,0 +1,2 @@
+require 'mkmf-rice'
+create_makefile('t1')

data/test/ext/t1/t1.cpp

@@ -0,0 +1,15 @@
+#include "Foo.hpp"
+
+#include "rice/Data_Type.hpp"
+#include "rice/Constructor.hpp"
+
+using namespace Rice;
+
+extern "C"
+void Init_t1()
+{
+  define_class<Foo>("Foo")
+    .define_constructor(Constructor<Foo>())
+    .define_method("foo", &Foo::foo);
+}
+

data/test/ext/t2/extconf.rb

@@ -0,0 +1,2 @@
+require 'mkmf-rice'
+create_makefile('t2')

data/test/ext/t2/t2.cpp

@@ -0,0 +1,11 @@
+#include "../t1/Foo.hpp"
+#include "rice/Data_Type.hpp"
+
+using namespace Rice;
+
+extern "C"
+void Init_t2()
+{
+  volatile Data_Type<Foo> foo;
+}
+

data/test/test_Allocation_Strategies.cpp

@@ -67,7 +67,7 @@ TESTCASE(xmalloc_allocation_strategy_allocate)
 
 TESTCASE(xmalloc_allocation_strategy_free)
 {
-  Foo * t = new Foo;
+  Foo * t = Xmalloc_Allocation_Strategy<Foo>::allocate();
   ASSERT(constructor_called);
   ASSERT(!destructor_called);
   Xmalloc_Allocation_Strategy<Foo>::free(t);

data/test/test_Class.cpp

@@ -396,3 +396,82 @@ TESTCASE(subclassing)
   m.instance_eval("class NewClass < Testing::BaseClass; end;");
   m.instance_eval("n = NewClass.new");
 }
+
+namespace 
+{
+  int defaults_method_one_arg1;
+  int defaults_method_one_arg2;
+  bool defaults_method_one_arg3 = false;
+
+  class DefaultArgs
+  {
+    public:
+      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)
+{
+  Class c = define_class<DefaultArgs>("DefaultArgs")
+              .define_constructor(Constructor<DefaultArgs>())
+              .define_method("with_defaults", 
+                  &DefaultArgs::defaults_method_one, 
+                  (Arg("arg1"), Arg("arg2") = 3, Arg("arg3") = true));
+
+  Object o = c.call("new");
+  o.call("with_defaults", 2);
+
+  ASSERT_EQUAL(2, defaults_method_one_arg1);
+  ASSERT_EQUAL(3, defaults_method_one_arg2);
+  ASSERT(defaults_method_one_arg3);
+
+  o.call("with_defaults", 11, 10);
+
+  ASSERT_EQUAL(11, defaults_method_one_arg1);
+  ASSERT_EQUAL(10, defaults_method_one_arg2);
+  ASSERT(defaults_method_one_arg3);
+
+  o.call("with_defaults", 22, 33, false);
+
+  ASSERT_EQUAL(22, defaults_method_one_arg1);
+  ASSERT_EQUAL(33, defaults_method_one_arg2);
+  ASSERT(!defaults_method_one_arg3);
+}
+
+/*
+namespace {
+  float with_reference_defaults_x;
+  std::string with_reference_defaults_str;
+
+  class DefaultArgsRefs 
+  {
+    public:
+      void with_reference_defaults(float x, std::string const& str = std::string("testing"))
+      {
+        with_reference_defaults_x = x;
+        with_reference_defaults_str = str;
+      }
+  };
+
+}
+
+TESTCASE(define_method_works_with_reference_const_default_values) 
+{
+  Class c = define_class<DefaultArgsRefs>("DefaultArgsRefs")
+              .define_constructor(Constructor<DefaultArgsRefs>())
+              .define_method("bar", 
+                  &DefaultArgsRefs::with_reference_defaults, 
+                  (Arg("x"), Arg("str") = std::string("testing")));
+
+  Object o = c.call("new");
+  o.call("bar", 3);
+
+  ASSERT_EQUAL(3, with_reference_defaults_x);
+  ASSERT_EQUAL("testing", with_reference_defaults_str);
+}
+*/

data/test/test_Data_Type.cpp

@@ -44,7 +44,7 @@ namespace {
       }
 
       int process() {
-        vector<Listener*>::iterator i = mListeners.begin();
+        std::vector<Listener*>::iterator i = mListeners.begin();
         int accum = 0; 
         for(; i != mListeners.end(); i++) {
           accum += (*i)->getValue();
@@ -56,7 +56,7 @@ namespace {
       int listenerCount() { return mListeners.size(); }
 
     private:
-      vector<Listener*> mListeners;
+      std::vector<Listener*> mListeners;
   };
 }
 

data/test/test_Director.cpp

@@ -65,20 +65,20 @@ namespace {
     public:
       WorkerDirector(Object self) : Director(self) { }
 
-      int process(int num) {
-        if(callIsFromRuby("process")) {
-          raisePureVirtual();
-        } else {
-          return from_ruby<int>( getSelf().call("process", num) );
-        }
+      virtual int process(int num) {
+        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) );
-        }
+      int default_process(int num) {
+        raisePureVirtual();
+      }
+
+      virtual int doSomething(int num) {
+        return from_ruby<int>( getSelf().call("do_something", num) );
+      }
+
+      int default_doSomething(int num) {
+        return Worker::doSomething(num);
       }
   };
 };
@@ -86,15 +86,12 @@ namespace {
 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_class<Worker>("Worker")
+    .define_director<WorkerDirector>()
     .define_constructor(Constructor<WorkerDirector, Object>())
     .define_method("get_number", &Worker::getNumber);
 
@@ -106,10 +103,11 @@ TESTCASE(exposes_worker_as_instantiatable_class)
 
 TESTCASE(can_call_virtual_methods_on_base_class)
 {
-  define_class<WorkerDirector, Worker>("Worker")
+  define_class<Worker>("Worker")
+    .define_director<WorkerDirector>()
     .define_constructor(Constructor<WorkerDirector, Object>())
     .define_method("get_number", &Worker::getNumber)
-    .define_method("do_something", &WorkerDirector::doSomething);
+    .define_method("do_something", &WorkerDirector::default_doSomething);
 
   Module m = define_module("Testing");
 
@@ -120,9 +118,10 @@ TESTCASE(can_call_virtual_methods_on_base_class)
 
 TESTCASE(super_calls_pass_execution_up_the_inheritance_chain)
 {
-  define_class<WorkerDirector, Worker>("Worker")
+  define_class<Worker>("Worker")
+    .define_director<WorkerDirector>()
     .define_constructor(Constructor<WorkerDirector, Object>())
-    .define_method("do_something", &WorkerDirector::doSomething);
+    .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");
@@ -134,9 +133,10 @@ TESTCASE(super_calls_pass_execution_up_the_inheritance_chain)
 
 TESTCASE(super_calls_on_pure_virtual_raise_error)
 {
-  define_class<WorkerDirector, Worker>("Worker")
+  define_class<Worker>("Worker")
+    .define_director<WorkerDirector>()
     .define_constructor(Constructor<WorkerDirector, Object>())
-    .define_method("process", &WorkerDirector::process);
+    .define_method("process", &WorkerDirector::default_process);
 
   Module m = define_module("Testing");
   m.instance_eval("class RubyWorker < Worker; def process(num); super; end; end");
@@ -158,21 +158,22 @@ TESTCASE(polymorphic_calls_head_down_the_call_chain)
     .define_method("add_worker", &Handler::addWorker)
     .define_method("process_workers", &Handler::processWorkers);
 
-  define_class<WorkerDirector, Worker>("Worker")
+  define_class<Worker>("Worker")
+    .define_director<WorkerDirector>()
     .define_constructor(Constructor<WorkerDirector, Object>())
-    .define_method("process", &WorkerDirector::process);
+    .define_method("process", &WorkerDirector::default_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);"
+      "$handler = Handler.new;"
+      "$handler.add_worker(EchoWorker.new);"
+      "$handler.add_worker(DoubleWorker.new);"
   );
 
-  Object result = m.instance_eval("handler.process_workers(5)");
+  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()));
@@ -195,23 +196,42 @@ namespace {
       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) );
-        }
+        return from_ruby<int>( getSelf().call("do_it_impl", in) );
+      }
+
+      int default_doItImpl(int in) {
+        raisePureVirtual();
       }
   };
 
+  struct MyCallsSelf : CallsSelf {
+    MyCallsSelf() { }
+
+    int doItImpl(int in) { return in * 12; }
+  };
+
+  // Abstract type return types handled properly
+  CallsSelf* getCallsSelf() {
+    return new MyCallsSelf();
+  }
+
+  // Abstract type Argument types handled properly
+  int doItOnPointer(CallsSelf* obj, int in) {
+    return obj->doIt(in);
+  }
+
+  int doItOnReference(CallsSelf& obj, int in) {
+    return obj.doIt(in);
+  }
+
 }
 
 TESTCASE(mix_of_polymorphic_calls_and_inheritance_dont_cause_infinite_loops)
 {
-  define_class<CallsSelf>("__CallsSelf__");
-
-  define_class<CallsSelfDirector, CallsSelf>("CallsSelf")
+  define_class<CallsSelf>("CallsSelf")
+    .define_director<CallsSelfDirector>()
     .define_constructor(Constructor<CallsSelfDirector, Rice::Object>())
-    .define_method("do_it_impl", &CallsSelfDirector::doItImpl)
+    .define_method("do_it_impl", &CallsSelfDirector::default_doItImpl)
     .define_method("do_it", &CallsSelf::doIt);
 
   Module m = define_module("Testing");
@@ -223,3 +243,59 @@ TESTCASE(mix_of_polymorphic_calls_and_inheritance_dont_cause_infinite_loops)
 
   ASSERT_EQUAL(100, from_ruby<int>(result.value()));
 }
+
+TESTCASE(director_class_super_classes_get_type_bound)
+{
+  Module m = define_module("Testing");
+  m.define_module_function("get_calls_self", &getCallsSelf);
+
+  define_class<CallsSelf>("CallsSelf")
+    .define_director<CallsSelfDirector>()
+    .define_constructor(Constructor<CallsSelfDirector, Rice::Object>())
+    .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()));
+}
+
+TESTCASE(director_allows_abstract_types_used_as_parameters_pointers)
+{
+  Module m = define_module("Testing");
+  m.define_module_function("do_it_on_pointer", &doItOnPointer);
+
+  define_class<CallsSelf>("CallsSelf")
+    .define_director<CallsSelfDirector>()
+    .define_constructor(Constructor<CallsSelfDirector, Rice::Object>())
+    .define_method("do_it_impl", &CallsSelfDirector::default_doItImpl)
+    .define_method("do_it", &CallsSelf::doIt);
+
+  Object result = m.instance_eval(
+      "class MySelf < CallsSelf; def do_it_impl(num); num * 10; end; end;"
+      "c = MySelf.new;"
+      "Testing::do_it_on_pointer(c, 5)"
+      );
+
+  ASSERT_EQUAL(50, from_ruby<int>(result.value()));
+}
+/*
+TESTCASE(director_allows_abstract_types_used_as_parameters_reference)
+{
+  Module m = define_module("Testing");
+  m.define_module_function("do_it_on_ref", &doItOnReference);
+
+  define_class<CallsSelf>("CallsSelf")
+    .define_director<CallsSelfDirector>()
+    .define_constructor(Constructor<CallsSelfDirector, Rice::Object>())
+    .define_method("do_it_impl", &CallsSelfDirector::default_doItImpl)
+    .define_method("do_it", &CallsSelf::doIt);
+
+  Object result = m.instance_eval(
+      "class MySelf < CallsSelf; def do_it_impl(num); num * 10; end; end;"
+      "c = MySelf.new;"
+      "Testing::do_it_on_ref(c, 3)"
+      );
+
+  ASSERT_EQUAL(30, from_ruby<int>(result.value()));
+}
+*/

data/test/test_Module.cpp

@@ -179,12 +179,12 @@ Foo * from_ruby<Foo *>(Object x)
 TESTCASE(define_singleton_method_int_foo)
 {
   Module m(anonymous_module());
-  m.define_singleton_method("foo", define_method_int_foo_helper);
+  m.define_singleton_method("int_and_foo", define_method_int_foo_helper);
   define_method_int_result = 0;
   Foo * foo = new Foo;
   foo->x = 1024;
   VALUE f = Data_Wrap_Struct(rb_cObject, 0, Default_Allocation_Strategy<Foo>::free, foo);
-  m.call("foo", 42, Object(f));
+  m.call("int_and_foo", 42, Object(f));
   ASSERT_EQUAL(42, define_method_int_foo_result_i);
   ASSERT_EQUAL(foo, define_method_int_foo_result_x);
 }
@@ -426,3 +426,28 @@ TESTCASE(define_method_works_with_reference_arguments)
   ASSERT_EQUAL("test", with_defaults_and_references_x);
   ASSERT(!with_defaults_and_references_doIt);
 }
+
+/*
+namespace {
+  float with_reference_defaults_x;
+  std::string with_reference_defaults_str;
+
+  void with_reference_defaults(float x, std::string const& str = std::string("testing"))
+  {
+    with_reference_defaults_x = x;
+    with_reference_defaults_str = str;
+  }
+}
+
+TESTCASE(define_method_works_with_reference_const_default_values) 
+{
+  Module m(anonymous_module());
+  m.define_module_function("bar", &with_reference_defaults, 
+      (Arg("x"), Arg("str") = std::string("testing")));
+
+  m.call("bar", 3);
+
+  ASSERT_EQUAL(3, with_reference_defaults_x);
+  ASSERT_EQUAL("testing", with_reference_defaults_str);
+}
+*/

data/test/test_To_From_Ruby.cpp

@@ -188,9 +188,9 @@ TESTCASE(float_from_ruby)
       std::numeric_limits<float>::max(),
       from_ruby<float>(rb_float_new(std::numeric_limits<float>::max())));
   ASSERT(
-      isnan(from_ruby<float>(rb_float_new(std::numeric_limits<float>::quiet_NaN()))));
+      std::isnan(from_ruby<float>(rb_float_new(std::numeric_limits<float>::quiet_NaN()))));
   ASSERT(
-      isnan(from_ruby<float>(rb_float_new(std::numeric_limits<float>::signaling_NaN()))));
+      std::isnan(from_ruby<float>(rb_float_new(std::numeric_limits<float>::signaling_NaN()))));
   ASSERT_EQUAL(
       std::numeric_limits<float>::epsilon(),
       from_ruby<float>(rb_float_new(std::numeric_limits<float>::epsilon())));
@@ -229,9 +229,9 @@ TESTCASE(double_from_ruby)
       std::numeric_limits<double>::max(),
       from_ruby<double>(rb_float_new(std::numeric_limits<double>::max())));
   ASSERT(
-      isnan(from_ruby<double>(rb_float_new(std::numeric_limits<double>::quiet_NaN()))));
+      std::isnan(from_ruby<double>(rb_float_new(std::numeric_limits<double>::quiet_NaN()))));
   ASSERT(
-      isnan(from_ruby<double>(rb_float_new(std::numeric_limits<double>::signaling_NaN()))));
+      std::isnan(from_ruby<double>(rb_float_new(std::numeric_limits<double>::signaling_NaN()))));
   ASSERT_EQUAL(
       std::numeric_limits<double>::epsilon(),
       from_ruby<double>(rb_float_new(std::numeric_limits<double>::epsilon())));

data/test/test_rice.rb

@@ -16,10 +16,18 @@ class RiceTest < Test::Unit::TestCase
     run_external_test("./vm_unittest#{EXEEXT}")
   end
 
-  def test_vm_unittest
+  def test_multiple_extensions
     run_external_test("#{RUBY} test_multiple_extensions.rb")
   end
 
+  def test_multiple_extensions_with_inheritance
+    run_external_test("#{RUBY} test_multiple_extensions_with_inheritance.rb")
+  end
+
+  def test_multiple_extensions_same_class
+    run_external_test("#{RUBY} test_multiple_extensions_same_class.rb")
+  end
+
   def run_external_test(executable)
     if VERBOSE then
       system(executable)