gir_ffi 0.7.3 → 0.7.4

data/test/gir_ffi/builders/signal_builder_test.rb

@@ -12,7 +12,7 @@ describe GirFFI::Builders::SignalBuilder do
         expected = <<-CODE.reset_indentation
         def self.call_with_argument_mapping(_proc, _instance, _user_data)
           _v1 = Regress::TestObj.wrap(_instance)
-          _v2 = GirFFI::ArgHelper::OBJECT_STORE[_user_data.address]
+          _v2 = GirFFI::ArgHelper::OBJECT_STORE.fetch(_user_data)
           _proc.call(_v1, _v2)
         end
         CODE
@@ -32,7 +32,7 @@ describe GirFFI::Builders::SignalBuilder do
         def self.call_with_argument_mapping(_proc, _instance, i, _user_data)
           _v1 = Regress::TestObj.wrap(_instance)
           _v2 = i
-          _v3 = GirFFI::ArgHelper::OBJECT_STORE[_user_data.address]
+          _v3 = GirFFI::ArgHelper::OBJECT_STORE.fetch(_user_data)
           _v4 = _proc.call(_v1, _v2, _v3)
           return _v4
         end
@@ -51,7 +51,7 @@ describe GirFFI::Builders::SignalBuilder do
         def self.call_with_argument_mapping(_proc, _instance, result, _user_data)
           _v1 = Gio::MountOperation.wrap(_instance)
           _v2 = Gio::MountOperationResult.wrap(result)
-          _v3 = GirFFI::ArgHelper::OBJECT_STORE[_user_data.address]
+          _v3 = GirFFI::ArgHelper::OBJECT_STORE.fetch(_user_data)
           _proc.call(_v1, _v2, _v3)
         end
         CODE
@@ -71,7 +71,7 @@ describe GirFFI::Builders::SignalBuilder do
         def self.call_with_argument_mapping(_proc, _instance, arr, len, _user_data)
           _v1 = Regress::TestObj.wrap(_instance)
           _v2 = len
-          _v3 = GirFFI::ArgHelper::OBJECT_STORE[_user_data.address]
+          _v3 = GirFFI::ArgHelper::OBJECT_STORE.fetch(_user_data)
           _v4 = GirFFI::SizedArray.wrap(:guint32, _v2, arr)
           _proc.call(_v1, _v4, _v3)
         end
@@ -92,7 +92,7 @@ describe GirFFI::Builders::SignalBuilder do
         def self.call_with_argument_mapping(_proc, _instance, i, _user_data)
           _v1 = Regress::TestObj.wrap(_instance)
           _v2 = i
-          _v3 = GirFFI::ArgHelper::OBJECT_STORE[_user_data.address]
+          _v3 = GirFFI::ArgHelper::OBJECT_STORE.fetch(_user_data)
           _v4 = _proc.call(_v1, _v2, _v3)
           _v5 = GLib::Array.from(:gint32, _v4)
           return _v5

data/test/gir_ffi/builders/union_builder_test.rb

@@ -12,8 +12,9 @@ describe GirFFI::Builders::UnionBuilder do
 
   describe "#layout_specification" do
     it "returns the correct layout for GObject::TypeCValue" do
+      long_type = FFI.type_size(:long) == 8 ? :int64 : :int32
       builder.layout_specification.must_equal [:v_int, :int32, 0,
-                                               :v_long, :int64, 0,
+                                               :v_long, long_type, 0,
                                                :v_int64, :int64, 0,
                                                :v_double, :double, 0,
                                                :v_pointer, :pointer, 0]

data/test/gir_ffi/builders/vfunc_builder_test.rb

@@ -4,6 +4,12 @@ describe GirFFI::Builders::VFuncBuilder do
   let(:builder) { GirFFI::Builders::VFuncBuilder.new vfunc_info }
 
   describe "#mapping_method_definition" do
+    let(:result) { builder.mapping_method_definition }
+
+    before do
+      skip unless vfunc_info
+    end
+
     describe "for a vfunc with only one argument" do
       let(:vfunc_info) {
         get_vfunc_introspection_data "GIMarshallingTests", "Object", "method_int8_in" }
@@ -17,7 +23,7 @@ describe GirFFI::Builders::VFuncBuilder do
         end
         CODE
 
-        builder.mapping_method_definition.must_equal expected
+        result.must_equal expected
       end
     end
 
@@ -26,7 +32,6 @@ describe GirFFI::Builders::VFuncBuilder do
         get_vfunc_introspection_data "GIMarshallingTests", "Object", "vfunc_return_enum" }
 
       it "returns a valid mapping method including receiver" do
-        skip unless vfunc_info
         expected = <<-CODE.reset_indentation
         def self.call_with_argument_mapping(_proc, _instance)
           _v1 = GIMarshallingTests::Object.wrap(_instance)
@@ -36,9 +41,125 @@ describe GirFFI::Builders::VFuncBuilder do
         end
         CODE
 
-        builder.mapping_method_definition.must_equal expected
+        result.must_equal expected
+      end
+    end
+
+    describe "for a vfunc with a callback argument" do
+      let(:vfunc_info) {
+        get_vfunc_introspection_data "GIMarshallingTests", "Object", "vfunc_with_callback" }
+
+      it "returns a valid mapping method including receiver" do
+        expected = <<-CODE.reset_indentation
+        def self.call_with_argument_mapping(_proc, _instance, callback, callback_data)
+          _v1 = GIMarshallingTests::Object.wrap(_instance)
+          _v2 = GIMarshallingTests::CallbackIntInt.wrap(callback)
+          _v3 = GirFFI::ArgHelper::OBJECT_STORE.fetch(callback_data)
+          _proc.call(_v1, _v2, _v3)
+        end
+        CODE
+
+        result.must_equal expected
+      end
+    end
+
+    describe "for a vfunc with an out argument allocated by them, the caller" do
+      let(:vfunc_info) {
+        get_vfunc_introspection_data("GIMarshallingTests", "Object",
+                                     "method_int8_arg_and_out_caller") }
+
+      it "returns a valid mapping method including receiver" do
+        expected = <<-CODE.reset_indentation
+        def self.call_with_argument_mapping(_proc, _instance, arg, out)
+          _v1 = GIMarshallingTests::Object.wrap(_instance)
+          _v2 = arg
+          _v3 = GirFFI::InOutPointer.new(:gint8, out)
+          _v4 = _proc.call(_v1, _v2)
+          _v3.set_value _v4
+        end
+        CODE
+
+        result.must_equal expected
+      end
+    end
+
+    describe "for a vfunc with an out argument allocated by us, the callee" do
+      let(:vfunc_info) {
+        get_vfunc_introspection_data("GIMarshallingTests", "Object",
+                                     "method_int8_arg_and_out_callee") }
+
+      it "returns a valid mapping method including receiver" do
+        expected = <<-CODE.reset_indentation
+        def self.call_with_argument_mapping(_proc, _instance, arg, out)
+          _v1 = GIMarshallingTests::Object.wrap(_instance)
+          _v2 = arg
+          _v3 = GirFFI::InOutPointer.new(:gint8).tap { |ptr| out.put_pointer 0, ptr }
+          _v4 = _proc.call(_v1, _v2)
+          _v3.set_value _v4
+        end
+        CODE
+
+        result.must_equal expected
+      end
+    end
+
+    describe "for a vfunc with an error argument" do
+      let(:vfunc_info) {
+        get_vfunc_introspection_data("GIMarshallingTests", "Object",
+                                     "vfunc_meth_with_err")
+      }
+
+      it "returns a valid mapping method including receiver" do
+        expected = <<-CODE.reset_indentation
+        def self.call_with_argument_mapping(_proc, _instance, x, _error)
+          _v1 = GIMarshallingTests::Object.wrap(_instance)
+          _v2 = x
+          _v3 = GirFFI::InOutPointer.new([:pointer, :error], _error)
+          begin
+          _v4 = _proc.call(_v1, _v2)
+          rescue => _v5
+          _v3.set_value GLib::Error.from(_v5)
+          end
+          return _v4
+        end
+        CODE
+
+        result.must_equal expected
       end
     end
   end
-end
 
+  describe "#argument_ffi_types" do
+    let(:result) { builder.argument_ffi_types }
+
+    before do
+      skip unless vfunc_info
+    end
+
+    describe "for a vfunc with only one argument" do
+      let(:vfunc_info) {
+        get_vfunc_introspection_data "GIMarshallingTests", "Object", "method_int8_in" }
+
+      it "returns the correct FFI types including :pointer for the receiver" do
+        result.must_equal [:pointer, :int8]
+      end
+    end
+  end
+
+  describe "#return_ffi_type" do
+    let(:result) { builder.return_ffi_type }
+
+    before do
+      skip unless vfunc_info
+    end
+
+    describe "for a vfunc returning an object" do
+      let(:vfunc_info) {
+        get_vfunc_introspection_data "GIMarshallingTests", "Object", "vfunc_return_object_transfer_full" }
+
+      it "returns :pointer" do
+        result.must_equal :pointer
+      end
+    end
+  end
+end

data/test/gir_ffi/error_type_info_test.rb

@@ -0,0 +1,48 @@
+require 'gir_ffi_test_helper'
+require 'gir_ffi/error_type_info'
+
+describe GirFFI::ErrorTypeInfo do
+  let(:instance) { GirFFI::ErrorTypeInfo.new }
+
+  describe "#array_length" do
+    it "returns the correct value" do
+      instance.array_length.must_equal(-1)
+    end
+  end
+
+  describe "#tag_or_class" do
+    it "returns the correct value" do
+      instance.tag_or_class.must_equal [:pointer, :error]
+    end
+  end
+
+  describe "#pointer?" do
+    it "returns the correct value" do
+      instance.pointer?.must_equal true
+    end
+  end
+
+  describe "#flattened_tag" do
+    it "returns the correct value" do
+      instance.flattened_tag.must_equal :error
+    end
+  end
+
+  describe "#extra_conversion_arguments" do
+    it "returns the correct value" do
+      instance.extra_conversion_arguments.must_equal []
+    end
+  end
+
+  describe "#argument_class_name" do
+    it "returns the correct value" do
+      instance.argument_class_name.must_equal 'GLib::Error'
+    end
+  end
+
+  describe "#needs_ruby_to_c_conversion_for_callbacks?" do
+    it "returns the correct value" do
+      instance.needs_ruby_to_c_conversion_for_callbacks?.must_equal true
+    end
+  end
+end

data/test/gir_ffi/in_pointer_test.rb

@@ -188,7 +188,7 @@ describe GirFFI::InPointer do
       it "stores the string in GirFFI::ArgHelper::OBJECT_STORE" do
         str = "Foo"
         ptr = GirFFI::InPointer.from_closure_data(str)
-        result = GirFFI::ArgHelper::OBJECT_STORE[ptr.address]
+        result = GirFFI::ArgHelper::OBJECT_STORE.fetch(ptr)
         result.must_equal str
       end
     end

data/test/gir_ffi/sized_array_test.rb

@@ -44,7 +44,7 @@ describe GirFFI::SizedArray do
       end
 
       it "raises an error if the array has the wrong number of elements" do
-        lambda { GirFFI::SizedArray.from :gint32, 4, [3, 2, 1] }.must_raise ArgumentError
+        proc { GirFFI::SizedArray.from :gint32, 4, [3, 2, 1] }.must_raise ArgumentError
       end
 
       it "uses the array's size if passed -1 as the size" do
@@ -62,7 +62,7 @@ describe GirFFI::SizedArray do
 
       it "raises an error if the argument has the wrong number of elements" do
         arr = GirFFI::SizedArray.from :gint32, 3, [3, 2, 1]
-        lambda { GirFFI::SizedArray.from :gint32, 4, arr }.must_raise ArgumentError
+        proc { GirFFI::SizedArray.from :gint32, 4, arr }.must_raise ArgumentError
       end
     end
 

data/test/integration/generated_gimarshallingtests_test.rb

@@ -56,7 +56,9 @@ describe GIMarshallingTests do
 
       res = GIMarshallingTests::BoxedStruct.inout bx
 
-      assert_equal 42, bx.long_
+      # TODO: Deal with the fact that bx is now invalid (at least with
+      # gobject-introspection 1.40).
+
       assert_equal 0, res.long_
     end
 
@@ -275,9 +277,13 @@ describe GIMarshallingTests do
 
     it "has a working function #full_inout" do
       ob = GIMarshallingTests::Object.new 42
+
       res = GIMarshallingTests::Object.full_inout ob
+
+      # TODO: Deal with the fact that ob is now invalid
+
       assert_instance_of GIMarshallingTests::Object, res
-      ob.wont_equal res
+      res.int.must_equal 0
     end
 
     it "has a working function #full_out" do
@@ -291,7 +297,7 @@ describe GIMarshallingTests do
     end
 
     it "has a working function #inout_same" do
-      skip "This function is only found in the header"
+      skip "This function is defined in the header but not implemented"
     end
 
     it "has a working function #none_inout" do
@@ -319,33 +325,108 @@ describe GIMarshallingTests do
     let(:instance) { GIMarshallingTests::Object.new 42 }
 
     it "has a working method #call_vfunc_with_callback" do
-      # NOTE: To call this method, the callback slot vfunc_with_callback has to
-      # be filled in the GIMarshallingTests::Object class structure. The
-      # GIMarshallingTests library doesn't do this.
-      skip "Needs vfunc setup"
+      skip unless get_method_introspection_data("GIMarshallingTests", "Object",
+                                                "call_vfunc_with_callback")
+      cb = nil
+      user_data = nil
+      result = nil
+
+      derived_instance = make_derived_instance do |info|
+        info.install_vfunc_implementation :vfunc_with_callback, proc { |obj, callback, callback_data|
+          cb = callback
+          user_data = callback_data.address
+          result = callback.call(42, callback_data)
+        }
+      end
+      derived_instance.call_vfunc_with_callback
+
+      user_data.must_equal 0xdeadbeef
+      # TODO: Change implementation of CallbackBase so that this becomes an
+      # instance of GIMarshallingTests::CallbackIntInt
+      cb.must_be_instance_of FFI::Function
+      result.must_equal 42
     end
 
     it "has a working method #full_in" do
-      skip "This function is only found in the header"
+      skip "This function is defined in the header but not implemented"
     end
 
     it "has a working method #get_ref_info_for_vfunc_in_object_transfer_full" do
-      skip "Needs vfunc setup"
+      skip unless get_vfunc_introspection_data("GIMarshallingTests", "Object",
+                                               "vfunc_in_object_transfer_full")
+      obj = nil
+      derived_instance = make_derived_instance do |info|
+        info.install_vfunc_implementation :vfunc_in_object_transfer_full, proc {|this, object|
+          obj = object
+        }
+      end
+      result = derived_instance.
+        get_ref_info_for_vfunc_in_object_transfer_full GIMarshallingTests::Object.get_gtype
+      result.must_equal [1, false]
+      obj.must_be_instance_of GIMarshallingTests::Object
     end
+
     it "has a working method #get_ref_info_for_vfunc_in_object_transfer_none" do
-      skip "Needs vfunc setup"
+      skip unless get_vfunc_introspection_data("GIMarshallingTests", "Object",
+                                               "vfunc_in_object_transfer_none")
+      klass = nil
+      derived_instance = make_derived_instance do |info|
+        info.install_vfunc_implementation :vfunc_in_object_transfer_none, proc {|this, object|
+          klass = object.class
+        }
+      end
+      result = derived_instance.
+        get_ref_info_for_vfunc_in_object_transfer_none GIMarshallingTests::Object.get_gtype
+      result.must_equal [1, false]
+      klass.must_equal GIMarshallingTests::Object
     end
+
     it "has a working method #get_ref_info_for_vfunc_out_object_transfer_full" do
-      skip "Needs vfunc setup"
+      skip unless get_vfunc_introspection_data("GIMarshallingTests", "Object",
+                                               "vfunc_out_object_transfer_full")
+      derived_instance = make_derived_instance do |info|
+        info.install_vfunc_implementation :vfunc_out_object_transfer_full, proc {|obj|
+          GIMarshallingTests::Object.new 42
+        }
+      end
+      result = derived_instance.get_ref_info_for_vfunc_out_object_transfer_full
+      result.must_equal [1, false]
     end
+
     it "has a working method #get_ref_info_for_vfunc_out_object_transfer_none" do
-      skip "Needs vfunc setup"
+      skip unless get_vfunc_introspection_data("GIMarshallingTests", "Object",
+                                               "vfunc_out_object_transfer_none")
+      derived_instance = make_derived_instance do |info|
+        info.install_vfunc_implementation :vfunc_out_object_transfer_none, proc {|obj|
+          GIMarshallingTests::Object.new 42
+        }
+      end
+      result = derived_instance.get_ref_info_for_vfunc_out_object_transfer_none
+      result.must_equal [1, false]
     end
+
     it "has a working method #get_ref_info_for_vfunc_return_object_transfer_full" do
-      skip "Needs vfunc setup"
+      skip unless get_vfunc_introspection_data("GIMarshallingTests", "Object",
+                                               "vfunc_return_object_transfer_full")
+      derived_instance = make_derived_instance do |info|
+        info.install_vfunc_implementation :vfunc_return_object_transfer_full, proc {|obj|
+          GIMarshallingTests::Object.new 42
+        }
+      end
+      result = derived_instance.get_ref_info_for_vfunc_return_object_transfer_full
+      result.must_equal [1, false]
     end
+
     it "has a working method #get_ref_info_for_vfunc_return_object_transfer_none" do
-      skip "Needs vfunc setup"
+      skip unless get_vfunc_introspection_data("GIMarshallingTests", "Object",
+                                               "vfunc_return_object_transfer_none")
+      derived_instance = make_derived_instance do |info|
+        info.install_vfunc_implementation :vfunc_return_object_transfer_none, proc {|obj|
+          GIMarshallingTests::Object.new 42
+        }
+      end
+      result = derived_instance.get_ref_info_for_vfunc_return_object_transfer_none
+      result.must_equal [1, false]
     end
 
     it "has a working method #int8_in" do
@@ -356,8 +437,9 @@ describe GIMarshallingTests do
       derived_instance.int.must_equal 23
     end
 
+    # See https://bugzilla.gnome.org/show_bug.cgi?id=727665
     it "has a working method #int8_out" do
-      skip "Needs vfunc setup"
+      skip "Introspection data is not generated correctly"
     end
 
     it "has a working method #method" do
@@ -386,11 +468,27 @@ describe GIMarshallingTests do
     end
 
     it "has a working method #method_int8_arg_and_out_callee" do
-      skip "Needs vfunc setup"
+      skip unless get_method_introspection_data("GIMarshallingTests", "Object",
+                                                "method_int8_arg_and_out_callee")
+      derived_instance = make_derived_instance do |info|
+        info.install_vfunc_implementation :method_int8_arg_and_out_callee, proc { |obj, arg|
+          2 * arg
+        }
+      end
+      result = derived_instance.method_int8_arg_and_out_callee 32
+      result.must_equal 64
     end
 
     it "has a working method #method_int8_arg_and_out_caller" do
-      skip "Needs vfunc setup"
+      skip unless get_method_introspection_data("GIMarshallingTests", "Object",
+                                                "method_int8_arg_and_out_caller")
+      derived_instance = make_derived_instance do |info|
+        info.install_vfunc_implementation :method_int8_arg_and_out_caller, proc { |obj, arg|
+          2 * arg
+        }
+      end
+      result = derived_instance.method_int8_arg_and_out_caller 32
+      result.must_equal 64
     end
 
     it "has a working method #method_int8_in" do
@@ -418,7 +516,7 @@ describe GIMarshallingTests do
     end
 
     it "has a working method #method_variant_array_in" do
-      skip "This function is only found in the header"
+      skip "This function is defined in the header but not implemented"
     end
 
     it "has a working method #method_with_default_implementation" do
@@ -438,15 +536,48 @@ describe GIMarshallingTests do
     end
 
     it "has a working method #vfunc_array_out_parameter" do
-      skip "Needs vfunc setup"
+      skip unless get_vfunc_introspection_data("GIMarshallingTests", "Object",
+                                               "vfunc_array_out_parameter")
+      derived_instance = make_derived_instance do |info|
+        info.install_vfunc_implementation :vfunc_array_out_parameter, proc {|obj|
+          [1.1, 2.2, 3.3]
+        }
+      end
+      result = derived_instance.vfunc_array_out_parameter
+      arr = result.to_a
+      arr.length.must_equal 3
+      arr[0].must_be_close_to 1.1
+      arr[1].must_be_close_to 2.2
+      arr[2].must_be_close_to 3.3
     end
 
     it "has a working method #vfunc_caller_allocated_out_parameter" do
-      skip "Needs vfunc setup"
+      skip unless get_vfunc_introspection_data("GIMarshallingTests", "Object",
+                                               "vfunc_caller_allocated_out_parameter")
+      derived_instance = make_derived_instance do |info|
+        info.install_vfunc_implementation :vfunc_caller_allocated_out_parameter, proc {|obj|
+          "Hello!"
+        }
+      end
+      result = derived_instance.vfunc_caller_allocated_out_parameter
+      result.get_value.must_equal "Hello!"
     end
 
     it "has a working method #vfunc_meth_with_error" do
-      skip "Needs vfunc setup"
+      derived_instance = make_derived_instance do |info|
+        info.install_vfunc_implementation :vfunc_meth_with_err, proc {|object, x|
+          raise "This is not the answer!" unless x == 42
+          true
+        }
+      end
+      result = derived_instance.vfunc_meth_with_error 42
+      result.must_equal true
+
+      err = proc { derived_instance.vfunc_meth_with_error(21) }.
+        must_raise GirFFI::GLibError
+      err.message.must_equal "This is not the answer!"
+      err.domain.must_equal "gir_ffi"
+      err.code.must_equal 0
     end
 
     it "has a working method #vfunc_multiple_out_parameters" do
@@ -510,14 +641,30 @@ describe GIMarshallingTests do
 
     it "has a working method #vfunc_return_value_only" do
       derived_instance = make_derived_instance do |info|
-        info.install_vfunc_implementation :vfunc_return_value_only, proc {|obj| 0xdeadbeef }
+        info.install_vfunc_implementation :vfunc_return_value_only, proc {|obj| 0x1234_5678 }
       end
       result = derived_instance.vfunc_return_value_only
-      result.must_equal 0xdeadbeef
+      result.must_equal 0x1234_5678
     end
 
     it "has a working method #vfunc_with_callback" do
-      skip "Needs vfunc setup"
+      skip unless get_method_introspection_data("GIMarshallingTests", "Object",
+                                                "vfunc_with_callback")
+
+      result = 1
+
+      derived_instance = make_derived_instance do |info|
+        info.install_vfunc_implementation :vfunc_with_callback, proc { |obj, callback, callback_data|
+          callback.call(42, callback_data)
+        }
+      end
+
+      derived_instance.vfunc_with_callback proc { |val, user_data| result = val + user_data }, 23
+
+      # The current implementation of the vfunc_with_callback method currently
+      # doesn't actually call the virtual function vfunc_with_callback.
+      result.must_equal 1
+      result.wont_equal 42 + 23
     end
 
     describe "its 'int' property" do
@@ -1413,7 +1560,7 @@ describe GIMarshallingTests do
   end
 
   it "has a working function #callback_return_value_only" do
-    result = GIMarshallingTests.callback_return_value_only lambda { 42 }
+    result = GIMarshallingTests.callback_return_value_only proc { 42 }
     result.must_equal 42
   end
 
@@ -1595,10 +1742,15 @@ describe GIMarshallingTests do
   end
 
   it "has a working function #gbytes_full_return" do
-    skip "GBytes is not supported yet"
+    skip unless get_introspection_data 'GIMarshallingTests', 'gbytes_full_return'
+    res = GIMarshallingTests.gbytes_full_return
+    res.to_a.must_equal [0, 49, 0xFF, 51]
   end
+
   it "has a working function #gbytes_none_in" do
-    skip "GBytes is not supported yet"
+    skip unless get_introspection_data 'GIMarshallingTests', 'gbytes_none_in'
+    GIMarshallingTests.gbytes_none_in [0, 49, 0xFF, 51]
+    pass
   end
 
   it "has a working function #gclosure_in" do
@@ -1637,8 +1789,10 @@ describe GIMarshallingTests do
     begin
       GIMarshallingTests.gerror
       flunk "Error should have been raised"
-    rescue RuntimeError => e
+    rescue GirFFI::GLibError => e
       e.message.must_equal GIMarshallingTests::CONSTANT_GERROR_MESSAGE
+      e.domain.must_equal GIMarshallingTests::CONSTANT_GERROR_DOMAIN
+      e.code.must_equal GIMarshallingTests::CONSTANT_GERROR_CODE
     end
   end
 
@@ -1646,8 +1800,10 @@ describe GIMarshallingTests do
     begin
       GIMarshallingTests.gerror_array_in [1, 2, 3]
       flunk "Error should have been raised"
-    rescue RuntimeError => e
+    rescue GirFFI::GLibError => e
       e.message.must_equal GIMarshallingTests::CONSTANT_GERROR_MESSAGE
+      e.domain.must_equal GIMarshallingTests::CONSTANT_GERROR_DOMAIN
+      e.code.must_equal GIMarshallingTests::CONSTANT_GERROR_CODE
     end
   end
 
@@ -1987,7 +2143,12 @@ describe GIMarshallingTests do
   end
 
   it "has a working function #gvalue_flat_array_round_trip" do
-    skip "Passing structs by-value is not supported yet"
+    skip "Fails on JRuby" if RUBY_PLATFORM == 'java'
+    result = GIMarshallingTests.gvalue_flat_array_round_trip 42, "42", true
+    arr = result.to_a
+    arr[0].get_value.must_equal 42
+    arr[1].get_value.must_equal "42"
+    arr[2].get_value.must_equal true
   end
 
   it "has a working function #gvalue_in" do
@@ -2353,6 +2514,7 @@ describe GIMarshallingTests do
     res.must_be_instance_of GIMarshallingTests::OverridesStruct
   end
 
+  # See https://bugzilla.gnome.org/show_bug.cgi?id=728409
   it "has a working function #param_spec_in_bool" do
     skip "param_spec_in_bool tests the wrong type"
     ps = GObject.param_spec_boolean "mybool", "nick", "blurb", true, :readable
@@ -2506,7 +2668,13 @@ describe GIMarshallingTests do
   end
 
   it "has a working function #test_interface_test_int8_in" do
-    skip "Needs implementation of TestInterface"
+    derived_klass.class_eval { include GIMarshallingTests::Interface }
+    instance = make_derived_instance do |info|
+      info.install_vfunc_implementation :test_int8_in, proc {|obj, in_| obj.int = in_ }
+    end
+    instance.int.must_equal 0
+    GIMarshallingTests.test_interface_test_int8_in instance, 8
+    instance.int.must_equal 8
   end
 
   it "has a working function #time_t_in" do