jameskilton-rice 1.2.0

data/test/test_To_From_Ruby.cpp

@@ -0,0 +1,263 @@
+#include "unittest.hpp"
+#include "rice/to_from_ruby.hpp"
+#include "rice/String.hpp"
+#include <limits>
+#include <cmath>
+
+using namespace Rice;
+
+TESTSUITE(To_From_Ruby);
+
+SETUP(To_From_Ruby)
+{
+  ruby_init();
+}
+
+TESTCASE(object_to_ruby)
+{
+  Object o(rb_str_new2("foo"));
+  ASSERT_EQUAL(o.value(), to_ruby(o).value());
+}
+
+TESTCASE(object_from_ruby)
+{
+  Object o(rb_str_new2("foo"));
+  ASSERT_EQUAL(o.value(), from_ruby<Object>(o).value());
+}
+
+TESTCASE(int_to_ruby)
+{
+  ASSERT_EQUAL(INT2NUM(0), to_ruby((int)0).value());
+  ASSERT_EQUAL(INT2NUM(-1), to_ruby((int)-1).value());
+  ASSERT_EQUAL(INT2NUM(1), to_ruby((int)1).value());
+  ASSERT_EQUAL(
+      Object(INT2NUM(std::numeric_limits<int>::min())),
+      to_ruby(std::numeric_limits<int>::min()));
+  ASSERT_EQUAL(
+      Object(INT2NUM(std::numeric_limits<int>::max())),
+      to_ruby(std::numeric_limits<int>::max()));
+}
+
+TESTCASE(int_from_ruby)
+{
+  ASSERT_EQUAL(0, from_ruby<int>(INT2NUM(0)));
+  ASSERT_EQUAL(-1, from_ruby<int>(INT2NUM(-1)));
+  ASSERT_EQUAL(1, from_ruby<int>(INT2NUM(1)));
+  ASSERT_EQUAL(
+      std::numeric_limits<int>::min(),
+      from_ruby<int>(INT2NUM(std::numeric_limits<int>::min())));
+  ASSERT_EQUAL(
+      std::numeric_limits<int>::max(),
+      from_ruby<int>(INT2NUM(std::numeric_limits<int>::max())));
+}
+
+TESTCASE(long_to_ruby)
+{
+  ASSERT_EQUAL(LONG2NUM(0), to_ruby((long)0).value());
+  ASSERT_EQUAL(LONG2NUM(-1), to_ruby((long)-1).value());
+  ASSERT_EQUAL(LONG2NUM(1), to_ruby((long)1).value());
+  ASSERT_EQUAL(
+      LONG2NUM(FIXNUM_MAX),
+      to_ruby(FIXNUM_MAX).value());
+  ASSERT_EQUAL(
+      LONG2NUM(FIXNUM_MIN),
+      to_ruby(FIXNUM_MIN).value());
+  ASSERT_EQUAL(
+      Object(LONG2NUM(std::numeric_limits<long>::min())),
+      to_ruby(std::numeric_limits<long>::min()));
+  ASSERT_EQUAL(
+      Object(LONG2NUM(std::numeric_limits<long>::max())),
+      to_ruby(std::numeric_limits<long>::max()));
+}
+
+TESTCASE(long_from_ruby)
+{
+  ASSERT_EQUAL(0, from_ruby<long>(LONG2NUM(0)));
+  ASSERT_EQUAL(-1, from_ruby<long>(LONG2NUM(-1)));
+  ASSERT_EQUAL(1, from_ruby<long>(LONG2NUM(1)));
+  ASSERT_EQUAL(
+      FIXNUM_MIN,
+      from_ruby<long>(LONG2NUM(FIXNUM_MIN)));
+  ASSERT_EQUAL(
+      FIXNUM_MAX,
+      from_ruby<long>(LONG2NUM(FIXNUM_MAX)));
+  ASSERT_EQUAL(
+      std::numeric_limits<long>::min(),
+      from_ruby<long>(LONG2NUM(std::numeric_limits<long>::min())));
+  ASSERT_EQUAL(
+      std::numeric_limits<long>::max(),
+      from_ruby<long>(LONG2NUM(std::numeric_limits<long>::max())));
+}
+
+TESTCASE(unsigned_int_to_ruby)
+{
+  ASSERT_EQUAL(UINT2NUM(0), to_ruby((unsigned int)0).value());
+  ASSERT_EQUAL(UINT2NUM(1), to_ruby((unsigned int)1).value());
+  ASSERT_EQUAL(
+      Object(UINT2NUM(std::numeric_limits<unsigned int>::min())),
+      to_ruby(std::numeric_limits<unsigned int>::min()));
+  ASSERT_EQUAL(
+      Object(UINT2NUM(std::numeric_limits<unsigned int>::max())),
+      to_ruby(std::numeric_limits<unsigned int>::max()));
+}
+
+TESTCASE(unsigned_int_from_ruby)
+{
+  ASSERT_EQUAL(0u, from_ruby<unsigned int>(UINT2NUM(0)));
+  ASSERT_EQUAL(1u, from_ruby<unsigned int>(UINT2NUM(1)));
+  ASSERT_EQUAL(
+      std::numeric_limits<unsigned int>::min(),
+      from_ruby<unsigned int>(UINT2NUM(std::numeric_limits<unsigned int>::min())));
+  ASSERT_EQUAL(
+      std::numeric_limits<unsigned int>::max(),
+      from_ruby<unsigned int>(UINT2NUM(std::numeric_limits<unsigned int>::max())));
+}
+
+TESTCASE(unsigned_long_to_ruby)
+{
+  ASSERT_EQUAL(ULONG2NUM(0), to_ruby((unsigned long)0).value());
+  ASSERT_EQUAL(ULONG2NUM(1), to_ruby((unsigned long)1).value());
+  ASSERT_EQUAL(
+      ULONG2NUM(FIXNUM_MAX),
+      to_ruby(FIXNUM_MAX).value());
+  ASSERT_EQUAL(
+      Object(ULONG2NUM(std::numeric_limits<unsigned long>::min())),
+      to_ruby(std::numeric_limits<unsigned long>::min()));
+  ASSERT_EQUAL(
+      Object(ULONG2NUM(std::numeric_limits<unsigned long>::max())),
+      to_ruby(std::numeric_limits<unsigned long>::max()));
+}
+
+TESTCASE(unsigned_long_from_ruby)
+{
+  ASSERT_EQUAL(0u, from_ruby<unsigned long>(ULONG2NUM(0)));
+  ASSERT_EQUAL(1u, from_ruby<unsigned long>(ULONG2NUM(1)));
+  ASSERT_EQUAL(
+      static_cast<unsigned long>(FIXNUM_MIN),
+      from_ruby<unsigned long>(ULONG2NUM(FIXNUM_MIN)));
+  ASSERT_EQUAL(
+      std::numeric_limits<unsigned long>::min(),
+      from_ruby<unsigned long>(ULONG2NUM(std::numeric_limits<unsigned long>::min())));
+  ASSERT_EQUAL(
+      std::numeric_limits<unsigned long>::max(),
+      from_ruby<unsigned long>(ULONG2NUM(std::numeric_limits<unsigned long>::max())));
+}
+
+TESTCASE(bool_to_ruby)
+{
+  ASSERT_EQUAL(Qfalse, to_ruby(false).value());
+  ASSERT_EQUAL(Qtrue, to_ruby(true).value());
+}
+
+TESTCASE(bool_from_ruby)
+{
+  ASSERT_EQUAL(false, from_ruby<bool>(Object(Qfalse)));
+  ASSERT_EQUAL(true, from_ruby<bool>(Object(Qtrue)));
+}
+
+TESTCASE(float_to_ruby)
+{
+  ASSERT_EQUAL(Object(rb_float_new(0.0f)), to_ruby(0.0f));
+  ASSERT_EQUAL(Object(rb_float_new(-1.0f)), to_ruby(-1.0f));
+  ASSERT_EQUAL(Object(rb_float_new(1.0f)), to_ruby(1.0f));
+  ASSERT_EQUAL(Object(rb_float_new(0.5f)), to_ruby(0.5f));
+  ASSERT_EQUAL(
+      Object(rb_float_new(std::numeric_limits<float>::min())),
+      to_ruby(std::numeric_limits<float>::min()));
+  ASSERT_EQUAL(
+      Object(rb_float_new(std::numeric_limits<float>::max())),
+      to_ruby(std::numeric_limits<float>::max()));
+  ASSERT(
+      to_ruby(std::numeric_limits<float>::quiet_NaN()).call("nan?"));
+  ASSERT(
+      to_ruby(std::numeric_limits<float>::signaling_NaN()).call("nan?"));
+  ASSERT_EQUAL(
+      Object(rb_float_new(std::numeric_limits<float>::epsilon())),
+      to_ruby(std::numeric_limits<float>::epsilon()));
+}
+
+TESTCASE(float_from_ruby)
+{
+  ASSERT_EQUAL(0.0f, from_ruby<float>(rb_float_new(0.0f)));
+  ASSERT_EQUAL(-1.0f, from_ruby<float>(rb_float_new(-1.0f)));
+  ASSERT_EQUAL(1.0f, from_ruby<float>(rb_float_new(1.0f)));
+  ASSERT_EQUAL(
+      std::numeric_limits<float>::min(),
+      from_ruby<float>(rb_float_new(std::numeric_limits<float>::min())));
+  ASSERT_EQUAL(
+      std::numeric_limits<float>::max(),
+      from_ruby<float>(rb_float_new(std::numeric_limits<float>::max())));
+  ASSERT(
+      isnan(from_ruby<float>(rb_float_new(std::numeric_limits<float>::quiet_NaN()))));
+  ASSERT(
+      isnan(from_ruby<float>(rb_float_new(std::numeric_limits<float>::signaling_NaN()))));
+  ASSERT_EQUAL(
+      std::numeric_limits<float>::epsilon(),
+      from_ruby<float>(rb_float_new(std::numeric_limits<float>::epsilon())));
+}
+
+TESTCASE(double_to_ruby)
+{
+  ASSERT_EQUAL(Object(rb_float_new(0.0f)), to_ruby(0.0f));
+  ASSERT_EQUAL(Object(rb_float_new(-1.0f)), to_ruby(-1.0f));
+  ASSERT_EQUAL(Object(rb_float_new(1.0f)), to_ruby(1.0f));
+  ASSERT_EQUAL(Object(rb_float_new(0.5f)), to_ruby(0.5f));
+  ASSERT_EQUAL(
+      Object(rb_float_new(std::numeric_limits<double>::min())),
+      to_ruby(std::numeric_limits<double>::min()));
+  ASSERT_EQUAL(
+      Object(rb_float_new(std::numeric_limits<double>::max())),
+      to_ruby(std::numeric_limits<double>::max()));
+  ASSERT(
+      to_ruby(std::numeric_limits<double>::quiet_NaN()).call("nan?"));
+  ASSERT(
+      to_ruby(std::numeric_limits<double>::signaling_NaN()).call("nan?"));
+  ASSERT_EQUAL(
+      Object(rb_float_new(std::numeric_limits<double>::epsilon())),
+      to_ruby(std::numeric_limits<double>::epsilon()));
+}
+
+TESTCASE(double_from_ruby)
+{
+  ASSERT_EQUAL(0.0f, from_ruby<double>(rb_float_new(0.0f)));
+  ASSERT_EQUAL(-1.0f, from_ruby<double>(rb_float_new(-1.0f)));
+  ASSERT_EQUAL(1.0f, from_ruby<double>(rb_float_new(1.0f)));
+  ASSERT_EQUAL(
+      std::numeric_limits<double>::min(),
+      from_ruby<double>(rb_float_new(std::numeric_limits<double>::min())));
+  ASSERT_EQUAL(
+      std::numeric_limits<double>::max(),
+      from_ruby<double>(rb_float_new(std::numeric_limits<double>::max())));
+  ASSERT(
+      isnan(from_ruby<double>(rb_float_new(std::numeric_limits<double>::quiet_NaN()))));
+  ASSERT(
+      isnan(from_ruby<double>(rb_float_new(std::numeric_limits<double>::signaling_NaN()))));
+  ASSERT_EQUAL(
+      std::numeric_limits<double>::epsilon(),
+      from_ruby<double>(rb_float_new(std::numeric_limits<double>::epsilon())));
+}
+
+TESTCASE(char_const_ptr_to_ruby)
+{
+  ASSERT_EQUAL(String(""), to_ruby((char const *)""));
+  ASSERT_EQUAL(String("foo"), to_ruby((char const *)"foo"));
+}
+
+TESTCASE(char_const_ptr_from_ruby)
+{
+  ASSERT_EQUAL("", from_ruby<char const *>(rb_str_new2("")));
+  ASSERT_EQUAL("foo", from_ruby<char const *>(rb_str_new2("foo")));
+}
+
+TESTCASE(std_string_to_ruby)
+{
+  ASSERT_EQUAL(String(""), to_ruby(std::string("")));
+  ASSERT_EQUAL(String("foo"), to_ruby(std::string("foo")));
+}
+
+TESTCASE(std_string_from_ruby)
+{
+  ASSERT_EQUAL(std::string(""), from_ruby<std::string>(rb_str_new2("")));
+  ASSERT_EQUAL(std::string("foo"), from_ruby<std::string>(rb_str_new2("foo")));
+}
+

data/test/test_VM.cpp

@@ -0,0 +1,26 @@
+#include "unittest.hpp"
+#include "rice/VM.hpp"
+#include "rice/Object.hpp"
+#include <memory>
+
+using namespace Rice;
+
+std::auto_ptr<VM> vm;
+
+TESTSUITE(VM);
+
+SETUP(VM)
+{
+  std::vector<const char *> args;
+  args.push_back("test_VM");
+  args.push_back("-e");
+  args.push_back("puts \"HELLO\"");
+  vm.reset(new VM(args));
+}
+
+TESTCASE(create_object)
+{
+  Object o;
+  o.call("to_s");
+}
+

data/test/test_global_functions.cpp

@@ -0,0 +1,97 @@
+#include "unittest.hpp"
+#include "rice/global_function.hpp"
+
+using namespace Rice;
+
+TESTSUITE(GlobalFunction);
+
+SETUP(GlobalFunction)
+{
+  ruby_init();
+}
+
+namespace {
+
+  bool method_to_wrap_called = false;
+  void method_to_wrap(Object self) {
+    method_to_wrap_called = true;
+  }
+
+  int method_with_args_arg0;
+
+  void method_with_args(Object self, int arg) {
+    method_with_args_arg0 = arg;
+  } 
+
+}
+
+TESTCASE(exposes_global_functions)
+{
+  define_global_function("method_to_wrap", &method_to_wrap);
+  Module m = Module(rb_mKernel);
+  m.call("method_to_wrap");
+
+  ASSERT(method_to_wrap_called);
+}
+
+TESTCASE(exposes_global_functions_with_arguments)
+{
+  define_global_function("method_with_args", &method_with_args);
+  Module m = Module(rb_mKernel);
+  m.call("method_with_args", 10);
+
+  ASSERT_EQUAL(10, method_with_args_arg0);
+}
+
+namespace 
+{
+  int defaults_method_one_arg1;
+  int defaults_method_one_arg2;
+  bool defaults_method_one_arg3 = false;
+
+  void defaults_method_one(int arg1, int arg2 = 3, bool arg3 = true) 
+  {
+    defaults_method_one_arg1 = arg1;
+    defaults_method_one_arg2 = arg2;
+    defaults_method_one_arg3 = arg3;
+  }
+}
+
+TESTCASE(default_arguments_for_define_global_function)
+{
+  define_global_function("foo", &defaults_method_one, (Arg("arg1"), Arg("arg2") = 3, Arg("arg3") = true));
+  Module m(rb_mKernel);
+
+  m.call("foo", 2);
+
+  ASSERT_EQUAL(2, defaults_method_one_arg1);
+  ASSERT_EQUAL(3, defaults_method_one_arg2);
+  ASSERT(defaults_method_one_arg3);
+
+  m.call("foo", 11, 10);
+
+  ASSERT_EQUAL(11, defaults_method_one_arg1);
+  ASSERT_EQUAL(10, defaults_method_one_arg2);
+  ASSERT(defaults_method_one_arg3);
+
+  m.call("foo", 22, 33, false);
+
+  ASSERT_EQUAL(22, defaults_method_one_arg1);
+  ASSERT_EQUAL(33, defaults_method_one_arg2);
+  ASSERT(!defaults_method_one_arg3);
+}
+
+namespace {
+  int the_one_default_arg = 0;
+  void method_with_one_default_arg(int num = 4) {
+    the_one_default_arg = num;
+  }
+}
+
+TESTCASE(single_default_argument) 
+{
+  define_global_function("foo", &method_with_one_default_arg, (Arg("num") = 4));
+  Module m(rb_mKernel);
+  m.call("foo");
+  ASSERT_EQUAL(4, the_one_default_arg);
+}

data/test/test_rice.rb

@@ -0,0 +1,35 @@
+require 'test/unit'
+require 'rbconfig'
+
+class RiceTest < Test::Unit::TestCase
+  # TODO: probably a better way to find this out...
+  VERBOSE = ARGV.include?('-v')
+
+  EXEEXT = Config::CONFIG['EXEEXT']
+  RUBY = Config::CONFIG['RUBY_INSTALL_NAME']
+
+  def test_unittest
+    run_external_test("./unittest#{EXEEXT}")
+  end
+
+  def test_vm_unittest
+    run_external_test("./vm_unittest#{EXEEXT}")
+  end
+
+  def test_vm_unittest
+    run_external_test("#{RUBY} test_multiple_extensions.rb")
+  end
+
+  def run_external_test(executable)
+    if VERBOSE then
+      system(executable)
+    else
+      result = `#{executable}`
+      if $? != 0 then
+        puts result
+      end
+    end
+    raise "Error: $?" if $? != 0
+  end
+end
+

data/test/unittest.cpp

@@ -0,0 +1,136 @@
+#include <iostream>
+#include <map>
+#include "unittest.hpp"
+
+size_t assertions;
+
+namespace
+{
+
+typedef std::map<std::string, Test_Suite> Test_Suites;
+Test_Suite * last_test_suite;
+
+Test_Suites & test_suites()
+{
+  static Test_Suites test_suites;
+  return test_suites;
+}
+
+} // namespace
+
+Test_Suite & test_suite()
+{
+  return *last_test_suite;
+}
+
+void new_test_suite(std::string const & name)
+{
+  test_suites()[name] = Test_Suite(name);
+  last_test_suite = &test_suites()[name];
+}
+
+std::ostream & operator<<(std::ostream & out, Failure const & failure)
+{
+  out << "" << failure.test_suite_name_ << ":" << failure.test_case_name_ << ": " << failure.what_;
+  return out;
+}
+
+Test_Suite::
+Test_Suite(std::string const & name)
+  : name_(name)
+  , setup_(0)
+  , teardown_(0)
+{
+}
+
+void Test_Suite::
+run(Test_Result & result)
+{
+  for(Test_Cases::iterator it = test_cases_.begin(),
+      end = test_cases_.end();
+      it != end;
+      ++it)
+  {
+    try
+    {
+      std::cout << "" << name() << ":" << it->name() << " ";
+      std::cout.flush();
+      if(setup_)
+      {
+        setup_();
+      }
+      it->run();
+      std::cout << ".";
+    }
+    catch(Assertion_Failed const & ex)
+    {
+      std::cout << "F";
+      result.add_failure(Failure(name(), it->name(), ex.what()));
+    }
+    catch(std::exception const & ex)
+    {
+      std::cout << "E";
+      result.add_error(Failure(name(), it->name(), ex.what()));
+    }
+    catch(...)
+    {
+      std::cout << "E";
+      result.add_error(Failure(name(), it->name(), "Unknown exception"));
+    }
+    if(teardown_)
+    {
+      teardown_();
+    }
+    std::cout << std::endl;
+  }
+}
+
+int main()
+{
+  Test_Result result;
+  size_t num_tests = 0;
+
+  for(Test_Suites::iterator it = test_suites().begin(),
+      end = test_suites().end();
+      it != end;
+      ++it)
+  {
+    it->second.run(result);
+    num_tests += it->second.size();
+  }
+
+  std::cout << std::endl;
+
+  std::cout << num_tests << " test(s), "
+            << assertions << " assertion(s), "
+            << result.errors().size() << " error(s), "
+            << result.failures().size() << " failure(s)"
+            << std::endl;
+
+  if(result.errors().size() > 0)
+  {
+    std::cout << std::endl << "Errors:" << std::endl;
+    for(std::vector<Failure>::const_iterator it = result.errors().begin(),
+        end = result.errors().end();
+        it != end;
+        ++it)
+    {
+      std::cout << *it << std::endl;
+    }
+  }
+
+  if(result.failures().size() > 0)
+  {
+    std::cout << std::endl << "Failures:" << std::endl;
+    for(std::vector<Failure>::const_iterator it = result.failures().begin(),
+        end = result.failures().end();
+        it != end;
+        ++it)
+    {
+      std::cout << *it << std::endl;
+    }
+  }
+
+  return result.errors().size() + result.failures().size();
+}
+