gir_ffi 0.15.1 → 0.15.6

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

data/test/ffi-glib/list_test.rb

@@ -1,86 +0,0 @@
-# frozen_string_literal: true
-
-require "gir_ffi_test_helper"
-
-describe GLib::List do
-  it "knows its element type" do
-    arr = GLib::List.new :gint32
-    assert_equal :gint32, arr.element_type
-  end
-
-  describe "#append" do
-    it "appends integer values" do
-      lst = GLib::List.new :gint32
-      res = lst.append 1
-      assert_equal 1, res.data
-    end
-
-    it "appends string values" do
-      lst = GLib::List.new :utf8
-      res = lst.append "bla"
-      assert_equal "bla", res.data
-    end
-
-    it "appends multiple values into a single list" do
-      lst = GLib::List.new :gint32
-
-      lst = lst.append 1
-      lst = lst.append 2
-
-      assert_equal 1, lst.data
-      nxt = lst.next
-      assert_equal 2, nxt.data
-    end
-  end
-
-  describe "::from" do
-    it "creates a GList from a Ruby array" do
-      lst = GLib::List.from :gint32, [3, 2, 1]
-      assert_equal [3, 2, 1], lst.to_a
-    end
-
-    it "return its argument if given a GList" do
-      lst = GLib::List.from :gint32, [3, 2, 1]
-      lst2 = GLib::List.from :gint32, lst
-      assert lst2.equal? lst
-    end
-
-    it "wraps its argument if given a pointer" do
-      lst = GLib::List.from :gint32, [3, 2, 1]
-      pointer = lst.to_ptr
-      assert_instance_of FFI::Pointer, pointer
-      lst2 = GLib::List.from :gint32, pointer
-      assert_instance_of GLib::List, lst2
-      refute lst2.equal? lst
-      _(lst2.to_a).must_equal lst.to_a
-    end
-  end
-
-  describe "#==" do
-    it "returns true when comparing to an array with the same elements" do
-      list = GLib::List.from :gint32, [1, 2, 3]
-
-      _(list).must_be :==, [1, 2, 3]
-    end
-
-    it "returns false when comparing to an array with different elements" do
-      list = GLib::List.from :gint32, [1, 2, 3]
-
-      _(list).wont_be :==, [1, 2]
-    end
-
-    it "returns true when comparing to a list with the same elements" do
-      list = GLib::List.from :gint32, [1, 2, 3]
-      other = GLib::List.from :gint32, [1, 2, 3]
-
-      _(list).must_be :==, other
-    end
-
-    it "returns false when comparing to a list with different elements" do
-      list = GLib::List.from :gint32, [1, 2, 3]
-      other = GLib::List.from :gint32, [1, 2]
-
-      _(list).wont_be :==, other
-    end
-  end
-end

data/test/ffi-glib/main_loop_test.rb

@@ -1,53 +0,0 @@
-# frozen_string_literal: true
-
-require "gir_ffi_test_helper"
-
-class MainLoopTestException < RuntimeError; end
-
-describe GLib::MainLoop do
-  describe "#run" do
-    it "allows other threads to run" do
-      main_loop = GLib::MainLoop.new nil, false
-
-      a = []
-      GLib.timeout_add GLib::PRIORITY_DEFAULT, 150 do
-        main_loop.quit
-      end
-
-      slow_thread = Thread.new do
-        sleep 0.001
-        a << "During run"
-      end
-
-      a << "Before run"
-      main_loop.run
-      a << "After run"
-
-      slow_thread.join
-
-      _(a).must_equal ["Before run", "During run", "After run"]
-    end
-
-    it "raises and quits on exceptions in callbacks" do
-      main_loop = GLib::MainLoop.new nil, false
-
-      a = "expected"
-
-      # This timeout shouldn't get called
-      guard = GLib.timeout_add GLib::PRIORITY_DEFAULT, 150 do
-        a = "unexpected"
-        main_loop.quit
-      end
-
-      GLib.timeout_add GLib::PRIORITY_DEFAULT, 10 do
-        raise MainLoopTestException
-      end
-
-      _(-> { main_loop.run }).must_raise MainLoopTestException
-      _(a).must_equal "expected"
-
-      # Clean up uncalled timeout
-      GLib.source_remove guard
-    end
-  end
-end

data/test/ffi-glib/ptr_array_test.rb

@@ -1,112 +0,0 @@
-# frozen_string_literal: true
-
-require "gir_ffi_test_helper"
-
-describe GLib::PtrArray do
-  it "knows its element type" do
-    arr = GLib::PtrArray.new :utf8
-    assert_equal :utf8, arr.element_type
-  end
-
-  describe "::add" do
-    it "correctly takes the type into account" do
-      arr = GLib::PtrArray.new :utf8
-      str = "test"
-      GLib::PtrArray.add arr, str
-
-      assert_equal str, arr.pdata.read_pointer.read_string
-    end
-  end
-
-  describe "#each" do
-    it "works normally" do
-      arr = GLib::PtrArray.new :utf8
-
-      GLib::PtrArray.add arr, "test1"
-      GLib::PtrArray.add arr, "test2"
-      GLib::PtrArray.add arr, "test3"
-
-      a = []
-      arr.each { |v| a << v }
-
-      assert_equal %w(test1 test2 test3), a
-    end
-
-    it "works when exiting the loop prematurely" do
-      arr = GLib::PtrArray.new :utf8
-
-      GLib::PtrArray.add arr, "test1"
-      GLib::PtrArray.add arr, "test2"
-      GLib::PtrArray.add arr, "test3"
-
-      a = []
-      arr.each do |v|
-        a << v
-        break if v == "test2"
-      end
-
-      assert_equal %w(test1 test2), a
-    end
-  end
-
-  it "includes Enumerable" do
-    _(GLib::PtrArray).must_include Enumerable
-  end
-
-  it "has a working #to_a method" do
-    arr = GLib::PtrArray.new :utf8
-
-    GLib::PtrArray.add arr, "test1"
-    GLib::PtrArray.add arr, "test2"
-    GLib::PtrArray.add arr, "test3"
-
-    assert_equal %w(test1 test2 test3), arr.to_a
-  end
-
-  it "has #add as an instance method too" do
-    arr = GLib::PtrArray.new :utf8
-    arr.add "test1"
-    assert_equal ["test1"], arr.to_a
-  end
-
-  describe "#==" do
-    it "returns true when comparing to an array with the same elements" do
-      arr = GLib::PtrArray.from :utf8, %w(1 2 3)
-
-      _(arr).must_be :==, %w(1 2 3)
-    end
-
-    it "returns false when comparing to an array with different elements" do
-      arr = GLib::PtrArray.from :utf8, %w(1 2 3)
-
-      _(arr).wont_be :==, %w(1 2)
-    end
-
-    it "returns true when comparing to a GPtrArray with the same elements" do
-      arr = GLib::PtrArray.from :utf8, %w(1 2 3)
-      other = GLib::PtrArray.from :utf8, %w(1 2 3)
-
-      _(arr).must_be :==, other
-    end
-
-    it "returns false when comparing to a GPtrArray with different elements" do
-      arr = GLib::PtrArray.from :utf8, %w(1 2 3)
-      other = GLib::PtrArray.from :utf8, %w(1 2)
-
-      _(arr).wont_be :==, other
-    end
-  end
-
-  describe "#index" do
-    it "returns the correct element" do
-      arr = GLib::PtrArray.from :utf8, %w(1 2 3)
-      _(arr.index(1)).must_equal "2"
-    end
-
-    it "raises an error if the index is out of bounds" do
-      arr = GLib::PtrArray.from :utf8, %w(1 2 3)
-      _(proc { arr.index(16) }).must_raise IndexError
-      _(proc { arr.index(-1) }).must_raise IndexError
-    end
-  end
-end