gir_ffi 0.15.3 → 0.15.4

data/test/base_test_helper.rb

@@ -1,70 +0,0 @@
-# frozen_string_literal: true
-
-old_verbose = $VERBOSE
-$VERBOSE = false
-begin
-  require "test-prof"
-
-  TestProf::RubyProf.configure do |config|
-    config.min_percent = 0.5
-  end
-rescue LoadError
-  warn "test-prof not available"
-end
-$VERBOSE = old_verbose
-
-if ENV["CI"]
-  begin
-    require "coveralls"
-    Coveralls.wear!
-  rescue LoadError
-    nil
-  end
-end
-
-require "minitest/autorun"
-require "rspec/mocks/minitest_integration"
-
-Thread.abort_on_exception = true
-
-module BaseTestExtensions
-  def assert_defines_singleton_method(klass, method, msg = nil)
-    method = method.to_sym
-    methods = klass.singleton_methods(false).map(&:to_sym)
-    msg = message(msg) do
-      "Expected #{mu_pp(klass)} to define singleton method #{mu_pp(method)}, " \
-        "but only found #{mu_pp(methods)}"
-    end
-    assert_includes methods, method, msg
-  end
-
-  def refute_defines_singleton_method(klass, method, msg = nil)
-    method = method.to_sym
-    methods = klass.singleton_methods(false).map(&:to_sym)
-    msg = message(msg) do
-      "Expected #{mu_pp(klass)} not to define singleton method #{mu_pp(method)}"
-    end
-    refute_includes methods, method, msg
-  end
-
-  def assert_defines_instance_method(klass, method, msg = nil)
-    method = method.to_sym
-    methods = klass.instance_methods(false).map(&:to_sym)
-    msg = message(msg) do
-      "Expected #{mu_pp(klass)} to define instance method #{mu_pp(method)}, " \
-        "but only found #{mu_pp(methods)}"
-    end
-    assert_includes methods, method, msg
-  end
-
-  def refute_defines_instance_method(klass, method, msg = nil)
-    method = method.to_sym
-    methods = klass.instance_methods(false).map(&:to_sym)
-    msg = message(msg) do
-      "Expected #{mu_pp(klass)} not to define instance method #{mu_pp(method)}"
-    end
-    refute_includes methods, method, msg
-  end
-end
-
-Minitest::Test.include BaseTestExtensions

data/test/ffi-glib/array_test.rb

@@ -1,203 +0,0 @@
-# frozen_string_literal: true
-
-require "gir_ffi_test_helper"
-
-describe GLib::Array do
-  it "knows its element type" do
-    arr = GLib::Array.new :gint32
-    assert_equal :gint32, arr.element_type
-  end
-
-  describe "#append_vals" do
-    before do
-      @arr = GLib::Array.new :gint32
-      @result = @arr.append_vals [1, 2, 3]
-    end
-
-    it "appends values" do
-      assert_equal 3, @arr.len
-    end
-
-    it "returns self" do
-      assert_equal @result, @arr
-    end
-  end
-
-  describe "#each" do
-    before do
-      @arr = GLib::Array.new(:gint32).append_vals [1, 2, 3]
-    end
-
-    it "iterates over the values" do
-      a = []
-      @arr.each { |v| a << v }
-
-      assert_equal [1, 2, 3], a
-    end
-  end
-
-  describe "::wrap" do
-    it "wraps a pointer, taking the element type as the first argument" do
-      arr = GLib::Array.new :gint32
-      arr.append_vals [1, 2, 3]
-      arr2 = GLib::Array.wrap :gint32, arr.to_ptr
-      assert_equal arr.to_a, arr2.to_a
-    end
-
-    it "warns the element sizes don't match" do
-      arr = GLib::Array.new :gint32
-      arr.append_vals [1, 2, 3]
-      _(proc { GLib::Array.wrap :gint8, arr.to_ptr }).must_output nil, /sizes do not match/
-    end
-
-    it "handles a struct as the element type" do
-      vals = [1, 2, 3].map { |i| GObject::EnumValue.new.tap { |ev| ev.value = i } }
-      arr = GLib::Array.new GObject::EnumValue
-      arr.append_vals vals
-      arr2 = GLib::Array.wrap GObject::EnumValue, arr.to_ptr
-      _(arr2.to_a).must_equal arr.to_a
-    end
-  end
-
-  it "includes Enumerable" do
-    _(GLib::Array).must_include Enumerable
-  end
-
-  it "has a working #to_a method" do
-    arr = GLib::Array.new :gint32
-    arr.append_vals [1, 2, 3]
-    assert_equal [1, 2, 3], arr.to_a
-  end
-
-  describe ".from" do
-    it "creates a GArray from an array of :gint32" do
-      arr = GLib::Array.from :gint32, [3, 2, 1]
-      _(arr).must_be_instance_of GLib::Array
-      _(arr.to_a).must_equal [3, 2, 1]
-    end
-
-    it "creates a GArray from an array of :gboolean" do
-      arr = GLib::Array.from :gboolean, [true, false, true]
-      _(arr).must_be_instance_of GLib::Array
-      _(arr.to_a).must_equal [true, false, true]
-    end
-
-    it "creates a GArray from an array of :utf8 values" do
-      arr = GLib::Array.from :utf8, %w(hello there)
-      _(arr).must_be_instance_of GLib::Array
-      _(arr.to_a).must_equal %w(hello there)
-    end
-
-    it "creates a GArray from an array of struct values" do
-      values = [1, 2, 3].map do |val|
-        GObject::EnumValue.new.tap { |it| it.value = val }
-      end
-      arr = GLib::Array.from GObject::EnumValue, values
-      _(arr).must_be_instance_of GLib::Array
-      _(arr.to_a.map(&:value)).must_equal [1, 2, 3]
-    end
-
-    it "return its argument if given a GArray" do
-      arr = GLib::Array.new :gint32
-      arr.append_vals [3, 2, 1]
-      arr2 = GLib::Array.from :gint32, arr
-      assert arr2.equal? arr
-    end
-
-    it "wraps its argument if given a pointer" do
-      arr = GLib::Array.new :gint32
-      arr.append_vals [3, 2, 1]
-      pointer = arr.to_ptr
-      assert_instance_of FFI::Pointer, pointer
-      arr2 = GLib::Array.from :gint32, pointer
-      assert_instance_of GLib::Array, arr2
-      refute arr2.equal? arr
-      _(arr2.to_a).must_equal arr.to_a
-    end
-  end
-
-  describe "#==" do
-    it "returns true when comparing to an array with the same elements" do
-      arr = GLib::Array.from :gint32, [1, 2, 3]
-
-      _(arr).must_be :==, [1, 2, 3]
-    end
-
-    it "returns false when comparing to an array with different elements" do
-      arr = GLib::Array.from :gint32, [1, 2, 3]
-
-      _(arr).wont_be :==, [1, 2]
-    end
-
-    it "returns true when comparing to a GArray with the same elements" do
-      arr = GLib::Array.from :gint32, [1, 2, 3]
-      other = GLib::Array.from :gint32, [1, 2, 3]
-
-      _(arr).must_be :==, other
-    end
-
-    it "returns false when comparing to a GArray with different elements" do
-      arr = GLib::Array.from :gint32, [1, 2, 3]
-      other = GLib::Array.from :gint32, [1, 2]
-
-      _(arr).wont_be :==, other
-    end
-  end
-
-  describe "#index" do
-    it "returns the proper element for an array of :gint32" do
-      arr = GLib::Array.from :gint32, [1, 2, 3]
-      _(arr.index(2)).must_equal 3
-    end
-
-    it "returns the proper element for an array of :utf8" do
-      arr = GLib::Array.from :utf8, %w(a b c)
-      _(arr.index(1)).must_equal "b"
-    end
-
-    it "returns the proper element for an array of :gboolean" do
-      arr = GLib::Array.from :gboolean, [true, false, true]
-      _(arr.index(1)).must_equal false
-    end
-
-    it "returns the proper element for an array of struct" do
-      vals = [1, 2, 3].map { |i| GObject::EnumValue.new.tap { |ev| ev.value = i } }
-      arr = GLib::Array.from GObject::EnumValue, vals
-      _(arr.index(1).value).must_equal 2
-    end
-
-    it "raises an error if the index is out of bounds" do
-      arr = GLib::Array.from :gint32, [1, 2, 3]
-      _(proc { arr.index(16) }).must_raise IndexError
-      _(proc { arr.index(-1) }).must_raise IndexError
-    end
-  end
-
-  describe "#reset_typespec" do
-    describe "when it needs to guess the type" do
-      it "guesses :uint8 for size 1" do
-        arr = GLib::Array.from :int8, [1, 2, 3]
-        arr.reset_typespec
-        _(arr.element_type).must_equal :uint8
-      end
-
-      it "guesses :uint16 for size 2" do
-        arr = GLib::Array.from :int16, [1, 2, 3]
-        arr.reset_typespec
-        _(arr.element_type).must_equal :uint16
-      end
-
-      it "guesses :uint32 for size 4" do
-        arr = GLib::Array.from :int32, [1, 2, 3]
-        arr.reset_typespec
-        _(arr.element_type).must_equal :uint32
-      end
-
-      it "guesses :uint64 for size 8" do
-        arr = GLib::Array.from :int64, [1, 2, 3]
-        arr.reset_typespec
-        _(arr.element_type).must_equal :uint64
-      end
-    end
-  end
-end

data/test/ffi-glib/byte_array_test.rb

@@ -1,28 +0,0 @@
-# frozen_string_literal: true
-
-require "gir_ffi_test_helper"
-
-describe GLib::ByteArray do
-  it "can succesfully be created with GLib::ByteArray.new" do
-    ba = GLib::ByteArray.new
-    assert_instance_of GLib::ByteArray, ba
-  end
-
-  it "allows strings to be appended to it" do
-    ba = GLib::ByteArray.new
-    ba.append "abdc"
-    pass
-  end
-
-  it "has a working #to_string method" do
-    ba = GLib::ByteArray.new
-    ba = ba.append "abdc"
-    assert_equal "abdc", ba.to_string
-  end
-
-  it "can be created from a string" do
-    str = "cdba"
-    ba = GLib::ByteArray.from str
-    _(ba.to_string).must_equal str
-  end
-end

data/test/ffi-glib/bytes_test.rb

@@ -1,61 +0,0 @@
-# frozen_string_literal: true
-
-require "gir_ffi_test_helper"
-
-describe GLib::Bytes do
-  it "can succesfully be created with GLib::Bytes.new" do
-    bytes = GLib::Bytes.new [1, 2, 3]
-    _(bytes).must_be_instance_of GLib::Bytes
-  end
-
-  it "has a working #get_size method" do
-    bytes = GLib::Bytes.new [1, 2, 3]
-    _(bytes.get_size).must_equal 3
-  end
-
-  it "has #size as an alias for #get_size" do
-    bytes = GLib::Bytes.new [1, 2, 3]
-    _(bytes.size).must_equal 3
-  end
-
-  it "has a working #get_data method" do
-    bytes = GLib::Bytes.new [1, 2, 3]
-    _(bytes.get_data.to_a).must_equal [1, 2, 3]
-  end
-
-  it "has a working #each method" do
-    a = []
-    bytes = GLib::Bytes.new [1, 2, 3]
-    bytes.each do |v|
-      a.unshift v
-    end
-    _(a).must_equal [3, 2, 1]
-  end
-
-  it "has a working #to_a method" do
-    bytes = GLib::Bytes.new [1, 2, 3]
-    _(bytes.to_a).must_equal [1, 2, 3]
-  end
-
-  describe ".from" do
-    it "creates a GLib::Bytes object form an array of small integers" do
-      bytes = GLib::Bytes.from [1, 2, 3]
-      _(bytes).must_be_instance_of GLib::Bytes
-      _(bytes.to_a).must_equal [1, 2, 3]
-    end
-
-    it "returns its argument if given a GLib::Bytes object" do
-      bytes = GLib::Bytes.new [1, 2, 3]
-      result = GLib::Bytes.from bytes
-      assert result.equal?(bytes)
-    end
-
-    it "wraps its argument if given a pointer" do
-      bytes = GLib::Bytes.new [1, 2, 3]
-      ptr = bytes.to_ptr
-      result = GLib::Bytes.from ptr
-      _(result.to_a).must_equal [1, 2, 3]
-      _(result.to_ptr).must_equal ptr
-    end
-  end
-end

data/test/ffi-glib/closure_test.rb

@@ -1,38 +0,0 @@
-# frozen_string_literal: true
-
-require "gir_ffi_test_helper"
-
-describe GObject::Closure do
-  describe ".new" do
-    it "updates the ref_count of the created object" do
-      # Tested on a subclass ...
-      c = GObject::RubyClosure.new {}
-      _(c.ref_count).must_equal 1
-    end
-  end
-
-  describe "#invoke" do
-    it "invokes the closure" do
-      a = 0
-      c = GObject::RubyClosure.new { a = 2 }
-      c2 = GObject::Closure.wrap(c.to_ptr)
-      c2.invoke nil, []
-      _(a).must_equal 2
-    end
-
-    it "returns the closure result" do
-      c = GObject::RubyClosure.new { 3 }
-      c2 = GObject::Closure.wrap(c.to_ptr)
-      result = c2.invoke GObject::Value.for_gtype(GObject::TYPE_INT), []
-      _(result).must_equal 3
-    end
-
-    it "passes arguments" do
-      a = 0
-      c = GObject::RubyClosure.new { |val| a = val }
-      c2 = GObject::Closure.wrap(c.to_ptr)
-      c2.invoke nil, [5]
-      _(a).must_equal 5
-    end
-  end
-end

data/test/ffi-glib/destroy_notify_test.rb

@@ -1,18 +0,0 @@
-# frozen_string_literal: true
-
-require "gir_ffi_test_helper"
-
-describe GLib::DestroyNotify do
-  describe ".default" do
-    it "removes the passed-in key from the callback store" do
-      dummy_proc = "some-callback"
-      GirFFI::CallbackBase.store_callback dummy_proc
-      _(GirFFI::CallbackBase::CALLBACKS[dummy_proc.object_id]).wont_be_nil
-
-      user_data = GirFFI::ArgHelper.store dummy_proc
-      GLib::DestroyNotify.default.call user_data
-
-      _(GirFFI::CallbackBase::CALLBACKS[dummy_proc.object_id]).must_be_nil
-    end
-  end
-end

data/test/ffi-glib/hash_table_test.rb

@@ -1,68 +0,0 @@
-# frozen_string_literal: true
-
-require "gir_ffi_test_helper"
-
-describe GLib::HashTable do
-  it "knows its key and value types" do
-    hsh = GLib::HashTable.new :gint32, :utf8
-    assert_equal :gint32, hsh.key_type
-    assert_equal :utf8, hsh.value_type
-  end
-
-  describe "::from" do
-    it "creates a GHashTable from a Ruby hash" do
-      hsh = GLib::HashTable.from [:utf8, :gint32],
-                                 "foo" => 23, "bar" => 32
-      assert_equal({ "foo" => 23, "bar" => 32 }, hsh.to_hash)
-    end
-
-    it "return its argument if given a GHashTable" do
-      hsh = GLib::HashTable.from [:utf8, :gint32], "foo" => 23, "bar" => 32
-      hsh2 = GLib::HashTable.from [:utf8, :gint32], hsh
-      assert hsh2.equal? hsh
-    end
-
-    it "wraps its argument if given a pointer" do
-      hsh = GLib::HashTable.from [:utf8, :gint32], "foo" => 23, "bar" => 32
-      pointer = hsh.to_ptr
-      assert_instance_of FFI::Pointer, pointer
-      hsh2 = GLib::HashTable.from [:utf8, :gint32], pointer
-      assert_instance_of GLib::HashTable, hsh2
-      refute hsh2.equal? hsh
-      _(hsh2.to_hash).must_equal hsh.to_hash
-    end
-  end
-
-  it "allows key-value pairs to be inserted" do
-    h = GLib::HashTable.new :utf8, :utf8
-    h.insert "foo", "bar"
-    _(h.to_hash).must_equal "foo" => "bar"
-  end
-
-  it "includes Enumerable" do
-    _(GLib::HashTable).must_include Enumerable
-  end
-
-  describe "a HashTable provided by the system" do
-    before do
-      GirFFI.setup :Regress
-      @hash = Regress.test_ghash_container_return
-    end
-
-    it "has a working #each method" do
-      a = {}
-      @hash.each { |k, v| a[k] = v }
-      _(a).must_be :==,
-                   "foo" => "bar",
-                   "baz" => "bat",
-                   "qux" => "quux"
-    end
-
-    it "has a working #to_hash method" do
-      _(@hash.to_hash).must_be :==,
-                               "foo" => "bar",
-                               "baz" => "bat",
-                               "qux" => "quux"
-    end
-  end
-end