wurlinc-rice 1.4.0.1

data/test/test_Hash.cpp

@@ -0,0 +1,195 @@
+#include "unittest.hpp"
+#include "rice/Hash.hpp"
+#include <vector>
+#include <map>
+#include <algorithm>
+
+using namespace Rice;
+
+TESTSUITE(Hash);
+
+SETUP(Hash)
+{
+  ruby_init();
+}
+
+TESTCASE(default_construct)
+{
+  Hash h;
+  ASSERT_EQUAL(T_HASH, rb_type(h));
+  ASSERT_EQUAL(0, RHASH_TBL(h.value())->num_entries);
+}
+
+TESTCASE(construct_from_object)
+{
+  Object o(rb_hash_new());
+  Hash h(o);
+  ASSERT_EQUAL(T_HASH, rb_type(h));
+  ASSERT_EQUAL(0, RHASH_TBL(h.value())->num_entries);
+}
+
+TESTCASE(construct_from_value)
+{
+  VALUE v(rb_hash_new());
+  Hash h(v);
+  ASSERT_EQUAL(T_HASH, rb_type(h));
+  ASSERT_EQUAL(0, RHASH_TBL(h.value())->num_entries);
+}
+
+TESTCASE(copy_construct)
+{
+  Hash h;
+  Hash h2(h);
+  ASSERT_EQUAL(h.value(), h2.value());
+}
+
+TESTCASE(assignment)
+{
+  Hash h;
+  Hash h2;
+  h = h2;
+}
+
+TESTCASE(size)
+{
+  Hash h;
+  ASSERT_EQUAL(0u, h.size());
+  h[1] = 5;
+  ASSERT_EQUAL(1u, h.size());
+  h[6] = 9;
+  ASSERT_EQUAL(2u, h.size());
+  h[42] = 42;
+  ASSERT_EQUAL(3u, h.size());
+  h[6] = 1;
+  ASSERT_EQUAL(3u, h.size());
+}
+
+TESTCASE(bracket)
+{
+  Hash h;
+  h[1] = 5;
+  h[6] = 9;
+  h[42] = 42;
+  h[6] = 1;
+  ASSERT_EQUAL(to_ruby(5), Object(h[1]));
+  ASSERT_EQUAL(to_ruby(42), Object(h[42]));
+  ASSERT_EQUAL(to_ruby(1), Object(h[6]));
+}
+
+TESTCASE(get)
+{
+  Hash h;
+  h[1] = 5;
+  h[6] = 9;
+  h[42] = 42;
+  h[6] = 1;
+  ASSERT_EQUAL(5, h.get<int>(1));
+  ASSERT_EQUAL(42, h.get<int>(42));
+  ASSERT_EQUAL(1, h.get<int>(6));
+}
+
+TESTCASE(construct_vector_from_hash_iterators)
+{
+  Hash h;
+  h[1] = 5;
+  h[6] = 9;
+  h[42] = 42;
+  h[6] = 1;
+  std::vector<Hash::Entry> v(h.begin(), h.end());
+  std::sort(v.begin(), v.end());
+  ASSERT_EQUAL(3u, v.size());
+  ASSERT_EQUAL(v[0].key, to_ruby(1));
+  ASSERT_EQUAL(v[1].key, to_ruby(6));
+  ASSERT_EQUAL(v[2].key, to_ruby(42));
+  ASSERT_EQUAL(&v[0].key, &v[0].first);
+  ASSERT_EQUAL(&v[1].key, &v[1].first);
+  ASSERT_EQUAL(&v[2].key, &v[2].first);
+  ASSERT_EQUAL(v[0].value, to_ruby(5));
+  ASSERT_EQUAL(v[1].value, to_ruby(1));
+  ASSERT_EQUAL(v[2].value, to_ruby(42));
+  ASSERT_EQUAL(&v[0].value, &v[0].second);
+  ASSERT_EQUAL(&v[1].value, &v[1].second);
+  ASSERT_EQUAL(&v[2].value, &v[2].second);
+}
+
+TESTCASE(iterate)
+{
+  Hash h;
+  h[1] = 5;
+  h[6] = 9;
+  h[42] = 42;
+  h[6] = 1;
+  std::vector<Hash::Entry> v;
+  Hash::iterator it = h.begin();
+  Hash::iterator end = h.end();
+  for(; it != end; ++it)
+  {
+    v.push_back(*it);
+  }
+  std::sort(v.begin(), v.end());
+  ASSERT_EQUAL(3u, v.size());
+  ASSERT_EQUAL(v[0].key, to_ruby(1));
+  ASSERT_EQUAL(v[1].key, to_ruby(6));
+  ASSERT_EQUAL(v[2].key, to_ruby(42));
+  ASSERT_EQUAL(&v[0].key, &v[0].first);
+  ASSERT_EQUAL(&v[1].key, &v[1].first);
+  ASSERT_EQUAL(&v[2].key, &v[2].first);
+  ASSERT_EQUAL(v[0].value, to_ruby(5));
+  ASSERT_EQUAL(v[1].value, to_ruby(1));
+  ASSERT_EQUAL(v[2].value, to_ruby(42));
+  ASSERT_EQUAL(&v[0].value, &v[0].second);
+  ASSERT_EQUAL(&v[1].value, &v[1].second);
+  ASSERT_EQUAL(&v[2].value, &v[2].second);
+}
+
+TESTCASE(const_iterate)
+{
+  Hash h;
+  h[1] = 5;
+  h[6] = 9;
+  h[42] = 42;
+  h[6] = 1;
+  std::vector<Hash::Entry> v;
+  Hash::const_iterator it = h.begin();
+  Hash::const_iterator end = h.end();
+  for(; it != end; ++it)
+  {
+    v.push_back(*it);
+  }
+  std::sort(v.begin(), v.end());
+  ASSERT_EQUAL(3u, v.size());
+  ASSERT_EQUAL(v[0].key, to_ruby(1));
+  ASSERT_EQUAL(v[1].key, to_ruby(6));
+  ASSERT_EQUAL(v[2].key, to_ruby(42));
+  ASSERT_EQUAL(&v[0].key, &v[0].first);
+  ASSERT_EQUAL(&v[1].key, &v[1].first);
+  ASSERT_EQUAL(&v[2].key, &v[2].first);
+  ASSERT_EQUAL(v[0].value, to_ruby(5));
+  ASSERT_EQUAL(v[1].value, to_ruby(1));
+  ASSERT_EQUAL(v[2].value, to_ruby(42));
+  ASSERT_EQUAL(&v[0].value, &v[0].value);
+  ASSERT_EQUAL(&v[1].value, &v[1].value);
+  ASSERT_EQUAL(&v[2].value, &v[2].value);
+}
+
+TESTCASE(iterate_and_change)
+{
+  Hash h;
+  h[1] = 5;
+  h[6] = 9;
+  h[42] = 42;
+  h[6] = 1;
+  Hash::const_iterator it = h.begin();
+  Hash::const_iterator end = h.end();
+  std::map<int, int> m;
+  for(int j = 0; it != end; ++j, ++it)
+  {
+    it->second = j;
+    m[from_ruby<int>(it->first)] = j;
+  }
+  ASSERT_EQUAL(3u, m.size());
+  ASSERT_EQUAL(to_ruby(m[1]), h[1]);
+  ASSERT_EQUAL(to_ruby(m[6]), h[6]);
+  ASSERT_EQUAL(to_ruby(m[42]), h[42]);
+}
+

data/test/test_Identifier.cpp

@@ -0,0 +1,70 @@
+#include "unittest.hpp"
+#include "rice/Identifier.hpp"
+#include "rice/Symbol.hpp"
+
+using namespace Rice;
+
+TESTSUITE(Identifier);
+
+SETUP(Identifier)
+{
+  ruby_init();
+}
+
+TESTCASE(construct_from_id)
+{
+  ID id = rb_intern("foo");
+  Identifier identifier(id);
+  ASSERT_EQUAL(id, identifier.id());
+}
+
+TESTCASE(construct_from_symbol)
+{
+  Symbol symbol("FOO");
+  Identifier identifier(symbol);
+  ASSERT_EQUAL(rb_intern("FOO"), identifier.id());
+}
+
+TESTCASE(construct_from_c_string)
+{
+  Identifier identifier("Foo");
+  ASSERT_EQUAL(rb_intern("Foo"), identifier.id());
+}
+
+TESTCASE(default_construct)
+{
+  Identifier identifier;
+  ASSERT_EQUAL(rb_intern(""), identifier.id());
+}
+
+TESTCASE(copy_construct)
+{
+  Identifier identifier1("Foo");
+  Identifier identifier2(identifier1);
+  ASSERT_EQUAL(rb_intern("Foo"), identifier2.id());
+}
+
+TESTCASE(c_str)
+{
+  Identifier identifier("Foo");
+  ASSERT_EQUAL("Foo", identifier.c_str());
+}
+
+TESTCASE(str)
+{
+  Identifier identifier("Foo");
+  ASSERT_EQUAL(std::string("Foo"), identifier.str());
+}
+
+TESTCASE(implicit_conversion_to_id)
+{
+  Identifier identifier("Foo");
+  ASSERT_EQUAL(rb_intern("Foo"), static_cast<ID>(identifier));
+}
+
+TESTCASE(to_sym)
+{
+  Identifier identifier("Foo");
+  ASSERT_EQUAL(Symbol("Foo"), Symbol(identifier.to_sym()));
+}
+

data/test/test_Jump_Tag.cpp

@@ -0,0 +1,17 @@
+#include "unittest.hpp"
+#include "rice/Jump_Tag.hpp"
+
+using namespace Rice;
+
+TESTSUITE(Jump_Tag);
+
+SETUP(Jump_Tag)
+{
+}
+
+TESTCASE(construct)
+{
+  Jump_Tag jump_tag(42);
+  ASSERT_EQUAL(42, jump_tag.tag);
+}
+

data/test/test_Memory_Management.cpp

@@ -0,0 +1,50 @@
+#include "unittest.hpp"
+#include "rice/String.hpp"
+#include "rice/Class.hpp"
+#include "rice/global_function.hpp"
+
+using namespace Rice;
+
+TESTSUITE(Memory_Management);
+
+SETUP(Memory_Management)
+{
+  ruby_init();
+}
+
+namespace
+{
+  class TestClass {
+    double tmp;
+    public:
+      TestClass() {tmp=0;}
+
+      double getTmp() {
+        return tmp;
+      }
+
+      void setTmp(double x) {
+        tmp = x;
+      }
+  };
+
+  TestClass returnTestClass() {
+    TestClass x = TestClass();
+    x.setTmp(8);
+    return x;
+  }
+}
+
+TESTCASE(allows_copy_contructors_to_work)
+{
+  define_class<TestClass>("TestClass")
+    .define_method("tmp=", &TestClass::setTmp)
+    .define_method("tmp", &TestClass::getTmp);
+
+  define_global_function("return_test_class", &returnTestClass);
+
+  Module m = define_module("TestingModule");
+
+  Object result = m.instance_eval("return_test_class.tmp");
+  ASSERT_EQUAL(8.0, from_ruby<double>(result.value()));
+}