rice2 2.2.0

data/test/test_Exception.cpp

@@ -0,0 +1,47 @@
+#include "unittest.hpp"
+#include "rice/Exception.hpp"
+#include "rice/String.hpp"
+
+using namespace Rice;
+
+TESTSUITE(Exception);
+
+SETUP(Exception)
+{
+  ruby_init();
+}
+
+TESTCASE(construct_from_exception_object)
+{
+  VALUE v = protect(rb_exc_new2, rb_eRuntimeError, "foo");
+  Exception ex(v);
+  ASSERT_EQUAL(ex.value(), v);
+}
+
+TESTCASE(copy_construct)
+{
+  VALUE v = protect(rb_exc_new2, rb_eRuntimeError, "foo");
+  Exception ex1(v);
+  Exception ex2(v);
+  ASSERT_EQUAL(ex2.value(), v);
+}
+
+TESTCASE(construct_from_format_string)
+{
+  Exception ex(rb_eRuntimeError, "%s", "foo");
+  ASSERT_EQUAL(ex.class_of(), Object(rb_eRuntimeError));
+}
+
+TESTCASE(message)
+{
+  Exception ex(rb_eRuntimeError, "%s", "foo");
+  ASSERT_EQUAL(String("foo"), ex.message());
+}
+
+TESTCASE(what)
+{
+  const char* foo = "foo";
+  Exception ex(rb_eRuntimeError, "%s", "foo");
+  ASSERT_EQUAL(foo, ex.what());
+}
+

data/test/test_Hash.cpp

@@ -0,0 +1,212 @@
+#include "unittest.hpp"
+#include "rice/Hash.hpp"
+#include "rice/global_function.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_SIZE(h.value()));
+}
+
+TESTCASE(construct_from_object)
+{
+  Object o(rb_hash_new());
+  Hash h(o);
+  ASSERT_EQUAL(T_HASH, rb_type(h));
+  ASSERT_EQUAL(0, RHASH_SIZE(h.value()));
+}
+
+TESTCASE(construct_from_value)
+{
+  VALUE v(rb_hash_new());
+  Hash h(v);
+  ASSERT_EQUAL(T_HASH, rb_type(h));
+  ASSERT_EQUAL(0, RHASH_SIZE(h.value()));
+}
+
+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]);
+}
+
+/**
+ * Issue 59 - Copy constructor compilation problem.
+ */
+
+namespace {
+  void testHashArg(Object self, Hash string) {
+  }
+}
+
+TESTCASE(use_hash_in_wrapped_function) {
+  define_global_function("test_hash_arg", &testHashArg);
+}

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

data/test/test_Module.cpp

@@ -0,0 +1,497 @@
+#include "unittest.hpp"
+#include "rice/Module.hpp"
+#include "rice/Exception.hpp"
+#include "rice/Array.hpp"
+#include "rice/Arg.hpp"
+#include "rice/global_function.hpp"
+#include "rice/Constructor.hpp"
+
+using namespace Rice;
+
+TESTSUITE(Module);
+
+SETUP(Object)
+{
+  ruby_init();
+}
+
+TESTCASE(construct_from_value)
+{
+  Module m(rb_mEnumerable);
+  ASSERT_EQUAL(rb_mEnumerable, m.value());
+}
+
+namespace
+{
+
+class Quite_Silly_Exception
+  : public std::exception
+{
+};
+
+void handle_silly_exception(Quite_Silly_Exception const & ex)
+{
+  throw Exception(rb_eRuntimeError, "SILLY");
+}
+
+void throw_silly_exception(Object self)
+{
+  throw Quite_Silly_Exception();
+}
+
+} // namespace
+
+TESTCASE(add_handler)
+{
+  Module m(anonymous_module());
+  m.add_handler<Quite_Silly_Exception>(handle_silly_exception);
+  m.define_singleton_method("foo", throw_silly_exception);
+  Object exc = m.instance_eval("begin; foo; rescue Exception; $!; end");
+  ASSERT_EQUAL(rb_eRuntimeError, CLASS_OF(exc));
+  Exception ex(exc);
+  ASSERT_EQUAL(String("SILLY"), String(ex.message()));
+}
+
+namespace
+{
+
+bool define_method_simple_ok;
+
+void define_method_simple_helper(Object o)
+{
+  define_method_simple_ok = true;
+}
+
+} // namespace
+
+TESTCASE(define_method_simple)
+{
+  Module m(anonymous_module());
+  m.define_method("foo", define_method_simple_helper);
+  define_method_simple_ok = false;
+  Object o = m.instance_eval("o = Object.new; o.extend(self); o.foo");
+  ASSERT(define_method_simple_ok);
+}
+
+TESTCASE(define_singleton_method_simple)
+{
+  Module m(anonymous_module());
+  m.define_singleton_method("foo", define_method_simple_helper);
+  define_method_simple_ok = false;
+  Object o = m.call("foo");
+  ASSERT(define_method_simple_ok);
+}
+
+TESTCASE(define_module_function_simple)
+{
+  Module m(anonymous_module());
+  m.define_module_function("foo", define_method_simple_helper);
+  define_method_simple_ok = false;
+  m.instance_eval("o = Object.new; o.extend(self); o.instance_eval { foo }");
+  ASSERT(define_method_simple_ok);
+  define_method_simple_ok = false;
+  m.call("foo");
+  ASSERT(define_method_simple_ok);
+}
+
+TESTCASE(define_module_does_not_leak_method_to_Object)
+{
+  Module m = define_module("TestModule");
+  m.define_module_function("test_module_function", &define_method_simple_helper);
+
+  Module runner(anonymous_module());
+  ASSERT_EXCEPTION_CHECK(
+    Exception,
+    runner.instance_eval("Object.test_module_function"),
+    ASSERT_EQUAL(
+      Object(rb_eNoMethodError),
+      Object(CLASS_OF(ex.value()))
+    )
+  );
+}
+
+namespace
+{
+
+int define_method_int_result;
+
+void define_method_int_helper(Object o, int i)
+{
+  define_method_int_result = i;
+}
+
+} // namespace
+
+TESTCASE(define_method_int)
+{
+  Module m(anonymous_module());
+  m.define_method("foo", define_method_int_helper);
+  define_method_int_result = 0;
+  Object o = m.instance_eval("o = Object.new; o.extend(self); o.foo(42)");
+  ASSERT_EQUAL(42, define_method_int_result);
+}
+
+TESTCASE(define_singleton_method_int)
+{
+  Module m(anonymous_module());
+  m.define_singleton_method("foo", define_method_int_helper);
+  define_method_int_result = 0;
+  Object o = m.call("foo", 42);
+  ASSERT_EQUAL(42, define_method_int_result);
+}
+
+TESTCASE(define_module_function_int)
+{
+  Module m(anonymous_module());
+  m.define_module_function("foo", define_method_int_helper);
+  define_method_int_result = 0;
+  m.instance_eval("o = Object.new; o.extend(self); o.instance_eval { foo(42) }");
+  ASSERT_EQUAL(42, define_method_int_result);
+  define_method_int_result = 0;
+  m.call("foo", 42);
+  ASSERT_EQUAL(42, define_method_int_result);
+}
+
+TESTCASE(define_method_int_passed_no_args)
+{
+  Module m(anonymous_module());
+  m.define_method("foo", define_method_int_helper);
+  ASSERT_EXCEPTION_CHECK(
+      Exception,
+      m.instance_eval("o = Object.new; o.extend(self); o.foo"),
+      ASSERT_EQUAL(
+          Object(rb_eArgError),
+          Object(CLASS_OF(ex.value()))
+          )
+      );
+}
+
+namespace
+{
+
+struct Foo
+{
+  int x;
+};
+
+int define_method_int_foo_result_i;
+Foo * define_method_int_foo_result_x;
+
+void define_method_int_foo_helper(Object o, int i, Foo * x)
+{
+  define_method_int_foo_result_i = i;
+  define_method_int_foo_result_x = x;
+}
+
+} // namespace
+
+template<>
+Foo * from_ruby<Foo *>(Object x)
+{
+  Foo * retval;
+  Data_Get_Struct(x.value(), Foo, retval);
+  return retval;
+}
+
+TESTCASE(define_singleton_method_int_foo)
+{
+  Module m(anonymous_module());
+  m.define_singleton_method("int_and_foo", define_method_int_foo_helper);
+  define_method_int_result = 0;
+  Foo * foo = new Foo;
+  foo->x = 1024;
+  VALUE f = Data_Wrap_Struct(rb_cObject, 0, Default_Free_Function<Foo>::free, foo);
+  m.call("int_and_foo", 42, Object(f));
+  ASSERT_EQUAL(42, define_method_int_foo_result_i);
+  ASSERT_EQUAL(foo, define_method_int_foo_result_x);
+}
+
+// TODO: how to test define_iterator?
+
+TESTCASE(include_module)
+{
+  Module m(anonymous_module());
+  Module & m2(m.include_module(rb_mEnumerable));
+  ASSERT_EQUAL(&m, &m2);
+  Array ancestors(m.ancestors());
+  Array expected_ancestors;
+  expected_ancestors.push(m);
+  expected_ancestors.push(Module(rb_mEnumerable));
+  ASSERT_EQUAL(expected_ancestors, ancestors);
+}
+
+TESTCASE(const_set_get_by_id)
+{
+  Module m(anonymous_module());
+  Object v = to_ruby(42);
+  Module & m2(m.const_set(rb_intern("FOO"), v));
+  ASSERT_EQUAL(&m, &m2);
+  ASSERT_EQUAL(v, m.const_get(rb_intern("FOO")));
+}
+
+TESTCASE(const_set_get_by_identifier)
+{
+  Module m(anonymous_module());
+  Object v = to_ruby(42);
+  Module & m2(m.const_set(Identifier("FOO"), v));
+  ASSERT_EQUAL(&m, &m2);
+  ASSERT_EQUAL(v, m.const_get(Identifier("FOO")));
+}
+
+TESTCASE(const_set_get_by_string)
+{
+  Module m(anonymous_module());
+  Object v = to_ruby(42);
+  Module & m2(m.const_set("FOO", v));
+  ASSERT_EQUAL(&m, &m2);
+  ASSERT_EQUAL(v, m.const_get("FOO"));
+}
+
+TESTCASE(remove_const)
+{
+  Module m(anonymous_module());
+  Object v = to_ruby(42);
+  m.const_set("FOO", v);
+  ASSERT_EQUAL(v, m.const_get("FOO"));
+  m.remove_const("FOO");
+  ASSERT_EXCEPTION_CHECK(
+      Exception,
+      m.const_get("FOO"),
+      ASSERT_EQUAL(
+          Object(rb_eNameError),
+          Object(CLASS_OF(ex.value()))
+          )
+      );
+}
+
+TESTCASE(mod_name_anonymous)
+{
+  Module m(anonymous_module());
+  ASSERT_EQUAL(String(""), m.name());
+}
+
+/**
+ * Tests for default arguments
+ */
+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(define_method_default_arguments)
+{
+  Module m(anonymous_module());
+  m.define_method("foo", &defaults_method_one, (Arg("arg1"), Arg("arg2") = 3, Arg("arg3") = true));
+
+  Object o = m.instance_eval("o = Object.new; o.extend(self); o");
+  o.call("foo", 2);
+
+  ASSERT_EQUAL(2, defaults_method_one_arg1);
+  ASSERT_EQUAL(3, defaults_method_one_arg2);
+  ASSERT(defaults_method_one_arg3);
+
+  o.call("foo", 11, 10);
+
+  ASSERT_EQUAL(11, defaults_method_one_arg1);
+  ASSERT_EQUAL(10, defaults_method_one_arg2);
+  ASSERT(defaults_method_one_arg3);
+
+  o.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_still_throws_argument_error)
+{
+  Module m(anonymous_module());
+  m.define_method("foo", &defaults_method_one, (Arg("arg1"), Arg("arg2") = 3, Arg("arg3") = true));
+
+  ASSERT_EXCEPTION_CHECK(
+      Exception,
+      m.instance_eval("o = Object.new; o.extend(self); o.foo()"),
+      ASSERT_EQUAL(
+          Object(rb_eArgError),
+          Object(CLASS_OF(ex.value()))
+          )
+      );
+
+  ASSERT_EXCEPTION_CHECK(
+      Exception,
+      m.instance_eval("o = Object.new; o.extend(self); o.foo(3, 4, false, 17)"),
+      ASSERT_EQUAL(
+          Object(rb_eArgError),
+          Object(CLASS_OF(ex.value()))
+          )
+      );
+}
+
+namespace {
+  int the_one_default_arg = 0;
+  void method_with_one_default_arg(int num = 4) {
+    the_one_default_arg = num;
+  }
+}
+
+TESTCASE(defining_methods_with_single_default_argument)
+{
+  // define_method
+  Module m(anonymous_module());
+  m.define_method("foo", &method_with_one_default_arg, (Arg("num") = 4));
+  m.instance_eval("o = Object.new; o.extend(self); o.foo()");
+  ASSERT_EQUAL(4, the_one_default_arg);
+
+  the_one_default_arg = 0;
+
+  // define_singleton_method
+  Class c(anonymous_class());
+  c.define_singleton_method("foo", &method_with_one_default_arg, (Arg("num") = 4));
+  c.call("foo");
+  ASSERT_EQUAL(4, the_one_default_arg);
+
+  the_one_default_arg = 0;
+
+  // define_module_function
+  m.define_module_function("foo2", &method_with_one_default_arg, (Arg("num") = 4));
+
+  m.call("foo2");
+  ASSERT_EQUAL(4, the_one_default_arg);
+}
+
+TESTCASE(default_arguments_for_define_singleton_method)
+{
+  Class c(anonymous_class());
+  c.define_singleton_method("foo", &defaults_method_one, (Arg("arg1"), Arg("arg2") = 3, Arg("arg3") = true));
+
+  c.call("foo", 2);
+
+  ASSERT_EQUAL(2, defaults_method_one_arg1);
+  ASSERT_EQUAL(3, defaults_method_one_arg2);
+  ASSERT(defaults_method_one_arg3);
+
+  c.call("foo", 11, 10);
+
+  ASSERT_EQUAL(11, defaults_method_one_arg1);
+  ASSERT_EQUAL(10, defaults_method_one_arg2);
+  ASSERT(defaults_method_one_arg3);
+
+  c.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_module_function)
+{
+  Module m(anonymous_module());
+  m.define_module_function("foo", &defaults_method_one, (Arg("arg1"), Arg("arg2") = 3, Arg("arg3") = true));
+
+  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 {
+  std::string with_defaults_and_references_x;
+  bool with_defaults_and_references_doIt;
+
+  void with_defaults_and_references(std::string const& x, bool doIt = false)
+  {
+    with_defaults_and_references_x = x;
+    with_defaults_and_references_doIt = doIt;
+  }
+}
+
+TESTCASE(define_method_works_with_reference_arguments)
+{
+  Module m(anonymous_module());
+  m.define_module_function("foo", &with_defaults_and_references,
+      (Arg("x"), Arg("doIt") = false));
+
+  m.call("foo", "test");
+
+  ASSERT_EQUAL("test", with_defaults_and_references_x);
+  ASSERT(!with_defaults_and_references_doIt);
+}
+
+namespace {
+  class ReturnTest { };
+
+  class Factory {
+    public:
+      Factory() { returnTest_ = new ReturnTest(); }
+
+      const ReturnTest& getReturnTest() const {
+        return *returnTest_;
+      }
+
+     private:
+      const ReturnTest* returnTest_;
+  };
+}
+
+TESTCASE(define_method_works_with_const_reference_return)
+{
+  define_class<ReturnTest>("ReturnTest")
+    .define_constructor(Constructor<ReturnTest>());
+
+  define_class<Factory>("Factory")
+    .define_constructor(Constructor<Factory>())
+    .define_method("get_return_test", &Factory::getReturnTest);
+
+  Module m(anonymous_module());
+
+  Object result = m.instance_eval("Factory.new.get_return_test");
+
+  ASSERT_EQUAL("ReturnTest", result.class_of().name().c_str());
+}
+
+/*
+namespace {
+  float with_reference_defaults_x;
+  std::string with_reference_defaults_str;
+
+  void with_reference_defaults(float x, std::string const& str = std::string("testing"))
+  {
+    with_reference_defaults_x = x;
+    with_reference_defaults_str = str;
+  }
+}
+
+TESTCASE(define_method_works_with_reference_const_default_values)
+{
+  Module m(anonymous_module());
+  m.define_module_function("bar", &with_reference_defaults,
+      (Arg("x"), Arg("str") = std::string("testing")));
+
+  m.call("bar", 3);
+
+  ASSERT_EQUAL(3, with_reference_defaults_x);
+  ASSERT_EQUAL("testing", with_reference_defaults_str);
+}
+*/