gir_ffi 0.15.1 → 0.15.6

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

data/test/ffi-glib/variant_test.rb

@@ -1,12 +0,0 @@
-# frozen_string_literal: true
-
-require "gir_ffi_test_helper"
-
-describe GLib::Variant do
-  describe "#get_string" do
-    it "returns just the contained string" do
-      var = GLib::Variant.new_string("Foo")
-      _(var.get_string).must_equal "Foo"
-    end
-  end
-end

data/test/ffi-gobject/gobject_test.rb

@@ -1,76 +0,0 @@
-# frozen_string_literal: true
-
-require "gir_ffi_test_helper"
-
-require "ffi-gobject"
-
-GirFFI.setup :GIMarshallingTests
-
-describe GObject do
-  describe ".type_init" do
-    it "does not raise an error" do
-      GObject.type_init
-      pass
-    end
-  end
-
-  it "has constants for the fundamental GTypes" do
-    _(GObject::TYPE_INVALID).must_equal GObject.type_from_name("invalid")
-    _(GObject.type_name(GObject::TYPE_INVALID)).must_be_nil
-
-    _(GObject.type_name(GObject::TYPE_NONE)).must_equal       "void"
-    _(GObject.type_name(GObject::TYPE_INTERFACE)).must_equal  "GInterface"
-    _(GObject.type_name(GObject::TYPE_CHAR)).must_equal       "gchar"
-    _(GObject.type_name(GObject::TYPE_UCHAR)).must_equal      "guchar"
-    _(GObject.type_name(GObject::TYPE_BOOLEAN)).must_equal    "gboolean"
-    _(GObject.type_name(GObject::TYPE_INT)).must_equal        "gint"
-    _(GObject.type_name(GObject::TYPE_UINT)).must_equal       "guint"
-    _(GObject.type_name(GObject::TYPE_LONG)).must_equal       "glong"
-    _(GObject.type_name(GObject::TYPE_ULONG)).must_equal      "gulong"
-    _(GObject.type_name(GObject::TYPE_INT64)).must_equal      "gint64"
-    _(GObject.type_name(GObject::TYPE_UINT64)).must_equal     "guint64"
-    _(GObject.type_name(GObject::TYPE_ENUM)).must_equal       "GEnum"
-    _(GObject.type_name(GObject::TYPE_FLAGS)).must_equal      "GFlags"
-    _(GObject.type_name(GObject::TYPE_FLOAT)).must_equal      "gfloat"
-    _(GObject.type_name(GObject::TYPE_DOUBLE)).must_equal     "gdouble"
-    _(GObject.type_name(GObject::TYPE_STRING)).must_equal     "gchararray"
-    _(GObject.type_name(GObject::TYPE_POINTER)).must_equal    "gpointer"
-    _(GObject.type_name(GObject::TYPE_BOXED)).must_equal      "GBoxed"
-    _(GObject.type_name(GObject::TYPE_PARAM)).must_equal      "GParam"
-    _(GObject.type_name(GObject::TYPE_OBJECT)).must_equal     "GObject"
-    _(GObject.type_name(GObject::TYPE_GTYPE)).must_equal      "GType"
-    _(GObject.type_name(GObject::TYPE_VARIANT)).must_equal    "GVariant"
-
-    _(GObject.type_name(GObject::TYPE_ARRAY)).must_equal      "GArray"
-    _(GObject.type_name(GObject::TYPE_BYTE_ARRAY)).must_equal "GByteArray"
-    _(GObject.type_name(GObject::TYPE_ERROR)).must_equal      "GError"
-    _(GObject.type_name(GObject::TYPE_HASH_TABLE)).must_equal "GHashTable"
-    _(GObject.type_name(GObject::TYPE_STRV)).must_equal       "GStrv"
-  end
-
-  describe "::object_class_from_instance" do
-    it "returns a GObject::ObjectClass with the correct GType" do
-      obj = GIMarshallingTests::OverridesObject.new
-      object_class = GObject.object_class_from_instance obj
-      gtype = object_class.g_type_class.g_type
-
-      _(object_class).must_be_instance_of GObject::ObjectClass
-      _(gtype).must_equal GIMarshallingTests::OverridesObject.gtype
-    end
-  end
-
-  describe "creating ParamSpecs" do
-    describe "#param_spec_int" do
-      it "creates a GObject::ParamSpecInt" do
-        spec = GObject.param_spec_int("foo", "foo bar",
-                                      "The Foo Bar Property",
-                                      10, 20, 15,
-                                      3)
-        _(spec).must_be_instance_of GObject::ParamSpecInt
-        _(spec.struct[:minimum]).must_equal 10
-        _(spec.struct[:maximum]).must_equal 20
-        _(spec.get_default_value).must_equal 15
-      end
-    end
-  end
-end

data/test/ffi-gobject/object_class_test.rb

@@ -1,31 +0,0 @@
-# frozen_string_literal: true
-
-require "gir_ffi_test_helper"
-
-require "ffi-gobject"
-
-describe GObject::ObjectClass do
-  describe "#list_properties" do
-    it "returns GIMarshallingTests::OverridesObject's properties" do
-      obj = GIMarshallingTests::OverridesObject.new
-      object_class = GObject.object_class_from_instance obj
-
-      info = get_introspection_data "GIMarshallingTests", "OverridesObject"
-      expected_props = info.properties.map(&:name)
-      expected_props += info.parent.properties.map(&:name)
-
-      props = object_class.list_properties
-      prop_names = props.map(&:get_name)
-
-      _(prop_names.sort).must_equal expected_props.sort
-    end
-  end
-
-  describe "#gtype" do
-    it "returns the correct GType" do
-      obj = GIMarshallingTests::OverridesObject.new
-      object_class = GObject.object_class_from_instance obj
-      _(object_class.gtype).must_equal GIMarshallingTests::OverridesObject.gtype
-    end
-  end
-end

data/test/ffi-gobject/object_test.rb

@@ -1,122 +0,0 @@
-# frozen_string_literal: true
-
-require "gir_ffi_test_helper"
-
-require "ffi-gobject"
-GirFFI.setup :GIMarshallingTests
-
-describe GObject::Object do
-  describe ".new" do
-    it "is overridden to take only one argument" do
-      _(GObject::Object.new({})).must_be_instance_of GObject::Object
-    end
-
-    it "can be used to create objects with properties" do
-      obj = GIMarshallingTests::SubObject.new(int: 13)
-      _(obj.int).must_equal 13
-    end
-
-    it "allows omission of the first argument" do
-      _(GObject::Object.new).must_be_instance_of GObject::Object
-    end
-
-    it "raises an error for properties that do not exist" do
-      _(proc { GObject::Object.new(dog: "bark") }).must_raise GirFFI::PropertyNotFoundError
-    end
-  end
-
-  describe "#get_property" do
-    it "is overridden to have arity 1" do
-      _(GObject::Object.instance_method("get_property").arity).must_equal 1
-    end
-
-    it "raises an error for a property that does not exist" do
-      instance = GObject::Object.new
-      _(proc { instance.get_property "foo-bar" }).must_raise GirFFI::PropertyNotFoundError
-    end
-
-    it "raises an error for a property that does not exist" do
-      instance = GObject::Object.new
-      _(proc { instance.get_property "foo-bar" })
-        .must_raise GirFFI::PropertyNotFoundError
-    end
-  end
-
-  describe "#get_property_extended" do
-    it "raises an error for a property that does not exist" do
-      instance = GObject::Object.new
-      _(proc { instance.get_property_extended "foo-bar" })
-        .must_raise GirFFI::PropertyNotFoundError
-    end
-  end
-
-  describe "#set_property" do
-    it "raises an error for a property that does not exist" do
-      instance = GObject::Object.new
-      _(proc { instance.set_property "foo-bar", 123 }).must_raise GirFFI::PropertyNotFoundError
-    end
-  end
-
-  describe "#set_property_extended" do
-    it "raises an error for a property that does not exist" do
-      instance = GObject::Object.new
-      _(proc { instance.set_property_extended "foo-bar", 123 })
-        .must_raise GirFFI::PropertyNotFoundError
-    end
-  end
-
-  describe "#signal_connect" do
-    subject { GObject::Object.new }
-
-    it "delegates to GObject" do
-      expect(GObject).to receive(:signal_connect).with(subject, "some-event", nil)
-      subject.signal_connect("some-event") do
-        nothing
-      end
-    end
-
-    it "delegates to GObject if an optional data argument is passed" do
-      expect(GObject).to receive(:signal_connect).with(subject, "some-event", "data")
-      subject.signal_connect("some-event", "data") do
-        nothing
-      end
-    end
-  end
-
-  describe "#signal_connect_after" do
-    subject { GObject::Object.new }
-
-    it "delegates to GObject" do
-      expect(GObject).to receive(:signal_connect_after).with(subject, "some-event", nil)
-      subject.signal_connect_after("some-event") do
-        nothing
-      end
-    end
-
-    it "delegates to GObject if an optional data argument is passed" do
-      expect(GObject).to receive(:signal_connect_after).with(subject, "some-event", "data")
-      subject.signal_connect_after("some-event", "data") do
-        nothing
-      end
-    end
-  end
-
-  describe "upon garbage collection" do
-    it "lowers the reference count" do
-      skip "cannot be reliably tested on JRuby and Rubinius" if jruby? || rubinius?
-
-      ptr = GObject::Object.new.to_ptr
-      _(object_ref_count(ptr)).must_equal 1
-
-      GC.start
-      # Creating a new object is sometimes needed to trigger enough garbage collection.
-      GObject::Object.new
-      sleep 1
-
-      GC.start
-      GC.start
-
-      _(object_ref_count(ptr)).must_equal 0
-    end
-  end
-end

data/test/ffi-gobject/param_spec_test.rb

@@ -1,32 +0,0 @@
-# frozen_string_literal: true
-
-require "gir_ffi_test_helper"
-
-require "ffi-gobject"
-describe GObject::ParamSpec do
-  let(:pspec) do
-    GObject.param_spec_int("foo-bar", "foo bar",
-                           "Foo Bar",
-                           1, 3, 2,
-                           readable: true, writable: true)
-  end
-  let(:pspec_struct) { GObject::ParamSpec::Struct.new(pspec.to_ptr) }
-
-  describe "#ref" do
-    it "increases the ref count" do
-      old = pspec_struct[:ref_count]
-      pspec.ref
-      _(pspec_struct[:ref_count]).must_equal old + 1
-    end
-  end
-
-  describe "#accessor_name" do
-    it "returns a safe ruby method name" do
-      _(pspec.accessor_name).must_equal "foo_bar"
-    end
-  end
-
-  it "cannot be instantiated directly" do
-    _(proc { GObject::ParamSpec.new }).must_raise NoMethodError
-  end
-end