gir_ffi 0.14.1 → 0.15.4

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.reset_indentation
-          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.reset_indentation
-          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.reset_indentation
-          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.reset_indentation
-          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