rice 2.1.2 → 4.0.1

data/test/test_Exception.cpp

@@ -1,6 +1,6 @@
 #include "unittest.hpp"
-#include "rice/Exception.hpp"
-#include "rice/String.hpp"
+#include "embed_ruby.hpp"
+#include <rice/rice.hpp>
 
 using namespace Rice;
 
@@ -8,19 +8,19 @@ TESTSUITE(Exception);
 
 SETUP(Exception)
 {
-  ruby_init();
+  embed_ruby();
 }
 
 TESTCASE(construct_from_exception_object)
 {
-  VALUE v = protect(rb_exc_new2, rb_eRuntimeError, "foo");
+  VALUE v = detail::protect(rb_exc_new2, rb_eRuntimeError, "foo");
   Exception ex(v);
   ASSERT_EQUAL(ex.value(), v);
 }
 
 TESTCASE(copy_construct)
 {
-  VALUE v = protect(rb_exc_new2, rb_eRuntimeError, "foo");
+  VALUE v = detail::protect(rb_exc_new2, rb_eRuntimeError, "foo");
   Exception ex1(v);
   Exception ex2(v);
   ASSERT_EQUAL(ex2.value(), v);
@@ -29,13 +29,13 @@ TESTCASE(copy_construct)
 TESTCASE(construct_from_format_string)
 {
   Exception ex(rb_eRuntimeError, "%s", "foo");
-  ASSERT_EQUAL(ex.class_of(), Object(rb_eRuntimeError));
+  ASSERT_EQUAL(rb_eRuntimeError, ex.class_of());
 }
 
 TESTCASE(message)
 {
   Exception ex(rb_eRuntimeError, "%s", "foo");
-  ASSERT_EQUAL(String("foo"), ex.message());
+  ASSERT_EQUAL("foo", ex.what());
 }
 
 TESTCASE(what)

data/test/test_Hash.cpp

@@ -1,6 +1,7 @@
 #include "unittest.hpp"
-#include "rice/Hash.hpp"
-#include "rice/global_function.hpp"
+#include "embed_ruby.hpp"
+#include <rice/rice.hpp>
+
 #include <vector>
 #include <map>
 #include <algorithm>
@@ -11,14 +12,14 @@ TESTSUITE(Hash);
 
 SETUP(Hash)
 {
-  ruby_init();
+  embed_ruby();
 }
 
 TESTCASE(default_construct)
 {
   Hash h;
   ASSERT_EQUAL(T_HASH, rb_type(h));
-  ASSERT_EQUAL(0, RHASH_SIZE(h.value()));
+  ASSERT_EQUAL(0u, RHASH_SIZE(h.value()));
 }
 
 TESTCASE(construct_from_object)
@@ -26,7 +27,7 @@ TESTCASE(construct_from_object)
   Object o(rb_hash_new());
   Hash h(o);
   ASSERT_EQUAL(T_HASH, rb_type(h));
-  ASSERT_EQUAL(0, RHASH_SIZE(h.value()));
+  ASSERT_EQUAL(0u, RHASH_SIZE(h.value()));
 }
 
 TESTCASE(construct_from_value)
@@ -34,7 +35,7 @@ TESTCASE(construct_from_value)
   VALUE v(rb_hash_new());
   Hash h(v);
   ASSERT_EQUAL(T_HASH, rb_type(h));
-  ASSERT_EQUAL(0, RHASH_SIZE(h.value()));
+  ASSERT_EQUAL(0u, RHASH_SIZE(h.value()));
 }
 
 TESTCASE(copy_construct)
@@ -49,6 +50,7 @@ TESTCASE(assignment)
   Hash h;
   Hash h2;
   h = h2;
+  ASSERT_EQUAL(h.value(), h2.value());
 }
 
 TESTCASE(size)
@@ -72,9 +74,9 @@ TESTCASE(bracket)
   h[6] = 9;
   h[42] = 42;
   h[6] = 1;
-  ASSERT_EQUAL(to_ruby(5), Object(h[1]));
-  ASSERT_EQUAL(to_ruby(42), Object(h[42]));
-  ASSERT_EQUAL(to_ruby(1), Object(h[6]));
+  ASSERT_EQUAL(detail::to_ruby(5), h[1].value());
+  ASSERT_EQUAL(detail::to_ruby(42), h[42].value());
+  ASSERT_EQUAL(detail::to_ruby(1), h[6].value());
 }
 
 TESTCASE(get)
@@ -100,15 +102,15 @@ TESTCASE(construct_vector_from_hash_iterators)
   std::vector<Hash::Entry> v(h.begin(), h.end());
   std::sort(v.begin(), v.end());
   ASSERT_EQUAL(3u, v.size());
-  ASSERT_EQUAL(v[0].key, to_ruby(1));
-  ASSERT_EQUAL(v[1].key, to_ruby(6));
-  ASSERT_EQUAL(v[2].key, to_ruby(42));
+  ASSERT_EQUAL(v[0].key.value(), detail::to_ruby(1));
+  ASSERT_EQUAL(v[1].key.value(), detail::to_ruby(6));
+  ASSERT_EQUAL(v[2].key.value(), detail::to_ruby(42));
   ASSERT_EQUAL(&v[0].key, &v[0].first);
   ASSERT_EQUAL(&v[1].key, &v[1].first);
   ASSERT_EQUAL(&v[2].key, &v[2].first);
-  ASSERT_EQUAL(v[0].value, to_ruby(5));
-  ASSERT_EQUAL(v[1].value, to_ruby(1));
-  ASSERT_EQUAL(v[2].value, to_ruby(42));
+  ASSERT_EQUAL(v[0].value, detail::to_ruby(5));
+  ASSERT_EQUAL(v[1].value, detail::to_ruby(1));
+  ASSERT_EQUAL(v[2].value, detail::to_ruby(42));
   ASSERT_EQUAL(&v[0].value, &v[0].second);
   ASSERT_EQUAL(&v[1].value, &v[1].second);
   ASSERT_EQUAL(&v[2].value, &v[2].second);
@@ -133,15 +135,15 @@ TESTCASE(iterate)
 
   std::sort(v.begin(), v.end());
   ASSERT_EQUAL(3u, v.size());
-  ASSERT_EQUAL(v[0].key, to_ruby(1));
-  ASSERT_EQUAL(v[1].key, to_ruby(6));
-  ASSERT_EQUAL(v[2].key, to_ruby(42));
+  ASSERT_EQUAL(v[0].key.value(), detail::to_ruby(1));
+  ASSERT_EQUAL(v[1].key.value(), detail::to_ruby(6));
+  ASSERT_EQUAL(v[2].key.value(), detail::to_ruby(42));
   ASSERT_EQUAL(&v[0].key, &v[0].first);
   ASSERT_EQUAL(&v[1].key, &v[1].first);
   ASSERT_EQUAL(&v[2].key, &v[2].first);
-  ASSERT_EQUAL(v[0].value, to_ruby(5));
-  ASSERT_EQUAL(v[1].value, to_ruby(1));
-  ASSERT_EQUAL(v[2].value, to_ruby(42));
+  ASSERT_EQUAL(v[0].value, detail::to_ruby(5));
+  ASSERT_EQUAL(v[1].value, detail::to_ruby(1));
+  ASSERT_EQUAL(v[2].value, detail::to_ruby(42));
   ASSERT_EQUAL(&v[0].value, &v[0].second);
   ASSERT_EQUAL(&v[1].value, &v[1].second);
   ASSERT_EQUAL(&v[2].value, &v[2].second);
@@ -163,15 +165,15 @@ TESTCASE(const_iterate)
   }
   std::sort(v.begin(), v.end());
   ASSERT_EQUAL(3u, v.size());
-  ASSERT_EQUAL(v[0].key, to_ruby(1));
-  ASSERT_EQUAL(v[1].key, to_ruby(6));
-  ASSERT_EQUAL(v[2].key, to_ruby(42));
+  ASSERT_EQUAL(v[0].key.value(), detail::to_ruby(1));
+  ASSERT_EQUAL(v[1].key.value(), detail::to_ruby(6));
+  ASSERT_EQUAL(v[2].key.value(), detail::to_ruby(42));
   ASSERT_EQUAL(&v[0].key, &v[0].first);
   ASSERT_EQUAL(&v[1].key, &v[1].first);
   ASSERT_EQUAL(&v[2].key, &v[2].first);
-  ASSERT_EQUAL(v[0].value, to_ruby(5));
-  ASSERT_EQUAL(v[1].value, to_ruby(1));
-  ASSERT_EQUAL(v[2].value, to_ruby(42));
+  ASSERT_EQUAL(v[0].value.value(), detail::to_ruby(5));
+  ASSERT_EQUAL(v[1].value.value(), detail::to_ruby(1));
+  ASSERT_EQUAL(v[2].value.value(), detail::to_ruby(42));
   ASSERT_EQUAL(&v[0].value, &v[0].value);
   ASSERT_EQUAL(&v[1].value, &v[1].value);
   ASSERT_EQUAL(&v[2].value, &v[2].value);
@@ -190,12 +192,12 @@ TESTCASE(iterate_and_change)
   for(int j = 0; it != end; ++j, ++it)
   {
     it->second = j;
-    m[from_ruby<int>(it->first)] = j;
+    m[detail::From_Ruby<int>().convert(it->first)] = j;
   }
   ASSERT_EQUAL(3u, m.size());
-  ASSERT_EQUAL(to_ruby(m[1]), h[1]);
-  ASSERT_EQUAL(to_ruby(m[6]), h[6]);
-  ASSERT_EQUAL(to_ruby(m[42]), h[42]);
+  ASSERT_EQUAL(detail::to_ruby(m[1]), h[1]);
+  ASSERT_EQUAL(detail::to_ruby(m[6]), h[6]);
+  ASSERT_EQUAL(detail::to_ruby(m[42]), h[42]);
 }
 
 /**

data/test/test_Identifier.cpp

@@ -1,6 +1,6 @@
 #include "unittest.hpp"
-#include "rice/Identifier.hpp"
-#include "rice/Symbol.hpp"
+#include "embed_ruby.hpp"
+#include <rice/rice.hpp>
 
 using namespace Rice;
 
@@ -8,7 +8,7 @@ TESTSUITE(Identifier);
 
 SETUP(Identifier)
 {
-  ruby_init();
+  embed_ruby();
 }
 
 TESTCASE(construct_from_id)
@@ -31,10 +31,10 @@ TESTCASE(construct_from_c_string)
   ASSERT_EQUAL(rb_intern("Foo"), identifier.id());
 }
 
-TESTCASE(default_construct)
+TESTCASE(construct_from_string)
 {
-  Identifier identifier;
-  ASSERT_EQUAL(rb_intern(""), identifier.id());
+  Identifier identifier(std::string("Foo"));
+  ASSERT_EQUAL(rb_intern("Foo"), identifier.id());
 }
 
 TESTCASE(copy_construct)

data/test/test_Inheritance.cpp

@@ -0,0 +1,221 @@
+#include <assert.h> 
+
+#include "unittest.hpp"
+#include "embed_ruby.hpp"
+
+#include <rice/rice.hpp>
+#include <rice/stl.hpp>
+
+using namespace Rice;
+
+TESTSUITE(Inheritance);
+
+namespace
+{
+  enum class NotificationType
+  {
+    Email,
+    Push
+  };
+
+  class Notification
+  {
+  public:
+    virtual ~Notification() = default;
+    virtual std::string message() = 0;
+  };
+
+  class EmailNotification : public Notification
+  {
+    std::string message() override
+    {
+      return "Email";
+    }
+  };
+
+  class PushNotification : public Notification
+  {
+    std::string message() override
+    {
+      return "Push";
+    }
+  };
+
+  Notification* makeNotification(NotificationType type)
+  {
+    switch (type)
+    {
+    case NotificationType::Email:
+      return new EmailNotification();
+      break;
+
+    case NotificationType::Push:
+      return new PushNotification();
+
+    default:
+      return nullptr; // Will never happen but makes compiler happy
+    }
+  }
+
+  std::string processNotification(Notification* notification)
+  {
+    return notification->message();
+  }
+}
+
+Enum<NotificationType> createNotificationEnum()
+{
+  return define_enum<NotificationType>("NotificationType")
+    .define_value("Email", NotificationType::Email)
+    .define_value("Push", NotificationType::Push);
+}
+
+SETUP(Inheritance)
+{
+  embed_ruby();
+  static Enum<NotificationType> NotificationEnum = createNotificationEnum();
+
+  Data_Type<Notification>::unbind();
+  Data_Type<EmailNotification>::unbind();
+  Data_Type<PushNotification>::unbind();
+}
+
+TESTCASE(return_base_pointer)
+{
+  Class rcNotification = define_class<Notification>("Notification");
+
+  Class rcEmailNotification = define_class<EmailNotification, Notification>("EmailNotification")
+    .define_constructor(Constructor<PushNotification>());
+
+  Class rcPushNotification = define_class<PushNotification, Notification>("PushNotification")
+    .define_constructor(Constructor<PushNotification>());
+
+  define_global_function("make_notification", &makeNotification);
+
+  Module m = define_module("Testing");
+
+  Object notification = m.instance_eval("make_notification(NotificationType::Email)");
+  String temp = notification.class_of().name();
+  std::string temp2 = detail::From_Ruby<std::string>().convert(temp);
+
+  ASSERT(rb_obj_is_kind_of(notification, rcNotification));
+  ASSERT(rb_obj_is_kind_of(notification, rcEmailNotification));
+  ASSERT(!rb_obj_is_kind_of(notification, rcPushNotification));
+  ASSERT(rb_obj_is_instance_of(notification, rcEmailNotification));
+
+  notification = m.instance_eval("make_notification(NotificationType::Push)");
+  ASSERT(rb_obj_is_kind_of(notification, rcNotification));
+  ASSERT(!rb_obj_is_kind_of(notification, rcEmailNotification));
+  ASSERT(rb_obj_is_kind_of(notification, rcPushNotification));
+  ASSERT(rb_obj_is_instance_of(notification, rcPushNotification));
+}
+
+TESTCASE(base_pointer_method_call)
+{
+  Class rcNotification = define_class<Notification>("Notification")
+    .define_method("message", &Notification::message);
+
+  Class rcEmailNotification = define_class<EmailNotification, Notification>("EmailNotification")
+    .define_constructor(Constructor<EmailNotification>());
+
+  Class rcPushNotification = define_class<PushNotification, Notification>("PushNotification")
+    .define_constructor(Constructor<PushNotification>());
+
+  Module m = define_module("Testing");
+
+  Object message = m.instance_eval(R"EOS(notification = EmailNotification.new
+                                         notification.message)EOS");
+  ASSERT_EQUAL("Email", detail::From_Ruby<std::string>().convert(message));
+
+  message = m.instance_eval(R"EOS(notification = PushNotification.new
+                                  notification.message)EOS");
+  ASSERT_EQUAL("Push", detail::From_Ruby<std::string>().convert(message));
+}
+
+TESTCASE(base_pointer_function_argument)
+{
+  Class rcNotification = define_class<Notification>("Notification")
+    .define_method("message", &Notification::message);
+
+  Class rcEmailNotification = define_class<EmailNotification, Notification>("EmailNotification")
+    .define_constructor(Constructor<EmailNotification>());
+
+  Class rcPushNotification = define_class<PushNotification, Notification>("PushNotification")
+    .define_constructor(Constructor<PushNotification>());
+
+  define_global_function("process_notification", &processNotification);
+
+  Module m = define_module("Testing");
+  Object message = m.instance_eval(R"EOS(notification = EmailNotification.new
+                                         process_notification(notification))EOS");
+  ASSERT_EQUAL("Email", detail::From_Ruby<std::string>().convert(message));
+
+  message = m.instance_eval(R"EOS(notification = PushNotification.new
+                                  process_notification(notification))EOS");
+  ASSERT_EQUAL("Push", detail::From_Ruby<std::string>().convert(message));
+}
+
+TESTCASE(module_base_pointer_method_call)
+{
+  Module mInheritance = define_module("Inheritance");
+
+  Class rcNotification = define_class_under<Notification>(mInheritance, "Notification")
+    .define_method("message", &Notification::message);
+
+  Class rcEmailNotification = define_class_under<EmailNotification, Notification>(mInheritance, "EmailNotification")
+    .define_constructor(Constructor<EmailNotification>());
+
+  Class rcPushNotification = define_class_under<PushNotification, Notification>(mInheritance, "PushNotification")
+    .define_constructor(Constructor<PushNotification>());
+
+  Module m = define_module("Testing");
+
+  Object message = m.instance_eval(R"EOS(notification = Inheritance::EmailNotification.new
+                                         notification.message)EOS");
+  ASSERT_EQUAL("Email", detail::From_Ruby<std::string>().convert(message));
+
+  message = m.instance_eval(R"EOS(notification = Inheritance::PushNotification.new
+                                  notification.message)EOS");
+  ASSERT_EQUAL("Push", detail::From_Ruby<std::string>().convert(message));
+}
+
+namespace
+{
+  class Processor
+  {
+  public:
+    Processor(Notification* notification) : notification_(notification)
+    {
+    }
+
+    std::string process()
+    {
+      return notification_->message();
+    }
+
+  private:
+    Notification* notification_;
+  };
+}
+
+TESTCASE(base_pointer_constructor)
+{
+  Class rcNotification = define_class<Notification>("Notification");
+
+  Class rcEmailNotification = define_class<EmailNotification, Notification>("EmailNotification")
+    .define_constructor(Constructor<PushNotification>());
+
+  Class rcPushNotification = define_class<PushNotification, Notification>("PushNotification")
+    .define_constructor(Constructor<PushNotification>());
+
+  Class rcProcessor = define_class<Processor, Notification>("Processor")
+    .define_constructor(Constructor<Processor, Notification*>())
+    .define_method("process", &Processor::process);
+
+  Module m = define_module("Testing");
+
+  Object result = m.instance_eval(R"EOS(notification = PushNotification.new
+                                        processor = Processor.new(notification)
+                                        processor.process)EOS");
+  ASSERT_EQUAL("Push", detail::From_Ruby<std::string>().convert(result));
+}

data/test/test_Iterator.cpp

@@ -0,0 +1,161 @@
+#include "unittest.hpp"
+#include "embed_ruby.hpp"
+#include <rice/rice.hpp>
+
+using namespace Rice;
+
+TESTSUITE(Iterator);
+
+SETUP(Iterator)
+{
+  embed_ruby();
+}
+
+namespace
+{
+  class Container
+  {
+  public:
+    Container(int* array, size_t length)
+      : array_(array)
+      , length_(length)
+    {
+    }
+
+    // Custom names to make sure we call the function pointers rather than
+    // expectable default names.
+    int* beginFoo() { return array_; }
+    int* endBar() { return array_ + length_; }
+
+  private:
+    int* array_;
+    size_t length_;
+  };
+} // namespace
+
+TESTCASE(define_array_iterator)
+{
+  define_class<Container>("Container")
+    .define_constructor(Constructor<Container, int*, size_t>())
+    .define_iterator(&Container::beginFoo, &Container::endBar);
+
+  int array[] = { 1, 2, 3 };
+  Container* container = new Container(array, 3);
+
+  Object wrapped_container = Data_Object<Container>(container);
+
+  Array a = wrapped_container.instance_eval("a = []; each() { |x| a << x }; a");
+  ASSERT_EQUAL(3u, a.size());
+  ASSERT_EQUAL(Object(detail::to_ruby(1)), a[0]);
+  ASSERT_EQUAL(Object(detail::to_ruby(2)), a[1]);
+  ASSERT_EQUAL(Object(detail::to_ruby(3)), a[2]);
+}
+
+namespace
+{
+  struct Data
+  {
+    uint32_t index;
+  };
+
+  class ContainerValues
+  {
+  public:
+    ContainerValues()
+    {
+      this->data_ = { {1}, {2}, {3}};
+    }
+
+    std::vector<Data>::iterator begin()
+    {
+      return this->data_.begin();
+    }
+
+    std::vector<Data>::iterator end()
+    {
+      return this->data_.end();
+    }
+
+    std::vector<Data> data_;
+  };
+
+  class ContainerPointers
+  {
+  public:
+    ContainerPointers()
+    {
+      this->data_ = { new Data{1}, new Data{2},  new Data{3} };
+    }
+
+    ~ContainerPointers()
+    {
+      for (Data* data : this->data_)
+      {
+        delete data;
+      }
+    }
+
+    std::vector<Data*>::iterator begin()
+    {
+      return this->data_.begin();
+    }
+
+    std::vector<Data*>::iterator end()
+    {
+      return this->data_.end();
+    }
+
+    std::vector<Data*> data_;
+  };
+}
+
+template <>
+struct detail::To_Ruby<Data>
+{
+  static VALUE convert(const Data& data)
+  {
+    return detail::to_ruby(data.index);
+  }
+};
+
+template <>
+struct detail::To_Ruby<Data*>
+{
+  static VALUE convert(const Data* data)
+  {
+    return detail::to_ruby(data->index);
+  }
+};
+
+TESTCASE(iterator_value)
+{
+  define_class<ContainerValues>("ContainerValues")
+      .define_constructor(Constructor<ContainerValues>())
+      .define_iterator(&ContainerValues::begin, &ContainerValues::end);
+
+  ContainerValues* container = new ContainerValues();
+  Object wrapper = Data_Object<ContainerValues>(container);
+
+  Array a = wrapper.instance_eval("a = []; each() { |x| a << x }; a");
+  ASSERT_EQUAL(3u, a.size());
+
+  ASSERT_EQUAL(Object(detail::to_ruby(1)), a[0]);
+  ASSERT_EQUAL(Object(detail::to_ruby(2)), a[1]);
+  ASSERT_EQUAL(Object(detail::to_ruby(3)), a[2]);
+}
+
+TESTCASE(iterator_pointer)
+{
+  define_class<ContainerPointers>("ContainerPointers")
+    .define_constructor(Constructor<ContainerPointers>())
+    .define_iterator(&ContainerPointers::begin, &ContainerPointers::end);
+
+  ContainerPointers* container = new ContainerPointers();
+  Object wrapper = Data_Object<ContainerPointers>(container);
+
+  Array a = wrapper.instance_eval("a = []; each() { |x| a << x }; a");
+  ASSERT_EQUAL(3u, a.size());
+  ASSERT_EQUAL(Object(detail::to_ruby(1)), a[0]);
+  ASSERT_EQUAL(Object(detail::to_ruby(2)), a[1]);
+  ASSERT_EQUAL(Object(detail::to_ruby(3)), a[2]);
+}