gir_ffi 0.14.1 → 0.15.4

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,140 +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 = 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'
-    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,300 +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 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
-  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
-      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