gir_ffi 0.14.1 → 0.15.0

data/tasks/test.rake

@@ -71,7 +71,7 @@ class Listener
       result.puts "    it \"handles the '#{obj_name}' signal\" do"
     when 'type', 'alias', 'return-value', 'parameters',
       'instance-parameter', 'parameter', 'doc', 'array',
-      'repository', 'include', 'package'
+      'repository', 'include', 'package', 'source-position'
       # Not printed"
     else
       puts "Skipping #{name}: #{attrs}"
@@ -156,9 +156,10 @@ namespace :test do
   task overrides: :lib
   task integration: :lib
 
-  desc 'Run the entire test suite as one'
+  desc 'Run the entire test suite as one with simplecov activated'
   define_test_task(:all) do |t|
     t.test_files = FileList['test/**/*_test.rb']
+    t.ruby_opts += ['-rbundler/setup -rsimplecov -w -Itest']
   end
 
   task all: :lib

data/test/base_test_helper.rb

@@ -1,22 +1,29 @@
 # frozen_string_literal: true
 
-require 'simplecov'
-SimpleCov.start do
-  track_files 'lib/**/*.rb'
-  add_filter '/test/'
+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']
+if ENV["CI"]
   begin
-    require 'coveralls'
+    require "coveralls"
     Coveralls.wear!
   rescue LoadError
     nil
   end
 end
 
-require 'minitest/autorun'
-require 'rspec/mocks/minitest_integration'
+require "minitest/autorun"
+require "rspec/mocks/minitest_integration"
 
 Thread.abort_on_exception = true
 
@@ -60,4 +67,4 @@ module BaseTestExtensions
   end
 end
 
-Minitest::Test.send :include, BaseTestExtensions
+Minitest::Test.include BaseTestExtensions

data/test/ffi-glib/array_test.rb

@@ -1,34 +1,34 @@
 # frozen_string_literal: true
 
-require 'gir_ffi_test_helper'
+require "gir_ffi_test_helper"
 
 describe GLib::Array do
-  it 'knows its element type' do
+  it "knows its element type" do
     arr = GLib::Array.new :gint32
     assert_equal :gint32, arr.element_type
   end
 
-  describe '#append_vals' do
+  describe "#append_vals" do
     before do
       @arr = GLib::Array.new :gint32
       @result = @arr.append_vals [1, 2, 3]
     end
 
-    it 'appends values' do
+    it "appends values" do
       assert_equal 3, @arr.len
     end
 
-    it 'returns self' do
+    it "returns self" do
       assert_equal @result, @arr
     end
   end
 
-  describe '#each' do
+  describe "#each" do
     before do
       @arr = GLib::Array.new(:gint32).append_vals [1, 2, 3]
     end
 
-    it 'iterates over the values' do
+    it "iterates over the values" do
       a = []
       @arr.each { |v| a << v }
 
@@ -36,8 +36,8 @@ describe GLib::Array do
     end
   end
 
-  describe '::wrap' do
-    it 'wraps a pointer, taking the element type as the first argument' do
+  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
@@ -47,49 +47,64 @@ describe GLib::Array do
     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/
+      _(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
+    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
+      _(arr2.to_a).must_equal arr.to_a
     end
   end
 
-  it 'includes Enumerable' do
-    GLib::Array.must_include Enumerable
+  it "includes Enumerable" do
+    _(GLib::Array).must_include Enumerable
   end
 
-  it 'has a working #to_a method' do
+  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
+  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]
+      _(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
+    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]
+      _(arr).must_be_instance_of GLib::Array
+      _(arr.to_a).must_equal [true, false, true]
     end
 
-    it 'return its argument if given a GArray' do
+    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
+    it "wraps its argument if given a pointer" do
       arr = GLib::Array.new :gint32
       arr.append_vals [3, 2, 1]
       pointer = arr.to_ptr
@@ -97,91 +112,91 @@ describe GLib::Array do
       arr2 = GLib::Array.from :gint32, pointer
       assert_instance_of GLib::Array, arr2
       refute arr2.equal? arr
-      arr2.to_a.must_equal arr.to_a
+      _(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
+  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]
+      _(arr).must_be :==, [1, 2, 3]
     end
 
-    it 'returns false when comparing to an array with different elements' do
+    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]
+      _(arr).wont_be :==, [1, 2]
     end
 
-    it 'returns true when comparing to a GArray with the same elements' do
+    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
+      _(arr).must_be :==, other
     end
 
-    it 'returns false when comparing to a GArray with different elements' do
+    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
+      _(arr).wont_be :==, other
     end
   end
 
-  describe '#index' do
-    it 'returns the proper element for an array of :gint32' do
+  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
+      _(arr.index(2)).must_equal 3
     end
 
-    it 'returns the proper element for an array of :utf8' do
+    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'
+      _(arr.index(1)).must_equal "b"
     end
 
-    it 'returns the proper element for an array of :gboolean' do
+    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
+      _(arr.index(1)).must_equal false
     end
 
-    it 'returns the proper element for an array of struct' do
+    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
+      _(arr.index(1).value).must_equal 2
     end
 
-    it 'raises an error if the index is out of bounds' do
+    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
+      _(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
+  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
+        _(arr.element_type).must_equal :uint8
       end
 
-      it 'guesses :uint16 for size 2' do
+      it "guesses :uint16 for size 2" do
         arr = GLib::Array.from :int16, [1, 2, 3]
         arr.reset_typespec
-        arr.element_type.must_equal :uint16
+        _(arr.element_type).must_equal :uint16
       end
 
-      it 'guesses :uint32 for size 4' do
+      it "guesses :uint32 for size 4" do
         arr = GLib::Array.from :int32, [1, 2, 3]
         arr.reset_typespec
-        arr.element_type.must_equal :uint32
+        _(arr.element_type).must_equal :uint32
       end
 
-      it 'guesses :uint64 for size 8' do
+      it "guesses :uint64 for size 8" do
         arr = GLib::Array.from :int64, [1, 2, 3]
         arr.reset_typespec
-        arr.element_type.must_equal :uint64
+        _(arr.element_type).must_equal :uint64
       end
     end
   end

data/test/ffi-glib/byte_array_test.rb

@@ -1,22 +1,28 @@
 # frozen_string_literal: true
 
-require 'gir_ffi_test_helper'
+require "gir_ffi_test_helper"
 
 describe GLib::ByteArray do
-  it 'can succesfully be created with GLib::ByteArray.new' 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
+  it "allows strings to be appended to it" do
     ba = GLib::ByteArray.new
-    ba.append 'abdc'
+    ba.append "abdc"
     pass
   end
 
-  it 'has a working #to_string method' do
+  it "has a working #to_string method" do
     ba = GLib::ByteArray.new
-    ba = ba.append 'abdc'
-    assert_equal 'abdc', ba.to_string
+    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,56 +1,61 @@
 # frozen_string_literal: true
 
-require 'gir_ffi_test_helper'
+require "gir_ffi_test_helper"
 
 describe GLib::Bytes do
-  it 'can succesfully be created with GLib::Bytes.new' 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
+    _(bytes).must_be_instance_of GLib::Bytes
   end
 
-  it 'has a working #get_size method' do
+  it "has a working #get_size method" do
     bytes = GLib::Bytes.new [1, 2, 3]
-    bytes.get_size.must_equal 3
+    _(bytes.get_size).must_equal 3
   end
 
-  it 'has a working #get_data method' do
+  it "has #size as an alias for #get_size" do
     bytes = GLib::Bytes.new [1, 2, 3]
-    bytes.get_data.to_a.must_equal [1, 2, 3]
+    _(bytes.size).must_equal 3
   end
 
-  it 'has a working #each method' do
+  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]
+    _(a).must_equal [3, 2, 1]
   end
 
-  it 'has a working #to_a method' do
+  it "has a working #to_a method" do
     bytes = GLib::Bytes.new [1, 2, 3]
-    bytes.to_a.must_equal [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
+  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]
+      _(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
+    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
+    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
+      _(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 +1,38 @@
 # frozen_string_literal: true
 
-require 'gir_ffi_test_helper'
+require "gir_ffi_test_helper"
 
 describe GObject::Closure do
-  describe '.new' do
-    it 'updates the ref_count of the created object' 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
+      _(c.ref_count).must_equal 1
     end
   end
 
-  describe '#invoke' do
-    it 'invokes the closure' do
+  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
+      _(a).must_equal 2
     end
 
-    it 'returns the closure result' do
+    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
+      _(result).must_equal 3
     end
 
-    it 'passes arguments' do
+    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
+      _(a).must_equal 5
     end
   end
 end