rice 2.1.0 → 3.0.0

data/test/test_Data_Object.cpp

@@ -1,4 +1,5 @@
 #include "unittest.hpp"
+#include "embed_ruby.hpp"
 #include "rice/Data_Object.hpp"
 #include "rice/Data_Type.hpp"
 #include "rice/Exception.hpp"
@@ -22,7 +23,7 @@ void ruby_mark(Foo * foo)
 
 SETUP(Data_Object)
 {
-  ruby_init();
+  embed_ruby();
 
   if(!Data_Type<Foo>::is_bound())
   {

data/test/test_Data_Type.cpp

@@ -1,4 +1,5 @@
 #include "unittest.hpp"
+#include "embed_ruby.hpp"
 #include "rice/Data_Type.hpp"
 #include "rice/Exception.hpp"
 #include "rice/Constructor.hpp"
@@ -63,7 +64,7 @@ namespace {
 
 SETUP(Data_Type)
 {
-  ruby_init();
+  embed_ruby();
 
   define_class<Listener>("Listener")
     .define_constructor(Constructor<Listener>())

data/test/test_Director.cpp

@@ -1,4 +1,5 @@
 #include "unittest.hpp"
+#include "embed_ruby.hpp"
 #include "rice/Exception.hpp"
 #include "rice/Director.hpp"
 #include "rice/Constructor.hpp"
@@ -87,7 +88,7 @@ namespace {
 
 SETUP(Director)
 {
-  ruby_init();
+  embed_ruby();
 }
 
 TESTCASE(exposes_worker_as_instantiatable_class)

data/test/test_Enum.cpp

@@ -1,8 +1,10 @@
 #include "unittest.hpp"
+#include "embed_ruby.hpp"
 #include "rice/Enum.hpp"
 #include "rice/Array.hpp"
 #include "rice/String.hpp"
 #include "rice/Constructor.hpp"
+#include "rice/global_function.hpp"
 #include <iostream>
 
 using namespace Rice;
@@ -25,7 +27,7 @@ namespace
 
 SETUP(Enum)
 {
-  ruby_init();
+  embed_ruby();
 }
 
 TESTCASE(copy_construct)
@@ -147,14 +149,12 @@ TESTCASE(different_objects_eql)
   ASSERT_EQUAL(true, red1 == red2);
 }
 
-/*
 TESTCASE(hash)
 {
   Enum<Color> rb_cColor = define_color_enum();
   Data_Object<Color> red(new Color(RED));
   ASSERT_EQUAL(to_ruby(int(RED)), red.call("hash"));
 }
-*/
 
 TESTCASE(from_int)
 {
@@ -193,3 +193,24 @@ TESTCASE(nested_enums)
   ASSERT_EQUAL(to_ruby(int(2)), Object(protect(rb_eval_string, "Inner::Props::VALUE3.to_i")));
 }
 
+namespace
+{
+  Color getEnum()
+  {
+    return GREEN;
+  }
+}
+
+TESTCASE(return_enum_value_to_ruby)
+{
+  Enum<Color> rb_cColor = define_color_enum();
+  define_global_function("get_enum", &getEnum);
+
+  ASSERT_EQUAL(
+    Data_Object<Color>(protect(rb_eval_string, "Color::GREEN")),
+    Data_Object<Color>(protect(rb_eval_string, "get_enum"))
+  );
+
+  ASSERT_EQUAL(String("GREEN"), String(protect(rb_eval_string, "get_enum.to_s")));
+  ASSERT_EQUAL(String("#<Color::GREEN>"), String(protect(rb_eval_string, "get_enum.inspect")));
+}

data/test/test_Exception.cpp

@@ -1,4 +1,5 @@
 #include "unittest.hpp"
+#include "embed_ruby.hpp"
 #include "rice/Exception.hpp"
 #include "rice/String.hpp"
 
@@ -8,7 +9,7 @@ TESTSUITE(Exception);
 
 SETUP(Exception)
 {
-  ruby_init();
+  embed_ruby();
 }
 
 TESTCASE(construct_from_exception_object)

data/test/test_Hash.cpp

@@ -1,4 +1,5 @@
 #include "unittest.hpp"
+#include "embed_ruby.hpp"
 #include "rice/Hash.hpp"
 #include "rice/global_function.hpp"
 #include <vector>
@@ -11,7 +12,7 @@ TESTSUITE(Hash);
 
 SETUP(Hash)
 {
-  ruby_init();
+  embed_ruby();
 }
 
 TESTCASE(default_construct)

data/test/test_Identifier.cpp

@@ -1,4 +1,5 @@
 #include "unittest.hpp"
+#include "embed_ruby.hpp"
 #include "rice/Identifier.hpp"
 #include "rice/Symbol.hpp"
 
@@ -8,7 +9,7 @@ TESTSUITE(Identifier);
 
 SETUP(Identifier)
 {
-  ruby_init();
+  embed_ruby();
 }
 
 TESTCASE(construct_from_id)

data/test/test_Memory_Management.cpp

@@ -1,4 +1,5 @@
 #include "unittest.hpp"
+#include "embed_ruby.hpp"
 #include "rice/String.hpp"
 #include "rice/Class.hpp"
 #include "rice/global_function.hpp"
@@ -9,7 +10,7 @@ TESTSUITE(Memory_Management);
 
 SETUP(Memory_Management)
 {
-  ruby_init();
+  embed_ruby();
 }
 
 namespace

data/test/test_Module.cpp

@@ -1,4 +1,5 @@
 #include "unittest.hpp"
+#include "embed_ruby.hpp"
 #include "rice/Module.hpp"
 #include "rice/Exception.hpp"
 #include "rice/Array.hpp"
@@ -12,7 +13,7 @@ TESTSUITE(Module);
 
 SETUP(Object)
 {
-  ruby_init();
+  embed_ruby();
 }
 
 TESTCASE(construct_from_value)

data/test/test_Object.cpp

@@ -1,4 +1,5 @@
 #include "unittest.hpp"
+#include "embed_ruby.hpp"
 #include "rice/Object.hpp"
 #include "rice/Class.hpp"
 #include "rice/String.hpp"
@@ -10,7 +11,7 @@ TESTSUITE(Object);
 
 SETUP(Object)
 {
-  ruby_init();
+  embed_ruby();
 }
 
 TESTCASE(default_construct)
@@ -146,3 +147,14 @@ TESTCASE(rb_type)
   ASSERT_EQUAL(T_UNDEF, Object(Qundef).rb_type());
 }
 
+TESTCASE(call_no_arguments)
+{
+  Object three = to_ruby(3).call("to_s");
+  ASSERT_EQUAL(String("3"), three);
+}
+
+TESTCASE(call_return_rice_object)
+{
+  Object three = to_ruby(1).call("+", 2);
+  ASSERT_EQUAL(to_ruby(3), three);
+}

data/test/test_String.cpp

@@ -1,4 +1,5 @@
 #include "unittest.hpp"
+#include "embed_ruby.hpp"
 #include "rice/String.hpp"
 #include "rice/global_function.hpp"
 
@@ -8,7 +9,7 @@ TESTSUITE(String);
 
 SETUP(String)
 {
-  ruby_init();
+  embed_ruby();
 }
 
 TESTCASE(default_construct)

data/test/test_Struct.cpp

@@ -1,4 +1,5 @@
 #include "unittest.hpp"
+#include "embed_ruby.hpp"
 #include "rice/Struct.hpp"
 #include "rice/Symbol.hpp"
 #include "rice/global_function.hpp"
@@ -22,7 +23,7 @@ namespace
 
 SETUP(Struct)
 {
-  ruby_init();
+  embed_ruby();
 }
 
 TESTCASE(default_construct)

data/test/test_Symbol.cpp

@@ -1,4 +1,5 @@
 #include "unittest.hpp"
+#include "embed_ruby.hpp"
 #include "rice/Symbol.hpp"
 #include "rice/Identifier.hpp"
 
@@ -8,7 +9,7 @@ TESTSUITE(Symbol);
 
 SETUP(Symbol)
 {
-  ruby_init();
+  embed_ruby();
 }
 
 TESTCASE(construct_from_symbol)

data/test/test_To_From_Ruby.cpp

@@ -1,4 +1,5 @@
 #include "unittest.hpp"
+#include "embed_ruby.hpp"
 #include "rice/to_from_ruby.hpp"
 #include "rice/String.hpp"
 #include "rice/Array.hpp"
@@ -12,7 +13,7 @@ TESTSUITE(To_From_Ruby);
 
 SETUP(To_From_Ruby)
 {
-  ruby_init();
+  embed_ruby();
 }
 
 TESTCASE(object_to_ruby)
@@ -27,6 +28,32 @@ TESTCASE(object_from_ruby)
   ASSERT_EQUAL(o.value(), from_ruby<Object>(o).value());
 }
 
+TESTCASE(short_to_ruby)
+{
+  ASSERT_EQUAL(INT2NUM(0), to_ruby((short)0).value());
+  ASSERT_EQUAL(INT2NUM(-1), to_ruby((short)-1).value());
+  ASSERT_EQUAL(INT2NUM(1), to_ruby((short)1).value());
+  ASSERT_EQUAL(
+      Object(INT2NUM(std::numeric_limits<short>::min())),
+      to_ruby(std::numeric_limits<short>::min()));
+  ASSERT_EQUAL(
+      Object(INT2NUM(std::numeric_limits<short>::max())),
+      to_ruby(std::numeric_limits<short>::max()));
+}
+
+TESTCASE(short_from_ruby)
+{
+  ASSERT_EQUAL(0, from_ruby<short>(INT2NUM(0)));
+  ASSERT_EQUAL(-1, from_ruby<short>(INT2NUM(-1)));
+  ASSERT_EQUAL(1, from_ruby<short>(INT2NUM(1)));
+  ASSERT_EQUAL(
+      std::numeric_limits<short>::min(),
+      from_ruby<short>(INT2NUM(std::numeric_limits<short>::min())));
+  ASSERT_EQUAL(
+      std::numeric_limits<short>::max(),
+      from_ruby<short>(INT2NUM(std::numeric_limits<short>::max())));
+}
+
 TESTCASE(int_to_ruby)
 {
   ASSERT_EQUAL(INT2NUM(0), to_ruby((int)0).value());
@@ -91,6 +118,56 @@ TESTCASE(long_from_ruby)
       from_ruby<long>(LONG2NUM(std::numeric_limits<long>::max())));
 }
 
+TESTCASE(long_long_to_ruby)
+{
+  ASSERT_EQUAL(LL2NUM(0), to_ruby((long long)0).value());
+  ASSERT_EQUAL(LL2NUM(-1), to_ruby((long long)-1).value());
+  ASSERT_EQUAL(LL2NUM(1), to_ruby((long long)1).value());
+  ASSERT_EQUAL(
+      Object(LL2NUM(std::numeric_limits<long long>::min())),
+      to_ruby(std::numeric_limits<long long>::min()));
+  ASSERT_EQUAL(
+      Object(LL2NUM(std::numeric_limits<long long>::max())),
+      to_ruby(std::numeric_limits<long long>::max()));
+}
+
+TESTCASE(long_long_from_ruby)
+{
+  ASSERT_EQUAL(0, from_ruby<long long>(LL2NUM(0)));
+  ASSERT_EQUAL(-1, from_ruby<long long>(LL2NUM(-1)));
+  ASSERT_EQUAL(1, from_ruby<long long>(LL2NUM(1)));
+  ASSERT_EQUAL(
+      std::numeric_limits<long long>::min(),
+      from_ruby<long long>(LL2NUM(std::numeric_limits<long long>::min())));
+  ASSERT_EQUAL(
+      std::numeric_limits<long long>::max(),
+      from_ruby<long long>(LL2NUM(std::numeric_limits<long long>::max())));
+}
+
+TESTCASE(unsigned_short_to_ruby)
+{
+  ASSERT_EQUAL(UINT2NUM(0), to_ruby((unsigned short)0).value());
+  ASSERT_EQUAL(UINT2NUM(1), to_ruby((unsigned short)1).value());
+  ASSERT_EQUAL(
+      Object(UINT2NUM(std::numeric_limits<unsigned short>::min())),
+      to_ruby(std::numeric_limits<unsigned short>::min()));
+  ASSERT_EQUAL(
+      Object(UINT2NUM(std::numeric_limits<unsigned short>::max())),
+      to_ruby(std::numeric_limits<unsigned short>::max()));
+}
+
+TESTCASE(unsigned_short_from_ruby)
+{
+  ASSERT_EQUAL(0u, from_ruby<unsigned short>(UINT2NUM(0)));
+  ASSERT_EQUAL(1u, from_ruby<unsigned short>(UINT2NUM(1)));
+  ASSERT_EQUAL(
+      std::numeric_limits<unsigned short>::min(),
+      from_ruby<unsigned short>(UINT2NUM(std::numeric_limits<unsigned short>::min())));
+  ASSERT_EQUAL(
+      std::numeric_limits<unsigned short>::max(),
+      from_ruby<unsigned short>(UINT2NUM(std::numeric_limits<unsigned short>::max())));
+}
+
 TESTCASE(unsigned_int_to_ruby)
 {
   ASSERT_EQUAL(UINT2NUM(0), to_ruby((unsigned int)0).value());
@@ -145,6 +222,30 @@ TESTCASE(unsigned_long_from_ruby)
       from_ruby<unsigned long>(ULONG2NUM(std::numeric_limits<unsigned long>::max())));
 }
 
+TESTCASE(unsigned_long_long_to_ruby)
+{
+  ASSERT_EQUAL(ULL2NUM(0), to_ruby((unsigned long long)0).value());
+  ASSERT_EQUAL(ULL2NUM(1), to_ruby((unsigned long long)1).value());
+  ASSERT_EQUAL(
+      Object(ULL2NUM(std::numeric_limits<unsigned long long>::min())),
+      to_ruby(std::numeric_limits<unsigned long long>::min()));
+  ASSERT_EQUAL(
+      Object(ULL2NUM(std::numeric_limits<unsigned long long>::max())),
+      to_ruby(std::numeric_limits<unsigned long long>::max()));
+}
+
+TESTCASE(unsigned_long_long_from_ruby)
+{
+  ASSERT_EQUAL(0u, from_ruby<unsigned long>(ULL2NUM(0)));
+  ASSERT_EQUAL(1u, from_ruby<unsigned long>(ULL2NUM(1)));
+  ASSERT_EQUAL(
+      std::numeric_limits<unsigned long long>::min(),
+      from_ruby<unsigned long long>(ULL2NUM(std::numeric_limits<unsigned long long>::min())));
+  ASSERT_EQUAL(
+      std::numeric_limits<unsigned long long>::max(),
+      from_ruby<unsigned long long>(ULL2NUM(std::numeric_limits<unsigned long long>::max())));
+}
+
 TESTCASE(bool_to_ruby)
 {
   ASSERT_EQUAL(Qfalse, to_ruby(false).value());

data/test/test_global_functions.cpp

@@ -1,4 +1,5 @@
 #include "unittest.hpp"
+#include "embed_ruby.hpp"
 #include "rice/global_function.hpp"
 
 using namespace Rice;
@@ -7,7 +8,7 @@ TESTSUITE(GlobalFunction);
 
 SETUP(GlobalFunction)
 {
-  ruby_init();
+  embed_ruby();
 }
 
 namespace {

data/test/test_rice.rb

@@ -26,6 +26,10 @@ class RiceTest < Minitest::Test
     run_external_test("#{RUBY} test_multiple_extensions_same_class.rb")
   end
 
+  def test_callbacks_sample
+    run_external_test("#{RUBY} test_callbacks_sample.rb")
+  end
+
   def run_external_test(executable)
     if VERBOSE then
       system(executable)

data/test/unittest.cpp

@@ -1,3 +1,4 @@
+#include <algorithm>
 #include <iostream>
 #include <map>
 #include "unittest.hpp"
@@ -85,18 +86,43 @@ run(Test_Result & result)
   }
 }
 
-int main()
+char* findOption(char** begin, char** end, const std::string& option)
 {
+  char** itr = std::find(begin, end, option);
+  if (itr != end && ++itr != end)
+  {
+    return *itr;
+  }
+  return nullptr;
+}
+
+int main(int argc, char** argv)
+{
+  std::vector<Test_Suite> suites;
+
+  char* moduleName = findOption(argv, argv + argc, "--suite");
+  if (moduleName)
+  {
+    Test_Suite suite = test_suites()[moduleName];
+    suites.push_back(suite);
+  }
+  else
+  {
+    std::transform(test_suites().begin(), test_suites().end(),
+      std::back_inserter(suites),
+      [](auto& pair)
+      {
+        return pair.second;
+      });
+  }
+
   Test_Result result;
   size_t num_tests = 0;
-
-  for(Test_Suites::iterator it = test_suites().begin(),
-      end = test_suites().end();
-      it != end;
-      ++it)
+  
+  for (Test_Suite& suite : suites)
   {
-    it->second.run(result);
-    num_tests += it->second.size();
+    suite.run(result);
+    num_tests += suite.size();
   }
 
   std::cout << std::endl;
@@ -131,6 +157,6 @@ int main()
     }
   }
 
-  return result.errors().size() + result.failures().size();
+  return (int)result.errors().size() + (int)result.failures().size();
 }