rice 4.3.3 → 4.6.0

data/test/test_Attribute.cpp

@@ -14,12 +14,23 @@ SETUP(Attribute)
   embed_ruby();
 }
 
+TEARDOWN(Attribute)
+{
+  Rice::detail::Registries::instance.types.clearUnverifiedTypes();
+  rb_gc_start();
+}
+
 namespace
 {
   class SomeClass
   {
   };
 
+  class NotAssignable
+  {
+    NotAssignable& operator=(const NotAssignable&) = delete;
+  };
+
   struct DataStruct
   {
     static inline float staticFloat = 1.0;
@@ -29,7 +40,9 @@ namespace
     std::string readWriteString = "Read Write";
     int writeInt = 0;
     const char* readChars = "Read some chars!";
+    const int constInt = 5;
     SomeClass someClass;
+    NotAssignable notAssignable;
 
     std::string inspect()
     {
@@ -40,6 +53,21 @@ namespace
   bool globalBool = true;
   const DataStruct* globalStruct = new DataStruct();
 
+  class VecStruct
+  {
+  public:
+    std::vector<double> vector;
+
+    VecStruct(std::vector<double> aVector) : vector(aVector)
+    {
+    }
+
+    size_t vecSize()
+    {
+      return this->vector.size();
+    }
+  };
+
 } // namespace
 
 TESTCASE(attributes)
@@ -57,21 +85,28 @@ TESTCASE(attributes)
   // 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(std::string(ex.what()).find("undefined method `read_char='") == 0)
-  );
 
+  if constexpr (!oldRuby)
+  {
+    ASSERT_EXCEPTION_CHECK(
+      Exception,
+      o.call("read_char=", "some text"),
+      ASSERT(std::string(ex.what()).find("undefined method `read_char='") == 0)
+    );
+  }
   // 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(std::string(ex.what()).find("undefined method `write_int'") == 0)
-  );
+
+  if constexpr (!oldRuby)
+  {
+    ASSERT_EXCEPTION_CHECK(
+      Exception,
+      o.call("write_int", 3),
+      ASSERT(std::string(ex.what()).find("undefined method `write_int'") == 0)
+    );
+  }
 
   // Test readwrite attribute
   result = o.call("read_write_string=", "Set a string");
@@ -82,6 +117,66 @@ TESTCASE(attributes)
   ASSERT_EQUAL("Set a string", detail::From_Ruby<std::string>().convert(result.value()));
 }
 
+TESTCASE(vector)
+{
+  // See https ://github.com/ruby-rice/rice/issues/283
+  Module m = define_module("Testing");
+
+  define_class<VecStruct>("VecStruct")
+    .define_constructor(Constructor<VecStruct, std::vector<double>>())
+    .define_attr("vector", &VecStruct::vector, Rice::AttrAccess::Read)
+    .define_method("vector_size", &VecStruct::vecSize);
+
+  std::string code = R"(struct = VecStruct.new([1, 2])
+                        # Access the attribute
+                        array =  struct.vector.to_a
+                        struct.vector_size)";
+
+  Object result = m.module_eval(code);
+  ASSERT_EQUAL(2, detail::From_Ruby<int>().convert(result));
+}
+
+TESTCASE(const_attribute)
+{
+  Class c = define_class<DataStruct>("DataStruct")
+    .define_constructor(Constructor<DataStruct>())
+    .define_attr("const_int", &DataStruct::constInt);
+
+  Data_Object<DataStruct> o = c.call("new");
+
+  if constexpr (!oldRuby)
+  {
+    ASSERT_EXCEPTION_CHECK(
+      Exception,
+      o.call("const_int=", 5),
+      ASSERT(std::string(ex.what()).find("undefined method `const_int='") == 0)
+    );
+  }
+}
+
+TESTCASE(not_copyable_attribute)
+{
+  Class notAssignableClass = define_class<NotAssignable>("NotAssignable")
+    .define_constructor(Constructor<NotAssignable>());
+    
+  Class c = define_class<DataStruct>("DataStruct")
+    .define_constructor(Constructor<DataStruct>())
+    .define_attr("not_assignable", &DataStruct::notAssignable);
+
+  Data_Object<NotAssignable> notAssignable = notAssignableClass.call("new");
+
+  Data_Object<DataStruct> o = c.call("new");
+  
+  if constexpr (!oldRuby)
+  {
+    ASSERT_EXCEPTION_CHECK(
+      Exception,
+      o.call("not_assignable=", notAssignable),
+      ASSERT(std::string(ex.what()).find("undefined method `not_assignable='") == 0)
+    );
+  }
+}
+
 TESTCASE(static_attributes)
 {
   Class c = define_class<DataStruct>("DataStruct")
@@ -98,11 +193,15 @@ TESTCASE(static_attributes)
 
   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(std::string(ex.what()).find("undefined method `static_string='") == 0)
-  );
+
+  if constexpr (!oldRuby)
+  {
+    ASSERT_EXCEPTION_CHECK(
+      Exception,
+      c.call("static_string=", true),
+      ASSERT(std::string(ex.what()).find("undefined method `static_string='") == 0)
+    );
+  }
 }
 
 TESTCASE(global_attributes)
@@ -128,20 +227,36 @@ 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";
+  const char* message = "The following types are not registered with Rice:\n  class `anonymous namespace'::SomeClass\n";
 #else
-  const char* message = "Type is not defined with Rice: (anonymous namespace)::SomeClass";
+  const char* message = "The following types are not registered with Rice:\n  (anonymous namespace)::SomeClass\n";
 #endif
 
+  c.define_singleton_attr("some_class_static", &DataStruct::someClassStatic);
+
   ASSERT_EXCEPTION_CHECK(
     std::invalid_argument,
-    c.define_singleton_attr("some_class_static", &DataStruct::someClassStatic),
+    Rice::detail::Registries::instance.types.validateTypes(),
     ASSERT_EQUAL(message, ex.what())
   );
 
+#ifdef _MSC_VER
+  message = "Type is not registered with Rice: class `anonymous namespace'::SomeClass";
+#else
+  message = "Type is not registered with Rice: (anonymous namespace)::SomeClass";
+#endif
+
   ASSERT_EXCEPTION_CHECK(
-    std::invalid_argument,
-    c.define_attr("some_class", &DataStruct::someClass),
+    Rice::Exception,
+    c.call("some_class_static"),
     ASSERT_EQUAL(message, ex.what())
   );
-}
+
+  c.define_attr("some_class", &DataStruct::someClass);
+  Object o = c.call("new");
+  ASSERT_EXCEPTION_CHECK(
+    Rice::Exception,
+    o.call("some_class"),
+    ASSERT_EQUAL(message, ex.what())
+  );
+}

data/test/test_Buffer.cpp

@@ -0,0 +1,285 @@
+#include "unittest.hpp"
+#include "embed_ruby.hpp"
+#include <rice/rice.hpp>
+
+#include <limits>
+#include <cmath>
+
+using namespace Rice;
+
+TESTSUITE(Buffer);
+
+SETUP(Buffer)
+{
+  embed_ruby();
+}
+
+TEARDOWN(Buffer)
+{
+  rb_gc_start();
+}
+
+TESTCASE(Char)
+{
+  define_buffer<char>();
+
+  Module m = define_module("BufferTesting");
+
+  std::string code = R"(Rice::Buffer≺char≻.new("my string"))";
+  Object result = m.instance_eval(code);
+
+  ASSERT_EQUAL("Rice::Buffer≺char≻", result.class_name().c_str());
+  ASSERT_EQUAL("my string", String(result.call("bytes")).c_str());
+
+  Array array = result.call("to_ary");
+  ASSERT_EQUAL("109, 121, 32, 115, 116, 114, 105, 110, 103", array.join(", ").c_str());
+
+  Object size = result.call("size");
+  ASSERT_EQUAL(9, detail::From_Ruby<int>().convert(size));
+
+  Data_Object<Buffer<char>> dataObject(result);
+  Buffer<char> buffer = std::move(*dataObject);
+  ASSERT_EQUAL("my string", buffer.ptr());
+  ASSERT_EQUAL(9, (int)buffer.size());
+}
+
+TESTCASE(CharArray)
+{
+  define_buffer<char>();
+
+  Module m = define_module("BufferTesting");
+
+  std::string code = R"(Rice::Buffer≺char≻.new([0, 127, 128, 255, 256, -128, -129, -255]))";
+  Data_Object<Buffer<char>> result = m.instance_eval(code);
+  Buffer<char> buffer = std::move(*result);
+  char* data = buffer.ptr();
+
+  ASSERT_EQUAL(data[0], 0);
+  ASSERT_EQUAL(data[1], 127);
+  ASSERT_EQUAL(data[2], -128);
+  ASSERT_EQUAL(data[3], -1);
+  ASSERT_EQUAL(data[4], 0);
+  ASSERT_EQUAL(data[5], -128);
+  ASSERT_EQUAL(data[6], 127);
+  ASSERT_EQUAL(data[7], 1);
+}
+
+TESTCASE(signed_char_pointer)
+{
+  define_buffer<signed char>();
+  Module m = define_module("Testing");
+
+  std::string code = R"(Rice::Buffer≺signed char≻.new("my string"))";
+  Data_Object<Buffer<signed char>> result = m.instance_eval(code);
+  Buffer<signed char> buffer = std::move(*result);
+  signed char* data = buffer.ptr();
+
+  signed char* expected = (signed char*)"my string";
+  ASSERT_EQUAL(*expected, *data);
+
+  code = R"(Rice::Buffer≺signed char≻.new([0, 127, 128, 255, 256, -128, -129, -255]))";
+  result = m.instance_eval(code);
+  buffer = std::move(*result);
+  data = buffer.ptr();
+
+  ASSERT_EQUAL(data[0], 0);
+  ASSERT_EQUAL(data[1], 127);
+  ASSERT_EQUAL(data[2], -128);
+  ASSERT_EQUAL(data[3], -1);
+  ASSERT_EQUAL(data[4], 0);
+  ASSERT_EQUAL(data[5], -128);
+  ASSERT_EQUAL(data[6], 127);
+  ASSERT_EQUAL(data[7], 1);
+}
+
+TESTCASE(char_pointer_const)
+{
+  define_buffer<char>();
+  Module m = define_module("Testing");
+
+  std::string code = R"(Rice::Buffer≺char≻.new("my string"))";
+
+  Data_Object<Buffer<char>> result = m.instance_eval(code);
+  Buffer<char> buffer = std::move(*result);
+  char* data = buffer.ptr();
+
+  const char* expected = "my string";
+  ASSERT_EQUAL(expected, data);
+
+  code = R"(Rice::Buffer≺char≻.new(""))";
+  result = m.instance_eval(code);
+  buffer = std::move(*result);
+  data = buffer.ptr();
+
+  expected = "";
+  ASSERT_EQUAL(expected, data);
+}
+
+TESTCASE(unsigned_char_pointer)
+{
+  define_buffer<unsigned char>();
+  Module m = define_module("Testing");
+
+  std::string code = R"(Rice::Buffer≺unsigned char≻.new([0, 127, 128, 255, 256, -128, -129, -255]))";
+  Data_Object<Buffer<unsigned char>> result = m.instance_eval(code);
+  Buffer<unsigned char> buffer = std::move(*result);
+  unsigned char* data = buffer.ptr();
+
+  ASSERT_EQUAL(data[0], 0x0);
+  ASSERT_EQUAL(data[1], 0x7F);
+  ASSERT_EQUAL(data[2], 0x80);
+  ASSERT_EQUAL(data[3], 0xFF);
+  ASSERT_EQUAL(data[4], 0x00);
+  ASSERT_EQUAL(data[5], 0x80);
+  ASSERT_EQUAL(data[6], 0x7F);
+  ASSERT_EQUAL(data[7], 0x01);
+
+  code = R"(array = [0, 127, 128, 255, 256, -128, -129, -255]
+              packed = array.pack("C*")
+              Rice::Buffer≺unsigned char≻.new(packed))";
+  result = m.instance_eval(code);
+  buffer = std::move(*result);
+  data = buffer.ptr();
+
+  ASSERT_EQUAL(data[0], 0x0);
+  ASSERT_EQUAL(data[1], 0x7F);
+  ASSERT_EQUAL(data[2], 0x80);
+  ASSERT_EQUAL(data[3], 0xFF);
+  ASSERT_EQUAL(data[4], 0x00);
+  ASSERT_EQUAL(data[5], 0x80);
+  ASSERT_EQUAL(data[6], 0x7F);
+  ASSERT_EQUAL(data[7], 0x01);
+}
+
+TESTCASE(float_array_array)
+{
+  define_buffer<float*>();
+  Module m = define_module("Testing");
+
+  std::string code = R"(Rice::Buffer≺float∗≻.new([[1.1, 2.2], [3.3, 4.4], [5.5, 6.6]]))";
+  Data_Object<Buffer<float*>> result = m.instance_eval(code);
+  Buffer<float*> buffer = std::move(*result);
+
+  ASSERT_EQUAL(3, (int)buffer.size());
+
+  const Buffer<float>& bufferInner1 = buffer[0];
+  ASSERT_EQUAL(2, (int)bufferInner1.size());
+
+  const Buffer<float>& bufferInner2 = buffer[1];
+  ASSERT_EQUAL(2, (int)bufferInner2.size());
+
+  const Buffer<float>& bufferInner3 = buffer[2];
+  ASSERT_EQUAL(2, (int)bufferInner3.size());
+}
+
+TESTCASE(wrong_type)
+{
+  define_buffer<float*>();
+  Module m = define_module("Testing");
+
+  std::string code = R"(Rice::Buffer≺float∗≻.new([[4, "bad"], [2, 1]]))";
+
+  ASSERT_EXCEPTION_CHECK(
+    Exception,
+    m.module_eval(code),
+    ASSERT_EQUAL("can't convert String into Float", ex.what())
+  );
+}
+
+namespace
+{
+  void updateRef(int& ref)
+  {
+    ref = 4;
+  }
+
+  void updatePtr(int* ptr)
+  {
+    *ptr = 5;
+  }
+}
+
+TESTCASE(update_reference)
+{
+  define_buffer<int>();
+  Module m = define_module("Testing");
+  m.define_module_function("update_reference", &updateRef);
+
+  std::string code = R"(buffer = Rice::Buffer≺int≻.new(0)
+                        update_reference(buffer)
+                        buffer.to_ary(1).first)";
+
+  Object result = m.module_eval(code);
+  ASSERT_EQUAL(4, detail::From_Ruby<int>().convert(result));
+
+  code = R"(buffer = Rice::Buffer≺int≻.new(0)
+            update_reference(buffer)
+            buffer[0])";
+
+  result = m.module_eval(code);
+  ASSERT_EQUAL(4, detail::From_Ruby<int>().convert(result));
+
+  code = R"(buffer = Rice::Buffer≺int≻.new(0)
+            update_reference(buffer)
+            buffer[1])";
+
+  ASSERT_EXCEPTION_CHECK(
+    Exception,
+    m.module_eval(code),
+    ASSERT_EQUAL("index 1 outside of bounds: 0..1", ex.what())
+  );
+}
+
+TESTCASE(update_ptr)
+{
+  define_buffer<int>();
+  Module m = define_module("Testing");
+  m.define_module_function("update_pointer", &updatePtr);
+
+  std::string code = R"(buffer = Rice::Buffer≺int≻.new(0)
+                        update_pointer(buffer)
+                        buffer.to_ary(1).first)";
+
+  Object result = m.module_eval(code);
+  ASSERT_EQUAL(5, detail::From_Ruby<int>().convert(result));
+
+  code = R"(buffer = Rice::Buffer≺int≻.new(0)
+            update_pointer(buffer)
+            buffer[0])";
+
+  result = m.module_eval(code);
+  ASSERT_EQUAL(5, detail::From_Ruby<int>().convert(result));
+
+  code = R"(buffer = Rice::Buffer≺int≻.new(0)
+            update_pointer(buffer)
+            buffer[1])";
+
+  ASSERT_EXCEPTION_CHECK(
+    Exception,
+    m.module_eval(code),
+    ASSERT_EQUAL("index 1 outside of bounds: 0..1", ex.what())
+  );
+}
+
+TESTCASE(update_buffer)
+{
+  define_buffer<int>();
+  Module m = define_module("Testing");
+
+  std::string code = R"(buffer = Rice::Buffer≺int≻.new(0)
+                        buffer[0] = 8
+                        buffer[0])";
+
+  Object result = m.module_eval(code);
+  ASSERT_EQUAL(8, detail::From_Ruby<int>().convert(result));
+
+  code = R"(buffer = Rice::Buffer≺int≻.new(0)
+            buffer[1] = 9
+            buffer[1])";
+
+  ASSERT_EXCEPTION_CHECK(
+    Exception,
+    m.module_eval(code),
+    ASSERT_EQUAL("index 1 outside of bounds: 0..1", ex.what())
+  );
+}

data/test/test_Builtin_Object.cpp

@@ -11,6 +11,11 @@ SETUP(Builtin_Object)
   embed_ruby();
 }
 
+TEARDOWN(Builtin_Object)
+{
+  rb_gc_start();
+}
+
 TESTCASE(construct_with_object)
 {
   Class c(rb_cObject);