rice 3.0.0 → 4.0.0

data/test/test_Attribute.cpp

@@ -0,0 +1,147 @@
+#include <assert.h> 
+
+#include "unittest.hpp"
+#include "embed_ruby.hpp"
+#include <rice/rice.hpp>
+#include <rice/stl.hpp>
+
+using namespace Rice;
+
+TESTSUITE(Attribute);
+
+SETUP(Attribute)
+{
+  embed_ruby();
+}
+
+namespace
+{
+  class SomeClass
+  {
+  };
+
+  struct DataStruct
+  {
+    static inline float staticFloat = 1.0;
+    static inline const std::string staticString = "Static string";
+    static inline SomeClass someClassStatic;
+
+    std::string readWriteString = "Read Write";
+    int writeInt = 0;
+    const char* readChars = "Read some chars!";
+    SomeClass someClass;
+
+    std::string inspect()
+    {
+      return "";
+    }
+  };
+
+  bool globalBool = true;
+  const DataStruct* globalStruct = new DataStruct();
+
+} // namespace
+
+TESTCASE(attributes)
+{
+  Class c = define_class<DataStruct>("DataStruct")
+    .define_constructor(Constructor<DataStruct>())
+    .define_method("inspect", &DataStruct::inspect)
+    .define_attr("read_chars", &DataStruct::readChars, Rice::AttrAccess::Read)
+    .define_attr("write_int", &DataStruct::writeInt, Rice::AttrAccess::Write)
+    .define_attr("read_write_string", &DataStruct::readWriteString);
+
+  Object o = c.call("new");
+  DataStruct* dataStruct = detail::From_Ruby<DataStruct*>().convert(o);
+
+  // Test readonly attribute
+  Object result = o.call("read_chars");
+  ASSERT_EQUAL("Read some chars!", detail::From_Ruby<char*>().convert(result));
+  ASSERT_EXCEPTION_CHECK(
+    Exception,
+    o.call("read_char=", "some text"),
+    ASSERT_EQUAL("undefined method `read_char=' for :DataStruct", ex.what())
+  );
+  
+  // Test writeonly attribute
+  result = o.call("write_int=", 5);
+  ASSERT_EQUAL(5, detail::From_Ruby<int>().convert(result.value()));
+  ASSERT_EQUAL(5, dataStruct->writeInt);
+  ASSERT_EXCEPTION_CHECK(
+    Exception,
+    o.call("write_int", 3),
+    ASSERT_EQUAL("undefined method `write_int' for :DataStruct", ex.what())
+  );
+
+  // Test readwrite attribute
+  result = o.call("read_write_string=", "Set a string");
+  ASSERT_EQUAL("Set a string", detail::From_Ruby<std::string>().convert(result.value()));
+  ASSERT_EQUAL("Set a string", dataStruct->readWriteString);
+
+  result = o.call("read_write_string");
+  ASSERT_EQUAL("Set a string", detail::From_Ruby<std::string>().convert(result.value()));
+}
+
+TESTCASE(static_attributes)
+{
+  Class c = define_class<DataStruct>("DataStruct")
+    .define_constructor(Constructor<DataStruct>())
+    .define_singleton_attr("static_float", &DataStruct::staticFloat, Rice::AttrAccess::ReadWrite)
+    .define_singleton_attr("static_string", &DataStruct::staticString, Rice::AttrAccess::Read);
+
+  // Test readwrite attribute
+  Object result = c.call("static_float=", 7.0);
+  ASSERT_EQUAL(7.0, detail::From_Ruby<float>().convert(result.value()));
+  ASSERT_EQUAL(7.0, DataStruct::staticFloat);
+  result = c.call("static_float");
+  ASSERT_EQUAL(7.0, detail::From_Ruby<float>().convert(result.value()));
+
+  result = c.call("static_string");
+  ASSERT_EQUAL("Static string", detail::From_Ruby<std::string>().convert(result.value()));
+  ASSERT_EXCEPTION_CHECK(
+    Exception,
+    c.call("static_string=", true),
+    ASSERT_EQUAL("undefined method `static_string=' for DataStruct:Class", ex.what())
+  );
+}
+
+TESTCASE(global_attributes)
+{
+  Class c = define_class<DataStruct>("DataStruct")
+    .define_constructor(Constructor<DataStruct>())
+    .define_singleton_attr("global_bool", &globalBool, Rice::AttrAccess::ReadWrite)
+    .define_singleton_attr("global_struct", &globalStruct, Rice::AttrAccess::Read);
+
+  Object result = c.call("global_bool=", false);
+  ASSERT_EQUAL(Qfalse, result.value());
+  ASSERT_EQUAL(false, globalBool);
+  result = c.call("global_bool");
+  ASSERT_EQUAL(Qfalse, result.value());
+
+  result = c.call("global_struct");
+  DataStruct* aStruct = detail::From_Ruby<DataStruct*>().convert(result.value());
+  ASSERT_EQUAL(aStruct, globalStruct);
+}
+
+TESTCASE(not_defined)
+{
+  Data_Type<DataStruct> c = define_class<DataStruct>("DataStruct");
+
+#ifdef _MSC_VER    
+  const char* message = "Type is not defined with Rice: class `anonymous namespace'::SomeClass";
+#else
+  const char* message = "Type is not defined with Rice: (anonymous namespace)::SomeClass";
+#endif
+
+  ASSERT_EXCEPTION_CHECK(
+    std::invalid_argument,
+    c.define_singleton_attr("some_class_static", &DataStruct::someClassStatic),
+    ASSERT_EQUAL(message, ex.what())
+  );
+
+  ASSERT_EXCEPTION_CHECK(
+    std::invalid_argument,
+    c.define_attr("some_class", &DataStruct::someClass),
+    ASSERT_EQUAL(message, ex.what())
+  );
+}

data/test/test_Builtin_Object.cpp

@@ -1,7 +1,6 @@
 #include "unittest.hpp"
 #include "embed_ruby.hpp"
-#include "rice/Builtin_Object.hpp"
-#include "rice/Class.hpp"
+#include <rice/rice.hpp>
 
 using namespace Rice;
 
@@ -35,6 +34,39 @@ TESTCASE(copy_construct)
   ASSERT_EQUAL(rb_cObject, CLASS_OF(b2.value()));
 }
 
+TESTCASE(copy_assign)
+{
+  Class c(rb_cObject);
+  Builtin_Object<T_OBJECT> b1(c.call("new"));
+  Builtin_Object<T_OBJECT> b2(c.call("new"));
+  
+  b2 = b1;
+
+  ASSERT_EQUAL(b2.value(), b1.value());
+}
+
+TESTCASE(move_constructor)
+{
+  Class c(rb_cObject);
+  Builtin_Object<T_OBJECT> b1(c.call("new"));
+  Builtin_Object<T_OBJECT> b2(std::move(b1));
+
+  ASSERT_NOT_EQUAL(b2.value(), b1.value());
+  ASSERT_EQUAL(b1.value(), Qnil);
+}
+
+TESTCASE(move_assign)
+{
+  Class c(rb_cObject);
+  Builtin_Object<T_OBJECT> b1(c.call("new"));
+  Builtin_Object<T_OBJECT> b2(c.call("new"));
+
+  b2 = std::move(b1);
+
+  ASSERT_NOT_EQUAL(b2.value(), b1.value());
+  ASSERT_EQUAL(b1.value(), Qnil);
+}
+
 TESTCASE(dereference)
 {
   Class c(rb_cObject);
@@ -58,15 +90,3 @@ TESTCASE(get)
   Builtin_Object<T_OBJECT> b(o);
   ASSERT_EQUAL(ROBJECT(o.value()), b.get());
 }
-
-TESTCASE(swap)
-{
-  Class c(rb_cObject);
-  Object o1(c.call("new"));
-  Builtin_Object<T_OBJECT> b1(o1);
-  Object o2(c.call("new"));
-  Builtin_Object<T_OBJECT> b2(o2);
-  b1.swap(b2);
-  ASSERT_EQUAL(b1.value(), o2.value());
-  ASSERT_EQUAL(b2.value(), o1.value());
-}

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