rice 4.3.3 → 4.6.0

data/test/test_Stl_Map.cpp

@@ -5,6 +5,7 @@
 #include "embed_ruby.hpp"
 #include <rice/rice.hpp>
 #include <rice/stl.hpp>
+#include <ruby/version.h>
 
 using namespace Rice;
 
@@ -15,9 +16,13 @@ SETUP(Map)
   embed_ruby();
 }
 
-namespace
+TEARDOWN(Map)
 {
+  rb_gc_start();
+}
 
+namespace
+{
   class MyClass
   {
   public:
@@ -42,9 +47,9 @@ TESTCASE(StringMap)
 {
   Module m = define_module("Testing");
 
-  Class c = define_map<std::map<std::string, std::string>>("StringMap");
+  Class c = define_map<std::string, std::string>("StringMap");
 
-  Object map = m.module_eval("$map = StringMap.new");
+  Object map = m.module_eval("$map = Std::StringMap.new");
   Object result = map.call("size");
   ASSERT_EQUAL(0, detail::From_Ruby<int32_t>().convert(result));
 
@@ -61,8 +66,8 @@ TESTCASE(WrongType)
 {
   Module m = define_module("Testing");
 
-  Class c = define_map<std::map<std::string, std::string>>("StringMap");
-  Object map = m.module_eval("$map = StringMap.new");
+  Class c = define_map<std::string, std::string>("StringMap");
+  Object map = m.module_eval("$map = Std::StringMap.new");
 
   ASSERT_EXCEPTION_CHECK(
     Exception,
@@ -79,7 +84,7 @@ TESTCASE(Empty)
 {
   Module m = define_module("Testing");
 
-  Class c = define_map<std::map<std::string, std::int32_t>>("IntMap");
+  Class c = define_map<std::string, std::int32_t>("IntMap");
   Object map = c.call("new");
 
   Object result = map.call("size");
@@ -93,10 +98,14 @@ TESTCASE(Include)
 {
   Module m = define_module("Testing");
 
-  Class c = define_map<std::map<std::string, std::int32_t>>("IntMap");
-  Object map = c.call("new");
-  map.call("[]=", "one", 1);
-  map.call("[]=", "two", 2);
+  Class c = define_map<std::string, std::int32_t>("IntMap");
+
+  std::string code = R"(map = Std::IntMap.new
+                        map["one"] = 1
+                        map["two"] = 2
+                        map)";
+
+  Object map = m.module_eval(code);
 
   Object result = map.call("include?", "two");
   ASSERT_EQUAL(Qtrue, result.value());
@@ -112,7 +121,7 @@ TESTCASE(Value)
 {
   Module m = define_module("Testing");
 
-  Class c = define_map<std::map<std::string, std::int32_t>>("IntMap");
+  Class c = define_map<std::string, std::int32_t>("IntMap");
   Object map = c.call("new");
   map.call("[]=", "one", 1);
   map.call("[]=", "two", 2);
@@ -128,7 +137,7 @@ TESTCASE(ToString)
 {
   Module m = define_module("Testing");
 
-  Class c = define_map<std::map<std::string, std::int32_t>>("IntMap");
+  Class c = define_map<std::string, std::int32_t>("IntMap");
   Object map = c.call("new");
   map.call("[]=", "one", 1);
   map.call("[]=", "two", 2);
@@ -146,7 +155,7 @@ TESTCASE(Update)
 {
   Module m = define_module("Testing");
 
-  Class c = define_map<std::map<std::string, std::string>>("StringMap");
+  Class c = define_map<std::string, std::string>("StringMap");
   Object map = c.call("new");
   map.call("[]=", "one", "original 1");
   map.call("[]=", "two", "original 2");
@@ -168,7 +177,7 @@ TESTCASE(Modify)
 {
   Module m = define_module("Testing");
 
-  Class c = define_map<std::map<std::string, int64_t>>("Int64Map");
+  Class c = define_map<std::string, int64_t>("Int64Map");
   Object map = c.call("new");
 
   Object result = map.call("[]=", "one", 3232323232);
@@ -187,7 +196,7 @@ TESTCASE(keysAndValues)
 {
   Module m = define_module("Testing");
 
-  Class c = define_map<std::map<std::string, int32_t>>("Int32Map");
+  Class c = define_map<std::string, int32_t>("Int32Map");
   Object map = c.call("new");
 
   map.call("[]=", "one", 1);
@@ -215,7 +224,7 @@ TESTCASE(Copy)
 {
   Module m = define_module("Testing");
 
-  Class c = define_map<std::map<std::string, double>>("DoubleMap");
+  Class c = define_map<std::string, double>("DoubleMap");
   Object object = c.call("new");
 
   object.call("[]=", "one", 11.1);
@@ -236,9 +245,9 @@ TESTCASE(Copy)
 TESTCASE(Iterate)
 {
   Module m = define_module("Testing");
-  Class c = define_map<std::map<std::string, int>>("IntMap");
+  Class c = define_map<std::string, int>("IntMap");
 
-  std::string code = R"(map = IntMap.new
+  std::string code = R"(map = Std::IntMap.new
                         map["five"] = 5
                         map["six"] = 6
                         map["seven"] = 7
@@ -253,15 +262,19 @@ TESTCASE(Iterate)
   ASSERT_EQUAL(3u, result.size());
 
   std::string result_string = result.to_s().str();
+#if RUBY_API_VERSION_MAJOR == 3 && RUBY_API_VERSION_MINOR >= 4
+  ASSERT_EQUAL("{\"five\" => 10, \"seven\" => 14, \"six\" => 12}", result_string);
+#else
   ASSERT_EQUAL("{\"five\"=>10, \"seven\"=>14, \"six\"=>12}", result_string);
+#endif
 }
 
 TESTCASE(ToEnum)
 {
   Module m = define_module("Testing");
-  Class c = define_map<std::map<std::string, int>>("IntMap");
+  Class c = define_map<std::string, int>("IntMap");
 
-  std::string code = R"(map = IntMap.new
+  std::string code = R"(map = Std::IntMap.new
                         map["five"] = 5
                         map["six"] = 6
                         map["seven"] = 7
@@ -276,15 +289,20 @@ TESTCASE(ToEnum)
   ASSERT_EQUAL(3u, result.size());
 
   std::string result_string = result.to_s().str();
+
+#if RUBY_API_VERSION_MAJOR == 3 && RUBY_API_VERSION_MINOR >= 4
+  ASSERT_EQUAL("{\"five\" => 10, \"seven\" => 14, \"six\" => 12}", result_string);
+#else
   ASSERT_EQUAL("{\"five\"=>10, \"seven\"=>14, \"six\"=>12}", result_string);
+#endif
 }
 
 TESTCASE(ToEnumSize)
 {
   Module m = define_module("TestingModule");
-  Class c = define_map<std::map<std::string, int>>("IntMap");
+  Class c = define_map<std::string, int>("IntMap");
 
-  std::string code = R"(map = IntMap.new
+  std::string code = R"(map = Std::IntMap.new
                         map["five"] = 5
                         map["six"] = 6
                         map["seven"] = 7
@@ -318,7 +336,7 @@ TESTCASE(NotComparable)
   define_class<NotComparable>("NotComparable").
     define_constructor(Constructor<NotComparable, uint32_t>());
 
-  Class c = define_map<std::map<std::string, NotComparable>>("NotComparableMap");
+  Class c = define_map<std::string, NotComparable>("NotComparableMap");
 
   Object map = c.call("new");
   map.call("[]=", "one", NotComparable(1));
@@ -337,7 +355,7 @@ TESTCASE(NotPrintable)
   define_class<NotComparable>("NotComparable").
     define_constructor(Constructor<NotComparable, uint32_t>());
 
-  Class c = define_map<std::map<std::string, NotComparable>>("NotComparableMap");
+  Class c = define_map<std::string, NotComparable>("NotComparableMap");
 
   Object map = c.call("new");
   map.call("[]=", "one", NotComparable(1));
@@ -358,7 +376,7 @@ namespace
     {
     };
 
-    bool operator==(const Comparable& other)
+    bool operator==(const Comparable& other) const
     {
       return this->value_ == other.value_;
     }
@@ -378,7 +396,7 @@ TESTCASE(Comparable)
   define_class<Comparable>("IsComparable").
     define_constructor(Constructor<Comparable, uint32_t>());
 
-  Class c = define_map<std::map<std::string, Comparable>>("ComparableMap");
+  Class c = define_map<std::string, Comparable>("ComparableMap");
 
   Object map = c.call("new");
   
@@ -395,7 +413,7 @@ TESTCASE(Printable)
   define_class<Comparable>("IsComparable").
     define_constructor(Constructor<Comparable, uint32_t>());
 
-  Class c = define_map<std::map<std::string, Comparable>>("ComparableMap");
+  Class c = define_map<std::string, Comparable>("ComparableMap");
 
   Object map = c.call("new");
   map.call("[]=", "one", Comparable(1));
@@ -433,7 +451,7 @@ TESTCASE(AutoRegisterReturn)
 
   Module m = define_module("Testing");
   Object map = m.module_eval("return_complex_map");
-  ASSERT_EQUAL("Rice::Std::Map__basic_string__char_char_traits__char___allocator__char_____complex__double___less__basic_string__char_char_traits__char___allocator__char_______allocator__pair__basic_string__char_char_traits__char___allocator__char____Const_complex__double________",
+  ASSERT_EQUAL("Std::Map≺string‚ complex≺double≻≻",
                map.class_name().str());
 
   std::string code = R"(map = return_complex_map
@@ -444,14 +462,8 @@ TESTCASE(AutoRegisterReturn)
   ASSERT_EQUAL(Qtrue, result.value());
 
   // Now register the map again
-  define_map<std::map<std::string, std::complex<double>>>("ComplexMap");
-  code = R"(map = ComplexMap.new)";
-  result = m.module_eval(code);
-  ASSERT(result.is_instance_of(map.class_of()));
-
-  // And again in the module
-  define_map_under<std::map<std::string, std::complex<double>>>(m, "ComplexMap2");
-  code = R"(map = Testing::ComplexMap2.new)";
+  define_map<std::string, std::complex<double>>("ComplexMap");
+  code = R"(map = Std::ComplexMap.new)";
   result = m.module_eval(code);
   ASSERT(result.is_instance_of(map.class_of()));
 }
@@ -460,16 +472,16 @@ TESTCASE(AutoRegisterParameter)
 {
   define_global_function("pass_complex_map", &passComplexMap);
 
-  std::string code = R"(map = Rice::Std::Map__basic_string__char_char_traits__char___allocator__char_____complex__double___less__basic_string__char_char_traits__char___allocator__char_______allocator__pair__basic_string__char_char_traits__char___allocator__char____Const_complex__double________.new
-                        map["four"] = Complex(4.0, 4.0)
-                        map["five"] = Complex(5.0, 5.0)
-                        pass_complex_map(map))";
+  std::string code = R"(map = Std::Map≺string‚ complex≺double≻≻.new
+                          map["four"] = Complex(4.0, 4.0)
+                          map["five"] = Complex(5.0, 5.0)
+                          pass_complex_map(map))";
 
   Module m = define_module("Testing");
   Object map = m.module_eval(code);
 
   Object result = map.call("size");
-  ASSERT_EQUAL("Rice::Std::Map__basic_string__char_char_traits__char___allocator__char_____complex__double___less__basic_string__char_char_traits__char___allocator__char_______allocator__pair__basic_string__char_char_traits__char___allocator__char____Const_complex__double________",
+  ASSERT_EQUAL("Std::Map≺string‚ complex≺double≻≻",
                map.class_name().str());
   ASSERT_EQUAL(2, detail::From_Ruby<int32_t>().convert(result));
 
@@ -488,7 +500,7 @@ namespace
 
 TESTCASE(DefaultValue)
 {
-  define_map<std::map<std::string, std::string>>("StringMap");
+  define_map<std::string, std::string>("StringMap");
   define_global_function("default_map", &defaultMap, Arg("strings") = std::map<std::string, std::string>{ {"one", "value 1"}, {"two", "value 2"}, {"three", "value 3"} });
 
   Module m = define_module("Testing");