rice 3.0.0 → 4.0.3

data/test/test_Array.cpp

@@ -1,13 +1,23 @@
 #include "unittest.hpp"
 #include "embed_ruby.hpp"
-#include "rice/Array.hpp"
-#include "rice/String.hpp"
-#include "rice/global_function.hpp"
+#include <rice/rice.hpp>
+
+#include <vector>
 
 using namespace Rice;
 
 TESTSUITE(Array);
 
+// This is needed to make unittest compile (it uses ostream to report errors)
+inline std::ostream& operator<<(std::ostream& os, const std::vector<int32_t>& vector)
+{
+  for (auto i : vector)
+  {
+    os << i << ", ";
+  }
+  return os;
+}
+
 SETUP(Array)
 {
   embed_ruby();
@@ -28,9 +38,9 @@ TESTCASE(construct_from_vector_of_int)
   v.push_back(42);
   Array a(v.begin(), v.end());
   ASSERT_EQUAL(3u, a.size());
-  ASSERT_EQUAL(to_ruby(10), a[0]);
-  ASSERT_EQUAL(to_ruby(6), a[1]);
-  ASSERT_EQUAL(to_ruby(42), a[2]);
+  ASSERT(rb_equal(detail::to_ruby(10), a[0].value()));
+  ASSERT(rb_equal(detail::to_ruby(6), a[1].value()));
+  ASSERT(rb_equal(detail::to_ruby(42), a[2].value()));
 }
 
 TESTCASE(construct_from_c_array)
@@ -38,12 +48,11 @@ TESTCASE(construct_from_c_array)
   int arr[] = { 10, 6, 42 };
   Array a(arr);
   ASSERT_EQUAL(3u, a.size());
-  ASSERT_EQUAL(to_ruby(10), a[0]);
-  ASSERT_EQUAL(to_ruby(6), a[1]);
-  ASSERT_EQUAL(to_ruby(42), a[2]);
+  ASSERT(rb_equal(detail::to_ruby(10), a[0].value()));
+  ASSERT(rb_equal(detail::to_ruby(6), a[1].value()));
+  ASSERT(rb_equal(detail::to_ruby(42), a[2].value()));
 }
 
-
 TESTCASE(push_no_items)
 {
   Array a;
@@ -61,23 +70,23 @@ TESTCASE(push_one_item)
 TESTCASE(push_two_items)
 {
   Array a;
-  a.push(to_ruby(42));
-  a.push(to_ruby(43));
+  a.push(42);
+  a.push(43);
   ASSERT_EQUAL(2u, a.size());
-  ASSERT_EQUAL(42, from_ruby<int>(a[0]));
-  ASSERT_EQUAL(43, from_ruby<int>(a[1]));
+  ASSERT_EQUAL(42, detail::From_Ruby<int>().convert(a[0].value()));
+  ASSERT_EQUAL(43, detail::From_Ruby<int>().convert(a[1].value()));
 }
 
 TESTCASE(push_three_items)
 {
   Array a;
-  a.push(to_ruby(42));
-  a.push(to_ruby(43));
-  a.push(to_ruby(44));
+  a.push(42);
+  a.push(43);
+  a.push(44);
   ASSERT_EQUAL(3u, a.size());
-  ASSERT_EQUAL(42, from_ruby<int>(a[0]));
-  ASSERT_EQUAL(43, from_ruby<int>(a[1]));
-  ASSERT_EQUAL(44, from_ruby<int>(a[2]));
+  ASSERT_EQUAL(42, detail::From_Ruby<int>().convert(a[0].value()));
+  ASSERT_EQUAL(43, detail::From_Ruby<int>().convert(a[1].value()));
+  ASSERT_EQUAL(44, detail::From_Ruby<int>().convert(a[2].value()));
 }
 
 TESTCASE(push_int)
@@ -85,25 +94,25 @@ TESTCASE(push_int)
   Array a;
   a.push(42);
   ASSERT_EQUAL(1u, a.size());
-  ASSERT_EQUAL(to_ruby(42), a[0]);
+  ASSERT(rb_equal(detail::to_ruby(42), a[0].value()));
 }
 
 TESTCASE(bracket_equals)
 {
   Array a;
-  a.push(to_ruby(42));
-  a.push(to_ruby(43));
-  a.push(to_ruby(44));
-  a[1] = to_ruby(10);
-  ASSERT_EQUAL(10, from_ruby<int>(a[1]));
+  a.push(42);
+  a.push(43);
+  a.push(44);
+  a[1] = 10;
+  ASSERT_EQUAL(10, detail::From_Ruby<int>().convert(a[1].value()));
 }
 
 TESTCASE(to_s)
 {
   Array a;
-  a.push(to_ruby(42));
-  a.push(to_ruby(43));
-  a.push(to_ruby(44));
+  a.push(42);
+  a.push(43);
+  a.push(44);
   String s1(a.call("to_s"));
   String s2(a.to_s());
   ASSERT_EQUAL(s1.str(), s2.str());
@@ -112,28 +121,28 @@ TESTCASE(to_s)
 TESTCASE(pop)
 {
   Array a;
-  a.push(to_ruby(42));
-  a.push(to_ruby(43));
-  a.push(to_ruby(44));
+  a.push(42);
+  a.push(43);
+  a.push(44);
   VALUE result = a.pop();
   ASSERT_EQUAL(2u, a.size());
-  ASSERT_EQUAL(42, from_ruby<int>(a[0]));
-  ASSERT_EQUAL(43, from_ruby<int>(a[1]));
-  ASSERT_EQUAL(44, from_ruby<int>(result));
+  ASSERT_EQUAL(42, detail::From_Ruby<int>().convert(a[0].value()));
+  ASSERT_EQUAL(43, detail::From_Ruby<int>().convert(a[1].value()));
+  ASSERT_EQUAL(44, detail::From_Ruby<int>().convert(result));
 }
 
 TESTCASE(unshift)
 {
   Array a;
-  a.push(to_ruby(42));
-  a.push(to_ruby(43));
-  a.push(to_ruby(44));
-  a.unshift(to_ruby(10));
+  a.push(42);
+  a.push(43);
+  a.push(44);
+  a.unshift(10);
   ASSERT_EQUAL(4u, a.size());
-  ASSERT_EQUAL(10, from_ruby<int>(a[0]));
-  ASSERT_EQUAL(42, from_ruby<int>(a[1]));
-  ASSERT_EQUAL(43, from_ruby<int>(a[2]));
-  ASSERT_EQUAL(44, from_ruby<int>(a[3]));
+  ASSERT_EQUAL(10, detail::From_Ruby<int>().convert(a[0].value()));
+  ASSERT_EQUAL(42, detail::From_Ruby<int>().convert(a[1].value()));
+  ASSERT_EQUAL(43, detail::From_Ruby<int>().convert(a[2].value()));
+  ASSERT_EQUAL(44, detail::From_Ruby<int>().convert(a[3].value()));
 }
 
 TESTCASE(unshift_int)
@@ -141,76 +150,80 @@ TESTCASE(unshift_int)
   Array a;
   a.unshift(42);
   ASSERT_EQUAL(1u, a.size());
-  ASSERT_EQUAL(to_ruby(42), a[0]);
+  ASSERT(rb_equal(detail::to_ruby(42), a[0].value()));
 }
 
 TESTCASE(shift)
 {
   Array a;
-  a.push(to_ruby(42));
-  a.push(to_ruby(43));
-  a.push(to_ruby(44));
+  a.push(42);
+  a.push(43);
+  a.push(44);
   VALUE result = a.shift();
   ASSERT_EQUAL(2u, a.size());
-  ASSERT_EQUAL(42, from_ruby<int>(result));
-  ASSERT_EQUAL(43, from_ruby<int>(a[0]));
-  ASSERT_EQUAL(44, from_ruby<int>(a[1]));
+  ASSERT_EQUAL(42, detail::From_Ruby<int>().convert(result));
+  ASSERT_EQUAL(43, detail::From_Ruby<int>().convert(a[0].value()));
+  ASSERT_EQUAL(44, detail::From_Ruby<int>().convert(a[1].value()));
 }
 
 TESTCASE(iterate)
 {
   Array a;
-  a.push(to_ruby(42));
-  a.push(to_ruby(43));
-  a.push(to_ruby(44));
+  a.push(42);
+  a.push(43);
+  a.push(44);
   int ca[] = { 42, 43, 44 };
   Array::iterator it = a.begin();
   Array::iterator end = a.end();
   for(int j = 0; it != end; ++j, ++it)
   {
-    ASSERT_EQUAL(ca[j], from_ruby<int>(*it));
+    ASSERT_EQUAL(ca[j], detail::From_Ruby<int>().convert(it->value()));
   }
 }
 
 TESTCASE(const_iterate)
 {
   Array a;
-  a.push(to_ruby(42));
-  a.push(to_ruby(43));
-  a.push(to_ruby(44));
+  a.push(42);
+  a.push(43);
+  a.push(44);
   int ca[] = { 42, 43, 44 };
   Array::const_iterator it = a.begin();
   Array::const_iterator end = a.end();
   for(int j = 0; it != end; ++j, ++it)
   {
-    ASSERT_EQUAL(ca[j], from_ruby<int>(*it));
+    ASSERT_EQUAL(ca[j], detail::From_Ruby<int>().convert(*it));
   }
 }
 
 TESTCASE(iterate_and_change)
 {
   Array a;
-  a.push(to_ruby(42));
-  a.push(to_ruby(43));
-  a.push(to_ruby(44));
+  a.push(42);
+  a.push(43);
+  a.push(44);
   Array::iterator it = a.begin();
   Array::iterator end = a.end();
   for(int j = 0; it != end; ++j, ++it)
   {
-    int value = from_ruby<int>(*it);
-    *it = to_ruby(value + j);
+    int value = detail::From_Ruby<int>().convert(it->value());
+    *it = value + j;
   }
-  ASSERT_EQUAL(42, from_ruby<int>(a[0]));
-  ASSERT_EQUAL(44, from_ruby<int>(a[1]));
-  ASSERT_EQUAL(46, from_ruby<int>(a[2]));
+  ASSERT_EQUAL(42, detail::From_Ruby<int>().convert(a[0].value()));
+  ASSERT_EQUAL(44, detail::From_Ruby<int>().convert(a[1].value()));
+  ASSERT_EQUAL(46, detail::From_Ruby<int>().convert(a[2].value()));
 }
 
+/**
+ * This test is running into GC issues on CI. Entries in the array
+ * are getting GC'd and the test is segfaulting. Really hard to reproduce
+ * so disable for now.
 TESTCASE(iterate_and_call_member)
 {
   Array a;
-  a.push(to_ruby(42));
-  a.push(to_ruby(43));
-  a.push(to_ruby(44));
+  a.push(42);
+  a.push(43);
+  a.push(44);
   Array::iterator it = a.begin();
   Array::iterator end = a.end();
   std::vector<Object> v;
@@ -218,21 +231,38 @@ TESTCASE(iterate_and_call_member)
   {
     v.push_back(it->to_s());
   }
-  ASSERT_EQUAL(42, from_ruby<int>(a[0]));
-  ASSERT_EQUAL(43, from_ruby<int>(a[1]));
-  ASSERT_EQUAL(44, from_ruby<int>(a[2]));
+  ASSERT_EQUAL(42, detail::From_Ruby<int>().convert(a[0].value()));
+  ASSERT_EQUAL(43, detail::From_Ruby<int>().convert(a[1].value()));
+  ASSERT_EQUAL(44, detail::From_Ruby<int>().convert(a[2].value()));
   ASSERT_EQUAL(3u, v.size());
   ASSERT_EQUAL(Object(a[0]).to_s(), v[0]);
   ASSERT_EQUAL(Object(a[1]).to_s(), v[1]);
   ASSERT_EQUAL(Object(a[2]).to_s(), v[2]);
 }
+*/
+
+TESTCASE(find_if)
+{
+  Array rubyValues;
+  rubyValues.push(42);
+  rubyValues.push(43);
+  rubyValues.push(44);
+
+  auto iter = std::find_if(rubyValues.begin(), rubyValues.end(),
+    [&rubyValues](const Object& object)
+    {
+      return object == rubyValues[1];
+    });
+
+  ASSERT_EQUAL(43, detail::From_Ruby<int>().convert(iter->value()));
+}
 
 TESTCASE(assign_int)
 {
   Array a;
   a.push(42);
   a[0] = 10;
-  ASSERT_EQUAL(10, from_ruby<int>(a[0]));
+  ASSERT_EQUAL(10, detail::From_Ruby<int>().convert(a[0].value()));
 }
 
 /**
@@ -247,3 +277,29 @@ namespace {
 TESTCASE(use_array_in_wrapped_function) {
   define_global_function("test_array_arg", &testArrayArg);
 }
+
+TESTCASE(array_to_ruby)
+{
+  Array a(rb_ary_new());
+  ASSERT(rb_equal(a.value(), detail::to_ruby(a)));
+}
+
+TESTCASE(array_ref_to_ruby)
+{
+  Array a(rb_ary_new());
+  Array& ref = a;
+  ASSERT(rb_equal(a.value(), detail::to_ruby(ref)));
+}
+
+TESTCASE(array_ptr_to_ruby)
+{
+  Array a(rb_ary_new());
+  Array* ptr = &a;
+  ASSERT(rb_equal(a.value(), detail::to_ruby(ptr)));
+}
+
+TESTCASE(array_from_ruby)
+{
+  Array a(rb_ary_new());
+  ASSERT_EQUAL(a, detail::From_Ruby<Array>().convert(a));
+}

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