gir_ffi 0.15.2 → 0.15.7

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_pointer_test.rb

@@ -1,203 +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 "returns a pointer to the value for type :gint64" do
-      result = GirFFI::InPointer.from :gint64, -0x90000000
-      assert_equal(-0x90000000, result.get_int64(0))
-    end
-
-    it "returns a pointer to the value for type :guint64" do
-      result = GirFFI::InPointer.from :guint64, 0xf0000000
-      assert_equal 0xf0000000, result.get_uint64(0)
-    end
-
-    it "returns a pointer to the value for type :gdouble" do
-      result = GirFFI::InPointer.from :gdouble, 0.1
-      assert_in_epsilon 0.1, result.read_double
-    end
-
-    it "returns a pointer to the value for type :gfloat" do
-      result = GirFFI::InPointer.from :gfloat, 0.1
-      assert_in_epsilon 0.1, result.read_float
-    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