rice 4.6.1 → 4.7.0

data/test/test_Array.cpp

@@ -74,7 +74,7 @@ TESTCASE(push_no_items)
 TESTCASE(push_one_item)
 {
   Array a;
-  a.push(Rice::True);
+  a.push(Rice::True, false);
   ASSERT_EQUAL(1, a.size());
   ASSERT_EQUAL(Qtrue, a[0]);
 }
@@ -82,8 +82,8 @@ TESTCASE(push_one_item)
 TESTCASE(push_two_items)
 {
   Array a;
-  a.push(42);
-  a.push(43);
+  a.push(42, false);
+  a.push(43, false);
   ASSERT_EQUAL(2, a.size());
   ASSERT_EQUAL(42, detail::From_Ruby<int>().convert(a[0].value()));
   ASSERT_EQUAL(43, detail::From_Ruby<int>().convert(a[1].value()));
@@ -92,9 +92,9 @@ TESTCASE(push_two_items)
 TESTCASE(push_three_items)
 {
   Array a;
-  a.push(42);
-  a.push(43);
-  a.push(44);
+  a.push(42, false);
+  a.push(43, false);
+  a.push(44, false);
   ASSERT_EQUAL(3, a.size());
   ASSERT_EQUAL(42, detail::From_Ruby<int>().convert(a[0].value()));
   ASSERT_EQUAL(43, detail::From_Ruby<int>().convert(a[1].value()));
@@ -104,7 +104,7 @@ TESTCASE(push_three_items)
 TESTCASE(push_int)
 {
   Array a;
-  a.push(42);
+  a.push(42, false);
   ASSERT_EQUAL(1, a.size());
   ASSERT(rb_equal(detail::to_ruby(42), a[0].value()));
 }
@@ -112,9 +112,9 @@ TESTCASE(push_int)
 TESTCASE(bracket_equals)
 {
   Array a;
-  a.push(42);
-  a.push(43);
-  a.push(44);
+  a.push(42, false);
+  a.push(43, false);
+  a.push(44, false);
   a[1] = 10;
   ASSERT_EQUAL(10, detail::From_Ruby<int>().convert(a[1].value()));
 }
@@ -122,9 +122,9 @@ TESTCASE(bracket_equals)
 TESTCASE(to_s)
 {
   Array a;
-  a.push(42);
-  a.push(43);
-  a.push(44);
+  a.push(42, false);
+  a.push(43, false);
+  a.push(44, false);
   String s1(a.call("to_s"));
   String s2(a.to_s());
   ASSERT_EQUAL(s1.str(), s2.str());
@@ -133,9 +133,9 @@ TESTCASE(to_s)
 TESTCASE(pop)
 {
   Array a;
-  a.push(42);
-  a.push(43);
-  a.push(44);
+  a.push(42, false);
+  a.push(43, false);
+  a.push(44, false);
   VALUE result = a.pop();
   ASSERT_EQUAL(2, a.size());
   ASSERT_EQUAL(42, detail::From_Ruby<int>().convert(a[0].value()));
@@ -146,9 +146,9 @@ TESTCASE(pop)
 TESTCASE(unshift)
 {
   Array a;
-  a.push(42);
-  a.push(43);
-  a.push(44);
+  a.push(42, false);
+  a.push(43, false);
+  a.push(44, false);
   a.unshift(10);
   ASSERT_EQUAL(4, a.size());
   ASSERT_EQUAL(10, detail::From_Ruby<int>().convert(a[0].value()));
@@ -168,9 +168,9 @@ TESTCASE(unshift_int)
 TESTCASE(shift)
 {
   Array a;
-  a.push(42);
-  a.push(43);
-  a.push(44);
+  a.push(42, false);
+  a.push(43, false);
+  a.push(44, false);
   VALUE result = a.shift();
   ASSERT_EQUAL(2, a.size());
   ASSERT_EQUAL(42, detail::From_Ruby<int>().convert(result));
@@ -181,9 +181,9 @@ TESTCASE(shift)
 TESTCASE(iterate)
 {
   Array a;
-  a.push(42);
-  a.push(43);
-  a.push(44);
+  a.push(42, false);
+  a.push(43, false);
+  a.push(44, false);
   int ca[] = { 42, 43, 44 };
   Array::iterator it = a.begin();
   Array::iterator end = a.end();
@@ -196,9 +196,9 @@ TESTCASE(iterate)
 TESTCASE(const_iterate)
 {
   Array a;
-  a.push(42);
-  a.push(43);
-  a.push(44);
+  a.push(42, false);
+  a.push(43, false);
+  a.push(44, false);
   int ca[] = { 42, 43, 44 };
   Array::const_iterator it = a.begin();
   Array::const_iterator end = a.end();
@@ -211,9 +211,9 @@ TESTCASE(const_iterate)
 TESTCASE(iterate_and_change)
 {
   Array a;
-  a.push(42);
-  a.push(43);
-  a.push(44);
+  a.push(42, false);
+  a.push(43, false);
+  a.push(44, false);
   Array::iterator it = a.begin();
   Array::iterator end = a.end();
   for(int j = 0; it != end; ++j, ++it)
@@ -229,9 +229,9 @@ TESTCASE(iterate_and_change)
 TESTCASE(iterate_and_call_member)
 {
   Array a;
-  a.push(42);
-  a.push(43);
-  a.push(44);
+  a.push(42, false);
+  a.push(43, false);
+  a.push(44, false);
   Array::iterator it = a.begin();
   Array::iterator end = a.end();
   std::vector<Object> v;
@@ -251,9 +251,9 @@ TESTCASE(iterate_and_call_member)
 TESTCASE(find_if)
 {
   Array rubyValues;
-  rubyValues.push(42);
-  rubyValues.push(43);
-  rubyValues.push(44);
+  rubyValues.push(42, false);
+  rubyValues.push(43, false);
+  rubyValues.push(44, false);
 
   auto iter = std::find_if(rubyValues.begin(), rubyValues.end(),
     [&rubyValues](const Object& object)
@@ -267,7 +267,7 @@ TESTCASE(find_if)
 TESTCASE(assign_int)
 {
   Array a;
-  a.push(42);
+  a.push(42, false);
   a[0] = 10;
   ASSERT_EQUAL(10, detail::From_Ruby<int>().convert(a[0].value()));
 }

data/test/test_Attribute.cpp

@@ -1,4 +1,4 @@
-#include <assert.h>
+#include <assert.h>
 
 #include "unittest.hpp"
 #include "embed_ruby.hpp"
@@ -38,6 +38,18 @@ namespace
     NotCopyable(const NotCopyable& other) = delete;
   };
 
+  enum OldEnum
+  {
+    OldValue1,
+    OldValue2
+  };
+
+  enum class NewEnum
+  {
+    NewValue1,
+    NewValue2
+  };
+
   struct DataStruct
   {
     static inline float staticFloat = 1.0;
@@ -46,11 +58,15 @@ namespace
 
     std::string readWriteString = "Read Write";
     int writeInt = 0;
+    const char* chars = "Some chars!";
     const char* readChars = "Read some chars!";
     const int constInt = 5;
     SomeClass someClass;
     NotAssignable notAssignable;
     NotCopyable notCopyable;
+    char buf[2] = { '0', '1' };
+    OldEnum oldEnum = OldValue1;
+    NewEnum newEnum = NewEnum::NewValue1;
 
     std::string inspect()
     {
@@ -83,6 +99,7 @@ TESTCASE(attributes)
   Class c = define_class<DataStruct>("DataStruct")
     .define_constructor(Constructor<DataStruct>())
     .define_method("inspect", &DataStruct::inspect)
+    .define_attr("chars", &DataStruct::chars)
     .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);
@@ -90,8 +107,15 @@ TESTCASE(attributes)
   Object o = c.call("new");
   DataStruct* dataStruct = detail::From_Ruby<DataStruct*>().convert(o);
 
+  Object result = o.call("chars");
+  ASSERT_EQUAL("Some chars!", detail::From_Ruby<char*>().convert(result));
+  
+  o.call("chars=", "New chars!");
+  result = o.call("chars");
+  ASSERT_EQUAL("New chars!", detail::From_Ruby<char*>().convert(result));
+
   // Test readonly attribute
-  Object result = o.call("read_chars");
+  result = o.call("read_chars");
   ASSERT_EQUAL("Read some chars!", detail::From_Ruby<char*>().convert(result));
 
   if constexpr (!oldRuby)
@@ -125,6 +149,56 @@ TESTCASE(attributes)
   ASSERT_EQUAL("Set a string", detail::From_Ruby<std::string>().convert(result.value()));
 }
 
+TESTCASE(Enums)
+{
+  static Enum<OldEnum> oldEnum = define_enum<OldEnum>("OldEnum")
+    .define_value("OldValue1", OldValue1)
+    .define_value("OldValue2", OldValue2);
+
+  static Enum<NewEnum> newEnum = define_enum<NewEnum>("NewEnum")
+    .define_value("NewValue1", NewEnum::NewValue1)
+    .define_value("NewValue2", NewEnum::NewValue2);
+
+  Class c = define_class<DataStruct>("DataStruct")
+    .define_constructor(Constructor<DataStruct>())
+    .define_attr("oldEnum", &DataStruct::oldEnum)
+    .define_attr("newEnum", &DataStruct::newEnum);
+
+  Object o = c.call("new");
+  DataStruct* dataStruct = detail::From_Ruby<DataStruct*>().convert(o);
+  ASSERT_NOT_EQUAL(nullptr, dataStruct);
+
+  Object result = o.call("oldEnum");
+  ASSERT_EQUAL(OldValue1, detail::From_Ruby<OldEnum>().convert(result));
+
+  o.call("oldEnum=", OldValue2);
+  result = o.call("oldEnum");
+  ASSERT_EQUAL(OldValue2, detail::From_Ruby<OldEnum>().convert(result));
+
+  result = o.call("newEnum");
+  ASSERT_EQUAL(NewEnum::NewValue1, detail::From_Ruby<NewEnum>().convert(result));
+
+  o.call("newEnum=", NewEnum::NewValue2);
+  result = o.call("newEnum");
+  ASSERT_EQUAL(NewEnum::NewValue2, detail::From_Ruby<NewEnum>().convert(result));
+}
+
+TESTCASE(Array)
+{
+  Module m = define_module("Testing");
+
+  Class c = define_class<DataStruct>("DataStruct")
+    .define_constructor(Constructor<DataStruct>())
+    .define_attr("buf", &DataStruct::buf, Rice::AttrAccess::Read);
+
+  Object o = c.call("new");
+  DataStruct* dataStruct = detail::From_Ruby<DataStruct*>().convert(o);
+  ASSERT_NOT_EQUAL(nullptr, dataStruct);
+
+  Object result = o.call("buf");
+  ASSERT_EQUAL("01", detail::From_Ruby<std::string>().convert(result));
+}
+
 TESTCASE(vector)
 {
   // See https ://github.com/ruby-rice/rice/issues/283
@@ -308,4 +382,115 @@ TESTCASE(not_defined)
     o.call("some_class"),
     ASSERT_EQUAL(message, ex.what())
   );
+}
+
+namespace
+{
+  class Counter
+  {
+  public:
+    Counter() = default;
+
+    Counter(int i): value(i)
+    {
+    }
+
+    int value;
+  };
+
+  struct BufferAttrs
+  {
+    BufferAttrs() : stringArray{"one", "two", "three"}
+    {
+      this->buffer = new unsigned char[4]{'a', 'b', 'c', '\0'};
+      this->countersBuffer = new Counter[2]{ 0, 1 };
+    }
+
+    ~BufferAttrs()
+    {
+      delete[] this->buffer;
+      delete[] this->countersBuffer;
+    }
+
+    inline static float floatArray[3] = {1.0, 2.0, 3.0};
+    std::string stringArray[3];
+    unsigned char* buffer = nullptr;
+    Counter counters[2];
+    Counter* countersBuffer = nullptr;
+  };
+}
+
+TESTCASE(ArrayStaticAttribute)
+{
+  Module m = define_module("Testing");
+
+  Class c = define_class<BufferAttrs>("BufferAttrs")
+    .define_constructor(Constructor<BufferAttrs>())
+    .define_singleton_attr("floats", &BufferAttrs::floatArray, Rice::AttrAccess::Read);
+
+  std::string code = R"(BufferAttrs.floats.class)";
+  Class klass = (Class)m.module_eval(code);
+  ASSERT_EQUAL("Rice::Buffer≺float≻", klass.name().c_str());
+}
+
+TESTCASE(ArrayAttribute)
+{
+  Module m = define_module("Testing");
+
+  Class c = define_class<BufferAttrs>("BufferAttrs")
+    .define_constructor(Constructor<BufferAttrs>())
+    .define_attr("strings", &BufferAttrs::stringArray, Rice::AttrAccess::Read);
+
+  std::string code = R"(struct = BufferAttrs.new
+                        struct.strings.class)";
+  Class klass = (Class)m.module_eval(code);
+  ASSERT_EQUAL("Rice::Buffer≺string≻", klass.name().c_str());
+}
+
+TESTCASE(BufferAttribute)
+{
+  Module m = define_module("Testing");
+
+  Class c = define_class<BufferAttrs>("BufferAttrs")
+    .define_constructor(Constructor<BufferAttrs>())
+    .define_attr("buffer", &BufferAttrs::buffer, Rice::AttrAccess::Read, Return().setBuffer());
+
+  std::string code = R"(struct = BufferAttrs.new
+                        struct.buffer.class)";
+  Class klass = (Class)m.module_eval(code);
+  ASSERT_EQUAL("Rice::Pointer≺unsigned char≻", klass.name().c_str());
+}
+
+TESTCASE(CounterArrayAttribute)
+{
+  Module m = define_module("Testing");
+
+  define_class<Counter>("Counter")
+    .define_attr("value", &Counter::value, Rice::AttrAccess::Read);
+
+  define_class<BufferAttrs>("BufferAttrs")
+    .define_constructor(Constructor<BufferAttrs>())
+    .define_attr("counters", &BufferAttrs::counters, Rice::AttrAccess::Read);
+
+  std::string code = R"(struct = BufferAttrs.new
+                        struct.counters.class)";
+  Class klass = (Class)m.module_eval(code);
+  ASSERT_EQUAL("Rice::Buffer≺AnonymousNamespace꞉꞉Counter≻", klass.name().c_str());
+}
+
+TESTCASE(CounterBufferAttribute)
+{
+  Module m = define_module("Testing");
+
+  define_class<Counter>("Counter")
+    .define_attr("value", &Counter::value, Rice::AttrAccess::Read);
+
+  define_class<BufferAttrs>("BufferAttrs")
+    .define_constructor(Constructor<BufferAttrs>())
+    .define_attr("counters_buffer", &BufferAttrs::countersBuffer, Rice::AttrAccess::Read, Return().setBuffer());
+
+  std::string code = R"(struct = BufferAttrs.new
+                        struct.counters_buffer.class)";
+  Class klass = (Class)m.module_eval(code);
+  ASSERT_EQUAL("Rice::Pointer≺AnonymousNamespace꞉꞉Counter≻", klass.name().c_str());
 }