gir_ffi 0.15.3 → 0.15.4

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

data/test/ffi-glib/ruby_closure_test.rb

@@ -1,62 +0,0 @@
-# frozen_string_literal: true
-
-require "gir_ffi_test_helper"
-
-describe GObject::RubyClosure do
-  describe ".new" do
-    it "takes a mandatory block argument" do
-      assert_raises ArgumentError do
-        GObject::RubyClosure.new
-      end
-    end
-
-    it "returns a kind of Closure" do
-      c = GObject::RubyClosure.new {}
-      assert_kind_of GObject::Closure, c
-    end
-  end
-
-  describe ".wrap" do
-    it "returns a fully functional object that can invoke the original block" do
-      a = 0
-      c = GObject::RubyClosure.new { a = 2 }
-      c2 = GObject::RubyClosure.wrap(c.to_ptr)
-      c2.invoke_block
-      assert_equal 2, a
-    end
-  end
-
-  describe ".marshaller" do
-    it "invokes its closure argument's block" do
-      a = 0
-      c = GObject::RubyClosure.new { a = 2 }
-      GObject::RubyClosure.marshaller(c, nil, nil, nil, nil)
-      assert_equal 2, a
-    end
-
-    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)
-      GObject::RubyClosure.marshaller(c2, nil, nil, nil, nil)
-      assert_equal 2, a
-    end
-
-    it "stores the closure's return value in the proper gvalue" do
-      c = GObject::RubyClosure.new { 2 }
-      gv = GObject::Value.new.init GObject::TYPE_INT
-      GObject::RubyClosure.marshaller(c, gv, nil, nil, nil)
-      assert_equal 2, gv.get_value
-    end
-  end
-
-  describe "#invoke" do
-    it "invokes the ruby block" do
-      a = 0
-      c = GObject::RubyClosure.new { a = 2 }
-      c2 = GObject::Closure.wrap(c.to_ptr)
-      c2.invoke nil, []
-      assert_equal 2, a
-    end
-  end
-end

data/test/ffi-glib/s_list_test.rb

@@ -1,76 +0,0 @@
-# frozen_string_literal: true
-
-require "gir_ffi_test_helper"
-
-describe GLib::SList 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
-      lst = GLib::SList.new :gint32
-      res = lst.prepend 1
-      assert_equal 1, res.data
-    end
-
-    it "prepends string values" do
-      lst = GLib::SList.new :utf8
-      res = lst.prepend "bla"
-      assert_equal "bla", res.data
-    end
-
-    it "prepends multiple values into a single list" do
-      lst = GLib::SList.new :gint32
-
-      res = lst.prepend 1
-      res2 = res.prepend 2
-
-      assert_equal 2, res2.data
-      assert_equal 1, res.data
-      assert_equal res.to_ptr, res2.next.to_ptr
-    end
-  end
-
-  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
-      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
-      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
-      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
-      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
-      list = GLib::SList.from :gint32, [1, 2, 3]
-      other = GLib::SList.from :gint32, [1, 2]
-
-      _(list).wont_be :==, other
-    end
-  end
-end

data/test/ffi-glib/strv_test.rb

@@ -1,60 +0,0 @@
-# frozen_string_literal: true
-
-require "base_test_helper"
-
-describe GLib::Strv do
-  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 %w(1 2 3)
-    end
-
-    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 %w(1 2 3)
-
-      pointer = strv.to_ptr
-      _(pointer).must_be_kind_of FFI::Pointer
-
-      strv2 = GLib::Strv.from pointer
-
-      _(strv2).must_be_kind_of GLib::Strv
-      refute strv2.equal? strv
-      _(strv2.to_a).must_equal strv.to_a
-    end
-  end
-
-  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 :==, %w(1 2 3)
-    end
-
-    it "returns false when comparing to an array with different elements" do
-      strv = GLib::Strv.from %w(1 2 3)
-
-      _(strv).wont_be :==, %w(1 2)
-    end
-
-    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 %w(1 2 3)
-      other = GLib::Strv.from %w(1 2)
-
-      _(strv).wont_be :==, other
-    end
-  end
-end