gir_ffi 0.14.1 → 0.15.4

data/test/gir_ffi/builders/signal_closure_builder_test.rb

@@ -1,188 +0,0 @@
-# frozen_string_literal: true
-
-require 'gir_ffi_test_helper'
-
-describe GirFFI::Builders::SignalClosureBuilder do
-  let(:builder) { GirFFI::Builders::SignalClosureBuilder.new signal_info }
-
-  describe '#build_class' do
-    let(:signal_info) do
-      get_signal_introspection_data 'Regress', 'TestObj', 'test'
-    end
-
-    it 'builds a descendant of RubyClosure' do
-      klass = builder.build_class
-      klass.superclass.must_equal GObject::RubyClosure
-    end
-  end
-
-  describe '#marshaller_definition' do
-    describe 'for a signal with no arguments or return value' do
-      let(:signal_info) do
-        get_signal_introspection_data 'Regress', 'TestObj', 'test'
-      end
-
-      it 'returns a valid marshaller converting only the receiver' do
-        expected = <<-CODE.reset_indentation
-        def self.marshaller(closure, return_value, param_values, _invocation_hint, _marshal_data)
-          _instance = param_values.first.get_value_plain
-          _v1 = _instance
-          wrap(closure.to_ptr).invoke_block(_v1)
-        end
-        CODE
-
-        builder.marshaller_definition.must_equal expected
-      end
-    end
-
-    describe 'for a signal with an argument and a return value' do
-      let(:signal_info) do
-        get_signal_introspection_data 'Regress', 'TestObj', 'sig-with-int64-prop'
-      end
-
-      it 'returns a valid mapping method' do
-        skip unless signal_info
-
-        expected = <<-CODE.reset_indentation
-        def self.marshaller(closure, return_value, param_values, _invocation_hint, _marshal_data)
-          _instance, i = param_values.map(&:get_value_plain)
-          _v1 = _instance
-          _v2 = i
-          _v3 = wrap(closure.to_ptr).invoke_block(_v1, _v2)
-          return_value.set_value _v3
-        end
-        CODE
-
-        builder.marshaller_definition.must_equal expected
-      end
-    end
-
-    describe 'for a signal with an enum argument' do
-      let(:signal_info) do
-        get_signal_introspection_data 'Gio', 'MountOperation', 'reply'
-      end
-
-      it 'returns a valid mapping method' do
-        expected = <<-CODE.reset_indentation
-        def self.marshaller(closure, return_value, param_values, _invocation_hint, _marshal_data)
-          _instance, result = param_values.map(&:get_value_plain)
-          _v1 = _instance
-          _v2 = result
-          wrap(closure.to_ptr).invoke_block(_v1, _v2)
-        end
-        CODE
-
-        builder.marshaller_definition.must_equal expected
-      end
-    end
-
-    describe 'for a signal with a array plus length arguments' do
-      let(:signal_info) do
-        get_signal_introspection_data 'Regress', 'TestObj', 'sig-with-array-len-prop'
-      end
-
-      it 'returns a valid mapping method' do
-        skip unless signal_info
-
-        expected = <<-CODE.reset_indentation
-        def self.marshaller(closure, return_value, param_values, _invocation_hint, _marshal_data)
-          _instance, arr, len = param_values.map(&:get_value_plain)
-          _v1 = _instance
-          _v2 = len
-          _v3 = GirFFI::SizedArray.wrap(:guint32, _v2, arr)
-          wrap(closure.to_ptr).invoke_block(_v1, _v3)
-        end
-        CODE
-
-        builder.marshaller_definition.must_equal expected
-      end
-    end
-
-    describe 'for a signal with a struct argument' do
-      let(:signal_info) do
-        get_signal_introspection_data 'Regress', 'TestObj', 'test-with-static-scope-arg'
-      end
-
-      it 'returns a valid mapping method' do
-        skip unless signal_info
-
-        expected = <<-CODE.reset_indentation
-        def self.marshaller(closure, return_value, param_values, _invocation_hint, _marshal_data)
-          _instance, object = param_values.map(&:get_value_plain)
-          _v1 = _instance
-          _v2 = Regress::TestSimpleBoxedA.wrap(object)
-          wrap(closure.to_ptr).invoke_block(_v1, _v2)
-        end
-        CODE
-
-        builder.marshaller_definition.must_equal expected
-      end
-    end
-
-    describe 'for a signal returning an array of integers' do
-      let(:signal_info) do
-        get_signal_introspection_data 'Regress', 'TestObj', 'sig-with-intarray-ret'
-      end
-
-      it 'returns a valid mapping method' do
-        skip unless signal_info
-
-        expected = <<-CODE.reset_indentation
-        def self.marshaller(closure, return_value, param_values, _invocation_hint, _marshal_data)
-          _instance, i = param_values.map(&:get_value_plain)
-          _v1 = _instance
-          _v2 = i
-          _v3 = wrap(closure.to_ptr).invoke_block(_v1, _v2)
-          _v4 = GLib::Array.from(:gint32, _v3)
-          return_value.set_value _v4
-        end
-        CODE
-
-        builder.marshaller_definition.must_equal expected
-      end
-    end
-
-    describe 'for a signal returning an string' do
-      let(:signal_info) do
-        get_signal_introspection_data 'Gtk', 'Scale', 'format-value'
-      end
-
-      it 'returns a mapping method that passes the string result to return_value directly' do
-        skip unless signal_info
-
-        expected = <<-CODE.reset_indentation
-        def self.marshaller(closure, return_value, param_values, _invocation_hint, _marshal_data)
-          _instance, value = param_values.map(&:get_value_plain)
-          _v1 = _instance
-          _v2 = value
-          _v3 = wrap(closure.to_ptr).invoke_block(_v1, _v2)
-          return_value.set_value _v3
-        end
-        CODE
-
-        builder.marshaller_definition.must_equal expected
-      end
-    end
-
-    describe 'for a signal with GList argument' do
-      let(:signal_info) do
-        get_signal_introspection_data 'Regress', 'AnnotationObject', 'list-signal'
-      end
-
-      it 'returns a valid mapping method' do
-        skip unless signal_info
-
-        expected = <<-CODE.reset_indentation
-        def self.marshaller(closure, return_value, param_values, _invocation_hint, _marshal_data)
-          _instance, list = param_values.map(&:get_value_plain)
-          _v1 = _instance
-          _v2 = GLib::List.wrap(:utf8, list)
-          wrap(closure.to_ptr).invoke_block(_v1, _v2)
-        end
-        CODE
-
-        builder.marshaller_definition.must_equal expected
-      end
-    end
-  end
-end

data/test/gir_ffi/builders/struct_builder_test.rb

@@ -1,93 +0,0 @@
-# frozen_string_literal: true
-
-require 'gir_ffi_test_helper'
-
-describe GirFFI::Builders::StructBuilder do
-  describe '#layout_specification' do
-    it 'returns the correct layout for Regress::TestStructA' do
-      info = get_introspection_data 'Regress', 'TestStructA'
-      builder = GirFFI::Builders::StructBuilder.new info
-      builder.layout_specification.must_equal [:some_int, :int32, 0,
-                                               :some_int8, :int8, 4,
-                                               :some_double, :double, 8,
-                                               :some_enum, Regress::TestEnum, 16]
-    end
-
-    describe 'for a struct with a simple layout' do
-      before do
-        @field = Object.new
-
-        @struct = Object.new
-        allow(@struct).to receive(:namespace).and_return 'Foo'
-        allow(@struct).to receive(:safe_name).and_return 'Bar'
-        allow(@struct).to receive(:fields).and_return [@field]
-
-        @builder = GirFFI::Builders::StructBuilder.new @struct
-      end
-
-      it 'creates the correct layout specification' do
-        expect(@field).to receive(:layout_specification).and_return [:bar, :int32, 0]
-        spec = @builder.layout_specification
-        assert_equal [:bar, :int32, 0], spec
-      end
-    end
-
-    describe 'for a struct with a layout with a complex type' do
-      it 'does not flatten the complex type specification' do
-        expect(simplefield = Object.new).to receive(:layout_specification).and_return [:bar, :foo, 0]
-        expect(complexfield = Object.new).to receive(:layout_specification).and_return [:baz, [:qux, 2], 0]
-        expect(struct = Object.new).to receive(:fields).and_return [simplefield, complexfield]
-
-        allow(struct).to receive(:safe_name).and_return 'Bar'
-        allow(struct).to receive(:namespace).and_return 'Foo'
-
-        builder = GirFFI::Builders::StructBuilder.new struct
-        spec = builder.layout_specification
-        assert_equal [:bar, :foo, 0, :baz, [:qux, 2], 0], spec
-      end
-    end
-  end
-
-  describe '#superclass' do
-    it 'returns StructBase for a normal struct' do
-      info = get_introspection_data 'Regress', 'TestStructA'
-      builder = GirFFI::Builders::StructBuilder.new info
-      builder.superclass.must_equal GirFFI::StructBase
-    end
-
-    it 'returns BoxedBase for a boxed type' do
-      info = get_introspection_data 'Regress', 'TestSimpleBoxedB'
-      builder = GirFFI::Builders::StructBuilder.new info
-      builder.superclass.must_equal GirFFI::BoxedBase
-    end
-
-    it 'returns the GObject parent class for a type class' do
-      info = get_introspection_data 'GIMarshallingTests', 'SubSubObjectClass'
-      builder = GirFFI::Builders::StructBuilder.new info
-      builder.superclass.must_equal GIMarshallingTests::SubObjectClass
-    end
-
-    it 'returns ObjectClass for InitiallyUnownedClass' do
-      info = get_introspection_data 'GObject', 'InitiallyUnownedClass'
-      builder = GirFFI::Builders::StructBuilder.new info
-      builder.superclass.must_equal GObject::ObjectClass
-    end
-  end
-
-  describe '#setup_class' do
-    before do
-      save_module :Regress
-    end
-
-    it 'stubs the structs methods' do
-      info = get_introspection_data 'Regress', 'TestStructA'
-      builder = GirFFI::Builders::StructBuilder.new info
-      builder.setup_class
-      assert_defines_instance_method Regress::TestStructA, :clone
-    end
-
-    after do
-      restore_module :Regress
-    end
-  end
-end

data/test/gir_ffi/builders/unintrospectable_boxed_builder_test.rb

@@ -1,35 +0,0 @@
-# frozen_string_literal: true
-
-require 'gir_ffi_test_helper'
-
-GirFFI.setup :GIMarshallingTests
-
-describe GirFFI::Builders::UnintrospectableBoxedBuilder do
-  let(:instance) { GIMarshallingTests::PropertiesObject.new }
-  let(:property) { instance.object_class.find_property 'some-boxed-glist' }
-  let(:gtype) { property.value_type }
-  let(:info) { GirFFI::UnintrospectableBoxedInfo.new(gtype) }
-  let(:bldr) { GirFFI::Builders::UnintrospectableBoxedBuilder.new(info) }
-  let(:boxed_class) { bldr.build_class }
-
-  before do
-    skip unless get_property_introspection_data('GIMarshallingTests',
-                                                'PropertiesObject',
-                                                'some-boxed-glist')
-  end
-
-  it 'builds a class' do
-    boxed_class.must_be_instance_of Class
-  end
-
-  it 'builds a class derived from GirFFI::BoxedBase' do
-    boxed_class.superclass.must_equal GirFFI::BoxedBase
-  end
-
-  it 'returns the same class when built again' do
-    other_bldr = GirFFI::Builders::UnintrospectableBoxedBuilder.new(info)
-    other_class = other_bldr.build_class
-
-    other_class.must_equal boxed_class
-  end
-end

data/test/gir_ffi/builders/unintrospectable_builder_test.rb

@@ -1,73 +0,0 @@
-# frozen_string_literal: true
-
-require 'gir_ffi_test_helper'
-
-GirFFI.setup :Gio
-GirFFI.setup :Gst
-
-describe GirFFI::Builders::UnintrospectableBuilder do
-  describe 'building the GLocalFile type' do
-    before do
-      Gio.file_new_for_path '/'
-
-      @gtype = GObject.type_from_name 'GLocalFile'
-      @info = GirFFI::UnintrospectableTypeInfo.new(@gtype)
-      @bldr = GirFFI::Builders::UnintrospectableBuilder.new(@info)
-      @klass = @bldr.build_class
-    end
-
-    it 'builds a class' do
-      assert_instance_of Class, @klass
-    end
-
-    it 'builds a class derived from GObject::Object' do
-      assert_includes @klass.registered_ancestors, GObject::Object
-    end
-
-    it 'builds a class derived from Gio::File' do
-      assert_includes @klass.registered_ancestors, Gio::File
-    end
-
-    it 'returns the same class when built again' do
-      other_bldr = GirFFI::Builders::UnintrospectableBuilder.new(@info)
-      other_klass = other_bldr.build_class
-
-      assert_equal @klass, other_klass
-    end
-
-    describe 'its #find_signal method' do
-      it "returns nil for a signal that doesn't exist" do
-        @bldr.find_signal('foo').must_be_nil
-      end
-
-      it 'finds signals in ancestor classes' do
-        signal = @bldr.find_signal 'notify'
-        signal.name.must_equal 'notify'
-      end
-    end
-
-    describe '#object_class_struct' do
-      it 'returns the parent class struct' do
-        @bldr.object_class_struct.must_equal GObject::ObjectClass
-      end
-    end
-  end
-
-  describe 'building the GstFakeSink type' do
-    let(:instance) { Gst::ElementFactory.make('fakesink', 'sink') }
-    let(:sink_class) { instance.class }
-    let(:builder) { sink_class.gir_ffi_builder }
-
-    before do
-      Gst.init []
-    end
-
-    describe 'its #find_signal method' do
-      it 'finds signals that are not defined in the GIR' do
-        signal = builder.find_signal 'handoff'
-        signal.wont_be_nil
-        signal.name.must_equal 'handoff'
-      end
-    end
-  end
-end

data/test/gir_ffi/builders/union_builder_test.rb

@@ -1,31 +0,0 @@
-# frozen_string_literal: true
-
-require 'gir_ffi_test_helper'
-
-describe GirFFI::Builders::UnionBuilder do
-  let(:union_info) { get_introspection_data('GObject', 'TypeCValue') }
-  let(:builder) { GirFFI::Builders::UnionBuilder.new union_info }
-
-  describe '#setup_instance_method' do
-    it "returns nil looking for a method that doesn't exist" do
-      builder.setup_instance_method('blub').must_be_nil
-    end
-  end
-
-  describe '#layout_specification' do
-    it 'returns the correct layout for GObject::TypeCValue' do
-      long_type = FFI.type_size(:long) == 8 ? :int64 : :int32
-      builder.layout_specification.must_equal [:v_int, :int32, 0,
-                                               :v_long, long_type, 0,
-                                               :v_int64, :int64, 0,
-                                               :v_double, :double, 0,
-                                               :v_pointer, :pointer, 0]
-    end
-  end
-
-  describe '#layout_superclass' do
-    it 'returns GirFFI::Union' do
-      builder.layout_superclass.must_equal GirFFI::Union
-    end
-  end
-end

data/test/gir_ffi/builders/user_defined_builder_test.rb

@@ -1,524 +0,0 @@
-# frozen_string_literal: true
-
-require 'gir_ffi_test_helper'
-
-GirFFI.setup :GIMarshallingTests
-GirFFI.setup :Regress
-
-describe GirFFI::Builders::UserDefinedBuilder do
-  let(:base_class) { GIMarshallingTests::Object }
-  let(:derived_class) do
-    Object.const_set("DerivedClass#{Sequence.next}", Class.new(base_class))
-  end
-  let(:builder) { GirFFI::Builders::UserDefinedBuilder.new info }
-  let(:info) { GirFFI::UserDefinedObjectInfo.new derived_class }
-
-  describe '#build_class' do
-    before do
-      builder.build_class
-    end
-
-    describe 'with type info containing one integer property' do
-      let(:info) do
-        GirFFI::UserDefinedObjectInfo.new derived_class do |it|
-          it.install_property GObject.param_spec_int('foo-bar', 'foo bar',
-                                                     'The Foo Bar Property',
-                                                     10, 20, 15,
-                                                     readable: true, writable: true)
-        end
-      end
-
-      it 'registers a type that is bigger than the parent' do
-        gtype = derived_class.gtype
-        q = GObject.type_query gtype
-        q.instance_size.must_be :>, GIMarshallingTests::Object::Struct.size
-      end
-
-      it "gives the type's Struct fields for the parent and the property" do
-        derived_class::Struct.members.must_equal [:parent, :foo_bar]
-      end
-
-      it 'creates accessor functions for the property' do
-        obj = derived_class.new
-        obj.foo_bar = 13
-        obj.foo_bar.must_equal 13
-      end
-
-      it 'makes the property retrievable using #get_property' do
-        obj = derived_class.new
-        obj.foo_bar = 13
-        obj.get_property('foo-bar').must_equal 13
-      end
-
-      it 'makes the property settable using #set_property' do
-        obj = derived_class.new
-        obj.set_property('foo-bar', 20)
-        obj.foo_bar.must_equal 20
-      end
-
-      it 'keeps parent properties accessible through their accessors' do
-        obj = derived_class.new
-        obj.int = 24
-        obj.int.must_equal 24
-      end
-
-      it 'keeps parent properties accessible through get_property and set_property' do
-        obj = derived_class.new
-        obj.set_property('int', 24)
-        obj.get_property('int').must_equal 24
-      end
-    end
-
-    describe 'with type info containing properties of several different types' do
-      let(:info) do
-        GirFFI::UserDefinedObjectInfo.new derived_class do |it|
-          it.install_property GObject.param_spec_string('string-prop', 'string property',
-                                                        'The String Property',
-                                                        'this is the default value',
-                                                        readable: true, writable: true)
-          it.install_property GObject.param_spec_int('int-prop', 'integer property',
-                                                     'The Integer Property',
-                                                     10, 20, 15,
-                                                     readable: true, writable: true)
-          it.install_property GObject.param_spec_long('long-prop', 'long property',
-                                                      'The Long Property',
-                                                      10.0, 50.0, 42.0,
-                                                      readable: true, writable: true)
-        end
-      end
-
-      it 'registers a type of the proper size' do
-        expected_size = derived_class::Struct.size
-        gtype = derived_class.gtype
-        q = GObject.type_query gtype
-        q.instance_size.must_equal expected_size
-      end
-
-      it "gives the type's Struct fields for the parent and the properties with the correct offsets" do
-        offsets = derived_class::Struct.offsets
-        alignment = derived_class::Struct.alignment
-        alignment.must_equal 8 # TODO: Fix tests for platforms where this fails.
-        offsets.must_equal [[:parent, 0], [:string_prop, 32], [:int_prop, 40], [:long_prop, 48]]
-      end
-
-      it 'creates accessor functions for the string property' do
-        obj = derived_class.new
-        obj.string_prop = 'hello!'
-        obj.string_prop.must_equal 'hello!'
-      end
-
-      it 'creates accessor functions for the integer property' do
-        obj = derived_class.new
-        obj.int_prop = 13
-        obj.int_prop.must_equal 13
-      end
-    end
-
-    describe 'with a boxed property' do
-      let(:boxed_gtype) { GIMarshallingTests::BoxedStruct.gtype }
-      let(:info) do
-        GirFFI::UserDefinedObjectInfo.new derived_class do |it|
-          it.install_property GObject.param_spec_boxed('boxed-prop', 'boxed property',
-                                                       'The Boxed Property',
-                                                       boxed_gtype,
-                                                       readable: true, writable: true)
-        end
-      end
-
-      it 'registers a type of the proper size' do
-        expected_size = derived_class::Struct.size
-        gtype = derived_class.gtype
-        q = GObject.type_query gtype
-        q.instance_size.must_equal expected_size
-      end
-
-      it "gives the type's Struct fields for the parent and the property" do
-        derived_class::Struct.members.must_equal [:parent, :boxed_prop]
-      end
-
-      it 'creates accessor functions for the property' do
-        obj = derived_class.new
-        boxed = GIMarshallingTests::BoxedStruct.new
-        boxed.long_ = 423
-        obj.boxed_prop = boxed
-        obj.boxed_prop.long_.must_equal 423
-      end
-    end
-
-    describe 'with an object property' do
-      let(:object_gtype) { GIMarshallingTests::Object.gtype }
-      let(:info) do
-        GirFFI::UserDefinedObjectInfo.new derived_class do |it|
-          it.install_property GObject.param_spec_object('object-prop', 'object property',
-                                                        'The Object Property',
-                                                        object_gtype,
-                                                        readable: true, writable: true)
-        end
-      end
-
-      it 'registers a type of the proper size' do
-        expected_size = derived_class::Struct.size
-        gtype = derived_class.gtype
-        q = GObject.type_query gtype
-        q.instance_size.must_equal expected_size
-      end
-
-      it "gives the type's Struct fields for the parent and the property" do
-        derived_class::Struct.members.must_equal [:parent, :object_prop]
-      end
-
-      it 'creates accessor functions for the property' do
-        obj = derived_class.new
-        object = GIMarshallingTests::Object.new 42
-        object.int = 423
-        obj.object_prop = object
-        obj.object_prop.int.must_equal 423
-      end
-
-      it 'allows clearing the property throught the setter method' do
-        obj = derived_class.new
-        obj.object_prop = nil
-        obj.object_prop.must_be_nil
-      end
-
-      it 'handles reference counting correctly when using the accessor' do
-        obj = derived_class.new
-        object = GIMarshallingTests::Object.new 42
-        obj.object_prop = object
-        object_ref_count(object).must_equal 2
-      end
-
-      it 'handles reference counting correctly when using the set_property method' do
-        obj = derived_class.new
-        object = GIMarshallingTests::Object.new 42
-
-        object_ref_count(object).must_equal 1
-        obj.set_property('object_prop', object)
-        object_ref_count(object).must_equal 4 # Due to extra Value#set_value + Value#get_value
-      end
-    end
-
-    describe 'with a boolean property' do
-      let(:object_gtype) { GIMarshallingTests::Object.gtype }
-      let(:info) do
-        GirFFI::UserDefinedObjectInfo.new derived_class do |it|
-          it.install_property GObject.param_spec_boolean('the-prop', 'the property',
-                                                         'The Property',
-                                                         true,
-                                                         readable: true, writable: true)
-        end
-      end
-
-      it 'creates accessor functions for the property' do
-        obj = derived_class.new
-        obj.the_prop = true
-        obj.the_prop.must_equal true
-      end
-    end
-
-    describe 'with a char property' do
-      let(:object_gtype) { GIMarshallingTests::Object.gtype }
-      let(:info) do
-        GirFFI::UserDefinedObjectInfo.new derived_class do |it|
-          it.install_property GObject.param_spec_char('the-prop', 'the property',
-                                                      'The Property',
-                                                      -20, 100, 15,
-                                                      readable: true, writable: true)
-        end
-      end
-
-      it 'creates accessor functions for the property' do
-        obj = derived_class.new
-        obj.the_prop = -13
-        obj.the_prop.must_equal(-13)
-      end
-    end
-
-    describe 'with a uchar property' do
-      let(:object_gtype) { GIMarshallingTests::Object.gtype }
-      let(:info) do
-        GirFFI::UserDefinedObjectInfo.new derived_class do |it|
-          it.install_property GObject.param_spec_uchar('the-prop', 'the property',
-                                                       'The Property',
-                                                       10, 100, 15,
-                                                       readable: true, writable: true)
-        end
-      end
-
-      it 'creates accessor functions for the property' do
-        obj = derived_class.new
-        obj.the_prop = 13
-        obj.the_prop.must_equal 13
-      end
-    end
-
-    describe 'with a uint property' do
-      let(:object_gtype) { GIMarshallingTests::Object.gtype }
-      let(:info) do
-        GirFFI::UserDefinedObjectInfo.new derived_class do |it|
-          it.install_property GObject.param_spec_uint('the-prop', 'the property',
-                                                      'The Property',
-                                                      10, 100, 15,
-                                                      readable: true, writable: true)
-        end
-      end
-
-      it 'creates accessor functions for the property' do
-        obj = derived_class.new
-        obj.the_prop = 423
-        obj.the_prop.must_equal 423
-      end
-    end
-
-    describe 'with a ulong property' do
-      let(:object_gtype) { GIMarshallingTests::Object.gtype }
-      let(:info) do
-        GirFFI::UserDefinedObjectInfo.new derived_class do |it|
-          it.install_property GObject.param_spec_ulong('the-prop', 'the property',
-                                                       'The Property',
-                                                       10, 100, 15,
-                                                       readable: true, writable: true)
-        end
-      end
-
-      it 'creates accessor functions for the property' do
-        obj = derived_class.new
-        obj.the_prop = 423_432
-        obj.the_prop.must_equal 423_432
-      end
-    end
-
-    describe 'with a int64 property' do
-      let(:object_gtype) { GIMarshallingTests::Object.gtype }
-      let(:info) do
-        GirFFI::UserDefinedObjectInfo.new derived_class do |it|
-          it.install_property GObject.param_spec_int64('the-prop', 'the property',
-                                                       'The Property',
-                                                       10, 100, 15,
-                                                       readable: true, writable: true)
-        end
-      end
-
-      it 'creates accessor functions for the property' do
-        obj = derived_class.new
-        obj.the_prop = -423_432
-        obj.the_prop.must_equal(-423_432)
-      end
-    end
-
-    describe 'with a uint64 property' do
-      let(:object_gtype) { GIMarshallingTests::Object.gtype }
-      let(:info) do
-        GirFFI::UserDefinedObjectInfo.new derived_class do |it|
-          it.install_property GObject.param_spec_uint64('the-prop', 'the property',
-                                                        'The Property',
-                                                        10, 100, 15,
-                                                        readable: true, writable: true)
-        end
-      end
-
-      it 'creates accessor functions for the property' do
-        obj = derived_class.new
-        obj.the_prop = 423_432
-        obj.the_prop.must_equal 423_432
-      end
-    end
-
-    describe 'with a float property' do
-      let(:object_gtype) { GIMarshallingTests::Object.gtype }
-      let(:info) do
-        GirFFI::UserDefinedObjectInfo.new derived_class do |it|
-          it.install_property GObject.param_spec_float('the-prop', 'the property',
-                                                       'The Property',
-                                                       10.0, 100.0, 15.0,
-                                                       readable: true, writable: true)
-        end
-      end
-
-      it 'creates accessor functions for the property' do
-        obj = derived_class.new
-        obj.the_prop = 42.23
-        obj.the_prop.must_be_within_epsilon 42.23
-      end
-    end
-
-    describe 'with a double property' do
-      let(:object_gtype) { GIMarshallingTests::Object.gtype }
-      let(:info) do
-        GirFFI::UserDefinedObjectInfo.new derived_class do |it|
-          it.install_property GObject.param_spec_double('the-prop', 'the property',
-                                                        'The Property',
-                                                        10.0, 100.0, 15.0,
-                                                        readable: true, writable: true)
-        end
-      end
-
-      it 'creates accessor functions for the property' do
-        obj = derived_class.new
-        obj.the_prop = 42.23
-        obj.the_prop.must_equal 42.23
-      end
-    end
-
-    describe 'with an enum property' do
-      let(:object_gtype) { GIMarshallingTests::Object.gtype }
-      let(:info) do
-        GirFFI::UserDefinedObjectInfo.new derived_class do |it|
-          prop = GObject.param_spec_enum('the-prop', 'the property',
-                                         'The Property',
-                                         GIMarshallingTests::GEnum.gtype, 0,
-                                         readable: true, writable: true)
-          it.install_property prop
-        end
-      end
-
-      it 'creates accessor functions for the property' do
-        obj = derived_class.new
-        obj.the_prop = :value2
-        obj.the_prop.must_equal :value2
-      end
-    end
-
-    describe 'with a flags property' do
-      let(:object_gtype) { GIMarshallingTests::Object.gtype }
-      let(:info) do
-        GirFFI::UserDefinedObjectInfo.new derived_class do |it|
-          prop = GObject.param_spec_flags('the-prop', 'the property',
-                                          'The Property',
-                                          GIMarshallingTests::Flags.gtype, 0,
-                                          readable: true, writable: true)
-          it.install_property prop
-        end
-      end
-
-      it 'creates accessor functions for the property' do
-        obj = derived_class.new
-        obj.the_prop = { value2: true }
-        obj.the_prop.must_equal value2: true
-      end
-    end
-
-    describe 'when deriving from a class with hidden struct size' do
-      let(:parent_class) { Regress::TestInheritDrawable }
-      let(:parent_size) do
-        GObject.type_query(parent_class.gtype).instance_size
-      end
-      let(:derived_class) do
-        Object.const_set("DerivedClass#{Sequence.next}", Class.new(parent_class))
-      end
-      let(:info) do
-        GirFFI::UserDefinedObjectInfo.new derived_class do |it|
-          it.install_property GObject.param_spec_int('int-prop', 'integer property',
-                                                     'Integer Property',
-                                                     10, 20, 15,
-                                                     readable: true, writable: true)
-        end
-      end
-
-      it 'registers a type that is bigger than the parent' do
-        class_size = GObject.type_query(derived_class.gtype).instance_size
-        class_size.must_be :>, parent_size
-      end
-
-      it 'leaves enough space in derived struct layout' do
-        struct_size = derived_class::Struct.size
-        struct_size.must_be :>, parent_size
-      end
-    end
-
-    describe 'with type info containing an overridden g_name' do
-      let(:info) do
-        GirFFI::UserDefinedObjectInfo.new derived_class do |it|
-          it.g_name = "OtherName#{Sequence.next}"
-        end
-      end
-
-      it 'registers a type under the overridden name' do
-        registered_name = GObject.type_name(derived_class.gtype)
-        registered_name.must_equal info.g_name
-        registered_name.wont_equal derived_class.name
-      end
-    end
-
-    describe 'with type info containing a vfunc' do
-      let(:info) do
-        GirFFI::UserDefinedObjectInfo.new derived_class do |it|
-          it.install_vfunc_implementation :method_int8_in, proc { |instance, in_|
-            instance.int = in_
-          }
-        end
-      end
-
-      it 'allows the vfunc to be called through its invoker' do
-        obj = derived_class.new
-        obj.method_int8_in 12
-        obj.int.must_equal 12
-      end
-    end
-
-    describe 'when using a default vfunc implementation' do
-      let(:base_class) { Regress::TestObj }
-      let(:info) do
-        GirFFI::UserDefinedObjectInfo.new derived_class do |it|
-          it.install_vfunc_implementation :matrix
-        end
-      end
-
-      before do
-        derived_class.class_eval do
-          def matrix(_arg)
-            44
-          end
-        end
-      end
-
-      it 'allows the vfunc to be called through its invoker' do
-        obj = derived_class.new
-        obj.do_matrix('bar').must_equal 44
-      end
-    end
-
-    describe 'with type info containing a vfunc from an included Interface' do
-      let(:info) do
-        derived_class.class_eval { include GIMarshallingTests::Interface }
-        GirFFI::UserDefinedObjectInfo.new derived_class do |it|
-          it.install_vfunc_implementation :test_int8_in,
-                                          proc { |instance, in_| instance.int = in_ }
-        end
-      end
-
-      it 'marks the type as conforming to the included Interface' do
-        iface_gtype = GIMarshallingTests::Interface.gtype
-        GObject.type_interfaces(derived_class.gtype).to_a.must_equal [iface_gtype]
-      end
-
-      it 'allows the vfunc to be called through its invoker' do
-        obj = derived_class.new
-        obj.test_int8_in 12
-        obj.int.must_equal 12
-      end
-    end
-
-    it 'keeps the gtype for an already registered class' do
-      gtype = derived_class.gtype
-      other_builder = GirFFI::Builders::UserDefinedBuilder.new info
-      other_class = other_builder.build_class
-      other_class.gtype.must_equal gtype
-    end
-
-    it 'creates a class with a new GType' do
-      derived_class.gtype.wont_equal GIMarshallingTests::Object.gtype
-    end
-
-    it 'makes the registered class return objects with the correct GType' do
-      obj = derived_class.new
-      GObject.type_from_instance(obj).must_equal derived_class.gtype
-    end
-  end
-
-  describe '#object_class_struct' do
-    it 'returns the parent class struct' do
-      builder.object_class_struct.must_equal GIMarshallingTests::ObjectClass
-    end
-  end
-end