gir_ffi 0.0.6 → 0.0.7

data/lib/gir_ffi/overrides/gobject.rb

@@ -2,8 +2,77 @@ module GirFFI
   module Overrides
     module GObject
 
-      def self.included(base)
+      def self.included base
 	base.extend ClassMethods
+        extend_classes(base)
+        attach_non_introspectable_functions(base)
+        build_extra_classes(base)
+      end
+
+      def self.extend_classes base
+        base::InitiallyUnowned.extend InitiallyUnownedClassMethods
+        base::Value.class_eval {
+          include ValueInstanceMethods
+          extend ValueClassMethods
+        }
+        base::Closure.class_eval {
+          include ClosureInstanceMethods
+        }
+      end
+
+      def self.attach_non_introspectable_functions base
+        base::Lib.attach_function :g_signal_connect_data,
+          [:pointer, :string, base::Callback, :pointer, base::ClosureNotify,
+            base::ConnectFlags],
+            :ulong
+        base::Lib.attach_function :g_closure_set_marshal,
+          [:pointer, base::ClosureMarshal], :void
+      end
+
+      def self.build_extra_classes base
+        klass = Class.new(base::Closure) do
+          const_set :BLOCK_STORE, {}
+
+          const_set :Struct, Class.new(FFI::Struct) {
+            layout :parent, base::Closure::Struct, 0,
+            :blockhash, :int64
+          }
+
+          def self.new &block
+            raise ArgumentError unless block_given?
+            wrap(new_simple(self::Struct.size, nil).to_ptr).tap do |it|
+              # XXX: Check that this methods is fool-proof!
+              h = block.hash
+              self::BLOCK_STORE[h] = block
+              it[:blockhash] = h
+              it.set_marshal Proc.new {|*args| marshaller(*args)}
+            end
+          end
+
+          def self.marshaller(closure, return_value, n_param_values,
+                              param_values, invocation_hint, marshal_data)
+            rclosure = self.wrap(closure.to_ptr)
+
+            args = []
+            n_param_values.times {|i|
+              gv = ::GObject::Value.wrap(param_values.to_ptr +
+                                         i * ::GObject::Value::Struct.size)
+              args << gv.ruby_value
+            }
+
+            r = rclosure.invoke_block(*args)
+            return_value.set_ruby_value r unless return_value.nil?
+          end
+
+          def block
+            self.class::BLOCK_STORE[self[:blockhash]]
+          end
+
+          def invoke_block *args
+            block.call(*args)
+          end
+        end
+        base.const_set :RubyClosure, klass
       end
 
       module ClassMethods
@@ -18,29 +87,6 @@ module GirFFI
 	  type_from_instance_pointer instance.to_ptr
 	end
 
-	def wrap_in_g_value val
-	  gvalue = ::GObject::Value.new
-	  case val
-	  when true, false
-	    gvalue.init ::GObject.type_from_name("gboolean")
-	    gvalue.set_boolean val
-	  else
-	    nil
-	  end
-	  gvalue
-	end
-
-	def unwrap_g_value gvalue
-	  gtype = gvalue[:g_type]
-	  gtypename = ::GObject.type_name gtype
-	  case gtypename
-	  when "gboolean"
-	    gvalue.get_boolean
-	  else
-	    nil
-	  end
-	end
-
 	def signal_emit object, signal, *args
 	  type = type_from_instance object
 	  id = signal_lookup signal, type
@@ -64,12 +110,16 @@ module GirFFI
 
 	  rettype = GirFFI::Builder.itypeinfo_to_ffitype sig.return_type
 
+          # FIXME: Why are these all pointers?
 	  argtypes = [:pointer] + sig.args.map {|arg| :pointer} + [:pointer]
 
 	  callback = FFI::Function.new rettype, argtypes,
 	    &(Helper.signal_callback_args(sig, object.class, &block))
+          ::GObject::Lib::CALLBACKS << callback
+
+          data_ptr = GirFFI::ArgHelper.object_to_inptr data
 
-	  signal_connect_data object, signal, callback, data, nil, 0
+	  ::GObject::Lib.g_signal_connect_data object, signal, callback, data_ptr, nil, 0
 	end
       end
 
@@ -150,7 +200,7 @@ module GirFFI
 	    arg = args.shift
 	    if info.type.tag == :interface
 	      iface = info.type.interface
-	      kls = GirFFI::Builder.build_class(iface.namespace, iface.name)
+	      kls = GirFFI::Builder.build_class iface
 	      result << kls.wrap(arg)
 	    else
 	      result << arg
@@ -174,6 +224,73 @@ module GirFFI
 	end
       end
 
+      module InitiallyUnownedClassMethods
+        def constructor_wrap ptr
+          super.tap {|obj| GirFFI::GObject.object_ref_sink obj}
+        end
+      end
+
+      module ValueClassMethods
+        def wrap_ruby_value val
+          self.new.set_ruby_value val
+        end
+      end
+
+      module ValueInstanceMethods
+        def set_ruby_value val
+          if current_gtype == 0
+            init_for_ruby_value val
+          end
+
+	  case current_gtype_name
+	  when "gboolean"
+	    set_boolean val
+          when "gint"
+	    set_int val
+	  else
+	    nil
+	  end
+          self
+        end
+
+        def init_for_ruby_value val
+	  case val
+	  when true, false
+	    init ::GObject.type_from_name("gboolean")
+          when Integer
+	    init ::GObject.type_from_name("gint")
+	  end
+          self
+        end
+
+        def current_gtype
+          self[:g_type]
+        end
+
+        def current_gtype_name
+          ::GObject.type_name current_gtype
+        end
+
+        def ruby_value
+	  case current_gtype_name
+	  when "gboolean"
+	    get_boolean
+	  when "gint"
+	    get_int
+	  else
+	    nil
+	  end
+        end
+      end
+
+      module ClosureInstanceMethods
+        def set_marshal marshal
+	  _v1 = GirFFI::ArgHelper.wrap_in_callback_args_mapper(
+            "GObject", "ClosureMarshal", marshal)
+	  ::GObject::Lib::CALLBACKS << _v1
+	  ::GObject::Lib.g_closure_set_marshal self, _v1
+        end
+      end
     end
   end
 end

data/tasks/test.rake

@@ -8,6 +8,20 @@ namespace :test do
     t.ruby_opts += ["-w"]
   end
 
+  desc 'Build Regress test library and typelib'
+  task :lib => "test/lib/Makefile" do
+    sh %{cd test/lib && make}
+  end
+
+  task :run => :lib
+end
+
+file "test/lib/Makefile" => "test/lib/configure" do
+  sh %{cd test/lib && ./configure}
+end
+
+file "test/lib/configure" do
+  sh %{cd test/lib && NOCONFIGURE=1 ./autogen.sh}
 end
 
 desc 'Alias to test:run'

data/test/arg_helper_test.rb

@@ -120,17 +120,33 @@ class ArgHelperTest < Test::Unit::TestCase
 
   context "The object_pointer_to_object method" do
     setup do
-      GirFFI.setup :Everything
-      @o = Everything::TestSubObj.new
+      GirFFI.setup :Regress
+      @o = Regress::TestSubObj.new
       @o2 = GirFFI::ArgHelper.object_pointer_to_object @o.to_ptr
     end
 
     should "return an object of the correct class" do
-      assert_instance_of Everything::TestSubObj, @o2
+      assert_instance_of Regress::TestSubObj, @o2
     end
 
     should "return an object pointing to the original struct" do
       assert_equal @o.to_ptr, @o2.to_ptr
     end
   end
+
+  context "The map_single_callback_arg method" do
+    should "correctly map a :struct type" do
+      GirFFI.setup :GObject
+
+      cl = GObject::Closure.new_simple GObject::Closure::Struct.size, nil
+
+      cinfo = GirFFI::IRepository.default.find_by_name 'GObject', 'ClosureMarshal'
+      ainfo = cinfo.args[0]
+
+      r = GirFFI::ArgHelper.map_single_callback_arg cl.to_ptr, ainfo
+
+      assert_instance_of GObject::Closure, r
+      assert_equal r.to_ptr, cl.to_ptr
+    end
+  end
 end

data/test/builder_test.rb

@@ -2,15 +2,18 @@ require File.expand_path('test_helper.rb', File.dirname(__FILE__))
 
 class BuilderTest < Test::Unit::TestCase
   context "The GirFFI::Builder module" do
+    setup do
+      @gir = GirFFI::IRepository.default
+    end
+
     context "building GObject::Object" do
       setup do
 	cleanup_module :GObject
-	GirFFI::Builder.build_class 'GObject', 'Object'
+	GirFFI::Builder.build_class @gir.find_by_name('GObject', 'Object')
       end
 
       should "create a Lib module in the parent namespace ready to attach functions from gobject-2.0" do
-	gir = GirFFI::IRepository.default
-	expected = gir.shared_library('GObject')
+	expected = @gir.shared_library('GObject')
 	assert_equal [expected], GObject::Lib.ffi_libraries.map(&:name)
       end
 
@@ -20,7 +23,7 @@ class BuilderTest < Test::Unit::TestCase
 
       should "not replace existing classes" do
 	oldclass = GObject::Object
-	GirFFI::Builder.build_class 'GObject', 'Object'
+	GirFFI::Builder.build_class @gir.find_by_name('GObject', 'Object')
 	assert_equal oldclass, GObject::Object
       end
     end
@@ -29,7 +32,7 @@ class BuilderTest < Test::Unit::TestCase
       setup do
 	cleanup_module :Gtk
 	cleanup_module :GObject
-	GirFFI::Builder.build_class 'Gtk', 'Window'
+	GirFFI::Builder.build_class @gir.find_by_name('Gtk', 'Window')
       end
 
       should "build Gtk namespace" do
@@ -39,22 +42,21 @@ class BuilderTest < Test::Unit::TestCase
 
       should "build parent classes also" do
 	assert Gtk.const_defined? :Widget
-	assert Gtk.const_defined? :Object
 	assert Object.const_defined? :GObject
 	assert GObject.const_defined? :InitiallyUnowned
 	assert GObject.const_defined? :Object
       end
 
-      should "set up inheritence chain" do
+      should "set up inheritance chain" do
+        ancestors = Gtk::Window.ancestors
 	assert_equal [
 	  Gtk::Window,
 	  Gtk::Bin,
 	  Gtk::Container,
-	  Gtk::Widget,
-	  Gtk::Object,
-	  GObject::InitiallyUnowned,
-	  GObject::Object
-	], Gtk::Window.ancestors[0..6]
+	  Gtk::Widget
+	], ancestors[0..3]
+        assert ancestors.include? GObject::InitiallyUnowned
+	assert ancestors.include? GObject::Object
       end
 
       should "create a Gtk::Window#to_ptr method" do
@@ -66,6 +68,17 @@ class BuilderTest < Test::Unit::TestCase
       end
     end
 
+    context "built Gtk::Widget" do
+      setup do
+        cleanup_module :Gtk
+	GirFFI::Builder.build_class @gir.find_by_name('Gtk', 'Widget')
+      end
+
+      should "not have regular #new as a constructor" do
+	assert_raises(NoMethodError) { Gtk::Widget.new }
+      end
+    end
+
     context "building Gtk" do
       setup do
 	cleanup_module :Gtk
@@ -74,8 +87,7 @@ class BuilderTest < Test::Unit::TestCase
 
       should "create a Lib module ready to attach functions from gtk-x11-2.0" do
 	# The Gtk module has more than one library on my current machine.
-	gir = GirFFI::IRepository.default
-	expected = (gir.shared_library 'Gtk').split(',')
+	expected = (@gir.shared_library 'Gtk').split(',')
 	assert_equal expected.sort, Gtk::Lib.ffi_libraries.map(&:name).sort
       end
 
@@ -102,9 +114,8 @@ class BuilderTest < Test::Unit::TestCase
       end
 
       should "have correct introspection data" do
-	gir = GirFFI::IRepository.default
-	gir.require "Gtk", nil
-	go2 = gir.find_by_name "Gtk", "main"
+	@gir.require "Gtk", nil
+	go2 = @gir.find_by_name "Gtk", "main"
 	assert_equal go2, @go
       end
 
@@ -147,62 +158,67 @@ class BuilderTest < Test::Unit::TestCase
 
     end
 
-    context "looking at GObject.signal_connect_data" do
+    context "looking at Regress.test_callback_destroy_notify" do
       setup do
+	cleanup_module :GLib
 	cleanup_module :GObject
+	cleanup_module :Regress
+	GirFFI::Builder.build_module 'GLib'
 	GirFFI::Builder.build_module 'GObject'
-	@go = get_function_introspection_data 'GObject', 'signal_connect_data'
+	GirFFI::Builder.build_module 'Regress'
+	@go = get_function_introspection_data 'Regress', 'test_callback_destroy_notify'
       end
 
       should "have the correct types of the arguments for the attached function" do
 	argtypes = GirFFI::Builder.send(:ffi_function_argument_types, @go)
-	assert_equal [:pointer, :pointer, GObject::Callback, :pointer, GObject::ClosureNotify, GObject::ConnectFlags],
+	assert_equal [Regress::TestCallbackUserData, :pointer, GLib::DestroyNotify],
 	  argtypes
       end
 
       should "define ffi callback types :Callback and :ClosureNotify" do
-	GObject.gir_ffi_builder.setup_function 'signal_connect_data'
-	cb = GObject::Lib.find_type :Callback
-	cn = GObject::Lib.find_type :ClosureNotify
+	Regress.gir_ffi_builder.setup_function 'test_callback_destroy_notify'
+	tcud = Regress::Lib.find_type :TestCallbackUserData
+	dn = GLib::Lib.find_type :DestroyNotify
 
-	assert_equal FFI.find_type(:void), cb.result_type
-	assert_equal FFI.find_type(:void), cn.result_type
-	assert_equal [], cb.param_types
-	assert_equal [FFI.find_type(:pointer), FFI.find_type(:pointer)], cn.param_types
+	assert_equal FFI.find_type(:int32), tcud.result_type
+	assert_equal FFI.find_type(:void), dn.result_type
+	assert_equal [FFI.find_type(:pointer)], tcud.param_types
+	assert_equal [FFI.find_type(:pointer)], dn.param_types
       end
 
+      # FIXME: Test passes but does not test what it claims to test.
       should "define ffi enum type ConnectFlags" do
 	assert_equal({:after => 1, :swapped => 2}, GObject::ConnectFlags.to_h)
       end
     end
 
-    context "building Everything::TestStructA" do
+    context "building Regress::TestStructA" do
       setup do
 	@fieldnames = [:some_int, :some_int8, :some_double, :some_enum]
-	GirFFI::Builder.build_class 'Everything', 'TestStructA'
+	GirFFI::Builder.build_class @gir.find_by_name('Regress', 'TestStructA')
       end
 
       should "set up the correct struct members" do
 	assert_equal @fieldnames,
-	  Everything::TestStructA::Struct.members
+	  Regress::TestStructA::Struct.members
       end
 
       should "set up struct members with the correct offset" do
-	info = GirFFI::IRepository.default.find_by_name 'Everything', 'TestStructA'
+	info = @gir.find_by_name 'Regress', 'TestStructA'
 	assert_equal info.fields.map{|f| [f.name.to_sym, f.offset]},
-	  Everything::TestStructA::Struct.offsets
+	  Regress::TestStructA::Struct.offsets
       end
 
       should "set up struct members with the correct types" do
-	tags = [:int, :int8, :double, Everything::TestEnum]
+	tags = [:int, :int8, :double, Regress::TestEnum]
 	assert_equal tags.map {|t| FFI.find_type t},
-	  @fieldnames.map {|f| Everything::TestStructA::Struct.layout[f].type}
+	  @fieldnames.map {|f| Regress::TestStructA::Struct.layout[f].type}
       end
     end
 
     context "building GObject::TypeCValue" do
       setup do
-	GirFFI::Builder.build_class 'GObject', 'TypeCValue'
+	GirFFI::Builder.build_class @gir.find_by_name('GObject', 'TypeCValue')
       end
 
       should "set up the correct union members" do
@@ -222,106 +238,102 @@ class BuilderTest < Test::Unit::TestCase
 
     context "building GObject::ValueArray" do
       should "use provided constructor if present" do
-	GirFFI::Builder.build_class 'GObject', 'ValueArray'
+	GirFFI::Builder.build_class @gir.find_by_name('GObject', 'ValueArray')
 	assert_nothing_raised {
 	  GObject::ValueArray.new 2
 	}
       end
     end
 
-    context "building Everything::TestBoxed" do
+    context "building Regress::TestBoxed" do
       setup do
-	GirFFI::Builder.build_class 'Everything', 'TestBoxed'
+	GirFFI::Builder.build_class @gir.find_by_name('Regress', 'TestBoxed')
       end
 
       should "set up #wrap" do
-	assert Everything::TestBoxed.respond_to? "wrap"
+	assert Regress::TestBoxed.respond_to? "wrap"
       end
 
       should "set up #allocate" do
-	assert Everything::TestBoxed.respond_to? "allocate"
+	assert Regress::TestBoxed.respond_to? "allocate"
       end
     end
 
-    context "built Everything module" do
+    context "built Regress module" do
       setup do
-	cleanup_module :Everything
-	GirFFI::Builder.build_module 'Everything'
+	cleanup_module :Regress
+	GirFFI::Builder.build_module 'Regress'
       end
 
       should "have a method_missing method" do
-	ms = (Everything.public_methods - Module.public_methods).map(&:to_sym)
+	ms = (Regress.public_methods - Module.public_methods).map(&:to_sym)
 	assert ms.include? :method_missing
       end
 
       should "autocreate the TestObj class" do
-	assert !Everything.const_defined?(:TestObj)
-	assert_nothing_raised {Everything::TestObj}
-	assert Everything.const_defined? :TestObj
+	assert !Regress.const_defined?(:TestObj)
+	assert_nothing_raised {Regress::TestObj}
+	assert Regress.const_defined? :TestObj
       end
 
       should "know its own module builder" do
-	assert GirFFI::ModuleBuilder === Everything.gir_ffi_builder
+	assert GirFFI::Builder::Module === Regress.gir_ffi_builder
       end
     end
 
-    context "built Everything::TestObj" do
+    context "built Regress::TestObj" do
       setup do
-	cleanup_module :Everything
-	GirFFI::Builder.build_class 'Everything', 'TestObj'
+	cleanup_module :Regress
+	GirFFI::Builder.build_class @gir.find_by_name('Regress', 'TestObj')
       end
 
       should "make autocreated instance method available to all instances" do
-	o1 = Everything::TestObj.new_from_file("foo")
-	o2 = Everything::TestObj.new_from_file("foo")
+	o1 = Regress::TestObj.new_from_file("foo")
+	o2 = Regress::TestObj.new_from_file("foo")
 	o1.instance_method
-	Everything::TestObj.class_eval do
+	Regress::TestObj.class_eval do
 	  undef method_missing
 	end
 	assert_nothing_raised { o2.instance_method }
       end
 
-      should "attach C functions to Everything::Lib" do
-	o = Everything::TestObj.new_from_file("foo")
+      should "attach C functions to Regress::Lib" do
+	o = Regress::TestObj.new_from_file("foo")
 	o.instance_method
-	assert Everything::Lib.respond_to? :test_obj_instance_method
-      end
-
-      should "not have regular #new as a constructor" do
-	assert_raises(NoMethodError) { Everything::TestObj.new }
+	assert Regress::Lib.respond_to? :regress_test_obj_instance_method
       end
 
       should "know its own GIR info" do
-	assert_equal 'TestObj', Everything::TestObj.gir_info.name
+	assert_equal 'TestObj', Regress::TestObj.gir_info.name
       end
 
       should "know its own class builder" do
-	assert GirFFI::ClassBuilder === Everything::TestObj.gir_ffi_builder
+	assert GirFFI::Builder::Class === Regress::TestObj.gir_ffi_builder
       end
 
       context "its #torture_signature_0 method" do
 	should "have the correct types of the arguments for the attached function" do
-	  info = get_method_introspection_data 'Everything', 'TestObj',
+	  info = get_method_introspection_data 'Regress', 'TestObj',
 	    'torture_signature_0'
-	  assert_equal [:pointer, :int, :pointer, :pointer, :pointer, :pointer, :uint],
+	  assert_equal [:pointer, :int32, :pointer, :pointer, :pointer, :pointer, :uint32],
 	    GirFFI::Builder.send(:ffi_function_argument_types, info)
 	end
       end
     end
 
-    context "built Everything::TestSubObj" do
+    context "built Regress::TestSubObj" do
       setup do
-	cleanup_module :Everything
-	GirFFI::Builder.build_class 'Everything', 'TestSubObj'
+	cleanup_module :Regress
+	GirFFI::Builder.build_class @gir.find_by_name('Regress', 'TestSubObj')
       end
 
       should "autocreate parent class' set_bare inside the parent class" do
-	o1 = Everything::TestSubObj.new
-	o2 = Everything::TestObj.new_from_file("foo")
+	o1 = Regress::TestSubObj.new
+	o2 = Regress::TestObj.new_from_file("foo")
 
 	assert_nothing_raised {o1.set_bare(nil)}
 
-	Everything::TestObj.class_eval do
+	Regress::TestObj.class_eval do
 	  undef method_missing
 	end
 
@@ -329,9 +341,9 @@ class BuilderTest < Test::Unit::TestCase
       end
 
       should "use its own version of instance_method when parent's version has been created" do
-	obj = Everything::TestObj.new_from_file("foo")
+	obj = Regress::TestObj.new_from_file("foo")
 	assert_equal(-1, obj.instance_method)
-	subobj = Everything::TestSubObj.new
+	subobj = Regress::TestSubObj.new
 	assert_equal 0, subobj.instance_method
       end
     end

data/test/class_builder_test.rb

@@ -1,17 +1,21 @@
 require File.expand_path('test_helper.rb', File.dirname(__FILE__))
 
 class ClassBuilderTest < Test::Unit::TestCase
-  context "The ClassBuilder" do
-    should "use parent struct as default layout" do
+  context "The Builder::Class class" do
+    setup do
       @gir = GirFFI::IRepository.default
+    end
+
+    should "use parent struct as default layout" do
       @gir.require 'GObject', nil
 
       stub(info = Object.new).parent { @gir.find_by_name 'GObject', 'Object' }
       stub(info).fields { [] }
       stub(info).type { :object }
+      stub(info).name { 'Bar' }
+      stub(info).namespace { 'Foo' }
 
-      @classbuilder = GirFFI::ClassBuilder.new 'Foo', 'Bar'
-      @classbuilder.instance_eval { @info = info }
+      @classbuilder = GirFFI::Builder::Class.new info
 
       spec = @classbuilder.send :layout_specification
       assert_equal [:parent, GObject::Object::Struct, 0], spec
@@ -19,7 +23,7 @@ class ClassBuilderTest < Test::Unit::TestCase
 
     context "for Gtk::Widget" do
       setup do
-	@cbuilder = GirFFI::ClassBuilder.new 'Gtk', 'Widget'
+	@cbuilder = GirFFI::Builder::Class.new @gir.find_by_name('Gtk', 'Widget')
       end
 
       context "looking at Gtk::Widget#show" do
@@ -27,9 +31,9 @@ class ClassBuilderTest < Test::Unit::TestCase
 	  @go = get_method_introspection_data 'Gtk', 'Widget', 'show'
 	end
 
-	should "delegate definition to FunctionDefinitionBuilder" do
+	should "delegate definition to Builder::Function" do
 	  code = @cbuilder.send :function_definition, @go
-	  expected = GirFFI::FunctionDefinitionBuilder.new(@go, Gtk::Lib).generate
+	  expected = GirFFI::Builder::Function.new(@go, Gtk::Lib).generate
 	  assert_equal cws(expected), cws(code)
 	end
 
@@ -38,19 +42,19 @@ class ClassBuilderTest < Test::Unit::TestCase
 
     context 'the find_signal method' do
       should 'find the signal "test" for TestObj' do
-	builder = GirFFI::ClassBuilder.new 'Everything', 'TestObj'
+	builder = GirFFI::Builder::Class.new @gir.find_by_name('Regress', 'TestObj')
 	sig = builder.find_signal 'test'
 	assert_equal 'test', sig.name
       end
 
       should 'find the signal "test" for TestSubObj' do
-	builder = GirFFI::ClassBuilder.new 'Everything', 'TestSubObj'
+	builder = GirFFI::Builder::Class.new @gir.find_by_name('Regress', 'TestSubObj')
 	sig = builder.find_signal 'test'
 	assert_equal 'test', sig.name
       end
 
       should 'find the signal "changed" for Gtk::Entry' do
-	builder = GirFFI::ClassBuilder.new 'Gtk', 'Entry'
+	builder = GirFFI::Builder::Class.new @gir.find_by_name('Gtk', 'Entry')
 	sig = builder.find_signal 'changed'
 	assert_equal 'changed', sig.name
       end
@@ -58,7 +62,7 @@ class ClassBuilderTest < Test::Unit::TestCase
 
     context "for GObject::TypeCValue (a union)" do
       setup do
-	@cbuilder = GirFFI::ClassBuilder.new 'GObject', 'TypeCValue'
+	@cbuilder = GirFFI::Builder::Class.new @gir.find_by_name('GObject', 'TypeCValue')
       end
 
       should "not raise an error looking for a method that doesn't exist" do