gir_ffi 0.14.1 → 0.15.4

data/test/gir_ffi/builders/vfunc_argument_builder_test.rb

@@ -1,101 +0,0 @@
-# frozen_string_literal: true
-
-require 'gir_ffi_test_helper'
-
-describe GirFFI::Builders::VFuncArgumentBuilder do
-  let(:var_gen) { GirFFI::VariableNameGenerator.new }
-  let(:builder) { GirFFI::Builders::VFuncArgumentBuilder.new(var_gen, arg_info) }
-
-  describe 'for a plain in argument' do
-    let(:vfunc_info) do
-      get_vfunc_introspection_data 'GIMarshallingTests', 'Object', 'method_int8_in'
-    end
-    let(:arg_info) { vfunc_info.args[0] }
-
-    it 'has the correct value for #pre_conversion' do
-      builder.pre_conversion.must_equal ['_v1 = in_']
-    end
-
-    it 'has the correct value for #post_conversion' do
-      builder.post_conversion.must_equal []
-    end
-  end
-
-  describe 'for a transfer-none in argument' do
-    let(:vfunc_info) do
-      get_vfunc_introspection_data 'GIMarshallingTests', 'Object', 'vfunc_in_object_transfer_none'
-    end
-    let(:arg_info) { vfunc_info.args[0] }
-
-    it 'has the correct value for #pre_conversion' do
-      builder.pre_conversion.must_equal ['_v1 = GObject::Object.wrap(object)', '_v1.ref']
-    end
-
-    it 'has the correct value for #post_conversion' do
-      builder.post_conversion.must_equal []
-    end
-  end
-
-  describe 'for a transfer-none outgoing object argument' do
-    let(:vfunc_info) do
-      get_vfunc_introspection_data 'GIMarshallingTests', 'Object', 'vfunc_out_object_transfer_none'
-    end
-    let(:arg_info) { vfunc_info.args[0] }
-
-    it 'has the correct value for #pre_conversion' do
-      builder.pre_conversion.must_equal ['_v1 = object']
-    end
-
-    it 'has the correct value for #post_conversion' do
-      builder.post_conversion.must_equal ['_v1.put_pointer 0, GObject::Object.from(_v2)']
-    end
-  end
-
-  describe 'for a full-transfer outgoing object argument' do
-    let(:vfunc_info) do
-      get_vfunc_introspection_data 'GIMarshallingTests', 'Object', 'vfunc_out_object_transfer_full'
-    end
-    let(:arg_info) { vfunc_info.args[0] }
-
-    it 'has the correct value for #pre_conversion' do
-      builder.pre_conversion.must_equal ['_v1 = object']
-    end
-
-    it 'has the correct value for #post_conversion' do
-      builder.pre_conversion
-      builder.post_conversion.must_equal ['_v2.ref', '_v1.put_pointer 0, GObject::Object.from(_v2)']
-    end
-  end
-
-  describe 'for a full-transfer outgoing non-object argument' do
-    let(:vfunc_info) do
-      get_vfunc_introspection_data('GIMarshallingTests', 'Object',
-                                   'method_int8_arg_and_out_callee')
-    end
-    let(:arg_info) { vfunc_info.args[1] }
-
-    it 'has the correct value for #pre_conversion' do
-      builder.pre_conversion.
-        must_equal ['_v1 = FFI::MemoryPointer.new(:int8).tap { |ptr| out.put_pointer 0, ptr }']
-    end
-
-    it 'has the correct value for #post_conversion' do
-      builder.post_conversion.must_equal ['_v1.put_int8 0, _v2']
-    end
-  end
-
-  describe 'for a receiver argument' do
-    let(:object_info) { get_introspection_data('GIMarshallingTests', 'Object') }
-    let(:type_info) { GirFFI::ReceiverTypeInfo.new(object_info) }
-    let(:arg_info) { GirFFI::ReceiverArgumentInfo.new(type_info) }
-
-    it 'has the correct value for #pre_conversion' do
-      builder.pre_conversion.
-        must_equal ['_v1 = GIMarshallingTests::Object.wrap(_instance)']
-    end
-
-    it 'has the correct value for #post_conversion' do
-      builder.post_conversion.must_equal []
-    end
-  end
-end

data/test/gir_ffi/builders/vfunc_builder_test.rb

@@ -1,253 +0,0 @@
-# frozen_string_literal: true
-
-require 'gir_ffi_test_helper'
-
-describe GirFFI::Builders::VFuncBuilder do
-  let(:builder) { GirFFI::Builders::VFuncBuilder.new vfunc_info }
-
-  describe '#mapping_method_definition' do
-    let(:result) { builder.mapping_method_definition }
-
-    before do
-      skip unless vfunc_info
-    end
-
-    describe 'for a vfunc with only one argument' do
-      let(:vfunc_info) do
-        get_vfunc_introspection_data 'GIMarshallingTests', 'Object', 'method_int8_in'
-      end
-
-      it 'returns a valid mapping method including receiver' do
-        expected = <<-CODE.reset_indentation
-        def self.call_with_argument_mapping(_proc, _instance, in_)
-          _v1 = GIMarshallingTests::Object.wrap(_instance)
-          _v2 = in_
-          _proc.call(_v1, _v2)
-        end
-        CODE
-
-        result.must_equal expected
-      end
-    end
-
-    describe 'for a vfunc returning an enum' do
-      let(:vfunc_info) do
-        get_vfunc_introspection_data 'GIMarshallingTests', 'Object', 'vfunc_return_enum'
-      end
-
-      it 'returns a valid mapping method including receiver' do
-        expected = <<-CODE.reset_indentation
-        def self.call_with_argument_mapping(_proc, _instance)
-          _v1 = GIMarshallingTests::Object.wrap(_instance)
-          _v2 = _proc.call(_v1)
-          _v3 = GIMarshallingTests::Enum.to_int(_v2)
-          return _v3
-        end
-        CODE
-
-        result.must_equal expected
-      end
-    end
-
-    describe 'for a vfunc with a callback argument' do
-      let(:vfunc_info) do
-        get_vfunc_introspection_data 'GIMarshallingTests', 'Object', 'vfunc_with_callback'
-      end
-
-      it 'returns a valid mapping method including receiver' do
-        expected = <<-CODE.reset_indentation
-        def self.call_with_argument_mapping(_proc, _instance, callback, callback_data)
-          _v1 = GIMarshallingTests::Object.wrap(_instance)
-          _v2 = GIMarshallingTests::CallbackIntInt.wrap(callback)
-          _v3 = GirFFI::ArgHelper::OBJECT_STORE.fetch(callback_data)
-          _proc.call(_v1, _v2, _v3)
-        end
-        CODE
-
-        result.must_equal expected
-      end
-    end
-
-    describe 'for a vfunc with an out argument allocated by them, the caller' do
-      let(:vfunc_info) do
-        get_vfunc_introspection_data('GIMarshallingTests', 'Object',
-                                     'method_int8_arg_and_out_caller')
-      end
-
-      it 'returns a valid mapping method including receiver' do
-        expected = <<-CODE.reset_indentation
-        def self.call_with_argument_mapping(_proc, _instance, arg, out)
-          _v1 = GIMarshallingTests::Object.wrap(_instance)
-          _v2 = arg
-          _v3 = out
-          _v4 = _proc.call(_v1, _v2)
-          _v3.put_int8 0, _v4
-        end
-        CODE
-
-        result.must_equal expected
-      end
-    end
-
-    describe 'for a vfunc with an out argument allocated by us, the callee' do
-      let(:vfunc_info) do
-        get_vfunc_introspection_data('GIMarshallingTests', 'Object',
-                                     'method_int8_arg_and_out_callee')
-      end
-
-      it 'returns a valid mapping method including receiver' do
-        expected = <<-CODE.reset_indentation
-        def self.call_with_argument_mapping(_proc, _instance, arg, out)
-          _v1 = GIMarshallingTests::Object.wrap(_instance)
-          _v2 = arg
-          _v3 = FFI::MemoryPointer.new(:int8).tap { |ptr| out.put_pointer 0, ptr }
-          _v4 = _proc.call(_v1, _v2)
-          _v3.put_int8 0, _v4
-        end
-        CODE
-
-        result.must_equal expected
-      end
-    end
-
-    describe 'for a vfunc with a GObject::Value out argument allocated by them, the caller' do
-      let(:vfunc_info) do
-        get_vfunc_introspection_data('GIMarshallingTests', 'Object',
-                                     'vfunc_caller_allocated_out_parameter')
-      end
-
-      it 'returns a valid mapping method including receiver' do
-        expected = <<-CODE.reset_indentation
-        def self.call_with_argument_mapping(_proc, _instance, a)
-          _v1 = GIMarshallingTests::Object.wrap(_instance)
-          _v2 = a
-          _v3 = _proc.call(_v1)
-          GObject::Value.copy_value_to_pointer(GObject::Value.from(_v3), _v2)
-        end
-        CODE
-
-        result.must_equal expected
-      end
-    end
-
-    describe 'for a vfunc with an error argument' do
-      let(:vfunc_info) do
-        get_vfunc_introspection_data('GIMarshallingTests', 'Object',
-                                     'vfunc_meth_with_err')
-      end
-
-      it 'returns a valid mapping method including receiver' do
-        expected = <<-CODE.reset_indentation
-        def self.call_with_argument_mapping(_proc, _instance, x, _error)
-          _v1 = GIMarshallingTests::Object.wrap(_instance)
-          _v2 = x
-          _v3 = _error
-          begin
-          _v4 = _proc.call(_v1, _v2)
-          rescue => _v5
-          _v3.put_pointer 0, GLib::Error.from(_v5)
-          end
-          return _v4
-        end
-        CODE
-
-        result.must_equal expected
-      end
-    end
-
-    describe 'for a vfunc with a full-transfer return value' do
-      let(:vfunc_info) do
-        get_vfunc_introspection_data 'GIMarshallingTests', 'Object', 'vfunc_return_object_transfer_full'
-      end
-
-      it 'returns a valid mapping method' do
-        expected = <<-CODE.reset_indentation
-        def self.call_with_argument_mapping(_proc, _instance)
-          _v1 = GIMarshallingTests::Object.wrap(_instance)
-          _v2 = _proc.call(_v1)
-          _v2.ref
-          _v3 = GObject::Object.from(_v2).to_ptr
-          return _v3
-        end
-        CODE
-
-        result.must_equal expected
-      end
-    end
-
-    describe 'for a vfunc with a transfer-none in argument' do
-      let(:vfunc_info) do
-        get_vfunc_introspection_data 'GIMarshallingTests', 'Object', 'vfunc_in_object_transfer_none'
-      end
-
-      it 'returns a valid mapping method' do
-        expected = <<-CODE.reset_indentation
-        def self.call_with_argument_mapping(_proc, _instance, object)
-          _v1 = GIMarshallingTests::Object.wrap(_instance)
-          _v2 = GObject::Object.wrap(object)
-          _v2.ref
-          _proc.call(_v1, _v2)
-        end
-        CODE
-
-        result.must_equal expected
-      end
-    end
-
-    describe 'for a vfunc with a full-transfer outgoing argument' do
-      let(:vfunc_info) do
-        get_vfunc_introspection_data 'GIMarshallingTests', 'Object', 'vfunc_out_object_transfer_full'
-      end
-
-      it 'returns a valid mapping method' do
-        expected = <<-CODE.reset_indentation
-        def self.call_with_argument_mapping(_proc, _instance, object)
-          _v1 = GIMarshallingTests::Object.wrap(_instance)
-          _v2 = object
-          _v3 = _proc.call(_v1)
-          _v3.ref
-          _v2.put_pointer 0, GObject::Object.from(_v3)
-        end
-        CODE
-
-        result.must_equal expected
-      end
-    end
-  end
-
-  describe '#argument_ffi_types' do
-    let(:result) { builder.argument_ffi_types }
-
-    before do
-      skip unless vfunc_info
-    end
-
-    describe 'for a vfunc with only one argument' do
-      let(:vfunc_info) do
-        get_vfunc_introspection_data 'GIMarshallingTests', 'Object', 'method_int8_in'
-      end
-
-      it 'returns the correct FFI types including :pointer for the receiver' do
-        result.must_equal [:pointer, :int8]
-      end
-    end
-  end
-
-  describe '#return_ffi_type' do
-    let(:result) { builder.return_ffi_type }
-
-    before do
-      skip unless vfunc_info
-    end
-
-    describe 'for a vfunc returning an object' do
-      let(:vfunc_info) do
-        get_vfunc_introspection_data 'GIMarshallingTests', 'Object', 'vfunc_return_object_transfer_full'
-      end
-
-      it 'returns :pointer' do
-        result.must_equal :pointer
-      end
-    end
-  end
-end

data/test/gir_ffi/callback_base_test.rb

@@ -1,22 +0,0 @@
-# frozen_string_literal: true
-
-require 'gir_ffi_test_helper'
-
-describe GirFFI::CallbackBase do
-  describe '.store_callback' do
-    it 'stores the passed in proc in CALLBACKS' do
-      dummy_proc = 'some-callback'
-      GirFFI::CallbackBase.store_callback dummy_proc
-      GirFFI::CallbackBase::CALLBACKS[dummy_proc.object_id].must_equal dummy_proc
-    end
-  end
-
-  describe '.drop_callback' do
-    it 'removes the corresponding proc from CALLBACKS' do
-      dummy_proc = 'some-callback'
-      GirFFI::CallbackBase.store_callback dummy_proc
-      GirFFI::CallbackBase.drop_callback dummy_proc
-      GirFFI::CallbackBase::CALLBACKS[dummy_proc.object_id].must_be_nil
-    end
-  end
-end

data/test/gir_ffi/class_base_test.rb

@@ -1,168 +0,0 @@
-# frozen_string_literal: true
-
-require 'gir_ffi_test_helper'
-
-describe GirFFI::ClassBase do
-  describe 'a simple descendant' do
-    let(:object_class) do
-      Class.new(GirFFI::ClassBase) do
-        self::Struct = Class.new(GirFFI::Struct) do
-          layout :foo, :int32
-        end
-      end
-    end
-    let(:object) { object_class.wrap FFI::MemoryPointer.new(:int32) }
-
-    it 'has #from as a pass-through method' do
-      result = object_class.from :foo
-      result.must_equal :foo
-    end
-
-    describe '#==' do
-      it 'returns true when comparing to an object of the same class and pointer' do
-        other = object_class.wrap object.to_ptr
-
-        object.must_be :==, other
-        other.must_be :==, object
-      end
-
-      it 'returns true when comparing to an object of the same class and a pointer with the same address' do
-        ptr = FFI::Pointer.new object.to_ptr
-        other = object_class.wrap ptr
-
-        object.must_be :==, other
-        other.must_be :==, object
-      end
-
-      it 'returns false when comparing to an object of a sub/superclass and the same pointer' do
-        subclass = Class.new(object_class)
-        other = subclass.wrap object.to_ptr
-
-        object.wont_be :==, other
-        other.wont_be :==, object
-      end
-
-      it 'returns false when comparing to an object of the same class and different pointer' do
-        other = object_class.wrap FFI::MemoryPointer.new(:int32)
-
-        object.wont_be :==, other
-        other.wont_be :==, object
-      end
-
-      it "returns false when comparing to an object that doesn't respond to #to_ptr" do
-        other = Object.new
-
-        object.wont_be :==, other
-        other.wont_be :==, object
-      end
-
-      it 'returns false when comparing to an object of a different class and same pointer' do
-        allow(other = Object.new).to receive(:to_ptr).and_return object.to_ptr
-
-        object.wont_be :==, other
-        other.wont_be :==, object
-      end
-
-      it 'returns false when comparing to an object of a different class and different pointer' do
-        allow(other = Object.new).to receive(:to_ptr).and_return FFI::MemoryPointer.new(:int32)
-
-        object.wont_be :==, other
-        other.wont_be :==, object
-      end
-    end
-  end
-
-  describe '.setup_and_call' do
-    it 'looks up class methods in all builders' do
-      expect(builder = Object.new).to receive(:setup_method).with('foo').and_return 'foo'
-      klass = Class.new GirFFI::ClassBase
-      klass.const_set :GIR_FFI_BUILDER, builder
-
-      expect(sub_builder = Object.new).to receive(:setup_method).with('foo').and_return nil
-      sub_klass = Class.new klass do
-        def self.foo; end
-      end
-      sub_klass.const_set :GIR_FFI_BUILDER, sub_builder
-
-      sub_klass.setup_and_call :foo, []
-    end
-
-    it 'calls the method given by the result of .setup_method' do
-      expect(builder = Object.new).to receive(:setup_method).with('foo').and_return 'bar'
-      klass = Class.new GirFFI::ClassBase do
-        def self.bar
-          'correct-result'
-        end
-
-        def initialize; end
-      end
-      klass.const_set :GIR_FFI_BUILDER, builder
-
-      result = klass.setup_and_call :foo, []
-      result.must_equal 'correct-result'
-    end
-
-    it 'raises a sensible error if the method is not found' do
-      expect(builder = Object.new).to receive(:setup_method).with('foo').and_return nil
-      klass = Class.new GirFFI::ClassBase do
-        def initialize; end
-      end
-      klass.const_set :GIR_FFI_BUILDER, builder
-
-      proc { klass.setup_and_call :foo, [] }.
-        must_raise(NoMethodError).message.
-        must_match(/^undefined method `foo' for/)
-    end
-  end
-
-  describe '#setup_and_call' do
-    it 'looks up instance methods in all builders' do
-      expect(builder = Object.new).to receive(:setup_instance_method).with('foo').and_return 'foo'
-      klass = Class.new GirFFI::ClassBase
-      klass.const_set :GIR_FFI_BUILDER, builder
-
-      expect(sub_builder = Object.new).to receive(:setup_instance_method).with('foo').and_return nil
-      sub_klass = Class.new klass do
-        def foo; end
-
-        def initialize; end
-      end
-      sub_klass.const_set :GIR_FFI_BUILDER, sub_builder
-
-      obj = sub_klass.new
-
-      obj.setup_and_call :foo, []
-    end
-
-    it 'calls the method given by the result of .setup_instance_method' do
-      expect(builder = Object.new).to receive(:setup_instance_method).with('foo').and_return 'bar'
-      klass = Class.new GirFFI::ClassBase do
-        def bar
-          'correct-result'
-        end
-
-        def initialize; end
-      end
-      klass.const_set :GIR_FFI_BUILDER, builder
-
-      obj = klass.new
-
-      result = obj.setup_and_call :foo, []
-      result.must_equal 'correct-result'
-    end
-
-    it 'raises a sensible error if the method is not found' do
-      expect(builder = Object.new).to receive(:setup_instance_method).with('foo').and_return nil
-      klass = Class.new GirFFI::ClassBase do
-        def initialize; end
-      end
-      klass.const_set :GIR_FFI_BUILDER, builder
-
-      obj = klass.new
-
-      proc { obj.setup_and_call :foo, [] }.
-        must_raise(NoMethodError).message.
-        must_match(/^undefined method `foo' for/)
-    end
-  end
-end