rice 4.0.4 → 4.2.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

@@ -109,6 +109,11 @@ SETUP(SmartPointer)
   define_global_function("extract_flag_unique_ptr_ref", &extractFlagUniquePtrRef);
   define_global_function("extract_flag_shared_ptr", &extractFlagSharedPtr);
   define_global_function("extract_flag_shared_ptr_ref", &extractFlagSharedPtrRef);
+
+  define_global_function("extract_flag_shared_ptr_with_default", &extractFlagSharedPtr,
+      Arg("myClass") = std::make_shared<MyClass>());
+  define_global_function("extract_flag_shared_ptr_ref_with_default", &extractFlagSharedPtrRef,
+      Arg("myClass") = std::make_shared<MyClass>());
 }
 
 TESTCASE(TransferOwnership)
@@ -124,7 +129,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 +152,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 +173,8 @@ 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);
+  ASSERT_EQUAL(7, detail::From_Ruby<int>().convert(result));
 }
 
 TESTCASE(SharedPtrParameter)
@@ -179,10 +185,11 @@ TESTCASE(SharedPtrParameter)
 
   std::string code = R"(factory = Factory.new
                         my_class = factory.share
-                        my_class.set_flag(7)
+                        my_class.set_flag(8)
                         extract_flag_shared_ptr(my_class))";
- 
-  Object result = m.instance_eval(code);
+
+  Object result = m.module_eval(code);
+  ASSERT_EQUAL(8, detail::From_Ruby<int>().convert(result));
 }
 
 TESTCASE(SharedPtrRefParameter)
@@ -193,8 +200,41 @@ TESTCASE(SharedPtrRefParameter)
 
   std::string code = R"(factory = Factory.new
                         my_class = factory.share
-                        my_class.set_flag(7)
+                        my_class.set_flag(9)
                         extract_flag_shared_ptr_ref(my_class))";
 
-  Object result = m.instance_eval(code);
-}
+  Object result = m.module_eval(code);
+  ASSERT_EQUAL(9, detail::From_Ruby<int>().convert(result));
+}
+
+TESTCASE(SharedPtrDefaultParameter)
+{
+  MyClass::reset();
+
+  Module m = define_module("TestingModule");
+
+  std::string code = R"(factory = Factory.new
+                        my_class = factory.share
+                        my_class.set_flag(7)
+                        extract_flag_shared_ptr_with_default())";
+
+  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));
+}
+
+TESTCASE(SharedPtrRefDefaultParameter)
+{
+  MyClass::reset();
+
+  Module m = define_module("TestingModule");
+
+  std::string code = R"(factory = Factory.new
+                        my_class = factory.share
+                        my_class.set_flag(7)
+                        extract_flag_shared_ptr_ref_with_default())";
+
+  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.cpp

@@ -27,7 +27,10 @@ TESTCASE(std_string_to_ruby_encoding)
   Object object(value);
   Object encoding = object.call("encoding");
   Object encodingName = encoding.call("name");
-  ASSERT_EQUAL("ASCII-8BIT", detail::From_Ruby<std::string>().convert(encodingName));
+  std::string result = detail::From_Ruby<std::string>().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_to_ruby_encoding_utf8)
@@ -71,4 +74,4 @@ TESTCASE(std_string_from_ruby_with_binary)
   std::string got = detail::From_Ruby<std::string>().convert(rb_str_new("\000test", 5));
   ASSERT_EQUAL(5ul, got.length());
   ASSERT_EQUAL(std::string("\000test", 5), got);
-}
+}