gir_ffi 0.14.1 → 0.15.4

data/test/gir_ffi/core_test.rb

@@ -1,98 +0,0 @@
-# frozen_string_literal: true
-
-require 'gir_ffi_test_helper'
-
-GirFFI.setup :GIMarshallingTests
-
-describe GirFFI::Core do
-  it 'sets up cairo as Cairo' do
-    GirFFI.setup :cairo
-    assert Object.const_defined?(:Cairo)
-  end
-
-  it 'sets up xlib, which has no shared library' do
-    gir = GObjectIntrospection::IRepository.default
-    gir.require 'xlib'
-    assert_nil gir.shared_library('xlib'), 'Precondition for test failed'
-    GirFFI.setup :xlib
-  end
-
-  it 'sets up dependencies' do
-    save_module :GObject
-    save_module :Regress
-    GirFFI.setup :Regress
-    assert Object.const_defined?(:GObject)
-    restore_module :Regress
-    restore_module :GObject
-  end
-
-  describe '.setup' do
-    it 'passes the desired version down to the module builder' do
-      expect(GirFFI::Builder).to receive(:build_module).with('Regress', '0.1')
-      GirFFI.setup :Regress, '0.1'
-    end
-  end
-
-  describe '::define_type' do
-    describe 'without a block' do
-      before do
-        @klass = Class.new GIMarshallingTests::OverridesObject
-        Object.const_set "DerivedA#{Sequence.next}", @klass
-        @gtype = GirFFI.define_type @klass
-      end
-
-      it 'returns a GType for the derived class' do
-        parent_gtype = GIMarshallingTests::OverridesObject.gtype
-        @gtype.wont_equal parent_gtype
-        GObject.type_name(@gtype).must_equal @klass.name
-      end
-
-      it 'makes #gtype on the registered class return the new GType' do
-        @klass.gtype.must_equal @gtype
-      end
-
-      it 'registers a type with the same size as the parent' do
-        q = GObject.type_query @gtype
-        q.instance_size.must_equal GIMarshallingTests::OverridesObject::Struct.size
-      end
-
-      it 'creates a struct class for the derived class with just one member' do
-        @klass::Struct.members.must_equal [:parent]
-      end
-
-      it 'allows the new class to be instantiated' do
-        obj = @klass.new
-        type = GObject.type_from_instance obj
-        type.must_equal @gtype
-      end
-    end
-
-    describe 'with a block with a call to #install_property' do
-      before do
-        @klass = Class.new GIMarshallingTests::OverridesObject
-        Object.const_set "DerivedB#{Sequence.next}", @klass
-        @gtype = GirFFI.define_type @klass do |info|
-          info.install_property GObject.param_spec_int('foo', 'foo bar',
-                                                       'The Foo Bar Property',
-                                                       10, 20, 15,
-                                                       3)
-        end
-      end
-
-      it 'registers a type that is bigger than the parent' do
-        q = GObject.type_query @gtype
-        q.instance_size.must_be :>, GIMarshallingTests::OverridesObject::Struct.size
-      end
-
-      it 'gives the types Struct the fields :parent and :foo' do
-        @klass::Struct.members.must_equal [:parent, :foo]
-      end
-
-      it 'creates accessor functions for the property' do
-        obj = @klass.new
-        obj.foo = 13
-        obj.foo.must_equal 13
-      end
-    end
-  end
-end

data/test/gir_ffi/enum_base_test.rb

@@ -1,43 +0,0 @@
-# frozen_string_literal: true
-
-require 'gir_ffi_test_helper'
-
-GirFFI.setup :Regress
-
-describe GirFFI::EnumBase do
-  describe '.wrap' do
-    it 'converts an integer to a symbol if possible' do
-      Regress::TestEnum.wrap(1).must_equal :value2
-    end
-
-    it 'passes an integer if it cannot be converted' do
-      Regress::TestEnum.wrap(32).must_equal 32
-    end
-
-    it 'passes a known symbol untouched' do
-      Regress::TestEnum.wrap(:value1).must_equal :value1
-    end
-
-    it 'passes an unknown symbol untouched' do
-      Regress::TestEnum.wrap(:foo).must_equal :foo
-    end
-  end
-
-  describe '.to_int' do
-    it 'passes a known integer untouched' do
-      Regress::TestEnum.to_int(1).must_equal 1
-    end
-
-    it 'passes an unknown integer untouched' do
-      Regress::TestEnum.to_int(32).must_equal 32
-    end
-
-    it 'convertes a known symbol to an integer' do
-      Regress::TestEnum.to_int(:value1).must_equal 0
-    end
-
-    it 'raises an error for an unknown symbol' do
-      -> { Regress::TestEnum.to_int(:foo) }.must_raise ArgumentError
-    end
-  end
-end

data/test/gir_ffi/error_type_info_test.rb

@@ -1,50 +0,0 @@
-# frozen_string_literal: true
-
-require 'gir_ffi_test_helper'
-require 'gir_ffi/error_type_info'
-
-describe GirFFI::ErrorTypeInfo do
-  let(:instance) { GirFFI::ErrorTypeInfo.new }
-
-  describe '#array_length' do
-    it 'returns the correct value' do
-      instance.array_length.must_equal(-1)
-    end
-  end
-
-  describe '#tag_or_class' do
-    it 'returns the correct value' do
-      instance.tag_or_class.must_equal [:pointer, :error]
-    end
-  end
-
-  describe '#pointer?' do
-    it 'returns the correct value' do
-      instance.pointer?.must_equal true
-    end
-  end
-
-  describe '#flattened_tag' do
-    it 'returns the correct value' do
-      instance.flattened_tag.must_equal :error
-    end
-  end
-
-  describe '#extra_conversion_arguments' do
-    it 'returns the correct value' do
-      instance.extra_conversion_arguments.must_equal []
-    end
-  end
-
-  describe '#argument_class_name' do
-    it 'returns the correct value' do
-      instance.argument_class_name.must_equal 'GLib::Error'
-    end
-  end
-
-  describe '#needs_ruby_to_c_conversion_for_callbacks?' do
-    it 'returns the correct value' do
-      instance.needs_ruby_to_c_conversion_for_callbacks?.must_equal true
-    end
-  end
-end

data/test/gir_ffi/ffi_ext/pointer_test.rb

@@ -1,20 +0,0 @@
-# frozen_string_literal: true
-
-require 'gir_ffi_test_helper'
-
-describe GirFFI::FFIExt::Pointer do
-  let(:pointer_class) { Class.new { include GirFFI::FFIExt::Pointer } }
-  describe '#to_object' do
-    it 'finds the wrapping class by gtype and wraps the pointer in it' do
-      ptr = pointer_class.new
-      expect(ptr).to receive(:null?).and_return false
-      object_class = Class.new
-
-      expect(GObject).to receive(:type_from_instance_pointer).with(ptr).and_return 0xdeadbeef
-      expect(GirFFI::Builder).to receive(:build_by_gtype).with(0xdeadbeef).and_return object_class
-      expect(object_class).to receive(:direct_wrap).with(ptr).and_return 'good-result'
-
-      ptr.to_object.must_equal 'good-result'
-    end
-  end
-end

data/test/gir_ffi/g_type_test.rb

@@ -1,31 +0,0 @@
-# frozen_string_literal: true
-
-require 'gir_ffi_test_helper'
-
-require 'gir_ffi/g_type'
-
-describe GirFFI::GType do
-  let(:gobject_gtype) { GObject::Object.gtype }
-  let(:gobject_type_query) { GObject.type_query gobject_gtype }
-
-  describe '#to_i' do
-    it 'returns the integer gtype' do
-      gt = GirFFI::GType.new(gobject_gtype)
-      gt.to_i.must_equal gobject_gtype
-    end
-  end
-
-  describe '#class_size' do
-    it 'returns the class size for object types' do
-      gt = GirFFI::GType.new(gobject_gtype)
-      gt.class_size.must_equal gobject_type_query.class_size
-    end
-  end
-
-  describe '#instance_size' do
-    it 'returns the instance size for object types' do
-      gt = GirFFI::GType.new(gobject_gtype)
-      gt.instance_size.must_equal gobject_type_query.instance_size
-    end
-  end
-end

data/test/gir_ffi/in_out_pointer_test.rb

@@ -1,56 +0,0 @@
-# frozen_string_literal: true
-
-require 'gir_ffi_test_helper'
-
-describe GirFFI::InOutPointer do
-  describe '.new' do
-    it 'wraps an existing pointer and a type' do
-      ptr = FFI::MemoryPointer.new(:int32)
-      ptr.put_int32 0, 42
-      instance = GirFFI::InOutPointer.new :gint32, ptr
-      instance.to_value.must_equal 42
-    end
-  end
-
-  describe '#to_value' do
-    it 'returns the held value' do
-      ptr = GirFFI::InOutPointer.allocate_new :gint32
-      ptr.put_int32 0, 123
-      assert_equal 123, ptr.to_value
-    end
-
-    describe 'for :gboolean values' do
-      it 'works when the value is false' do
-        ptr = GirFFI::InOutPointer.allocate_new :gboolean
-        ptr.put_int 0, 0
-        ptr.to_value.must_equal false
-      end
-
-      it 'works when the value is true' do
-        ptr = GirFFI::InOutPointer.allocate_new :gboolean
-        ptr.put_int 0, 1
-        ptr.to_value.must_equal true
-      end
-    end
-
-    describe 'for :utf8 values' do
-      it 'returns a pointer to the held string value' do
-        str_ptr = GirFFI::InPointer.from_utf8 'Some value'
-        ptr = GirFFI::InOutPointer.allocate_new :utf8
-        ptr.put_pointer 0, str_ptr
-        assert_equal 'Some value', ptr.to_value.read_string
-      end
-    end
-
-    describe 'for struct values' do
-      it 'returns a pointer to the held value' do
-        val = GObject::EnumValue.new
-        val.value = 3
-        ptr = GirFFI::InOutPointer.allocate_new GObject::EnumValue
-        GObject::EnumValue.copy_value_to_pointer val, ptr
-        result = ptr.to_value
-        GObject::EnumValue.wrap(result).value.must_equal 3
-      end
-    end
-  end
-end

data/test/gir_ffi/in_pointer_test.rb

@@ -1,183 +0,0 @@
-# frozen_string_literal: true
-
-require 'gir_ffi_test_helper'
-
-require 'gir_ffi/in_pointer'
-
-describe GirFFI::InPointer do
-  describe '.from_array' do
-    it 'returns nil when passed nil' do
-      result = GirFFI::InPointer.from_array :gint32, nil
-      assert_nil result
-    end
-
-    it 'handles type tag :GType' do
-      GirFFI::InPointer.from_array :GType, [2]
-    end
-
-    it 'handles enum types' do
-      e = Module.new do
-        extend GirFFI::EnumBase
-        self::Enum = FFI::Enum.new [:foo, :bar, :baz], :qux
-      end
-      ptr = GirFFI::InPointer.from_array e, [:bar, :foo, :baz]
-      ptr.read_array_of_int32(3).must_equal [1, 0, 2]
-    end
-
-    it 'handles struct types' do
-      e = Class.new(GirFFI::StructBase) do
-        self::Struct = Class.new(GirFFI::Struct) do
-          layout :foo, :int32, :bar, :int32
-        end
-      end
-      struct = e::Struct.allocate
-      struct[:foo] = 42
-      struct[:bar] = 24
-      ptr = GirFFI::InPointer.from_array e, [struct]
-      ptr.wont_be :==, struct.to_ptr
-      new_struct = e::Struct.new ptr
-      new_struct[:foo].must_equal 42
-      new_struct[:bar].must_equal 24
-    end
-
-    it 'handles typed pointers' do
-      p1 = GirFFI::InPointer.from :gint32, 42
-      p2 = GirFFI::InPointer.from :gint32, 24
-
-      ptr = GirFFI::InPointer.from_array [:pointer, :gint32], [p1, p2]
-
-      ptr.read_array_of_pointer(2).must_equal [p1, p2]
-    end
-
-    it 'handles pointer casting' do
-      ptr = GirFFI::InPointer.from_array [:pointer, :gint32], [42, 24]
-
-      ptr.read_array_of_pointer(2).map(&:address).must_equal [42, 24]
-    end
-  end
-
-  describe 'an instance created with .from_array :gint32' do
-    before do
-      @result = GirFFI::InPointer.from_array :gint32, [24, 13]
-    end
-
-    it 'holds a pointer to the correct input values' do
-      assert_equal 24, @result.get_int(0)
-      assert_equal 13, @result.get_int(4)
-    end
-
-    it 'is an instance of FFI::MemoryPointer' do
-      @result.must_be_instance_of FFI::MemoryPointer
-    end
-
-    it 'is zero-terminated' do
-      assert_equal 0, @result.get_int(8)
-    end
-  end
-
-  describe 'an instance created with .from_array :utf8' do
-    before do
-      @result = GirFFI::InPointer.from_array :utf8, %w(foo bar baz)
-    end
-
-    it 'returns an array of pointers to strings' do
-      ary = @result.read_array_of_pointer(3)
-      assert_equal %w(foo bar baz), ary.map(&:read_string)
-    end
-  end
-
-  describe 'an instance created with .from_array :filename' do
-    before do
-      @result = GirFFI::InPointer.from_array :filename, %w(foo bar baz)
-    end
-
-    it 'returns an array of pointers to strings' do
-      ary = @result.read_array_of_pointer(3)
-      assert_equal %w(foo bar baz), ary.map(&:read_string)
-    end
-  end
-
-  describe 'an instance created with .from :utf8' do
-    before do
-      @result = GirFFI::InPointer.from :utf8, 'foo'
-    end
-
-    it 'returns a pointer to the given string' do
-      assert_equal 'foo', @result.read_string
-    end
-
-    it 'is an instance of FFI::MemoryPointer' do
-      @result.must_be_instance_of FFI::MemoryPointer
-    end
-  end
-
-  describe 'an instance created with .from :guint32' do
-    before do
-      @result = GirFFI::InPointer.from :guint32, 12_345
-    end
-
-    it 'returns a pointer with an address equal to the given value' do
-      assert_equal 12_345, @result.address
-    end
-
-    it 'is an instance of FFI::Pointer' do
-      @result.must_be_instance_of FFI::Pointer
-    end
-  end
-
-  describe 'an instance created with .from :filename' do
-    before do
-      @result = GirFFI::InPointer.from :filename, 'foo'
-    end
-
-    it 'returns a pointer to the given string' do
-      assert_equal 'foo', @result.read_string
-    end
-  end
-
-  describe '.from' do
-    it 'returns nil when passed nil' do
-      result = GirFFI::InPointer.from :foo, nil
-      assert_nil result
-    end
-
-    it "sets the pointer's address to the passed value for type :gint8" do
-      result = GirFFI::InPointer.from :gint8, 23
-      assert_equal 23, result.address
-    end
-
-    it 'handles enum types' do
-      e = Module.new do
-        extend GirFFI::EnumBase
-        self::Enum = FFI::Enum.new [:foo, :bar, :baz], :qux
-      end
-      ptr = GirFFI::InPointer.from e, :bar
-      ptr.address.must_equal 1
-    end
-
-    describe 'for type :void' do
-      it 'returns the result of to_ptr' do
-        obj = Object.new
-        def obj.to_ptr
-          :test_value
-        end
-        GirFFI::InPointer.from(:void, obj).must_equal :test_value
-      end
-
-      it 'returns nil when passed nil' do
-        GirFFI::InPointer.from(:void, nil).must_be_nil
-      end
-    end
-
-    describe 'for types that are classes' do
-      it 'returns the result of to_ptr' do
-        klass = Class.new
-        obj = klass.new
-        def obj.to_ptr
-          :test_value
-        end
-        GirFFI::InPointer.from(klass, obj).must_equal :test_value
-      end
-    end
-  end
-end