gir_ffi 0.15.3 → 0.15.4

data/test/ffi-gobject_introspection/i_vfunc_info_test.rb

@@ -1,41 +0,0 @@
-# frozen_string_literal: true
-
-require "introspection_test_helper"
-
-describe GObjectIntrospection::IVFuncInfo do
-  let(:vfunc_info) do
-    get_vfunc_introspection_data "GIMarshallingTests", "Object", "method_int8_in"
-  end
-
-  let(:throwing_vfunc_info) do
-    get_vfunc_introspection_data "GIMarshallingTests", "Object", "vfunc_meth_with_err"
-  end
-
-  let(:vfunc_info_with_different_invoker) do
-    get_vfunc_introspection_data "Regress", "TestObj", "matrix"
-  end
-
-  describe "#throws?" do
-    it "returns false if there is no error argument" do
-      _(vfunc_info).wont_be :throws?
-    end
-
-    it "returns true if there is and error argument" do
-      _(throwing_vfunc_info).must_be :throws?
-    end
-  end
-
-  describe "#invoker" do
-    it "returns nil if no invoker method is present" do
-      _(throwing_vfunc_info.invoker).must_be_nil
-    end
-
-    it "returns info for the invoker method if present" do
-      _(vfunc_info.invoker.name).must_equal "method_int8_in"
-    end
-
-    it "returns the correct invoker even if named differently" do
-      _(vfunc_info_with_different_invoker.invoker.name).must_equal "do_matrix"
-    end
-  end
-end

data/test/ffi-gobject_introspection/lib_test.rb

@@ -1,13 +0,0 @@
-# frozen_string_literal: true
-
-require "introspection_test_helper"
-
-describe GObjectIntrospection::Lib::GIArgument do
-  describe "its member :v_ssize" do
-    it "is signed" do
-      gia = GObjectIntrospection::Lib::GIArgument.new
-      gia[:v_int64] = -1
-      assert_equal(-1, gia[:v_ssize])
-    end
-  end
-end

data/test/ffi-gobject_introspection/strv_test.rb

@@ -1,46 +0,0 @@
-# frozen_string_literal: true
-
-require "base_test_helper"
-
-describe GObjectIntrospection::Strv do
-  it "wraps a pointer" do
-    strv = GObjectIntrospection::Strv.new :some_pointer
-    assert_equal :some_pointer, strv.to_ptr
-  end
-
-  describe "::wrap" do
-    it "takes a pointer and returns a GObjectIntrospection::Strv wrapping it" do
-      strv = GObjectIntrospection::Strv.wrap :some_pointer
-      assert_instance_of GObjectIntrospection::Strv, strv
-      assert_equal :some_pointer, strv.to_ptr
-    end
-  end
-
-  describe "#each" do
-    it "yields each string 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
-
-      strv = GObjectIntrospection::Strv.new block
-      arr = []
-      strv.each do |str|
-        arr << str
-      end
-      assert_equal %w(one two three), arr
-    end
-
-    it "yields zero times for a Strv wrapping a null pointer" do
-      strv = GObjectIntrospection::Strv.new FFI::Pointer.new(0)
-      strv.each do |_str|
-        flunk
-      end
-    end
-  end
-
-  it "includes Enumerable" do
-    _(GObjectIntrospection::Strv).must_include Enumerable
-  end
-end

data/test/ffi-gobject_test.rb

@@ -1,153 +0,0 @@
-# frozen_string_literal: true
-
-require "gir_ffi_test_helper"
-
-describe GObject do
-  before do
-    GirFFI.setup :Regress
-  end
-
-  describe "::signal_emit" do
-    it "emits a signal" do
-      a = 1
-      o = Regress::TestSubObj.new
-      prc = proc { a = 2 }
-      callback = GObject::Callback.from prc
-      ::GObject::Lib.g_signal_connect_data o, "test", callback, nil, nil, 0
-      GObject.signal_emit o, "test"
-      assert_equal 2, a
-    end
-
-    it "handles return values" do
-      s = Gio::SocketService.new
-
-      argtypes = [:pointer, :pointer, :pointer, :pointer]
-      callback = FFI::Function.new(:bool, argtypes) { |_a, _b, _c, _d| true }
-      ::GObject::Lib.g_signal_connect_data s, "incoming", callback, nil, nil, 0
-      rv = GObject.signal_emit s, "incoming"
-      assert_equal true, rv
-    end
-
-    it "passes in extra arguments" do
-      o = Regress::TestSubObj.new
-      sb = Regress::TestSimpleBoxedA.new
-      sb.some_int8 = 31
-      sb.some_double = 2.42
-      sb.some_enum = :value2
-      b2 = nil
-
-      argtypes = [:pointer, :pointer, :pointer]
-      callback = FFI::Function.new(:void, argtypes) do |_a, b, _c|
-        b2 = b
-      end
-      ::GObject::Lib.g_signal_connect_data(o, "test-with-static-scope-arg",
-                                           callback, nil, nil, 0)
-      GObject.signal_emit o, "test-with-static-scope-arg", sb
-
-      sb2 = Regress::TestSimpleBoxedA.wrap b2
-      assert sb.equals(sb2)
-    end
-
-    it "allows specifying signal detail" do
-      a = 1
-      o = Regress::TestSubObj.new
-
-      callback = FFI::Function.new(:void, [:pointer, :pointer, :pointer]) { a = 2 }
-      ::GObject::Lib.g_signal_connect_data o, "notify::detail", callback, nil, nil, 0
-
-      GObject.signal_emit o, "notify::detail"
-
-      _(a).must_equal 2
-    end
-  end
-
-  describe "::signal_connect" do
-    it "installs a signal handler" do
-      a = 1
-      o = Regress::TestSubObj.new
-      GObject.signal_connect(o, "test") { a = 2 }
-      GObject.signal_emit o, "test"
-      assert_equal 2, a
-    end
-
-    it "passes user data to handler" do
-      a = 1
-      o = Regress::TestSubObj.new
-      GObject.signal_connect(o, "test", 2) { |_i, d| a = d }
-      GObject.signal_emit o, "test"
-      assert_equal 2, a
-    end
-
-    it "passes object to handler" do
-      o = Regress::TestSubObj.new
-      o2 = nil
-      GObject.signal_connect(o, "test") { |i, _d| o2 = i }
-      GObject.signal_emit o, "test"
-      assert_instance_of Regress::TestSubObj, o2
-      assert_equal o.to_ptr, o2.to_ptr
-    end
-
-    it "does not allow connecting an invalid signal" do
-      o = Regress::TestSubObj.new
-      _(proc { GObject.signal_connect(o, "not-really-a-signal") {} })
-        .must_raise GirFFI::SignalNotFoundError
-    end
-
-    it "handles return values" do
-      s = Gio::SocketService.new
-      GObject.signal_connect(s, "incoming") { true }
-      rv = GObject.signal_emit s, "incoming"
-      assert_equal true, rv
-    end
-
-    it "requires a block" do
-      o = Regress::TestSubObj.new
-      _(proc { GObject.signal_connect o, "test" }).must_raise ArgumentError
-    end
-
-    it "allows specifying signal detail" do
-      a = 1
-      o = Regress::TestSubObj.new
-      GObject.signal_connect(o, "notify::detail", 2) { |_i, _, d| a = d }
-      GObject.signal_emit o, "notify::detail"
-      assert_equal 2, a
-    end
-
-    describe "connecting a signal with extra arguments" do
-      before do
-        @a = nil
-        @b = 2
-
-        o = Regress::TestSubObj.new
-        sb = Regress::TestSimpleBoxedA.new
-        sb.some_int = 23
-
-        GObject.signal_connect(o, "test-with-static-scope-arg", 2) \
-          do |_instance, object, user_data|
-          @a = user_data
-          @b = object
-        end
-        GObject.signal_emit o, "test-with-static-scope-arg", sb
-      end
-
-      it "passes on the user data argument" do
-        assert_equal 2, @a
-      end
-
-      it "passes on the extra arguments" do
-        assert_instance_of Regress::TestSimpleBoxedA, @b
-        assert_equal 23, @b.some_int
-      end
-    end
-  end
-
-  describe "::signal_connect_after" do
-    it "installs a signal handler" do
-      a = 1
-      o = Regress::TestSubObj.new
-      GObject.signal_connect_after(o, "test") { a = 2 }
-      GObject.signal_emit o, "test"
-      assert_equal 2, a
-    end
-  end
-end

data/test/gir_ffi/allocation_helper_test.rb

@@ -1,36 +0,0 @@
-# frozen_string_literal: true
-
-require "gir_ffi_test_helper"
-
-describe GirFFI::AllocationHelper do
-  describe ".free_after" do
-    before do
-      allow(GirFFI::LibC).to receive(:free)
-    end
-
-    it "frees the passed-in pointer" do
-      ptr = double("pointer", null?: false)
-      GirFFI::AllocationHelper.free_after(ptr) {}
-      expect(GirFFI::LibC).to have_received(:free).with(ptr)
-    end
-
-    it "does not free a passed-in null pointer" do
-      ptr = double("pointer", null?: true)
-      GirFFI::AllocationHelper.free_after(ptr) {}
-      expect(GirFFI::LibC).not_to have_received(:free)
-    end
-
-    it "yields ptr to the block" do
-      ptr = double("pointer", null?: false)
-      foo = nil
-      GirFFI::AllocationHelper.free_after(ptr) { |it| foo = it }
-      _(foo).must_equal ptr
-    end
-
-    it "returns the result of the block" do
-      ptr = double("pointer", null?: false)
-      result = GirFFI::AllocationHelper.free_after(ptr) { "bar" }
-      _(result).must_equal "bar"
-    end
-  end
-end

data/test/gir_ffi/arg_helper_test.rb

@@ -1,146 +0,0 @@
-# frozen_string_literal: true
-
-require "gir_ffi_test_helper"
-
-describe GirFFI::ArgHelper do
-  describe ".cast_from_pointer" do
-    it "handles class types" do
-      klass = Class.new
-      expect(klass).to receive(:wrap).with(:pointer_value).and_return :wrapped_value
-      _(GirFFI::ArgHelper.cast_from_pointer(klass, :pointer_value))
-        .must_equal :wrapped_value
-    end
-
-    describe "for :gint8" do
-      it "handles negative :gint8" do
-        ptr = FFI::Pointer.new(-127)
-        _(GirFFI::ArgHelper.cast_from_pointer(:gint8, ptr)).must_equal(-127)
-      end
-
-      it "handles positive :gint8" do
-        ptr = FFI::Pointer.new(128)
-        _(GirFFI::ArgHelper.cast_from_pointer(:gint8, ptr)).must_equal(128)
-      end
-    end
-
-    it "handles :guint32" do
-      ptr = FFI::Pointer.new(0xffffffff)
-      _(GirFFI::ArgHelper.cast_from_pointer(:guint32, ptr)).must_equal(0xffffffff)
-    end
-
-    describe "for :gint32" do
-      it "handles positive :gint32" do
-        ptr = FFI::Pointer.new(1)
-        _(GirFFI::ArgHelper.cast_from_pointer(:gint32, ptr)).must_equal(1)
-      end
-
-      it "handles negative :gint32" do
-        ptr = FFI::Pointer.new(0xffffffff)
-        _(GirFFI::ArgHelper.cast_from_pointer(:gint32, ptr)).must_equal(-1)
-      end
-
-      it "handles largest negative :gint32" do
-        ptr = FFI::Pointer.new(0x80000000)
-        _(GirFFI::ArgHelper.cast_from_pointer(:gint32, ptr)).must_equal(-0x80000000)
-      end
-
-      it "handles largest positive :gint32" do
-        ptr = FFI::Pointer.new(0x7fffffff)
-        _(GirFFI::ArgHelper.cast_from_pointer(:gint32, ptr)).must_equal(0x7fffffff)
-      end
-    end
-
-    it "handles :utf8" do
-      ptr = FFI::MemoryPointer.from_string "foo"
-      _(GirFFI::ArgHelper.cast_from_pointer(:utf8, ptr)).must_equal "foo"
-    end
-
-    it "handles :filename" do
-      ptr = FFI::MemoryPointer.from_string "foo"
-      _(GirFFI::ArgHelper.cast_from_pointer(:filename, ptr)).must_equal "foo"
-    end
-
-    it "handles GHashTable" do
-      hash = GLib::HashTable.from [:utf8, :gint32], "foo" => 1, "bar" => 2
-      ptr = hash.to_ptr
-      result = GirFFI::ArgHelper.cast_from_pointer([:pointer, [:ghash, :utf8, :gint32]],
-                                                   ptr)
-      _(result.to_hash).must_equal hash.to_hash
-    end
-
-    describe "when passing a broken typespec" do
-      it "raises on unknown symbol" do
-        ptr = FFI::Pointer.new(0xffffffff)
-        exception = _(-> { GirFFI::ArgHelper.cast_from_pointer(:foo, ptr) })
-          .must_raise RuntimeError
-        _(exception.message).must_equal "Don't know how to cast foo"
-      end
-
-      it "raises on unexpected main type for complex type" do
-        ptr = FFI::Pointer.new(0xffffffff)
-        exception = _(-> { GirFFI::ArgHelper.cast_from_pointer([:utf8], ptr) })
-          .must_raise RuntimeError
-        _(exception.message).must_equal "Don't know how to cast [:utf8]"
-      end
-
-      it "raises on unexpected sub type for complex type" do
-        ptr = FFI::Pointer.new(0xffffffff)
-        exception = _(-> { GirFFI::ArgHelper.cast_from_pointer([:pointer, :utf8], ptr) })
-          .must_raise RuntimeError
-        _(exception.message).must_equal "Don't know how to cast [:pointer, :utf8]"
-      end
-
-      it "raises on unexpected container type for complex type" do
-        ptr = FFI::Pointer.new(0xffffffff)
-        exception =
-          _(-> { GirFFI::ArgHelper.cast_from_pointer([:pointer, [:gint32]], ptr) })
-            .must_raise RuntimeError
-        _(exception.message).must_equal "Don't know how to cast [:pointer, [:gint32]]"
-      end
-    end
-  end
-
-  describe ".store" do
-    describe "when called with nil" do
-      it "returns a null pointer" do
-        _(GirFFI::ArgHelper.store(nil)).must_be :null?
-      end
-    end
-
-    describe "when called with a string" do
-      it "stores the string in GirFFI::ArgHelper::OBJECT_STORE" do
-        str = "Foo"
-        ptr = GirFFI::ArgHelper.store(str)
-        result = GirFFI::ArgHelper::OBJECT_STORE.fetch(ptr)
-        _(result).must_equal str
-      end
-    end
-  end
-
-  describe ".check_fixed_array_size" do
-    it "passes if array has the correct size" do
-      GirFFI::ArgHelper.check_fixed_array_size(3, [1, 2, 3], "foo")
-      pass
-    end
-
-    it "raises if array does not have the correct size" do
-      result = _(-> { GirFFI::ArgHelper.check_fixed_array_size(3, [1, 2], "foo") })
-        .must_raise ArgumentError
-      _(result.message).must_equal "foo should have size 3"
-    end
-  end
-
-  describe ".check_error" do
-    it "does nothing if there is no error" do
-      err_ptr = double("err_ptr", read_pointer: nil)
-      GirFFI::ArgHelper.check_error err_ptr
-      pass
-    end
-
-    it "raises an exception if there is an error" do
-      err = GLib::Error.new
-      err_ptr = double("err_ptr", read_pointer: err.to_ptr)
-      _(-> { GirFFI::ArgHelper.check_error err_ptr }).must_raise GirFFI::GLibError
-    end
-  end
-end

data/test/gir_ffi/boolean_test.rb

@@ -1,43 +0,0 @@
-# frozen_string_literal: true
-
-require "gir_ffi_test_helper"
-
-describe GirFFI::Boolean do
-  it "has the same native size as an int" do
-    _(FFI.type_size(GirFFI::Boolean)).must_equal FFI.type_size :int
-  end
-
-  describe ".from_native" do
-    it "converts 0 to false" do
-      _(GirFFI::Boolean.from_native(0, "whatever")).must_equal false
-    end
-
-    it "converts 1 to true" do
-      _(GirFFI::Boolean.from_native(1, "whatever")).must_equal true
-    end
-  end
-
-  describe ".to_native" do
-    it "converts false to 0" do
-      _(GirFFI::Boolean.to_native(false, "whatever")).must_equal 0
-    end
-
-    it "converts true to 1" do
-      _(GirFFI::Boolean.to_native(true, "whatever")).must_equal 1
-    end
-
-    it "converts nil to 0" do
-      _(GirFFI::Boolean.to_native(nil, "whatever")).must_equal 0
-    end
-
-    it "converts truthy value to 1" do
-      _(GirFFI::Boolean.to_native("i am truth!", "whatever")).must_equal 1
-    end
-  end
-
-  describe ".size" do
-    it "returns the correct type size" do
-      _(GirFFI::Boolean.size).must_equal FFI.type_size :int
-    end
-  end
-end