rice 1.0.0

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,209 @@
+--- !ruby/object:Gem::Specification 
+rubygems_version: 0.9.4
+specification_version: 1
+name: rice
+version: !ruby/object:Gem::Version 
+  version: 1.0.0
+date: 2008-02-06 00:00:00 -05:00
+summary: Ruby Interface for C++ Extensions
+require_paths: 
+- ruby/lib
+email: curlypaul924@gmail.com
+homepage: http://rice.rubyforge.org/
+rubyforge_project: rice
+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.
+autorequire: 
+default_executable: 
+bindir: bin
+has_rdoc: false
+required_ruby_version: !ruby/object:Gem::Version::Requirement 
+  requirements: 
+  - - ">"
+    - !ruby/object:Gem::Version 
+      version: 0.0.0
+  version: 
+platform: ruby
+signing_key: 
+cert_chain: 
+post_install_message: 
+authors: 
+- Paul Brannan
+files: 
+- COPYING
+- README
+- README.mingw
+- Doxyfile
+- doxygen.ac
+- doxygen.am
+- bootstrap
+- configure.ac
+- configure
+- config.guess
+- config.sub
+- depcomp
+- install-sh
+- missing
+- post-autoconf.rb
+- post-automake.rb
+- ruby.ac
+- Makefile.am
+- Makefile.in
+- rice/Makefile.am
+- rice/Makefile.in
+- ruby/Makefile.am
+- ruby/Makefile.in
+- ruby/lib/Makefile.am
+- ruby/lib/Makefile.in
+- sample/Makefile.am
+- sample/Makefile.in
+- test/Makefile.am
+- test/Makefile.in
+- rice/Module.cpp
+- rice/Module.hpp
+- rice/Module.ipp
+- rice/Symbol.cpp
+- rice/Symbol.hpp
+- rice/Symbol.ipp
+- rice/to_from_ruby.hpp
+- rice/to_from_ruby.ipp
+- rice/Builtin_Object.hpp
+- rice/Builtin_Object.ipp
+- rice/Data_Object.hpp
+- rice/Data_Object.ipp
+- rice/Array.hpp
+- rice/Array.ipp
+- rice/Hash.hpp
+- rice/Hash.ipp
+- rice/Data_Type_fwd.hpp
+- rice/global_function.hpp
+- rice/global_function.ipp
+- rice/VM.cpp
+- rice/VM.hpp
+- rice/Jump_Tag.hpp
+- rice/String.cpp
+- rice/String.hpp
+- rice/Object.cpp
+- rice/Object.hpp
+- rice/Object.ipp
+- rice/Enum.hpp
+- rice/Enum.ipp
+- rice/protect.hpp
+- rice/protect.ipp
+- rice/Class.cpp
+- rice/Class.hpp
+- rice/Class.ipp
+- rice/ruby_try_catch.hpp
+- rice/to_from_ruby_defn.hpp
+- rice/config.hpp
+- rice/Exception.cpp
+- rice/Exception.hpp
+- rice/Module_defn.hpp
+- rice/Address_Registration_Guard.hpp
+- rice/Address_Registration_Guard.ipp
+- rice/Data_Type_defn.hpp
+- rice/Object_defn.hpp
+- rice/Constructor.hpp
+- rice/Require_Guard.hpp
+- rice/Builtin_Object_defn.hpp
+- rice/Data_Type.cpp
+- rice/Data_Type.hpp
+- rice/Data_Type.ipp
+- rice/Module_impl.hpp
+- rice/Module_impl.ipp
+- rice/Address_Registration_Guard_defn.hpp
+- rice/Class_defn.hpp
+- rice/Critical_Guard.hpp
+- rice/Critical_Guard.ipp
+- rice/Struct.cpp
+- rice/Struct.hpp
+- rice/Struct.ipp
+- rice/Exception_Base.hpp
+- rice/Exception_Base.ipp
+- rice/Allocation_Strategies.hpp
+- rice/Identifier.cpp
+- rice/Identifier.hpp
+- rice/Identifier.ipp
+- rice/generate_code.rb
+- rice/config.hpp.in
+- rice/detail/Not_Copyable.hpp
+- rice/detail/wrap_function.hpp
+- rice/detail/wrap_function.ipp
+- rice/detail/object_call.hpp
+- rice/detail/object_call.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/from_ruby.hpp
+- rice/detail/from_ruby.ipp
+- rice/detail/method_data.cpp
+- rice/detail/method_data.hpp
+- rice/detail/default_allocation_func.hpp
+- rice/detail/default_allocation_func.ipp
+- rice/detail/rubysig.hpp
+- rice/detail/ruby.hpp
+- rice/detail/protect.cpp
+- rice/detail/protect.hpp
+- rice/detail/env.hpp
+- rice/detail/win32.hpp
+- rice/detail/to_ruby.hpp
+- rice/detail/to_ruby.ipp
+- rice/detail/Caster.hpp
+- rice/detail/Iterator_Definer.hpp
+- rice/detail/remove_const.hpp
+- rice/detail/Exception_Handler.hpp
+- rice/detail/Auto_Member_Function_Wrapper.hpp
+- rice/detail/Auto_Member_Function_Wrapper.ipp
+- rice/detail/st.hpp
+- rice/detail/Wrapped_Function.hpp
+- rice/detail/Auto_Function_Wrapper.hpp
+- rice/detail/Auto_Function_Wrapper.ipp
+- rice/detail/node.hpp
+- rice/detail/define_method_and_auto_wrap.hpp
+- rice/detail/define_method_and_auto_wrap.ipp
+- ruby/lib/mkmf-rice.rb.in
+- 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_Array.cpp
+- test/test_Module.cpp
+- test/test_Symbol.cpp
+- test/test_Identifier.cpp
+- test/test_Hash.cpp
+- test/test_Data_Object.cpp
+- test/unittest.cpp
+- test/unittest.hpp
+- test/test_VM.cpp
+- test/test_Allocation_Strategies.cpp
+- test/test_Class.cpp
+- test/test_Critical_Guard.cpp
+- test/test_Enum.cpp
+- test/test_String.cpp
+- test/test_Object.cpp
+- test/test_Builtin_Object.cpp
+- test/test_Constructor.cpp
+- test/test_Jump_Tag.cpp
+- test/test_To_From_Ruby.cpp
+- test/test_Exception.cpp
+- test/test_Struct.cpp
+- test/test_Address_Registration_Guard.cpp
+test_files: 
+- test/test_rice.rb
+rdoc_options: []
+
+extra_rdoc_files: 
+- README
+executables: []
+
+extensions: 
+- configure
+requirements: []
+
+dependencies: []
+