rice 4.2.1 → 4.3.0

data/test/test_Stl_SmartPointer.cpp

@@ -74,6 +74,15 @@ namespace
       return instance_;
     }
 
+    std::shared_ptr<MyClass>& share_ref()
+    {
+      if (!instance_)
+      {
+        instance_ = std::make_shared<MyClass>();
+      }
+      return instance_;
+    }
+
   public:
     static inline std::shared_ptr<MyClass> instance_;
   };
@@ -104,7 +113,8 @@ SETUP(SmartPointer)
   define_class<Factory>("Factory").
     define_constructor(Constructor<Factory>()).
     define_method("transfer", &Factory::transfer).
-    define_method("share", &Factory::share);
+    define_method("share", &Factory::share).
+    define_method("share_ref", &Factory::share_ref);
 
   define_global_function("extract_flag_unique_ptr_ref", &extractFlagUniquePtrRef);
   define_global_function("extract_flag_shared_ptr", &extractFlagSharedPtr);
@@ -152,8 +162,13 @@ TESTCASE(ShareOwnership)
                           my_class.set_flag(i)
                         end)";
 
+
+  ASSERT_EQUAL(0, Factory::instance_.use_count());
   m.module_eval(code);
+  
+  ASSERT_EQUAL(11, Factory::instance_.use_count());
   rb_gc_start();
+  ASSERT_EQUAL(1, Factory::instance_.use_count());
 
   ASSERT_EQUAL(1, MyClass::constructorCalls);
   ASSERT_EQUAL(0, MyClass::copyConstructorCalls);
@@ -162,6 +177,34 @@ TESTCASE(ShareOwnership)
   ASSERT_EQUAL(9, Factory::instance_->flag);
 }
 
+
+TESTCASE(ShareOwnership2)
+{
+  MyClass::reset();
+
+  Module m = define_module("TestingModule");
+
+  // Create ruby objects that point to the same instance of MyClass
+  std::string code = R"(factory = Factory.new
+                        10.times do |i|
+                          my_class = factory.share
+                          my_class.set_flag(i)
+                        end)";
+
+  Factory factory;
+  std::shared_ptr<MyClass> myClass = factory.share();
+  ASSERT_EQUAL(2, Factory::instance_.use_count());
+
+  // Call some ruby code
+  Data_Object<Factory> wrapper(factory);
+  ASSERT_EQUAL(2, Factory::instance_.use_count());
+  wrapper.instance_eval("self.share_ref.set_flag(1)");
+
+  ASSERT_EQUAL(3, Factory::instance_.use_count());
+  rb_gc_start();
+  ASSERT_EQUAL(2, Factory::instance_.use_count());
+}
+
 TESTCASE(UniquePtrRefParameter)
 {
   MyClass::reset();
@@ -237,4 +280,4 @@ TESTCASE(SharedPtrRefDefaultParameter)
   Object result = m.module_eval(code);
   // The default value kicks in and ignores any previous pointer
   ASSERT_EQUAL(0, detail::From_Ruby<int>().convert(result));
-}
+}

data/test/test_Stl_String_View.cpp

@@ -0,0 +1,88 @@
+#include "unittest.hpp"
+#include "embed_ruby.hpp"
+#include <rice/rice.hpp>
+#include <ruby/encoding.h>
+#include <rice/stl.hpp>
+
+#include <optional>
+
+using namespace Rice;
+
+TESTSUITE(StlStringView);
+
+SETUP(StlStringView)
+{
+  embed_ruby();
+}
+
+TESTCASE(std_string_view_to_ruby)
+{
+  ASSERT(rb_equal(String("").value(), detail::to_ruby(std::string_view(""))));
+  ASSERT(rb_equal(String("foo").value(), detail::to_ruby(std::string_view("foo"))));
+}
+
+TESTCASE(std_string_view_to_ruby_encoding)
+{
+  VALUE value = detail::to_ruby(std::string_view("Some String"));
+  String string(value);
+  Object encoding = string.call("encoding");
+  String encodingName = encoding.call("name");
+  std::string_view result = detail::From_Ruby<std::string_view>().convert(encodingName);
+  if(result != "ASCII-8BIT" && result != "US-ASCII" && result != "UTF-8") {
+    FAIL("Encoding incorrect", "ASCII-8BIT, US-ASCII, or UTF-8 (Windows)", result);
+  }
+}
+
+TESTCASE(std_string_view_to_ruby_encoding_utf8)
+{
+  rb_encoding* defaultEncoding = rb_default_external_encoding();
+  
+  VALUE utf8Encoding = rb_enc_from_encoding(rb_utf8_encoding());
+  rb_enc_set_default_external(utf8Encoding);
+
+  VALUE value = detail::to_ruby(std::string_view("Some String"));
+  Object object(value);
+  Object encoding = object.call("encoding");
+  Object encodingName = encoding.call("name");
+  ASSERT_EQUAL("UTF-8", detail::From_Ruby<std::string_view>().convert(encodingName));
+
+  rb_enc_set_default_external(rb_enc_from_encoding(defaultEncoding));
+}
+
+TESTCASE(std_string_view_from_ruby)
+{
+  ASSERT_EQUAL(std::string_view(""), detail::From_Ruby<std::string_view>().convert(rb_str_new2("")));
+  ASSERT_EQUAL(std::string_view("foo"), detail::From_Ruby<std::string_view>().convert(rb_str_new2("foo")));
+
+  ASSERT_EXCEPTION_CHECK(
+    Exception,
+    detail::From_Ruby<std::string_view>().convert(rb_float_new(15.512)),
+    ASSERT_EQUAL("wrong argument type Float (expected String)", ex.what())
+  );
+}
+
+TESTCASE(std_string_view_to_ruby_with_binary)
+{
+  Rice::String got = detail::to_ruby(std::string_view("\000test", 5));
+
+  ASSERT_EQUAL(String(std::string_view("\000test", 5)), got);
+  ASSERT_EQUAL(5ul, got.length());
+}
+
+TESTCASE(std_string_view_from_ruby_with_binary)
+{
+  std::string_view got = detail::From_Ruby<std::string_view>().convert(rb_str_new("\000test", 5));
+  ASSERT_EQUAL(5ul, got.length());
+  ASSERT_EQUAL(std::string_view("\000test", 5), got);
+}
+
+TESTCASE(std_string_view_from_ruby_refefence)
+{
+  VALUE value = rb_str_new("test", 4);
+  std::string_view view = detail::From_Ruby<std::string_view>().convert(value);
+  ASSERT_EQUAL("test", view);
+
+  String string(value);
+  string.instance_eval("self[1] = 'a'");
+  //ASSERT_EQUAL("tast", view);
+}

data/test/test_Stl_Unordered_Map.cpp

@@ -80,7 +80,7 @@ TESTCASE(Empty)
   Module m = define_module("Testing");
 
   Class c = define_unordered_map<std::unordered_map<std::string, std::int32_t>>("IntUnorderedMap");
-  Object unordered_map = c.call("new");
+  Data_Object<std::unordered_map<std::string, std::int32_t>> unordered_map = c.call("new");
 
   Object result = unordered_map.call("size");
   ASSERT_EQUAL(0, detail::From_Ruby<int32_t>().convert(result));
@@ -94,7 +94,7 @@ TESTCASE(Include)
   Module m = define_module("Testing");
 
   Class c = define_unordered_map<std::unordered_map<std::string, std::int32_t>>("IntUnorderedMap");
-  Object unordered_map = c.call("new");
+  Data_Object<std::unordered_map<std::string, std::int32_t>> unordered_map = c.call("new");
   unordered_map.call("[]=", "one", 1);
   unordered_map.call("[]=", "two", 2);
 
@@ -113,7 +113,7 @@ TESTCASE(Value)
   Module m = define_module("Testing");
 
   Class c = define_unordered_map<std::unordered_map<std::string, std::int32_t>>("IntUnorderedMap");
-  Object unordered_map = c.call("new");
+  Data_Object<std::unordered_map<std::string, std::int32_t>> unordered_map = c.call("new");
   unordered_map.call("[]=", "one", 1);
   unordered_map.call("[]=", "two", 2);
 
@@ -129,16 +129,16 @@ TESTCASE(ToString)
   Module m = define_module("Testing");
 
   Class c = define_unordered_map<std::unordered_map<std::string, std::int32_t>>("IntUnorderedMap");
-  Object unordered_map = c.call("new");
+  Data_Object<std::unordered_map<std::string, std::int32_t>> unordered_map = c.call("new");
   unordered_map.call("[]=", "one", 1);
   unordered_map.call("[]=", "two", 2);
 
-  Object result = unordered_map.call("to_s");
-  ASSERT_EQUAL("{two => 2, one => 1}", detail::From_Ruby<std::string>().convert(result));
+  ASSERT_EQUAL(1, unordered_map->operator[]("one"));
+  ASSERT_EQUAL(2, unordered_map->operator[]("two"));
 
   unordered_map.call("clear");
 
-  result = unordered_map.call("to_s");
+  Object result = unordered_map.call("to_s");
   ASSERT_EQUAL("{}", detail::From_Ruby<std::string>().convert(result));
 }
 
@@ -147,7 +147,7 @@ TESTCASE(Update)
   Module m = define_module("Testing");
 
   Class c = define_unordered_map<std::unordered_map<std::string, std::string>>("StringUnorderedMap");
-  Object unordered_map = c.call("new");
+  Data_Object<std::unordered_map<std::string, std::string>> unordered_map = c.call("new");
   unordered_map.call("[]=", "one", "original 1");
   unordered_map.call("[]=", "two", "original 2");
 
@@ -169,7 +169,7 @@ TESTCASE(Modify)
   Module m = define_module("Testing");
 
   Class c = define_unordered_map<std::unordered_map<std::string, int64_t>>("Int64UnorderedMap");
-  Object unordered_map = c.call("new");
+  Data_Object<std::unordered_map<std::string, std::int64_t>> unordered_map = c.call("new");
 
   Object result = unordered_map.call("[]=", "one", 3232323232);
 
@@ -183,12 +183,12 @@ TESTCASE(Modify)
   ASSERT_EQUAL(0, detail::From_Ruby<int32_t>().convert(result));
 }
 
-TESTCASE(keysAndValues)
+TESTCASE(KeysAndValues)
 {
   Module m = define_module("Testing");
 
   Class c = define_unordered_map<std::unordered_map<std::string, int32_t>>("Int32UnorderedMap");
-  Object unordered_map = c.call("new");
+  Data_Object<std::unordered_map<std::string, std::int32_t>> unordered_map = c.call("new");
 
   unordered_map.call("[]=", "one", 1);
   unordered_map.call("[]=", "two", 2);
@@ -196,19 +196,19 @@ TESTCASE(keysAndValues)
 
   // Keys returns a std::vector
   Data_Object<std::vector<std::string>> keys = unordered_map.call("keys");
-  //std::vector<std::string> expected_keys{ {"one", "three", "two"} };
+  std::sort(keys->begin(), keys->end());
   ASSERT_EQUAL(3u, keys->size());
-  //ASSERT_EQUAL(expected_keys[0], keys->operator[](0));
-  //ASSERT_EQUAL(expected_keys[1], keys->operator[](1));
-  //ASSERT_EQUAL(expected_keys[2], keys->operator[](2));
+  ASSERT_EQUAL("one", keys->operator[](0));
+  ASSERT_EQUAL("three", keys->operator[](1));
+  ASSERT_EQUAL("two", keys->operator[](2));
 
-  // Keys returns a std::vector
+  // Values returns a std::vector
   Data_Object<std::vector<std::int32_t>> values = unordered_map.call("values");
-  //std::vector<std::int32_t> expected_values{ {1, 3, 2} };
+  std::sort(values->begin(), values->end());
   ASSERT_EQUAL(3u, values->size());
-  //ASSERT_EQUAL(expected_values[0], values->operator[](0));
-  //ASSERT_EQUAL(expected_values[1], values->operator[](1));
-  //ASSERT_EQUAL(expected_values[2], values->operator[](2));
+  ASSERT_EQUAL(1, values->operator[](0));
+  ASSERT_EQUAL(2, values->operator[](1));
+  ASSERT_EQUAL(3, values->operator[](2));
 }
 
 TESTCASE(Copy)
@@ -245,15 +245,16 @@ TESTCASE(Iterate)
 
                         result = Hash.new
                         unordered_map.each do |pair|
-                                    result[pair.first] = 2 * pair.second
-                                  end
+                          result[pair.first] = 2 * pair.second
+                        end
                         result)";
 
   Hash result = m.module_eval(code);
   ASSERT_EQUAL(3u, result.size());
 
-  std::string result_string = result.to_s().str();
-  ASSERT_EQUAL(R"({"seven"=>14, "six"=>12, "five"=>10})", result_string);
+  ASSERT_EQUAL(10, detail::From_Ruby<int>().convert(result["five"].value()));
+  ASSERT_EQUAL(12, detail::From_Ruby<int>().convert(result["six"].value()));
+  ASSERT_EQUAL(14, detail::From_Ruby<int>().convert(result["seven"].value()));
 }
 
 TESTCASE(ToEnum)
@@ -268,15 +269,17 @@ TESTCASE(ToEnum)
 
                         result = Hash.new
                         unordered_map.each.each do |pair|
-                                    result[pair.first] = 2 * pair.second
-                                  end
+                          result[pair.first] = 2 * pair.second
+                        end
                         result)";
 
   Hash result = m.module_eval(code);
   ASSERT_EQUAL(3u, result.size());
 
   std::string result_string = result.to_s().str();
-  ASSERT_EQUAL(R"({"seven"=>14, "six"=>12, "five"=>10})", result_string);
+  ASSERT_EQUAL(10, detail::From_Ruby<int>().convert(result["five"].value()));
+  ASSERT_EQUAL(12, detail::From_Ruby<int>().convert(result["six"].value()));
+  ASSERT_EQUAL(14, detail::From_Ruby<int>().convert(result["seven"].value()));
 }
 
 TESTCASE(ToEnumSize)
@@ -321,7 +324,7 @@ TESTCASE(NotComparable)
 
   Class c = define_unordered_map<std::unordered_map<std::string, NotComparable>>("NotComparableUnorderedMap");
 
-  Object unordered_map = c.call("new");
+  Data_Object<std::unordered_map<std::string, NotComparable>> unordered_map = c.call("new");
   unordered_map.call("[]=", "one", NotComparable(1));
   unordered_map.call("[]=", "two", NotComparable(2));
   unordered_map.call("[]=", "three", NotComparable(3));
@@ -340,7 +343,7 @@ TESTCASE(NotPrintable)
 
   Class c = define_unordered_map<std::unordered_map<std::string, NotComparable>>("NotComparableUnorderedMap");
 
-  Object unordered_map = c.call("new");
+  Data_Object<std::unordered_map<std::string, NotComparable>> unordered_map = c.call("new");
   unordered_map.call("[]=", "one", NotComparable(1));
   unordered_map.call("[]=", "two", NotComparable(2));
   unordered_map.call("[]=", "three", NotComparable(3));
@@ -359,7 +362,7 @@ namespace
     {
     };
 
-    bool operator==(const Comparable& other)
+    bool operator==(const Comparable& other) const
     {
       return this->value_ == other.value_;
     }
@@ -381,7 +384,7 @@ TESTCASE(Comparable)
 
   Class c = define_unordered_map<std::unordered_map<std::string, Comparable>>("ComparableUnorderedMap");
 
-  Object unordered_map = c.call("new");
+  Data_Object<std::unordered_map<std::string, Comparable>> unordered_map = c.call("new");
   
   unordered_map.call("[]=", "one", Comparable(1));
   unordered_map.call("[]=", "two", Comparable(2));
@@ -398,13 +401,14 @@ TESTCASE(Printable)
 
   Class c = define_unordered_map<std::unordered_map<std::string, Comparable>>("ComparableUnorderedMap");
 
-  Object unordered_map = c.call("new");
+  Data_Object<std::unordered_map<std::string, Comparable>> unordered_map = c.call("new");
   unordered_map.call("[]=", "one", Comparable(1));
   unordered_map.call("[]=", "two", Comparable(2));
   unordered_map.call("[]=", "three", Comparable(3));
 
-  Object result = unordered_map.call("to_s");
-  ASSERT_EQUAL("{three => Comparable(3), two => Comparable(2), one => Comparable(1)}", detail::From_Ruby<std::string>().convert(result));
+  ASSERT_EQUAL(Comparable(1), unordered_map->operator[]("one"));
+  ASSERT_EQUAL(Comparable(2), unordered_map->operator[]("two"));
+  ASSERT_EQUAL(Comparable(3), unordered_map->operator[]("three"));
 }
 
 namespace