rice-jdguyot 1.4.0.p1

data/test/test_Constructor.cpp

@@ -0,0 +1,128 @@
+#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
+{
+  int withArgsX;
+  float withArgsY;
+  bool withArgsYes;
+
+  class WithDefaultArgs
+  {
+    public:
+      WithDefaultArgs(int x, float y = 2.0, bool yes = false)
+      {
+        withArgsX = x;
+        withArgsY = y;
+        withArgsYes = yes;
+      }
+  };
+
+  int withArgX;
+  class WithOneArg
+  {
+    public:
+      WithOneArg(int x = 14) {
+        withArgX = x;
+      }
+  };
+}
+
+TESTCASE(constructor_supports_default_arguments)
+{
+  Class klass = define_class<WithDefaultArgs>("WithDefaultArgs").
+    define_constructor(Constructor<WithDefaultArgs, int, float, bool>(),
+          ( Arg("x"), Arg("y") = (float)2.0, Arg("yes") = (bool)false ));
+
+  klass.call("new", 4);
+  ASSERT_EQUAL(4, withArgsX);
+  ASSERT_EQUAL(2.0, withArgsY);
+  ASSERT_EQUAL(false, withArgsYes);
+
+  klass.call("new", 5, 3.0);
+  ASSERT_EQUAL(5, withArgsX);
+  ASSERT_EQUAL(3.0, withArgsY);
+  ASSERT_EQUAL(false, withArgsYes);
+
+  klass.call("new", 7, 12.0, true);
+  ASSERT_EQUAL(7, withArgsX);
+  ASSERT_EQUAL(12.0, withArgsY);
+  ASSERT_EQUAL(true, withArgsYes);
+}
+
+TESTCASE(constructor_supports_single_default_argument)
+{
+  Class klass = define_class<WithOneArg>("WithOneArg").
+    define_constructor(Constructor<WithOneArg, int>(),
+          ( Arg("x") = 14 ));
+
+  klass.call("new");
+  ASSERT_EQUAL(14, withArgX);
+
+  klass.call("new", 6);
+  ASSERT_EQUAL(6, withArgX);
+}

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);
+}
+