gir_ffi 0.15.1 → 0.15.6

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,241 +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 }
-
-    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
-          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
-          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
-          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
-          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
-          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
-          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
-          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
-          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
-          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
-          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 }
-
-    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 }
-
-    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,166 +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
-
-      exception = _(proc { klass.setup_and_call :foo, [] }).must_raise(NoMethodError)
-      _(exception.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
-
-      exception = _(proc { obj.setup_and_call :foo, [] }).must_raise(NoMethodError)
-      _(exception.message).must_match(/^undefined method `foo' for/)
-    end
-  end
-end