rice2 2.2.0

data/test/test_global_functions.cpp

@@ -0,0 +1,114 @@
+#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;
+  }
+
+  int defaults_returns(int arg1, int arg2 = 3)
+  {
+    return arg1 * arg2;
+  }
+}
+
+TESTCASE(default_arguments_for_define_global_function)
+{
+  define_global_function("foo", &defaults_method_one, (Arg("arg1"), Arg("arg2") = (int)3, Arg("arg3") = (bool)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);
+}
+
+TESTCASE(default_arguments_for_define_global_function_and_returning)
+{
+  define_global_function("foo_ret", &defaults_returns, (Arg("arg1"), Arg("arg2") = (int)3));
+  Module m(rb_mKernel);
+
+  Object o = m.call("foo_ret", 2);
+  ASSERT_EQUAL(INT2NUM(6), o.value());
+
+  o = m.call("foo_ret", 5, 10);
+  ASSERT_EQUAL(INT2NUM(50), o.value());
+}
+
+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") = (int)4));
+  Module m(rb_mKernel);
+  m.call("foo");
+  ASSERT_EQUAL(4, the_one_default_arg);
+}

data/test/test_rice.rb

@@ -0,0 +1,41 @@
+require 'rubygems'
+gem 'minitest'
+require 'minitest/autorun'
+require 'rbconfig'
+
+class RiceTest < Minitest::Test
+  # TODO: probably a better way to find this out...
+  VERBOSE = ARGV.include?('-v')
+
+  EXEEXT = RbConfig::CONFIG['EXEEXT']
+  RUBY = RbConfig::CONFIG['RUBY_INSTALL_NAME']
+
+  def test_unittest
+    run_external_test("./unittest#{EXEEXT}")
+  end
+
+  def test_multiple_extensions
+    run_external_test("#{RUBY} test_multiple_extensions.rb")
+  end
+
+  def test_multiple_extensions_with_inheritance
+    run_external_test("#{RUBY} test_multiple_extensions_with_inheritance.rb")
+  end
+
+  def test_multiple_extensions_same_class
+    run_external_test("#{RUBY} test_multiple_extensions_same_class.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 (int)result.errors().size() + (int)result.failures().size();
+}
+

data/test/unittest.hpp

@@ -0,0 +1,294 @@
+#ifndef unittest__hpp_
+#define unittest__hpp_
+
+/*! \file
+ *  \brief A (very) simple unit test framework.
+ */
+
+#if defined(_MSC_VER)
+#define NOMINMAX
+#endif
+
+#include <vector>
+#include <string>
+#include <stdexcept>
+#include <sstream>
+#include <iostream>
+
+#if !defined(_MSC_VER)
+using namespace std;
+#endif
+
+class Failure
+{
+public:
+  Failure(
+      std::string const & test_suite_name,
+      std::string const & test_case_name,
+      std::string what)
+    : test_suite_name_(test_suite_name)
+    , test_case_name_(test_case_name)
+    , what_(what)
+  {
+  }
+
+  friend std::ostream & operator<<(std::ostream & out, Failure const & failure);
+
+private:
+  std::string test_suite_name_;
+  std::string test_case_name_;
+  std::string what_;
+};
+
+class Test_Result
+{
+public:
+  void add_failure(Failure const & failure)
+  {
+    failures_.push_back(failure);
+  }
+
+  void add_error(Failure const & failure)
+  {
+    errors_.push_back(failure);
+  }
+
+  std::vector<Failure> const & failures() const
+  {
+    return failures_;
+  }
+
+  std::vector<Failure> const & errors() const
+  {
+    return errors_;
+  }
+
+private:
+  std::vector<Failure> failures_;
+  std::vector<Failure> errors_;
+};
+
+class Test_Case
+{
+public:
+  typedef void (*Func)();
+
+  Test_Case(
+      std::string const & name,
+      Func f)
+    : name_(name)
+    , f_(f)
+  {
+  }
+
+  void run()
+  {
+    f_();
+  }
+
+  std::string const & name() const { return name_; }
+
+  size_t size() const { return 1; }
+
+private:
+  std::string name_;
+  Func f_;
+};
+
+class Test_Suite
+{
+public:
+  Test_Suite(std::string const & name = "");
+
+  void add_test_case(Test_Case const & test_case)
+  {
+    test_cases_.push_back(test_case);
+  }
+
+  void setup(void (*f)()) { setup_ = f; }
+  void teardown(void (*f)()) { teardown_ = f; }
+
+  void run(Test_Result & result);
+
+  std::string const & name() const { return name_; }
+
+  size_t size() const { return test_cases_.size(); }
+
+private:
+  std::string name_;
+
+  typedef std::vector<Test_Case> Test_Cases;
+  Test_Cases test_cases_;
+
+  void (*setup_)();
+  void (*teardown_)();
+};
+
+
+Test_Suite & test_suite();
+void new_test_suite(std::string const & name);
+
+class Assertion_Failed
+  : public std::runtime_error
+{
+public:
+  Assertion_Failed(std::string const & what)
+    : std::runtime_error(what)
+  {
+  }
+};
+
+
+// TODO: not sure how to append __LINE__ correctly here
+#define UNIQUE_SUITE_NAME(prefix, name) \
+  prefix ## __ ## name \
+
+#define TESTSUITE(name) \
+  struct UNIQUE_SUITE_NAME(testsuite_append, name) \
+  { \
+    UNIQUE_SUITE_NAME(testsuite_append, name)() \
+    { \
+      new_test_suite(#name); \
+    } \
+  } UNIQUE_SUITE_NAME(testsuite_append__initializer, name)
+
+#define TESTCASE(name) \
+  static void UNIQUE_SUITE_NAME(test, name)(); \
+  \
+  namespace \
+  { \
+    struct UNIQUE_SUITE_NAME(test_append, name) \
+    { \
+      UNIQUE_SUITE_NAME(test_append, name)() \
+      { \
+        test_suite().add_test_case( \
+            Test_Case(#name, & UNIQUE_SUITE_NAME(test, name))); \
+      } \
+    } UNIQUE_SUITE_NAME(test_append__initializer, name); \
+  } \
+  \
+  static void UNIQUE_SUITE_NAME(test, name)()
+
+#define TESTFIXTURE(name, type) \
+  static void UNIQUE_SUITE_NAME(fixture ## __ ## name, type)(); \
+  \
+  namespace \
+  { \
+    struct UNIQUE_SUITE_NAME(fixture_append ## __ ## name, type) \
+    { \
+      UNIQUE_SUITE_NAME(fixture_append ## __ ## name, type)() \
+      { \
+        test_suite().type(UNIQUE_SUITE_NAME(fixture ## __ ## name, type)); \
+      } \
+    } UNIQUE_SUITE_NAME(fixture_append__initializer ## __ ## name, type); \
+  } \
+  \
+  static void UNIQUE_SUITE_NAME(fixture ## __ ## name, type)()
+
+#define SETUP(name) TESTFIXTURE(name, setup)
+
+#define TEARDOWN(name) TESTFIXTURE(name, teardown)
+
+template<typename RHS_T, typename LHS_T>
+inline bool is_equal(RHS_T const & rhs, LHS_T const & lhs)
+{
+  return rhs == lhs;
+}
+
+inline bool is_equal(char const * lhs, char const * rhs)
+{
+  return std::string(lhs) == std::string(rhs);
+}
+
+inline bool is_equal(char * lhs, char const * rhs)
+{
+  return std::string(lhs) == std::string(rhs);
+}
+
+inline bool is_equal(char const * lhs, char * rhs)
+{
+  return std::string(lhs) == std::string(rhs);
+}
+
+template<typename T, typename U>
+inline bool is_not_equal(T const & t, U const & u)
+{
+  return !is_equal(t, u);
+}
+
+extern size_t assertions;
+
+template<typename T, typename U>
+void assert_equal(
+    T const & t,
+    U const & u,
+    std::string const & s_t,
+    std::string const & s_u,
+    std::string const & file,
+    size_t line)
+{
+  if(!is_equal(t, u))
+  {
+    std::stringstream strm;
+    strm << "Assertion failed: "
+      << s_t << " != " << s_u
+      << " (" << t << " != " << u << ")"
+      << " at " << file << ":" << line;
+    throw Assertion_Failed(strm.str());
+  }
+}
+
+template<typename T, typename U>
+void assert_not_equal(
+    T const & t,
+    U const & u,
+    std::string const & s_t,
+    std::string const & s_u,
+    std::string const & file,
+    size_t line)
+{
+  if(!is_not_equal(t, u))
+  {
+    std::stringstream strm;
+    strm << "Assertion failed: "
+      << s_t << " should != " << s_u
+      << " (" << t << " should != " << u << ")"
+      << " at " << file << ":" << line;
+    throw Assertion_Failed(strm.str());
+  }
+}
+
+#define ASSERT_EQUAL(x, y) \
+  do \
+  { \
+    ++assertions; \
+    assert_equal((x), (y), #x, #y, __FILE__, __LINE__); \
+  } while(0)
+
+#define ASSERT_NOT_EQUAL(x, y) \
+  do \
+  { \
+    ++assertions; \
+    assert_not_equal((x), (y), #x, #y, __FILE__, __LINE__); \
+  } while(0)
+
+#define ASSERT(x) \
+  ASSERT_EQUAL(true, !!x);
+
+#define ASSERT_EXCEPTION_CHECK(type, code, check_exception) \
+  try \
+  { \
+    ++assertions; \
+    code; \
+    ASSERT(!"Expected exception"); \
+  } \
+  catch(type const & ex) \
+  { \
+    check_exception; \
+  }
+
+#define ASSERT_EXCEPTION(type, code) \
+  ASSERT_EXCEPTION_CHECK(type, code, )
+
+#endif
+