wurlinc-rice 1.4.0.1

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();
+}
+

data/test/unittest.hpp

@@ -0,0 +1,292 @@
+#ifndef unittest__hpp_
+#define unittest__hpp_
+
+/*! \file
+ *  \brief A (very) simple unit test framework.
+ */
+
+#if defined(_MSC_VER)
+#define NOMINMAX
+#else
+using namespace std;
+#endif
+
+#include <vector>
+#include <string>
+#include <stdexcept>
+#include <sstream>
+#include <iostream>
+
+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
+

metadata

@@ -0,0 +1,276 @@
+--- !ruby/object:Gem::Specification 
+name: wurlinc-rice
+version: !ruby/object:Gem::Version 
+  hash: 125
+  prerelease: false
+  segments: 
+  - 1
+  - 4
+  - 0
+  - 1
+  version: 1.4.0.1
+platform: ruby
+authors: 
+- Paul Brannan
+- Jason Roelofs
+- David Martinez
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2011-06-20 00:00:00 -07:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: rubyforge
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  type: :development
+  version_requirements: *id001
+description: |
+  Rice is a C++ interface to Ruby's C API.  It provides a type-safe and
+  exception-safe interface in order to make embedding Ruby and writing
+  Ruby extensions with C++ easier.  It is similar to Boost.Python in many
+  ways, but also attempts to provide an object-oriented interface to all
+  of the Ruby C API.
+
+email: 
+- curlypaul924@gmail.com
+- jameskilton@gmail.com
+- david@hackerdude.com
+executables: []
+
+extensions: 
+- extconf.rb
+extra_rdoc_files: 
+- README
+files: 
+- COPYING
+- README
+- README.mingw
+- Doxyfile
+- doxygen.ac
+- doxygen.am
+- extconf.rb
+- bootstrap
+- configure.ac
+- post-autoconf.rb
+- post-automake.rb
+- ruby.ac
+- Rakefile
+- Makefile.am
+- rice/Makefile.am
+- ruby/Makefile.am
+- ruby/lib/Makefile.am
+- sample/Makefile.am
+- test/Makefile.am
+- rice/Address_Registration_Guard.hpp
+- rice/Address_Registration_Guard.ipp
+- rice/Address_Registration_Guard_defn.hpp
+- rice/Allocation_Strategies.hpp
+- rice/Arg.hpp
+- rice/Arg_impl.hpp
+- rice/Arg_operators.cpp
+- rice/Arg_operators.hpp
+- rice/Array.hpp
+- rice/Array.ipp
+- rice/Builtin_Object.hpp
+- rice/Builtin_Object.ipp
+- rice/Builtin_Object_defn.hpp
+- rice/Class.cpp
+- rice/Class.hpp
+- rice/Class.ipp
+- rice/Class_defn.hpp
+- rice/Constructor.hpp
+- rice/Critical_Guard.hpp
+- rice/Critical_Guard.ipp
+- rice/Data_Object.hpp
+- rice/Data_Object.ipp
+- rice/Data_Object_defn.hpp
+- rice/Data_Type.cpp
+- rice/Data_Type.hpp
+- rice/Data_Type.ipp
+- rice/Data_Type_defn.hpp
+- rice/Data_Type_fwd.hpp
+- rice/Director.cpp
+- rice/Director.hpp
+- rice/Enum.hpp
+- rice/Enum.ipp
+- rice/Exception.cpp
+- rice/Exception.hpp
+- rice/Exception_Base.hpp
+- rice/Exception_Base.ipp
+- rice/Exception_Base_defn.hpp
+- rice/Exception_defn.hpp
+- rice/global_function.hpp
+- rice/global_function.ipp
+- rice/Hash.hpp
+- rice/Hash.ipp
+- rice/Identifier.cpp
+- rice/Identifier.hpp
+- rice/Identifier.ipp
+- rice/Jump_Tag.hpp
+- rice/Module.cpp
+- rice/Module.hpp
+- rice/Module.ipp
+- rice/Module_defn.hpp
+- rice/Module_impl.hpp
+- rice/Module_impl.ipp
+- rice/Object.cpp
+- rice/Object.hpp
+- rice/Object.ipp
+- rice/Object_defn.hpp
+- rice/protect.hpp
+- rice/protect.ipp
+- rice/Require_Guard.hpp
+- rice/ruby_mark.hpp
+- rice/ruby_try_catch.hpp
+- rice/String.cpp
+- rice/String.hpp
+- rice/Struct.cpp
+- rice/Struct.hpp
+- rice/Struct.ipp
+- rice/Symbol.cpp
+- rice/Symbol.hpp
+- rice/Symbol.ipp
+- rice/to_from_ruby.hpp
+- rice/to_from_ruby.ipp
+- rice/to_from_ruby_defn.hpp
+- rice/VM.cpp
+- rice/VM.hpp
+- rice/rubypp.rb
+- rice/config.hpp.in
+- rice/detail/Arguments.hpp
+- rice/detail/Auto_Function_Wrapper.hpp
+- rice/detail/Auto_Function_Wrapper.ipp
+- rice/detail/Auto_Member_Function_Wrapper.hpp
+- rice/detail/Auto_Member_Function_Wrapper.ipp
+- rice/detail/Caster.hpp
+- rice/detail/cfp.hpp
+- rice/detail/cfp.ipp
+- rice/detail/check_ruby_type.cpp
+- rice/detail/check_ruby_type.hpp
+- rice/detail/creation_funcs.hpp
+- rice/detail/creation_funcs.ipp
+- rice/detail/default_allocation_func.hpp
+- rice/detail/default_allocation_func.ipp
+- rice/detail/define_method_and_auto_wrap.hpp
+- rice/detail/define_method_and_auto_wrap.ipp
+- rice/detail/demangle.cpp
+- rice/detail/demangle.hpp
+- rice/detail/env.hpp
+- rice/detail/Exception_Handler.hpp
+- rice/detail/Exception_Handler.ipp
+- rice/detail/Exception_Handler_defn.hpp
+- rice/detail/from_ruby.hpp
+- rice/detail/from_ruby.ipp
+- rice/detail/Iterator.hpp
+- rice/detail/method_data.cpp
+- rice/detail/method_data.hpp
+- rice/detail/mininode.cpp
+- rice/detail/mininode.hpp
+- rice/detail/node.hpp
+- rice/detail/Not_Copyable.hpp
+- rice/detail/object_call.hpp
+- rice/detail/object_call.ipp
+- rice/detail/protect.cpp
+- rice/detail/protect.hpp
+- rice/detail/ruby.hpp
+- rice/detail/rubysig.hpp
+- rice/detail/st.hpp
+- rice/detail/to_ruby.hpp
+- rice/detail/to_ruby.ipp
+- rice/detail/traits.hpp
+- rice/detail/win32.hpp
+- rice/detail/wrap_function.hpp
+- rice/detail/wrap_function.ipp
+- rice/detail/Wrapped_Function.hpp
+- rice/detail/ruby_version_code.hpp.in
+- ruby/lib/mkmf-rice.rb.in
+- ruby/lib/version.rb
+- sample/enum/extconf.rb
+- sample/enum/sample_enum.cpp
+- sample/enum/test.rb
+- sample/map/extconf.rb
+- sample/map/map.cpp
+- sample/map/test.rb
+- sample/inheritance/extconf.rb
+- sample/inheritance/animals.cpp
+- sample/inheritance/test.rb
+- test/test_Address_Registration_Guard.cpp
+- test/test_Allocation_Strategies.cpp
+- test/test_Array.cpp
+- test/test_Builtin_Object.cpp
+- test/test_Class.cpp
+- test/test_Constructor.cpp
+- test/test_Critical_Guard.cpp
+- test/test_Data_Object.cpp
+- test/test_Data_Type.cpp
+- test/test_Director.cpp
+- test/test_Enum.cpp
+- test/test_Exception.cpp
+- test/test_global_functions.cpp
+- test/test_Hash.cpp
+- test/test_Identifier.cpp
+- test/test_Jump_Tag.cpp
+- test/test_Memory_Management.cpp
+- test/test_Module.cpp
+- test/test_Object.cpp
+- test/test_String.cpp
+- test/test_Struct.cpp
+- test/test_Symbol.cpp
+- test/test_To_From_Ruby.cpp
+- test/test_VM.cpp
+- test/unittest.cpp
+- test/unittest.hpp
+- test/ext/Makefile.am
+- test/ext/t1/extconf.rb
+- test/ext/t1/Foo.hpp
+- test/ext/t1/t1.cpp
+- test/ext/t2/extconf.rb
+- test/ext/t2/t2.cpp
+- test/test_rice.rb
+has_rdoc: true
+homepage: http://rice.rubyforge.org/
+licenses: []
+
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- ruby/lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+requirements: []
+
+rubyforge_project: rice
+rubygems_version: 1.3.7
+signing_key: 
+specification_version: 3
+summary: Ruby Interface for C++ Extensions
+test_files: 
+- test/test_rice.rb