gir_ffi 0.15.1 → 0.15.6

data/test/ffi-gobject_test.rb

@@ -1,151 +0,0 @@
-# frozen_string_literal: true
-
-require "gir_ffi_test_helper"
-
-describe GObject do
-  before do
-    GirFFI.setup :Regress
-  end
-
-  describe "::signal_emit" do
-    it "emits a signal" do
-      a = 1
-      o = Regress::TestSubObj.new
-      prc = proc { a = 2 }
-      callback = GObject::Callback.from prc
-      ::GObject::Lib.g_signal_connect_data o, "test", callback, nil, nil, 0
-      GObject.signal_emit o, "test"
-      assert_equal 2, a
-    end
-
-    it "handles return values" do
-      s = Gio::SocketService.new
-
-      argtypes = [:pointer, :pointer, :pointer, :pointer]
-      callback = FFI::Function.new(:bool, argtypes) { |_a, _b, _c, _d| true }
-      ::GObject::Lib.g_signal_connect_data s, "incoming", callback, nil, nil, 0
-      rv = GObject.signal_emit s, "incoming"
-      assert_equal true, rv
-    end
-
-    it "passes in extra arguments" do
-      o = Regress::TestSubObj.new
-      sb = Regress::TestSimpleBoxedA.new
-      sb.some_int8 = 31
-      sb.some_double = 2.42
-      sb.some_enum = :value2
-      b2 = nil
-
-      argtypes = [:pointer, :pointer, :pointer]
-      callback = FFI::Function.new(:void, argtypes) do |_a, b, _c|
-        b2 = b
-      end
-      ::GObject::Lib.g_signal_connect_data o, "test-with-static-scope-arg", callback, nil, nil, 0
-      GObject.signal_emit o, "test-with-static-scope-arg", sb
-
-      sb2 = Regress::TestSimpleBoxedA.wrap b2
-      assert sb.equals(sb2)
-    end
-
-    it "allows specifying signal detail" do
-      a = 1
-      o = Regress::TestSubObj.new
-
-      callback = FFI::Function.new(:void, [:pointer, :pointer, :pointer]) { a = 2 }
-      ::GObject::Lib.g_signal_connect_data o, "notify::detail", callback, nil, nil, 0
-
-      GObject.signal_emit o, "notify::detail"
-
-      _(a).must_equal 2
-    end
-  end
-
-  describe "::signal_connect" do
-    it "installs a signal handler" do
-      a = 1
-      o = Regress::TestSubObj.new
-      GObject.signal_connect(o, "test") { a = 2 }
-      GObject.signal_emit o, "test"
-      assert_equal 2, a
-    end
-
-    it "passes user data to handler" do
-      a = 1
-      o = Regress::TestSubObj.new
-      GObject.signal_connect(o, "test", 2) { |_i, d| a = d }
-      GObject.signal_emit o, "test"
-      assert_equal 2, a
-    end
-
-    it "passes object to handler" do
-      o = Regress::TestSubObj.new
-      o2 = nil
-      GObject.signal_connect(o, "test") { |i, _d| o2 = i }
-      GObject.signal_emit o, "test"
-      assert_instance_of Regress::TestSubObj, o2
-      assert_equal o.to_ptr, o2.to_ptr
-    end
-
-    it "does not allow connecting an invalid signal" do
-      o = Regress::TestSubObj.new
-      _(proc { GObject.signal_connect(o, "not-really-a-signal") {} })
-        .must_raise GirFFI::SignalNotFoundError
-    end
-
-    it "handles return values" do
-      s = Gio::SocketService.new
-      GObject.signal_connect(s, "incoming") { true }
-      rv = GObject.signal_emit s, "incoming"
-      assert_equal true, rv
-    end
-
-    it "requires a block" do
-      o = Regress::TestSubObj.new
-      _(proc { GObject.signal_connect o, "test" }).must_raise ArgumentError
-    end
-
-    it "allows specifying signal detail" do
-      a = 1
-      o = Regress::TestSubObj.new
-      GObject.signal_connect(o, "notify::detail", 2) { |_i, _, d| a = d }
-      GObject.signal_emit o, "notify::detail"
-      assert_equal 2, a
-    end
-
-    describe "connecting a signal with extra arguments" do
-      before do
-        @a = nil
-        @b = 2
-
-        o = Regress::TestSubObj.new
-        sb = Regress::TestSimpleBoxedA.new
-        sb.some_int = 23
-
-        GObject.signal_connect(o, "test-with-static-scope-arg", 2) do |_instance, object, user_data|
-          @a = user_data
-          @b = object
-        end
-        GObject.signal_emit o, "test-with-static-scope-arg", sb
-      end
-
-      it "passes on the user data argument" do
-        assert_equal 2, @a
-      end
-
-      it "passes on the extra arguments" do
-        assert_instance_of Regress::TestSimpleBoxedA, @b
-        assert_equal 23, @b.some_int
-      end
-    end
-  end
-
-  describe "::signal_connect_after" do
-    it "installs a signal handler" do
-      a = 1
-      o = Regress::TestSubObj.new
-      GObject.signal_connect_after(o, "test") { a = 2 }
-      GObject.signal_emit o, "test"
-      assert_equal 2, a
-    end
-  end
-end

data/test/gir_ffi/allocation_helper_test.rb

@@ -1,36 +0,0 @@
-# frozen_string_literal: true
-
-require "gir_ffi_test_helper"
-
-describe GirFFI::AllocationHelper do
-  describe ".free_after" do
-    before do
-      allow(GirFFI::LibC).to receive(:free)
-    end
-
-    it "frees the passed-in pointer" do
-      ptr = double("pointer", null?: false)
-      GirFFI::AllocationHelper.free_after(ptr) {}
-      expect(GirFFI::LibC).to have_received(:free).with(ptr)
-    end
-
-    it "does not free a passed-in null pointer" do
-      ptr = double("pointer", null?: true)
-      GirFFI::AllocationHelper.free_after(ptr) {}
-      expect(GirFFI::LibC).not_to have_received(:free)
-    end
-
-    it "yields ptr to the block" do
-      ptr = double("pointer", null?: false)
-      foo = nil
-      GirFFI::AllocationHelper.free_after(ptr) { |it| foo = it }
-      _(foo).must_equal ptr
-    end
-
-    it "returns the result of the block" do
-      ptr = double("pointer", null?: false)
-      result = GirFFI::AllocationHelper.free_after(ptr) { "bar" }
-      _(result).must_equal "bar"
-    end
-  end
-end

data/test/gir_ffi/arg_helper_test.rb

@@ -1,139 +0,0 @@
-# frozen_string_literal: true
-
-require "gir_ffi_test_helper"
-
-describe GirFFI::ArgHelper do
-  describe ".cast_from_pointer" do
-    it "handles class types" do
-      klass = Class.new
-      expect(klass).to receive(:wrap).with(:pointer_value).and_return :wrapped_value
-      _(GirFFI::ArgHelper.cast_from_pointer(klass, :pointer_value)).must_equal :wrapped_value
-    end
-
-    describe "for :gint8" do
-      it "handles negative :gint8" do
-        ptr = FFI::Pointer.new(-127)
-        _(GirFFI::ArgHelper.cast_from_pointer(:gint8, ptr)).must_equal(-127)
-      end
-
-      it "handles positive :gint8" do
-        ptr = FFI::Pointer.new(128)
-        _(GirFFI::ArgHelper.cast_from_pointer(:gint8, ptr)).must_equal(128)
-      end
-    end
-
-    it "handles :guint32" do
-      ptr = FFI::Pointer.new(0xffffffff)
-      _(GirFFI::ArgHelper.cast_from_pointer(:guint32, ptr)).must_equal(0xffffffff)
-    end
-
-    describe "for :gint32" do
-      it "handles positive :gint32" do
-        ptr = FFI::Pointer.new(1)
-        _(GirFFI::ArgHelper.cast_from_pointer(:gint32, ptr)).must_equal(1)
-      end
-
-      it "handles negative :gint32" do
-        ptr = FFI::Pointer.new(0xffffffff)
-        _(GirFFI::ArgHelper.cast_from_pointer(:gint32, ptr)).must_equal(-1)
-      end
-
-      it "handles largest negative :gint32" do
-        ptr = FFI::Pointer.new(0x80000000)
-        _(GirFFI::ArgHelper.cast_from_pointer(:gint32, ptr)).must_equal(-0x80000000)
-      end
-
-      it "handles largest positive :gint32" do
-        ptr = FFI::Pointer.new(0x7fffffff)
-        _(GirFFI::ArgHelper.cast_from_pointer(:gint32, ptr)).must_equal(0x7fffffff)
-      end
-    end
-
-    it "handles :utf8" do
-      ptr = FFI::MemoryPointer.from_string "foo"
-      _(GirFFI::ArgHelper.cast_from_pointer(:utf8, ptr)).must_equal "foo"
-    end
-
-    it "handles :filename" do
-      ptr = FFI::MemoryPointer.from_string "foo"
-      _(GirFFI::ArgHelper.cast_from_pointer(:filename, ptr)).must_equal "foo"
-    end
-
-    it "handles GHashTable" do
-      hash = GLib::HashTable.from [:utf8, :gint32], "foo" => 1, "bar" => 2
-      ptr = hash.to_ptr
-      result = GirFFI::ArgHelper.cast_from_pointer([:pointer, [:ghash, :utf8, :gint32]], ptr)
-      _(result.to_hash).must_equal hash.to_hash
-    end
-
-    describe "when passing a broken typespec" do
-      it "raises on unknown symbol" do
-        ptr = FFI::Pointer.new(0xffffffff)
-        exception = _(-> { GirFFI::ArgHelper.cast_from_pointer(:foo, ptr) }).must_raise RuntimeError
-        _(exception.message).must_equal "Don't know how to cast foo"
-      end
-
-      it "raises on unexpected main type for complex type" do
-        ptr = FFI::Pointer.new(0xffffffff)
-        exception = _(-> { GirFFI::ArgHelper.cast_from_pointer([:utf8], ptr) }).must_raise RuntimeError
-        _(exception.message).must_equal "Don't know how to cast [:utf8]"
-      end
-
-      it "raises on unexpected sub type for complex type" do
-        ptr = FFI::Pointer.new(0xffffffff)
-        exception = _(-> { GirFFI::ArgHelper.cast_from_pointer([:pointer, :utf8], ptr) }).must_raise RuntimeError
-        _(exception.message).must_equal "Don't know how to cast [:pointer, :utf8]"
-      end
-
-      it "raises on unexpected container type for complex type" do
-        ptr = FFI::Pointer.new(0xffffffff)
-        exception = _(-> { GirFFI::ArgHelper.cast_from_pointer([:pointer, [:gint32]], ptr) }).must_raise RuntimeError
-        _(exception.message).must_equal "Don't know how to cast [:pointer, [:gint32]]"
-      end
-    end
-  end
-
-  describe ".store" do
-    describe "when called with nil" do
-      it "returns a null pointer" do
-        _(GirFFI::ArgHelper.store(nil)).must_be :null?
-      end
-    end
-
-    describe "when called with a string" do
-      it "stores the string in GirFFI::ArgHelper::OBJECT_STORE" do
-        str = "Foo"
-        ptr = GirFFI::ArgHelper.store(str)
-        result = GirFFI::ArgHelper::OBJECT_STORE.fetch(ptr)
-        _(result).must_equal str
-      end
-    end
-  end
-
-  describe ".check_fixed_array_size" do
-    it "passes if array has the correct size" do
-      GirFFI::ArgHelper.check_fixed_array_size(3, [1, 2, 3], "foo")
-      pass
-    end
-
-    it "raises if array does not have the correct size" do
-      result = _(-> { GirFFI::ArgHelper.check_fixed_array_size(3, [1, 2], "foo") })
-        .must_raise ArgumentError
-      _(result.message).must_equal "foo should have size 3"
-    end
-  end
-
-  describe ".check_error" do
-    it "does nothing if there is no error" do
-      err_ptr = double("err_ptr", read_pointer: nil)
-      GirFFI::ArgHelper.check_error err_ptr
-      pass
-    end
-
-    it "raises an exception if there is an error" do
-      err = GLib::Error.new
-      err_ptr = double("err_ptr", read_pointer: err.to_ptr)
-      _(-> { GirFFI::ArgHelper.check_error err_ptr }).must_raise GirFFI::GLibError
-    end
-  end
-end

data/test/gir_ffi/boolean_test.rb

@@ -1,43 +0,0 @@
-# frozen_string_literal: true
-
-require "gir_ffi_test_helper"
-
-describe GirFFI::Boolean do
-  it "has the same native size as an int" do
-    _(FFI.type_size(GirFFI::Boolean)).must_equal FFI.type_size :int
-  end
-
-  describe ".from_native" do
-    it "converts 0 to false" do
-      _(GirFFI::Boolean.from_native(0, "whatever")).must_equal false
-    end
-
-    it "converts 1 to true" do
-      _(GirFFI::Boolean.from_native(1, "whatever")).must_equal true
-    end
-  end
-
-  describe ".to_native" do
-    it "converts false to 0" do
-      _(GirFFI::Boolean.to_native(false, "whatever")).must_equal 0
-    end
-
-    it "converts true to 1" do
-      _(GirFFI::Boolean.to_native(true, "whatever")).must_equal 1
-    end
-
-    it "converts nil to 0" do
-      _(GirFFI::Boolean.to_native(nil, "whatever")).must_equal 0
-    end
-
-    it "converts truthy value to 1" do
-      _(GirFFI::Boolean.to_native("i am truth!", "whatever")).must_equal 1
-    end
-  end
-
-  describe ".size" do
-    it "returns the correct type size" do
-      _(GirFFI::Boolean.size).must_equal FFI.type_size :int
-    end
-  end
-end

data/test/gir_ffi/boxed_base_test.rb

@@ -1,65 +0,0 @@
-# frozen_string_literal: true
-
-require "gir_ffi_test_helper"
-
-GirFFI.setup :GIMarshallingTests
-
-describe GirFFI::BoxedBase do
-  describe "initialize" do
-    it "sets up the held struct pointer" do
-      # NOTE: GObject::Value uses the generic constructor, unlike
-      # GIMarshallingTests::BoxedStruct, which has its own constructor.
-      value = GObject::Value.new
-      _(value.to_ptr).wont_be_nil
-    end
-  end
-
-  describe "copy_from" do
-    it "returns a copy with owned false" do
-      original = GIMarshallingTests::BoxedStruct.new
-      copy = GIMarshallingTests::BoxedStruct.copy_from(original)
-      ptr = copy.to_ptr
-      _(ptr).wont_be :==, original.to_ptr
-      _(ptr).wont_be :autorelease? if ptr.respond_to? :autorelease?
-      _(copy.struct).wont_be :owned?
-    end
-  end
-
-  describe "wrap_own" do
-    it "wraps and owns the supplied pointer" do
-      original = GIMarshallingTests::BoxedStruct.new
-      copy = GIMarshallingTests::BoxedStruct.wrap_own(original.to_ptr)
-      ptr = copy.to_ptr
-      _(ptr).must_equal original.to_ptr
-      _(ptr).wont_be :autorelease? if ptr.respond_to? :autorelease?
-      _(copy.struct).must_be :owned?
-    end
-  end
-
-  describe "upon garbage collection" do
-    it "frees and disowns the underlying struct if it is owned" do
-      skip "cannot be reliably tested on JRuby and Rubinius" if jruby? || rubinius?
-
-      allow(GObject).to receive(:boxed_free)
-      gtype = GIMarshallingTests::BoxedStruct.gtype
-
-      owned_struct = GIMarshallingTests::BoxedStruct.new.struct
-      owned_ptr = owned_struct.to_ptr
-
-      unowned_struct = GIMarshallingTests::BoxedStruct.new.struct
-      unowned_struct.owned = false
-      unowned_ptr = unowned_struct.to_ptr
-
-      GC.start
-      # Creating a new object is sometimes needed to trigger enough garbage collection.
-      GIMarshallingTests::BoxedStruct.new
-      sleep 1
-      GC.start
-      GC.start
-
-      expect(GObject).to have_received(:boxed_free).with(gtype, owned_ptr)
-      expect(GObject).not_to have_received(:boxed_free).with(gtype, unowned_ptr)
-      _(owned_struct).wont_be :owned?
-    end
-  end
-end

data/test/gir_ffi/builder_test.rb

@@ -1,322 +0,0 @@
-# frozen_string_literal: true
-
-require "gir_ffi_test_helper"
-
-GirFFI.setup :Regress
-GirFFI.setup :GIMarshallingTests
-
-describe GirFFI::Builder do
-  let(:gir) { GObjectIntrospection::IRepository.default }
-
-  describe ".build_class" do
-    it "does not replace existing classes" do
-      oldclass = GObject::Object
-      GirFFI::Builder.build_class get_introspection_data("GObject", "Object")
-      _(GObject::Object).must_equal oldclass
-    end
-  end
-
-  describe ".build_module" do
-    it "refuses to build existing modules defined elsewhere" do
-      result = _(-> { GirFFI::Builder.build_module("Array") }).must_raise RuntimeError
-      _(result.message).must_equal "The module Array was already defined elsewhere"
-    end
-
-    describe "building a module for the first time" do
-      before do
-        save_module :Regress
-        GirFFI::Builder.build_module "Regress"
-      end
-
-      it "creates a Lib module ready to attach functions from the shared library" do
-        gir = GObjectIntrospection::IRepository.default
-        expected = [gir.shared_library("Regress")]
-        assert_equal expected, Regress::Lib.ffi_libraries.map(&:name)
-      end
-
-      after do
-        restore_module :Regress
-      end
-    end
-
-    describe "building a module that already exists" do
-      it "does not replace the existing module" do
-        oldmodule = Regress
-        GirFFI::Builder.build_module "Regress"
-        assert_equal oldmodule, Regress
-      end
-
-      it "does not replace the existing Lib module" do
-        oldmodule = Regress::Lib
-        GirFFI::Builder.build_module "Regress"
-        assert_equal oldmodule, Regress::Lib
-      end
-    end
-
-    it "passes the version on to ModuleBuilder" do
-      builder = double(generate: nil)
-      expect(GirFFI::Builders::ModuleBuilder).to receive(:new)
-        .with("Foo", namespace: "Foo", version: "1.0")
-        .and_return builder
-
-      GirFFI::Builder.build_module "Foo", "1.0"
-    end
-  end
-
-  describe ".build_by_gtype" do
-    it "returns the class types known to the GIR" do
-      result = GirFFI::Builder.build_by_gtype GObject::Object.gtype
-      _(result).must_equal GObject::Object
-    end
-
-    it "returns the class for user-defined types" do
-      klass = Class.new GIMarshallingTests::OverridesObject
-      Object.const_set "Derived#{Sequence.next}", klass
-      gtype = GirFFI.define_type klass
-
-      found_klass = GirFFI::Builder.build_by_gtype gtype
-      _(found_klass).must_equal klass
-    end
-
-    it "returns the class for user-defined types not derived from GObject" do
-      klass = Class.new Regress::TestFundamentalObject
-      Object.const_set "Derived#{Sequence.next}", klass
-      gtype = GirFFI.define_type klass
-
-      found_klass = GirFFI::Builder.build_by_gtype gtype
-      _(found_klass).must_equal klass
-    end
-
-    it "returns a valid class for boxed classes unknown to GIR" do
-      object_class = GIMarshallingTests::PropertiesObject.object_class
-      property = object_class.find_property "some-boxed-glist"
-      gtype = property.value_type
-
-      _(gtype).wont_equal GObject::TYPE_NONE
-
-      found_klass = GirFFI::Builder.build_by_gtype gtype
-      _(found_klass.name).must_be_nil
-      _(found_klass.superclass).must_equal GirFFI::BoxedBase
-    end
-
-    it "refuse to build classes for base types" do
-      _(-> { GirFFI::Builder.build_by_gtype GObject::TYPE_INT })
-        .must_raise RuntimeError, "Unable to handle type gint"
-    end
-  end
-
-  describe ".attach_ffi_function" do
-    let(:lib) { Module.new }
-
-    it "calls attach_function with the correct types for Regress.test_callback_destroy_notify" do
-      function_info = get_introspection_data "Regress", "test_callback_destroy_notify"
-
-      expect(lib)
-        .to receive(:attach_function)
-        .with("regress_test_callback_destroy_notify",
-              [Regress::TestCallbackUserData, :pointer, GLib::DestroyNotify],
-              :int32)
-        .and_return true
-
-      GirFFI::Builder.attach_ffi_function(lib, function_info)
-    end
-
-    it "calls attach_function with the correct types for Regress::TestObj#torture_signature_0" do
-      info = get_method_introspection_data "Regress", "TestObj", "torture_signature_0"
-
-      expect(lib)
-        .to receive(:attach_function)
-        .with("regress_test_obj_torture_signature_0",
-              [:pointer, :int32, :pointer, :pointer, :pointer, :pointer, :uint32],
-              :void)
-        .and_return true
-
-      GirFFI::Builder.attach_ffi_function(lib, info)
-    end
-
-    it "calls attach_function with the correct types for Regress::TestObj#instance_method" do
-      info = get_method_introspection_data "Regress", "TestObj", "instance_method"
-      expect(lib).to receive(:attach_function)
-        .with("regress_test_obj_instance_method", [:pointer], :int32)
-        .and_return true
-      GirFFI::Builder.attach_ffi_function(lib, info)
-    end
-
-    it "calls attach_function with the correct types for Regress.test_array_gint32_in" do
-      info = get_introspection_data "Regress", "test_array_gint32_in"
-      expect(lib).to receive(:attach_function)
-        .with("regress_test_array_gint32_in", [:int32, :pointer], :int32)
-        .and_return true
-      GirFFI::Builder.attach_ffi_function(lib, info)
-    end
-
-    it "calls attach_function with the correct types for Regress.test_enum_param" do
-      info = get_introspection_data "Regress", "test_enum_param"
-      expect(lib).to receive(:attach_function)
-        .with("regress_test_enum_param", [Regress::TestEnum], :pointer)
-        .and_return true
-      GirFFI::Builder.attach_ffi_function(lib, info)
-    end
-
-    it "does not attach the function if it is already defined" do
-      info = get_introspection_data "Regress", "test_array_gint32_in"
-      allow(lib).to receive(:method_defined?).and_return true
-      expect(lib).not_to receive(:attach_function)
-      GirFFI::Builder.attach_ffi_function(lib, info)
-    end
-  end
-
-  #
-  # NOTE: Legacy tests below.
-  #
-
-  describe "looking at Regress.test_callback_destroy_notify" do
-    before do
-      save_module :GObject
-      save_module :Regress
-      GirFFI::Builder.build_module "GObject"
-      GirFFI::Builder.build_module "Regress"
-      @go = get_introspection_data "Regress", "test_callback_destroy_notify"
-    end
-
-    it "defines ffi callback types :Callback and :ClosureNotify" do
-      Regress.setup_method! "test_callback_destroy_notify"
-      tcud = Regress::Lib.find_type :TestCallbackUserData
-      dn = GLib::Lib.find_type :DestroyNotify
-
-      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
-
-    after do
-      restore_module :Regress
-      restore_module :GObject
-    end
-  end
-
-  describe "building Regress::TestBoxed" do
-    before do
-      GirFFI::Builder.build_class get_introspection_data("Regress", "TestBoxed")
-    end
-
-    it "sets up #wrap" do
-      assert Regress::TestBoxed.respond_to? "wrap"
-    end
-
-    it "sets up #allocate" do
-      assert Regress::TestBoxed.respond_to? "allocate"
-    end
-  end
-
-  describe "built Regress module" do
-    before do
-      save_module :Regress
-      GirFFI::Builder.build_module "Regress"
-    end
-
-    it "autocreates singleton methods" do
-      refute_defines_singleton_method Regress, :test_uint
-      Regress.test_uint 31
-      assert_defines_singleton_method Regress, :test_uint
-    end
-
-    it "autocreates the TestObj class on first access" do
-      assert !Regress.const_defined?(:TestObj)
-      _(Regress::TestObj).must_be_instance_of Class
-      assert Regress.const_defined? :TestObj
-    end
-
-    it "knows its own module builder" do
-      _(Regress.gir_ffi_builder).must_be_instance_of GirFFI::Builders::ModuleBuilder
-    end
-
-    after do
-      restore_module :Regress
-    end
-  end
-
-  describe "having built Regress::TestObj" do
-    before do
-      GirFFI::Builder.build_class get_introspection_data("Regress", "TestObj")
-    end
-
-    it "C functions for called instance methods get attached to Regress::Lib" do
-      o = Regress::TestObj.new_from_file("foo")
-      o.instance_method
-      _(Regress::Lib).must_respond_to :regress_test_obj_instance_method
-    end
-
-    it "the built class knows its own GIR info" do
-      _(Regress::TestObj.gir_info.name).must_equal "TestObj"
-    end
-
-    it "the built class knows its own class builder" do
-      _(Regress::TestObj.gir_ffi_builder).must_be_instance_of GirFFI::Builders::ObjectBuilder
-    end
-  end
-
-  describe "built Regress::TestSubObj" do
-    it "inherits #set_bare from its superclass" do
-      o1 = Regress::TestSubObj.new
-      o1.set_bare(nil)
-      pass
-    end
-
-    it "overrides #instance_method" do
-      obj = Regress::TestObj.new_from_file("foo")
-      subobj = Regress::TestSubObj.new
-
-      _(obj.instance_method).must_equal(-1)
-      _(subobj.instance_method).must_equal 0
-    end
-  end
-
-  describe "building Regress::TestSubObj" do
-    before do
-      save_module :Regress
-      GirFFI::Builder.build_class get_introspection_data("Regress", "TestSubObj")
-    end
-
-    it "sets up the Regress namespace" do
-      assert Regress.const_defined? :Lib
-      assert Regress.respond_to? :gir_ffi_builder
-      assert Regress.const_defined? :GIR_FFI_BUILDER
-    end
-
-    it "creates the Regress::Lib module ready to attach functions from the shared library" do
-      expected = [gir.shared_library("Regress")]
-      assert_equal expected, Regress::Lib.ffi_libraries.map(&:name)
-    end
-
-    it "builds parent classes also" do
-      assert Regress.const_defined? :TestObj
-      assert Object.const_defined? :GObject
-      assert GObject.const_defined? :Object
-    end
-
-    it "sets up the inheritance chain" do
-      # Introduced in version 1.59.1
-      expected = if Regress::TestSubObj.find_property :boolean
-                   [Regress::TestSubObj,
-                    Regress::TestInterface,
-                    Regress::TestObj,
-                    GObject::Object]
-                 else
-                   [Regress::TestSubObj,
-                    Regress::TestObj,
-                    GObject::Object]
-                 end
-      _(Regress::TestSubObj.registered_ancestors).must_equal expected
-    end
-
-    it "creates a Regress::TestSubObj#to_ptr method" do
-      assert Regress::TestSubObj.public_method_defined? :to_ptr
-    end
-
-    after do
-      restore_module :Regress
-    end
-  end
-end