gir_ffi 0.14.0 → 0.15.3

data/test/gir_ffi/arg_helper_test.rb

@@ -1,140 +1,146 @@
 # frozen_string_literal: true
 
-require 'gir_ffi_test_helper'
+require "gir_ffi_test_helper"
 
 describe GirFFI::ArgHelper do
-  describe '.cast_from_pointer' do
-    it 'handles class types' 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
+      _(GirFFI::ArgHelper.cast_from_pointer(klass, :pointer_value))
+        .must_equal :wrapped_value
     end
 
-    describe 'for :gint8' do
-      it 'handles negative :gint8' do
+    describe "for :gint8" do
+      it "handles negative :gint8" do
         ptr = FFI::Pointer.new(-127)
-        GirFFI::ArgHelper.cast_from_pointer(:gint8, ptr).must_equal(-127)
+        _(GirFFI::ArgHelper.cast_from_pointer(:gint8, ptr)).must_equal(-127)
       end
 
-      it 'handles positive :gint8' do
+      it "handles positive :gint8" do
         ptr = FFI::Pointer.new(128)
-        GirFFI::ArgHelper.cast_from_pointer(:gint8, ptr).must_equal(128)
+        _(GirFFI::ArgHelper.cast_from_pointer(:gint8, ptr)).must_equal(128)
       end
     end
 
-    it 'handles :guint32' do
+    it "handles :guint32" do
       ptr = FFI::Pointer.new(0xffffffff)
-      GirFFI::ArgHelper.cast_from_pointer(:guint32, ptr).must_equal(0xffffffff)
+      _(GirFFI::ArgHelper.cast_from_pointer(:guint32, ptr)).must_equal(0xffffffff)
     end
 
-    describe 'for :gint32' do
-      it 'handles positive :gint32' do
+    describe "for :gint32" do
+      it "handles positive :gint32" do
         ptr = FFI::Pointer.new(1)
-        GirFFI::ArgHelper.cast_from_pointer(:gint32, ptr).must_equal(1)
+        _(GirFFI::ArgHelper.cast_from_pointer(:gint32, ptr)).must_equal(1)
       end
 
-      it 'handles negative :gint32' do
+      it "handles negative :gint32" do
         ptr = FFI::Pointer.new(0xffffffff)
-        GirFFI::ArgHelper.cast_from_pointer(:gint32, ptr).must_equal(-1)
+        _(GirFFI::ArgHelper.cast_from_pointer(:gint32, ptr)).must_equal(-1)
       end
 
-      it 'handles largest negative :gint32' do
+      it "handles largest negative :gint32" do
         ptr = FFI::Pointer.new(0x80000000)
-        GirFFI::ArgHelper.cast_from_pointer(:gint32, ptr).must_equal(-0x80000000)
+        _(GirFFI::ArgHelper.cast_from_pointer(:gint32, ptr)).must_equal(-0x80000000)
       end
 
-      it 'handles largest positive :gint32' do
+      it "handles largest positive :gint32" do
         ptr = FFI::Pointer.new(0x7fffffff)
-        GirFFI::ArgHelper.cast_from_pointer(:gint32, ptr).must_equal(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'
+    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'
+    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
+    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
+      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
+    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"
+        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
+      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]"
+        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
+      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]"
+        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
+      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]]"
+        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?
+  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'
+    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
+        _(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')
+  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 = lambda do
-        GirFFI::ArgHelper.check_fixed_array_size(3, [1, 2], 'foo')
-      end.must_raise ArgumentError
-      result.message.must_equal 'foo should have size 3'
+    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)
+  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
+    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
+      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 +1,43 @@
 # frozen_string_literal: true
 
-require 'gir_ffi_test_helper'
+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
+  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
+  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
+    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
+  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
+    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
+    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
+    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
+  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,44 +1,44 @@
 # frozen_string_literal: true
 
-require 'gir_ffi_test_helper'
+require "gir_ffi_test_helper"
 
 GirFFI.setup :GIMarshallingTests
 
 describe GirFFI::BoxedBase do
-  describe 'initialize' do
-    it 'sets up the held struct pointer' 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
+      _(value.to_ptr).wont_be_nil
     end
   end
 
-  describe 'copy_from' do
-    it 'returns a copy with owned false' do
+  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?
+      _(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
+  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?
+      _(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?
+  describe "upon garbage collection" do
+    it "frees and disowns the underlying struct if it is owned" do
+      skip "cannot be reliably tested on JRuby" if jruby?
 
       allow(GObject).to receive(:boxed_free)
       gtype = GIMarshallingTests::BoxedStruct.gtype
@@ -59,7 +59,7 @@ describe GirFFI::BoxedBase do
 
       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?
+      _(owned_struct).wont_be :owned?
     end
   end
 end

data/test/gir_ffi/builder_test.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-require 'gir_ffi_test_helper'
+require "gir_ffi_test_helper"
 
 GirFFI.setup :Regress
 GirFFI.setup :GIMarshallingTests
@@ -8,29 +8,29 @@ GirFFI.setup :GIMarshallingTests
 describe GirFFI::Builder do
   let(:gir) { GObjectIntrospection::IRepository.default }
 
-  describe '.build_class' do
-    it 'does not replace existing classes' do
+  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
+      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'
+  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
+    describe "building a module for the first time" do
       before do
         save_module :Regress
-        GirFFI::Builder.build_module 'Regress'
+        GirFFI::Builder.build_module "Regress"
       end
 
-      it 'creates a Lib module ready to attach functions from the shared library' do
+      it "creates a Lib module ready to attach functions from the shared library" do
         gir = GObjectIntrospection::IRepository.default
-        expected = [gir.shared_library('Regress')]
+        expected = [gir.shared_library("Regress")]
         assert_equal expected, Regress::Lib.ffi_libraries.map(&:name)
       end
 
@@ -39,262 +39,130 @@ describe GirFFI::Builder do
       end
     end
 
-    describe 'building a module that already exists' do
-      it 'does not replace the existing module' do
+    describe "building a module that already exists" do
+      it "does not replace the existing module" do
         oldmodule = Regress
-        GirFFI::Builder.build_module 'Regress'
+        GirFFI::Builder.build_module "Regress"
         assert_equal oldmodule, Regress
       end
 
-      it 'does not replace the existing Lib module' do
+      it "does not replace the existing Lib module" do
         oldmodule = Regress::Lib
-        GirFFI::Builder.build_module 'Regress'
+        GirFFI::Builder.build_module "Regress"
         assert_equal oldmodule, Regress::Lib
       end
     end
 
-    it 'passes the version on to ModuleBuilder' do
+    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
+      expect(GirFFI::Builders::ModuleBuilder).to receive(:new)
+        .with("Foo", namespace: "Foo", version: "1.0")
+        .and_return builder
 
-      GirFFI::Builder.build_module 'Foo', '1.0'
+      GirFFI::Builder.build_module "Foo", "1.0"
     end
   end
 
-  describe '.build_by_gtype' do
-    it 'returns the class types known to the GIR' do
+  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
+      _(result).must_equal GObject::Object
     end
 
-    it 'returns the class for user-defined types' do
+    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
+      _(found_klass).must_equal klass
     end
 
-    it 'returns a valid class for boxed classes unknown to GIR' do
+    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'
+      property = object_class.find_property "some-boxed-glist"
       gtype = property.value_type
 
-      gtype.wont_equal GObject::TYPE_NONE
+      _(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
+      _(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
+  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'
+    it "attaches regress_test_callback_destroy_notify with the correct types" 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
+      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'
+    it "attaches regress_test_obj_torture_signature_0 with the correct types" 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
+      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
+    it "attaches regress_test_obj_instance_method with the correct types" 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
+    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
+    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'
+    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
-      Regress::TestSubObj.registered_ancestors.
-        must_equal [Regress::TestSubObj,
-                    Regress::TestObj,
-                    GObject::Object]
-    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