rice 4.3.3 → 4.6.0

data/test/test_Stl_Variant.cpp

@@ -104,6 +104,94 @@ void makeIntrinsicVariant()
     define_attr("variant_attr", &MyClass::variant_);
 }
 
+namespace
+{
+  class MyClass1
+  {
+  public:
+    MyClass1()
+    {
+      int a = 1;
+    }
+
+    std::string sayHello()
+    {
+      return "Hi from MyClass1";
+    }
+  };
+
+  class MyClass2
+  {
+  public:
+    MyClass2()
+    {
+      int a = 2;
+    }
+
+    std::string sayHello()
+    {
+      return "Hi from MyClass2";
+    }
+  };
+
+  using Variant_T = std::variant<std::monostate, MyClass1, MyClass2>;
+
+  Variant_T variant(bool myClass1)
+  {
+    if (myClass1)
+    {
+      return MyClass1();
+    }
+    else
+    {
+      return MyClass2();
+    }
+  }
+
+  Variant_T roundTripVariant(Variant_T variant)
+  {
+    return variant;
+  }
+
+  Variant_T& roundTripVariantRef(Variant_T& variant)
+  {
+    return variant;
+  }
+
+  const Variant_T& roundTripConstVariantRef(const Variant_T& variant)
+  {
+    return variant;
+  }
+}
+
+void makeClassVariant()
+{
+  define_class<MyClass1>("MyClass1").
+    define_constructor(Constructor<MyClass1>()).
+    define_method("say_hello", &MyClass1::sayHello);
+
+  define_class<MyClass2>("MyClass2").
+    define_constructor(Constructor<MyClass2>()).
+    define_method("say_hello", &MyClass2::sayHello);
+
+  define_global_function("variant_class", &variant);
+  define_global_function("roundtrip_variant", &roundTripVariant);
+  define_global_function("roundtrip_variant_ref", &roundTripVariantRef);
+  define_global_function("roundtrip_const_variant_ref", &roundTripConstVariantRef);
+}
+
+SETUP(Variant)
+{
+  embed_ruby();
+  makeIntrinsicVariant();
+  makeClassVariant();
+}
+
+TEARDOWN(Variant)
+{
+  rb_gc_start();
+}
+
 TESTCASE(IntrinsicReturns)
 {
   using namespace std::complex_literals;
@@ -212,83 +300,6 @@ TESTCASE(VariantAttribute)
   ASSERT_EQUAL(78, detail::From_Ruby<int>().convert(result));
 }
 
-namespace
-{
-  class MyClass1
-  {
-  public:
-    MyClass1()
-    {
-      int a = 1;
-    }
-
-    std::string sayHello()
-    {
-      return "Hi from MyClass1";
-    }
-  };
-
-  class MyClass2
-  {
-  public:
-    MyClass2()
-    {
-      int a = 2;
-    }
-
-    std::string sayHello()
-    {
-      return "Hi from MyClass2";
-    }
-  };
-
-  using Class_Variant_T = std::variant<std::monostate, MyClass1, MyClass2>;
-
-  Class_Variant_T variantClass(bool myClass1)
-  {
-    if (myClass1)
-    {
-      return MyClass1();
-    }
-    else
-    {
-      return MyClass2();
-    }
-  }
-
-  Class_Variant_T roundTripVariantClass(Class_Variant_T variant)
-  {
-    return variant;
-  }
-
-  Class_Variant_T& roundTripVariantClassRef(Class_Variant_T& variant)
-  {
-    return variant;
-  }
-}
-
-void makeClassVariant()
-{
-  define_class<MyClass1>("MyClass1").
-    define_constructor(Constructor<MyClass1>()).
-    define_method("say_hello", &MyClass1::sayHello);
-
-  define_class<MyClass2>("MyClass2").
-    define_constructor(Constructor<MyClass2>()).
-    define_method("say_hello", &MyClass2::sayHello);
-
-  define_global_function("variant_class", &variantClass);
-  define_global_function("roundtrip_variant_class", &roundTripVariantClass);
-  define_global_function("roundtrip_variant_class_ref", &roundTripVariantClassRef);
-}
-
-SETUP(Variant)
-{
-  embed_ruby();
-  makeIntrinsicVariant();
-  makeClassVariant();
-}
-
 TESTCASE(ClassReturns)
 {
   Module m = define_module("Testing");
@@ -302,19 +313,22 @@ TESTCASE(ClassReturns)
   ASSERT_EQUAL("Hi from MyClass2", detail::From_Ruby<std::string>().convert(hello));
 }
 
-TESTCASE(ClassRoundtrip)
+TESTCASE(Roundtrip)
 {
   Module m = define_module("Testing");
 
   Object instance = m.module_eval("MyClass1.new");
-  Object instance2 = m.call("roundtrip_variant_class", instance);
+  Object instance2 = m.call("roundtrip_variant", instance);
   String hello = instance2.call("say_hello");
   ASSERT_EQUAL("Hi from MyClass1", detail::From_Ruby<std::string>().convert(hello));
 
   instance = m.module_eval("MyClass2.new");
-  instance2 = m.call("roundtrip_variant_class", instance);
+  instance2 = m.call("roundtrip_variant", instance);
   hello = instance2.call("say_hello");
   ASSERT_EQUAL("Hi from MyClass2", detail::From_Ruby<std::string>().convert(hello));
+
+  instance2 = m.call("roundtrip_variant", nullptr);
+  ASSERT_EQUAL(Qnil, instance2.value());
 }
 
 /* This test case runs successfully on MSVC but not g++. Having stepped through the code with
@@ -326,21 +340,140 @@ TESTCASE(ClassRoundtrip)
  std::tuple with one element, a reference to a variant. So it doesn't change and the address
  of the variable doesn't change. But for some reason g++ resets the
  the std::variant index to 0 thus breaking the test. Maybe something to do with storing
- a refernence to a variant in a tuple? */
+ a reference to a variant in a tuple? */
 
 #ifdef _MSC_VER
-TESTCASE(ClassRoundtripRef)
+TESTCASE(RoundtripRef)
 {
   Module m = define_module("Testing");
 
   Object instance = m.module_eval("MyClass1.new");
-  Object instance2 = m.call("roundtrip_variant_class_ref", instance);
+  Object instance2 = m.call("roundtrip_variant_ref", instance);
   String hello = instance2.call("say_hello");
   ASSERT_EQUAL("Hi from MyClass1", detail::From_Ruby<std::string>().convert(hello));
 
   instance = m.module_eval("MyClass2.new");
-  instance2 = m.call("roundtrip_variant_class_ref", instance);
+  instance2 = m.call("roundtrip_variant_ref", instance);
   hello = instance2.call("say_hello");
   ASSERT_EQUAL("Hi from MyClass2", detail::From_Ruby<std::string>().convert(hello));
+
+  instance2 = m.call("roundtrip_variant_ref", nullptr);
+  ASSERT_EQUAL(Qnil, instance2.value());
 }
 #endif
+
+TESTCASE(RoundtripConstRef)
+{
+  Module m = define_module("Testing");
+
+  Object instance = m.module_eval("MyClass1.new");
+  Object instance2 = m.call("roundtrip_const_variant_ref", instance);
+  String hello = instance2.call("say_hello");
+  ASSERT_EQUAL("Hi from MyClass1", detail::From_Ruby<std::string>().convert(hello));
+
+  instance = m.module_eval("MyClass2.new");
+  instance2 = m.call("roundtrip_const_variant_ref", instance);
+  hello = instance2.call("say_hello");
+  ASSERT_EQUAL("Hi from MyClass2", detail::From_Ruby<std::string>().convert(hello));
+
+  instance2 = m.call("roundtrip_const_variant_ref", nullptr);
+  ASSERT_EQUAL(Qnil, instance2.value());
+}
+
+namespace
+{
+  class MyClass4
+  {
+  public:
+    size_t variantIndex(std::variant<std::vector<std::string>, std::vector<int>> variant)
+    {
+      return variant.index();
+    }
+  };
+}
+
+TESTCASE(VariantWithTwoVectors)
+{
+  using namespace std::complex_literals;
+
+  define_class<MyClass4>("MyClass4").
+    define_constructor(Constructor<MyClass4>()).
+    define_method("variant_index", &MyClass4::variantIndex);
+
+  Module m = define_module("Testing");
+
+  std::string code = R"(vector = Std::Vector≺string≻.new
+                          vector << "a" << "b" << "c"
+                          my_class = MyClass4.new
+                          my_class.variant_index(vector))";
+
+  Object result = m.module_eval(code);
+  ASSERT_EQUAL(0, detail::From_Ruby<size_t>().convert(result));
+
+  code = R"(vector = Std::Vector≺int≻.new
+              vector.push_back(4)
+              my_class = MyClass4.new
+              my_class.variant_index(vector))";
+  result = m.module_eval(code);
+  ASSERT_EQUAL(1, detail::From_Ruby<size_t>().convert(result));
+
+  code = R"(my_class = MyClass4.new
+              my_class.variant_index(["x", "y", "z"]))";
+  result = m.module_eval(code);
+  ASSERT_EQUAL(0, detail::From_Ruby<size_t>().convert(result));
+
+  code = R"(my_class = MyClass4.new
+              my_class.variant_index([5, 6]))";
+
+  ASSERT_EXCEPTION_CHECK(
+    Exception,
+    m.module_eval(code),
+    ASSERT_EQUAL("wrong argument type Integer (expected String)", ex.what())
+  );
+}
+
+namespace
+{
+  class MyClass5
+  {
+  public:
+    static inline int a = 10;
+    static inline float b = 11.0;
+  public:
+    std::variant<Buffer<int>, Buffer<float>> variantBuffer(int index)
+    {
+      if (index == 0)
+      {
+        return Buffer<int>(&a);
+      }
+      else
+      {
+        return Buffer<float>(&b);
+      }
+    }
+  };
+}
+
+TESTCASE(Buffer)
+{
+  define_buffer<int>();
+  define_buffer<float>();
+  using namespace std::complex_literals;
+
+  define_class<MyClass5>("MyClass5").
+    define_constructor(Constructor<MyClass5>()).
+    define_method("buffer", &MyClass5::variantBuffer);
+
+  Module m = define_module("Testing");
+
+  std::string code = R"(myclass = MyClass5.new
+                          myclass.buffer(0).to_ary(1).first)";
+
+  Object result = m.module_eval(code);
+  ASSERT_EQUAL(10, detail::From_Ruby<int>().convert(result));
+
+  code = R"(myclass = MyClass5.new
+              myclass.buffer(1).to_ary(1).first)";
+  result = m.module_eval(code);
+  ASSERT_EQUAL(11.0, detail::From_Ruby<float>().convert(result));
+}