gir_ffi 0.15.3 → 0.15.4

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,123 +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" if jruby?
-
-      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

data/test/ffi-gobject/value_test.rb

@@ -1,390 +0,0 @@
-# frozen_string_literal: true
-
-require "gir_ffi_test_helper"
-
-GirFFI.setup :Regress
-GirFFI.setup :Gio
-
-describe GObject::Value do
-  describe "::Struct" do
-    describe "layout" do
-      let(:layout) { GObject::Value::Struct.layout }
-
-      it "consists of :g_type and :data" do
-        _(layout.members).must_equal [:g_type, :data]
-      end
-
-      it "has an array as its second element" do
-        types = layout.fields.map(&:type)
-        _(types[1].class).must_equal FFI::Type::Array
-      end
-    end
-  end
-
-  describe ".for_gtype" do
-    it "handles char" do
-      gv = GObject::Value.for_gtype GObject::TYPE_CHAR
-      _(gv.current_gtype).must_equal GObject::TYPE_CHAR
-    end
-
-    it "handles invalid type" do
-      gv = GObject::Value.for_gtype GObject::TYPE_INVALID
-      _(gv.current_gtype).must_equal GObject::TYPE_INVALID
-    end
-
-    it "handles void type" do
-      gv = GObject::Value.for_gtype GObject::TYPE_NONE
-      _(gv.current_gtype).must_equal GObject::TYPE_INVALID
-    end
-  end
-
-  describe "::wrap_ruby_value" do
-    it "wraps a boolean false" do
-      gv = GObject::Value.wrap_ruby_value false
-      assert_instance_of GObject::Value, gv
-      _(gv.get_boolean).must_equal false
-    end
-
-    it "wraps a boolean true" do
-      gv = GObject::Value.wrap_ruby_value true
-      assert_instance_of GObject::Value, gv
-      _(gv.get_boolean).must_equal true
-    end
-
-    it "wraps an Integer" do
-      gv = GObject::Value.wrap_ruby_value 42
-      _(gv.get_int).must_equal 42
-    end
-
-    it "wraps a String" do
-      gv = GObject::Value.wrap_ruby_value "Some Random String"
-      _(gv.get_string).must_equal "Some Random String"
-    end
-
-    it "wraps nil" do
-      gv = GObject::Value.wrap_ruby_value nil
-      assert_instance_of GObject::Value, gv
-      _(gv.get_value).must_be_nil
-    end
-
-    it "wraps object values" do
-      value = GObject::Object.new({})
-      gv = GObject::Value.wrap_ruby_value value
-      _(object_ref_count(value)).must_equal 2
-      _(gv.get_value).must_equal value
-      _(object_ref_count(value)).must_equal 3
-    end
-  end
-
-  describe "#set_value" do
-    it "handles signed char values" do
-      value = -83
-      gv = GObject::Value.for_gtype GObject::TYPE_CHAR
-      gv.set_value value
-      _(gv.get_schar).must_equal value
-    end
-
-    it "handles unsigned char values" do
-      value = 174
-      gv = GObject::Value.for_gtype GObject::TYPE_UCHAR
-      gv.set_value value
-      _(gv.get_uchar).must_equal value
-    end
-
-    it "handles enum values presented as symbols" do
-      value = :value2
-      gv = GObject::Value.for_gtype Regress::TestEnum.gtype
-      gv.set_value value
-      _(gv.get_value).must_equal value
-    end
-
-    it "handles enum values presented as numbers" do
-      value = :value2
-      gv = GObject::Value.for_gtype Regress::TestEnum.gtype
-      gv.set_value Regress::TestEnum[value]
-      _(gv.get_value).must_equal value
-    end
-
-    it "handles flag values presented as hashes" do
-      value = { flag2: true }
-      gv = GObject::Value.for_gtype Regress::TestFlags.gtype
-      gv.set_value value
-      _(gv.get_value).must_equal value
-    end
-
-    it "handles flag values presented as symbols" do
-      gv = GObject::Value.for_gtype Regress::TestFlags.gtype
-      gv.set_value :flag2
-      _(gv.get_value).must_equal(flag2: true)
-    end
-
-    it "handles flag values presented as numbers" do
-      value = { flag2: true }
-      gv = GObject::Value.for_gtype Regress::TestFlags.gtype
-      gv.set_value Regress::TestFlags.to_native(value, nil)
-      _(gv.get_value).must_equal value
-    end
-
-    it "handles GType values" do
-      value = GObject::TYPE_STRING
-      gv = GObject::Value.for_gtype GObject::TYPE_GTYPE
-      gv.set_value value
-      _(gv.get_gtype).must_equal value
-    end
-
-    it "handles int64 values" do
-      value = 0x1234_5678_9012_3456
-      gv = GObject::Value.for_gtype GObject::TYPE_INT64
-      gv.set_value value
-      _(gv.get_int64).must_equal value
-    end
-
-    it "handles long values" do
-      value = FFI.type_size(:long) == 8 ? 0x1234_5678_9012_3456 : 0x1234_5678
-      gv = GObject::Value.for_gtype GObject::TYPE_LONG
-      gv.set_value value
-      _(gv.get_long).must_equal value
-    end
-
-    it "handles uchar values" do
-      value = 83
-      gv = GObject::Value.for_gtype GObject::TYPE_UCHAR
-      gv.set_value value
-      _(gv.get_uchar).must_equal value
-    end
-
-    it "handles uint values" do
-      value = 0x1234_5678
-      gv = GObject::Value.for_gtype GObject::TYPE_UINT
-      gv.set_value value
-      _(gv.get_uint).must_equal value
-    end
-
-    it "handles uint64 values" do
-      value = 0x1234_5678_9012_3456
-      gv = GObject::Value.for_gtype GObject::TYPE_UINT64
-      gv.set_value value
-      _(gv.get_uint64).must_equal value
-    end
-
-    it "handles ulong values" do
-      value = FFI.type_size(:long) == 8 ? 0x1234_5678_9012_3456 : 0x1234_5678
-      gv = GObject::Value.for_gtype GObject::TYPE_ULONG
-      gv.set_value value
-      _(gv.get_ulong).must_equal value
-    end
-
-    it "handles variant values" do
-      value = GLib::Variant.new_string("Foo")
-      gv = GObject::Value.for_gtype GObject::TYPE_VARIANT
-      gv.set_value value
-      _(gv.get_variant).must_equal value
-    end
-
-    it "handles object values" do
-      value = GObject::Object.new({})
-      gv = GObject::Value.for_gtype GObject::Object.gtype
-      gv.set_value value
-      _(gv.get_object).must_equal value
-    end
-
-    it "handles interface values" do
-      value = Gio.file_new_for_path("/")
-      gv = GObject::Value.for_gtype Gio::File.gtype
-      gv.set_value value
-      _(gv.get_object).must_equal value
-    end
-  end
-
-  describe "#get_value" do
-    it "unwraps a boolean false" do
-      gv = GObject::Value.wrap_ruby_value false
-      result = gv.get_value
-      _(result).must_equal false
-    end
-
-    it "unwraps a boolean true" do
-      gv = GObject::Value.wrap_ruby_value true
-      result = gv.get_value
-      _(result).must_equal true
-    end
-
-    it "unwraps a signed char" do
-      value = -42
-      gv = GObject::Value.for_gtype GObject::TYPE_CHAR
-      gv.set_schar value
-      _(gv.get_value).must_equal value
-    end
-
-    it "unwraps an unsigned char" do
-      value = 173
-      gv = GObject::Value.for_gtype GObject::TYPE_UCHAR
-      gv.set_uchar value
-      _(gv.get_value).must_equal value
-    end
-
-    it "unwraps an enum value" do
-      value = :value2
-      gv = GObject::Value.for_gtype Regress::TestEnum.gtype
-      gv.set_enum Regress::TestEnum[value]
-      _(gv.get_value).must_equal value
-    end
-
-    it "unwraps a flags value" do
-      value = { flag1: true, flag3: true }
-      gv = GObject::Value.for_gtype Regress::TestFlags.gtype
-      gv.set_flags Regress::TestFlags.to_native(value, nil)
-      _(gv.get_value).must_equal value
-    end
-
-    it "unwraps a GType" do
-      value = GObject::TYPE_STRING
-      gv = GObject::Value.for_gtype GObject::TYPE_GTYPE
-      gv.set_gtype value
-      _(gv.get_value).must_equal value
-    end
-
-    it "unwraps an int64" do
-      value = 0x1234_5678_9012_3456
-      gv = GObject::Value.for_gtype GObject::TYPE_INT64
-      gv.set_int64 value
-      _(gv.get_value).must_equal value
-    end
-
-    it "unwraps a long" do
-      value = FFI.type_size(:long) == 8 ? 0x1234_5678_9012_3456 : 0x1234_5678
-      gv = GObject::Value.for_gtype GObject::TYPE_LONG
-      gv.set_long value
-      _(gv.get_value).must_equal value
-    end
-
-    it "unwraps an uchar" do
-      value = 3
-      gv = GObject::Value.for_gtype GObject::TYPE_UCHAR
-      gv.set_uchar value
-      _(gv.get_value).must_equal value
-    end
-
-    it "unwraps an uint" do
-      value = 0x1234_5678
-      gv = GObject::Value.for_gtype GObject::TYPE_UINT
-      gv.set_uint value
-      _(gv.get_value).must_equal value
-    end
-
-    it "unwraps an uint64" do
-      value = 0x1234_5678_9012_3456
-      gv = GObject::Value.for_gtype GObject::TYPE_UINT64
-      gv.set_uint64 value
-      _(gv.get_value).must_equal value
-    end
-
-    it "unwraps an ulong" do
-      value = FFI.type_size(:long) == 8 ? 0x1234_5678_9012_3456 : 0x1234_5678
-      gv = GObject::Value.for_gtype GObject::TYPE_ULONG
-      gv.set_ulong value
-      _(gv.get_value).must_equal value
-    end
-
-    it "unwraps a variant" do
-      value = GLib::Variant.new_string("Foo")
-      gv = GObject::Value.for_gtype GObject::TYPE_VARIANT
-      gv.set_variant value
-      _(gv.get_value).must_equal value
-    end
-
-    it "works with a ByteArray" do
-      ba = GLib::ByteArray.new.append("some bytes")
-      v = GObject::Value.for_gtype GObject::TYPE_BYTE_ARRAY
-      v.set_boxed ba
-
-      result = v.get_value
-
-      _(result.to_string).must_equal "some bytes"
-      _(result).must_be_kind_of GLib::ByteArray
-    end
-
-    it "works with an Array" do
-      arr = GLib::Array.from(:uint, [1, 2, 3])
-      v = GObject::Value.for_gtype GObject::TYPE_ARRAY
-      v.set_boxed arr
-
-      result = v.get_value
-
-      _(result).must_be_kind_of GLib::Array
-      _(result.reset_typespec(:uint).to_a).must_equal [1, 2, 3]
-    end
-
-    it "unwraps a Strv" do
-      strv = GLib::Strv.from %w(foo bar)
-      val = GObject::Value.for_gtype GObject::TYPE_STRV
-      val.set_boxed strv
-
-      result = val.get_value
-
-      _(result).must_be_kind_of GLib::Strv
-      _(result.to_a).must_equal %w(foo bar)
-    end
-  end
-
-  describe "::from" do
-    it "creates a gint GValue from a Ruby Integer" do
-      gv = GObject::Value.from 21
-      _(gv.current_gtype_name).must_equal "gint"
-      _(gv.get_value).must_equal 21
-    end
-
-    it "returns its argument if given a GValue" do
-      gv = GObject::Value.from 21
-      gv2 = GObject::Value.from gv
-      _(gv2.current_gtype_name).must_equal "gint"
-      _(gv2.get_value).must_equal 21
-    end
-
-    it "creates a null GValue from a Ruby nil" do
-      gv = GObject::Value.from nil
-      _(gv.current_gtype).must_equal GObject::TYPE_INVALID
-      _(gv.get_value).must_be_nil
-    end
-  end
-
-  describe "#set_value" do
-    before do
-      GirFFI.setup :GIMarshallingTests
-    end
-
-    it "raises an error when setting an incompatible object type" do
-      o = GIMarshallingTests::Object.new 1
-      v = GObject::Value.new.init(GIMarshallingTests::OverridesObject.gtype)
-      _(proc { v.set_value o }).must_raise ArgumentError
-    end
-
-    it "works with a ByteArray" do
-      ba = GLib::ByteArray.new.append("some bytes")
-      v = GObject::Value.new.init(GObject.type_from_name("GByteArray"))
-      v.set_value ba
-      _(v.get_value.to_string).must_equal "some bytes"
-    end
-  end
-
-  describe "upon garbage collection" do
-    it "restores the underlying GValue to its pristine state" do
-      skip "cannot be reliably tested on JRuby" if jruby?
-
-      value = GObject::Value.from 42
-
-      # Drop reference to original GObject::Value
-      value = GObject::Value.wrap value.to_ptr
-      _(value.current_gtype_name).must_equal "gint"
-
-      GC.start
-      # Creating a new object is sometimes needed to trigger enough garbage collection.
-      GObject::Value.new
-      sleep 1
-      GC.start
-      GC.start
-
-      _(value.current_gtype_name).wont_equal "gint"
-    end
-  end
-end