jameskilton-rice 1.2.0

data/test/test_Object.cpp

@@ -0,0 +1,148 @@
+#include "unittest.hpp"
+#include "rice/Object.hpp"
+#include "rice/Class.hpp"
+#include "rice/String.hpp"
+#include "rice/Array.hpp"
+
+using namespace Rice;
+
+TESTSUITE(Object);
+
+SETUP(Object)
+{
+  ruby_init();
+}
+
+TESTCASE(default_construct)
+{
+  Object o;
+  ASSERT_EQUAL(Qnil, o.value());
+}
+
+TESTCASE(construct_with_value)
+{
+  Object o(INT2NUM(42));
+  ASSERT_EQUAL(INT2NUM(42), o.value());
+}
+
+TESTCASE(copy_construct)
+{
+  Object o(INT2NUM(42));
+  Object o2(o);
+  ASSERT_EQUAL(INT2NUM(42), o2.value());
+}
+
+TESTCASE(test)
+{
+  ASSERT_EQUAL(true, Object(Qtrue).test());
+  ASSERT_EQUAL(true, Object(INT2NUM(42)).test());
+  ASSERT_EQUAL(false, Object(Qfalse).test());
+  ASSERT_EQUAL(false, Object(Qnil).test());
+  ASSERT_EQUAL(true, Object(Qundef).test());
+}
+
+TESTCASE(explicit_conversion_to_bool)
+{
+  // g++ 3.3.3 can't handle constructor-style inside the assert, which
+  // is why we use cast-style here.
+  ASSERT_EQUAL(true, (bool)Object(Qtrue));
+  ASSERT_EQUAL(true, (bool)Object(INT2NUM(42)));
+  ASSERT_EQUAL(false, (bool)Object(Qfalse));
+  ASSERT_EQUAL(false, (bool)Object(Qnil));
+  ASSERT_EQUAL(true, (bool)Object(Qundef));
+}
+
+TESTCASE(is_nil)
+{
+  ASSERT_EQUAL(false, Object(Qtrue).is_nil());
+  ASSERT_EQUAL(false, Object(INT2NUM(42)).is_nil());
+  ASSERT_EQUAL(false, Object(Qfalse).is_nil());
+  ASSERT_EQUAL(true, Object(Qnil).is_nil());
+  ASSERT_EQUAL(false, Object(Qundef).is_nil());
+}
+
+TESTCASE(implicit_conversion_to_value)
+{
+  // g++ 3.3.3 can't handle constructor-style inside the assert, which
+  // is why we use cast-style here.
+  ASSERT_EQUAL(Qtrue, (VALUE)Object(Qtrue));
+  ASSERT_EQUAL(INT2NUM(42), (VALUE)Object(INT2NUM(42)));
+  ASSERT_EQUAL(Qfalse, (VALUE)Object(Qfalse));
+  ASSERT_EQUAL(Qnil, (VALUE)Object(Qnil));
+  ASSERT_EQUAL(Qundef, (VALUE)Object(Qundef));
+}
+
+TESTCASE(explicit_conversion_to_value)
+{
+  ASSERT_EQUAL(Qtrue, Object(Qtrue).value());
+  ASSERT_EQUAL(INT2NUM(42), Object(INT2NUM(42)).value());
+  ASSERT_EQUAL(Qfalse, Object(Qfalse).value());
+  ASSERT_EQUAL(Qnil, Object(Qnil).value());
+  ASSERT_EQUAL(Qundef, Object(Qundef).value());
+}
+
+TESTCASE(class_of)
+{
+  ASSERT_EQUAL(Class(rb_cObject), Class(rb_cObject).call("new").class_of());
+  ASSERT_EQUAL(Class(rb_cFloat), Object(rb_float_new(42.0)).class_of());
+}
+
+TESTCASE(compare)
+{
+  ASSERT_EQUAL(0, Object(INT2NUM(42)).compare(Object(INT2NUM(42))));
+  ASSERT_EQUAL(-1, Object(INT2NUM(42)).compare(Object(INT2NUM(43))));
+  ASSERT_EQUAL(1, Object(INT2NUM(42)).compare(Object(INT2NUM(41))));
+}
+
+TESTCASE(to_s)
+{
+  ASSERT_EQUAL(String("42"), Object(INT2NUM(42)).to_s());
+}
+
+TESTCASE(inspect)
+{
+  ASSERT_EQUAL(String("42"), Object(INT2NUM(42)).inspect());
+  ASSERT_EQUAL(String("\"foo\""), Object(rb_str_new2("foo")).inspect());
+}
+
+TESTCASE(freeze)
+{
+  Object o(Class(rb_cObject).call("new"));
+  ASSERT(!OBJ_FROZEN(o.value()));
+  o.freeze();
+  ASSERT(OBJ_FROZEN(o.value()));
+}
+
+TESTCASE(is_frozen)
+{
+  Object o(Class(rb_cObject).call("new"));
+  ASSERT(!o.is_frozen());
+  rb_obj_freeze(o);
+  ASSERT(o.is_frozen());
+}
+
+TESTCASE(swap)
+{
+  Object o1(INT2NUM(42));
+  Object o2(rb_ary_new());
+  o1.swap(o2);
+  ASSERT_EQUAL(to_ruby(42), o2);
+  ASSERT_EQUAL(Class(rb_cArray), o1.class_of());
+}
+
+TESTCASE(instance_eval)
+{
+  Object o(Class(rb_cObject).call("new"));
+  o.iv_set("@foo", 42);
+  ASSERT_EQUAL(to_ruby(42), o.instance_eval("@foo"));
+}
+
+TESTCASE(rb_type)
+{
+  ASSERT_EQUAL(T_TRUE, Object(Qtrue).rb_type());
+  ASSERT_EQUAL(T_FIXNUM, Object(INT2NUM(42)).rb_type());
+  ASSERT_EQUAL(T_FALSE, Object(Qfalse).rb_type());
+  ASSERT_EQUAL(T_NIL, Object(Qnil).rb_type());
+  ASSERT_EQUAL(T_UNDEF, Object(Qundef).rb_type());
+}
+

data/test/test_String.cpp

@@ -0,0 +1,94 @@
+#include "unittest.hpp"
+#include "rice/String.hpp"
+
+using namespace Rice;
+
+TESTSUITE(String);
+
+SETUP(String)
+{
+  ruby_init();
+}
+
+TESTCASE(default_construct)
+{
+  String s;
+  ASSERT_EQUAL(T_STRING, rb_type(s));
+  ASSERT_EQUAL("", RSTRING_PTR(s.value()));
+}
+
+TESTCASE(construct_from_value)
+{
+  String s(rb_str_new2("foo"));
+  ASSERT_EQUAL(T_STRING, rb_type(s));
+  ASSERT_EQUAL("foo", RSTRING_PTR(s.value()));
+}
+
+TESTCASE(construct_from_object)
+{
+  Object o(rb_str_new2("foo"));
+  String s(o);
+  ASSERT_EQUAL(T_STRING, rb_type(s));
+  ASSERT_EQUAL("foo", RSTRING_PTR(s.value()));
+}
+
+TESTCASE(construct_from_identifier)
+{
+  String s(Identifier("foo"));
+  ASSERT_EQUAL(T_STRING, rb_type(s));
+  ASSERT_EQUAL("foo", RSTRING_PTR(s.value()));
+}
+
+TESTCASE(construct_from_c_string)
+{
+  String s("foo");
+  ASSERT_EQUAL(T_STRING, rb_type(s));
+  ASSERT_EQUAL("foo", RSTRING_PTR(s.value()));
+}
+
+TESTCASE(construct_from_std_string)
+{
+  String s(std::string("foo"));
+  ASSERT_EQUAL(T_STRING, rb_type(s));
+  ASSERT_EQUAL("foo", RSTRING_PTR(s.value()));
+}
+
+TESTCASE(format)
+{
+  String s(String::format("%s %d", "foo", 42));
+  ASSERT_EQUAL(T_STRING, rb_type(s));
+  ASSERT_EQUAL("foo 42", RSTRING_PTR(s.value()));
+}
+
+TESTCASE(length)
+{
+  String s("foo");
+  ASSERT_EQUAL(3u, s.length());
+}
+
+TESTCASE(bracket)
+{
+  String s("foo");
+  ASSERT_EQUAL('f', s[0]);
+  ASSERT_EQUAL('o', s[1]);
+  ASSERT_EQUAL('o', s[2]);
+}
+
+TESTCASE(c_str)
+{
+  String s("foo");
+  ASSERT_EQUAL(RSTRING_PTR(s.value()), s.c_str());
+}
+
+TESTCASE(str)
+{
+  String s("foo");
+  ASSERT_EQUAL(std::string("foo"), s.str());
+}
+
+TESTCASE(intern)
+{
+  String s("foo");
+  ASSERT_EQUAL(Identifier("foo"), s.intern());
+}
+

data/test/test_Struct.cpp

@@ -0,0 +1,192 @@
+#include "unittest.hpp"
+#include "rice/Struct.hpp"
+#include "rice/Symbol.hpp"
+
+using namespace Rice;
+
+TESTSUITE(Struct);
+
+namespace
+{
+  Struct define_3d_point()
+  {
+    static Struct rb_cPoint = define_struct()
+      .define_member("x")
+      .define_member("y")
+      .define_member("z")
+      .initialize(rb_mKernel, "Point");
+    return rb_cPoint;
+  }
+}
+
+SETUP(Struct)
+{
+  ruby_init();
+}
+
+TESTCASE(default_construct)
+{
+  Struct s;
+  ASSERT_EQUAL(0, s.members().size());
+  // can't call rb_struct_s_members, because this isn't a struct yet
+}
+
+TESTCASE(initialize)
+{
+  Struct s(define_3d_point());
+  Array members(rb_struct_s_members(s));
+  ASSERT_EQUAL(3, members.size());
+  ASSERT_EQUAL("x", Symbol(members[0]).c_str());
+  ASSERT_EQUAL("y", Symbol(members[1]).c_str());
+  ASSERT_EQUAL("z", Symbol(members[2]).c_str());
+}
+
+TESTCASE(copy_construct)
+{
+  Struct s(define_3d_point());
+  Struct s2(s);
+  Array members(rb_struct_s_members(s2));
+  ASSERT_EQUAL(3, members.size());
+  ASSERT_EQUAL("x", Symbol(members[0]).c_str());
+  ASSERT_EQUAL("y", Symbol(members[1]).c_str());
+  ASSERT_EQUAL("z", Symbol(members[2]).c_str());
+}
+
+TESTCASE(offset_of)
+{
+  Struct s(define_3d_point());
+  ASSERT_EQUAL(0, s.offset_of("x"));
+  ASSERT_EQUAL(1, s.offset_of("y"));
+  ASSERT_EQUAL(2, s.offset_of("z"));
+}
+
+TESTCASE(new_instance_no_args)
+{
+  Struct s(define_3d_point());
+  Struct::Instance p(s.new_instance());
+  ASSERT_EQUAL(Rice::Nil, Object(rb_struct_getmember(p, rb_intern("x"))));
+  ASSERT_EQUAL(Rice::Nil, Object(rb_struct_getmember(p, rb_intern("y"))));
+  ASSERT_EQUAL(Rice::Nil, Object(rb_struct_getmember(p, rb_intern("z"))));
+}
+
+TESTCASE(new_instance_with_args)
+{
+  int a[] = { 1, 2, 3 };
+  Array args(a);
+  Struct s(define_3d_point());
+  Struct::Instance p(s.new_instance(args));
+  ASSERT_EQUAL(to_ruby(1), Object(rb_struct_getmember(p, rb_intern("x"))));
+  ASSERT_EQUAL(to_ruby(2), Object(rb_struct_getmember(p, rb_intern("y"))));
+  ASSERT_EQUAL(to_ruby(3), Object(rb_struct_getmember(p, rb_intern("z"))));
+}
+
+TESTCASE(swap)
+{
+  Struct s(define_3d_point());
+  Struct s2;
+  s2.swap(s);
+
+  try
+  {
+    Array members(rb_struct_s_members(s2));
+    ASSERT_EQUAL(3, members.size());
+    ASSERT_EQUAL("x", Symbol(members[0]).c_str());
+    ASSERT_EQUAL("y", Symbol(members[1]).c_str());
+    ASSERT_EQUAL("z", Symbol(members[2]).c_str());
+  }
+  catch(...)
+  {
+    s2.swap(s);
+    throw;
+  }
+
+  s2.swap(s);
+}
+
+TESTCASE(members)
+{
+  Struct s(define_3d_point());
+  Array members(s.members());
+  ASSERT_EQUAL(3, members.size());
+  ASSERT_EQUAL("x", Symbol(members[0]).c_str());
+  ASSERT_EQUAL("y", Symbol(members[1]).c_str());
+  ASSERT_EQUAL("z", Symbol(members[2]).c_str());
+}
+
+TESTCASE(construct_instance)
+{
+  int a[] = { 1, 2, 3 };
+  Array args(a);
+  Struct s(define_3d_point());
+  Struct::Instance p(s, args);
+  ASSERT_EQUAL(to_ruby(1), Object(rb_struct_getmember(p, rb_intern("x"))));
+  ASSERT_EQUAL(to_ruby(2), Object(rb_struct_getmember(p, rb_intern("y"))));
+  ASSERT_EQUAL(to_ruby(3), Object(rb_struct_getmember(p, rb_intern("z"))));
+}
+
+TESTCASE(wrap_instance)
+{
+  Struct s(define_3d_point());
+  Object o = s.instance_eval("new(1, 2, 3)");
+  Struct::Instance p(s, o);
+  ASSERT_EQUAL(to_ruby(1), Object(rb_struct_getmember(p, rb_intern("x"))));
+  ASSERT_EQUAL(to_ruby(2), Object(rb_struct_getmember(p, rb_intern("y"))));
+  ASSERT_EQUAL(to_ruby(3), Object(rb_struct_getmember(p, rb_intern("z"))));
+}
+
+TESTCASE(instance_bracket_identifier)
+{
+  int a[] = { 1, 2, 3 };
+  Array args(a);
+  Struct s(define_3d_point());
+  Struct::Instance p(s, args);
+  ASSERT_EQUAL(to_ruby(1), p[Identifier("x")]);
+  ASSERT_EQUAL(to_ruby(2), p[Identifier("y")]);
+  ASSERT_EQUAL(to_ruby(3), p[Identifier("z")]);
+}
+
+TESTCASE(instance_bracket_name)
+{
+  int a[] = { 1, 2, 3 };
+  Array args(a);
+  Struct s(define_3d_point());
+  Struct::Instance p(s, args);
+  ASSERT_EQUAL(to_ruby(1), p["x"]);
+  ASSERT_EQUAL(to_ruby(2), p["y"]);
+  ASSERT_EQUAL(to_ruby(3), p["z"]);
+}
+
+TESTCASE(instance_bracket_index)
+{
+  int a[] = { 1, 2, 3 };
+  Array args(a);
+  Struct s(define_3d_point());
+  Struct::Instance p(s, args);
+  ASSERT_EQUAL(to_ruby(1), p[0]);
+  ASSERT_EQUAL(to_ruby(2), p[1]);
+  ASSERT_EQUAL(to_ruby(3), p[2]);
+}
+
+TESTCASE(instance_swap)
+{
+  Struct s(define_3d_point());
+
+  int a1[] = { 1, 2, 3 };
+  Array args1(a1);
+  Struct::Instance p1(s, args1);
+
+  int a2[] = { 4, 5, 6 };
+  Array args2(a2);
+  Struct::Instance p2(s, args2);
+
+  p1.swap(p2);
+
+  ASSERT_EQUAL(to_ruby(4), Object(rb_struct_getmember(p1, rb_intern("x"))));
+  ASSERT_EQUAL(to_ruby(5), Object(rb_struct_getmember(p1, rb_intern("y"))));
+  ASSERT_EQUAL(to_ruby(6), Object(rb_struct_getmember(p1, rb_intern("z"))));
+
+  ASSERT_EQUAL(to_ruby(1), Object(rb_struct_getmember(p2, rb_intern("x"))));
+  ASSERT_EQUAL(to_ruby(2), Object(rb_struct_getmember(p2, rb_intern("y"))));
+  ASSERT_EQUAL(to_ruby(3), Object(rb_struct_getmember(p2, rb_intern("z"))));
+}
+

data/test/test_Symbol.cpp

@@ -0,0 +1,63 @@
+#include "unittest.hpp"
+#include "rice/Symbol.hpp"
+#include "rice/Identifier.hpp"
+
+using namespace Rice;
+
+TESTSUITE(Symbol);
+
+SETUP(Symbol)
+{
+  ruby_init();
+}
+
+TESTCASE(construct_from_symbol)
+{
+  VALUE v = ID2SYM(rb_intern("foo"));
+  Symbol symbol(v);
+  ASSERT_EQUAL(v, symbol.value());
+}
+
+TESTCASE(construct_from_identifier)
+{
+  Identifier identifier("FOO");
+  Symbol symbol(identifier);
+  ASSERT_EQUAL(ID2SYM(rb_intern("FOO")), symbol.value());
+}
+
+TESTCASE(construct_from_string)
+{
+  Symbol symbol("Foo");
+  ASSERT_EQUAL(ID2SYM(rb_intern("Foo")), symbol.value());
+}
+
+TESTCASE(default_construct)
+{
+  Symbol symbol;
+  ASSERT_EQUAL(ID2SYM(rb_intern("")), symbol.value());
+}
+
+TESTCASE(copy_construct)
+{
+  Symbol symbol1("Foo");
+  Symbol symbol2(symbol1);
+  ASSERT_EQUAL(ID2SYM(rb_intern("Foo")), symbol2.value());
+}
+
+TESTCASE(c_str)
+{
+  Symbol symbol("Foo");
+  ASSERT_EQUAL("Foo", symbol.c_str());
+}
+
+TESTCASE(str)
+{
+  Symbol symbol("Foo");
+  ASSERT_EQUAL(std::string("Foo"), symbol.str());
+}
+
+TESTCASE(to_id)
+{
+  Symbol symbol("Foo");
+  ASSERT_EQUAL(Identifier("Foo"), symbol.to_id());
+}