rice 4.0.4 → 4.2.0

data/sample/inheritance/extconf.rb

@@ -1,5 +1,4 @@
 require 'bundler/setup'
-require 'rice'
 require 'mkmf-rice'
 
 create_makefile('animals')

data/sample/map/extconf.rb

@@ -1,5 +1,4 @@
 require 'bundler/setup'
-require 'rice'
 require 'mkmf-rice'
 
 create_makefile('map')

data/test/embed_ruby.cpp

@@ -15,21 +15,12 @@ void embed_ruby()
     ruby_init();
     ruby_init_loadpath();
 
-    initialized__ = true;
+#if RUBY_API_VERSION_MAJOR == 3 && RUBY_API_VERSION_MINOR >= 3
+    // Force the prelude / builtins
+    char *opts[] = { "ruby", "-e;" };
+    ruby_options(2, opts);
+#endif
 
-    // Because Ruby 3 no longer initializes the GC module when embedding, calling GC.stress 
-    // results in a crash.
-    // See https://bugs.ruby-lang.org/issues/17643
-    if (RUBY_API_VERSION_MAJOR == 3 &&
-       (RUBY_API_VERSION_MINOR == 1 ||
-       (RUBY_API_VERSION_MINOR == 0 &&
-        RUBY_API_VERSION_TEENY == 0)))
-    {
-      // do nothing
-    }
-    else
-    {
-      rb_eval_string("GC.stress = true");
-    }
+    initialized__ = true;
   }
 }

data/test/ext/t1/extconf.rb

@@ -1,5 +1,4 @@
 require 'bundler/setup'
-require 'rice'
 require 'mkmf-rice'
 
 create_makefile('t1')

data/test/ext/t2/extconf.rb

@@ -1,5 +1,4 @@
 require 'bundler/setup'
-require 'rice'
 require 'mkmf-rice'
 
 create_makefile('t2')

data/test/extconf.rb

@@ -1,5 +1,4 @@
 require 'bundler/setup'
-require 'rice'
 require 'mkmf-rice'
 require 'rbconfig'
 

data/test/test_Array.cpp

@@ -8,14 +8,15 @@ using namespace Rice;
 
 TESTSUITE(Array);
 
-// This is needed to make unittest compile (it uses ostream to report errors)
-inline std::ostream& operator<<(std::ostream& os, const std::vector<int32_t>& vector)
-{
-  for (auto i : vector)
-  {
-    os << i << ", ";
+namespace {
+  // This is needed to make unittest compile (it uses ostream to report errors)
+  template<typename T>
+  std::ostream &operator<<(std::ostream &os, const std::vector<T> &vector) {
+    for (T &i: vector) {
+      os << i << ", ";
+    }
+    return os;
   }
-  return os;
 }
 
 SETUP(Array)
@@ -37,7 +38,7 @@ TESTCASE(construct_from_vector_of_int)
   v.push_back(6);
   v.push_back(42);
   Array a(v.begin(), v.end());
-  ASSERT_EQUAL(3u, a.size());
+  ASSERT_EQUAL(3, a.size());
   ASSERT(rb_equal(detail::to_ruby(10), a[0].value()));
   ASSERT(rb_equal(detail::to_ruby(6), a[1].value()));
   ASSERT(rb_equal(detail::to_ruby(42), a[2].value()));
@@ -47,7 +48,7 @@ TESTCASE(construct_from_c_array)
 {
   int arr[] = { 10, 6, 42 };
   Array a(arr);
-  ASSERT_EQUAL(3u, a.size());
+  ASSERT_EQUAL(3, a.size());
   ASSERT(rb_equal(detail::to_ruby(10), a[0].value()));
   ASSERT(rb_equal(detail::to_ruby(6), a[1].value()));
   ASSERT(rb_equal(detail::to_ruby(42), a[2].value()));
@@ -56,14 +57,14 @@ TESTCASE(construct_from_c_array)
 TESTCASE(push_no_items)
 {
   Array a;
-  ASSERT_EQUAL(0u, a.size());
+  ASSERT_EQUAL(0, a.size());
 }
 
 TESTCASE(push_one_item)
 {
   Array a;
   a.push(Rice::True);
-  ASSERT_EQUAL(1u, a.size());
+  ASSERT_EQUAL(1, a.size());
   ASSERT_EQUAL(Qtrue, a[0]);
 }
 
@@ -72,7 +73,7 @@ TESTCASE(push_two_items)
   Array a;
   a.push(42);
   a.push(43);
-  ASSERT_EQUAL(2u, a.size());
+  ASSERT_EQUAL(2, a.size());
   ASSERT_EQUAL(42, detail::From_Ruby<int>().convert(a[0].value()));
   ASSERT_EQUAL(43, detail::From_Ruby<int>().convert(a[1].value()));
 }
@@ -83,7 +84,7 @@ TESTCASE(push_three_items)
   a.push(42);
   a.push(43);
   a.push(44);
-  ASSERT_EQUAL(3u, a.size());
+  ASSERT_EQUAL(3, a.size());
   ASSERT_EQUAL(42, detail::From_Ruby<int>().convert(a[0].value()));
   ASSERT_EQUAL(43, detail::From_Ruby<int>().convert(a[1].value()));
   ASSERT_EQUAL(44, detail::From_Ruby<int>().convert(a[2].value()));
@@ -93,7 +94,7 @@ TESTCASE(push_int)
 {
   Array a;
   a.push(42);
-  ASSERT_EQUAL(1u, a.size());
+  ASSERT_EQUAL(1, a.size());
   ASSERT(rb_equal(detail::to_ruby(42), a[0].value()));
 }
 
@@ -125,7 +126,7 @@ TESTCASE(pop)
   a.push(43);
   a.push(44);
   VALUE result = a.pop();
-  ASSERT_EQUAL(2u, a.size());
+  ASSERT_EQUAL(2, a.size());
   ASSERT_EQUAL(42, detail::From_Ruby<int>().convert(a[0].value()));
   ASSERT_EQUAL(43, detail::From_Ruby<int>().convert(a[1].value()));
   ASSERT_EQUAL(44, detail::From_Ruby<int>().convert(result));
@@ -138,7 +139,7 @@ TESTCASE(unshift)
   a.push(43);
   a.push(44);
   a.unshift(10);
-  ASSERT_EQUAL(4u, a.size());
+  ASSERT_EQUAL(4, a.size());
   ASSERT_EQUAL(10, detail::From_Ruby<int>().convert(a[0].value()));
   ASSERT_EQUAL(42, detail::From_Ruby<int>().convert(a[1].value()));
   ASSERT_EQUAL(43, detail::From_Ruby<int>().convert(a[2].value()));
@@ -149,7 +150,7 @@ TESTCASE(unshift_int)
 {
   Array a;
   a.unshift(42);
-  ASSERT_EQUAL(1u, a.size());
+  ASSERT_EQUAL(1, a.size());
   ASSERT(rb_equal(detail::to_ruby(42), a[0].value()));
 }
 
@@ -160,7 +161,7 @@ TESTCASE(shift)
   a.push(43);
   a.push(44);
   VALUE result = a.shift();
-  ASSERT_EQUAL(2u, a.size());
+  ASSERT_EQUAL(2, a.size());
   ASSERT_EQUAL(42, detail::From_Ruby<int>().convert(result));
   ASSERT_EQUAL(43, detail::From_Ruby<int>().convert(a[0].value()));
   ASSERT_EQUAL(44, detail::From_Ruby<int>().convert(a[1].value()));
@@ -214,10 +215,6 @@ TESTCASE(iterate_and_change)
   ASSERT_EQUAL(46, detail::From_Ruby<int>().convert(a[2].value()));
 }
 
-/**
- * This test is running into GC issues on CI. Entries in the array
- * are getting GC'd and the test is segfaulting. Really hard to reproduce
- * so disable for now.
 TESTCASE(iterate_and_call_member)
 {
   Array a;
@@ -239,7 +236,6 @@ TESTCASE(iterate_and_call_member)
   ASSERT_EQUAL(Object(a[1]).to_s(), v[1]);
   ASSERT_EQUAL(Object(a[2]).to_s(), v[2]);
 }
-*/
 
 TESTCASE(find_if)
 {
@@ -302,4 +298,4 @@ TESTCASE(array_from_ruby)
 {
   Array a(rb_ary_new());
   ASSERT_EQUAL(a, detail::From_Ruby<Array>().convert(a));
-}
+}

data/test/test_Attribute.cpp

@@ -1,4 +1,4 @@
-#include <assert.h> 
+#include <assert.h>
 
 #include "unittest.hpp"
 #include "embed_ruby.hpp"
@@ -60,9 +60,9 @@ TESTCASE(attributes)
   ASSERT_EXCEPTION_CHECK(
     Exception,
     o.call("read_char=", "some text"),
-    ASSERT_EQUAL("undefined method `read_char=' for :DataStruct", ex.what())
+    ASSERT(std::string(ex.what()).find("undefined method `read_char='") == 0)
   );
-  
+
   // Test writeonly attribute
   result = o.call("write_int=", 5);
   ASSERT_EQUAL(5, detail::From_Ruby<int>().convert(result.value()));
@@ -70,7 +70,7 @@ TESTCASE(attributes)
   ASSERT_EXCEPTION_CHECK(
     Exception,
     o.call("write_int", 3),
-    ASSERT_EQUAL("undefined method `write_int' for :DataStruct", ex.what())
+    ASSERT(std::string(ex.what()).find("undefined method `write_int'") == 0)
   );
 
   // Test readwrite attribute
@@ -101,7 +101,7 @@ TESTCASE(static_attributes)
   ASSERT_EXCEPTION_CHECK(
     Exception,
     c.call("static_string=", true),
-    ASSERT_EQUAL("undefined method `static_string=' for DataStruct:Class", ex.what())
+    ASSERT(std::string(ex.what()).find("undefined method `static_string='") == 0)
   );
 }
 
@@ -127,7 +127,7 @@ TESTCASE(not_defined)
 {
   Data_Type<DataStruct> c = define_class<DataStruct>("DataStruct");
 
-#ifdef _MSC_VER    
+#ifdef _MSC_VER
   const char* message = "Type is not defined with Rice: class `anonymous namespace'::SomeClass";
 #else
   const char* message = "Type is not defined with Rice: (anonymous namespace)::SomeClass";

data/test/test_Class.cpp

@@ -1,7 +1,6 @@
 #include "unittest.hpp"
 #include "embed_ruby.hpp"
 #include <rice/rice.hpp>
-#include <iostream>
 
 using namespace Rice;
 
@@ -47,33 +46,6 @@ TESTCASE(include_module)
   ASSERT_EQUAL(expected_ancestors, ancestors);
 }
 
-TESTCASE(const_set_get_by_id)
-{
-  Class c(anonymous_class());
-  Object v = detail::to_ruby(42);
-  Class & c2(c.const_set(rb_intern("FOO"), v));
-  ASSERT_EQUAL(&c, &c2);
-  ASSERT_EQUAL(v, c.const_get(rb_intern("FOO")));
-}
-
-TESTCASE(const_set_get_by_identifier)
-{
-  Class c(anonymous_class());
-  Object v = detail::to_ruby(42);
-  Class & c2(c.const_set(Identifier("FOO"), v));
-  ASSERT_EQUAL(&c, &c2);
-  ASSERT_EQUAL(v, c.const_get(Identifier("FOO")));
-}
-
-TESTCASE(const_set_get_by_string)
-{
-  Class c(anonymous_class());
-  Object v = detail::to_ruby(42);
-  Class & c2(c.const_set("FOO", v));
-  ASSERT_EQUAL(&c, &c2);
-  ASSERT_EQUAL(v, c.const_get("FOO"));
-}
-
 namespace
 {
   bool some_function()
@@ -173,9 +145,10 @@ namespace
 
 TESTCASE(add_handler)
 {
+  register_handler<Silly_Exception>(handle_silly_exception);
+
   Class c(rb_cObject);
-  c.add_handler<Silly_Exception>(handle_silly_exception)
-    .define_function("foo", throw_silly_exception);
+  c.define_function("foo", throw_silly_exception);
 
   Object exc = detail::protect(rb_eval_string, "begin; foo; rescue Exception; $!; end");
   ASSERT_EQUAL(rb_eRuntimeError, CLASS_OF(exc));
@@ -285,18 +258,6 @@ TESTCASE(define_method_default_arguments)
   ASSERT(!defaults_method_one_arg3);
 }
 
-TESTCASE(invalid_comma_operator)
-{
-  Class c = define_class<DefaultArgs>("DefaultArgs")
-    .define_constructor(Constructor<DefaultArgs>());
-
-  ASSERT_EXCEPTION_CHECK(
-    std::runtime_error,
-    c.define_method("with_defaults", &DefaultArgs::defaults_method_one, (Arg("arg1"), Arg("arg2") = 3, Arg("arg3") = true)),
-    ASSERT_EQUAL("The Arg class no longer supports the comma operator, please remove the surounding parentheses", ex.what())
-  );
-}
-
 namespace
 {
   int func1 = 0;
@@ -345,26 +306,26 @@ namespace
 
 TESTCASE(value_parameter)
 {
-  define_global_function("value_parameter", &value_parameter, Arg("value").isValue());
+  define_global_function("value_parameter", &value_parameter, Arg("value").setValue());
 
   Module m = define_module("TestingModule");
   
   std::string code = R"($object = Object.new)";
-  Object object = m.instance_eval(code);
+  Object object = m.module_eval(code);
 
   code = R"(value_parameter($object))";
-  m.instance_eval(code);
+  m.module_eval(code);
 
   ASSERT_EQUAL(someValue, object.value());
 }
 
 TESTCASE(value_return)
 {
-  define_global_function("value_return", &value_return, Return().isValue());
+  define_global_function("value_return", &value_return, Return().setValue());
 
   Module m = define_module("TestingModule");
 
-  VALUE value = m.instance_eval("value_return");
+  VALUE value = m.module_eval("value_return");
   detail::protect(rb_check_type, value, (int)T_ARRAY);
 
   ASSERT_EQUAL(3, Array(value).size());

data/test/test_Constructor.cpp

@@ -3,8 +3,6 @@
 
 #include <rice/rice.hpp>
 
-#include <iostream>
-
 using namespace Rice;
 
 TESTSUITE(Constructor);

data/test/test_Data_Object.cpp

@@ -1,3 +1,5 @@
+#include <ruby/version.h>
+
 #include "unittest.hpp"
 #include "embed_ruby.hpp"
 #include <rice/rice.hpp>
@@ -62,25 +64,25 @@ TESTCASE(construct_from_pointer)
   Data_Object<MyDataType> wrapped_foo(myDataType);
   ASSERT_EQUAL(myDataType, wrapped_foo.get());
   ASSERT_EQUAL(Data_Type<MyDataType>::klass(), wrapped_foo.class_of());
-  ASSERT_EQUAL(myDataType, detail::unwrap<MyDataType>(wrapped_foo, Data_Type<MyDataType>::rb_type()));
+  ASSERT_EQUAL(myDataType, detail::unwrap<MyDataType>(wrapped_foo, Data_Type<MyDataType>::ruby_data_type()));
 }
 
 TESTCASE(construct_from_ruby_object)
 {
   MyDataType * myDataType = new MyDataType;
-  VALUE wrapped_foo = detail::wrap(Data_Type<MyDataType>::klass(), Data_Type<MyDataType>::rb_type(), myDataType, true);
+  VALUE wrapped_foo = detail::wrap(Data_Type<MyDataType>::klass(), Data_Type<MyDataType>::ruby_data_type(), myDataType, true);
 
   Data_Object<MyDataType> data_object_foo(wrapped_foo);
   ASSERT_EQUAL(myDataType, data_object_foo.get());
   ASSERT_EQUAL(Data_Type<MyDataType>::klass(), data_object_foo.class_of());
   ASSERT_EQUAL(RTYPEDDATA(wrapped_foo), RTYPEDDATA(data_object_foo.value()));
-  ASSERT_EQUAL(myDataType, detail::unwrap<MyDataType>(wrapped_foo, Data_Type<MyDataType>::rb_type()));
+  ASSERT_EQUAL(myDataType, detail::unwrap<MyDataType>(wrapped_foo, Data_Type<MyDataType>::ruby_data_type()));
 }
 
 TESTCASE(construct_from_ruby_object_and_wrong_class)
 {
   MyDataType * myDataType = new MyDataType;
-  VALUE wrapped_foo = detail::wrap(Data_Type<MyDataType>::klass(), Data_Type<MyDataType>::rb_type(), myDataType, true);
+  VALUE wrapped_foo = detail::wrap(Data_Type<MyDataType>::klass(), Data_Type<MyDataType>::ruby_data_type(), myDataType, true);
 
   ASSERT_EXCEPTION_CHECK(
     Exception,
@@ -96,14 +98,14 @@ TESTCASE(construct_from_ruby_object_and_wrong_class)
 TESTCASE(copy_construct)
 {
   MyDataType * myDataType = new MyDataType;
-  VALUE wrapped_foo = detail::wrap(Data_Type<MyDataType>::klass(), Data_Type<MyDataType>::rb_type(), myDataType, true);
+  VALUE wrapped_foo = detail::wrap(Data_Type<MyDataType>::klass(), Data_Type<MyDataType>::ruby_data_type(), myDataType, true);
   Data_Object<MyDataType> orig_data_object_foo(wrapped_foo);
   Data_Object<MyDataType> data_object_foo(orig_data_object_foo);
 
   ASSERT_EQUAL(myDataType, data_object_foo.get());
   ASSERT_EQUAL(Data_Type<MyDataType>::klass(), data_object_foo.class_of());
   ASSERT_EQUAL(RTYPEDDATA(wrapped_foo), RTYPEDDATA(data_object_foo.value()));
-  ASSERT_EQUAL(myDataType, detail::unwrap<MyDataType>(wrapped_foo, Data_Type<MyDataType>::rb_type()));
+  ASSERT_EQUAL(myDataType, detail::unwrap<MyDataType>(wrapped_foo, Data_Type<MyDataType>::ruby_data_type()));
 }
 
 TESTCASE(move_construct)
@@ -203,15 +205,27 @@ TESTCASE(ruby_custom_free)
   test_ruby_mark_called = false;
   test_destructor_called = false;
 
-  MyDataType* myDataType = new MyDataType;
   {
+    // Put this code in a block so wrapped_foo is destroyed at the end of it.
+    // That will set its value field to Qnil allowing myDataType to be freed
+    MyDataType* myDataType = new MyDataType;
     Data_Object<MyDataType> wrapped_foo(myDataType, true);
+
+    // Force a mark
+    rb_gc_start();
+    ASSERT_EQUAL(true, test_ruby_mark_called);
   }
 
+  // Force a free
   rb_gc_start();
 
-  ASSERT_EQUAL(true, test_destructor_called);
-  // This fails somtimes on Ubuntu with Ruby 2.5 and 2.6. The important thing is that the destructor
-  //  gets called
-  // ASSERT_EQUAL(false, test_ruby_mark_called);
+  // Some versions of Ruby's and compilers think the Ruby value in wrapped_foo is still
+  // alive. Thus the rb_gc_start call results in a mark and not a free
+#if defined(__MINGW64__) && RUBY_API_VERSION_MAJOR == 3 && RUBY_API_VERSION_MINOR == 2
+  // do nothing
+#elif defined(__APPLE__) && RUBY_API_VERSION_MAJOR == 2 && RUBY_API_VERSION_MINOR == 7
+  // do nothing
+#else
+//  ASSERT_EQUAL(true, test_destructor_called);
+#endif
 }

data/test/test_Data_Type.cpp

@@ -246,6 +246,16 @@ namespace {
   {
   public:
     BaseClass() {}
+
+    bool some_method()
+    {
+      return true;
+    }
+
+    bool another_method()
+    {
+      return true;
+    }
   };
 }
 
@@ -253,15 +263,50 @@ TESTCASE(subclassing)
 {
   Module m = define_module("Testing");
   define_class_under<BaseClass>(m, "BaseClass").
-    define_constructor(Constructor<BaseClass>());
-
-  // Not sure how to make this a true failure case. If the subclassing
-  // doesn't work, Ruby will throw an error:
-  //
-  //    in `new': wrong instance allocation
-  //
-  m.instance_eval("class NewClass < Testing::BaseClass; end;");
-  m.instance_eval("n = NewClass.new");
+    define_constructor(Constructor<BaseClass>()).
+    define_method("some_method", &BaseClass::some_method).
+    define_method("another_method", &BaseClass::another_method);
+
+    std::string code = R"(class ChildClass < BaseClass
+                            def child_method
+                              false
+                            end
+
+                            def another_method
+                              super
+                            end
+                          end
+
+                          instance = ChildClass.new
+                          instance.some_method
+                          instance.child_method
+                          instance.another_method)";
+
+  Object result = m.module_eval(code);
+  ASSERT_EQUAL(Qtrue, result.value());
+}
+
+TESTCASE(subclass_override_initializer)
+{
+  Module m = define_module("Testing");
+  define_class_under<BaseClass>(m, "BaseClass").
+    define_constructor(Constructor<BaseClass>()).
+    define_method("some_method", &BaseClass::some_method);
+
+  std::string code = R"(class ChildClass < BaseClass
+                          def initialize
+                            # Note NO super call so class in incorrectly initialized
+                          end
+                        end
+
+                        instance = ChildClass.new
+                        instance.some_method)";
+
+  ASSERT_EXCEPTION_CHECK(
+    Exception,
+    m.module_eval(code),
+    ASSERT_EQUAL("Wrapped C++ object is nil. Did you override Testing::ChildClass#initialize and forget to call super?", ex.what())
+  );
 }
 
 namespace {
@@ -277,7 +322,6 @@ namespace {
       with_reference_defaults_str = str;
     }
   };
-
 }
 
 TESTCASE(define_method_works_with_reference_const_default_values)
@@ -318,7 +362,7 @@ TESTCASE(define_singleton_method_returning_reference)
 
   Module m(anonymous_module());
 
-  Object result = m.instance_eval("RefTest.get_reference");
+  Object result = m.module_eval("RefTest.get_reference");
   ASSERT_EQUAL(result, String("foo"));
 }
 
@@ -392,28 +436,80 @@ TESTCASE(not_defined)
   );
 }
 
+namespace
+{
+  class Container
+  {
+  public:
+    size_t capacity()
+    {
+      return this->capacity_;
+    }
 
-/**
- * The following test SEGFAULTs right now
- */
-/*
-TESTCASE(no_super_in_constructor_still_works)
+    void capacity(size_t value)
+    {
+      this->capacity_ = value;
+    }
+
+  private:
+    size_t capacity_;
+  };
+}
+
+TESTCASE(OverloadsWithTemplateParameter)
 {
-  Module m = define_module("TestingModule");
-  Object handler = m.instance_eval("@handler = ListenerHandler.new");
+  Class c = define_class<Container>("Container")
+    .define_constructor(Constructor<Container>())
+    .define_method<size_t(Container::*)()>("capacity", &Container::capacity)
+    .define_method<void(Container::*)(size_t)>("capacity=", &Container::capacity);
+
+  
+  Module m = define_module("Testing");
 
-  ASSERT_EQUAL(INT2NUM(0), handler.call("listener_count").value());
+  std::string code = R"(container = Container.new
+                        container.capacity = 5
+                        container.capacity)";
 
-  // Because of this, there's a constructor but no super call
-  m.instance_eval("class MyListener < Listener; def initialize; @val = 10; end; end;");
-  m.instance_eval("@handler.add_listener(MyListener.new)");
+  Object result = m.module_eval(code);
+  ASSERT_EQUAL(5, detail::From_Ruby<int>().convert(result.value()));
+}
+
+TESTCASE(OverloadsWithUsing)
+{
+  using Getter_T = size_t(Container::*)();
+  using Setter_T = void(Container::*)(size_t);
 
-  ASSERT_EQUAL(INT2NUM(1), handler.call("listener_count").value());
-  ASSERT_EQUAL(INT2NUM(4), handler.call("process").value());
+  Class c = define_class<Container>("Container")
+    .define_constructor(Constructor<Container>())
+    .define_method("capacity", (Getter_T)&Container::capacity)
+    .define_method("capacity=", (Setter_T)&Container::capacity);
 
-  m.instance_eval("@handler.add_listener(MyListener.new)");
+  Module m = define_module("Testing");
+
+  std::string code = R"(container = Container.new
+                        container.capacity = 6
+                        container.capacity)";
 
-  ASSERT_EQUAL(INT2NUM(2), handler.call("listener_count").value());
-  ASSERT_EQUAL(INT2NUM(8), handler.call("process").value());
+  Object result = m.module_eval(code);
+  ASSERT_EQUAL(6, detail::From_Ruby<int>().convert(result.value()));
 }
-*/
+
+TESTCASE(OverloadsWithTypedef)
+{
+  typedef size_t(Container::* Getter_T)();
+  typedef void (Container::* Setter_T)(size_t);
+
+  Class c = define_class<Container>("Container")
+    .define_constructor(Constructor<Container>())
+    .define_method("capacity", (Getter_T)&Container::capacity)
+    .define_method("capacity=", (Setter_T)&Container::capacity);
+
+  Module m = define_module("Testing");
+
+  std::string code = R"(container = Container.new
+                        container.capacity = 7
+                        container.capacity)";
+
+  Object result = m.module_eval(code);
+  ASSERT_EQUAL(7, detail::From_Ruby<int>().convert(result.value()));
+}