rice 1.0.0

data/test/test_Constructor.cpp

@@ -0,0 +1,30 @@
+#include "unittest.hpp"
+#include "rice/Constructor.hpp"
+#include "rice/Data_Type.hpp"
+#include "rice/Constructor.hpp"
+
+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());
+}
+

data/test/test_Critical_Guard.cpp

@@ -0,0 +1,47 @@
+#include "unittest.hpp"
+#include "rice/Critical_Guard.hpp"
+#include <stdexcept>
+
+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);
+}
+

data/test/test_Data_Object.cpp

@@ -0,0 +1,235 @@
+#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_; };
+}
+
+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());
+  ASSERT_EQUAL(RUBY_DATA_FUNC(0), 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());
+  ASSERT_EQUAL(RUBY_DATA_FUNC(0), 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()));
+  ASSERT_EQUAL(RUBY_DATA_FUNC(0), 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_);
+}

data/test/test_Enum.cpp

@@ -0,0 +1,162 @@
+#include "unittest.hpp"
+#include "rice/Enum.hpp"
+#include "rice/Array.hpp"
+#include "rice/String.hpp"
+#include <iostream>
+
+using namespace Rice;
+
+TESTSUITE(Enum);
+
+namespace
+{
+  enum Color { RED, BLACK, GREEN };
+
+  Enum<Color> define_color_enum()
+  {
+    static Enum<Color> colors = define_enum<Color>("Color")
+      .define_value("RED", RED)
+      .define_value("BLACK", BLACK)
+      .define_value("GREEN", GREEN);
+    return colors;
+  }
+}
+
+SETUP(Enum)
+{
+  ruby_init();
+}
+
+TESTCASE(copy_construct)
+{
+  Enum<Color> rb_cColor(define_color_enum());
+  ASSERT_EQUAL(define_color_enum().value(), rb_cColor.value());
+}
+
+TESTCASE(assignment)
+{
+  Enum<Color> rb_cColor;
+  rb_cColor = define_color_enum();
+  ASSERT_EQUAL(define_color_enum().value(), rb_cColor.value());
+}
+
+TESTCASE(each)
+{
+  Enum<Color> rb_cColor = define_color_enum();
+  Array a = protect(rb_eval_string, "a = []; Color.each { |x| a << x }; a");
+  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]));
+}
+
+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")));
+}
+
+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")));
+}
+
+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")));
+}
+
+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")));
+}
+
+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")));
+}
+
+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());
+}
+
+TESTCASE(invalid_to_i)
+{
+  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"));
+}
+
+TESTCASE(invalid_inspect)
+{
+  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());
+}
+
+TESTCASE(invalid_compare)
+{
+  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));
+}
+
+TESTCASE(invalid_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);
+}
+
+TESTCASE(different_objects_compare)
+{
+  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));
+}
+
+TESTCASE(different_objects_eql)
+{
+  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);
+}
+
+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)
+{
+  Enum<Color> rb_cColor = define_color_enum();
+  Data_Object<Color> color(rb_cColor.call("from_int", int(RED)));
+  ASSERT_EQUAL(RED, *color);
+}
+