gir_ffi 0.15.1 → 0.15.6

data/test/gir_ffi/builders/signal_closure_builder_test.rb

@@ -1,197 +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
-          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
-        expected = <<~CODE
-          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
-          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
-        expected = <<~CODE
-          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
-        expected = <<~CODE
-          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
-        expected = <<~CODE
-          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
-        expected = <<~CODE
-          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
-        expected = <<~CODE
-          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
-
-    describe "for a signal with GError argument" do
-      let(:signal_info) do
-        get_signal_introspection_data "Regress", "TestObj", "sig-with-gerror"
-      end
-
-      it "returns a valid mapping method" do
-        skip_below "1.61.1"
-
-        expected = <<~CODE
-          def self.marshaller(closure, return_value, param_values, _invocation_hint, _marshal_data)
-            _instance, error = param_values.map(&:get_value_plain)
-            _v1 = _instance
-            _v2 = GLib::Error.wrap(error)
-            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,29 +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 }
-
-  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,84 +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
-
-    describe "its #find_property method" do
-      it "returns nil for a property that doesn't exist" do
-        _(builder.find_property("foo")).must_be_nil
-      end
-
-      it "finds properies in ancestor classes" do
-        property = builder.find_property "name"
-        _(property.name).must_equal "name"
-      end
-    end
-  end
-end

data/test/gir_ffi/builders/union_builder_test.rb

@@ -1,28 +0,0 @@
-# frozen_string_literal: true
-
-require "gir_ffi_test_helper"
-
-describe GirFFI::Builders::UnionBuilder do
-  let(:union_info) { get_introspection_data("Regress", "FooBUnion") }
-  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 Regress::FooBUnion" do
-      _(builder.layout_specification).must_equal [:type, :int32, 0,
-                                                  :v, :double, 0,
-                                                  :rect, :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