rice 3.0.0 → 4.0.3

data/test/test_Class.cpp

@@ -1,16 +1,9 @@
 #include "unittest.hpp"
 #include "embed_ruby.hpp"
-#include "rice/Class.hpp"
-#include "rice/Constructor.hpp"
-#include "rice/protect.hpp"
-#include "rice/Exception.hpp"
-#include "rice/Array.hpp"
-#include "rice/String.hpp"
-#include "rice/Symbol.hpp"
+#include <rice/rice.hpp>
 #include <iostream>
 
 using namespace Rice;
-using namespace std;
 
 TESTSUITE(Class);
 
@@ -33,10 +26,7 @@ TESTCASE(undef_creation_funcs)
   ASSERT_EXCEPTION_CHECK(
       Exception,
       c.call("new"),
-      ASSERT_EQUAL(
-          Object(rb_eTypeError), // TODO: 1.6.x?
-          Object(CLASS_OF(ex.value()))
-          )
+      ASSERT_EQUAL(rb_eTypeError, ex.class_of())
       );
 }
 
@@ -60,7 +50,7 @@ TESTCASE(include_module)
 TESTCASE(const_set_get_by_id)
 {
   Class c(anonymous_class());
-  Object v = to_ruby(42);
+  Object v = detail::to_ruby(42);
   Class & c2(c.const_set(rb_intern("FOO"), v));
   ASSERT_EQUAL(&c, &c2);
   ASSERT_EQUAL(v, c.const_get(rb_intern("FOO")));
@@ -69,7 +59,7 @@ TESTCASE(const_set_get_by_id)
 TESTCASE(const_set_get_by_identifier)
 {
   Class c(anonymous_class());
-  Object v = to_ruby(42);
+  Object v = detail::to_ruby(42);
   Class & c2(c.const_set(Identifier("FOO"), v));
   ASSERT_EQUAL(&c, &c2);
   ASSERT_EQUAL(v, c.const_get(Identifier("FOO")));
@@ -78,7 +68,7 @@ TESTCASE(const_set_get_by_identifier)
 TESTCASE(const_set_get_by_string)
 {
   Class c(anonymous_class());
-  Object v = to_ruby(42);
+  Object v = detail::to_ruby(42);
   Class & c2(c.const_set("FOO", v));
   ASSERT_EQUAL(&c, &c2);
   ASSERT_EQUAL(v, c.const_get("FOO"));
@@ -86,257 +76,111 @@ TESTCASE(const_set_get_by_string)
 
 namespace
 {
+  bool some_function()
+  {
+    return true;
+  }
 
-bool define_method_simple_ok;
-
-void define_method_simple_helper()
-{
-  define_method_simple_ok = true;
+  Object some_method(Object self)
+  {
+    return self;
+  }
 }
 
-} // namespace
-
-TESTCASE(define_method_simple)
+TESTCASE(methods)
 {
   Class c(anonymous_class());
-  c.define_method("foo", &define_method_simple_helper);
+  c.define_function("some_function", &some_function);
+  c.define_method("some_method", &some_method);
+
   Object o = c.call("new");
-  define_method_simple_ok = false;
-  o.call("foo");
-  ASSERT(define_method_simple_ok);
-}
+  Object result = o.call("some_function");
+  ASSERT_EQUAL(Qtrue, result.value());
 
-TESTCASE(define_singleton_method_simple)
-{
-  Class c(anonymous_class());
-  c.define_singleton_method("foo", &define_method_simple_helper);
-  define_method_simple_ok = false;
-  Object o = c.call("foo");
-  ASSERT(define_method_simple_ok);
+  result = o.call("some_method");
+  ASSERT_EQUAL(o, result);
 }
 
-TESTCASE(define_module_function_simple)
+TESTCASE(method_lambdas)
 {
-  // module_function only works with Module, not Class
   Class c(anonymous_class());
-  ASSERT_EXCEPTION_CHECK(
-    std::runtime_error,
-    c.define_module_function("foo", &define_method_simple_helper),
-  );
-}
-
-namespace
-{
-  class RefTest
+  c.define_function("some_function", []()
+    {
+      return some_function();
+    });
+  c.define_method("some_method", [](VALUE self)
   {
-    public:
-      RefTest() { }
-
-      static std::string& getReference() {
-        static std::string foo = "foo";
-        return foo;
-      }
-  };
-}
-
-TESTCASE(define_singleton_method_returning_reference)
-{
-  Class c = define_class<RefTest>("RefTest")
-    .define_constructor(Constructor<RefTest>())
-    .define_singleton_method("get_reference", &RefTest::getReference);
-
-  Module m(anonymous_module());
-
-  Object result = m.instance_eval("RefTest.get_reference");
-  ASSERT_EQUAL(result, String("foo"));
-}
-
-namespace
-{
-
-  int define_method_int_result;
-
-  class IntHelper {
-    public:
-      IntHelper() { }
-
-      void define_method_int_helper(int i)
-      {
-        define_method_int_result = i;
-      }
-  };
-
-} // namespace
-
-TESTCASE(define_method_int)
-{
-  Class c =
-    define_class<IntHelper>("IntHelper")
-      .define_constructor(Constructor<IntHelper>())
-      .define_method("foo", &IntHelper::define_method_int_helper);
-
-  Object o = c.call("new");
-  define_method_int_result = 0;
-  o.call("foo", 42);
-  ASSERT_EQUAL(42, define_method_int_result);
-}
-
-TESTCASE(define_method_int_passed_two_args)
-{
-  Class c =
-    define_class<IntHelper>("IntHelper")
-      .define_constructor(Constructor<IntHelper>())
-      .define_method("foo", &IntHelper::define_method_int_helper);
+    return some_method(self);
+  });
 
   Object o = c.call("new");
+  Object result = o.call("some_function");
+  ASSERT_EQUAL(Qtrue, result.value());
 
-  ASSERT_EXCEPTION_CHECK(
-      Exception,
-      o.call("foo", 1, 2),
-      ASSERT_EQUAL(
-          Object(rb_eArgError),
-          Object(CLASS_OF(ex.value()))
-          )
-      );
+  result = o.call("some_method");
+  ASSERT_EQUAL(o, result);
 }
 
-TESTCASE(define_method_int_passed_no_args)
+TESTCASE(singleton_methods)
 {
-  Class c =
-    define_class<IntHelper>("IntHelper")
-      .define_constructor(Constructor<IntHelper>())
-      .define_method("foo", &IntHelper::define_method_int_helper);
-
-  Object o = c.call("new");
+  Class c(anonymous_class());
+  c.define_singleton_method("some_method", &some_method);
 
-  ASSERT_EXCEPTION_CHECK(
-      Exception,
-      o.call("foo"),
-      ASSERT_EQUAL(
-          Object(rb_eArgError),
-          Object(CLASS_OF(ex.value()))
-          )
-      );
+  Object result = c.call("some_method");
+  ASSERT_EQUAL(c, result);
 }
 
-
-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(int i, Foo * x)
+TESTCASE(singleton_method_lambdas)
 {
-  define_method_int_foo_result_i = i;
-  define_method_int_foo_result_x = x;
-}
-
-} // namespace
+  Class c(anonymous_class());
+  c.define_singleton_method("some_method", [](VALUE self)
+    {
+      return some_method(self);
+    });
 
-template<>
-Foo * from_ruby<Foo *>(Object x)
-{
-  Foo * retval;
-  Data_Get_Struct(x.value(), Foo, retval);
-  return retval;
+  Object result = c.call("some_method");
+  ASSERT_EQUAL(c, result);
 }
 
-TESTCASE(define_method_int_foo)
+TESTCASE(module_function)
 {
+  // module_function only works with Module, not Class
   Class c(anonymous_class());
-  c.define_method("foo", &define_method_int_foo_helper);
-  Object o = c.call("new");
-  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);
-  o.call("foo", 42, Object(f));
-  ASSERT_EQUAL(42, define_method_int_foo_result_i);
-  ASSERT_EQUAL(foo, define_method_int_foo_result_x);
+  ASSERT_EXCEPTION_CHECK(
+    std::runtime_error,
+    c.define_module_function("some_function", &some_function),
+    ASSERT_EQUAL("can only define module functions for modules", ex.what())
+  );
 }
 
 namespace
 {
+  class Silly_Exception
+    : public std::exception
+  {
+  };
 
-class Silly_Exception
-  : public std::exception
-{
-};
-
-void handle_silly_exception(Silly_Exception const & ex)
-{
-  throw Exception(rb_eRuntimeError, "SILLY");
-}
-
-void throw_silly_exception()
-{
-  throw Silly_Exception();
-}
+  void handle_silly_exception(Silly_Exception const & ex)
+  {
+    throw Exception(rb_eRuntimeError, "SILLY");
+  }
 
+  void throw_silly_exception()
+  {
+    throw Silly_Exception();
+  }
 }
 
 TESTCASE(add_handler)
 {
   Class c(rb_cObject);
-  c.add_handler<Silly_Exception>(handle_silly_exception);
-  c.define_method("foo", throw_silly_exception);
-  Object exc = protect(rb_eval_string, "begin; foo; rescue Exception; $!; end");
+  c.add_handler<Silly_Exception>(handle_silly_exception)
+    .define_function("foo", throw_silly_exception);
+
+  Object exc = detail::protect(rb_eval_string, "begin; foo; rescue Exception; $!; end");
   ASSERT_EQUAL(rb_eRuntimeError, CLASS_OF(exc));
   Exception ex(exc);
-  ASSERT_EQUAL(String("SILLY"), String(ex.message()));
-}
-
-namespace
-{
-
-class Container
-{
-public:
-  Container(int * array, size_t length)
-    : array_(array)
-    , length_(length)
-  {
-  }
-
-  // Custom names to make sure we call the function pointers rather than
-  // expectable default names.
-  int * beginFoo() { return array_; }
-  int * endBar() { return array_ + length_; }
-
-private:
-  int * array_;
-  size_t length_;
-};
-
-} // namespace
-
-template<>
-Container * from_ruby<Container *>(Object x)
-{
-  Container * retval;
-  Data_Get_Struct(x.value(), Container, retval);
-  return retval;
-}
-
-TESTCASE(define_iterator)
-{
-  int array[] = { 1, 2, 3 };
-  Class c(anonymous_class());
-  c.define_iterator(&Container::beginFoo, &Container::endBar);
-  Container * container = new Container(array, 3);
-  Object wrapped_container = Data_Wrap_Struct(
-      c, 0, Default_Free_Function<Container>::free, container);
-  Array a = wrapped_container.instance_eval("a = []; each() { |x| a << x }; a");
-  ASSERT_EQUAL(3u, a.size());
-  ASSERT_EQUAL(to_ruby(1), Object(a[0]));
-  ASSERT_EQUAL(to_ruby(2), Object(a[1]));
-  ASSERT_EQUAL(to_ruby(3), Object(a[2]));
+  ASSERT_EQUAL("SILLY", ex.what());
 }
 
 TESTCASE(define_class)
@@ -347,10 +191,10 @@ TESTCASE(define_class)
     object.remove_const("Foo");
   }
 
-  Class c = define_class("Foo");
+  Class c = define_class("Foo1");
 
   ASSERT(c.is_a(rb_cClass));
-  ASSERT_EQUAL(c, object.const_get("Foo"));
+  ASSERT_EQUAL(c, object.const_get("Foo1"));
 }
 
 TESTCASE(define_class_under)
@@ -388,35 +232,13 @@ TESTCASE(module_define_class)
     math.remove_const("Foo");
   }
 
-  Class c = math.define_class("Foo");
+  Class c = define_class_under(math, "Foo");
 
   ASSERT(c.is_a(rb_cClass));
   ASSERT_EQUAL(c, math.const_get("Foo"));
   ASSERT(!object.const_defined("Foo"));
 }
 
-namespace {
-  class BaseClass {
-    public:
-      BaseClass() { }
-  };
-}
-
-TESTCASE(subclassing)
-{
-  Module m = define_module("Testing");
-  define_class_under<BaseClass>(m, "BaseClass").
-    define_constructor(Constructor<BaseClass>());
-
-  // Not sure how to make this a true failure case. If the subclassing
-  // doesn't work, Ruby will throw an error:
-  //
-  //    in `new': wrong instance allocation
-  //
-  m.instance_eval("class NewClass < Testing::BaseClass; end;");
-  m.instance_eval("n = NewClass.new");
-}
-
 namespace
 {
   int defaults_method_one_arg1;
@@ -441,7 +263,7 @@ TESTCASE(define_method_default_arguments)
               .define_constructor(Constructor<DefaultArgs>())
               .define_method("with_defaults",
                   &DefaultArgs::defaults_method_one,
-                  (Arg("arg1"), Arg("arg2") = 3, Arg("arg3") = true));
+                  Arg("arg1"), Arg("arg2") = 3, Arg("arg3") = true);
 
   Object o = c.call("new");
   o.call("with_defaults", 2);
@@ -463,35 +285,87 @@ TESTCASE(define_method_default_arguments)
   ASSERT(!defaults_method_one_arg3);
 }
 
-/*
-namespace {
-  float with_reference_defaults_x;
-  std::string with_reference_defaults_str;
+TESTCASE(invalid_comma_operator)
+{
+  Class c = define_class<DefaultArgs>("DefaultArgs")
+    .define_constructor(Constructor<DefaultArgs>());
 
-  class DefaultArgsRefs
+  ASSERT_EXCEPTION_CHECK(
+    std::runtime_error,
+    c.define_method("with_defaults", &DefaultArgs::defaults_method_one, (Arg("arg1"), Arg("arg2") = 3, Arg("arg3") = true)),
+    ASSERT_EQUAL("The Arg class no longer supports the comma operator, please remove the surounding parentheses", ex.what())
+  );
+}
+
+namespace
+{
+  int func1 = 0;
+  int func2 = 0;
+
+  int function1(int aValue)
   {
-    public:
-      void with_reference_defaults(float x, std::string const& str = std::string("testing"))
-      {
-        with_reference_defaults_x = x;
-        with_reference_defaults_str = str;
-      }
-  };
+    func1 = aValue;
+    return func1;
+  }
 
+  int function2(int aValue)
+  {
+    func2 = aValue;
+    return func2;
+  }
 }
 
-TESTCASE(define_method_works_with_reference_const_default_values)
+TESTCASE(same_function_signature)
 {
-  Class c = define_class<DefaultArgsRefs>("DefaultArgsRefs")
-              .define_constructor(Constructor<DefaultArgsRefs>())
-              .define_method("bar",
-                  &DefaultArgsRefs::with_reference_defaults,
-                  (Arg("x"), Arg("str") = std::string("testing")));
+  Class c = define_class("FunctionSignatures")
+    .define_singleton_function("function1", &function1)
+    .define_singleton_function("function2", &function2);
 
-  Object o = c.call("new");
-  o.call("bar", 3);
+  c.call("function1", 5);
+  ASSERT_EQUAL(5, func1);
+
+  c.call("function2", 6);
+  ASSERT_EQUAL(6, func2);
+}
+
+namespace
+{
+  VALUE someValue;
+
+  void value_parameter(VALUE value)
+  {
+    someValue = value;
+  }
+
+  VALUE value_return()
+  {
+    return rb_ary_new_from_args(3, Qnil, Qtrue, Qfalse);
+  }
+}
+
+TESTCASE(value_parameter)
+{
+  define_global_function("value_parameter", &value_parameter, Arg("value").isValue());
+
+  Module m = define_module("TestingModule");
+  
+  std::string code = R"($object = Object.new)";
+  Object object = m.instance_eval(code);
+
+  code = R"(value_parameter($object))";
+  m.instance_eval(code);
+
+  ASSERT_EQUAL(someValue, object.value());
+}
+
+TESTCASE(value_return)
+{
+  define_global_function("value_return", &value_return, Return().isValue());
+
+  Module m = define_module("TestingModule");
+
+  VALUE value = m.instance_eval("value_return");
+  detail::protect(rb_check_type, value, (int)T_ARRAY);
 
-  ASSERT_EQUAL(3, with_reference_defaults_x);
-  ASSERT_EQUAL("testing", with_reference_defaults_str);
+  ASSERT_EQUAL(3, Array(value).size());
 }
-*/

data/test/test_Constructor.cpp

@@ -1,11 +1,9 @@
 #include "unittest.hpp"
-#include "rice/Constructor.hpp"
-#include "rice/Data_Type.hpp"
+#include "embed_ruby.hpp"
 
-#include "rice/detail/env.hpp"
+#include <rice/rice.hpp>
 
 #include <iostream>
-using namespace std;
 
 using namespace Rice;
 
@@ -22,12 +20,15 @@ namespace
   };
 }
 
+SETUP(Array)
+{
+  embed_ruby();
+}
+
 TESTCASE(default_constructor)
 {
-  Data_Type<Default_Constructible> rb_cDefault_Constructible(
-      anonymous_class());
-  rb_cDefault_Constructible
-    .define_constructor(Constructor<Default_Constructible>());
+  Data_Type<Default_Constructible> rb_cDefault_Constructible(anonymous_class());
+  rb_cDefault_Constructible.define_constructor(Constructor<Default_Constructible>());
   Object o = rb_cDefault_Constructible.call("new");
   ASSERT_EQUAL(rb_cDefault_Constructible, o.class_of());
 }
@@ -96,7 +97,7 @@ TESTCASE(constructor_supports_default_arguments)
 {
   Class klass = define_class<WithDefaultArgs>("WithDefaultArgs").
     define_constructor(Constructor<WithDefaultArgs, int, float, bool>(),
-          ( Arg("x"), Arg("y") = (float)2.0, Arg("yes") = (bool)false ));
+           Arg("x"), Arg("y") = (float)2.0, Arg("yes") = (bool)false);
 
   klass.call("new", 4);
   ASSERT_EQUAL(4, withArgsX);