gir_ffi 0.14.1 → 0.15.4

data/test/ffi-glib/byte_array_test.rb

@@ -1,22 +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
-end

data/test/ffi-glib/bytes_test.rb

@@ -1,56 +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 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