gir_ffi 0.9.4 → 0.9.5

data/test/gir_ffi/builders/signal_closure_builder_test.rb

@@ -162,5 +162,26 @@ describe GirFFI::Builders::SignalClosureBuilder do
         builder.marshaller_definition.must_equal expected
       end
     end
+
+    describe 'for a signal with GList argument' do
+      let(:signal_info) do
+        get_signal_introspection_data 'Regress', 'AnnotationObject', 'list-signal'
+      end
+
+      it 'returns a valid mapping method' do
+        skip unless signal_info
+
+        expected = <<-CODE.reset_indentation
+        def self.marshaller(closure, return_value, param_values, _invocation_hint, _marshal_data)
+          _instance, list = param_values.map(&:get_value_plain)
+          _v1 = _instance
+          _v2 = GLib::List.wrap(:utf8, list)
+          wrap(closure.to_ptr).invoke_block(_v1, _v2)
+        end
+        CODE
+
+        builder.marshaller_definition.must_equal expected
+      end
+    end
   end
 end

data/test/gir_ffi/builders/vfunc_builder_test.rb

@@ -109,6 +109,26 @@ describe GirFFI::Builders::VFuncBuilder do
       end
     end
 
+    describe 'for a vfunc with a GObject::Value out argument allocated by them, the caller' do
+      let(:vfunc_info) do
+        get_vfunc_introspection_data('GIMarshallingTests', 'Object',
+                                     'vfunc_caller_allocated_out_parameter')
+      end
+
+      it 'returns a valid mapping method including receiver' do
+        expected = <<-CODE.reset_indentation
+        def self.call_with_argument_mapping(_proc, _instance, a)
+          _v1 = GIMarshallingTests::Object.wrap(_instance)
+          _v2 = GirFFI::InOutPointer.new(GObject::Value, a)
+          _v3 = _proc.call(_v1)
+          _v2.set_value GObject::Value.from(_v3)
+        end
+        CODE
+
+        result.must_equal expected
+      end
+    end
+
     describe 'for a vfunc with an error argument' do
       let(:vfunc_info) do
         get_vfunc_introspection_data('GIMarshallingTests', 'Object',

data/test/gir_ffi/info_ext/i_type_info_test.rb

@@ -585,6 +585,15 @@ describe GirFFI::InfoExt::ITypeInfo do
       end
     end
 
+    describe 'for :void pointer' do
+      let(:tag) { :void }
+      let(:pointer?) { true }
+
+      it 'equals the none type' do
+        GObject.type_name(type_info.gtype).must_equal 'gpointer'
+      end
+    end
+
     describe 'for :gboolean' do
       let(:tag) { :gboolean }
       let(:pointer?) { false }
@@ -639,6 +648,15 @@ describe GirFFI::InfoExt::ITypeInfo do
       end
     end
 
+    describe 'for pointer to :glist' do
+      let(:tag) { :glist }
+      let(:pointer?) { true }
+
+      it 'equals the pointer type' do
+        GObject.type_name(type_info.gtype).must_equal 'gpointer'
+      end
+    end
+
     describe 'for arrays' do
       let(:tag) { :array }
       let(:pointer?) { true }

data/test/gir_ffi/user_defined_type_info_test.rb

@@ -2,6 +2,8 @@
 require 'gir_ffi_test_helper'
 require 'gir_ffi/user_defined_type_info'
 
+GirFFI.setup :GIMarshallingTests
+
 describe GirFFI::UserDefinedTypeInfo do
   describe '#described_class' do
     let(:info) { GirFFI::UserDefinedTypeInfo.new :some_class }
@@ -86,4 +88,27 @@ describe GirFFI::UserDefinedTypeInfo do
       info.find_method('foo').must_equal nil
     end
   end
+
+  describe '#find_signal' do
+    let(:klass) { Object.new }
+    let(:info) { GirFFI::UserDefinedTypeInfo.new klass }
+
+    it 'finds no signals' do
+      info.find_signal('foo').must_equal nil
+    end
+  end
+
+  describe '#interfaces' do
+    let(:modul) { GIMarshallingTests::Interface }
+    let(:klass) { Class.new GIMarshallingTests::Object }
+    let(:info) { GirFFI::UserDefinedTypeInfo.new klass }
+
+    before do
+      klass.send :include, modul
+    end
+
+    it 'returns the interface infos for the include modules' do
+      info.interfaces.must_equal [modul.gir_info]
+    end
+  end
 end

data/test/gir_ffi_test_helper.rb

@@ -30,12 +30,8 @@ module GirFFITestExtensions
     SAVED_MODULES.delete name
   end
 
-  def ref_count(object)
-    GObject::Object::Struct.new(object.to_ptr)[:ref_count]
-  end
-
-  def ref(object)
-    object.ref
+  def ref_count(ptr)
+    GObject::Object::Struct.new(ptr)[:ref_count]
   end
 
   def max_for_unsigned_type(type)

data/test/integration/generated_gimarshallingtests_test.rb

@@ -298,12 +298,12 @@ describe GIMarshallingTests do
 
     it 'has a working function #full_inout' do
       ob = GIMarshallingTests::Object.new 42
-      ref_count(ob).must_equal 1
+      ob.ref_count.must_equal 1
 
       res = GIMarshallingTests::Object.full_inout ob
 
-      ref_count(ob).must_be :>, 0
-      ref_count(res).must_equal 1
+      ob.ref_count.must_be :>, 0
+      res.ref_count.must_equal 1
 
       res.must_be_instance_of GIMarshallingTests::Object
       res.int.must_equal 0
@@ -400,7 +400,7 @@ describe GIMarshallingTests do
       end
       result = derived_instance.
         get_ref_info_for_vfunc_in_object_transfer_none GIMarshallingTests::Object.gtype
-      ref_count(obj).must_be :>, 0
+      obj.ref_count.must_be :>, 0
       result.must_equal [2, false]
       obj.must_be_instance_of GIMarshallingTests::Object
     end
@@ -415,7 +415,7 @@ describe GIMarshallingTests do
         }
       end
       result = derived_instance.get_ref_info_for_vfunc_out_object_transfer_full
-      ref_count(obj).must_be :>, 0
+      obj.ref_count.must_be :>, 0
       # TODO: Check desired result
       result.must_equal [2, false]
     end

data/test/integration/generated_gio_test.rb

@@ -5,10 +5,9 @@ GirFFI.setup :Gio
 
 # Tests generated methods and functions in the Gio namespace.
 describe 'The generated Gio module' do
-  # TODO: Allow Gio::File.new_for_path
-  describe '#file_new_for_path, a method returning an interface,' do
+  describe 'File#new_for_path, a method returning an interface,' do
     it 'returns an object of a more specific class' do
-      file = Gio.file_new_for_path('/')
+      file = Gio::File.new_for_path('/')
       refute_instance_of Gio::File, file
       assert_includes file.class.ancestors, Gio::File
     end

data/test/integration/generated_gst_test.rb

@@ -25,6 +25,7 @@ describe 'the generated Gst module' do
     let(:instance) { Gst::ElementFactory.make('autoaudiosink', 'audiosink') }
 
     it 'correctly fetches the name' do
+      skip 'Audio sink was not created' unless instance
       instance.get_name.must_equal 'audiosink'
       instance.name.must_equal 'audiosink'
     end

data/test/integration/generated_regress_test.rb

@@ -65,11 +65,11 @@ describe Regress do
     end
 
     it 'has a writable field a' do
-      skip 'Not implemented yet'
+      skip 'Anonymous union fields are not exposed in the GIR data'
     end
 
     it 'has a writable field padding' do
-      skip 'Not implemented yet'
+      skip 'Anonymous union fields are not exposed in the GIR data'
     end
   end
 
@@ -113,153 +113,287 @@ describe Regress do
   end
 
   describe 'Regress::AnnotationObject' do
+    let(:instance) { Regress::AnnotationObject.new }
+
+    it 'has an attribute org.example.Test' do
+      info = get_introspection_data('Regress', 'AnnotationObject')
+      info.attribute('org.example.Test').must_equal 'cows'
+    end
+
     it 'has a working method #allow_none' do
-      skip 'Needs testing'
+      instance.allow_none('hello!').must_be_nil
+      instance.allow_none(nil).must_be_nil
+      instance.allow_none.must_be_nil
     end
+
     it 'has a working method #calleeowns' do
-      skip 'Needs testing'
+      result, object = instance.calleeowns
+      result.must_equal 1
+      object.must_be_nil
     end
+
     it 'has a working method #calleesowns' do
-      skip 'Needs testing'
+      result, toown1, toown2 = instance.calleesowns
+      result.must_equal 1
+      toown1.must_be_nil
+      toown2.must_be_nil
     end
+
     it 'has a working method #compute_sum' do
-      skip 'Needs testing'
+      instance.compute_sum [1, 2, 3]
+      pass
     end
+
     it 'has a working method #compute_sum_n' do
-      skip 'Needs testing'
+      instance.compute_sum_n [1, 2, 3]
+      pass
     end
+
     it 'has a working method #compute_sum_nz' do
-      skip 'Needs testing'
+      instance.compute_sum_nz [1, 2, 3]
+      pass
     end
+
     it 'has a working method #create_object' do
-      skip 'Needs testing'
+      result = instance.create_object
+      result.must_equal instance
     end
+
     it 'has a working method #do_not_use' do
-      skip 'Needs testing'
+      # TODO: Handle deprecation
+      instance.do_not_use.must_be_nil
     end
+
     it 'has a working method #extra_annos' do
-      skip 'Needs testing'
+      info = get_method_introspection_data('Regress', 'AnnotationObject', 'extra_annos')
+      info.attribute('org.foobar').must_equal 'testvalue'
+
+      instance.extra_annos.must_be_nil
     end
+
     it 'has a working method #foreach' do
-      skip 'Needs testing'
+      a = 1
+      instance.foreach { a += 1 }
+      a.must_equal 1
     end
+
     it 'has a working method #get_hash' do
-      skip 'Needs testing'
+      result = instance.get_hash
+      hash = result.to_hash
+      hash['one'].must_equal instance
+      hash['two'].must_equal instance
     end
+
     it 'has a working method #get_objects' do
-      skip 'Needs testing'
+      list = instance.get_objects
+      list.to_a.must_equal [instance]
     end
+
     it 'has a working method #get_strings' do
-      skip 'Needs testing'
+      list = instance.get_strings
+      list.to_a.must_equal %w(bar regress_annotation)
     end
+
     it 'has a working method #hidden_self' do
-      skip 'Needs testing'
+      instance.hidden_self.must_be_nil
     end
+
     it 'has a working method #in' do
-      skip 'Needs testing'
+      # TODO: Automatically convert to pointer argument
+      ptr = FFI::MemoryPointer.new(:int, 1)
+      ptr.put_int 0, 2342
+      instance.in(ptr).must_equal 2342
     end
+
     it 'has a working method #inout' do
-      skip 'Needs testing'
+      instance.inout(2342).must_equal [2343, 2343]
     end
+
     it 'has a working method #inout2' do
-      skip 'Needs testing'
+      instance.inout2(2342).must_equal [2343, 2343]
     end
+
     it 'has a working method #inout3' do
-      skip 'Needs testing'
+      instance.inout3(2342).must_equal [2343, 2342]
     end
+
     it 'has a working method #method' do
-      skip 'Needs testing'
+      instance.method.must_equal 1
     end
+
     it 'has a working method #notrans' do
-      skip 'Needs testing'
+      instance.notrans.must_be_nil
     end
+
     it 'has a working method #out' do
-      skip 'Needs testing'
+      instance.out.must_equal [1, 2]
     end
+
     it 'has a working method #parse_args' do
-      skip 'Needs testing'
+      instance.parse_args(%w(one two)).to_a.must_equal %w(one two)
     end
+
     it 'has a working method #set_data' do
-      skip 'Needs testing'
+      # TODO: Explicitely allow or deny passing a string here.
+      instance.set_data([1, 2, 3]).must_be_nil
     end
+
     it 'has a working method #set_data2' do
-      skip 'Needs testing'
+      instance.set_data2([1, -2, 3]).must_be_nil
     end
+
     it 'has a working method #set_data3' do
-      skip 'Needs testing'
+      instance.set_data3([1, 2, 3]).must_be_nil
     end
+
     it 'has a working method #string_out' do
-      skip 'Needs testing'
+      instance.string_out.must_equal [false, nil]
     end
+
     it 'has a working method #use_buffer' do
-      skip 'Needs testing'
+      skip 'Ingoing pointer argument conversion is not implemented yet'
+      instance.use_buffer(FFI::MemoryPointer.new(:void, 1)).must_be_nil
     end
+
     it 'has a working method #watch_full' do
-      skip 'Needs testing'
+      instance.watch {}
     end
+
     it 'has a working method #with_voidp' do
-      skip 'Needs testing'
+      # NOTE: Anything implementing #to_ptr could be passed in here
+      obj = Regress::AnnotationObject.new
+      instance.with_voidp(obj).must_be_nil
     end
+
     describe "its 'function-property' property" do
-      it 'can be retrieved with #get_property' do
-        skip 'Needs testing'
+      it 'can be retrieved with #get_property_extended' do
+        instance.get_property_extended('function-property').must_be_nil
       end
+
       it 'can be retrieved with #function_property' do
-        skip 'Needs testing'
+        instance.function_property.must_be_nil
       end
-      it 'can be set with #set_property' do
-        skip 'Needs testing'
+
+      it 'can be set with #set_property_extended' do
+        instance.set_property_extended('function-property', proc {})
+        # AnnotationObject doesn't actually store stuff
+        instance.function_property.must_be_nil
       end
+
       it 'can be set with #function_property=' do
-        skip 'Needs testing'
+        instance.function_property = proc {}
+        # AnnotationObject doesn't actually store stuff
+        instance.get_property_extended('function-property').must_be_nil
       end
     end
+
     describe "its 'string-property' property" do
       it 'can be retrieved with #get_property' do
-        skip 'Needs testing'
+        instance.get_property('string-property').must_be_nil
       end
+
       it 'can be retrieved with #string_property' do
-        skip 'Needs testing'
+        instance.string_property.must_be_nil
       end
+
       it 'can be set with #set_property' do
-        skip 'Needs testing'
+        instance.set_property('string-property', 'hello 42')
+        # AnnotationObject doesn't actually store stuff
+        instance.string_property.must_be_nil
       end
+
       it 'can be set with #string_property=' do
-        skip 'Needs testing'
+        instance.string_property = 'hello 42'
+        # AnnotationObject doesn't actually store stuff
+        instance.get_property('string-property').must_be_nil
       end
     end
+
     describe "its 'tab-property' property" do
       it 'can be retrieved with #get_property' do
-        skip 'Needs testing'
+        instance.get_property('tab-property').must_be_nil
       end
+
       it 'can be retrieved with #tab_property' do
-        skip 'Needs testing'
+        instance.tab_property.must_be_nil
       end
+
       it 'can be set with #set_property' do
-        skip 'Needs testing'
+        instance.set_property('tab-property', 'hello 42')
+        # AnnotationObject doesn't actually store stuff
+        instance.tab_property.must_be_nil
       end
+
       it 'can be set with #tab_property=' do
-        skip 'Needs testing'
+        instance.tab_property = 'hello 42'
+        # AnnotationObject doesn't actually store stuff
+        instance.get_property('tab-property').must_be_nil
       end
     end
+
     it "handles the 'attribute-signal' signal" do
-      skip 'Needs testing'
+      signal_info = get_signal_introspection_data('Regress',
+                                                  'AnnotationObject',
+                                                  'attribute-signal')
+      argument_infos = signal_info.args
+      argument_infos.first.attribute('some.annotation.foo1').must_equal 'val1'
+      argument_infos.last.attribute('some.annotation.foo2').must_equal 'val2'
+
+      result = nil
+      instance.signal_connect 'attribute-signal' do |_obj, _arg1, _arg2, _user_data|
+        # This signal uses a null marshaller, so the return value is never passed on.
+        result = 'hello'
+      end
+
+      GObject.signal_emit instance, 'attribute-signal', 'foo', 'bar'
+      result.must_equal 'hello'
     end
+
     it "handles the 'doc-empty-arg-parsing' signal" do
-      skip 'Needs testing'
+      test = nil
+      instance.signal_connect 'doc-empty-arg-parsing' do |_obj, arg1, _user_data|
+        test = arg1
+      end
+
+      result = GObject.signal_emit instance, 'doc-empty-arg-parsing', FFI::Pointer.new(123)
+      result.must_be_nil
+      test.address.must_equal 123
     end
+
     it "handles the 'list-signal' signal" do
-      skip 'Needs testing'
+      result = nil
+      instance.signal_connect 'list-signal' do |_obj, list, _user_data|
+        result = list
+      end
+
+      # TODO: Automatically convert to GLib::List
+      GObject.signal_emit instance, 'list-signal', GLib::List.from(:utf8, %w(foo bar))
+      result.to_a.must_equal %w(foo bar)
     end
+
     it "handles the 'string-signal' signal" do
-      skip 'Needs testing'
+      result = nil
+      instance.signal_connect 'string-signal' do |_obj, string, _user_data|
+        result = string
+      end
+
+      GObject.signal_emit instance, 'string-signal', 'foo'
+      result.must_equal 'foo'
     end
   end
+
   describe 'Regress::AnnotationStruct' do
+    let(:instance) { Regress::AnnotationStruct.new }
+
     it 'has a writable field objects' do
-      skip 'Needs testing'
+      instance.objects.to_a.must_equal [nil] * 10
+
+      obj = Regress::AnnotationObject.new
+      instance.objects = [nil] * 5 + [obj] + [nil] * 4
+      instance.objects.to_a[5].must_equal obj
     end
   end
+
   it 'has the constant BOOL_CONSTANT' do
     skip unless get_introspection_data 'Regress', 'BOOL_CONSTANT'
     Regress::BOOL_CONSTANT.must_equal true
@@ -270,355 +404,615 @@ describe Regress do
   end
 
   it 'has the constant FOO_DEFINE_SHOULD_BE_EXPOSED' do
-    skip 'Needs testing'
+    Regress::FOO_DEFINE_SHOULD_BE_EXPOSED.must_equal 'should be exposed'
   end
+
   it 'has the constant FOO_PIE_IS_TASTY' do
-    skip 'Needs testing'
+    Regress::FOO_PIE_IS_TASTY.must_equal 3.141590
   end
+
   it 'has the constant FOO_SUCCESS_INT' do
-    skip 'Needs testing'
+    Regress::FOO_SUCCESS_INT.must_equal 4408
   end
+
   describe 'Regress::FooASingle' do
     it 'has the member :foo_some_single_enum' do
-      skip 'Needs testing'
+      Regress::FooASingle[:foo_some_single_enum].must_equal 0
     end
   end
+
   describe 'Regress::FooAddressType' do
     it 'has the member :invalid' do
-      skip 'Needs testing'
+      Regress::FooAddressType[:invalid].must_equal 0
     end
+
     it 'has the member :ipv4' do
-      skip 'Needs testing'
+      Regress::FooAddressType[:ipv4].must_equal 1
     end
+
     it 'has the member :ipv6' do
-      skip 'Needs testing'
+      Regress::FooAddressType[:ipv6].must_equal 2
     end
   end
+
   describe 'Regress::FooBRect' do
+    let(:instance) { Regress::FooBRect.wrap(Regress::FooBRect::Struct.new.to_ptr) }
+
     it 'has a writable field x' do
-      skip 'Needs testing'
+      instance.x.must_equal 0.0
+      instance.x = 23.42
+      instance.x.must_equal 23.42
     end
+
     it 'has a writable field y' do
-      skip 'Needs testing'
+      instance.y.must_equal 0.0
+      instance.y = 23.42
+      instance.y.must_equal 23.42
     end
+
     it 'creates an instance using #new' do
-      skip 'Needs testing'
+      skip 'This function is defined in the header but not implemented'
     end
+
     it 'has a working method #add' do
-      skip 'Needs testing'
+      skip 'This function is defined in the header but not implemented'
     end
   end
+
   describe 'Regress::FooBUnion' do
+    let(:instance) { Regress::FooBUnion.wrap(Regress::FooBUnion::Struct.new.to_ptr) }
+
     it 'has a writable field type' do
-      skip 'Needs testing'
+      instance.type.must_equal 0
+      instance.type = 42
+      instance.type.must_equal 42
     end
+
     it 'has a writable field v' do
-      skip 'Needs testing'
+      instance.v.must_equal 0.0
+      instance.v = 23.42
+      instance.v.must_equal 23.42
     end
+
     it 'has a writable field rect' do
-      skip 'Needs testing'
+      instance.rect.must_be_nil
+      rect = Regress::FooBRect.wrap(Regress::FooBRect::Struct.new.to_ptr)
+      rect.x = 42
+      rect.y = 23
+      instance.rect = rect
+      instance.rect.x.must_equal 42.0
+      instance.rect.y.must_equal 23.0
     end
+
     it 'creates an instance using #new' do
-      skip 'Needs testing'
+      skip 'This function is defined in the header but not implemented'
     end
+
     it 'has a working method #get_contained_type' do
-      skip 'Needs testing'
+      skip 'This function is defined in the header but not implemented'
     end
   end
+
   describe 'Regress::FooBoxed' do
+    let(:instance) { Regress::FooBoxed.new }
+
     it 'creates an instance using #new' do
-      skip 'Needs testing'
+      instance.must_be_instance_of Regress::FooBoxed
     end
+
     it 'has a working method #method' do
-      skip 'Needs testing'
+      instance.method.must_be_nil
     end
   end
+
   describe 'Regress::FooBuffer' do
+    let(:instance) { Regress::FooBuffer.new }
+
+    it 'creates an instance using #new' do
+      instance.must_be_instance_of Regress::FooBuffer
+    end
+
     it 'has a working method #some_method' do
-      skip 'Needs testing'
+      instance.some_method.must_be_nil
     end
   end
+
   describe 'Regress::FooDBusData' do
+    let(:instance) { Regress::FooDBusData.new }
+
+    it 'creates an instance using #new' do
+      instance.must_be_instance_of Regress::FooDBusData
+    end
+
     it 'has a working method #method' do
-      skip 'Needs testing'
+      skip 'This function is defined in the header but not implemented'
     end
   end
+
   describe 'Regress::FooEnumFullname' do
     it 'has the member :one' do
-      skip 'Needs testing'
+      Regress::FooEnumFullname[:one].must_equal 1
     end
+
     it 'has the member :two' do
-      skip 'Needs testing'
+      Regress::FooEnumFullname[:two].must_equal 2
     end
+
     it 'has the member :three' do
-      skip 'Needs testing'
+      Regress::FooEnumFullname[:three].must_equal 3
     end
   end
+
   describe 'Regress::FooEnumNoType' do
     it 'has the member :un' do
-      skip 'Needs testing'
+      Regress::FooEnumNoType[:un].must_equal 1
     end
+
     it 'has the member :deux' do
-      skip 'Needs testing'
+      Regress::FooEnumNoType[:deux].must_equal 2
     end
+
     it 'has the member :trois' do
-      skip 'Needs testing'
+      Regress::FooEnumNoType[:trois].must_equal 3
     end
+
     it 'has the member :neuf' do
-      skip 'Needs testing'
+      Regress::FooEnumNoType[:neuf].must_equal 9
     end
   end
+
   describe 'Regress::FooEnumType' do
     it 'has the member :alpha' do
-      skip 'Needs testing'
+      Regress::FooEnumType[:alpha].must_equal 0
     end
+
     it 'has the member :beta' do
-      skip 'Needs testing'
+      Regress::FooEnumType[:beta].must_equal 1
     end
+
     it 'has the member :delta' do
-      skip 'Needs testing'
+      Regress::FooEnumType[:delta].must_equal 2
     end
+
     it 'has a working function #method' do
-      skip 'Needs testing'
+      skip 'This function is defined in the header but not implemented'
     end
+
     it 'has a working function #returnv' do
-      skip 'Needs testing'
+      skip 'This function is defined in the header but not implemented'
     end
   end
+
   describe 'Regress::FooError' do
     it 'has the member :good' do
-      skip 'Needs testing'
+      Regress::FooError[:good].must_equal 0
     end
+
     it 'has the member :bad' do
-      skip 'Needs testing'
+      Regress::FooError[:bad].must_equal 1
     end
+
     it 'has the member :ugly' do
-      skip 'Needs testing'
+      Regress::FooError[:ugly].must_equal 2
     end
+
     it 'has a working function #quark' do
-      skip 'Needs testing'
+      quark = Regress::FooError.quark
+      GLib.quark_to_string(quark).must_equal 'regress_foo-error-quark'
     end
   end
+
   describe 'Regress::FooEvent' do
+    let(:instance) { Regress::FooEvent.new }
+
     it 'has a writable field type' do
-      skip 'Needs testing'
+      instance.type.must_equal 0
+      instance.type = 23
+      instance.type.must_equal 23
     end
+
     it 'has a writable field any' do
-      skip 'Needs testing'
+      instance.any.send_event.must_equal 0
+      any = Regress::FooEventAny.new
+      any.send_event = 42
+      instance.any = any
+      instance.any.send_event.must_equal 42
     end
+
     it 'has a writable field expose' do
-      skip 'Needs testing'
+      instance.expose.send_event.must_equal 0
+      instance.expose.count.must_equal 0
+      expose = Regress::FooEventExpose.new
+      expose.send_event = 23
+      expose.count = 14
+      instance.expose = expose
+      instance.expose.send_event.must_equal 23
+      instance.expose.count.must_equal 14
     end
   end
+
   describe 'Regress::FooEventAny' do
+    let(:instance) { Regress::FooEventAny.new }
+
     it 'has a writable field send_event' do
-      skip 'Needs testing'
+      instance.send_event.must_equal 0
+      instance.send_event = 23
+      instance.send_event.must_equal 23
     end
   end
+
   describe 'Regress::FooEventExpose' do
+    let(:instance) { Regress::FooEventExpose.new }
+
     it 'has a writable field send_event' do
-      skip 'Needs testing'
+      instance.send_event.must_equal 0
+      instance.send_event = 23
+      instance.send_event.must_equal 23
     end
+
     it 'has a writable field count' do
-      skip 'Needs testing'
+      instance.count.must_equal 0
+      instance.count = 42
+      instance.count.must_equal 42
     end
   end
+
   describe 'Regress::FooFlagsNoType' do
     it 'has the member :ett' do
-      skip 'Needs testing'
+      Regress::FooFlagsNoType[:ett].must_equal 1
     end
+
     it 'has the member :tva' do
-      skip 'Needs testing'
+      Regress::FooFlagsNoType[:tva].must_equal 2
     end
+
     it 'has the member :fyra' do
-      skip 'Needs testing'
+      Regress::FooFlagsNoType[:fyra].must_equal 4
     end
   end
+
   describe 'Regress::FooFlagsType' do
     it 'has the member :first' do
-      skip 'Needs testing'
+      Regress::FooFlagsType[:first].must_equal 1
     end
+
     it 'has the member :second' do
-      skip 'Needs testing'
+      Regress::FooFlagsType[:second].must_equal 2
     end
+
     it 'has the member :third' do
-      skip 'Needs testing'
+      Regress::FooFlagsType[:third].must_equal 4
     end
   end
+
   describe 'Regress::FooForeignStruct' do
+    let(:instance) { Regress::FooForeignStruct.new }
+
     it 'has a writable field regress_foo' do
-      skip 'Needs testing'
+      instance.regress_foo.must_equal 0
+      instance.regress_foo = 143
+      instance.regress_foo.must_equal 143
     end
+
     it 'creates an instance using #new' do
-      skip 'Needs testing'
+      instance.must_be_instance_of Regress::FooForeignStruct
     end
+
     it 'has a working method #copy' do
-      skip 'Needs testing'
+      instance.regress_foo = 585
+      result = instance.copy
+      instance.regress_foo = 0
+      result.regress_foo.must_equal 585
     end
   end
+
   describe 'Regress::FooInterface' do
     it 'has a working function #static_method' do
-      skip 'Needs testing'
+      Regress::FooInterface.static_method(42).must_be_nil
     end
+
     it 'has a working method #do_regress_foo' do
-      skip 'Needs testing'
+      instance = Regress::FooObject.new
+      instance.must_be_kind_of Regress::FooInterface
+      instance.do_regress_foo(42).must_be_nil
     end
   end
+
   describe 'Regress::FooObject' do
+    let(:instance) { Regress::FooObject.new }
+
     it 'creates an instance using #new' do
-      skip 'Needs testing'
+      instance.must_be_instance_of Regress::FooObject
     end
+
     it 'creates an instance using #new_as_super' do
-      skip 'Needs testing'
+      other_instance = Regress::FooObject.new_as_super
+      other_instance.must_be_instance_of Regress::FooObject
     end
+
     it 'has a working function #a_global_method' do
-      skip 'Needs testing'
+      skip 'This function is defined in the header but not implemented'
     end
+
     it 'has a working function #get_default' do
-      skip 'Needs testing'
+      Regress::FooObject.get_default.must_be_nil
     end
+
     it 'has a working function #static_meth' do
-      skip 'Needs testing'
+      skip 'This function is defined in the header but not implemented'
     end
+
     it 'has a working method #append_new_stack_layer' do
-      skip 'Needs testing'
+      instance.append_new_stack_layer(42).must_be_nil
     end
+
     it 'has a working method #dup_name' do
-      skip 'Needs testing'
+      instance.dup_name.must_equal 'regress_foo'
     end
+
     it 'has a working method #external_type' do
-      skip 'Needs testing'
+      result = instance.external_type
+      result.must_be_nil
     end
+
     it 'has a working method #get_name' do
-      skip 'Needs testing'
+      instance.get_name.must_equal 'regress_foo'
     end
+
     it 'has a working method #handle_glyph' do
-      skip 'Needs testing'
+      skip 'This function is defined in the header but not implemented'
     end
+
     it 'has a working method #is_it_time_yet' do
-      skip 'Needs testing'
+      instance.is_it_time_yet(Time.now.to_i).must_be_nil
     end
+
     it 'has a working method #read' do
-      skip 'Needs testing'
+      instance.read(12, 13).must_be_nil
     end
+
     it 'has a working method #various' do
-      skip 'Needs testing'
+      skip 'This function is defined in the header but not implemented'
     end
+
     it 'has a working method #virtual_method' do
-      skip 'Needs testing'
+      skip 'This function is defined in the header but not implemented'
     end
+
     describe "its 'string' property" do
       it 'can be retrieved with #get_property' do
-        skip 'Needs testing'
+        instance.get_property('string').must_equal nil
       end
+
       it 'can be retrieved with #string' do
-        skip 'Needs testing'
+        instance.string.must_equal nil
       end
+
       it 'can be set with #set_property' do
-        skip 'Needs testing'
+        instance.set_property 'string', 'hello 42'
+        # FooObject doesn't actually store stuff
+        instance.string.must_be_nil
+        instance.get_property('string').must_be_nil
       end
+
       it 'can be set with #string=' do
-        skip 'Needs testing'
+        instance.string = 'hello 42'
+        # FooObject doesn't actually store stuff
+        instance.string.must_be_nil
+        instance.get_property('string').must_be_nil
       end
     end
+
     it "handles the 'signal' signal" do
+      instance.signal_connect 'signal' do
+        'hello'
+      end
+
+      result = GObject.signal_emit instance, 'signal'
+      result.must_equal 'hello'
     end
   end
+
   describe 'Regress::FooOtherObject' do
+    it 'is derived from GObject::Object' do
+      Regress::FooOtherObject.superclass.must_equal GObject::Object
+    end
   end
+
   describe 'Regress::FooRectangle' do
+    let(:instance) { Regress::FooRectangle.new }
+
     it 'has a writable field x' do
-      skip 'Needs testing'
+      instance.x.must_equal 0
+      instance.x = 23
+      instance.x.must_equal 23
     end
+
     it 'has a writable field y' do
-      skip 'Needs testing'
+      instance.y.must_equal 0
+      instance.y = 23
+      instance.y.must_equal 23
     end
+
     it 'has a writable field width' do
-      skip 'Needs testing'
+      instance.width.must_equal 0
+      instance.width = 23
+      instance.width.must_equal 23
     end
+
     it 'has a writable field height' do
-      skip 'Needs testing'
+      instance.height.must_equal 0
+      instance.height = 23
+      instance.height.must_equal 23
     end
+
     it 'has a working method #add' do
-      skip 'Needs testing'
+      skip 'Not implemented yet'
+      other_instance = Regress::FooRectangle.new
+      instance.add other_instance
     end
   end
+
   describe 'Regress::FooStackLayer' do
     it 'has the member :desktop' do
-      skip 'Needs testing'
+      Regress::FooStackLayer[:desktop].must_equal 0
     end
+
     it 'has the member :bottom' do
-      skip 'Needs testing'
+      Regress::FooStackLayer[:bottom].must_equal 1
     end
+
     it 'has the member :normal' do
-      skip 'Needs testing'
+      Regress::FooStackLayer[:normal].must_equal 2
     end
+
     it 'has the member :top' do
-      skip 'Needs testing'
+      Regress::FooStackLayer[:top].must_equal 4
     end
+
     it 'has the member :dock' do
-      skip 'Needs testing'
+      Regress::FooStackLayer[:dock].must_equal 4
     end
+
     it 'has the member :fullscreen' do
-      skip 'Needs testing'
+      Regress::FooStackLayer[:fullscreen].must_equal 5
     end
+
     it 'has the member :focused_window' do
-      skip 'Needs testing'
+      Regress::FooStackLayer[:focused_window].must_equal 6
     end
+
     it 'has the member :override_redirect' do
-      skip 'Needs testing'
+      Regress::FooStackLayer[:override_redirect].must_equal 7
     end
+
     it 'has the member :last' do
-      skip 'Needs testing'
+      Regress::FooStackLayer[:last].must_equal 8
     end
   end
+
   describe 'Regress::FooStruct' do
+    let(:instance) { Regress::FooStruct.new }
+
     it 'has a writable field priv' do
-      skip 'Needs testing'
+      instance.priv.must_be_nil
+      struct = Regress::FooStructPrivate.new
+      instance.priv = struct
+      instance.priv.must_equal struct
     end
+
     it 'has a writable field member' do
-      skip 'Needs testing'
+      instance.member.must_equal 0
+      instance.member = 23
+      instance.member.must_equal 23
     end
   end
+
   describe 'Regress::FooSubInterface' do
+    let(:derived_klass) do
+      Object.const_set("DerivedClass#{Sequence.next}",
+                       Class.new(Regress::FooObject))
+    end
+
+    def make_derived_instance
+      derived_klass.send :include, Regress::FooSubInterface
+      GirFFI.define_type derived_klass do |info|
+        yield info if block_given?
+      end
+      derived_klass.new
+    end
+
     it 'has a working method #do_bar' do
-      skip 'Needs testing'
+      result = nil
+      instance = make_derived_instance do |info|
+        info.install_vfunc_implementation :do_bar, proc { |obj| result = obj.get_name }
+      end
+      instance.do_bar
+      result.must_equal 'regress_foo'
     end
+
     it 'has a working method #do_baz' do
-      skip 'Needs testing'
+      a = nil
+      instance = make_derived_instance do |info|
+        # TODO: Do not pass callback again in user_data if destroy notifier is absent
+        info.install_vfunc_implementation :do_baz,
+                                          proc { |obj, callback, _user_data| callback.call; a = obj.get_name }
+      end
+      b = nil
+      instance.do_baz { b = 'hello' }
+      a.must_equal 'regress_foo'
+      b.must_equal 'hello'
     end
+
     it "handles the 'destroy-event' signal" do
+      a = nil
+      instance = make_derived_instance
+      instance.signal_connect 'destroy-event' do
+        a = 'hello'
+      end
+      GObject.signal_emit instance, 'destroy-event'
+      a.must_equal 'hello'
     end
   end
+
   describe 'Regress::FooSubobject' do
     it 'creates an instance using #new' do
-      skip 'Needs testing'
+      # TODO: Guard against instantiating abstract classes
+      skip 'This function is defined in the header but not implemented'
     end
   end
+
   describe 'Regress::FooThingWithArray' do
+    let(:instance) { Regress::FooThingWithArray.new }
+
     it 'has a writable field x' do
-      skip 'Needs testing'
+      instance.x.must_equal 0
+      instance.x = 23
+      instance.x.must_equal 23
     end
+
     it 'has a writable field y' do
-      skip 'Needs testing'
+      instance.y.must_equal 0
+      instance.y = 23
+      instance.y.must_equal 23
     end
+
     it 'has a writable field lines' do
-      skip 'Needs testing'
+      instance.lines.must_be :==, [0] * 80
+      instance.lines = (1..80).to_a
+      instance.lines.must_be :==, (1..80).to_a
     end
+
     it 'has a writable field data' do
-      skip 'Needs testing'
+      instance.data.must_equal FFI::Pointer::NULL
+      instance.data = FFI::Pointer.new(23)
+      instance.data.must_equal FFI::Pointer.new(23)
     end
   end
+
   describe 'Regress::FooUnion' do
+    let(:instance) { Regress::FooUnion.new }
+
     it 'has a writable field regress_foo' do
-      skip 'Needs testing'
+      instance.regress_foo.must_equal 0
+      instance.regress_foo = 23
+      instance.regress_foo.must_equal 23
     end
   end
+
   describe 'Regress::FooUtilityStruct' do
+    let(:instance) { Regress::FooUtilityStruct.new }
+
     it 'has a writable field bar' do
-      skip 'Needs testing'
+      struct = Utility::Struct.new
+      struct.field = 23
+
+      instance.bar.field.must_equal 0
+      instance.bar = struct
+      instance.bar.field.must_equal 23
     end
   end
+
   it 'has the constant GI_SCANNER_ELSE' do
     skip unless get_introspection_data 'Regress', 'GI_SCANNER_ELSE'
     Regress::GI_SCANNER_ELSE.must_equal 3
@@ -1030,7 +1424,7 @@ describe Regress do
       end
 
       it 'has a reference count of 1' do
-        assert_equal 1, ref_count(@o)
+        assert_equal 1, @o.ref_count
       end
 
       it 'has been sunk' do
@@ -1190,7 +1584,7 @@ describe Regress do
     end
 
     it 'has a reference count of 1' do
-      assert_equal 1, ref_count(instance)
+      assert_equal 1, instance.ref_count
     end
 
     it 'does not float' do
@@ -1261,9 +1655,9 @@ describe Regress do
 
     it 'has a working method #instance_method_full' do
       skip unless get_method_introspection_data('Regress', 'TestObj', 'instance_method_full')
-      ref_count(instance).must_equal 1
+      instance.ref_count.must_equal 1
       instance.instance_method_full
-      ref_count(instance).must_equal 1
+      instance.ref_count.must_equal 1
     end
 
     it 'has a working method #set_bare' do
@@ -2314,53 +2708,81 @@ describe Regress do
   end
 
   it 'has a working function #annotation_attribute_func' do
-    skip 'Needs testing'
+    info = get_introspection_data('Regress', 'annotation_attribute_func')
+    param = info.args.last
+    param.attribute('some.annotation').must_equal 'value'
+    param.attribute('another.annotation').must_equal 'blahvalue'
+
+    obj = Regress::AnnotationObject.new
+    Regress.annotation_attribute_func(obj, 'hello').must_equal 42
   end
+
   it 'has a working function #annotation_custom_destroy' do
-    skip 'Needs testing'
+    result = Regress.annotation_custom_destroy {}
+    result.must_be_nil
   end
+
   it 'has a working function #annotation_get_source_file' do
-    skip 'Needs testing'
+    Regress.annotation_get_source_file.must_be_nil
   end
+
   it 'has a working function #annotation_init' do
-    skip 'Needs testing'
+    result = Regress.annotation_init %w(foo bar)
+    result.to_a.must_equal %w(foo bar)
   end
+
   it 'has a working function #annotation_invalid_regress_annotation' do
-    skip 'Needs testing'
+    Regress.annotation_invalid_regress_annotation(42).must_be_nil
   end
+
   it 'has a working function #annotation_ptr_array' do
-    skip 'Needs testing'
+    # TODO: Automatically convert array elements to correct type
+    val1 = GObject::Value.from 1
+    val2 = GObject::Value.from 'a'
+    Regress.annotation_ptr_array([val1, val2]).must_be_nil
   end
+
   it 'has a working function #annotation_return_array' do
-    skip 'Needs testing'
+    Regress.annotation_return_array.must_be_nil
   end
+
   it 'has a working function #annotation_return_filename' do
-    skip 'Needs testing'
+    Regress.annotation_return_filename.must_equal 'a utf-8 filename'
   end
+
   it 'has a working function #annotation_set_source_file' do
-    skip 'Needs testing'
+    Regress.annotation_set_source_file('a filename').must_be_nil
   end
+
   it 'has a working function #annotation_space_after_comment_bug631690' do
-    skip 'Needs testing'
+    Regress.annotation_space_after_comment_bug631690.must_be_nil
   end
+
   it 'has a working function #annotation_string_array_length' do
-    skip 'Needs testing'
+    Regress.annotation_string_array_length(%w(foo bar)).must_be_nil
   end
+
   it 'has a working function #annotation_string_zero_terminated' do
-    skip 'Needs testing'
+    Regress.annotation_string_zero_terminated.to_a.must_equal []
   end
+
   it 'has a working function #annotation_string_zero_terminated_out' do
-    skip 'Needs testing'
+    Regress.annotation_string_zero_terminated_out(%w(foo bar)).to_a.
+      must_equal %w(foo bar)
   end
+
   it 'has a working function #annotation_test_parsing_bug630862' do
-    skip 'Needs testing'
+    Regress.annotation_test_parsing_bug630862.must_be_nil
   end
+
   it 'has a working function #annotation_transfer_floating' do
-    skip 'Needs testing'
+    Regress.annotation_transfer_floating.must_be_nil
   end
+
   it 'has a working function #annotation_versioned' do
-    skip 'Needs testing'
+    Regress.annotation_versioned.must_be_nil
   end
+
   it 'has a working function #atest_error_quark' do
     skip unless get_introspection_data 'Regress', 'atest_error_quark'
     result = Regress.atest_error_quark
@@ -2368,59 +2790,78 @@ describe Regress do
   end
 
   it 'has a working function #foo_async_ready_callback' do
-    skip 'Needs testing'
+    skip 'This function is defined in the header but not implemented'
   end
+
   it 'has a working function #foo_destroy_notify_callback' do
-    skip 'Needs testing'
+    skip 'This function is defined in the header but not implemented'
   end
+
   it 'has a working function #foo_enum_type_method' do
-    skip 'Needs testing'
+    skip 'This function is defined in the header but not implemented'
   end
+
   it 'has a working function #foo_enum_type_returnv' do
-    skip 'Needs testing'
+    skip 'This function is defined in the header but not implemented'
   end
+
   it 'has a working function #foo_error_quark' do
-    skip 'Needs testing'
+    result = Regress.foo_error_quark
+    GLib.quark_to_string(result).must_equal('regress_foo-error-quark')
   end
+
   it 'has a working function #foo_init' do
-    skip 'Needs testing'
+    Regress.foo_init.must_equal 0x1138
   end
+
   it 'has a working function #foo_interface_static_method' do
-    skip 'Needs testing'
+    Regress.foo_interface_static_method(42).must_be_nil
   end
+
   it 'has a working function #foo_method_external_references' do
-    skip 'Needs testing'
+    skip 'This function is defined in the header but not implemented'
   end
+
   it 'has a working function #foo_not_a_constructor_new' do
-    skip 'Needs testing'
+    Regress.foo_not_a_constructor_new.must_be_nil
   end
+
   it 'has a working function #foo_test_array' do
-    skip 'Needs testing'
+    Regress.foo_test_array.must_be_nil
   end
+
   it 'has a working function #foo_test_const_char_param' do
-    skip 'Needs testing'
+    skip 'This function is defined in the header but not implemented'
   end
+
   it 'has a working function #foo_test_const_char_retval' do
-    skip 'Needs testing'
+    skip 'This function is defined in the header but not implemented'
   end
+
   it 'has a working function #foo_test_const_struct_param' do
-    skip 'Needs testing'
+    skip 'This function is defined in the header but not implemented'
   end
+
   it 'has a working function #foo_test_const_struct_retval' do
-    skip 'Needs testing'
+    skip 'This function is defined in the header but not implemented'
   end
+
   it 'has a working function #foo_test_string_array' do
-    skip 'Needs testing'
+    Regress.foo_test_string_array(%w(foo bar)).must_be_nil
   end
+
   it 'has a working function #foo_test_string_array_with_g' do
-    skip 'Needs testing'
+    Regress.foo_test_string_array_with_g(%w(foo bar)).must_be_nil
   end
+
   it 'has a working function #foo_test_unsigned_qualifier' do
-    skip 'Needs testing'
+    skip 'This function is defined in the header but not implemented'
   end
+
   it 'has a working function #foo_test_unsigned_type' do
-    skip 'Needs testing'
+    skip 'This function is defined in the header but not implemented'
   end
+
   it 'has a working function #func_obj_null_in' do
     Regress.func_obj_null_in nil
     Regress.func_obj_null_in Regress::TestObj.constructor
@@ -2700,7 +3141,7 @@ describe Regress do
     skip unless get_introspection_data 'Regress', 'test_callback_return_full'
     obj = Regress::TestObj.constructor
     Regress.test_callback_return_full { obj }
-    ref_count(obj).must_equal 1
+    obj.ref_count.must_equal 1
   end
 
   it 'has a working function #test_callback_thaw_async' do
@@ -2937,8 +3378,8 @@ describe Regress do
   end
 
   it 'has a working function #test_glist_gtype_container_in' do
-    skip 'Not implemented yet'
-    Regress.test_glist_gtype_container_in %w(1 2 3)
+    skip unless get_introspection_data 'Regress', 'test_glist_gtype_container_in'
+    Regress.test_glist_gtype_container_in [Regress::TestObj.gtype, Regress::TestSubObj.gtype]
     pass
   end
 
@@ -3025,8 +3466,8 @@ describe Regress do
   it 'has a working function #test_gvariant_asv' do
     result = Regress.test_gvariant_asv
     result.n_children.must_equal 2
-    result.lookup_value('name', nil).get_string.must_equal 'foo'
-    result.lookup_value('timeout', nil).get_int32.must_equal 10
+    result.lookup_value('name').get_string.must_equal 'foo'
+    result.lookup_value('timeout').get_int32.must_equal 10
   end
 
   it 'has a working function #test_gvariant_i' do