gir_ffi 0.6.7 → 0.7.0

data/test/integration/generated_gobject_test.rb

@@ -1,10 +1,6 @@
 require 'gir_ffi_test_helper'
 
-describe "The generated GObject module" do
-  before do
-    GirFFI.setup :GObject
-  end
-
+describe GObject do
   describe "#type_interfaces" do
     it "works, showing that returning an array of GType works" do
       klass = GObject::TypeModule
@@ -13,7 +9,24 @@ describe "The generated GObject module" do
     end
   end
 
-  describe "the TypePlugin interface" do
+  describe GObject::TypeInfo do
+    let(:instance) { GObject::TypeInfo.new }
+    it "has a working field setter for class_init" do
+      instance.class_init = proc do |object_class, data|
+      end
+    end
+
+    it "has a working field getter for class_init" do
+      instance.class_init.must_be_nil
+      instance.class_init = proc do |object_class, data|
+      end
+      result = instance.class_init
+      result.wont_be_nil
+      result.must_be_instance_of FFI::Function
+    end
+  end
+
+  describe GObject::TypePlugin do
     it "is implemented as a module" do
       mod = GObject::TypePlugin
       assert_instance_of Module, mod
@@ -21,14 +34,14 @@ describe "The generated GObject module" do
     end
   end
 
-  describe "the TypeModule class" do
+  describe GObject::TypeModule do
     it "has the GObject::TypePlugin module as an ancestor" do
       klass = GObject::TypeModule
       assert_includes klass.ancestors, GObject::TypePlugin
     end
   end
 
-  describe "the ValueArray struct class" do
+  describe GObject::ValueArray do
     it "uses the constructor provided by GObject" do
       instance = GObject::ValueArray.new 16
       instance.n_prealloced.must_equal 16

data/test/integration/generated_pango_test.rb

@@ -10,11 +10,11 @@ describe Pango do
       lang = Pango::Language.from_string 'ja'
       result = lang.get_scripts
 
-      if GLib::SizedArray === result
+      if GirFFI::SizedArray === result
         scripts = result
       else
         ptr, size = *result
-        scripts = GLib::SizedArray.new Pango::Script, size, ptr
+        scripts = GirFFI::SizedArray.new Pango::Script, size, ptr
       end
 
       scripts.must_be :==, [:han, :katakana, :hiragana]

data/test/integration/generated_regress_test.rb

@@ -3,17 +3,12 @@ require 'gir_ffi_test_helper'
 
 GirFFI.setup :Regress
 
-def get_field_value obj, field
-  struct = obj.instance_variable_get :@struct
-  struct[field]
-end
-
 # Tests generated methods and functions in the Regress namespace.
 describe Regress do
   describe Regress::Lib do
-    it "extends GirFFI::Library" do
+    it "extends FFI::Library" do
       class << Regress::Lib
-        self.must_be :include?, GirFFI::Library
+        self.must_be :include?, FFI::Library
       end
     end
   end
@@ -90,8 +85,7 @@ describe Regress do
     end
 
     it "has a writable field attributes" do
-      skip "This does not work yet"
-      instance.attributes
+      skip "Introspection data cannot deal with type of this field yet"
     end
 
     it "has a writable field dummy2" do
@@ -101,6 +95,27 @@ describe Regress do
     end
   end
 
+  describe "Regress::LikeXklConfigItem" do
+    before do
+      skip unless get_introspection_data 'Regress', 'LikeXklConfigItem'
+    end
+
+    let(:instance) { Regress::LikeXklConfigItem.new }
+    let(:name_array) { "foo".bytes.to_a + [0] * 29 }
+
+    it "has a writable field name" do
+      # TODO: Should an array of gint8 be more string-like?
+      instance.name.to_a.must_equal [0] * 32
+      instance.name = name_array
+      instance.name.to_a.must_equal name_array
+    end
+
+    it "has a working method #set_name" do
+      instance.set_name "foo"
+      instance.name.to_a.must_equal name_array
+    end
+  end
+
   it "has the constant MAXUINT64" do
     skip unless get_introspection_data 'Regress', 'MAXUINT64'
     Regress::MAXUINT64.must_equal 0xffff_ffff_ffff_ffff
@@ -431,7 +446,7 @@ describe Regress do
         GObject::Object
     end
 
-    it "cannot be instanciated" do
+    it "cannot be instantiated" do
       proc { Regress::TestFundamentalObject.new }.must_raise NoMethodError
     end
 
@@ -575,9 +590,9 @@ describe Regress do
     end
 
     it "has a working method #emit_sig_with_int64" do
-      skip "This does not work yet"
+      skip "FFI doesn't seem to convert the returned :int64 properly yet"
       instance.signal_connect "sig-with-int64-prop" do |obj, i, ud|
-        int
+        i
       end
       instance.emit_sig_with_int64
     end
@@ -593,7 +608,7 @@ describe Regress do
     end
 
     it "has a working method #emit_sig_with_uint64" do
-      skip "This does not work yet"
+      skip "FFI doesn't seem to convert the returned :int64 properly yet"
       instance.signal_connect "sig-with-uint64-prop" do |obj, i, ud|
         i
       end
@@ -693,7 +708,7 @@ describe Regress do
 
     describe "its 'bare' property" do
       it "can be retrieved with #get_property" do
-        instance.get_property("bare").must_be_nil
+        instance.get_property("bare").get_value.must_be_nil
       end
 
       it "can be retrieved with #bare" do
@@ -703,7 +718,7 @@ describe Regress do
       it "can be set with #set_property" do
         obj = Regress::TestObj.new_from_file("bar")
         instance.set_property "bare", obj
-        instance.get_property("bare").must_equal obj
+        instance.get_property("bare").get_value.must_equal obj
       end
 
       it "can be set with #bare=" do
@@ -711,13 +726,13 @@ describe Regress do
         instance.bare = obj
 
         instance.bare.must_equal obj
-        instance.get_property("bare").must_equal obj
+        instance.get_property("bare").get_value.must_equal obj
       end
     end
 
     describe "its 'boxed' property" do
       it "can be retrieved with #get_property" do
-        instance.get_property("boxed").must_be_nil
+        instance.get_property("boxed").get_value.must_be_nil
       end
 
       it "can be retrieved with #boxed" do
@@ -727,20 +742,20 @@ describe Regress do
       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
+        instance.get_property("boxed").get_value.some_int8.must_equal 75
       end
 
       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
+        instance.get_property("boxed").get_value.some_int8.must_equal tb.some_int8
       end
     end
 
     describe "its 'double' property" do
       it "can be retrieved with #get_property" do
-        instance.get_property("double").must_equal 0.0
+        instance.get_property("double").get_value.must_equal 0.0
       end
 
       it "can be retrieved with #double" do
@@ -749,19 +764,19 @@ describe Regress do
 
       it "can be set with #set_property" do
         instance.set_property "double", 3.14
-        instance.get_property("double").must_equal 3.14
+        instance.get_property("double").get_value.must_equal 3.14
       end
 
       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
+        instance.get_property("double").get_value.must_equal 3.14
       end
     end
 
     describe "its 'float' property" do
       it "can be retrieved with #get_property" do
-        instance.get_property("float").must_equal 0.0
+        instance.get_property("float").get_value.must_equal 0.0
       end
 
       it "can be retrieved with #float" do
@@ -770,13 +785,13 @@ describe Regress do
 
       it "can be set with #set_property" do
         instance.set_property "float", 3.14
-        instance.get_property("float").must_be_close_to 3.14
+        instance.get_property("float").get_value.must_be_close_to 3.14
       end
 
       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
+        instance.get_property("float").get_value.must_be_close_to 3.14
       end
     end
 
@@ -786,7 +801,7 @@ describe Regress do
       end
 
       it "can be retrieved with #get_property" do
-        instance.get_property("gtype").must_equal 0
+        instance.get_property("gtype").get_value.must_equal 0
       end
 
       it "can be retrieved with #gtype" do
@@ -795,69 +810,63 @@ describe Regress do
 
       it "can be set with #set_property" do
         instance.set_property "gtype", GObject::TYPE_INT64
-        instance.get_property("gtype").must_equal GObject::TYPE_INT64
+        instance.get_property("gtype").get_value.must_equal GObject::TYPE_INT64
       end
 
       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
+        instance.get_property("gtype").get_value.must_equal GObject::TYPE_STRING
       end
     end
 
     describe "its 'hash-table' property" do
       it "can be retrieved with #get_property" do
-        instance.get_property("hash-table").must_be_nil
+        instance.get_property("hash-table").get_value.must_be_nil
       end
 
       it "can be retrieved with #hash_table" do
         instance.hash_table.must_be_nil
       end
 
-      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})
+      it "can be set with #set_property_extended" do
+        instance.set_property_extended "hash-table", {"foo" => -4, "bar" => 83}
+        instance.hash_table.to_hash.must_equal({"foo" => -4, "bar" => 83})
       end
 
       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})
+        instance.hash_table = {"foo" => -4, "bar" => 83}
+        instance.hash_table.to_hash.must_equal({"foo" => -4, "bar" => 83})
+        instance.get_property_extended("hash-table").to_hash.must_equal({"foo" => -4,
+                                                                         "bar" => 83})
       end
     end
 
     describe "its 'hash-table-old' property" do
       it "can be retrieved with #get_property" do
-        instance.get_property("hash-table-old").must_be_nil
+        instance.get_property("hash-table-old").get_value.must_be_nil
       end
 
       it "can be retrieved with #hash_table_old" do
         instance.hash_table_old.must_be_nil
       end
 
-      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})
+      it "can be set with #set_property_extended" do
+        instance.set_property_extended "hash-table-old", {"foo" => 34, "bar" => -3}
+        instance.hash_table_old.to_hash.must_equal({"foo" => 34, "bar" => -3})
       end
 
       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})
+        instance.hash_table_old = {"foo" => 34, "bar" => -3}
+        instance.hash_table_old.to_hash.must_equal({"foo" => 34, "bar" => -3})
+        instance.get_property_extended("hash-table-old").to_hash.must_equal({"foo" => 34,
+                                                                             "bar" => -3})
       end
     end
 
     describe "its 'int' property" do
       it "can be retrieved with #get_property" do
-        assert_equal 0, instance.get_property("int")
+        assert_equal 0, instance.get_property("int").get_value
       end
 
       it "can be retrieved with #int" do
@@ -866,61 +875,61 @@ describe Regress do
 
       it "can be set with #set_property" do
         instance.set_property "int", 42
-        assert_equal 42, instance.get_property("int")
+        assert_equal 42, instance.get_property("int").get_value
       end
 
       it "can be set with #int=" do
         instance.int = 41
-        assert_equal 41, instance.get_property("int")
+        assert_equal 41, instance.get_property("int").get_value
         assert_equal 41, instance.int
       end
     end
 
     describe "its 'list' property" do
-      it "can be retrieved with #get_property" do
-        instance.get_property("list").must_be_nil
+      it "can be retrieved with #get_property_extended" do
+        instance.get_property_extended("list").must_be_nil
       end
 
       it "can be retrieved with #list" do
         instance.list.must_be_nil
       end
 
-      it "can be set with #set_property" do
-        instance.set_property "list", ["foo", "bar"]
-        instance.get_property("list").must_be :==, ["foo", "bar"]
+      it "can be set with #set_property_extended" do
+        instance.set_property_extended "list", ["foo", "bar"]
+        instance.list.to_a.must_equal ["foo", "bar"]
       end
 
       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"]
+        instance.list.to_a.must_equal ["foo", "bar"]
+        instance.get_property_extended("list").must_be :==, ["foo", "bar"]
       end
     end
 
     describe "its 'list-old' property" do
       it "can be retrieved with #get_property" do
-        instance.get_property("list-old").must_be_nil
+        instance.get_property_extended("list-old").must_be_nil
       end
 
       it "can be retrieved with #list_old" do
         instance.list_old.must_be_nil
       end
 
-      it "can be set with #set_property" do
-        instance.set_property "list-old", ["foo", "bar"]
-        instance.get_property("list-old").must_be :==, ["foo", "bar"]
+      it "can be set with #set_property_extended" do
+        instance.set_property_extended "list-old", ["foo", "bar"]
+        instance.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"]
+        instance.get_property_extended("list-old").must_be :==, ["foo", "bar"]
       end
     end
 
     describe "its 'string' property" do
       it "can be retrieved with #get_property" do
-        assert_nil instance.get_property("string")
+        assert_nil instance.get_property("string").get_value
       end
 
       it "can be retrieved with #string" do
@@ -929,13 +938,13 @@ describe Regress do
 
       it "can be set with #set_property" do
         instance.set_property "string", "foobar"
-        assert_equal "foobar", instance.get_property("string")
+        assert_equal "foobar", instance.get_property("string").get_value
       end
 
       it "can be set with #string=" do
         instance.string = "foobar"
         assert_equal "foobar", instance.string
-        assert_equal "foobar", instance.get_property("string")
+        assert_equal "foobar", instance.get_property("string").get_value
       end
     end
 
@@ -961,38 +970,130 @@ describe Regress do
     end
 
     it "handles the 'sig-with-array-len-prop' signal" do
-      skip
+      skip unless get_signal_introspection_data "Regress", "TestObj", "sig-with-array-len-prop"
+
+      a = nil
+
+      GObject.signal_connect(instance, "sig-with-array-len-prop") do |obj, arr, user_data|
+        a = arr
+      end
+
+      arr = GirFFI::InPointer.from_array(:uint, [1, 2, 3])
+      GObject.signal_emit instance, "sig-with-array-len-prop", arr, 3
+
+      a.to_a.must_equal [1, 2, 3]
     end
 
     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 "handles the 'sig-with-foreign-struct' signal" do
-      skip
+      skip unless get_signal_introspection_data "Regress", "TestObj", "sig-with-foreign-struct"
+
+      a = nil
+      instance.signal_connect "sig-with-foreign-struct" do |obj, ct|
+        a = ct
+      end
+
+      cairo_context = Regress.test_cairo_context_full_return
+
+      GObject.signal_emit instance, "sig-with-foreign-struct", cairo_context
+
+      a.must_be_instance_of Cairo::Context
+      a.must_equal cairo_context
     end
+
     it "handles the 'sig-with-hash-prop' signal" do
-      skip
+      a = nil
+
+      GObject.signal_connect(instance, "sig-with-hash-prop") do |_, ghash, _|
+        a = ghash.to_hash
+      end
+
+      g_hash_table = GLib::HashTable.from([:utf8, GObject::Value],
+                                          {"foo" => GObject::Value.from("bar")})
+
+      GObject.signal_emit instance, "sig-with-hash-prop", g_hash_table
+
+      a["foo"].must_be_instance_of GObject::Value
+      a["foo"].get_value.must_equal "bar"
     end
+
     it "handles the 'sig-with-int64-prop' signal" do
-      skip
+      skip unless get_signal_introspection_data "Regress", "TestObj", "sig-with-int64-prop"
+
+      a = nil
+
+      GObject.signal_connect(instance, "sig-with-int64-prop") do |obj, int64, user_data|
+        a = int64
+      end
+
+      GObject.signal_emit instance, "sig-with-int64-prop", 0x7fffffffffffffff
+
+      a.must_equal 0x7fffffffffffffff
     end
+
     it "handles the 'sig-with-intarray-ret' signal" do
-      skip
+      skip unless get_signal_introspection_data "Regress", "TestObj", "sig-with-intarray-ret"
+
+      a = nil
+
+      GObject.signal_connect(instance, "sig-with-intarray-ret") do |_, i, _|
+        a = i
+        [3, 2, 1]
+      end
+
+      result = GObject.signal_emit instance, "sig-with-intarray-ret", 3
+
+      a.must_equal 3
+
+      # We would expect result to contain the int array, but regress.c uses the
+      # wrong marshalling function
+      result.get_value.must_be_nil
     end
+
     it "handles the 'sig-with-obj' signal" do
-      skip
+      a = nil
+
+      GObject.signal_connect(instance, "sig-with-obj") do |_, obj, _|
+        a = obj
+      end
+
+      object = Regress::TestObj.constructor
+      GObject.signal_emit instance, "sig-with-obj", object
+
+      a.must_equal object
     end
+
     it "handles the 'sig-with-strv' signal" do
-      skip
+      a = nil
+
+      GObject.signal_connect(instance, "sig-with-strv") do |_, strs, _|
+        a = strs
+      end
+
+      GObject.signal_emit instance, "sig-with-strv", GLib::Strv.from(["foo", "bar"])
+
+      a.to_a.must_equal ["foo", "bar"]
     end
+
     it "handles the 'sig-with-uint64-prop' signal" do
-      skip
+      skip unless get_signal_introspection_data "Regress", "TestObj", "sig-with-uint64-prop"
+
+      a = nil
+
+      GObject.signal_connect(instance, "sig-with-uint64-prop") do |_, uint64, _|
+        a = uint64
+      end
+
+      GObject.signal_emit instance, "sig-with-uint64-prop", 0xffffffffffffffff
+
+      a.must_equal 0xffffffffffffffff
     end
 
     it "handles the 'test' signal" do
@@ -1002,8 +1103,19 @@ describe Regress do
       GObject.signal_emit o, "test"
       assert_equal [2, o], [a, b]
     end
+
     it "handles the 'test-with-static-scope-arg' signal" do
-      skip
+      a = nil
+
+      GObject.signal_connect(instance, "test-with-static-scope-arg") do |_, obj, _|
+        a = obj
+      end
+
+      arg = Regress::TestSimpleBoxedA.new
+      arg.some_int = 12345
+      GObject.signal_emit instance, "test-with-static-scope-arg", arg
+
+      a.some_int.must_equal 12345
     end
   end
 
@@ -1096,6 +1208,30 @@ describe Regress do
 
     let(:instance) { Regress::TestSimpleBoxedA.new }
 
+    it "has a writable field some_int" do
+      instance.some_int.must_equal 0
+      instance.some_int = 42
+      instance.some_int.must_equal 42
+    end
+
+    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 some_double" do
+      instance.some_double.must_equal 0.0
+      instance.some_double = 42.0
+      instance.some_double.must_equal 42.0
+    end
+
+    it "has a writable field some_enum" do
+      instance.some_enum.must_equal :value1
+      instance.some_enum = :value4
+      instance.some_enum.must_equal :value4
+    end
+
     it "has a working method #copy" do
       instance.some_int = 4236
 
@@ -1273,6 +1409,20 @@ describe Regress do
       instance.field = o
       instance.field.must_equal o
     end
+
+    it "has a writable field list" do
+      instance.list.must_be_nil
+      o = Regress::TestSubObj.new
+      instance.list = [o]
+      instance.list.must_be :==, [o]
+    end
+
+    it "has a writable field garray" do
+      instance.garray.must_be_nil
+      o = Regress::TestSubObj.new
+      instance.garray = [o]
+      instance.garray.must_be :==, [o]
+    end
   end
 
   describe "Regress::TestStructE" do
@@ -1364,7 +1514,7 @@ describe Regress do
     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
+      instance.data1.read_int.must_equal 42
     end
 
     it "has a writable field data2" do
@@ -1458,7 +1608,7 @@ describe Regress do
 
     describe "its 'testbool' property" do
       it "can be retrieved with #get_property" do
-        instance.get_property("testbool").must_equal true
+        instance.get_property("testbool").get_value.must_equal true
       end
 
       it "can be retrieved with #testbool" do
@@ -1468,23 +1618,23 @@ describe Regress do
       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.get_property("testbool").get_value.must_equal true
 
         instance.set_property "testbool", false
         instance.get_testbool.must_equal false
-        instance.get_property("testbool").must_equal false
+        instance.get_property("testbool").get_value.must_equal false
       end
 
       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.get_property("testbool").get_value.must_equal true
 
         instance.testbool = false
         instance.testbool.must_equal false
         instance.get_testbool.must_equal false
-        instance.get_property("testbool").must_equal false
+        instance.get_property("testbool").get_value.must_equal false
       end
     end
   end
@@ -1511,13 +1661,19 @@ describe Regress do
   end
 
   it "has a working function #global_get_flags_out" do
-    skip
+    result = Regress.global_get_flags_out
+    result.must_equal Regress::TestFlags[:flag1] | Regress::TestFlags[:flag3]
   end
+
   it "has a working function #has_parameter_named_attrs" do
-    skip
+    skip unless get_introspection_data 'Regress', 'has_parameter_named_attrs'
+    Regress.has_parameter_named_attrs 42, [23] * 32
+    pass
   end
+
   it "has a working function #introspectable_via_alias" do
-    skip
+    Regress.introspectable_via_alias []
+    pass
   end
 
   it "has a working function #set_abort_on_error" do
@@ -1527,10 +1683,28 @@ describe Regress do
   end
 
   it "has a working function #test_abc_error_quark" do
-    skip
+    skip unless get_introspection_data 'Regress', 'test_abc_error_quark'
+
+    quark = Regress.test_abc_error_quark
+    GLib.quark_to_string(quark).must_equal "regress-test-abc-error"
   end
+
   it "has a working function #test_array_callback" do
-    skip
+    a = nil
+    b = nil
+    c = 95
+
+    callback = lambda do |one, two|
+      a = one
+      b = two
+      c
+    end
+
+    result = Regress.test_array_callback callback
+
+    result.must_equal 2 * c
+    a.to_a.must_equal [-1, 0, 1, 2]
+    b.to_a.must_equal ["one", "two", "three"]
   end
 
   it "has a working function #test_array_fixed_out_objects" do
@@ -1703,13 +1877,52 @@ describe Regress do
   end
 
   it "has a working function #test_callback_destroy_notify_no_user_data" do
-    skip
+    skip unless get_introspection_data 'Regress', 'test_callback_destroy_notify_no_user_data'
+
+    callback_times_called = 0
+    notify_times_called = 0
+    b = :not_nil
+
+    callback = Proc.new {|user_data|
+      callback_times_called += 1
+      b = user_data
+      callback_times_called * 5
+    }
+
+    notify = Proc.new { notify_times_called += 1 }
+
+    result = Regress.test_callback_destroy_notify_no_user_data callback, notify
+
+    callback_times_called.must_equal 1
+    notify_times_called.must_equal 0
+    result.must_equal 5
+    b.must_be_nil
+
+    result = Regress.test_callback_thaw_notifications
+
+    callback_times_called.must_equal 2
+    notify_times_called.must_equal 1
+    result.must_equal 10
+    b.must_be_nil
   end
+
   it "has a working function #test_callback_thaw_async" do
-    skip
+    invoked = []
+    Regress.test_callback_async Proc.new { invoked << 1; 1 }, nil
+    Regress.test_callback_async Proc.new { invoked << 2; 2 }, nil
+    Regress.test_callback_async Proc.new { invoked << 3; 3 }, nil
+    result = Regress.test_callback_thaw_async
+    invoked.must_equal [3, 2, 1]
+    result.must_equal 1
   end
+
   it "has a working function #test_callback_thaw_notifications" do
-    skip
+    invoked = false
+    Regress.test_callback_destroy_notify Proc.new { 42 }, nil, nil
+    Regress.test_callback_destroy_notify Proc.new { 24 }, nil, Proc.new { invoked = true }
+    result = Regress.test_callback_thaw_notifications
+    result.must_equal 66
+    invoked.must_equal true
   end
 
   it "has a working function #test_callback_user_data" do
@@ -1746,7 +1959,21 @@ describe Regress do
   end
 
   it "has a working function #test_closure_variant" do
-    skip
+    skip "This causes a core dump on some systems"
+    arg = GLib::Variant.new_string "foo"
+    closure = GObject::RubyClosure.new do |variant|
+      str = variant.get_string
+      if str == "foo"
+        GLib::Variant.new_int32 40
+      else
+        GLib::Variant.new_string "bar"
+      end
+    end
+
+    # TODO: Convert proc to RubyClosure automatically
+    result = Regress.test_closure_variant closure, arg
+
+    result.get_int32.must_equal 40
   end
 
   it "has a working function #test_date_in_gvalue" do
@@ -1758,7 +1985,9 @@ describe Regress do
   end
 
   it "has a working function #test_def_error_quark" do
-    skip
+    skip unless get_introspection_data 'Regress', 'test_def_error_quark'
+    quark = Regress.test_def_error_quark
+    GLib.quark_to_string(quark).must_equal "regress-test-def-error"
   end
 
   it "has a working function #test_double" do
@@ -1772,7 +2001,9 @@ describe Regress do
   end
 
   it "has a working function #test_error_quark" do
-    skip
+    skip unless get_introspection_data 'Regress', 'test_error_quark'
+    quark = Regress.test_error_quark
+    GLib.quark_to_string(quark).must_equal "regress-test-error"
   end
 
   it "has a working function #test_filename_return" do
@@ -1796,10 +2027,14 @@ describe Regress do
   end
 
   it "has a working function #test_garray_full_return" do
-    skip
+    result = Regress.test_garray_full_return
+    result.to_a.must_equal ["regress"]
   end
+
   it "has a working function #test_gerror_callback" do
-    skip
+    result = nil
+    Regress.test_gerror_callback Proc.new {|err| result = err.message }
+    result.must_equal "regression test error"
   end
 
   it "has a working function #test_ghash_container_return" do
@@ -1818,16 +2053,41 @@ describe Regress do
   end
 
   it "has a working function #test_ghash_gvalue_in" do
-    skip
+    skip unless get_introspection_data 'Regress', 'test_ghash_gvalue_in'
+    skip unless get_introspection_data 'Regress', 'test_ghash_gvalue_return'
+    hash_table = Regress.test_ghash_gvalue_return
+    Regress.test_ghash_gvalue_in hash_table
   end
+
   it "has a working function #test_ghash_gvalue_return" do
-    skip
+    skip unless get_introspection_data 'Regress', 'test_ghash_gvalue_return'
+    result = Regress.test_ghash_gvalue_return
+    hash = result.to_hash
+    hash["integer"].get_value.must_equal 12
+    hash["boolean"].get_value.must_equal true
+    hash["string"].get_value.must_equal "some text"
+    hash["strings"].get_value.to_a.must_equal ["first", "second", "third"]
+    hash["flags"].get_value.must_equal Regress::TestFlags[:flag1] | Regress::TestFlags[:flag3]
+    hash["enum"].get_value.must_equal :value2
+    hash.keys.sort.must_equal ["boolean", "enum", "flags", "integer", "string", "strings"]
   end
+
   it "has a working function #test_ghash_nested_everything_return" do
-    skip
+    result = Regress.test_ghash_nested_everything_return
+    hash = result.to_hash
+    hash.keys.must_equal ["wibble"]
+    hash["wibble"].to_hash.must_equal({"foo" => "bar",
+                                       "baz" => "bat",
+                                       "qux" => "quux"})
   end
+
   it "has a working function #test_ghash_nested_everything_return2" do
-    skip
+    result = Regress.test_ghash_nested_everything_return2
+    hash = result.to_hash
+    hash.keys.must_equal ["wibble"]
+    hash["wibble"].to_hash.must_equal({"foo" => "bar",
+                                       "baz" => "bat",
+                                       "qux" => "quux"})
   end
 
   it "has a working function #test_ghash_nothing_in" do