gir_ffi 0.14.1 → 0.15.4

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,72 +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_STRV).must_equal       'GStrv'
-    GObject.type_name(GObject::TYPE_HASH_TABLE).must_equal 'GHashTable'
-  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,140 +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
-  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 'automatic accessor methods' do
-    class AccessorTest < GObject::Object
-      def get_x
-        @x
-      end
-
-      def set_x(val)
-        @x = val
-      end
-    end
-
-    subject { AccessorTest.new }
-
-    it 'reads x by calling get_x' do
-      subject.set_x(1)
-      assert_equal 1, subject.x
-    end
-
-    it 'writes x by calling set_x' do
-      subject.x = 2
-      assert_equal 2, subject.x
-    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