rice 4.0.3 → 4.1.0

data/test/test_Stl_Optional.cpp

@@ -53,7 +53,7 @@ SETUP(Optional)
 TESTCASE(OptionalReturn)
 {
   Module m = define_module("Testing");
-  Object myClass = m.instance_eval("MyClass.new");
+  Object myClass = m.module_eval("MyClass.new");
 
   Object result = myClass.call("optional_return", true);
   ASSERT_EQUAL("Here is a value", detail::From_Ruby<std::string>().convert(result));
@@ -65,7 +65,7 @@ TESTCASE(OptionalReturn)
 TESTCASE(OptionalArgument)
 {
   Module m = define_module("Testing");
-  Object myClass = m.instance_eval("MyClass.new");
+  Object myClass = m.module_eval("MyClass.new");
 
   Object result = myClass.call("optional_argument", 77);
   ASSERT_EQUAL(77, detail::From_Ruby<int32_t>().convert(result));
@@ -77,7 +77,7 @@ TESTCASE(OptionalArgument)
 TESTCASE(OptionalAttribute)
 {
   Module m = define_module("Testing");
-  Object myClass = m.instance_eval("MyClass.new");
+  Object myClass = m.module_eval("MyClass.new");
 
   Object result = myClass.call("optional_attr");
   ASSERT_EQUAL(Qnil, result.value());

data/test/test_Stl_Pair.cpp

@@ -41,6 +41,32 @@ TESTCASE(CreatePair)
   ASSERT_EQUAL("A second value", detail::From_Ruby<std::string>().convert(result));
 }
 
+TESTCASE(CreatePairConst)
+{
+  Module m = define_module("Testing");
+
+  Class c = define_pair<std::pair<const std::string, const std::string>>("ConstStringPair");
+  Object pair = c.call("new", "pair1", "pair2");
+
+  Object result = pair.call("first");
+  ASSERT_EQUAL("pair1", detail::From_Ruby<std::string>().convert(result));
+
+  result = pair.call("second");
+  ASSERT_EQUAL("pair2", detail::From_Ruby<std::string>().convert(result));
+
+  ASSERT_EXCEPTION_CHECK(
+    Exception,
+    pair.call("first=", "A second value"),
+    ASSERT_EQUAL("Cannot set pair.first since it is a constant", ex.what())
+  );
+
+  ASSERT_EXCEPTION_CHECK(
+    Exception,
+    pair.call("second=", "A second value"),
+    ASSERT_EQUAL("Cannot set pair.second since it is a constant", ex.what())
+  );
+}
+
 namespace
 {
   class SomeClass
@@ -63,7 +89,6 @@ namespace
 
 // This test passes everywhere except for Ruby 2.7 on Windows
 // and I don't know why. Throws a "bad any_cast" from MethodData::data
-#ifndef _WIN32
 TESTCASE(AutoRegister)
 {
   Module m = define_module("Testing");
@@ -98,8 +123,19 @@ TESTCASE(AutoRegister)
 
   result = newPair.call("second");
   ASSERT_EQUAL(3.2, detail::From_Ruby<double>().convert(result));
+
+  // Now register the pair again
+  define_pair<std::pair<std::string, double>>("SomePair");
+  std::string code = R"(pair = SomePair.new('string', 2.0))";
+  result = m.module_eval(code);
+  ASSERT(result.is_instance_of(pair.class_of()));
+
+  // And again in the module
+  define_pair_under<std::pair<std::string, double>>(m, "SomePair2");
+  code = R"(pair = Testing::SomePair2.new('string', 3.0))";
+  result = m.module_eval(code);
+  ASSERT(result.is_instance_of(pair.class_of()));
 }
-#endif
 
 namespace
 {

data/test/test_Stl_Reference_Wrapper.cpp

@@ -0,0 +1,102 @@
+#include "unittest.hpp"
+#include "embed_ruby.hpp"
+#include <rice/rice.hpp>
+#include <rice/stl.hpp>
+
+#include <functional>
+
+using namespace Rice;
+
+TESTSUITE(ReferenceWrapper);
+
+namespace
+{
+  class MyClass
+  {
+  public:
+    int reference_wrapper_argument(std::reference_wrapper<int32_t> ref)
+    {
+      return ref.get();
+    }
+
+    std::reference_wrapper<std::string> reference_wrapper_return()
+    {
+      return reference_wrapper_;
+    }
+
+    std::string say_hello()
+    {
+      return "My ref wrapper class";
+    }
+
+    std::string string_ = "A ref wrapped string";
+    std::reference_wrapper<std::string> reference_wrapper_ = std::ref(string_);
+  };
+
+  std::reference_wrapper<MyClass> roundtrip_class(std::reference_wrapper<MyClass> instance)
+  {
+    return instance;
+  }
+
+  std::variant<std::reference_wrapper<MyClass>> roundtrip_class_in_variant(std::variant<std::reference_wrapper<MyClass>> instance)
+  {
+    return instance;
+  }
+}
+
+void makeReferenceWrapperClass()
+{
+  define_class<MyClass>("MyClass").
+    define_constructor(Constructor<MyClass>()).
+    define_method("reference_wrapper_argument", &MyClass::reference_wrapper_argument).
+    define_method("reference_wrapper_return", &MyClass::reference_wrapper_return);
+
+  define_global_function("roundtrip_class", &roundtrip_class);
+  define_global_function("roundtrip_class_in_variant", &roundtrip_class_in_variant);
+}
+
+SETUP(ReferenceWrapper)
+{
+  embed_ruby();
+  makeReferenceWrapperClass();
+}
+
+TESTCASE(Return)
+{
+  Module m = define_module("Testing");
+  Object myClass = m.module_eval("MyClass.new");
+
+  Object result = myClass.call("reference_wrapper_return");
+  ASSERT_EQUAL("A ref wrapped string", detail::From_Ruby<std::string>().convert(result));
+}
+
+TESTCASE(Argument)
+{
+  Module m = define_module("Testing");
+  Object myClass = m.module_eval("MyClass.new");
+
+  Object result = myClass.call("reference_wrapper_argument", 77);
+  ASSERT_EQUAL(77, detail::From_Ruby<int32_t>().convert(result));
+}
+
+TESTCASE(RoundTrip)
+{
+  Module m = define_module("Testing");
+  Object myClass = m.module_eval("MyClass.new");
+
+  Object result = myClass.call("roundtrip_class", myClass);
+  Data_Object<MyClass> finish(result);
+
+  ASSERT_EQUAL(Data_Object<MyClass>::from_ruby(myClass), Data_Object<MyClass>::from_ruby(result));
+}
+
+TESTCASE(RoundTripInVariant)
+{
+  Module m = define_module("Testing");
+  Object myClass = m.module_eval("MyClass.new");
+
+  Object result = myClass.call("roundtrip_class_in_variant", myClass);
+  Data_Object<MyClass> finish(result);
+
+  ASSERT_EQUAL(Data_Object<MyClass>::from_ruby(myClass), Data_Object<MyClass>::from_ruby(result));
+}

data/test/test_Stl_SmartPointer.cpp

@@ -124,7 +124,7 @@ TESTCASE(TransferOwnership)
                           my_class = nil
                         end)";
 
-  m.instance_eval(code);
+  m.module_eval(code);
   rb_gc_start();
 
   ASSERT_EQUAL(10, MyClass::constructorCalls);
@@ -147,7 +147,7 @@ TESTCASE(ShareOwnership)
                           my_class.set_flag(i)
                         end)";
 
-  m.instance_eval(code);
+  m.module_eval(code);
   rb_gc_start();
 
   ASSERT_EQUAL(1, MyClass::constructorCalls);
@@ -168,7 +168,7 @@ TESTCASE(UniquePtrRefParameter)
                         my_class.set_flag(7)
                         extract_flag_unique_ptr_ref(my_class))";
 
-  Object result = m.instance_eval(code);
+  Object result = m.module_eval(code);
 }
 
 TESTCASE(SharedPtrParameter)
@@ -182,7 +182,7 @@ TESTCASE(SharedPtrParameter)
                         my_class.set_flag(7)
                         extract_flag_shared_ptr(my_class))";
  
-  Object result = m.instance_eval(code);
+  Object result = m.module_eval(code);
 }
 
 TESTCASE(SharedPtrRefParameter)
@@ -196,5 +196,5 @@ TESTCASE(SharedPtrRefParameter)
                         my_class.set_flag(7)
                         extract_flag_shared_ptr_ref(my_class))";
 
-  Object result = m.instance_eval(code);
+  Object result = m.module_eval(code);
 }