rice 4.9.0 → 4.9.1

data/test/test_Stl_Vector.cpp

@@ -16,6 +16,7 @@ SETUP(Vector)
 
 TEARDOWN(Vector)
 {
+  Rice::detail::Registries::instance.natives.reset(rb_mKernel);
   rb_gc_start();
 }
 
@@ -40,7 +41,7 @@ Class makeVectorClass()
 
   return c;
 }
-
+/*
 TESTCASE(StringVector)
 {
   Module m = define_module("Testing");
@@ -215,7 +216,7 @@ TESTCASE(Indexing)
   vec.call("push", 0);
   vec.call("push", 1);
   vec.call("push", 2);
-  
+
   Object result = vec.call("size");
   ASSERT_EQUAL(3, detail::From_Ruby<int32_t>().convert(result));
 
@@ -520,7 +521,7 @@ TESTCASE(NotDefaultConstructable)
 {
   define_class<NotComparable>("NotComparable").
     define_constructor(Constructor<NotComparable, uint32_t>());
-    
+
   Class c = define_vector<NotComparable>("NotComparableVector");
   Object vec = c.call("new");
 
@@ -579,7 +580,7 @@ TESTCASE(Comparable)
   Class c = define_vector<Comparable>("ComparableVector");
 
   Object vec = c.call("new");
-  
+
   Comparable comparable1(1);
   vec.call("push", comparable1);
 
@@ -818,7 +819,7 @@ TESTCASE(DefaultValue)
 TESTCASE(ToArray)
 {
   Module m = define_module("Testing");
-  
+
   Class c = define_vector<std::string>("StringVector").
     define_constructor(Constructor<std::vector<std::string>>());
 
@@ -992,13 +993,7 @@ namespace
   public:
     static inline std::vector<std::string> instance_{ "one", "two", "three" };
   };
-
- /* std::ostream& operator<<(std::ostream& stream, const std::vector<std::string>& vector)
-  {
-    stream << vector;
-    return stream;
-  }*/
-
+  
   void createFactoryClass()
   {
     define_class<Factory>("Factory").
@@ -1149,7 +1144,7 @@ TESTCASE(StringPointerVector)
   ASSERT_EQUAL(1, array.size());
   ASSERT_EQUAL("World", detail::From_Ruby<std::string>().convert(array[0].value()).c_str());
 }
-
+*/
 namespace
 {
   class MyClass2
@@ -1186,6 +1181,81 @@ TESTCASE(MyClass2PointerVector)
  ASSERT_EQUAL("Hello MyClass2", pMyClass->name);
 }
 
+TESTCASE(KeepAliveArrayConstructor)
+{
+  Class c = define_class<MyClass2>("MyClass2").
+    define_constructor(Constructor<MyClass2, std::string>()).
+    define_attr("name", &MyClass2::name, AttrAccess::Read);
+
+  define_vector<MyClass2*>("MyClass2PointerVector");
+
+  Module m = define_module("Testing");
+
+  std::string code = R"(
+    array = []
+    3.times do |i|
+      array << MyClass2.new("instance#{i + 1}")
+    end
+
+    vector = Std::MyClass2PointerVector.new(array)
+    array = nil
+    GC.start
+
+    names = []
+    vector.each do |instance|
+      names << instance.name
+    end
+    names
+  )";
+
+  Array result = m.module_eval(code);
+  ASSERT_EQUAL(3, result.size());
+  ASSERT_EQUAL("instance1", detail::From_Ruby<std::string>().convert(result[0].value()));
+  ASSERT_EQUAL("instance2", detail::From_Ruby<std::string>().convert(result[1].value()));
+  ASSERT_EQUAL("instance3", detail::From_Ruby<std::string>().convert(result[2].value()));
+}
+
+TESTCASE(KeepAlive)
+{
+  Class c = define_class<MyClass2>("MyClass2").
+    define_constructor(Constructor<MyClass2, std::string>()).
+    define_attr("name", &MyClass2::name, AttrAccess::Read);
+
+  define_vector<MyClass2*>("MyClass2PointerVector");
+
+  Module m = define_module("Testing");
+
+  std::string code = R"(
+    vector = Std::MyClass2PointerVector.new
+
+    # Test push_back
+    3.times do |i|
+      vector.push(MyClass2.new("instance#{i + 1}"))
+    end
+
+    # Test insert
+    vector.insert(1, MyClass2.new("inserted"))
+
+    # Test []=
+    vector[0] = MyClass2.new("replaced")
+
+    GC.start
+
+    names = []
+    vector.each do |instance|
+      names << instance.name
+    end
+    names
+  )";
+
+  Array result = m.module_eval(code);
+  ASSERT_EQUAL(4, result.size());
+  ASSERT_EQUAL("replaced", detail::From_Ruby<std::string>().convert(result[0].value()));
+  ASSERT_EQUAL("inserted", detail::From_Ruby<std::string>().convert(result[1].value()));
+  ASSERT_EQUAL("instance2", detail::From_Ruby<std::string>().convert(result[2].value()));
+  ASSERT_EQUAL("instance3", detail::From_Ruby<std::string>().convert(result[3].value()));
+}
+
 namespace
 {
   bool typeCheckValue(std::vector<std::string>)
@@ -1253,3 +1323,60 @@ TESTCASE(TypeCheck)
     result = m.module_eval(code),
     ASSERT_EQUAL("wrong argument type Std::Vector≺int≻ (expected Std::Vector≺string≻)", ex.what()));
 }
+
+namespace
+{
+  class ClassA
+  {
+  public:
+    ClassA() = default;
+  };
+
+  class ClassB
+  {
+  public:
+    ClassB() = default;
+  };
+
+  std::string vectorOverload(std::vector<ClassA>&)
+  {
+    return "ClassA";
+  }
+
+  std::string vectorOverload(std::vector<ClassB>&)
+  {
+    return "ClassB";
+  }
+}
+
+TESTCASE(VectorOverloadResolution)
+{
+  define_class<ClassA>("ClassA").
+    define_constructor(Constructor<ClassA>());
+
+  define_class<ClassB>("ClassB").
+    define_constructor(Constructor<ClassB>());
+
+  define_global_function<std::string(*)(std::vector<ClassA>&)>("vector_overload", &vectorOverload);
+  define_global_function<std::string(*)(std::vector<ClassB>&)>("vector_overload", &vectorOverload);
+
+  Module m = define_module("Testing");
+
+  // When passing array with ClassA instance, should call ClassA overload
+  std::string code = R"(
+    a = ClassA.new
+    vector_overload([a])
+  )";
+
+  Object result = m.module_eval(code);
+  ASSERT_EQUAL("ClassA", detail::From_Ruby<std::string>().convert(result));
+
+  // When passing array with ClassB instance, should call ClassB overload
+  code = R"(
+    b = ClassB.new
+    vector_overload([b])
+  )";
+
+  result = m.module_eval(code);
+  ASSERT_EQUAL("ClassB", detail::From_Ruby<std::string>().convert(result));
+}

data/test/test_Tracking.cpp

@@ -50,7 +50,10 @@ namespace
 
     MyClass moveValue()
     {
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wpessimizing-move"
       return std::move(MyClass());
+#pragma GCC diagnostic pop
     }
 
     MyClass* instance()

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: rice
 version: !ruby/object:Gem::Version
-  version: 4.9.0
+  version: 4.9.1
 platform: ruby
 authors:
 - Paul Brannan