wurlinc-rice 1.4.0.1

data/test/Makefile.am

@@ -0,0 +1,78 @@
+noinst_PROGRAMS = unittest vm_unittest
+
+SUBDIRS = ext
+
+TESTS = unittest vm_unittest
+
+
+check: run_multiple_extensions_test
+
+.PHONY: run_multiple_extensions_test
+
+run_multiple_extensions_test:
+	$(RUBY) test_multiple_extensions.rb
+
+
+check: run_multiple_extensions_with_inheritance_test
+
+.PHONY: run_multiple_extensions_with_inheritance_test
+
+run_multiple_extensions_with_inheritance_test:
+	$(RUBY) test_multiple_extensions_with_inheritance.rb
+
+
+check: run_multiple_extensions_same_class_test
+
+.PHONY: run_multiple_extensions_same_class_test
+
+run_multiple_extensions_same_class_test:
+	$(RUBY) test_multiple_extensions_same_class.rb
+
+
+unittest_SOURCES = \
+	unittest.cpp \
+	test_Address_Registration_Guard.cpp \
+	test_Allocation_Strategies.cpp \
+	test_Array.cpp \
+	test_Builtin_Object.cpp \
+	test_Class.cpp \
+	test_Constructor.cpp \
+	test_Critical_Guard.cpp \
+	test_Data_Object.cpp \
+	test_Data_Type.cpp \
+	test_Director.cpp \
+	test_Enum.cpp \
+	test_Exception.cpp \
+	test_Hash.cpp \
+	test_Identifier.cpp \
+	test_Jump_Tag.cpp \
+	test_Memory_Management.cpp \
+	test_Module.cpp \
+	test_Object.cpp \
+	test_String.cpp \
+	test_Struct.cpp \
+	test_Symbol.cpp \
+	test_To_From_Ruby.cpp \
+	test_global_functions.cpp
+
+vm_unittest_SOURCES = \
+	unittest.cpp \
+	test_VM.cpp
+
+AM_CPPFLAGS = \
+	-I.. \
+	$(RUBY_CFLAGS)
+	$(RUBY_CPPFLAGS)
+
+AM_CXXLAGS = \
+	$(RUBY_CXXFLAGS)
+
+AM_LDFLAGS = \
+	$(RUBY_LDFLAGS) \
+	-L../rice
+
+LIBS = \
+	-lrice \
+	$(RUBY_LIBS) \
+	$(RUBY_LIBRUBYARG)
+

data/test/ext/Makefile.am

@@ -0,0 +1,43 @@
+RUBY_EXTCONF_OPTIONS = -I@RICE_ROOT@/ruby/lib
+EXTCONF_OPTIONS = --with-cppflags="-I@RICE_ROOT@" --with-libpath="@RICE_ROOT@/rice"
+
+EXTRA_DIST = \
+  t1/extconf.rb \
+  t1/t1.cpp \
+  t2/extconf.rb \
+  t2/t2.cpp
+
+all:
+
+t1/Makefile: t1/extconf.rb ../../config.status ../../ruby/lib/mkmf-rice.rb
+	@RUBY@ $(RUBY_EXTCONF_OPTIONS) -C t1 extconf.rb $(EXTCONF_OPTIONS)
+
+t2/Makefile: t2/extconf.rb ../../config.status ../../ruby/lib/mkmf-rice.rb
+	@RUBY@ $(RUBY_EXTCONF_OPTIONS) -C t2 extconf.rb $(EXTCONF_OPTIONS)
+
+all clean distclean: t1/Makefile t2/Makefile
+
+all: t1_all t2_all
+
+t1_all:
+	make -C t1 all
+
+t2_all:
+	make -C t2 all
+
+clean: t1_clean t2_clean
+
+t1_clean:
+	make -C t1 clean
+
+t2_clean:
+	make -C t2 clean
+
+distclean: t1_distclean t2_distclean
+
+t1_distclean:
+	make -C t1 distclean
+
+t2_distclean:
+	make -C t2 distclean
+

data/test/ext/t1/Foo.hpp

@@ -0,0 +1,10 @@
+#ifndef T1__FOO__HPP_
+#define T1__FOO__HPP_
+
+class Foo
+{
+public:
+  int foo() { return 42; }
+};
+
+#endif // T1__FOO__HPP_

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_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 = Xmalloc_Allocation_Strategy<Foo>::allocate();
+  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_LEN(a.value()));
+}
+
+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_PTR(a.value()), 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());
+}
+