gir_ffi 0.6.4 → 0.6.5

data/test/gir_ffi/info_ext/i_type_info_test.rb

@@ -8,6 +8,7 @@ describe GirFFI::InfoExt::ITypeInfo do
   let(:elmtype_info) { klass.new }
   let(:keytype_info) { klass.new }
   let(:valtype_info) { klass.new }
+  let(:iface_info) { Object.new }
 
   describe "#to_ffitype" do
     it "returns an array with elements subtype and size for type :array" do
@@ -21,11 +22,25 @@ describe GirFFI::InfoExt::ITypeInfo do
       result = type_info.to_ffitype
       assert_equal [:foo, 2], result
     end
+
+    describe "for an :interface type" do
+      before do
+        stub(type_info).interface { iface_info }
+        stub(type_info).tag { :interface }
+        stub(type_info).pointer? { false }
+      end
+
+      it "maps a the interface's ffitype" do
+        stub(iface_info).to_ffitype { :foo }
+
+        type_info.to_ffitype.must_equal :foo
+      end
+    end
   end
 
   describe "#element_type" do
     it "returns the element type for lists" do
-      mock(elmtype_info).tag { :foo }
+      stub(elmtype_info).tag { :foo }
       mock(elmtype_info).pointer? { false }
 
       mock(type_info).tag {:glist}
@@ -36,9 +51,9 @@ describe GirFFI::InfoExt::ITypeInfo do
     end
 
     it "returns the key and value types for ghashes" do
-      mock(keytype_info).tag { :foo }
+      stub(keytype_info).tag { :foo }
       mock(keytype_info).pointer? { false }
-      mock(valtype_info).tag { :bar }
+      stub(valtype_info).tag { :bar }
       mock(valtype_info).pointer? { false }
 
       mock(type_info).tag {:ghash}
@@ -149,7 +164,7 @@ describe GirFFI::InfoExt::ITypeInfo do
   describe "#tag_or_class_name" do
     describe "for the simple type :foo" do
       it "returns the string ':foo'" do
-        mock(type_info).tag { :foo }
+        stub(type_info).tag { :foo }
         mock(type_info).pointer? { false }
 
         assert_equal ":foo", type_info.tag_or_class_name
@@ -158,20 +173,39 @@ describe GirFFI::InfoExt::ITypeInfo do
 
     describe "for :utf8" do
       it "returns the string ':utf8'" do
-        mock(type_info).tag { :utf8 }
+        stub(type_info).tag { :utf8 }
         mock(type_info).pointer? { true }
 
         assert_equal ":utf8", type_info.tag_or_class_name
       end
     end
 
-    describe "for an interface class" do
-      it "returns the interface's full class name" do
-        mock(type_info).tag { :interface }
-        mock(type_info).interface_type_name { "-full-type-name-" }
+    describe "for an interface named Foo::Bar" do
+      let(:interface) { Object.new }
+
+      before do
+        stub(type_info).tag { :interface }
+        stub(type_info).interface { iface_info }
         mock(type_info).pointer? { false }
+        stub(interface).inspect { "Foo::Bar" }
 
-        assert_equal "-full-type-name-", type_info.tag_or_class_name
+        mock(GirFFI::Builder).build_class(iface_info) { interface }
+      end
+
+      context "when the interface type is :enum" do
+        it "returns the interface's full class name" do
+          stub(iface_info).info_type { :enum }
+
+          assert_equal "Foo::Bar", type_info.tag_or_class_name
+        end
+      end
+
+      context "when the interface type is :object" do
+        it "returns the string [:pointer, Foo::Bar]" do
+          stub(iface_info).info_type { :object }
+
+          assert_equal "[:pointer, Foo::Bar]", type_info.tag_or_class_name
+        end
       end
     end
 
@@ -188,7 +222,7 @@ describe GirFFI::InfoExt::ITypeInfo do
   describe "#tag_or_class" do
     describe "for a simple type" do
       it "returns the type's tag" do
-        mock(type_info).tag { :foo }
+        stub(type_info).tag { :foo }
         mock(type_info).pointer? { false }
 
         type_info.tag_or_class.must_equal :foo
@@ -197,7 +231,7 @@ describe GirFFI::InfoExt::ITypeInfo do
 
     describe "for utf8 strings" do
       it "returns the tag :utf8" do
-        mock(type_info).tag { :utf8 }
+        stub(type_info).tag { :utf8 }
         mock(type_info).pointer? { true }
 
         type_info.tag_or_class.must_equal :utf8
@@ -206,7 +240,7 @@ describe GirFFI::InfoExt::ITypeInfo do
 
     describe "for filename strings" do
       it "returns the tag :filename" do
-        mock(type_info).tag { :filename }
+        stub(type_info).tag { :filename }
         mock(type_info).pointer? { true }
 
         type_info.tag_or_class.must_equal :filename
@@ -214,23 +248,44 @@ describe GirFFI::InfoExt::ITypeInfo do
     end
 
     describe "for an interface class" do
-      it "returns the class built from the interface" do
-        interface_info = Object.new
-        interface = Object.new
+      let(:interface) { Object.new }
 
-        mock(type_info).tag { :interface }
-        mock(type_info).interface { interface_info }
+      before do
+        stub(type_info).tag { :interface }
+        stub(type_info).interface { iface_info }
         mock(type_info).pointer? { false }
 
-        mock(GirFFI::Builder).build_class(interface_info) { interface }
+        mock(GirFFI::Builder).build_class(iface_info) { interface }
+      end
+
+      context "when the interface type is :enum" do
+        it "returns the built interface module" do
+          stub(iface_info).info_type { :enum }
+
+          type_info.tag_or_class.must_equal interface
+        end
+      end
+
+      context "when the interface type is :object" do
+        it "returns an array with elements :pointer and built interface class" do
+          stub(iface_info).info_type { :object }
 
-        type_info.tag_or_class.must_equal interface
+          type_info.tag_or_class.must_equal [:pointer, interface]
+        end
+      end
+
+      context "when the interface type is :struct" do
+        it "returns the built interface class" do
+          stub(iface_info).info_type { :struct }
+
+          type_info.tag_or_class.must_equal interface
+        end
       end
     end
 
     describe "for a pointer to simple type :foo" do
       it "returns [:pointer, :foo]" do
-        mock(type_info).tag { :foo }
+        stub(type_info).tag { :foo }
         mock(type_info).pointer? { true }
 
         type_info.tag_or_class.must_equal [:pointer, :foo]
@@ -248,22 +303,21 @@ describe GirFFI::InfoExt::ITypeInfo do
   end
 
   describe "#to_callback_ffitype" do
-    let(:iface) { Object.new }
     describe "for an :interface argument" do
       before do
-        stub(type_info).interface { iface }
+        stub(type_info).interface { iface_info }
         stub(type_info).tag { :interface }
         stub(type_info).pointer? { false }
       end
 
       it "correctly maps a :union argument to :pointer" do
-        stub(iface).info_type { :union }
+        stub(iface_info).info_type { :union }
 
         type_info.to_callback_ffitype.must_equal :pointer
       end
 
       it "correctly maps a :flags argument to :int32" do
-        stub(iface).info_type { :flags }
+        stub(iface_info).info_type { :flags }
 
         type_info.to_callback_ffitype.must_equal :int32
       end

data/test/gir_ffi/type_map_test.rb

@@ -0,0 +1,15 @@
+require 'gir_ffi_test_helper'
+
+describe GirFFI::TypeMap do
+  describe ".type_specification_to_ffitype" do
+    it "returns the nested FFI::Enum for an Enum module" do
+      GirFFI::TypeMap.type_specification_to_ffitype(GLib::DateMonth).
+        must_equal GLib::DateMonth::Enum
+    end
+
+    it "returns the nested FFI::Struct for an Struct module" do
+      GirFFI::TypeMap.type_specification_to_ffitype(GObject::EnumValue).
+        must_equal GObject::EnumValue::Struct
+    end
+  end
+end

data/test/gir_ffi/zero_terminated_test.rb

@@ -51,6 +51,34 @@ describe GirFFI::ZeroTerminated do
 
   end
 
+  describe "#==" do
+    it "returns true when comparing to an array with the same elements" do
+      zero_terminated = GirFFI::ZeroTerminated.from :int32, [1, 2, 3]
+
+      (zero_terminated == [1, 2, 3]).must_equal true
+    end
+
+    it "returns false when comparing to an array with different elements" do
+      zero_terminated = GirFFI::ZeroTerminated.from :int32, [1, 2, 3]
+
+      (zero_terminated == [1, 2]).must_equal false
+    end
+
+    it "returns true when comparing to a zero-terminated array with the same elements" do
+      zero_terminated = GirFFI::ZeroTerminated.from :int32, [1, 2, 3]
+      other = GirFFI::ZeroTerminated.from :int32, [1, 2, 3]
+
+      (zero_terminated == other).must_equal true
+    end
+
+    it "returns false when comparing to a zero-terminated array with different elements" do
+      zero_terminated = GirFFI::ZeroTerminated.from :int32, [1, 2, 3]
+      other = GirFFI::ZeroTerminated.from :int32, [1, 2]
+
+      (zero_terminated == other).must_equal false
+    end
+  end
+
   it "includes Enumerable" do
     GirFFI::ZeroTerminated.must_include Enumerable
   end

data/test/integration/generated_gimarshallingtests_test.rb

@@ -34,9 +34,9 @@ describe GIMarshallingTests do
       end
 
       it "has a writable field g_strv" do
-        assert_equal [], @bx.g_strv.to_a
+        @bx.g_strv.must_be :==, []
         @bx.g_strv = ["foo", "bar"]
-        assert_equal ["foo", "bar"], @bx.g_strv.to_a
+        @bx.g_strv.must_be :==, ["foo", "bar"]
       end
     end
 
@@ -58,7 +58,7 @@ describe GIMarshallingTests do
     it "has a working function #returnv" do
       res = GIMarshallingTests::BoxedStruct.returnv
       assert_equal 42, res.long_
-      assert_equal ["0", "1", "2"], res.g_strv.to_a
+      res.g_strv.must_be :==, ["0", "1", "2"]
     end
   end
 
@@ -244,7 +244,7 @@ describe GIMarshallingTests do
       ob = GIMarshallingTests::Object.new 42
       res = GIMarshallingTests::Object.full_inout ob
       assert_instance_of GIMarshallingTests::Object, res
-      refute_equal res.to_ptr, ob.to_ptr
+      ob.wont_equal res
     end
 
     it "has a working function #full_out" do
@@ -265,7 +265,7 @@ describe GIMarshallingTests do
       ob = GIMarshallingTests::Object.new 42
       res = GIMarshallingTests::Object.none_inout ob
       assert_instance_of GIMarshallingTests::Object, res
-      refute_equal res.to_ptr, ob.to_ptr
+      ob.wont_equal res
     end
 
     it "has a working function #none_out" do
@@ -335,17 +335,17 @@ describe GIMarshallingTests do
 
     it "has a working method #method_array_inout" do
       res = instance.method_array_inout [-1, 0, 1, 2]
-      assert_equal [-2, -1, 0, 1, 2], res.to_a
+      res.must_be :==, [-2, -1, 0, 1, 2]
     end
 
     it "has a working method #method_array_out" do
       res = instance.method_array_out
-      assert_equal [-1, 0, 1, 2], res.to_a
+      res.must_be :==, [-1, 0, 1, 2]
     end
 
     it "has a working method #method_array_return" do
       res = instance.method_array_return
-      assert_equal [-1, 0, 1, 2], res.to_a
+      res.must_be :==, [-1, 0, 1, 2]
     end
 
     it "has a working method #method_int8_arg_and_out_callee" do
@@ -665,7 +665,7 @@ describe GIMarshallingTests do
 
   it "has a working function #array_fixed_inout" do
     res = GIMarshallingTests.array_fixed_inout [-1, 0, 1, 2]
-    assert_equal [2, 1, 0, -1], res.to_a
+    res.must_be :==, [2, 1, 0, -1]
   end
 
   it "has a working function #array_fixed_int_in" do
@@ -675,12 +675,12 @@ describe GIMarshallingTests do
 
   it "has a working function #array_fixed_int_return" do
     res = GIMarshallingTests.array_fixed_int_return
-    assert_equal [-1, 0, 1, 2], res.to_a
+    res.must_be :==, [-1, 0, 1, 2]
   end
 
   it "has a working function #array_fixed_out" do
     res = GIMarshallingTests.array_fixed_out
-    assert_equal [-1, 0, 1, 2], res.to_a
+    res.must_be :==, [-1, 0, 1, 2]
   end
 
   it "has a working function #array_fixed_out_struct" do
@@ -695,7 +695,7 @@ describe GIMarshallingTests do
 
   it "has a working function #array_fixed_short_return" do
     res = GIMarshallingTests.array_fixed_short_return
-    assert_equal [-1, 0, 1, 2], res.to_a
+    res.must_be :==, [-1, 0, 1, 2]
   end
 
   it "has a working function #array_gvariant_container_in" do
@@ -761,39 +761,42 @@ describe GIMarshallingTests do
 
   it "has a working function #array_inout" do
     res = GIMarshallingTests.array_inout [-1, 0, 1, 2]
-    assert_equal [-2, -1, 0, 1, 2], res.to_a
+    res.must_be :==, [-2, -1, 0, 1, 2]
   end
 
   it "has a working function #array_inout_etc" do
     arr, sum = GIMarshallingTests.array_inout_etc 42, [-1, 0, 1, 2], 24
-    arr.to_a.must_equal [42, -1, 0, 1, 24]
+    arr.must_be :==, [42, -1, 0, 1, 24]
     sum.must_equal 42 + 24
   end
 
   it "has a working function #array_out" do
     res = GIMarshallingTests.array_out
-    assert_equal  [-1, 0, 1, 2], res.to_a
+    res.must_be :==, [-1, 0, 1, 2]
   end
 
   it "has a working function #array_out_etc" do
     arr, sum = GIMarshallingTests.array_out_etc 42, 24
-    arr.to_a.must_equal [42, 0, 1, 24]
+    arr.must_be :==, [42, 0, 1, 24]
     sum.must_equal 42 + 24
   end
 
   it "has a working function #array_return" do
     res = GIMarshallingTests.array_return
-    assert_equal  [-1, 0, 1, 2], res.to_a
+    res.must_be :==, [-1, 0, 1, 2]
   end
 
   it "has a working function #array_return_etc" do
     arr, sum = GIMarshallingTests.array_return_etc 42, 24
-    arr.to_a.must_equal [42, 0, 1, 24]
+    arr.must_be :==, [42, 0, 1, 24]
     sum.must_equal 42 + 24
   end
 
   it "has a working function #array_simple_struct_in" do
-    skip "Non-pointer arrays of complex types are not supported yet"
+    arr = [1, 2, 3].map { |val|
+      GIMarshallingTests::SimpleStruct.new.tap { |struct| struct.long_ = val }
+    }
+    GIMarshallingTests.array_simple_struct_in arr
   end
 
   it "has a working function #array_string_in" do
@@ -817,7 +820,11 @@ describe GIMarshallingTests do
   end
 
   it "has a working function #array_struct_value_in" do
-    skip "Non-pointer arrays of complex types are not supported yet"
+    skip unless get_introspection_data 'GIMarshallingTests', 'array_struct_value_in'
+    arr = [1, 2, 3].map { |val|
+      GIMarshallingTests::BoxedStruct.new.tap { |struct| struct.long_ = val }
+    }
+    GIMarshallingTests.array_struct_value_in arr
   end
 
   it "has a working function #array_uint8_in" do
@@ -833,22 +840,22 @@ describe GIMarshallingTests do
 
   it "has a working function #array_zero_terminated_inout" do
     res = GIMarshallingTests.array_zero_terminated_inout ["0", "1", "2"]
-    res.to_a.must_equal ["-1", "0", "1", "2"]
+    res.must_be :==, ["-1", "0", "1", "2"]
   end
 
   it "has a working function #array_zero_terminated_out" do
     res = GIMarshallingTests.array_zero_terminated_out
-    assert_equal ["0", "1", "2"], res.to_a
+    res.must_be :==, ["0", "1", "2"]
   end
 
   it "has a working function #array_zero_terminated_return" do
     res = GIMarshallingTests.array_zero_terminated_return
-    assert_equal ["0", "1", "2"], res.to_a
+    res.must_be :==, ["0", "1", "2"]
   end
 
   it "has a working function #array_zero_terminated_return_null" do
     res = GIMarshallingTests.array_zero_terminated_return_null
-    res.to_a.must_equal []
+    res.must_be :==, []
   end
 
   it "has a working function #array_zero_terminated_return_struct" do
@@ -911,7 +918,7 @@ describe GIMarshallingTests do
   it "has a working function #boxed_struct_returnv" do
     res = GIMarshallingTests.boxed_struct_returnv
     assert_equal 42, res.long_
-    assert_equal ["0", "1", "2"], res.g_strv.to_a
+    res.g_strv.must_be :==, ["0", "1", "2"]
   end
 
   it "has a working function #bytearray_full_return" do
@@ -1053,7 +1060,7 @@ describe GIMarshallingTests do
 
   it "has a working function #garray_int_none_return" do
     arr = GIMarshallingTests.garray_int_none_return
-    assert_equal [-1, 0, 1, 2], arr.to_a
+    arr.must_be :==, [-1, 0, 1, 2]
   end
 
   it "has a working function #garray_uint64_none_in" do
@@ -1065,45 +1072,45 @@ describe GIMarshallingTests do
   it "has a working function #garray_uint64_none_return" do
     skip unless get_introspection_data 'GIMarshallingTests', 'garray_uint64_none_return'
     res = GIMarshallingTests.garray_uint64_none_return
-    res.to_a.must_equal [0, 0xffff_ffff_ffff_ffff]
+    res.must_be :==, [0, 0xffff_ffff_ffff_ffff]
   end
 
   it "has a working function #garray_utf8_container_inout" do
     res = GIMarshallingTests.garray_utf8_container_inout ["0", "1", "2"]
-    res.to_a.must_equal ["-2", "-1", "0", "1"]
+    res.must_be :==, ["-2", "-1", "0", "1"]
   end
 
   it "has a working function #garray_utf8_container_out" do
     res = GIMarshallingTests.garray_utf8_container_out
-    assert_equal ["0", "1", "2"], res.to_a
+    res.must_be :==, ["0", "1", "2"]
   end
 
   it "has a working function #garray_utf8_container_return" do
     res = GIMarshallingTests.garray_utf8_container_return
-    assert_equal ["0", "1", "2"], res.to_a
+    res.must_be :==, ["0", "1", "2"]
   end
 
   it "has a working function #garray_utf8_full_inout" do
     arr = ["0", "1", "2"]
     res = GIMarshallingTests.garray_utf8_full_inout arr
-    assert_equal ["-2", "-1", "0", "1"], res.to_a
+    res.must_be :==, ["-2", "-1", "0", "1"]
   end
 
   it "has a working function #garray_utf8_full_out" do
     res = GIMarshallingTests.garray_utf8_full_out
-    assert_equal ["0", "1", "2"], res.to_a
+    res.must_be :==, ["0", "1", "2"]
   end
 
   it "has a working function #garray_utf8_full_out_caller_allocated" do
     skip unless get_introspection_data 'GIMarshallingTests',
       'garray_utf8_full_out_caller_allocated'
     res = GIMarshallingTests.garray_utf8_full_out_caller_allocated
-    assert_equal ["0", "1", "2"], res.to_a
+    res.must_be :==, ["0", "1", "2"]
   end
 
   it "has a working function #garray_utf8_full_return" do
     res = GIMarshallingTests.garray_utf8_full_return
-    assert_equal ["0", "1", "2"], res.to_a
+    res.must_be :==, ["0", "1", "2"]
   end
 
   it "has a working function #garray_utf8_none_in" do
@@ -1115,17 +1122,17 @@ describe GIMarshallingTests do
   it "has a working function #garray_utf8_none_inout" do
     arr = ["0", "1", "2"]
     res = GIMarshallingTests.garray_utf8_none_inout arr
-    assert_equal ["-2", "-1", "0", "1"], res.to_a
+    res.must_be :==, ["-2", "-1", "0", "1"]
   end
 
   it "has a working function #garray_utf8_none_out" do
     res = GIMarshallingTests.garray_utf8_none_out
-    assert_equal ["0", "1", "2"], res.to_a
+    res.must_be :==, ["0", "1", "2"]
   end
 
   it "has a working function #garray_utf8_none_return" do
     res = GIMarshallingTests.garray_utf8_none_return
-    assert_equal ["0", "1", "2"], res.to_a
+    res.must_be :==, ["0", "1", "2"]
   end
 
   it "has a working function #gbytes_full_return" do
@@ -1287,7 +1294,7 @@ describe GIMarshallingTests do
 
   it "has a working function #glist_int_none_return" do
     res = GIMarshallingTests.glist_int_none_return
-    assert_equal [-1, 0, 1, 2], res.to_a
+    res.must_be :==, [-1, 0, 1, 2]
   end
 
   it "has a working function #glist_uint32_none_in" do
@@ -1299,37 +1306,37 @@ describe GIMarshallingTests do
   it "has a working function #glist_uint32_none_return" do
     skip unless get_introspection_data 'GIMarshallingTests', 'glist_uint32_none_return'
     res = GIMarshallingTests.glist_uint32_none_return
-    res.to_a.must_equal [0, 0xffff_ffff]
+    res.must_be :==, [0, 0xffff_ffff]
   end
 
   it "has a working function #glist_utf8_container_inout" do
     res = GIMarshallingTests.glist_utf8_container_inout ["0", "1", "2"]
-    assert_equal ["-2", "-1", "0", "1"], res.to_a
+    res.must_be :==, ["-2", "-1", "0", "1"]
   end
 
   it "has a working function #glist_utf8_container_out" do
     res = GIMarshallingTests.glist_utf8_container_out
-    assert_equal ["0", "1", "2"], res.to_a
+    res.must_be :==, ["0", "1", "2"]
   end
 
   it "has a working function #glist_utf8_container_return" do
     res = GIMarshallingTests.glist_utf8_container_return
-    assert_equal ["0", "1", "2"], res.to_a
+    res.must_be :==, ["0", "1", "2"]
   end
 
   it "has a working function #glist_utf8_full_inout" do
     res = GIMarshallingTests.glist_utf8_full_inout ["0", "1", "2"]
-    assert_equal ["-2", "-1", "0", "1"], res.to_a
+    res.must_be :==, ["-2", "-1", "0", "1"]
   end
 
   it "has a working function #glist_utf8_full_out" do
     res = GIMarshallingTests.glist_utf8_full_out
-    assert_equal ["0", "1", "2"], res.to_a
+    res.must_be :==, ["0", "1", "2"]
   end
 
   it "has a working function #glist_utf8_full_return" do
     res = GIMarshallingTests.glist_utf8_full_return
-    assert_equal ["0", "1", "2"], res.to_a
+    res.must_be :==, ["0", "1", "2"]
   end
 
   it "has a working function #glist_utf8_none_in" do
@@ -1338,47 +1345,47 @@ describe GIMarshallingTests do
 
   it "has a working function #glist_utf8_none_inout" do
     res = GIMarshallingTests.glist_utf8_none_inout ["0", "1", "2"]
-    assert_equal ["-2", "-1", "0", "1"], res.to_a
+    res.must_be :==, ["-2", "-1", "0", "1"]
   end
 
   it "has a working function #glist_utf8_none_out" do
     res = GIMarshallingTests.glist_utf8_none_out
-    assert_equal ["0", "1", "2"], res.to_a
+    res.must_be :==, ["0", "1", "2"]
   end
 
   it "has a working function #glist_utf8_none_return" do
     res = GIMarshallingTests.glist_utf8_none_return
-    assert_equal ["0", "1", "2"], res.to_a
+    res.must_be :==, ["0", "1", "2"]
   end
 
   it "has a working function #gptrarray_utf8_container_inout" do
     res = GIMarshallingTests.gptrarray_utf8_container_inout ["0", "1", "2"]
-    res.to_a.must_equal ["-2", "-1", "0", "1"]
+    res.must_be :==, ["-2", "-1", "0", "1"]
   end
 
   it "has a working function #gptrarray_utf8_container_out" do
     res = GIMarshallingTests.gptrarray_utf8_container_out
-    res.to_a.must_equal ["0", "1", "2"]
+    res.must_be :==, ["0", "1", "2"]
   end
 
   it "has a working function #gptrarray_utf8_container_return" do
     res = GIMarshallingTests.gptrarray_utf8_container_return
-    res.to_a.must_equal ["0", "1", "2"]
+    res.must_be :==, ["0", "1", "2"]
   end
 
   it "has a working function #gptrarray_utf8_full_inout" do
     res = GIMarshallingTests.gptrarray_utf8_full_inout ["0", "1", "2"]
-    res.to_a.must_equal ["-2", "-1", "0", "1"]
+    res.must_be :==, ["-2", "-1", "0", "1"]
   end
 
   it "has a working function #gptrarray_utf8_full_out" do
     res = GIMarshallingTests.gptrarray_utf8_full_out
-    res.to_a.must_equal ["0", "1", "2"]
+    res.must_be :==, ["0", "1", "2"]
   end
 
   it "has a working function #gptrarray_utf8_full_return" do
     res = GIMarshallingTests.gptrarray_utf8_full_return
-    res.to_a.must_equal ["0", "1", "2"]
+    res.must_be :==, ["0", "1", "2"]
   end
 
   it "has a working function #gptrarray_utf8_none_in" do
@@ -1387,17 +1394,17 @@ describe GIMarshallingTests do
 
   it "has a working function #gptrarray_utf8_none_inout" do
     res = GIMarshallingTests.gptrarray_utf8_none_inout ["0", "1", "2"]
-    res.to_a.must_equal ["-2", "-1", "0", "1"]
+    res.must_be :==, ["-2", "-1", "0", "1"]
   end
 
   it "has a working function #gptrarray_utf8_none_out" do
     res = GIMarshallingTests.gptrarray_utf8_none_out
-    res.to_a.must_equal ["0", "1", "2"]
+    res.must_be :==, ["0", "1", "2"]
   end
 
   it "has a working function #gptrarray_utf8_none_return" do
     res = GIMarshallingTests.gptrarray_utf8_none_return
-    res.to_a.must_equal ["0", "1", "2"]
+    res.must_be :==, ["0", "1", "2"]
   end
 
   it "has a working function #gslist_int_none_in" do
@@ -1407,37 +1414,37 @@ describe GIMarshallingTests do
 
   it "has a working function #gslist_int_none_return" do
     res = GIMarshallingTests.gslist_int_none_return
-    assert_equal [-1, 0, 1, 2], res.to_a
+    res.must_be :==, [-1, 0, 1, 2]
   end
 
   it "has a working function #gslist_utf8_container_inout" do
     res = GIMarshallingTests.gslist_utf8_container_inout ["0", "1", "2"]
-    assert_equal ["-2", "-1", "0", "1"], res.to_a
+    res.must_be :==, ["-2", "-1", "0", "1"]
   end
 
   it "has a working function #gslist_utf8_container_out" do
     res = GIMarshallingTests.gslist_utf8_container_out
-    assert_equal ["0", "1", "2"], res.to_a
+    res.must_be :==, ["0", "1", "2"]
   end
 
   it "has a working function #gslist_utf8_container_return" do
     res = GIMarshallingTests.gslist_utf8_container_return
-    assert_equal ["0", "1", "2"], res.to_a
+    res.must_be :==, ["0", "1", "2"]
   end
 
   it "has a working function #gslist_utf8_full_inout" do
     res = GIMarshallingTests.gslist_utf8_full_inout ["0", "1", "2"]
-    assert_equal ["-2", "-1", "0", "1"], res.to_a
+    res.must_be :==, ["-2", "-1", "0", "1"]
   end
 
   it "has a working function #gslist_utf8_full_out" do
     res = GIMarshallingTests.gslist_utf8_full_out
-    assert_equal ["0", "1", "2"], res.to_a
+    res.must_be :==, ["0", "1", "2"]
   end
 
   it "has a working function #gslist_utf8_full_return" do
     res = GIMarshallingTests.gslist_utf8_full_return
-    assert_equal ["0", "1", "2"], res.to_a
+    res.must_be :==, ["0", "1", "2"]
   end
 
   it "has a working function #gslist_utf8_none_in" do
@@ -1447,17 +1454,17 @@ describe GIMarshallingTests do
 
   it "has a working function #gslist_utf8_none_inout" do
     res = GIMarshallingTests.gslist_utf8_none_inout ["0", "1", "2"]
-    assert_equal ["-2", "-1", "0", "1"], res.to_a
+    res.must_be :==, ["-2", "-1", "0", "1"]
   end
 
   it "has a working function #gslist_utf8_none_out" do
     res = GIMarshallingTests.gslist_utf8_none_out
-    assert_equal ["0", "1", "2"], res.to_a
+    res.must_be :==, ["0", "1", "2"]
   end
 
   it "has a working function #gslist_utf8_none_return" do
     res = GIMarshallingTests.gslist_utf8_none_return
-    assert_equal ["0", "1", "2"], res.to_a
+    res.must_be :==, ["0", "1", "2"]
   end
 
   it "has a working function #gstrv_in" do
@@ -1467,17 +1474,17 @@ describe GIMarshallingTests do
 
   it "has a working function #gstrv_inout" do
     res = GIMarshallingTests.gstrv_inout ["0", "1", "2"]
-    assert_equal ["-1", "0", "1", "2"], res.to_a
+    res.must_be :==, ["-1", "0", "1", "2"]
   end
 
   it "has a working function #gstrv_out" do
     res = GIMarshallingTests.gstrv_out
-    assert_equal ["0", "1", "2"], res.to_a
+    res.must_be :==, ["0", "1", "2"]
   end
 
   it "has a working function #gstrv_return" do
     res = GIMarshallingTests.gstrv_return
-    assert_equal ["0", "1", "2"], res.to_a
+    res.must_be :==, ["0", "1", "2"]
   end
 
   it "has a working function #gtype_in" do
@@ -1516,11 +1523,13 @@ describe GIMarshallingTests do
   end
 
   it "has a working function #gvalue_flat_array" do
-    skip "Non-pointer arrays of complex types are not supported yet"
+    # TODO: Convert array of Ruby values to GValues automatically?
+    arr = [42, "42", true].map { |val| GObject::Value.wrap_ruby_value val }
+    GIMarshallingTests.gvalue_flat_array arr
   end
 
   it "has a working function #gvalue_flat_array_round_trip" do
-    skip "Non-pointer arrays of complex types are not supported yet"
+    skip "Passing structs by-value is not supported yet"
   end
 
   it "has a working function #gvalue_in" do
@@ -1585,7 +1594,7 @@ describe GIMarshallingTests do
   it "has a working function #init_function" do
     res, arr = GIMarshallingTests.init_function ["foo", "bar", "baz"]
     res.must_equal true
-    arr.to_a.must_equal ["foo", "bar"]
+    arr.must_be :==, ["foo", "bar"]
   end
 
   it "has a working function #int16_in_max" do
@@ -1844,7 +1853,9 @@ describe GIMarshallingTests do
   end
 
   it "has a working function #multi_array_key_value_in" do
-    skip "Non-pointer arrays of complex types are not supported yet"
+    keys = ["one", "two", "three"]
+    values = [1, 2, 3].map { |val| GObject::Value.wrap_ruby_value val }
+    GIMarshallingTests.multi_array_key_value_in keys, values
   end
 
   it "has a working function #no_type_flags_in" do
@@ -1916,7 +1927,11 @@ describe GIMarshallingTests do
   end
 
   it "has a working function #return_gvalue_flat_array" do
-    skip "Non-pointer arrays of complex types are not supported yet"
+    result = GIMarshallingTests.return_gvalue_flat_array
+    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 #short_in_max" do