gir_ffi 0.7.7 → 0.7.8

data/test/ffi-glib/bytes_test.rb

@@ -1,22 +1,22 @@
 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
   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
   end
 
-  it "has a working #get_data 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
+  it 'has a working #each method' do
     a = []
     bytes = GLib::Bytes.new [1, 2, 3]
     bytes.each do |v|
@@ -25,25 +25,25 @@ describe GLib::Bytes do
     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]
   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]
     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

data/test/ffi-glib/hash_table_test.rb

@@ -1,27 +1,27 @@
 require 'gir_ffi_test_helper'
 
 describe GLib::HashTable do
-  it "knows its key and value types" 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
+  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)
+        '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}
+    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}
+    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
@@ -31,33 +31,36 @@ describe GLib::HashTable do
     end
   end
 
-  it "allows key-value pairs to be inserted" do
+  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"
+    h.insert 'foo', 'bar'
+    h.to_hash.must_equal 'foo' => 'bar'
   end
 
-  it "includes Enumerable" do
-    GLib::HashTable.must_include Enumerable 
+  it 'includes Enumerable' do
+    GLib::HashTable.must_include Enumerable
   end
 
-  describe "a HashTable provided by the system" do
+  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
+    it 'has a working #each method' do
       a = {}
-      @hash.each {|k, v| a[k] = v}
-      a.must_be :==, {"foo" => "bar", "baz" => "bat",
-        "qux" => "quux"}
+      @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"}
+    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/iconv_test.rb

@@ -1,16 +1,16 @@
 require 'gir_ffi_test_helper'
 
 describe GLib::IConv do
-  describe ".open" do
-    it "creates a new instance of GLib::Iconv" do
-      instance = GLib::IConv.open("ascii", "utf-8")
+  describe '.open' do
+    it 'creates a new instance of GLib::Iconv' do
+      instance = GLib::IConv.open('ascii', 'utf-8')
       instance.must_be_instance_of GLib::IConv
     end
   end
 
-  let(:instance) { GLib::IConv.open("ascii", "utf-8") }
+  let(:instance) { GLib::IConv.open('ascii', 'utf-8') }
 
-  describe "#setup_and_call" do
+  describe '#setup_and_call' do
     it "works for the method called ''" do
       instance.setup_and_call :'', [nil, nil, nil, nil]
     end

data/test/ffi-glib/list_test.rb

@@ -1,25 +1,25 @@
 require 'gir_ffi_test_helper'
 
 describe GLib::List do
-  it "knows its element type" 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
+  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
+    it 'appends string values' do
       lst = GLib::List.new :utf8
-      res = lst.append "bla"
-      assert_equal "bla", res.data
+      res = lst.append 'bla'
+      assert_equal 'bla', res.data
     end
 
-    it "appends multiple values into a single list" do
+    it 'appends multiple values into a single list' do
       lst = GLib::List.new :gint32
 
       lst = lst.append 1
@@ -31,19 +31,19 @@ describe GLib::List do
     end
   end
 
-  describe "::from" do
-    it "creates a GList from a Ruby array" do
+  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
+    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
+    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
@@ -54,27 +54,27 @@ describe GLib::List do
     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
       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
+    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
+    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
+    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]
 

data/test/ffi-glib/main_loop_test.rb

@@ -1,8 +1,8 @@
 require 'gir_ffi_test_helper'
 
 describe GLib::MainLoop do
-  describe "#run" do
-    it "allows other threads to run" do
+  describe '#run' do
+    it 'allows other threads to run' do
       main_loop = GLib::MainLoop.new nil, false
 
       a = []
@@ -12,16 +12,16 @@ describe GLib::MainLoop do
 
       slow_thread = Thread.new do
         sleep 0.001
-        a << "During run"
+        a << 'During run'
       end
 
-      a << "Before run"
+      a << 'Before run'
       main_loop.run
-      a << "After run"
+      a << 'After run'
 
       slow_thread.join
 
-      a.last.must_equal "After run"
+      a.last.must_equal 'After run'
     end
   end
 end

data/test/ffi-glib/ptr_array_test.rb

@@ -1,108 +1,108 @@
 require 'gir_ffi_test_helper'
 
 describe GLib::PtrArray do
-  it "knows its element type" 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
+  describe '::add' do
+    it 'correctly takes the type into account' do
       arr = GLib::PtrArray.new :utf8
-      str = "test"
+      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
+  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"
+      GLib::PtrArray.add arr, 'test1'
+      GLib::PtrArray.add arr, 'test2'
+      GLib::PtrArray.add arr, 'test3'
 
       a = []
-      arr.each {|v| a << v}
+      arr.each { |v| a << v }
 
-      assert_equal ["test1", "test2", "test3"], a
+      assert_equal %w(test1 test2 test3), a
     end
 
-    it "works when exiting the loop prematurely" do
+    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"
+      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"
+        break if v == 'test2'
       end
 
-      assert_equal ["test1", "test2"], a
+      assert_equal %w(test1 test2), a
     end
   end
 
-  it "includes Enumerable" do
+  it 'includes Enumerable' do
     GLib::PtrArray.must_include Enumerable
   end
 
-  it "has a working #to_a method" do
+  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"
+    GLib::PtrArray.add arr, 'test1'
+    GLib::PtrArray.add arr, 'test2'
+    GLib::PtrArray.add arr, 'test3'
 
-    assert_equal ["test1", "test2", "test3"], arr.to_a
+    assert_equal %w(test1 test2 test3), arr.to_a
   end
 
-  it "has #add as an instance method too" do
+  it 'has #add as an instance method too' do
     arr = GLib::PtrArray.new :utf8
-    arr.add "test1"
-    assert_equal ["test1"], arr.to_a
+    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, ["1", "2", "3"]
+  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 :==, ["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, ["1", "2", "3"]
+    it 'returns false when comparing to an array with different elements' do
+      arr = GLib::PtrArray.from :utf8, %w(1 2 3)
 
-      arr.wont_be :==, ["1", "2"]
+      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, ["1", "2", "3"]
-      other = GLib::PtrArray.from :utf8, ["1", "2", "3"]
+    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, ["1", "2", "3"]
-      other = GLib::PtrArray.from :utf8, ["1", "2"]
+    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, ["1", "2", "3"]
-      arr.index(1).must_equal "2"
+  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, ["1", "2", "3"]
+    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

data/test/ffi-glib/ruby_closure_test.rb

@@ -1,18 +1,18 @@
 require 'gir_ffi_test_helper'
 
 describe GObject::RubyClosure do
-  it "has a constructor with a mandatory block argument" do
+  it 'has a constructor with a mandatory block argument' do
     assert_raises ArgumentError do
       GObject::RubyClosure.new
     end
   end
 
-  it "is a kind of Closure" do
+  it 'is a kind of Closure' do
     c = GObject::RubyClosure.new {}
     assert_kind_of GObject::Closure, c
   end
 
-  it "is able to retrieve its block from its struct" do
+  it 'is able to retrieve its block from its struct' do
     a = 0
     c = GObject::RubyClosure.new { a = 2 }
     c2 = GObject::RubyClosure.wrap(c.to_ptr)
@@ -20,7 +20,7 @@ describe GObject::RubyClosure do
     assert_equal 2, a
   end
 
-  describe "its #marshaller singleton method" do
+  describe 'its #marshaller singleton method' do
     it "invokes its closure argument's block" do
       a = 0
       c = GObject::RubyClosure.new { a = 2 }
@@ -28,7 +28,7 @@ describe GObject::RubyClosure do
       assert_equal 2, a
     end
 
-    it "works when its closure argument is a GObject::Closure" do
+    it 'works when its closure argument is a GObject::Closure' do
       a = 0
       c = GObject::RubyClosure.new { a = 2 }
       c2 = GObject::Closure.wrap(c.to_ptr)
@@ -44,7 +44,7 @@ describe GObject::RubyClosure do
     end
   end
 
-  it "has GObject::Closure#invoke call its block" do
+  it 'has GObject::Closure#invoke call its block' do
     a = 0
     c = GObject::RubyClosure.new { a = 2 }
     c2 = GObject::Closure.wrap(c.to_ptr)

data/test/ffi-glib/s_list_test.rb

@@ -1,25 +1,25 @@
 require 'gir_ffi_test_helper'
 
 describe GLib::SList do
-  it "knows its element type" do
+  it 'knows its element type' do
     arr = GLib::SList.new :gint32
     assert_equal :gint32, arr.element_type
   end
 
-  describe "#prepend" do
-    it "prepends integer values" do
+  describe '#prepend' do
+    it 'prepends integer values' do
       lst = GLib::SList.new :gint32
       res = lst.prepend 1
       assert_equal 1, res.data
     end
 
-    it "prepends string values" do
+    it 'prepends string values' do
       lst = GLib::SList.new :utf8
-      res = lst.prepend "bla"
-      assert_equal "bla", res.data
+      res = lst.prepend 'bla'
+      assert_equal 'bla', res.data
     end
 
-    it "prepends multiple values into a single list" do
+    it 'prepends multiple values into a single list' do
       lst = GLib::SList.new :gint32
 
       res = lst.prepend 1
@@ -31,40 +31,40 @@ describe GLib::SList do
     end
   end
 
-  describe "::from" do
-    it "creates a GSList from a Ruby array" do
+  describe '::from' do
+    it 'creates a GSList from a Ruby array' do
       lst = GLib::SList.from :gint32, [3, 2, 1]
       assert_equal [3, 2, 1], lst.to_a
     end
 
-    it "return its argument if given a GSList" do
+    it 'return its argument if given a GSList' do
       lst = GLib::SList.from :gint32, [3, 2, 1]
       lst2 = GLib::SList.from :gint32, lst
       assert_equal lst, lst2
     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
       list = GLib::SList.from :gint32, [1, 2, 3]
 
       list.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
       list = GLib::SList.from :gint32, [1, 2, 3]
 
       list.wont_be :==, [1, 2]
     end
 
-    it "returns true when comparing to a list with the same elements" do
+    it 'returns true when comparing to a list with the same elements' do
       list = GLib::SList.from :gint32, [1, 2, 3]
       other = GLib::SList.from :gint32, [1, 2, 3]
 
       list.must_be :==, other
     end
 
-    it "returns false when comparing to a list with different elements" do
+    it 'returns false when comparing to a list with different elements' do
       list = GLib::SList.from :gint32, [1, 2, 3]
       other = GLib::SList.from :gint32, [1, 2]
 

data/test/ffi-glib/strv_test.rb

@@ -1,21 +1,21 @@
 require 'base_test_helper'
 
 describe GLib::Strv do
-  describe "::from" do
-    it "creates a Strv from a Ruby array" do
-      strv = GLib::Strv.from ["1", "2", "3"]
+  describe '::from' do
+    it 'creates a Strv from a Ruby array' do
+      strv = GLib::Strv.from %w(1 2 3)
       strv.must_be_instance_of GLib::Strv
-      strv.to_a.must_equal ["1", "2", "3"]
+      strv.to_a.must_equal %w(1 2 3)
     end
 
-    it "return its argument if given a Strv" do
-      strv = GLib::Strv.from ["1", "2", "3"]
+    it 'return its argument if given a Strv' do
+      strv = GLib::Strv.from %w(1 2 3)
       strv2 = GLib::Strv.from strv
       assert strv2.equal? strv
     end
 
-    it "wraps its argument if given a pointer" do
-      strv = GLib::Strv.from ["1", "2", "3"]
+    it 'wraps its argument if given a pointer' do
+      strv = GLib::Strv.from %w(1 2 3)
 
       pointer = strv.to_ptr
       pointer.must_be_kind_of FFI::Pointer
@@ -28,29 +28,29 @@ describe GLib::Strv do
     end
   end
 
-  describe "#==" do
-    it "returns true when comparing to an array with the same elements" do
-      strv = GLib::Strv.from ["1", "2", "3"]
+  describe '#==' do
+    it 'returns true when comparing to an array with the same elements' do
+      strv = GLib::Strv.from %w(1 2 3)
 
-      strv.must_be :==, ["1", "2", "3"]
+      strv.must_be :==, %w(1 2 3)
     end
 
-    it "returns false when comparing to an array with different elements" do
-      strv = GLib::Strv.from ["1", "2", "3"]
+    it 'returns false when comparing to an array with different elements' do
+      strv = GLib::Strv.from %w(1 2 3)
 
-      strv.wont_be :==, ["1", "2"]
+      strv.wont_be :==, %w(1 2)
     end
 
-    it "returns true when comparing to a strv with the same elements" do
-      strv = GLib::Strv.from ["1", "2", "3"]
-      other = GLib::Strv.from ["1", "2", "3"]
+    it 'returns true when comparing to a strv with the same elements' do
+      strv = GLib::Strv.from %w(1 2 3)
+      other = GLib::Strv.from %w(1 2 3)
 
       strv.must_be :==, other
     end
 
-    it "returns false when comparing to a strv with different elements" do
-      strv = GLib::Strv.from ["1", "2", "3"]
-      other = GLib::Strv.from ["1", "2"]
+    it 'returns false when comparing to a strv with different elements' do
+      strv = GLib::Strv.from %w(1 2 3)
+      other = GLib::Strv.from %w(1 2)
 
       strv.wont_be :==, other
     end