rice 4.3.2 → 4.5.0

data/test/test_Enum.cpp

@@ -9,19 +9,22 @@ using namespace Rice;
 
 TESTSUITE(Enum);
 
+SETUP(Enum)
+{
+  embed_ruby();
+}
+
+TEARDOWN(Enum)
+{
+  Rice::detail::Registries::instance.types.clearUnverifiedTypes();
+  rb_gc_start();
+}
+
+
 namespace
 {
   enum Color { RED, BLACK, GREEN };
 
-  Enum<Color> define_color_enum()
-  {
-    static Enum<Color> colors = define_enum<Color>("Color")
-      .define_value("RED", RED)
-      .define_value("BLACK", BLACK)
-      .define_value("GREEN", GREEN);
-    return colors;
-  }
-  
   enum class Season { Spring, Summer, Fall, Winter };
 
   // This is needed to make unittest compile (it uses ostream to report errors)
@@ -30,22 +33,26 @@ namespace
     os << static_cast<std::underlying_type_t<Season>>(season);
     return os;
   }
+}
 
-  Enum<Season> define_season_enum()
-  {
-    static Enum<Season> seasons = define_enum<Season>("Season")
-      .define_value("Spring", Season::Spring)
-      .define_value("Summer", Season::Summer)
-      .define_value("Fall", Season::Fall)
-      .define_value("Winter", Season::Winter);
-
-    return seasons;
-  }
+Enum<Color> define_color_enum()
+{
+  static Enum<Color> colors = define_enum<Color>("Color")
+    .define_value("RED", RED)
+    .define_value("BLACK", BLACK)
+    .define_value("GREEN", GREEN);
+  return colors;
 }
 
-SETUP(Enum)
+Enum<Season> define_season_enum()
 {
-  embed_ruby();
+  static Enum<Season> seasons = define_enum<Season>("Season")
+    .define_value("Spring", Season::Spring)
+    .define_value("Summer", Season::Summer)
+    .define_value("Fall", Season::Fall)
+    .define_value("Winter", Season::Winter);
+
+  return seasons;
 }
 
 TESTCASE(copy_construct)
@@ -147,6 +154,44 @@ TESTCASE(each_seasons)
   ASSERT_EQUAL(Season::Winter, *enum_3);
 }
 
+TESTCASE(bitset_operators)
+{
+  Module m = define_module("TestingBitsetOperators");
+
+  Enum<Season> rb_cSeason = define_season_enum();
+
+  std::string code = R"(Season::Summer & Season::Winter)";
+  Object value = m.module_eval(code);
+  ASSERT_EQUAL(1, detail::From_Ruby<int>().convert(value));
+
+  code = R"(Season::Summer | Season::Fall)";
+  value = m.module_eval(code);
+  ASSERT_EQUAL(3, detail::From_Ruby<int>().convert(value));
+
+  code = R"(Season::Summer ^ Season::Winter)";
+  value = m.module_eval(code);
+  ASSERT_EQUAL(2, detail::From_Ruby<int>().convert(value));
+
+  code = R"(~Season::Winter)";
+  value = m.module_eval(code);
+  ASSERT_EQUAL(-4, detail::From_Ruby<int>().convert(value));
+}
+
+TESTCASE(shift_operators)
+{
+  Module m = define_module("TestingShiftOperators");
+
+  Enum<Season> rb_cSeason = define_season_enum();
+
+  std::string code = R"(Season::Winter << 1)";
+  Object value = m.module_eval(code);
+  ASSERT_EQUAL(6, detail::From_Ruby<int>().convert(value));
+
+  code = R"(Season::Winter >> 1)";
+  value = m.module_eval(code);
+  ASSERT_EQUAL(1, detail::From_Ruby<int>().convert(value));
+}
+
 TESTCASE(to_s)
 {
   Module m = define_module("Testing");
@@ -157,14 +202,14 @@ TESTCASE(to_s)
   ASSERT_EQUAL(String("GREEN"), String(m.module_eval("Color::GREEN.to_s")));
 }
 
-TESTCASE(to_i)
+TESTCASE(to_int)
 {
   Module m = define_module("Testing");
 
   Enum<Color> colorEnum = define_color_enum();
-  ASSERT_EQUAL(detail::to_ruby(int(RED)), m.module_eval("Color::RED.to_i").value());
-  ASSERT_EQUAL(detail::to_ruby(int(BLACK)), m.module_eval("Color::BLACK.to_i").value());
-  ASSERT_EQUAL(detail::to_ruby(int(GREEN)), m.module_eval("Color::GREEN.to_i").value());
+  ASSERT_EQUAL(detail::to_ruby(int(RED)), m.module_eval("Color::RED.to_int").value());
+  ASSERT_EQUAL(detail::to_ruby(int(BLACK)), m.module_eval("Color::BLACK.to_int").value());
+  ASSERT_EQUAL(detail::to_ruby(int(GREEN)), m.module_eval("Color::GREEN.to_int").value());
 }
 
 TESTCASE(inspect)
@@ -275,7 +320,7 @@ namespace
 TESTCASE(nested_enums)
 {
   Data_Type<Inner> inner = define_class<Inner>("Inner");
-  define_enum<Inner::Props>("Props", inner)
+  define_enum_under<Inner::Props>("Props", inner)
     .define_value("VALUE1", Inner::VALUE1)
     .define_value("VALUE2", Inner::VALUE2)
     .define_value("VALUE3", Inner::VALUE3);
@@ -283,9 +328,9 @@ TESTCASE(nested_enums)
 
   Module m = define_module("Testing");
 
-  ASSERT_EQUAL(detail::to_ruby(int(0)), m.module_eval("Inner::Props::VALUE1.to_i").value());
-  ASSERT_EQUAL(detail::to_ruby(int(1)), m.module_eval("Inner::Props::VALUE2.to_i").value());
-  ASSERT_EQUAL(detail::to_ruby(int(2)), m.module_eval("Inner::Props::VALUE3.to_i").value());
+  ASSERT_EQUAL(detail::to_ruby(int(0)), m.module_eval("Inner::Props::VALUE1.to_int").value());
+  ASSERT_EQUAL(detail::to_ruby(int(1)), m.module_eval("Inner::Props::VALUE2.to_int").value());
+  ASSERT_EQUAL(detail::to_ruby(int(2)), m.module_eval("Inner::Props::VALUE3.to_int").value());
 }
 
 namespace
@@ -295,9 +340,14 @@ namespace
     return RED;
   }
 
-  bool isMyFavoriteColor(Color aColor)
+  bool isMyFavoriteColor(Color color)
   {
-    return aColor == RED;
+    return color == RED;
+  }
+
+  bool myFavoriteColorAsInt(int color)
+  {
+    return color == RED;
   }
 }
 
@@ -305,9 +355,8 @@ TESTCASE(using_enums)
 {
   Enum<Color> colorEnum = define_color_enum();
   colorEnum.define_singleton_function("my_favorite_color", &myFavoriteColor)
-       .define_singleton_function("is_my_favorite_color", &isMyFavoriteColor)
-       .define_singleton_function("is_my_favorite_color", &isMyFavoriteColor)
-       .define_method("is_my_favorite_color", &isMyFavoriteColor);
+           .define_singleton_function("is_my_favorite_color", &isMyFavoriteColor)
+           .define_method("is_my_favorite_color", &isMyFavoriteColor);
 
   Module m = define_module("Testing");
 
@@ -327,6 +376,46 @@ TESTCASE(using_enums)
   ASSERT_EQUAL(Qfalse, result.value());
 }
 
+TESTCASE(enum_to_int)
+{
+  Enum<Color> colorEnum = define_color_enum();
+
+  Module m = define_module("Testing");
+  m.define_module_function("my_favorite_color_as_int", &myFavoriteColorAsInt);
+
+  std::string code = R"(my_favorite_color_as_int(Color::RED))";
+  Object result = m.module_eval(code);
+  ASSERT_EQUAL(Qtrue, result.value());
+
+  code = R"(my_favorite_color_as_int(Color::GREEN))";
+  result = m.module_eval(code);
+  ASSERT_EQUAL(Qfalse, result.value());
+}
+
+namespace
+{
+  bool isMyFavoriteSeasonAsInt(int season)
+  {
+    return ((Season)season == Season::Summer);
+  }
+}
+
+TESTCASE(enum_class_to_int)
+{
+  define_season_enum();
+
+  Module m = define_module("Testing");
+  m.define_module_function("is_my_favorite_season_as_int", &isMyFavoriteSeasonAsInt);
+
+  std::string code = R"(is_my_favorite_season_as_int(Season::Spring))";
+  Object result = m.module_eval(code);
+  ASSERT_EQUAL(Qfalse, result.value());
+
+  code = R"(is_my_favorite_season_as_int(Season::Summer))";
+  result = m.module_eval(code);
+  ASSERT_EQUAL(Qtrue, result.value());
+}
+
 namespace
 {
   Color defaultColor(Color aColor = BLACK)
@@ -360,21 +449,44 @@ namespace
 
 TESTCASE(not_defined)
 {
+  Module m = define_module("TestingEnumNotDefined");
+
 #ifdef _MSC_VER
-  const char* message = "Type is not defined with Rice: enum `anonymous namespace'::Undefined";
+  const char* message = "The following types are not registered with Rice:\n  enum `anonymous namespace'::Undefined\n";
 #else
-  const char* message = "Type is not defined with Rice: (anonymous namespace)::Undefined";
+  const char* message = "The following types are not registered with Rice:\n  (anonymous namespace)::Undefined\n";
 #endif
 
+  m.define_module_function("undefined_arg", &undefinedArg);
+
   ASSERT_EXCEPTION_CHECK(
     std::invalid_argument,
-    define_global_function("undefined_arg", &undefinedArg),
+    Rice::detail::Registries::instance.types.validateTypes(),
+    ASSERT_EQUAL(message, ex.what())
+  );
+
+#ifdef _MSC_VER
+  message = "Type is not registered with Rice: enum `anonymous namespace'::Undefined";
+#else
+  message = "Type is not registered with Rice: (anonymous namespace)::Undefined";
+#endif
+
+  m.define_module_function("undefined_return", &undefinedReturn);
+  ASSERT_EXCEPTION_CHECK(
+    Rice::Exception,
+    m.call("undefined_return"),
     ASSERT_EQUAL(message, ex.what())
   );
 
+#ifdef _MSC_VER
+  message = "Type is not defined with Rice: enum `anonymous namespace'::Undefined";
+#else
+  message = "Type is not defined with Rice: (anonymous namespace)::Undefined";
+#endif
+
   ASSERT_EXCEPTION_CHECK(
-    std::invalid_argument,
-    define_global_function("undefined_return", &undefinedReturn),
+    Rice::Exception,
+    m.call("undefined_arg", 1),
     ASSERT_EQUAL(message, ex.what())
   );
-}
+}

data/test/test_Exception.cpp

@@ -11,6 +11,11 @@ SETUP(Exception)
   embed_ruby();
 }
 
+TEARDOWN(Exception)
+{
+  rb_gc_start();
+}
+
 TESTCASE(construct_from_exception_object)
 {
   VALUE v = detail::protect(rb_exc_new2, rb_eRuntimeError, "foo");
@@ -45,3 +50,233 @@ TESTCASE(what)
   ASSERT_EQUAL(foo, ex.what());
 }
 
+namespace
+{
+  enum class ErrorCode
+  {
+    MEMORY,
+    DISK,
+    CPU
+  };
+
+  class CustomException
+  {
+  public:
+    CustomException(ErrorCode code) : code(code)
+    {
+    }
+
+    const char* what() const noexcept
+    {
+      return "My custom exception occurred!";
+    }
+
+    ErrorCode code;
+  };
+
+  void raiseCustomException(ErrorCode code)
+  {
+    throw CustomException(code);
+  }
+
+  class MyExceptionHandler
+  {
+  public:
+    void operator()()
+    {
+      try
+      {
+        throw;
+      }
+      catch (const CustomException& exception)
+      {
+        Data_Object<CustomException> wrapper(exception, true);
+        rb_exc_raise(wrapper);
+      }
+    }
+  };
+}
+
+Enum<ErrorCode> define_error_code_enum()
+{
+  static Enum<ErrorCode> errorCodes = define_enum<ErrorCode>("ErrorCode")
+    .define_value("MEMORY", ErrorCode::MEMORY)
+    .define_value("DISK", ErrorCode::DISK)
+    .define_value("CPU", ErrorCode::CPU);
+  
+  return errorCodes;
+}
+
+TESTCASE(default_handler)
+{
+  define_error_code_enum();
+  Module m = define_module("Testing");
+  m.define_singleton_function("raise_custom_exception", &raiseCustomException);
+  Class MyExceptionClass = define_class_under<CustomException>(rb_cObject, "CustomException", rb_eStandardError).
+                           define_method("message", &CustomException::what);
+
+  ASSERT_EXCEPTION_CHECK(
+    Exception,
+    m.call("raise_custom_exception", ErrorCode::MEMORY),
+    ASSERT_EQUAL("Unknown C++ exception thrown", ex.what())
+  );
+}
+
+TESTCASE(custom_handler_functor)
+{
+  define_error_code_enum();
+  Class MyExceptionClass = define_class_under<CustomException>(rb_cObject, "CustomException", rb_eStandardError).
+                           define_method("message", &CustomException::what);
+
+  detail::Registries::instance.handlers.set(MyExceptionHandler());
+
+  Module m = define_module("Testing");
+  m.define_singleton_function("raise_custom_exception", &raiseCustomException);
+
+  ASSERT_EXCEPTION_CHECK(
+    Exception,
+    m.call("raise_custom_exception", ErrorCode::DISK),
+    ASSERT_EQUAL("My custom exception occurred!", ex.what())
+  );
+
+  std::string code = R"(begin
+                          raise_custom_exception(ErrorCode::DISK)
+                        rescue CustomException => exception
+                          "Caught in Ruby"       
+                        end)";
+
+  String string = m.instance_eval(code);
+  ASSERT_EQUAL("Caught in Ruby", string.c_str());
+}
+
+TESTCASE(custom_handler_lambda)
+{
+  define_error_code_enum();
+  Class rb_eCustomException = define_class("CustomException", rb_eStandardError).
+                              define_method("message", &CustomException::what);
+
+  auto handler = []()
+    {
+      try
+      {
+        throw;
+      }
+      catch (const CustomException& exception)
+      {
+        Data_Object<CustomException> wrapper(exception);
+        rb_exc_raise(wrapper);
+      }
+    };
+
+  detail::Registries::instance.handlers.set(handler);
+
+  Module m = define_module("Testing");
+  m.define_singleton_function("raise_custom_exception", &raiseCustomException);
+
+  ASSERT_EXCEPTION_CHECK(
+    Exception,
+    m.call("raise_custom_exception", ErrorCode::CPU),
+    ASSERT_EQUAL("My custom exception occurred!", ex.what())
+  );
+
+  std::string code = R"(begin
+                          raise_custom_exception(ErrorCode::CPU)
+                        rescue CustomException => exception
+                          $!
+                        end)";
+
+  Object object = m.instance_eval(code);
+  ASSERT_EQUAL(rb_eCustomException.value(), object.class_of().value());
+}
+
+TESTCASE(subclasses)
+{
+  define_error_code_enum();
+  Class rb_eCustomException = define_class("CustomException", rb_eStandardError).
+                              define_method("message", &CustomException::what);
+  Class rb_eMemoryException = define_class_under(rb_cObject, "MemoryException", rb_eCustomException);
+  Class rb_eDiskException = define_class_under(rb_cObject, "DiskException", rb_eCustomException);
+  Class rb_eCpuException = define_class_under(rb_cObject, "CpuException", rb_eCustomException);
+
+  auto handler = [&]()
+    {
+      try
+      {
+        throw;
+      }
+      catch (const CustomException& exception)
+      {
+        Class exceptionKlass = rb_eCustomException;
+        
+        switch (exception.code)
+        {
+          case ErrorCode::MEMORY:
+            exceptionKlass = rb_eMemoryException;
+            break;
+          case ErrorCode::DISK:
+            exceptionKlass = rb_eDiskException;
+            break;
+          case ErrorCode::CPU:
+            exceptionKlass = rb_eCpuException;
+            break;
+        }
+
+        // Take ownership of the exception object and map it to the right subclass
+        Data_Object<CustomException> wrapper(exception, true, exceptionKlass);
+        rb_exc_raise(wrapper);
+      }
+    };
+
+  detail::Registries::instance.handlers.set(handler);
+
+  Module m = define_module("Testing");
+  m.define_singleton_function("raise_custom_exception", &raiseCustomException);
+
+  std::string code = R"(begin
+                          raise_custom_exception(ErrorCode::MEMORY)
+                        rescue => e
+                          e.class.name
+                        end)";
+
+  String result = m.instance_eval(code);
+  ASSERT_EQUAL("MemoryException", result.c_str());
+
+  code = R"(begin
+              raise_custom_exception(ErrorCode::MEMORY)
+            rescue MemoryException => e
+              e.class.name
+            end)";
+
+  result = m.instance_eval(code);
+  ASSERT_EQUAL("MemoryException", result.c_str());
+
+  code = R"(begin
+              raise_custom_exception(ErrorCode::DISK)
+            rescue DiskException => e
+              e.class.name
+            end)";
+
+  result = m.instance_eval(code);
+  ASSERT_EQUAL("DiskException", result.c_str());
+
+  code = R"(begin
+              raise_custom_exception(ErrorCode::CPU)
+            rescue CpuException => e
+              e.class.name
+            end)";
+
+  result = m.instance_eval(code);
+  ASSERT_EQUAL("CpuException", result.c_str());
+
+  code = R"(begin
+              raise_custom_exception(ErrorCode::CPU)
+            rescue RuntimeError => e
+              e.class.name
+            end)";
+
+  ASSERT_EXCEPTION_CHECK(
+    Exception,
+    m.instance_eval(code),
+    ASSERT_EQUAL("My custom exception occurred!", ex.what())
+  );
+}

data/test/test_File.cpp

@@ -0,0 +1,70 @@
+#include <cstdio>
+#include <filesystem>
+
+#include "unittest.hpp"
+#include "embed_ruby.hpp"
+#include <rice/rice.hpp>
+#include <rice/stl.hpp>
+
+using namespace Rice;
+
+TESTSUITE(FILE);
+
+SETUP(FILE)
+{
+  embed_ruby();
+}
+
+TEARDOWN(FILE)
+{
+  rb_gc_start();
+}
+
+namespace
+{
+  FILE* openFile()
+  {
+    std::filesystem::path path = __FILE__;
+    FILE* fptr = fopen(path.u8string().c_str(), "rb");
+    return fptr;
+  }
+
+  std::string readFile(FILE* fptr)
+  {
+    std::ostringstream result;
+
+    char buffer[255]; 
+    while (fgets(buffer, sizeof(buffer), fptr) != NULL)
+    {
+      result << buffer;
+    }
+    return result.str();
+  }
+
+  bool closeFile(FILE* fptr)
+  {
+    // Ruby override fclose and replaces it with rb_w32_fclose which causes a segementation fault. Oy!
+#ifndef _MSC_VER
+    fclose(fptr);
+#endif
+    return true;
+  }
+}
+
+TESTCASE(File)
+{
+  Module m = define_module("TestingModule");
+  m.define_module_function("open_file", openFile).
+    define_module_function("read_file", readFile).
+    define_module_function("close_file", closeFile);
+
+  Data_Object<FILE> file = m.call("open_file");
+  ASSERT((file.value() != Qnil));
+  ASSERT((file.get() != nullptr));
+
+  String string = m.call("read_file", file);
+  ASSERT((string.length() > 1300));
+
+  Object result = m.call("close_file", file);
+  ASSERT_EQUAL(Qtrue, result.value());
+}