gir_ffi 0.6.6 → 0.6.7

data/test/integration/generated_gio_test.rb

@@ -2,17 +2,11 @@ require 'gir_ffi_test_helper'
 
 # Tests generated methods and functions in the Gio namespace.
 describe "The generated Gio module" do
-  setup do
+  before do
     GirFFI.setup :Gio
   end
 
   describe "#file_new_for_path, a method returning an interface," do
-    it "does not throw an error when generated" do
-      assert_nothing_raised {
-        Gio.file_new_for_path('/')
-      }
-    end
-
     it "returns an object of a more specific class" do
       file = Gio.file_new_for_path('/')
       refute_instance_of Gio::File, file
@@ -41,14 +35,14 @@ describe "The generated Gio module" do
     end
   end
 
-  context "the FileInfo class" do
-    context "an instance" do
-      setup do
+  describe "the FileInfo class" do
+    describe "an instance" do
+      before do
         file = Gio.file_new_for_path('/')
         @fileinfo = file.query_info "*", :none, nil
       end
 
-      should "hava a working #get_attribute_type method" do
+      it "has a working #get_attribute_type method" do
         type = @fileinfo.get_attribute_type "standard::display-name"
         assert_equal :string, type
       end

data/test/integration/generated_gobject_test.rb

@@ -27,4 +27,12 @@ describe "The generated GObject module" do
       assert_includes klass.ancestors, GObject::TypePlugin
     end
   end
+
+  describe "the ValueArray struct class" do
+    it "uses the constructor provided by GObject" do
+      instance = GObject::ValueArray.new 16
+      instance.n_prealloced.must_equal 16
+      instance.n_values.must_equal 0
+    end
+  end
 end

data/test/integration/generated_regress_test.rb

@@ -148,6 +148,30 @@ describe Regress do
   end
 
   describe "Regress::TestBoxed" do
+    let(:instance) { Regress::TestBoxed.new_alternative_constructor1 123 }
+
+    it "has a writable field some_int8" do
+      instance.some_int8.must_equal 123
+      instance.some_int8 = -43
+      instance.some_int8.must_equal(-43)
+    end
+
+    it "has a writable field nested_a" do
+      instance.nested_a.some_int.must_equal 0
+      nested = Regress::TestSimpleBoxedA.new
+      nested.some_int = 12345
+      instance.nested_a = nested
+      instance.nested_a.some_int.must_equal 12345
+    end
+
+    it "has a writable field priv" do
+      instance.priv.wont_be_nil
+      other = Regress::TestBoxed.new
+      instance.priv.wont_equal other.priv
+      instance.priv = other.priv
+      instance.priv.must_equal other.priv
+    end
+
     it "creates an instance using #new" do
       tb = Regress::TestBoxed.new
       assert_instance_of Regress::TestBoxed, tb
@@ -175,8 +199,6 @@ describe Regress do
       assert Regress::TestBoxed.get_gtype > 0
     end
 
-    let(:instance) { Regress::TestBoxed.new_alternative_constructor1 123 }
-
     it "has a working method #copy" do
       tb2 = instance.copy
       assert_instance_of Regress::TestBoxed, tb2
@@ -192,13 +214,25 @@ describe Regress do
   end
 
   describe "Regress::TestBoxedB" do
+    let(:instance) { Regress::TestBoxedB.new 8, 42 }
+
+    it "has a writable field some_int8" do
+      instance.some_int8.must_equal 8
+      instance.some_int8 = -43
+      instance.some_int8.must_equal(-43)
+    end
+
+    it "has a writable field some_long" do
+      instance.some_long.must_equal 42
+      instance.some_long = -4342
+      instance.some_long.must_equal(-4342)
+    end
+
     it "creates an instance using #new" do
       tb = Regress::TestBoxedB.new 8, 42
       assert_instance_of Regress::TestBoxedB, tb
     end
 
-    let(:instance) { Regress::TestBoxedB.new 8, 42 }
-
     it "has a working method #copy" do
       cp = instance.copy
       cp.must_be_instance_of Regress::TestBoxedB
@@ -213,6 +247,21 @@ describe Regress do
     before do
       skip unless get_introspection_data 'Regress', 'TestBoxedC'
     end
+
+    let(:instance) { Regress::TestBoxedC.new }
+
+    it "has a writable field refcount" do
+      instance.refcount.must_equal 1
+      instance.refcount = 2
+      instance.refcount.must_equal 2
+    end
+
+    it "has a writable field another_thing" do
+      instance.another_thing.must_equal 42
+      instance.another_thing = 4342
+      instance.another_thing.must_equal 4342
+    end
+
     it "creates an instance using #new" do
       tb = Regress::TestBoxedC.new
       assert_instance_of Regress::TestBoxedC, tb
@@ -223,17 +272,29 @@ describe Regress do
     before do
       skip unless get_introspection_data 'Regress', 'TestBoxedD'
     end
+
     it "creates an instance using #new" do
-      skip
+      instance = Regress::TestBoxedD.new "foo", 42
+      instance.must_be_instance_of Regress::TestBoxedD
     end
+
     it "has a working method #copy" do
-      skip
+      instance = Regress::TestBoxedD.new "foo", 42
+      copy = instance.copy
+      copy.must_be_instance_of Regress::TestBoxedD
+      instance.get_magic.must_equal copy.get_magic
+      instance.wont_equal copy
     end
+
     it "has a working method #free" do
-      skip
+      instance = Regress::TestBoxedD.new "foo", 42
+      instance.free
+      pass
     end
+
     it "has a working method #get_magic" do
-      skip
+      instance = Regress::TestBoxedD.new "foo", 42
+      instance.get_magic.must_equal "foo".length + 42
     end
   end
 
@@ -350,7 +411,7 @@ describe Regress do
     end
 
     describe "an instance" do
-      setup do
+      before do
         @o = Regress::TestFloating.new
       end
 
@@ -391,11 +452,6 @@ describe Regress do
 
     let(:instance) { Regress::TestFundamentalSubObject.new "foo" }
 
-    it "can be instantiated" do
-      instance
-      pass
-    end
-
     it "is a subclass of TestFundamentalObject" do
       assert_kind_of Regress::TestFundamentalObject, instance
     end
@@ -405,9 +461,7 @@ describe Regress do
     end
 
     it "can access its parent class' fields directly" do
-      assert_nothing_raised do
-        instance.flags
-      end
+      instance.flags.must_equal 0
     end
 
     # NOTE: The following tests test fields and methods on the abstract parent
@@ -492,241 +546,465 @@ describe Regress do
       end
     end
 
-    describe "#get_property" do
-      it "gets the 'bare' property" do
+    it "has a reference count of 1" do
+      assert_equal 1, ref_count(instance)
+    end
+
+    it "does not float" do
+      assert !is_floating?(instance)
+    end
+
+    it "has a working method #matrix" do
+      instance.matrix("bar").must_equal 42
+    end
+
+    it "has a working method #do_matrix" do
+      instance.do_matrix("bar").must_equal 42
+    end
+
+    it "has a working method #emit_sig_with_foreign_struct" do
+      skip unless get_method_introspection_data('Regress', 'TestObj',
+                                                'emit_sig_with_foreign_struct')
+      has_fired = false
+      instance.signal_connect "sig-with-foreign-struct" do |obj, cr|
+        has_fired = true
+        cr.must_be_instance_of Cairo::Context
+      end
+      instance.emit_sig_with_foreign_struct
+      assert has_fired
+    end
+
+    it "has a working method #emit_sig_with_int64" do
+      skip "This does not work yet"
+      instance.signal_connect "sig-with-int64-prop" do |obj, i, ud|
+        int
+      end
+      instance.emit_sig_with_int64
+    end
+
+    it "has a working method #emit_sig_with_obj" do
+      has_fired = false
+      instance.signal_connect "sig-with-obj" do |it, obj|
+        has_fired = true
+        obj.int.must_equal 3
+      end
+      instance.emit_sig_with_obj
+      assert has_fired
+    end
+
+    it "has a working method #emit_sig_with_uint64" do
+      skip "This does not work yet"
+      instance.signal_connect "sig-with-uint64-prop" do |obj, i, ud|
+        i
+      end
+      instance.emit_sig_with_uint64
+    end
+
+    it "has a working method #forced_method" do
+      instance.forced_method
+      pass
+    end
+
+    it "has a working method #instance_method" do
+      rv = instance.instance_method
+      assert_equal(-1, rv)
+    end
+
+    it "has a working method #instance_method_callback" do
+      a = 1
+      instance.instance_method_callback Proc.new { a = 2 }
+      assert_equal 2, a
+    end
+
+    it "has a working method #set_bare" do
+      obj = Regress::TestObj.new_from_file("bar")
+      instance.set_bare obj
+      instance.bare.must_equal obj
+    end
+
+    it "has a working method #skip_inout_param" do
+      a = 1
+      c = 2.0
+      num1 = 3
+      num2 = 4
+      result, out_b, sum = instance.skip_inout_param a, c, num1, num2
+      result.must_equal true
+      out_b.must_equal a + 1
+      sum.must_equal num1 + 10 * num2
+    end
+
+    it "has a working method #skip_out_param" do
+      a = 1
+      c = 2.0
+      d = 3
+      num1 = 4
+      num2 = 5
+      result, out_d, sum = instance.skip_out_param a, c, d, num1, num2
+      result.must_equal true
+      out_d.must_equal d + 1
+      sum.must_equal num1 + 10 * num2
+    end
+
+    it "has a working method #skip_param" do
+      a = 1
+      d = 3
+      num1 = 4
+      num2 = 5
+      result, out_b, out_d, sum = instance.skip_param a, d, num1, num2
+      result.must_equal true
+      out_b.must_equal a + 1
+      out_d.must_equal d + 1
+      sum.must_equal num1 + 10 * num2
+    end
+
+    it "has a working method #skip_return_val" do
+      a = 1
+      c = 2.0
+      d = 3
+      num1 = 4
+      num2 = 5
+      out_b, out_d, out_sum = instance.skip_return_val a, c, d, num1, num2
+      out_b.must_equal a + 1
+      out_d.must_equal d + 1
+      out_sum.must_equal num1 + 10 * num2
+    end
+
+    it "has a working method #skip_return_val_no_out" do
+      result = instance.skip_return_val_no_out 1
+      result.must_be_nil
+
+      lambda { instance.skip_return_val_no_out 0 }.must_raise RuntimeError
+    end
+
+    it "has a working method #torture_signature_0" do
+      y, z, q = instance.torture_signature_0(-21, "hello", 13)
+      assert_equal [-21, 2 * -21, "hello".length + 13],
+        [y, z, q]
+    end
+
+    it "has a working method #torture_signature_1" do
+      ret, y, z, q = instance.torture_signature_1(-21, "hello", 12)
+      assert_equal [true, -21, 2 * -21, "hello".length + 12],
+        [ret, y, z, q]
+      assert_raises RuntimeError do
+        instance.torture_signature_1(-21, "hello", 11)
+      end
+    end
+
+    describe "its 'bare' property" do
+      it "can be retrieved with #get_property" do
+        instance.get_property("bare").must_be_nil
+      end
+
+      it "can be retrieved with #bare" do
+        instance.bare.must_be_nil
+      end
+
+      it "can be set with #set_property" do
         obj = Regress::TestObj.new_from_file("bar")
-        instance.set_bare obj
+        instance.set_property "bare", obj
+        instance.get_property("bare").must_equal obj
+      end
 
-        obj2 = instance.get_property("bare")
+      it "can be set with #bare=" do
+        obj = Regress::TestObj.new_from_file("bar")
+        instance.bare = obj
+
+        instance.bare.must_equal obj
+        instance.get_property("bare").must_equal obj
+      end
+    end
 
-        assert_instance_of Regress::TestObj, obj2
-        obj2.must_equal obj
+    describe "its 'boxed' property" do
+      it "can be retrieved with #get_property" do
+        instance.get_property("boxed").must_be_nil
       end
 
-      it "gets the 'boxed' property" do
+      it "can be retrieved with #boxed" do
+        instance.boxed.must_be_nil
+      end
+
+      it "can be set with #set_property" do
         tb = Regress::TestBoxed.new_alternative_constructor1 75
         instance.set_property "boxed", tb
+        instance.get_property("boxed").some_int8.must_equal 75
+      end
 
-        tb2 = instance.get_property("boxed")
+      it "can be set with #boxed=" do
+        tb = Regress::TestBoxed.new_alternative_constructor1 75
+        instance.boxed = tb
+        instance.boxed.some_int8.must_equal tb.some_int8
+        instance.get_property("boxed").some_int8.must_equal tb.some_int8
+      end
+    end
 
-        assert_instance_of Regress::TestBoxed, tb2
-        assert_equal 75, tb2.some_int8
+    describe "its 'double' property" do
+      it "can be retrieved with #get_property" do
+        instance.get_property("double").must_equal 0.0
       end
 
-      it "gets the 'hash-table' property" do
-        ht = GLib::HashTable.new :utf8, :gint8
-        ht.insert "foo", 34
-        ht.insert "bar", 83
+      it "can be retrieved with #double" do
+        instance.double.must_equal 0.0
+      end
 
-        instance.set_property "hash-table", ht
+      it "can be set with #set_property" do
+        instance.set_property "double", 3.14
+        instance.get_property("double").must_equal 3.14
+      end
 
-        ht2 = instance.get_property "hash-table"
-        assert_equal({"foo" => 34, "bar" => 83}, ht2.to_hash)
+      it "can be set with #double=" do
+        instance.double = 3.14
+        instance.double.must_equal 3.14
+        instance.get_property("double").must_equal 3.14
       end
+    end
 
-      it "gets the 'float' property" do
-        instance.set_property "float", 3.14
-        assert_in_epsilon 3.14, instance.get_property("float")
+    describe "its 'float' property" do
+      it "can be retrieved with #get_property" do
+        instance.get_property("float").must_equal 0.0
       end
 
-      it "gets the 'double' property" do
-        instance.set_property "double", 3.14
-        assert_in_epsilon 3.14, instance.get_property("double")
+      it "can be retrieved with #float" do
+        instance.float.must_equal 0.0
       end
 
-      it "gets the 'int' property" do
-        instance.set_property "int", 42
-        assert_equal 42, instance.get_property("int")
+      it "can be set with #set_property" do
+        instance.set_property "float", 3.14
+        instance.get_property("float").must_be_close_to 3.14
       end
 
-      it "gets the 'list' property" do
-        lst = GLib::List.new(:utf8).append("foo").append("bar")
+      it "can be set with #float=" do
+        instance.float = 3.14
+        instance.float.must_be_close_to 3.14
+        instance.get_property("float").must_be_close_to 3.14
+      end
+    end
 
-        instance.set_property "list", lst
+    describe "its 'gtype' property" do
+      before do
+        skip unless get_property_introspection_data("Regress", "TestObj", "gtype")
+      end
 
-        lst2 = instance.get_property "list"
-        lst2.must_be :==, ["foo", "bar"]
+      it "can be retrieved with #get_property" do
+        instance.get_property("gtype").must_equal 0
       end
 
-      it "gets the 'string' property" do
-        instance.set_property "string", "foobar"
-        assert_equal "foobar", instance.get_property("string")
+      it "can be retrieved with #gtype" do
+        instance.gtype.must_equal 0
       end
-    end
 
-    describe "#set_property" do
-      it "sets the 'bare' property" do
-        obj = Regress::TestObj.new_from_file("bar")
-        instance.set_property "bare", obj
-        instance.bare.must_equal obj
+      it "can be set with #set_property" do
+        instance.set_property "gtype", GObject::TYPE_INT64
+        instance.get_property("gtype").must_equal GObject::TYPE_INT64
       end
 
-      it "sets the 'boxed' property" do
-        tb = Regress::TestBoxed.new_alternative_constructor1 75
-        instance.set_property "boxed", tb
-        tb2 = instance.boxed
-        assert_equal 75, tb2.some_int8
+      it "can be set with #gtype=" do
+        instance.gtype = GObject::TYPE_STRING
+        instance.gtype.must_equal GObject::TYPE_STRING
+        instance.get_property("gtype").must_equal GObject::TYPE_STRING
       end
+    end
 
-      it "sets the 'hash-table' property" do
-        instance.set_property("hash-table", {"foo" => 34, "bar" => 83})
+    describe "its 'hash-table' property" do
+      it "can be retrieved with #get_property" do
+        instance.get_property("hash-table").must_be_nil
+      end
 
-        ht = instance.hash_table
-        ht.key_type = :utf8
-        ht.value_type = :gint32
+      it "can be retrieved with #hash_table" do
+        instance.hash_table.must_be_nil
+      end
 
-        assert_equal({"foo" => 34, "bar" => 83}, ht.to_hash)
+      it "can be set with #set_property" do
+        instance.set_property "hash-table", {"foo" => 34, "bar" => 83}
+        instance.get_property("hash-table").to_hash.must_equal({"foo" => 34,
+                                                                "bar" => 83})
       end
 
-      it "sets the 'float' property" do
-        instance.set_property "float", 3.14
-        assert_in_epsilon 3.14, get_field_value(instance, :some_float)
+      it "can be set with #hash_table=" do
+        instance.set_property "hash-table", {"foo" => 34, "bar" => 83}
+        instance.hash_table.to_hash.must_equal({"foo" => 34, "bar" => 83})
+        instance.get_property("hash-table").to_hash.must_equal({"foo" => 34,
+                                                                "bar" => 83})
       end
+    end
 
-      it "sets the 'double' property" do
-        instance.set_property "double", 3.14
-        assert_in_epsilon 3.14, get_field_value(instance, :some_double)
+    describe "its 'hash-table-old' property" do
+      it "can be retrieved with #get_property" do
+        instance.get_property("hash-table-old").must_be_nil
       end
 
-      it "sets the 'int' property" do
-        instance.set_property "int", 42
-        assert_equal 42, get_field_value(instance, :some_int8)
+      it "can be retrieved with #hash_table_old" do
+        instance.hash_table_old.must_be_nil
       end
 
-      it "sets the 'list' property" do
-        instance.set_property "list", ["foo", "bar"]
-        instance.list.must_be :==, ["foo",  "bar"]
+      it "can be set with #set_property" do
+        instance.set_property "hash-table-old", {"foo" => 34,
+                                                 "bar" => 83}
+
+        instance.get_property("hash-table-old").to_hash.must_equal({"foo" => 34,
+                                                                    "bar" => 83})
       end
 
-      it "sets the 'string' property" do
-        instance.set_property "string", "foobar"
-        assert_equal "foobar", instance.string
+      it "can be set with #hash_table_old=" do
+        instance.set_property "hash-table-old", {"foo" => 34,
+                                                 "bar" => 83}
+
+        instance.hash_table_old.to_hash.must_equal({"foo" => 34, "bar" => 83})
+        instance.get_property("hash-table-old").to_hash.must_equal({"foo" => 34,
+                                                                    "bar" => 83})
       end
     end
 
     describe "its 'int' property" do
-      it "is set with #int=" do
+      it "can be retrieved with #get_property" do
+        assert_equal 0, instance.get_property("int")
+      end
+
+      it "can be retrieved with #int" do
+        assert_equal 0, instance.int
+      end
+
+      it "can be set with #set_property" do
+        instance.set_property "int", 42
+        assert_equal 42, instance.get_property("int")
+      end
+
+      it "can be set with #int=" do
         instance.int = 41
         assert_equal 41, instance.get_property("int")
+        assert_equal 41, instance.int
       end
+    end
 
-      it "is retrieved with #int" do
-        instance.set_property "int", 43
-        assert_equal 43, instance.int
+    describe "its 'list' property" do
+      it "can be retrieved with #get_property" do
+        instance.get_property("list").must_be_nil
       end
-    end
 
-    it "has a reference count of 1" do
-      assert_equal 1, ref_count(instance)
-    end
+      it "can be retrieved with #list" do
+        instance.list.must_be_nil
+      end
 
-    it "does not float" do
-      assert !is_floating?(instance)
-    end
+      it "can be set with #set_property" do
+        instance.set_property "list", ["foo", "bar"]
+        instance.get_property("list").must_be :==, ["foo", "bar"]
+      end
 
-    it "has a working method #matrix" do
-      instance.matrix("bar").must_equal 42
+      it "can be set with #list=" do
+        instance.list = ["foo", "bar"]
+        instance.list.must_be :==, ["foo",  "bar"]
+        instance.get_property("list").must_be :==, ["foo", "bar"]
+      end
     end
 
-    it "has a working method #do_matrix" do
-      instance.do_matrix("bar").must_equal 42
-    end
+    describe "its 'list-old' property" do
+      it "can be retrieved with #get_property" do
+        instance.get_property("list-old").must_be_nil
+      end
 
-    it "has a working method #emit_sig_with_foreign_struct" do
-      skip
-    end
+      it "can be retrieved with #list_old" do
+        instance.list_old.must_be_nil
+      end
 
-    it "has a working method #emit_sig_with_int64" do
-      skip "This does not work yet"
-      instance.signal_connect "sig-with-int64-prop" do |obj, int, ud|
-        int
+      it "can be set with #set_property" do
+        instance.set_property "list-old", ["foo", "bar"]
+        instance.get_property("list-old").must_be :==, ["foo", "bar"]
+      end
+
+      it "can be set with #list_old=" do
+        instance.list_old = ["foo", "bar"]
+        instance.list_old.must_be :==, ["foo",  "bar"]
+        instance.get_property("list-old").must_be :==, ["foo", "bar"]
       end
-      instance.emit_sig_with_int64
     end
 
-    it "has a working method #emit_sig_with_obj" do
-      skip
+    describe "its 'string' property" do
+      it "can be retrieved with #get_property" do
+        assert_nil instance.get_property("string")
+      end
+
+      it "can be retrieved with #string" do
+        assert_nil instance.string
+      end
+
+      it "can be set with #set_property" do
+        instance.set_property "string", "foobar"
+        assert_equal "foobar", instance.get_property("string")
+      end
+
+      it "can be set with #string=" do
+        instance.string = "foobar"
+        assert_equal "foobar", instance.string
+        assert_equal "foobar", instance.get_property("string")
+      end
     end
-    it "has a working method #emit_sig_with_uint64" do
-      skip
+
+    it "handles the 'all' signal" do
+      a = nil
+      GObject.signal_connect(instance, "all") { a = 4 }
+      GObject.signal_emit instance, "all"
+      a.must_equal 4
     end
-    it "has a working method #forced_method" do
-      skip
+
+    it "handles the 'cleanup' signal" do
+      a = nil
+      GObject.signal_connect(instance, "cleanup") { a = 4 }
+      GObject.signal_emit instance, "cleanup"
+      a.must_equal 4
     end
-    it "has a working method #instance_method" do
-      rv = instance.instance_method
-      assert_equal(-1, rv)
+
+    it "handles the 'first' signal" do
+      a = nil
+      GObject.signal_connect(instance, "first") { a = 4 }
+      GObject.signal_emit instance, "first"
+      a.must_equal 4
     end
 
-    it "has a working method #instance_method_callback" do
-      a = 1
-      instance.instance_method_callback Proc.new { a = 2 }
-      assert_equal 2, a
+    it "handles the 'sig-with-array-len-prop' signal" do
+      skip
     end
 
-    it "has a working method #set_bare" do
-      obj = Regress::TestObj.new_from_file("bar")
-      # XXX: Sometimes uses set_property, and it shouldn't?
-      instance.set_bare obj
-      instance.bare.must_equal obj
+    it "handles the 'sig-with-array-prop' signal" do
+      a = nil
+      GObject.signal_connect(instance, "sig-with-array-prop") {|_, arr, _| a = arr }
+      # TODO: Automatically convert arguments to signal_emit.
+      GObject.signal_emit instance, "sig-with-array-prop",
+        GLib::Array.from(:uint, [1, 2, 3])
+      a.to_a.must_equal [1, 2, 3]
     end
 
-    it "has a working method #skip_inout_param" do
+    it "handles the 'sig-with-foreign-struct' signal" do
       skip
     end
-    it "has a working method #skip_out_param" do
+    it "handles the 'sig-with-hash-prop' signal" do
       skip
     end
-    it "has a working method #skip_param" do
+    it "handles the 'sig-with-int64-prop' signal" do
       skip
     end
-    it "has a working method #skip_return_val" do
+    it "handles the 'sig-with-intarray-ret' signal" do
       skip
     end
-    it "has a working method #skip_return_val_no_out" do
+    it "handles the 'sig-with-obj' signal" do
       skip
     end
-    it "has a working method #torture_signature_0" do
-      y, z, q = instance.torture_signature_0(-21, "hello", 13)
-      assert_equal [-21, 2 * -21, "hello".length + 13],
-        [y, z, q]
-    end
-
-    it "has a working method #torture_signature_1" do
-      # TODO: Merge with below
+    it "handles the 'sig-with-strv' signal" do
       skip
     end
-
-    describe "its #torture_signature_1" do
-      it "works for m even" do
-        ret, y, z, q = instance.torture_signature_1(-21, "hello", 12)
-        assert_equal [true, -21, 2 * -21, "hello".length + 12],
-          [ret, y, z, q]
-      end
-
-      it "throws an exception for m odd" do
-        assert_raises RuntimeError do
-          instance.torture_signature_1(-21, "hello", 11)
-        end
-      end
+    it "handles the 'sig-with-uint64-prop' signal" do
+      skip
     end
 
-    it "does not respond to #static_method" do
-      assert_raises(NoMethodError) { instance.static_method 1 }
+    it "handles the 'test' signal" do
+      a = b = nil
+      o = Regress::TestSubObj.new
+      GObject.signal_connect(o, "test", 2) { |i, d| a = d; b = i }
+      GObject.signal_emit o, "test"
+      assert_equal [2, o], [a, b]
     end
-    # TODO: Test instance's fields and properies.
-
-    describe "its 'test' signal" do
-      it "properly passes its arguments" do
-        a = b = nil
-        o = Regress::TestSubObj.new
-        GObject.signal_connect(o, "test", 2) { |i, d| a = d; b = i }
-        GObject.signal_emit o, "test"
-        assert_equal [2, o], [a, b]
-      end
+    it "handles the 'test-with-static-scope-arg' signal" do
+      skip
     end
-
-    # TODO: Test other signals.
   end
 
   describe "Regress::TestOtherError" do
@@ -773,12 +1051,9 @@ describe Regress do
       instance.this_is_public_before.must_equal 42
     end
 
-    it "cannot read from field this_is_private" do
+    it "has a private field this_is_private" do
       skip "GIR identifies this field as readable"
       proc { instance.this_is_private }.must_raise NoMethodError
-    end
-
-    it "cannot write to field this_is_private" do
       proc { instance.this_is_private = 42 }.must_raise NoMethodError
     end
 
@@ -819,80 +1094,89 @@ describe Regress do
       assert_instance_of Regress::TestSimpleBoxedA, obj
     end
 
+    let(:instance) { Regress::TestSimpleBoxedA.new }
+
     it "has a working method #copy" do
-      skip
+      instance.some_int = 4236
+
+      obj2 = instance.copy
+      obj2.must_be_instance_of Regress::TestSimpleBoxedA
+      obj2.some_int.must_equal instance.some_int
+
+      instance.some_int = 89
+      obj2.some_int.wont_equal instance.some_int
     end
+
     it "has a working method #equals" do
-      skip
+      instance.some_int = 4236
+
+      ob2 = Regress::TestSimpleBoxedA.new
+      ob2.some_int = 4236
+      ob2.equals(instance).must_equal true
+      ob2.some_enum = :value3
+      ob2.equals(instance).must_equal true
+      ob2.some_int = 42
+      ob2.equals(instance).wont_equal true
     end
+
     it "has a working function #const_return" do
-      skip
+      result = Regress::TestSimpleBoxedA.const_return
+      [result.some_int, result.some_int8, result.some_double].must_equal [5, 6, 7.0]
     end
+  end
 
-    describe "an instance" do
-      setup do
-        @obj = Regress::TestSimpleBoxedA.new
-        @obj.some_int = 4236
-        @obj.some_int8 = 36
-        @obj.some_double = 23.53
-        @obj.some_enum = :value2
-      end
-
-      describe "its equals method" do
-        setup do
-          @ob2 = Regress::TestSimpleBoxedA.new
-          @ob2.some_int = 4236
-          @ob2.some_int8 = 36
-          @ob2.some_double = 23.53
-          @ob2.some_enum = :value2
-        end
-
-        it "returns true if values are the same" do
-          assert_equal true, @obj.equals(@ob2)
-        end
-
-        it "returns true if enum values differ" do
-          @ob2.some_enum = :value3
-          assert_equal true, @obj.equals(@ob2)
-        end
-
-        it "returns false if other values differ" do
-          @ob2.some_int = 1
-          assert_equal false, @obj.equals(@ob2)
-        end
-      end
+  describe "Regress::TestSimpleBoxedB" do
+    let(:instance) { Regress::TestSimpleBoxedB.new }
+    it "has a writable field some_int8" do
+      instance.some_int8.must_equal 0
+      instance.some_int8 = 42
+      instance.some_int8.must_equal 42
+    end
 
-      describe "its copy method" do
-        setup do
-          @ob2 = @obj.copy
-        end
-
-        it "returns an instance of TestSimpleBoxedA" do
-          assert_instance_of Regress::TestSimpleBoxedA, @ob2
-        end
-
-        it "copies fields" do
-          assert_equal 4236, @ob2.some_int
-          assert_equal 36, @ob2.some_int8
-          assert_equal 23.53, @ob2.some_double
-          assert_equal :value2, @ob2.some_enum
-        end
-
-        it "creates a true copy" do
-          @obj.some_int8 = 89
-          assert_equal 36, @ob2.some_int8
-        end
-      end
+    it "has a writable field nested_a" do
+      instance.nested_a.some_int.must_equal 0
+      instance.nested_a = Regress::TestSimpleBoxedA.const_return
+      instance.nested_a.some_int.must_equal 5
     end
-  end
 
-  describe "Regress::TestSimpleBoxedB" do
     it "has a working method #copy" do
-      skip
+      instance.some_int8 = -42
+      instance.nested_a.some_int = 4242
+
+      copy = instance.copy
+      [copy.some_int8, copy.nested_a.some_int].must_equal [-42, 4242]
+
+      instance.some_int8 = 103
+      copy.some_int8.must_equal(-42)
     end
   end
 
   describe "Regress::TestStructA" do
+    let(:instance) { Regress::TestStructA.new }
+    it "has a writable field some_int" do
+      instance.some_int.must_equal 0
+      instance.some_int = 2556
+      instance.some_int.must_equal 2556
+    end
+
+    it "has a writable field some_int8" do
+      instance.some_int8.must_equal 0
+      instance.some_int8 = -10
+      instance.some_int8.must_equal(-10)
+    end
+
+    it "has a writable field some_double" do
+      instance.some_double.must_equal 0.0
+      instance.some_double = 1.03455e20
+      instance.some_double.must_equal 1.03455e20
+    end
+
+    it "has a writable field some_enum" do
+      instance.some_enum.must_equal :value1
+      instance.some_enum = :value2
+      instance.some_enum.must_equal :value2
+    end
+
     it "has a working method #clone" do
       a = Regress::TestStructA.new
       a.some_int = 2556
@@ -909,11 +1193,30 @@ describe Regress do
     end
 
     it "has a working function #parse" do
-      skip
+      skip unless get_method_introspection_data 'Regress', 'TestStructA', 'parse'
+      a = Regress::TestStructA.parse("this string is actually ignored")
+      a.some_int.must_equal 23
     end
   end
 
   describe "Regress::TestStructB" do
+    let(:instance) { Regress::TestStructB.new }
+    it "has a writable field some_int8" do
+      instance.some_int8.must_equal 0
+      instance.some_int8 = 42
+      instance.some_int8.must_equal 42
+    end
+
+    it "has a writable field nested_a" do
+      instance.nested_a.some_int.must_equal 0
+
+      nested = Regress::TestStructA.new
+      nested.some_int = -4321
+
+      instance.nested_a = nested
+      instance.nested_a.some_int.must_equal(-4321)
+    end
+
     it "has a working method #clone" do
       a = Regress::TestStructB.new
       a.some_int8 = 42
@@ -973,23 +1276,137 @@ describe Regress do
   end
 
   describe "Regress::TestStructE" do
-    it "must be tested" do
-      skip
+    let(:instance) { Regress::TestStructE.new }
+    it "has a writable field some_type" do
+      instance.some_type.must_equal 0
+      instance.some_type = GObject::TYPE_STRING
+      instance.some_type.must_equal GObject::TYPE_STRING
+    end
+
+    it "has a writable field some_union" do
+      instance.some_union.map(&:v_int).must_equal [0, 0]
+
+      union1 = Regress::TestStructE__some_union__union.new
+      union1.v_int = 42
+      union2 = Regress::TestStructE__some_union__union.new
+      union2.v_int = 84
+
+      instance.some_union = [union1, union2]
+
+      instance.some_union.map(&:v_int).must_equal [42, 84]
     end
   end
   describe "Regress::TestStructE__some_union__union" do
-    it "must be tested" do
-      skip
+    let(:instance) { Regress::TestStructE__some_union__union.new }
+    it "has a writable field v_int" do
+      instance.v_int.must_equal 0
+      instance.v_int = -54321
+      instance.v_int.must_equal(-54321)
+    end
+
+    it "has a writable field v_uint" do
+      instance.v_uint.must_equal 0
+      instance.v_uint = 54321
+      instance.v_uint.must_equal 54321
+    end
+
+    it "has a writable field v_long" do
+      instance.v_long.must_equal 0
+      instance.v_long = -54321
+      instance.v_long.must_equal(-54321)
+    end
+
+    it "has a writable field v_ulong" do
+      instance.v_long.must_equal 0
+      instance.v_long = 54321
+      instance.v_long.must_equal 54321
+    end
+
+    it "has a writable field v_int64" do
+      instance.v_int64.must_equal 0
+      instance.v_int64 = -54_321_000_000_000
+      instance.v_int64.must_equal(-54_321_000_000_000)
+    end
+    it "has a writable field v_uint64" do
+      instance.v_uint64.must_equal 0
+      instance.v_uint64 = 54_321_000_000_000
+      instance.v_uint64.must_equal 54_321_000_000_000
+    end
+    it "has a writable field v_float" do
+      instance.v_float.must_equal 0
+      instance.v_float = 3.1415
+      instance.v_float.must_be_close_to 3.1415
+    end
+    it "has a writable field v_double" do
+      instance.v_double.must_equal 0
+      instance.v_double = 3.1415
+      instance.v_double.must_equal 3.1415
+    end
+    it "has a writable field v_pointer" do
+      instance.v_pointer.must_be :null?
+      instance.v_pointer = FFI::Pointer.new 54321
+      instance.v_pointer.address.must_equal 54321
     end
   end
   describe "Regress::TestStructF" do
-    it "must be tested" do
-      skip
+    before do
+      skip unless get_introspection_data 'Regress', 'TestStructF'
+    end
+
+    let(:instance) { Regress::TestStructF.new }
+
+    it "has a writable field ref_count" do
+      instance.ref_count.must_equal 0
+      instance.ref_count = 1
+      instance.ref_count.must_equal 1
+    end
+
+    it "has a writable field data1" do
+      instance.data1.must_be :null?
+      instance.data1 = GirFFI::InOutPointer.from(:gint32, 42)
+      instance.data1.read_int32.must_equal 42
+    end
+
+    it "has a writable field data2" do
+      skip "Introspection data cannot deal with type of this field yet"
+    end
+
+    it "has a writable field data3" do
+      skip "Introspection data cannot deal with type of this field yet"
+    end
+
+    it "has a writable field data4" do
+      skip "Introspection data cannot deal with type of this field yet"
+    end
+
+    it "has a writable field data5" do
+      skip "Introspection data cannot deal with type of this field yet"
+    end
+
+    it "has a writable field data6" do
+      skip "Introspection data cannot deal with type of this field yet"
     end
   end
+
   describe "Regress::TestStructFixedArray" do
+    let(:instance) { Regress::TestStructFixedArray.new }
+    it "has a writable field just_int" do
+      instance.just_int.must_equal 0
+      instance.just_int = 42
+      instance.just_int.must_equal 42
+    end
+
+    it "has a writable field array" do
+      instance.array.must_be :==, [0] * 10
+      instance.array = (1..10).to_a
+      instance.array.must_be :==, (1..10).to_a
+    end
+
     it "has a working method #frob" do
-      skip
+      instance.array = (0..9).to_a
+      instance.frob
+      instance.array.must_be :==, (42..42+9).to_a
+      instance.just_int.must_equal 7
     end
   end
 
@@ -1029,42 +1446,45 @@ describe Regress do
     let(:instance) { Regress::TestWi8021x.new }
 
     it "has a working method #get_testbool" do
-      instance.set_testbool false
-      assert_equal false, instance.get_testbool
-      instance.set_testbool true
-      assert_equal true, instance.get_testbool
+      instance.get_testbool.must_equal true
     end
 
     it "has a working method #set_testbool" do
       instance.set_testbool true
-      assert_equal true, get_field_value(instance, :testbool)
+      instance.get_testbool.must_equal true
       instance.set_testbool false
-      assert_equal false, get_field_value(instance, :testbool)
+      instance.get_testbool.must_equal false
     end
 
-    describe "an instance" do
-      setup do
-        @obj = instance
+    describe "its 'testbool' property" do
+      it "can be retrieved with #get_property" do
+        instance.get_property("testbool").must_equal true
       end
 
-      it "gets its boolean field with #get_property" do
-        @obj.set_testbool true
-        val = @obj.get_property "testbool"
-        assert_equal true, val
+      it "can be retrieved with #testbool" do
+        instance.testbool.must_equal true
       end
 
-      it "gets its boolean field with #testbool" do
-        @obj.set_testbool true
-        assert_equal true, @obj.testbool
-        @obj.set_testbool false
-        assert_equal false, @obj.testbool
+      it "can be set with #set_property" do
+        instance.set_property "testbool", true
+        instance.get_testbool.must_equal true
+        instance.get_property("testbool").must_equal true
+
+        instance.set_property "testbool", false
+        instance.get_testbool.must_equal false
+        instance.get_property("testbool").must_equal false
       end
 
-      it "sets its boolean field with #testbool=" do
-        @obj.testbool = true
-        assert_equal true, @obj.testbool
-        @obj.testbool = false
-        assert_equal false, @obj.testbool
+      it "can be set with #testbool=" do
+        instance.testbool = true
+        instance.testbool.must_equal true
+        instance.get_testbool.must_equal true
+        instance.get_property("testbool").must_equal true
+
+        instance.testbool = false
+        instance.testbool.must_equal false
+        instance.get_testbool.must_equal false
+        instance.get_property("testbool").must_equal false
       end
     end
   end
@@ -1074,14 +1494,22 @@ describe Regress do
   end
 
   it "has a working function #aliased_caller_alloc" do
-    skip
+    result = Regress.aliased_caller_alloc
+    result.must_be_instance_of Regress::TestBoxed
   end
+
   it "has a working function #atest_error_quark" do
-    skip
+    skip unless get_introspection_data 'Regress', 'atest_error_quark'
+    result = Regress.atest_error_quark
+    GLib.quark_to_string(result).must_equal "regress-atest-error"
   end
+
   it "has a working function #func_obj_null_in" do
-    skip
+    Regress.func_obj_null_in nil
+    Regress.func_obj_null_in Regress::TestObj.constructor
+    pass
   end
+
   it "has a working function #global_get_flags_out" do
     skip
   end
@@ -1095,6 +1523,7 @@ describe Regress do
   it "has a working function #set_abort_on_error" do
     Regress.set_abort_on_error false
     Regress.set_abort_on_error true
+    pass
   end
 
   it "has a working function #test_abc_error_quark" do
@@ -1175,7 +1604,8 @@ describe Regress do
   end
 
   it "has a working function #test_array_int_null_in" do
-    assert_nothing_raised { Regress.test_array_int_null_in nil }
+    Regress.test_array_int_null_in nil
+    pass
   end
 
   it "has a working function #test_array_int_null_out" do
@@ -1345,7 +1775,6 @@ describe Regress do
     skip
   end
 
-  # TODO: Find a way to test encoding issues.
   it "has a working function #test_filename_return" do
     arr = Regress.test_filename_return
     arr.must_be :==, ["åäö", "/etc/fstab"]
@@ -1383,8 +1812,9 @@ describe Regress do
 
   it "has a working function #test_ghash_everything_return" do
     ghash = Regress.test_ghash_everything_return
-    ghash.to_hash.must_be :==, {"foo" => "bar", "baz" => "bat",
-        "qux" => "quux"}
+    ghash.to_hash.must_be :==, {"foo" => "bar",
+                                "baz" => "bat",
+                                "qux" => "quux"}
   end
 
   it "has a working function #test_ghash_gvalue_in" do
@@ -1401,25 +1831,29 @@ describe Regress do
   end
 
   it "has a working function #test_ghash_nothing_in" do
-    Regress.test_ghash_nothing_in({"foo" => "bar", "baz" => "bat",
-        "qux" => "quux"})
+    Regress.test_ghash_nothing_in({"foo" => "bar",
+                                   "baz" => "bat",
+                                   "qux" => "quux"})
   end
 
   it "has a working function #test_ghash_nothing_in2" do
-    Regress.test_ghash_nothing_in2({"foo" => "bar", "baz" => "bat",
-        "qux" => "quux"})
+    Regress.test_ghash_nothing_in2({"foo" => "bar",
+                                    "baz" => "bat",
+                                    "qux" => "quux"})
   end
 
   it "has a working function #test_ghash_nothing_return" do
     ghash = Regress.test_ghash_nothing_return
-    ghash.to_hash.must_be :==, {"foo" => "bar", "baz" => "bat",
-        "qux" => "quux"}
+    ghash.to_hash.must_be :==, {"foo" => "bar",
+                                "baz" => "bat",
+                                "qux" => "quux"}
   end
 
   it "has a working function #test_ghash_nothing_return2" do
     ghash = Regress.test_ghash_nothing_return2
-    ghash.to_hash.must_be :==, {"foo" => "bar", "baz" => "bat",
-        "qux" => "quux"}
+    ghash.to_hash.must_be :==, {"foo" => "bar",
+                                "baz" => "bat",
+                                "qux" => "quux"}
   end
 
   it "has a working function #test_ghash_null_in" do
@@ -1448,15 +1882,13 @@ describe Regress do
   end
 
   it "has a working function #test_glist_nothing_in" do
-    assert_nothing_raised {
-      Regress.test_glist_nothing_in ["1", "2", "3"]
-    }
+    Regress.test_glist_nothing_in ["1", "2", "3"]
+    pass
   end
 
   it "has a working function #test_glist_nothing_in2" do
-    assert_nothing_raised {
-      Regress.test_glist_nothing_in2 ["1", "2", "3"]
-    }
+    Regress.test_glist_nothing_in2 ["1", "2", "3"]
+    pass
   end
 
   it "has a working function #test_glist_nothing_return" do
@@ -1470,9 +1902,8 @@ describe Regress do
   end
 
   it "has a working function #test_glist_null_in" do
-    assert_nothing_raised {
-      Regress.test_glist_null_in nil
-    }
+    Regress.test_glist_null_in nil
+    pass
   end
 
   it "has a working function #test_glist_null_out" do
@@ -1492,15 +1923,13 @@ describe Regress do
   end
 
   it "has a working function #test_gslist_nothing_in" do
-    assert_nothing_raised {
-      Regress.test_gslist_nothing_in ["1", "2", "3"]
-    }
+    Regress.test_gslist_nothing_in ["1", "2", "3"]
+    pass
   end
 
   it "has a working function #test_gslist_nothing_in2" do
-    assert_nothing_raised {
-      Regress.test_gslist_nothing_in2 ["1", "2", "3"]
-    }
+    Regress.test_gslist_nothing_in2 ["1", "2", "3"]
+    pass
   end
 
   it "has a working function #test_gslist_nothing_return" do
@@ -1514,9 +1943,8 @@ describe Regress do
   end
 
   it "has a working function #test_gslist_null_in" do
-    assert_nothing_raised {
-      Regress.test_gslist_null_in nil
-    }
+    Regress.test_gslist_null_in nil
+    pass
   end
 
   it "has a working function #test_gslist_null_out" do
@@ -1530,22 +1958,32 @@ describe Regress do
   end
 
   it "has a working function #test_gvariant_as" do
-    skip
+    Regress.test_gvariant_as.get_strv.to_a.must_equal ["one", "two", "three"]
   end
+
   it "has a working function #test_gvariant_asv" do
-    skip
+    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
   end
+
   it "has a working function #test_gvariant_i" do
-    skip
+    Regress.test_gvariant_i.get_int32.must_equal 1
   end
+
   it "has a working function #test_gvariant_s" do
-    skip
+    Regress.test_gvariant_s.get_string.must_equal "one"
   end
+
   it "has a working function #test_gvariant_v" do
-    skip
+    Regress.test_gvariant_v.get_variant.get_string.must_equal "contents"
   end
+
   it "has a working function #test_hash_table_callback" do
-    skip
+    value = nil
+    Regress.test_hash_table_callback({"foo" => 42}, Proc.new {|hash| value = hash})
+    value.to_hash.must_equal({"foo" => 42})
   end
 
   it "has a working function #test_int" do
@@ -1609,16 +2047,23 @@ describe Regress do
   end
 
   it "has a working function #test_multiline_doc_comments" do
-    skip
+    Regress.test_multiline_doc_comments.must_be_nil
   end
+
   it "has a working function #test_nested_parameter" do
-    skip
+    Regress.test_nested_parameter(3).must_be_nil
   end
+
   it "has a working function #test_null_gerror_callback" do
-    skip
+    value = nil
+    Regress.test_owned_gerror_callback Proc.new {|err| value = err }
+    value.message.must_equal "regression test owned error"
   end
+
   it "has a working function #test_owned_gerror_callback" do
-    skip
+    value = nil
+    Regress.test_owned_gerror_callback Proc.new {|err| value = err }
+    value.message.must_equal "regression test owned error"
   end
 
   it "has a working function #test_short" do
@@ -1646,7 +2091,10 @@ describe Regress do
   end
 
   it "has a working function #test_struct_a_parse" do
-    skip
+    skip unless get_introspection_data 'Regress', 'test_struct_a_parse'
+    a = Regress.test_struct_a_parse("this string is actually ignored")
+    a.must_be_instance_of Regress::TestStructA
+    a.some_int.must_equal 23
   end
 
   it "has a working function #test_strv_in" do
@@ -1753,9 +2201,8 @@ describe Regress do
   end
 
   it "has a working function #test_utf8_const_in" do
-    assert_nothing_raised do
-      Regress.test_utf8_const_in("const \xe2\x99\xa5 utf8")
-    end
+    Regress.test_utf8_const_in("const \xe2\x99\xa5 utf8")
+    pass
   end
 
   it "has a working function #test_utf8_const_return" do
@@ -1774,9 +2221,8 @@ describe Regress do
   end
 
   it "has a working function #test_utf8_null_in" do
-    assert_nothing_raised do
-      Regress.test_utf8_null_in nil
-    end
+    Regress.test_utf8_null_in nil
+    pass
   end
 
   it "has a working function #test_utf8_null_out" do