jameskilton-rice 1.2.0

data/test/test_Constructor.cpp

@@ -0,0 +1,238 @@
+#include "unittest.hpp"
+#include "rice/Constructor.hpp"
+#include "rice/Data_Type.hpp"
+
+#include "rice/detail/env.hpp"
+
+#include <iostream>
+using namespace std;
+
+using namespace Rice;
+
+TESTSUITE(Constructor);
+
+namespace
+{
+  class Default_Constructible
+  {
+  public:
+    Default_Constructible()
+    {
+    }
+  };
+}
+
+TESTCASE(default_constructor)
+{
+  Data_Type<Default_Constructible> rb_cDefault_Constructible(
+      anonymous_class());
+  rb_cDefault_Constructible
+    .define_constructor(Constructor<Default_Constructible>());
+  Object o = rb_cDefault_Constructible.call("new");
+  ASSERT_EQUAL(rb_cDefault_Constructible, o.class_of());
+}
+
+
+namespace
+{
+  class Non_Default_Constructible
+  {
+  public:
+    Non_Default_Constructible(int i)
+      : i_(i)
+    {
+    }
+
+    int i() const
+    {
+      return i_;
+    }
+
+  private:
+    int i_;
+  };
+}
+
+TESTCASE(non_default_constructor)
+{
+  Data_Type<Non_Default_Constructible> rb_cNon_Default_Constructible(
+      anonymous_class());
+  rb_cNon_Default_Constructible
+    .define_constructor(Constructor<Non_Default_Constructible, int>());
+  Data_Object<Non_Default_Constructible> o =
+    rb_cNon_Default_Constructible.call("new", 42);
+  ASSERT_EQUAL(rb_cNon_Default_Constructible, o.class_of());
+  ASSERT_EQUAL(42, o->i());
+}
+/*
+namespace {
+
+  class AbstractClass
+  {
+    public:
+
+    int doSomething()
+    {
+      return doSomethingImpl();
+    }
+
+    int doSomethingParam(int a, int b)
+    {
+      return doSomethingParamImpl(a, b);
+    }
+
+    virtual int doSomethingImpl() = 0;
+
+    virtual int doSomethingParamImpl(int a, int b) = 0;
+  };
+
+  class Director : public AbstractClass
+  {
+    Rice::Object m_rbSelf;
+
+    public:
+      Director(Rice::Object self) : m_rbSelf(self) { }
+
+      virtual int doSomethingImpl() 
+      {
+        cout << endl << "In Impl, frame's last_func is " << rb_id2name(ruby_frame->last_func) << endl;
+        cout << endl << "In Impl, frame's orig_func is " << rb_id2name(ruby_frame->orig_func) << endl;
+        cout << endl << "In Impl, frame's last_class is " << Class(ruby_frame->last_class).name().str() << endl;
+
+        cout << endl << "In Impl, frame's prev's last_func is " << rb_id2name(ruby_frame->prev->last_func) << endl;
+        cout << endl << "In Impl, frame's prev's orig_func is " << rb_id2name(ruby_frame->prev->orig_func) << endl;
+
+        cout << endl << "We've got classname (frame) " << rb_obj_classname(ruby_frame->self) << " vs (self) " << rb_obj_classname(m_rbSelf.value()) << endl;
+        cout << endl << "We've got classname (frame prev) " << rb_obj_classname(ruby_frame->prev->self) << " vs (self) " << rb_obj_classname(m_rbSelf.value()) << endl;
+
+        // Need to get the Ruby callee, compare that to m_rbSelf, and 
+        // if they're equal, go UP the chain, otherwise go DOWN
+        if(ruby_frame->self == m_rbSelf.value()) { 
+          // As doSomethingImpl is pure virtual, we need to implement a default here so
+          // that super calls don't blow things up
+          return 100;
+        } else {
+          return from_ruby<int>( m_rbSelf.call("do_something_impl") );
+        }
+
+      }
+
+      virtual int doSomethingParamImpl(int a, int b) 
+      {
+        return from_ruby<int>( m_rbSelf.call("do_something_param_impl", a, b) );
+      }
+  };
+}
+
+TESTCASE(director_system_polymorphic_calls)
+{
+  Data_Type<AbstractClass> a = define_class<AbstractClass>("__AbstractClass__");
+
+  Data_Type<Director> d = define_class<Director, AbstractClass>("AbstractClass");
+  d.define_constructor(Constructor<Director, Rice::Object>());
+  d.define_method("do_something", &AbstractClass::doSomething);
+  d.define_method("do_something_impl", &Director::doSomethingImpl);
+
+  Module m = define_module("Testing");
+  m.instance_eval(
+    "class MyWorker < AbstractClass;"
+    "def do_something_impl; 8; end;"
+    "end"
+  );
+
+  Object result = m.instance_eval("worker = MyWorker.new; worker.do_something");
+
+  ASSERT_EQUAL(
+    8, from_ruby<int>(result.value())
+  );
+}
+
+TESTCASE(director_system_polymorphic_calls_with_parameters)
+{
+  Data_Type<AbstractClass> a = define_class<AbstractClass>("__AbstractClass__");
+
+  Data_Type<Director> d = define_class<Director, AbstractClass>("AbstractClass");
+  d.define_constructor(Constructor<Director, Rice::Object>());
+  d.define_method("do_something_param", &AbstractClass::doSomethingParam);
+  d.define_method("do_something_param_impl", &Director::doSomethingParamImpl);
+
+  Module m = define_module("Testing");
+  m.instance_eval(
+    "class MyWorker < AbstractClass;"
+    "def do_something_param_impl(a, b); a * b; end;"
+    "end"
+  );
+
+  Object result = m.instance_eval("worker = MyWorker.new; worker.do_something_param(2, 10)");
+
+  ASSERT_EQUAL(
+    20, from_ruby<int>(result.value())
+  );
+}
+
+TESTCASE(director_system_polymorphic_calls_very_deep)
+{
+  Data_Type<AbstractClass> a = define_class<AbstractClass>("__AbstractClass__");
+
+  Data_Type<Director> d = define_class<Director, AbstractClass>("AbstractClass");
+  d.define_constructor(Constructor<Director, Rice::Object>());
+  d.define_method("do_something", &AbstractClass::doSomething);
+  d.define_method("do_something_impl", &Director::doSomethingImpl);
+
+  Module m = define_module("Testing");
+  m.instance_eval(
+    "class MyWorker < AbstractClass;"
+    "def do_something_impl; 4; end;"
+    "end;"
+    "class MyWorker2 < MyWorker;"
+    "def do_something_impl; 6; end;"
+    "end;"
+    "class MyWorker3 < MyWorker2;"
+    "def do_something_impl; 8; end;"
+    "end;"
+    "class MyWorker4 < MyWorker3;"
+    "def do_something_impl; 10; end;"
+    "end;"
+  );
+
+  Object result = m.instance_eval("worker = MyWorker4.new; worker.do_something");
+
+  ASSERT_EQUAL(
+    10, from_ruby<int>(result.value())
+  );
+}
+
+TESTCASE(director_system_super_calls_dont_infinite_loop) 
+{
+  Data_Type<AbstractClass> a = define_class<AbstractClass>("__AbstractClass__");
+
+  Data_Type<Director> d = define_class<Director, AbstractClass>("AbstractClass");
+  d.define_constructor(Constructor<Director, Rice::Object>());
+  d.define_method("do_something", &AbstractClass::doSomething);
+  d.define_method("do_something_impl", &Director::doSomethingImpl);
+
+  Module m = define_module("Testing");
+  m.instance_eval(
+    "class MyWorker < AbstractClass;"
+    "@@call_count = 0;"
+    "def do_something_impl;"
+    "@@call_count += 1;"
+    "if @@call_count == 1; super; else; -1; end;"
+    "end; end;"
+  );
+
+  Object result = m.instance_eval("worker = MyWorker.new; worker.do_something");
+
+  // -1 means that the do_something_impl got called twice, aka we were in an infinite loop
+  // had the class var check not been there
+  ASSERT_NOT_EQUAL(
+    -1,
+    from_ruby<int>(result.value())
+  );
+
+  ASSERT_EQUAL(
+    100,
+    from_ruby<int>(result.value())
+  );
+}
+*/

data/test/test_Critical_Guard.cpp

@@ -0,0 +1,51 @@
+#include "unittest.hpp"
+#include "rice/Critical_Guard.hpp"
+#include <stdexcept>
+
+#if RICE__RUBY_VERSION_CODE < 190
+
+using namespace Rice;
+
+TESTSUITE(Critical_Guard);
+
+SETUP(Critical_Guard)
+{
+  ruby_init();
+}
+
+TESTCASE(normal_path)
+{
+  rb_thread_critical = 1;
+  {
+    Critical_Guard g;
+    ASSERT(rb_thread_critical);
+  }
+  ASSERT(!rb_thread_critical);
+}
+
+TESTCASE(unset_thread_critical_on_destruction)
+{
+  rb_thread_critical = 1;
+  {
+    Critical_Guard g;
+    ASSERT(rb_thread_critical);
+  }
+  ASSERT(!rb_thread_critical);
+}
+
+TESTCASE(exception)
+{
+  rb_thread_critical = 1;
+  try
+  {
+    Critical_Guard g;
+    throw std::runtime_error("testing");
+  }
+  catch(...)
+  {
+  }
+  ASSERT(!rb_thread_critical);
+}
+
+#endif
+

data/test/test_Data_Object.cpp

@@ -0,0 +1,275 @@
+#include "unittest.hpp"
+#include "rice/Data_Object.hpp"
+#include "rice/Data_Type.hpp"
+#include "rice/Exception.hpp"
+
+using namespace Rice;
+
+TESTSUITE(Data_Object);
+
+namespace
+{
+  struct Foo { Foo() : x_(42) { } int x_; };
+
+  bool test_ruby_mark__marked = false;
+}
+
+template<>
+void ruby_mark(Foo * foo)
+{
+  test_ruby_mark__marked = true;
+}
+
+SETUP(Data_Object)
+{
+  ruby_init();
+
+  if(!Data_Type<Foo>::is_bound())
+  {
+    Class object(rb_cObject);
+    if(object.const_defined("Foo"))
+    {
+      object.remove_const("Foo");
+    }
+
+    define_class<Foo>("Foo");
+  }
+}
+
+TESTCASE(construct_from_pointer_with_defaults)
+{
+  Data_Type<Foo> rb_cFoo;
+  Foo * foo = new Foo;
+  Data_Object<Foo> wrapped_foo(foo);
+  ASSERT_EQUAL(foo, wrapped_foo.get());
+  ASSERT_EQUAL(Data_Type<Foo>::klass(), wrapped_foo.class_of());
+  typedef void (*Mark_Func)(void *);
+  typedef void (*Mark_Func_Foo)(Foo *);
+  Mark_Func expected_mark_func =
+    Mark_Func(Mark_Func_Foo(ruby_mark<Foo>));
+  ASSERT_EQUAL(
+      expected_mark_func,
+      RDATA(wrapped_foo.value())->dmark);
+  ASSERT_EQUAL(
+      RUBY_DATA_FUNC(Default_Allocation_Strategy<Foo>::free),
+      RUBY_DATA_FUNC(RDATA(wrapped_foo.value())->dfree));
+  ASSERT_EQUAL(foo, DATA_PTR(wrapped_foo.value()));
+}
+
+TESTCASE(construct_from_pointer_and_klass)
+{
+  Data_Type<Foo> rb_cFoo;
+  Foo * foo = new Foo;
+  Data_Object<Foo> wrapped_foo(foo, Data_Type<Foo>::klass());
+  ASSERT_EQUAL(foo, wrapped_foo.get());
+  ASSERT_EQUAL(Data_Type<Foo>::klass(), wrapped_foo.class_of());
+  typedef void (*Mark_Func)(void *);
+  typedef void (*Mark_Func_Foo)(Foo *);
+  Mark_Func expected_mark_func =
+    Mark_Func(Mark_Func_Foo(ruby_mark<Foo>));
+  ASSERT_EQUAL(
+      expected_mark_func,
+      RDATA(wrapped_foo.value())->dmark);
+  ASSERT_EQUAL(
+      RUBY_DATA_FUNC(Default_Allocation_Strategy<Foo>::free),
+      RUBY_DATA_FUNC(RDATA(wrapped_foo.value())->dfree));
+  ASSERT_EQUAL(foo, DATA_PTR(wrapped_foo.value()));
+}
+
+TESTCASE(construct_from_pointer_and_alternate_klass)
+{
+  Data_Type<Foo> rb_cFoo;
+  Foo * foo = new Foo;
+  Data_Object<Foo> wrapped_foo(foo, rb_cObject);
+  ASSERT_EQUAL(foo, wrapped_foo.get());
+  ASSERT_EQUAL(rb_cObject, CLASS_OF(wrapped_foo.value()));
+  typedef void (*Mark_Func)(void *);
+  typedef void (*Mark_Func_Foo)(Foo *);
+  Mark_Func expected_mark_func =
+    Mark_Func(Mark_Func_Foo(ruby_mark<Foo>));
+  ASSERT_EQUAL(
+      expected_mark_func,
+      RDATA(wrapped_foo.value())->dmark);
+  ASSERT_EQUAL(
+      RUBY_DATA_FUNC(Default_Allocation_Strategy<Foo>::free),
+      RUBY_DATA_FUNC(RDATA(wrapped_foo.value())->dfree));
+  ASSERT_EQUAL(foo, DATA_PTR(wrapped_foo.value()));
+}
+
+namespace
+{
+  void dummy_mark(Foo *)
+  {
+  }
+}
+
+TESTCASE(construct_from_pointer_and_klass_and_mark_function)
+{
+  Data_Type<Foo> rb_cFoo;
+  Foo * foo = new Foo;
+  Data_Object<Foo> wrapped_foo(foo, rb_cFoo, dummy_mark);
+  ASSERT_EQUAL(foo, wrapped_foo.get());
+  ASSERT_EQUAL(Data_Type<Foo>::klass(), wrapped_foo.class_of());
+  ASSERT_EQUAL((void *)dummy_mark, RDATA(wrapped_foo.value())->dmark);
+  ASSERT_EQUAL(
+      RUBY_DATA_FUNC(Default_Allocation_Strategy<Foo>::free),
+      RUBY_DATA_FUNC(RDATA(wrapped_foo.value())->dfree));
+  ASSERT_EQUAL(foo, DATA_PTR(wrapped_foo.value()));
+}
+
+namespace
+{
+  void my_free(Foo * f)
+  {
+    delete f;
+  }
+}
+
+TESTCASE(construct_from_pointer_and_klass_and_mark_and_free)
+{
+  Data_Type<Foo> rb_cFoo;
+  Foo * foo = new Foo;
+  Data_Object<Foo> wrapped_foo(foo, rb_cFoo, dummy_mark, my_free);
+  ASSERT_EQUAL(foo, wrapped_foo.get());
+  ASSERT_EQUAL(Data_Type<Foo>::klass(), wrapped_foo.class_of());
+  ASSERT_EQUAL((void *)dummy_mark, RDATA(wrapped_foo.value())->dmark);
+  ASSERT_EQUAL(
+      RUBY_DATA_FUNC(my_free),
+      RUBY_DATA_FUNC(RDATA(wrapped_foo.value())->dfree));
+  ASSERT_EQUAL(foo, DATA_PTR(wrapped_foo.value()));
+}
+
+TESTCASE(construct_from_ruby_object)
+{
+  Foo * foo = new Foo;
+  VALUE wrapped_foo = Data_Wrap_Struct(Data_Type<Foo>::klass(), 0, Default_Allocation_Strategy<Foo>::free, foo);
+  Data_Object<Foo> data_object_foo(wrapped_foo);
+  ASSERT_EQUAL(foo, data_object_foo.get());
+  ASSERT_EQUAL(Data_Type<Foo>::klass(), data_object_foo.class_of());
+  ASSERT_EQUAL(RDATA(wrapped_foo), RDATA(data_object_foo.value()));
+  ASSERT_EQUAL(RUBY_DATA_FUNC(0), RDATA(data_object_foo.value())->dmark);
+  ASSERT_EQUAL(
+      RUBY_DATA_FUNC(Default_Allocation_Strategy<Foo>::free),
+      RUBY_DATA_FUNC(RDATA(data_object_foo.value())->dfree));
+  ASSERT_EQUAL(foo, DATA_PTR(data_object_foo.value()));
+}
+
+TESTCASE(construct_from_ruby_object_and_class)
+{
+  Data_Type<Foo> rb_cFoo;
+  Foo * foo = new Foo;
+  VALUE wrapped_foo = Data_Wrap_Struct(Data_Type<Foo>::klass(), 0, Default_Allocation_Strategy<Foo>::free, foo);
+  Data_Object<Foo> data_object_foo(wrapped_foo, rb_cFoo);
+  ASSERT_EQUAL(foo, data_object_foo.get());
+  ASSERT_EQUAL(Data_Type<Foo>::klass(), data_object_foo.class_of());
+  ASSERT_EQUAL(RDATA(wrapped_foo), RDATA(data_object_foo.value()));
+  ASSERT_EQUAL(RUBY_DATA_FUNC(0), RDATA(data_object_foo.value())->dmark);
+  ASSERT_EQUAL(
+      RUBY_DATA_FUNC(Default_Allocation_Strategy<Foo>::free),
+      RUBY_DATA_FUNC(RDATA(data_object_foo.value())->dfree));
+  ASSERT_EQUAL(foo, DATA_PTR(data_object_foo.value()));
+}
+
+TESTCASE(construct_from_ruby_object_and_wrong_class)
+{
+  Foo * foo = new Foo;
+  Data_Type<Foo> rb_cFoo;
+  VALUE wrapped_foo = Data_Wrap_Struct(rb_cObject, 0, Default_Allocation_Strategy<Foo>::free, foo);
+  ASSERT_EXCEPTION_CHECK(
+      Exception,
+      Data_Object<Foo> data_object_foo(wrapped_foo, rb_cFoo),
+      ASSERT_EQUAL(
+          Object(rb_eTypeError),
+          Object(CLASS_OF(ex.value()))
+          )
+      );
+}
+
+TESTCASE(copy_construct)
+{
+  Data_Type<Foo> rb_cFoo;
+  Foo * foo = new Foo;
+  VALUE wrapped_foo = Data_Wrap_Struct(Data_Type<Foo>::klass(), 0, Default_Allocation_Strategy<Foo>::free, foo);
+  Data_Object<Foo> orig_data_object_foo(wrapped_foo, rb_cFoo);
+  Data_Object<Foo> data_object_foo(orig_data_object_foo);
+  ASSERT_EQUAL(foo, data_object_foo.get());
+  ASSERT_EQUAL(Data_Type<Foo>::klass(), data_object_foo.class_of());
+  ASSERT_EQUAL(RDATA(wrapped_foo), RDATA(data_object_foo.value()));
+  ASSERT_EQUAL(RUBY_DATA_FUNC(0), RDATA(data_object_foo.value())->dmark);
+  ASSERT_EQUAL(
+      RUBY_DATA_FUNC(Default_Allocation_Strategy<Foo>::free),
+      RUBY_DATA_FUNC(RDATA(data_object_foo.value())->dfree));
+  ASSERT_EQUAL(foo, DATA_PTR(data_object_foo.value()));
+}
+
+TESTCASE(dereference)
+{
+  Data_Type<Foo> rb_cFoo;
+  Foo * foo = new Foo;
+  Data_Object<Foo> wrapped_foo(foo);
+  ASSERT_EQUAL(foo, &*wrapped_foo);
+}
+
+TESTCASE(arrow)
+{
+  Data_Type<Foo> rb_cFoo;
+  Foo * foo = new Foo;
+  Data_Object<Foo> wrapped_foo(foo);
+  ASSERT_EQUAL(42, foo->x_);
+}
+
+TESTCASE(get)
+{
+  Data_Type<Foo> rb_cFoo;
+  Foo * foo = new Foo;
+  Data_Object<Foo> wrapped_foo(foo);
+  ASSERT_EQUAL(foo, wrapped_foo.get());
+}
+
+// TODO: swap
+
+TESTCASE(to_ruby)
+{
+  Data_Type<Foo> rb_cFoo;
+  Foo * foo = new Foo;
+  Data_Object<Foo> wrapped_foo(foo);
+  ASSERT_EQUAL(wrapped_foo.value(), to_ruby(wrapped_foo).value());
+}
+
+TESTCASE(from_ruby)
+{
+  Data_Type<Foo> rb_cFoo;
+  Foo * foo = new Foo;
+  Data_Object<Foo> wrapped_foo(foo);
+  ASSERT_EQUAL(foo, from_ruby<Foo *>(wrapped_foo));
+}
+
+TESTCASE(from_ruby_const_ref)
+{
+  Data_Type<Foo> rb_cFoo;
+  Foo * foo = new Foo;
+  Data_Object<Foo> wrapped_foo(foo);
+  ASSERT_EQUAL(foo->x_, from_ruby<Foo const &>(wrapped_foo).x_);
+}
+
+TESTCASE(from_ruby_copy)
+{
+  Data_Type<Foo> rb_cFoo;
+  Foo * foo = new Foo;
+  Data_Object<Foo> wrapped_foo(foo);
+  ASSERT_EQUAL(foo->x_, from_ruby<Foo>(wrapped_foo).x_);
+}
+
+TESTCASE(ruby_mark)
+{
+  Data_Type<Foo> rb_cFoo;
+  Foo * foo = new Foo;
+  Data_Object<Foo> wrapped_foo(foo);
+
+  test_ruby_mark__marked = false;
+
+  rb_gc_start();
+
+  ASSERT_EQUAL(true, test_ruby_mark__marked);
+}
+