rice 1.0.0

data/test/test_Address_Registration_Guard.cpp

@@ -0,0 +1,43 @@
+#include "unittest.hpp"
+#include "rice/Address_Registration_Guard.hpp"
+
+using namespace Rice;
+
+TESTSUITE(Address_Registration_Guard);
+
+SETUP(Address_Registration_Guard)
+{
+  ruby_init();
+}
+
+TESTCASE(register_address)
+{
+  VALUE v = Qnil;
+  Address_Registration_Guard g(&v);
+}
+
+TESTCASE(register_object)
+{
+  Object o;
+  Address_Registration_Guard g(&o);
+}
+
+TESTCASE(get_address)
+{
+  VALUE v = Qnil;
+  Address_Registration_Guard g(&v);
+  ASSERT_EQUAL(&v, g.address());
+}
+
+TESTCASE(swap)
+{
+  VALUE v = Qnil;
+  VALUE v2 = Qnil;
+  Address_Registration_Guard g(&v);
+  Address_Registration_Guard g2(&v2);
+  g.swap(g2);
+  ASSERT_EQUAL(&v, g2.address());
+  ASSERT_EQUAL(&v2, g.address());
+  // TODO: ensure addresses are still registered
+}
+

data/test/test_Allocation_Strategies.cpp

@@ -0,0 +1,77 @@
+#include "unittest.hpp"
+#include "rice/Allocation_Strategies.hpp"
+
+using namespace Rice;
+
+namespace
+{
+
+bool constructor_called = false;
+bool destructor_called = false;
+
+class Foo
+{
+public:
+  Foo()
+  {
+    constructor_called = true;
+  }
+
+  ~Foo()
+  {
+    destructor_called = true;
+  }
+};
+
+} // namespace
+
+TESTSUITE(Allocation_Strategies);
+
+SETUP(Allocation_Strategies)
+{
+  ruby_init();
+  constructor_called = false;
+  destructor_called = false;
+}
+
+TESTCASE(default_allocation_strategy_allocate)
+{
+  Foo * t = Default_Allocation_Strategy<Foo>::allocate();
+  ASSERT(constructor_called);
+  ASSERT(!destructor_called);
+  delete t;
+  ASSERT(constructor_called);
+  ASSERT(destructor_called);
+}
+
+TESTCASE(default_allocation_strategy_free)
+{
+  Foo * t = new Foo;
+  ASSERT(constructor_called);
+  ASSERT(!destructor_called);
+  Default_Allocation_Strategy<Foo>::free(t);
+  ASSERT(constructor_called);
+  ASSERT(destructor_called);
+}
+
+TESTCASE(xmalloc_allocation_strategy_allocate)
+{
+  Foo * t = Xmalloc_Allocation_Strategy<Foo>::allocate();
+  ASSERT(constructor_called);
+  ASSERT(!destructor_called);
+  t->~Foo();
+  xfree(t);
+  ASSERT(constructor_called);
+  ASSERT(destructor_called);
+}
+
+TESTCASE(xmalloc_allocation_strategy_free)
+{
+  Foo * t = new Foo;
+  ASSERT(constructor_called);
+  ASSERT(!destructor_called);
+  Xmalloc_Allocation_Strategy<Foo>::free(t);
+  ASSERT(constructor_called);
+  ASSERT(destructor_called);
+}
+

data/test/test_Array.cpp

@@ -0,0 +1,241 @@
+#include "unittest.hpp"
+#include "rice/Array.hpp"
+#include "rice/String.hpp"
+
+using namespace Rice;
+
+TESTSUITE(Array);
+
+SETUP(Array)
+{
+  ruby_init();
+}
+
+TESTCASE(default_construct)
+{
+  Array a;
+  ASSERT_EQUAL(T_ARRAY, rb_type(a));
+  ASSERT_EQUAL(0, RARRAY(a.value())->len);
+}
+
+TESTCASE(construct_from_vector_of_int)
+{
+  std::vector<int> v;
+  v.push_back(10);
+  v.push_back(6);
+  v.push_back(42);
+  Array a(v.begin(), v.end());
+  ASSERT_EQUAL(3u, a.size());
+  ASSERT_EQUAL(to_ruby(10), a[0]);
+  ASSERT_EQUAL(to_ruby(6), a[1]);
+  ASSERT_EQUAL(to_ruby(42), a[2]);
+}
+
+TESTCASE(construct_from_c_array)
+{
+  int arr[] = { 10, 6, 42 };
+  Array a(arr);
+  ASSERT_EQUAL(3u, a.size());
+  ASSERT_EQUAL(to_ruby(10), a[0]);
+  ASSERT_EQUAL(to_ruby(6), a[1]);
+  ASSERT_EQUAL(to_ruby(42), a[2]);
+}
+
+
+TESTCASE(push_no_items)
+{
+  Array a;
+  ASSERT_EQUAL(0u, a.size());
+}
+
+TESTCASE(push_one_item)
+{
+  Array a;
+  a.push(Rice::True);
+  ASSERT_EQUAL(1u, a.size());
+  ASSERT_EQUAL(Qtrue, a[0]);
+}
+
+TESTCASE(push_two_items)
+{
+  Array a;
+  a.push(to_ruby(42));
+  a.push(to_ruby(43));
+  ASSERT_EQUAL(2u, a.size());
+  ASSERT_EQUAL(42, from_ruby<int>(a[0]));
+  ASSERT_EQUAL(43, from_ruby<int>(a[1]));
+}
+
+TESTCASE(push_three_items)
+{
+  Array a;
+  a.push(to_ruby(42));
+  a.push(to_ruby(43));
+  a.push(to_ruby(44));
+  ASSERT_EQUAL(3u, a.size());
+  ASSERT_EQUAL(42, from_ruby<int>(a[0]));
+  ASSERT_EQUAL(43, from_ruby<int>(a[1]));
+  ASSERT_EQUAL(44, from_ruby<int>(a[2]));
+}
+
+TESTCASE(push_int)
+{
+  Array a;
+  a.push(42);
+  ASSERT_EQUAL(1u, a.size());
+  ASSERT_EQUAL(to_ruby(42), a[0]);
+}
+
+TESTCASE(bracket_equals)
+{
+  Array a;
+  a.push(to_ruby(42));
+  a.push(to_ruby(43));
+  a.push(to_ruby(44));
+  a[1] = to_ruby(10);
+  ASSERT_EQUAL(10, from_ruby<int>(a[1]));
+}
+
+TESTCASE(to_s)
+{
+  Array a;
+  a.push(to_ruby(42));
+  a.push(to_ruby(43));
+  a.push(to_ruby(44));
+  String s1(a.call("to_s"));
+  String s2(a.to_s());
+  ASSERT_EQUAL(s1.str(), s2.str());
+}
+
+TESTCASE(pop)
+{
+  Array a;
+  a.push(to_ruby(42));
+  a.push(to_ruby(43));
+  a.push(to_ruby(44));
+  VALUE result = a.pop();
+  ASSERT_EQUAL(2u, a.size());
+  ASSERT_EQUAL(42, from_ruby<int>(a[0]));
+  ASSERT_EQUAL(43, from_ruby<int>(a[1]));
+  ASSERT_EQUAL(44, from_ruby<int>(result));
+}
+
+TESTCASE(unshift)
+{
+  Array a;
+  a.push(to_ruby(42));
+  a.push(to_ruby(43));
+  a.push(to_ruby(44));
+  a.unshift(to_ruby(10));
+  ASSERT_EQUAL(4u, a.size());
+  ASSERT_EQUAL(10, from_ruby<int>(a[0]));
+  ASSERT_EQUAL(42, from_ruby<int>(a[1]));
+  ASSERT_EQUAL(43, from_ruby<int>(a[2]));
+  ASSERT_EQUAL(44, from_ruby<int>(a[3]));
+}
+
+TESTCASE(unshift_int)
+{
+  Array a;
+  a.unshift(42);
+  ASSERT_EQUAL(1u, a.size());
+  ASSERT_EQUAL(to_ruby(42), a[0]);
+}
+
+TESTCASE(shift)
+{
+  Array a;
+  a.push(to_ruby(42));
+  a.push(to_ruby(43));
+  a.push(to_ruby(44));
+  VALUE result = a.shift();
+  ASSERT_EQUAL(2u, a.size());
+  ASSERT_EQUAL(42, from_ruby<int>(result));
+  ASSERT_EQUAL(43, from_ruby<int>(a[0]));
+  ASSERT_EQUAL(44, from_ruby<int>(a[1]));
+}
+
+TESTCASE(to_c_array)
+{
+  Array a;
+  ASSERT_EQUAL(RARRAY(a.value())->ptr, a.to_c_array());
+}
+
+TESTCASE(iterate)
+{
+  Array a;
+  a.push(to_ruby(42));
+  a.push(to_ruby(43));
+  a.push(to_ruby(44));
+  int ca[] = { 42, 43, 44 };
+  Array::iterator it = a.begin();
+  Array::iterator end = a.end();
+  for(int j = 0; it != end; ++j, ++it)
+  {
+    ASSERT_EQUAL(ca[j], from_ruby<int>(*it));
+  }
+}
+
+TESTCASE(const_iterate)
+{
+  Array a;
+  a.push(to_ruby(42));
+  a.push(to_ruby(43));
+  a.push(to_ruby(44));
+  int ca[] = { 42, 43, 44 };
+  Array::const_iterator it = a.begin();
+  Array::const_iterator end = a.end();
+  for(int j = 0; it != end; ++j, ++it)
+  {
+    ASSERT_EQUAL(ca[j], from_ruby<int>(*it));
+  }
+}
+
+TESTCASE(iterate_and_change)
+{
+  Array a;
+  a.push(to_ruby(42));
+  a.push(to_ruby(43));
+  a.push(to_ruby(44));
+  Array::iterator it = a.begin();
+  Array::iterator end = a.end();
+  for(int j = 0; it != end; ++j, ++it)
+  {
+    int value = from_ruby<int>(*it);
+    *it = to_ruby(value + j);
+  }
+  ASSERT_EQUAL(42, from_ruby<int>(a[0]));
+  ASSERT_EQUAL(44, from_ruby<int>(a[1]));
+  ASSERT_EQUAL(46, from_ruby<int>(a[2]));
+}
+
+TESTCASE(iterate_and_call_member)
+{
+  Array a;
+  a.push(to_ruby(42));
+  a.push(to_ruby(43));
+  a.push(to_ruby(44));
+  Array::iterator it = a.begin();
+  Array::iterator end = a.end();
+  std::vector<Object> v;
+  for(int j = 0; it != end; ++j, ++it)
+  {
+    v.push_back(it->to_s());
+  }
+  ASSERT_EQUAL(42, from_ruby<int>(a[0]));
+  ASSERT_EQUAL(43, from_ruby<int>(a[1]));
+  ASSERT_EQUAL(44, from_ruby<int>(a[2]));
+  ASSERT_EQUAL(3u, v.size());
+  ASSERT_EQUAL(Object(a[0]).to_s(), v[0]);
+  ASSERT_EQUAL(Object(a[1]).to_s(), v[1]);
+  ASSERT_EQUAL(Object(a[2]).to_s(), v[2]);
+}
+
+TESTCASE(assign_int)
+{
+  Array a;
+  a.push(42);
+  a[0] = 10;
+  ASSERT_EQUAL(10, from_ruby<int>(a[0]));
+}
+

data/test/test_Builtin_Object.cpp

@@ -0,0 +1,72 @@
+#include "unittest.hpp"
+#include "rice/Builtin_Object.hpp"
+#include "rice/Class.hpp"
+
+using namespace Rice;
+
+TESTSUITE(Builtin_Object);
+
+SETUP(Builtin_Object)
+{
+  ruby_init();
+}
+
+TESTCASE(construct_with_object)
+{
+  Class c(rb_cObject);
+  Object o(c.call("new"));
+  Builtin_Object<RObject, T_OBJECT> b(o);
+  ASSERT_EQUAL(o.value(), b.value());
+  ASSERT_EQUAL(T_OBJECT, rb_type(b.value()));
+  ASSERT_EQUAL(rb_cObject, b.class_of().value());
+  ASSERT_EQUAL(rb_cObject, CLASS_OF(b.value()));
+}
+
+TESTCASE(copy_construct)
+{
+  Class c(rb_cObject);
+  Object o(c.call("new"));
+  Builtin_Object<RObject, T_OBJECT> b(o);
+  Builtin_Object<RObject, T_OBJECT> b2(b);
+  ASSERT_EQUAL(o.value(), b2.value());
+  ASSERT_EQUAL(T_OBJECT, rb_type(b2.value()));
+  ASSERT_EQUAL(rb_cObject, b2.class_of().value());
+  ASSERT_EQUAL(rb_cObject, CLASS_OF(b2.value()));
+}
+
+TESTCASE(dereference)
+{
+  Class c(rb_cObject);
+  Object o(c.call("new"));
+  Builtin_Object<RObject, T_OBJECT> b(o);
+  ASSERT_EQUAL(ROBJECT(o.value()), &*b);
+}
+
+TESTCASE(arrow)
+{
+  Class c(rb_cObject);
+  Object o(c.call("new"));
+  Builtin_Object<RObject, T_OBJECT> b(o);
+  ASSERT_EQUAL(rb_cObject, b->basic.klass);
+}
+
+TESTCASE(get)
+{
+  Class c(rb_cObject);
+  Object o(c.call("new"));
+  Builtin_Object<RObject, T_OBJECT> b(o);
+  ASSERT_EQUAL(ROBJECT(o.value()), b.get());
+}
+
+TESTCASE(swap)
+{
+  Class c(rb_cObject);
+  Object o1(c.call("new"));
+  Builtin_Object<RObject, T_OBJECT> b1(o1);
+  Object o2(c.call("new"));
+  Builtin_Object<RObject, T_OBJECT> b2(o2);
+  b1.swap(b2);
+  ASSERT_EQUAL(b1.value(), o2.value());
+  ASSERT_EQUAL(b2.value(), o1.value());
+}
+

data/test/test_Class.cpp

@@ -0,0 +1,350 @@
+#include "unittest.hpp"
+#include "rice/Class.hpp"
+#include "rice/protect.hpp"
+#include "rice/Exception.hpp"
+#include "rice/Array.hpp"
+#include "rice/String.hpp"
+#include "rice/Symbol.hpp"
+#include <iostream>
+
+using namespace Rice;
+
+TESTSUITE(Class);
+
+SETUP(Class)
+{
+  ruby_init();
+}
+
+TESTCASE(construct)
+{
+  Class c(rb_cObject);
+  ASSERT_EQUAL(rb_cObject, c.value());
+}
+
+TESTCASE(undef_creation_funcs)
+{
+  Class c(anonymous_class());
+  Class & c2(c.undef_creation_funcs());
+  ASSERT_EQUAL(&c, &c2);
+  ASSERT_EXCEPTION_CHECK(
+      Exception,
+      c.call("new"),
+      ASSERT_EQUAL(
+          Object(rb_eTypeError), // TODO: 1.6.x?
+          Object(CLASS_OF(ex.value()))
+          )
+      );
+}
+
+TESTCASE(include_module)
+{
+  Class c(anonymous_class());
+  Class & c2(c.include_module(rb_mEnumerable));
+  ASSERT_EQUAL(&c, &c2);
+  Array ancestors(c.ancestors());
+  Array expected_ancestors;
+  expected_ancestors.push(c);
+  expected_ancestors.push(Module(rb_mEnumerable));
+  expected_ancestors.push(Module(rb_cObject));
+  expected_ancestors.push(Module(rb_mKernel));
+  ASSERT_EQUAL(expected_ancestors, ancestors);
+}
+
+TESTCASE(const_set_get_by_id)
+{
+  Class c(anonymous_class());
+  Object v = to_ruby(42);
+  Class & c2(c.const_set(rb_intern("FOO"), v));
+  ASSERT_EQUAL(&c, &c2);
+  ASSERT_EQUAL(v, c.const_get(rb_intern("FOO")));
+}
+
+TESTCASE(const_set_get_by_identifier)
+{
+  Class c(anonymous_class());
+  Object v = to_ruby(42);
+  Class & c2(c.const_set(Identifier("FOO"), v));
+  ASSERT_EQUAL(&c, &c2);
+  ASSERT_EQUAL(v, c.const_get(Identifier("FOO")));
+}
+
+TESTCASE(const_set_get_by_string)
+{
+  Class c(anonymous_class());
+  Object v = to_ruby(42);
+  Class & c2(c.const_set("FOO", v));
+  ASSERT_EQUAL(&c, &c2);
+  ASSERT_EQUAL(v, c.const_get("FOO"));
+}
+
+namespace
+{
+
+bool define_method_simple_ok;
+
+void define_method_simple_helper(Object o)
+{
+  define_method_simple_ok = true;
+}
+
+} // namespace
+
+TESTCASE(define_method_simple)
+{
+  Class c(anonymous_class());
+  c.define_method("foo", &define_method_simple_helper);
+  Object o = c.call("new");
+  define_method_simple_ok = false;
+  o.call("foo");
+  ASSERT(define_method_simple_ok);
+}
+
+TESTCASE(define_singleton_method_simple)
+{
+  Class c(anonymous_class());
+  c.define_singleton_method("foo", &define_method_simple_helper);
+  define_method_simple_ok = false;
+  Object o = c.call("foo");
+  ASSERT(define_method_simple_ok);
+}
+
+TESTCASE(define_module_function_simple)
+{
+  // module_function only works with Module, not Class
+  Class c(anonymous_class());
+  ASSERT_EXCEPTION_CHECK(
+      Exception,
+      c.define_module_function("foo", &define_method_simple_helper),
+      ASSERT_EQUAL(
+          Object(rb_eNoMethodError), // TODO: 1.6.x?
+          Object(CLASS_OF(ex.value()))
+          )
+      );
+}
+
+namespace
+{
+
+int define_method_int_result;
+
+void define_method_int_helper(Object o, int i)
+{
+  define_method_int_result = i;
+}
+
+} // namespace
+
+TESTCASE(define_method_int)
+{
+  Class c(anonymous_class());
+  c.define_method("foo", &define_method_int_helper);
+  Object o = c.call("new");
+  define_method_int_result = 0;
+  o.call("foo", 42);
+  ASSERT_EQUAL(42, define_method_int_result);
+}
+
+TESTCASE(define_method_int_passed_two_args)
+{
+  Class c(anonymous_class());
+  c.define_method("foo", &define_method_int_helper);
+  Object o = c.call("new");
+  ASSERT_EXCEPTION_CHECK(
+      Exception,
+      o.call("foo", 1, 2),
+      ASSERT_EQUAL(
+          Object(rb_eArgError),
+          Object(CLASS_OF(ex.value()))
+          )
+      );
+}
+
+TESTCASE(define_method_int_passed_no_args)
+{
+  Class c(anonymous_class());
+  c.define_method("foo", &define_method_int_helper);
+  Object o = c.call("new");
+  ASSERT_EXCEPTION_CHECK(
+      Exception,
+      o.call("foo"),
+      ASSERT_EQUAL(
+          Object(rb_eArgError),
+          Object(CLASS_OF(ex.value()))
+          )
+      );
+}
+
+
+namespace
+{
+
+struct Foo
+{
+  int x;
+};
+
+int define_method_int_foo_result_i;
+Foo * define_method_int_foo_result_x;
+
+void define_method_int_foo_helper(Object o, int i, Foo * x)
+{
+  define_method_int_foo_result_i = i;
+  define_method_int_foo_result_x = x;
+}
+
+} // namespace
+
+template<>
+Foo * from_ruby<Foo *>(Object x)
+{
+  Foo * retval;
+  Data_Get_Struct(x.value(), Foo, retval);
+  return retval;
+}
+
+TESTCASE(define_method_int_foo)
+{
+  Class c(anonymous_class());
+  c.define_method("foo", &define_method_int_foo_helper);
+  Object o = c.call("new");
+  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);
+  o.call("foo", 42, Object(f));
+  ASSERT_EQUAL(42, define_method_int_foo_result_i);
+  ASSERT_EQUAL(foo, define_method_int_foo_result_x);
+}
+
+namespace
+{
+
+class Silly_Exception
+  : public std::exception
+{
+};
+
+void handle_silly_exception(Silly_Exception const & ex)
+{
+  throw Exception(rb_eRuntimeError, "SILLY");
+}
+
+void throw_silly_exception(Object self)
+{
+  throw Silly_Exception();
+}
+
+}
+
+TESTCASE(add_handler)
+{
+  Class c(rb_cObject);
+  c.add_handler<Silly_Exception>(handle_silly_exception);
+  c.define_method("foo", throw_silly_exception);
+  Object exc = protect(rb_eval_string, "begin; foo; rescue Exception; $!; end");
+  ASSERT_EQUAL(rb_eRuntimeError, CLASS_OF(exc));
+  Exception ex(exc);
+  ASSERT_EQUAL(String("SILLY"), String(ex.message()));
+}
+
+namespace
+{
+
+class Container
+{
+public:
+  Container(int * array, size_t length)
+    : array_(array)
+    , length_(length)
+  {
+  }
+
+  int * begin() { return array_; }
+  int * end() { return array_ + length_; }
+
+private:
+  int * array_;
+  size_t length_;
+};
+
+} // namespace
+
+template<>
+Container * from_ruby<Container *>(Object x)
+{
+  Container * retval;
+  Data_Get_Struct(x.value(), Container, retval);
+  return retval;
+}
+
+TESTCASE(define_iterator)
+{
+  int array[] = { 1, 2, 3 };
+  Class c(anonymous_class());
+  c.define_iterator(&Container::begin, &Container::end);
+  Container * container = new Container(array, 3);
+  Object wrapped_container = Data_Wrap_Struct(
+      c, 0, Default_Allocation_Strategy<Container>::free, container);
+  Array a = wrapped_container.instance_eval("a = []; each() { |x| a << x }; a");
+  ASSERT_EQUAL(3u, a.size());
+  ASSERT_EQUAL(to_ruby(1), Object(a[0]));
+  ASSERT_EQUAL(to_ruby(2), Object(a[1]));
+  ASSERT_EQUAL(to_ruby(3), Object(a[2]));
+}
+
+TESTCASE(define_class)
+{
+  Class object(rb_cObject);
+  if(object.const_defined("Foo"))
+  {
+    object.remove_const("Foo");
+  }
+
+  Class c = define_class("Foo");
+
+  ASSERT(c.is_a(rb_cClass));
+  ASSERT_EQUAL(c, object.const_get("Foo"));
+}
+
+TESTCASE(define_class_under)
+{
+  Class object(rb_cObject);
+  if(object.const_defined("Foo"))
+  {
+    object.remove_const("Foo");
+  }
+
+  Module math(rb_mMath);
+  if(math.const_defined("Foo"))
+  {
+    math.remove_const("Foo");
+  }
+
+  Class c = define_class_under(math, "Foo");
+
+  ASSERT(c.is_a(rb_cClass));
+  ASSERT_EQUAL(c, math.const_get("Foo"));
+  ASSERT(!object.const_defined("Foo"));
+}
+
+TESTCASE(module_define_class)
+{
+  Class object(rb_cObject);
+  if(object.const_defined("Foo"))
+  {
+    object.remove_const("Foo");
+  }
+
+  Module math(rb_mMath);
+  if(math.const_defined("Foo"))
+  {
+    math.remove_const("Foo");
+  }
+
+  Class c = math.define_class("Foo");
+
+  ASSERT(c.is_a(rb_cClass));
+  ASSERT_EQUAL(c, math.const_get("Foo"));
+  ASSERT(!object.const_defined("Foo"));
+}