gir_ffi 0.15.1 → 0.15.6

data/test/gir_ffi/info_ext/i_unresolved_info_test.rb

@@ -1,19 +0,0 @@
-# frozen_string_literal: true
-
-require "gir_ffi_test_helper"
-
-describe GirFFI::InfoExt::IUnresolvedInfo do
-  let(:info_class) do
-    Class.new do
-      include GirFFI::InfoExt::IUnresolvedInfo
-    end
-  end
-
-  let(:unresolved_info) { info_class.new }
-
-  describe "#to_ffi_type" do
-    it "returns the most generic type" do
-      _(unresolved_info.to_ffi_type).must_equal :pointer
-    end
-  end
-end

data/test/gir_ffi/info_ext/safe_constant_name_test.rb

@@ -1,26 +0,0 @@
-# frozen_string_literal: true
-
-require "gir_ffi_test_helper"
-
-describe GirFFI::InfoExt::SafeConstantName do
-  let(:info_class) do
-    Class.new do
-      include GirFFI::InfoExt::SafeConstantName
-    end
-  end
-  let(:info) { info_class.new }
-
-  describe "#safe_name" do
-    it "makes names starting with an underscore safe" do
-      expect(info).to receive(:name).and_return "_foo"
-
-      assert_equal "Private___foo", info.safe_name
-    end
-
-    it "makes names with dashes safe" do
-      expect(info).to receive(:name).and_return "this-could-be-a-signal-name"
-
-      _(info.safe_name).must_equal "This_could_be_a_signal_name"
-    end
-  end
-end

data/test/gir_ffi/info_ext/safe_function_name_test.rb

@@ -1,26 +0,0 @@
-# frozen_string_literal: true
-
-require "gir_ffi_test_helper"
-
-describe GirFFI::InfoExt::SafeFunctionName do
-  let(:info_class) do
-    Class.new do
-      include GirFFI::InfoExt::SafeFunctionName
-    end
-  end
-  let(:info) { info_class.new }
-
-  describe "#safe_name" do
-    it "keeps lower case names lower case" do
-      expect(info).to receive(:name).and_return "foo"
-
-      assert_equal "foo", info.safe_name
-    end
-
-    it "returns a non-empty string if name is empty" do
-      expect(info).to receive(:name).and_return ""
-
-      assert_equal "_", info.safe_name
-    end
-  end
-end

data/test/gir_ffi/interface_base_test.rb

@@ -1,20 +0,0 @@
-# frozen_string_literal: true
-
-require "gir_ffi_test_helper"
-
-describe GirFFI::InterfaceBase do
-  let(:interface) { Module.new { extend GirFFI::InterfaceBase } }
-
-  describe "#wrap" do
-    it "delegates conversion to the wrapped pointer" do
-      expect(ptr = Object.new).to receive(:to_object).and_return "good-result"
-      _(interface.wrap(ptr)).must_equal "good-result"
-    end
-  end
-
-  describe ".to_ffi_type" do
-    it "returns :pointer" do
-      _(interface.to_ffi_type).must_equal :pointer
-    end
-  end
-end

data/test/gir_ffi/method_stubber_test.rb

@@ -1,65 +0,0 @@
-# frozen_string_literal: true
-
-require "gir_ffi_test_helper"
-
-describe GirFFI::MethodStubber do
-  describe "#method_stub" do
-    let(:stubber) { GirFFI::MethodStubber.new(method_info) }
-    let(:result) { stubber.method_stub }
-
-    describe "for a regular method" do
-      let(:method_info) do
-        get_method_introspection_data("Regress", "TestObj", "instance_method")
-      end
-
-      it "creates a method stub" do
-        _(result).must_equal <<~STUB
-          def instance_method *args, &block
-            setup_and_call "instance_method", args, &block
-          end
-        STUB
-      end
-    end
-
-    describe "for a static method" do
-      let(:method_info) do
-        get_method_introspection_data("Regress", "TestObj", "static_method")
-      end
-
-      it "creates a class method stub" do
-        _(result).must_equal <<~STUB
-          def self.static_method *args, &block
-            setup_and_call "static_method", args, &block
-          end
-        STUB
-      end
-    end
-
-    describe "for a module function" do
-      let(:method_info) do
-        get_introspection_data("Regress", "test_int")
-      end
-
-      it "creates a module method stub" do
-        _(result).must_equal <<~STUB
-          def self.test_int *args, &block
-            setup_and_call "test_int", args, &block
-          end
-        STUB
-      end
-    end
-
-    describe "for a method with an empty name" do
-      let(:method_info) { get_method_introspection_data("Regress", "TestObj", "instance_method") }
-
-      it "creates a method stub with a safe name that sets up the unsafe method" do
-        allow(method_info).to receive(:name).and_return ""
-        _(result).must_equal <<~STUB
-          def _ *args, &block
-            setup_and_call "", args, &block
-          end
-        STUB
-      end
-    end
-  end
-end

data/test/gir_ffi/object_base_test.rb

@@ -1,64 +0,0 @@
-# frozen_string_literal: true
-
-require "gir_ffi_test_helper"
-
-GirFFI.setup :Regress
-
-describe GirFFI::ObjectBase do
-  let(:derived_class) { Class.new GirFFI::ObjectBase }
-
-  describe ".wrap" do
-    it "delegates conversion to the wrapped pointer" do
-      expect(ptr = Object.new).to receive(:to_object).and_return "good-result"
-      _(derived_class.wrap(ptr)).must_equal "good-result"
-    end
-  end
-
-  describe ".to_ffi_type" do
-    it "returns itself" do
-      _(derived_class.to_ffi_type).must_equal derived_class
-    end
-  end
-
-  describe ".object_class" do
-    it "returns an object of the class struct type" do
-      _(Regress::TestObj.object_class).must_be_instance_of Regress::TestObjClass
-    end
-
-    it "caches its result" do
-      first = Regress::TestObj.object_class
-      second = Regress::TestObj.object_class
-      _(second).must_be :eql?, first
-    end
-  end
-
-  describe "#included_interfaces" do
-    let(:base_class) { GIMarshallingTests::Object }
-    let(:derived_class) { Class.new(base_class) }
-
-    before do
-      derived_class.class_eval { include GIMarshallingTests::Interface }
-    end
-
-    it "finds the included interface" do
-      _(derived_class.included_interfaces).must_equal [GIMarshallingTests::Interface]
-    end
-  end
-
-  describe "#registered_ancestors" do
-    let(:base_class) { GIMarshallingTests::Object }
-    let(:derived_class) { Class.new(base_class) }
-
-    before do
-      derived_class.class_eval { include GIMarshallingTests::Interface }
-    end
-
-    it "finds the ancestor classes and included interface" do
-      _(derived_class.registered_ancestors)
-        .must_equal [derived_class,
-                     GIMarshallingTests::Interface,
-                     GIMarshallingTests::Object,
-                     GObject::Object]
-    end
-  end
-end

data/test/gir_ffi/object_store_test.rb

@@ -1,41 +0,0 @@
-# frozen_string_literal: true
-
-require "gir_ffi_test_helper"
-
-describe GirFFI::ObjectStore do
-  let(:store) { GirFFI::ObjectStore.new }
-
-  describe "#store" do
-    it "returns a non-null pointer when storing objects" do
-      obj = Object.new
-      ptr = store.store obj
-      _(ptr).wont_be :null?
-    end
-
-    it "returns a null pointer when storing nil" do
-      ptr = store.store nil
-      _(ptr).must_be :null?
-    end
-  end
-
-  describe "#fetch" do
-    it "returns the stored object when passed the key pointer" do
-      obj = Object.new
-      ptr = store.store obj
-      result = store.fetch ptr
-      _(result).must_equal obj
-    end
-
-    it "returns the nil object when passed a null pointer" do
-      ptr = FFI::Pointer.new(0)
-      result = store.fetch ptr
-      _(result).must_be_nil
-    end
-
-    it "returns the pointer itself when passed an unknown pointer" do
-      ptr = FFI::Pointer.new(42)
-      result = store.fetch ptr
-      _(result).must_equal ptr
-    end
-  end
-end

data/test/gir_ffi/receiver_argument_info_test.rb

@@ -1,33 +0,0 @@
-# frozen_string_literal: true
-
-require "gir_ffi_test_helper"
-require "gir_ffi/receiver_argument_info"
-
-describe GirFFI::ReceiverArgumentInfo do
-  let(:dummy_type) { "foo" }
-  let(:instance) { GirFFI::ReceiverArgumentInfo.new dummy_type }
-
-  describe "#argument_type" do
-    it "returns the argument type" do
-      _(instance.argument_type).must_equal dummy_type
-    end
-  end
-
-  describe "#direction" do
-    it "returns the correct value" do
-      _(instance.direction).must_equal :in
-    end
-  end
-
-  describe "#ownership_transfer" do
-    it "returns the correct value" do
-      _(instance.ownership_transfer).must_equal :everything
-    end
-  end
-
-  describe "#name" do
-    it "returns the correct value" do
-      _(instance.name).must_equal "_instance"
-    end
-  end
-end

data/test/gir_ffi/sized_array_test.rb

@@ -1,206 +0,0 @@
-# frozen_string_literal: true
-
-require "gir_ffi_test_helper"
-
-describe GirFFI::SizedArray do
-  describe "::wrap" do
-    it "takes a type, size and pointer and returns a GirFFI::SizedArray wrapping them" do
-      expect(ptr = Object.new).to receive(:null?).and_return false
-      sarr = GirFFI::SizedArray.wrap :gint32, 3, ptr
-      assert_instance_of GirFFI::SizedArray, sarr
-      assert_equal ptr, sarr.to_ptr
-      assert_equal 3, sarr.size
-      assert_equal :gint32, sarr.element_type
-    end
-
-    it "returns nil if the wrapped pointer is null" do
-      expect(ptr = Object.new).to receive(:null?).and_return true
-      sarr = GirFFI::SizedArray.wrap :gint32, 3, ptr
-      _(sarr).must_be_nil
-    end
-  end
-
-  describe "#each" do
-    it "yields each element" do
-      ary = %w(one two three)
-      ptrs = ary.map { |a| FFI::MemoryPointer.from_string(a) }
-      ptrs << nil
-      block = FFI::MemoryPointer.new(:pointer, ptrs.length)
-      block.write_array_of_pointer ptrs
-
-      sarr = GirFFI::SizedArray.new :utf8, 3, block
-      arr = []
-      sarr.each do |str|
-        arr << str
-      end
-      assert_equal %w(one two three), arr
-    end
-  end
-
-  describe "::from" do
-    describe "from a Ruby array" do
-      it "creates a GirFFI::SizedArray with the same elements" do
-        arr = GirFFI::SizedArray.from :gint32, 3, [3, 2, 1]
-        _(arr).must_be_instance_of GirFFI::SizedArray
-        assert_equal [3, 2, 1], arr.to_a
-      end
-
-      it "raises an error if the array has the wrong number of elements" do
-        _(proc { GirFFI::SizedArray.from :gint32, 4, [3, 2, 1] }).must_raise ArgumentError
-      end
-
-      it "uses the array's size if passed -1 as the size" do
-        arr = GirFFI::SizedArray.from :gint32, -1, [3, 2, 1]
-        _(arr.size).must_equal 3
-      end
-    end
-
-    describe "from a GirFFI::SizedArray" do
-      it "return its argument" do
-        arr = GirFFI::SizedArray.from :gint32, 3, [3, 2, 1]
-        arr2 = GirFFI::SizedArray.from :gint32, 3, arr
-        assert_equal arr, arr2
-      end
-
-      it "raises an error if the argument has the wrong number of elements" do
-        arr = GirFFI::SizedArray.from :gint32, 3, [3, 2, 1]
-        _(proc { GirFFI::SizedArray.from :gint32, 4, arr }).must_raise ArgumentError
-      end
-    end
-
-    it "returns nil when passed nil" do
-      arr = GirFFI::SizedArray.from :gint32, 0, nil
-      _(arr).must_be_nil
-    end
-
-    it "wraps its argument if given a pointer" do
-      arr = GirFFI::SizedArray.from :gint32, 3, [3, 2, 1]
-      arr2 = GirFFI::SizedArray.from :gint32, 3, arr.to_ptr
-      assert_instance_of GirFFI::SizedArray, arr2
-      refute arr2.equal? arr
-      _(arr2.to_ptr).must_equal arr.to_ptr
-    end
-  end
-
-  describe ".copy_from" do
-    describe "from a Ruby array" do
-      it "creates an unowned GirFFI::SizedArray with the same elements" do
-        arr = GirFFI::SizedArray.copy_from :gint32, 3, [3, 2, 1]
-        _(arr).must_be_instance_of GirFFI::SizedArray
-        assert_equal [3, 2, 1], arr.to_a
-        _(arr.to_ptr).wont_be :autorelease?
-      end
-
-      it "creates unowned copies of struct pointer elements" do
-        struct = GIMarshallingTests::BoxedStruct.new
-        struct.long_ = 2342
-        _(struct.struct).must_be :owned?
-
-        arr = GirFFI::SizedArray.copy_from([:pointer, GIMarshallingTests::BoxedStruct],
-                                           1,
-                                           [struct])
-        _(arr).must_be_instance_of GirFFI::SizedArray
-        _(arr.to_ptr).wont_be :autorelease?
-
-        struct_copy = arr.first
-        _(struct_copy.long_).must_equal struct.long_
-        _(struct_copy.to_ptr).wont_be :==, struct.to_ptr
-        _(struct_copy.struct).wont_be :owned?
-      end
-
-      it "increases the ref count of object pointer elements" do
-        obj = GIMarshallingTests::Object.new 42
-        arr = GirFFI::SizedArray.copy_from([:pointer, GIMarshallingTests::Object],
-                                           -1,
-                                           [obj, nil])
-        _(arr).must_be_instance_of GirFFI::SizedArray
-        _(arr.to_ptr).wont_be :autorelease?
-
-        _(arr.to_a).must_equal [obj, nil]
-        _(object_ref_count(obj)).must_equal 2
-      end
-    end
-
-    describe "from a GirFFI::SizedArray" do
-      it "return an unowned copy of its argument" do
-        arr = GirFFI::SizedArray.from :gint32, 3, [3, 2, 1]
-        arr2 = GirFFI::SizedArray.copy_from :gint32, 3, arr
-        _(arr.to_ptr).wont_be :==, arr2.to_ptr
-        _(arr2.to_a).must_equal [3, 2, 1]
-        _(arr2.to_ptr).wont_be :autorelease?
-      end
-    end
-
-    it "returns nil when passed nil" do
-      arr = GirFFI::SizedArray.copy_from :gint32, 0, nil
-      _(arr).must_be_nil
-    end
-  end
-
-  describe "#==" do
-    it "returns true when comparing to an array with the same elements" do
-      sized = GirFFI::SizedArray.from :int32, 3, [1, 2, 3]
-
-      _(sized).must_be :==, [1, 2, 3]
-    end
-
-    it "returns false when comparing to an array with different elements" do
-      sized = GirFFI::SizedArray.from :int32, 3, [1, 2, 3]
-
-      _(sized).wont_be :==, [1, 2]
-    end
-
-    it "returns true when comparing to a sized array with the same elements" do
-      sized = GirFFI::SizedArray.from :int32, 3, [1, 2, 3]
-      other = GirFFI::SizedArray.from :int32, 3, [1, 2, 3]
-
-      _(sized).must_be :==, other
-    end
-
-    it "returns false when comparing to a sized array with different elements" do
-      sized = GirFFI::SizedArray.from :int32, 3, [1, 2, 3]
-      other = GirFFI::SizedArray.from :int32, 2, [1, 2]
-
-      _(sized).wont_be :==, other
-    end
-  end
-
-  describe "#size_in_bytes" do
-    it "returns the correct value" do
-      sized = GirFFI::SizedArray.from :int32, 3, [1, 2, 3]
-
-      _(sized.size_in_bytes).must_equal 12
-    end
-  end
-
-  describe ".get_value_from_pointer" do
-    it "returns just a pointer" do
-      sized = GirFFI::SizedArray.from :int32, 3, [1, 2, 3]
-      ptr = sized.to_ptr
-      result = GirFFI::SizedArray.get_value_from_pointer(ptr, 0)
-      _(result).must_be :==, ptr
-    end
-
-    it "offsets correctly" do
-      sized = GirFFI::SizedArray.from :int32, 3, [1, 2, 3]
-      ptr = sized.to_ptr
-      next_ptr = GirFFI::SizedArray.get_value_from_pointer(ptr, 4)
-      tail = GirFFI::SizedArray.from(:int32, 2, next_ptr)
-      _(tail).must_be :==, [2, 3]
-    end
-  end
-
-  describe ".copy_value_to_pointer" do
-    it "copies data correctly" do
-      sized = GirFFI::SizedArray.from :int32, 3, [1, 2, 3]
-      target = FFI::MemoryPointer.new sized.size_in_bytes
-      GirFFI::SizedArray.copy_value_to_pointer(sized, target)
-      result = GirFFI::SizedArray.from :int32, 3, target
-      _(result).must_be :==, [1, 2, 3]
-    end
-  end
-
-  it "includes Enumerable" do
-    _(GirFFI::SizedArray).must_include Enumerable
-  end
-end