gir_ffi 0.4.0 → 0.4.1

data/lib/ffi-glib/strv.rb

@@ -1,31 +0,0 @@
-module GLib
-  # Represents a null-terminated array of strings.
-  class Strv
-    include Enumerable
-
-    POINTER_SIZE = FFI.type_size(:pointer)
-
-    def initialize ptr
-      @ptr = ptr
-    end
-
-    def to_ptr
-      @ptr
-    end
-
-    def each
-      return if @ptr.null?
-      offset = 0
-      loop do
-        ptr = @ptr.get_pointer offset
-        break if ptr.null?
-        yield ptr.read_string
-        offset += POINTER_SIZE
-      end
-    end
-
-    def self.wrap ptr
-      self.new ptr
-    end
-  end
-end

data/test/builder_test.rb

@@ -1,264 +0,0 @@
-require File.expand_path('gir_ffi_test_helper.rb', File.dirname(__FILE__))
-
-class BuilderTest < MiniTest::Spec
-  context "The GirFFI::Builder module" do
-    setup do
-      @gir = GObjectIntrospection::IRepository.default
-    end
-
-    context "building GObject::Object" do
-      before do
-	save_module :GObject
-	GirFFI::Builder.build_class get_introspection_data('GObject', 'Object')
-      end
-
-      should "create a Lib module in the parent namespace ready to attach functions from gobject-2.0" do
-	expected = @gir.shared_library('GObject')
-	assert_equal [expected], GObject::Lib.ffi_libraries.map(&:name)
-      end
-
-      should "create an array CALLBACKS inside the GObject::Lib module" do
-	assert_equal [], GObject::Lib::CALLBACKS
-      end
-
-      should "not replace existing classes" do
-	oldclass = GObject::Object
-	GirFFI::Builder.build_class get_introspection_data('GObject', 'Object')
-	assert_equal oldclass, GObject::Object
-      end
-
-      after do
-        restore_module :GObject
-      end
-    end
-
-    context "looking at Regress.test_callback_destroy_notify" do
-      before do
-	save_module :GLib
-	save_module :GObject
-	save_module :Regress
-	GirFFI::Builder.build_module 'GLib'
-	GirFFI::Builder.build_module 'GObject'
-	GirFFI::Builder.build_module 'Regress'
-	@go = get_introspection_data 'Regress', 'test_callback_destroy_notify'
-      end
-
-      should "have the correct types of the arguments for the attached function" do
-	argtypes = GirFFI::Builder.send(:ffi_function_argument_types, @go)
-	assert_equal [Regress::TestCallbackUserData, :pointer, GLib::DestroyNotify],
-	  argtypes
-      end
-
-      should "define ffi callback types :Callback and :ClosureNotify" do
-	Regress._setup_method 'test_callback_destroy_notify'
-	tcud = Regress::Lib.find_type :TestCallbackUserData
-	dn = GLib::Lib.find_type :DestroyNotify
-
-	assert_equal FFI.find_type(:int32), tcud.result_type
-	assert_equal FFI.find_type(:void), dn.result_type
-	assert_equal [FFI.find_type(:pointer)], tcud.param_types
-	assert_equal [FFI.find_type(:pointer)], dn.param_types
-      end
-
-      # FIXME: Test passes but does not test what it claims to test.
-      should "define ffi enum type ConnectFlags" do
-	assert_equal({:after => 1, :swapped => 2}, GObject::ConnectFlags.to_h)
-      end
-
-      after do
-	restore_module :Regress
-	restore_module :GObject
-	restore_module :GLib
-      end
-    end
-
-    context "building Regress::TestStructA" do
-      setup do
-	GirFFI::Builder.build_class get_introspection_data('Regress', 'TestStructA')
-      end
-
-      should "set up the correct struct members" do
-	assert_equal [:some_int, :some_int8, :some_double, :some_enum],
-	  Regress::TestStructA::Struct.members
-      end
-
-      should "set up struct members with the correct offset" do
-	info = @gir.find_by_name 'Regress', 'TestStructA'
-	assert_equal info.fields.map{|f| [f.name.to_sym, f.offset]},
-	  Regress::TestStructA::Struct.offsets
-      end
-
-      should "set up struct members with the correct types" do
-	tags = [:int, :int8, :double, Regress::TestEnum]
-	assert_equal tags.map {|t| FFI.find_type t},
-	  Regress::TestStructA::Struct.layout.fields.map {|f| f.type}
-      end
-    end
-
-    context "building GObject::TypeCValue" do
-      setup do
-	GirFFI::Builder.build_class get_introspection_data('GObject', 'TypeCValue')
-      end
-
-      should "set up the correct union members" do
-	assert_equal [:v_int, :v_long, :v_int64, :v_double, :v_pointer],
-	  GObject::TypeCValue::Struct.members
-      end
-
-      should "set up union members with the correct offset" do
-	assert_equal [0, 0, 0, 0, 0],
-	  GObject::TypeCValue::Struct.offsets.map {|o| o[1]}
-      end
-
-      should "set up the inner class as derived from FFI::Union" do
-	assert_equal FFI::Union, GObject::TypeCValue::Struct.superclass
-      end
-    end
-
-    context "building GObject::ValueArray" do
-      should "use provided constructor if present" do
-	GirFFI::Builder.build_class get_introspection_data('GObject', 'ValueArray')
-	assert_nothing_raised {
-	  GObject::ValueArray.new 2
-	}
-      end
-    end
-
-    context "building Regress::TestBoxed" do
-      setup do
-	GirFFI::Builder.build_class get_introspection_data('Regress', 'TestBoxed')
-      end
-
-      should "set up #wrap" do
-	assert Regress::TestBoxed.respond_to? "wrap"
-      end
-
-      should "set up #allocate" do
-	assert Regress::TestBoxed.respond_to? "allocate"
-      end
-    end
-
-    context "built Regress module" do
-      before do
-	save_module :Regress
-	GirFFI::Builder.build_module 'Regress'
-      end
-
-      should "autocreate singleton methods" do
-        refute_defines_singleton_method Regress, :test_uint
-        Regress.test_uint 31
-        assert_defines_singleton_method Regress, :test_uint
-      end
-
-      should "autocreate the TestObj class" do
-	assert !Regress.const_defined?(:TestObj)
-	assert_nothing_raised {Regress::TestObj}
-	assert Regress.const_defined? :TestObj
-      end
-
-      should "know its own module builder" do
-	assert GirFFI::Builder::Module === Regress._builder
-      end
-
-      after do
-        restore_module :Regress
-      end
-    end
-
-    context "built Regress::TestObj" do
-      before do
-	save_module :Regress
-	GirFFI::Builder.build_class get_introspection_data('Regress', 'TestObj')
-      end
-
-      should "make autocreated instance method available to all instances" do
-	o1 = Regress::TestObj.new_from_file("foo")
-	o2 = Regress::TestObj.new_from_file("foo")
-	o1.instance_method
-	Regress::TestObj.class_eval do
-	  undef method_missing
-	end
-	assert_nothing_raised { o2.instance_method }
-      end
-
-      should "attach C functions to Regress::Lib" do
-	o = Regress::TestObj.new_from_file("foo")
-	o.instance_method
-	assert Regress::Lib.respond_to? :regress_test_obj_instance_method
-      end
-
-      should "know its own GIR info" do
-	assert_equal 'TestObj', Regress::TestObj.gir_info.name
-      end
-
-      should "know its own class builder" do
-	assert GirFFI::Builder::Type::Base === Regress::TestObj._builder
-      end
-
-      context "its #torture_signature_0 method" do
-	should "have the correct types of the arguments for the attached function" do
-	  info = get_method_introspection_data 'Regress', 'TestObj',
-	    'torture_signature_0'
-	  assert_equal [:pointer, :int32, :pointer, :pointer, :pointer, :pointer, :uint32],
-	    GirFFI::Builder.send(:ffi_function_argument_types, info)
-	end
-      end
-
-      after do
-        restore_module :Regress
-      end
-    end
-
-    context "built Regress::TestSubObj" do
-      before do
-	save_module :Regress
-	GirFFI::Builder.build_class get_introspection_data('Regress', 'TestSubObj')
-      end
-
-      should "autocreate parent class' set_bare inside the parent class" do
-	o1 = Regress::TestSubObj.new
-	o2 = Regress::TestObj.new_from_file("foo")
-
-	assert_nothing_raised {o1.set_bare(nil)}
-
-	Regress::TestObj.class_eval do
-	  undef method_missing
-	end
-
-	assert_nothing_raised {o2.set_bare(nil)}
-      end
-
-      should "use its own version of instance_method when parent's version has been created" do
-	obj = Regress::TestObj.new_from_file("foo")
-	assert_equal(-1, obj.instance_method)
-	subobj = Regress::TestSubObj.new
-	assert_equal 0, subobj.instance_method
-      end
-
-      after do
-        restore_module :Regress
-      end
-    end
-
-    context "built Gio::ThreadedSocketService" do
-      before do
-	save_module :Gio
-	GirFFI::Builder.build_module 'Gio'
-      end
-
-      context "when parent constructor has been called" do
-	setup do
-	  Gio::SocketService.new
-	end
-
-	should "still use its own constructor" do
-	  assert_nothing_raised { Gio::ThreadedSocketService.new 2 }
-	end
-      end
-
-      after do
-        restore_module :Gio
-      end
-    end
-  end
-end

data/test/ffi-glib/glib_overrides_test.rb

@@ -1,38 +0,0 @@
-require File.expand_path('../gir_ffi_test_helper.rb', File.dirname(__FILE__))
-
-require 'ffi-glib'
-
-describe "With the GLib overrides" 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
-      a = {}
-      @hash.each {|k, v| a[k] = v}
-      a.must_be :==, {"foo" => "bar", "baz" => "bat",
-        "qux" => "quux"}
-    end
-
-    it "includes Enumerable" do
-      GLib::HashTable.must_include Enumerable 
-    end
-
-    it "has a working #to_hash method" do
-      @hash.to_hash.must_be :==, {"foo" => "bar", "baz" => "bat",
-        "qux" => "quux"}
-    end
-  end
-
-  describe "HashTable" do
-    it "allows key-value pairs to be inserted" do
-      h = GLib::HashTable.new :utf8, :utf8
-      h.insert "foo", "bar"
-      h.to_hash.must_be :==, {"foo" => "bar"}
-    end
-  end
-end
-
-

data/test/ffi-gobject/g_object_overrides_test.rb

@@ -1,274 +0,0 @@
-require File.expand_path('../gir_ffi_test_helper.rb', File.dirname(__FILE__))
-
-require 'ffi-gobject'
-
-class GObjectOverridesTest < MiniTest::Spec
-  context "In the GObject module with overridden functions" do
-    setup do
-      GirFFI.setup :Regress
-    end
-
-    context "the signal_emit function" do
-      should "emit a signal" do
-	a = 1
-	o = Regress::TestSubObj.new
-	::GObject::Lib.g_signal_connect_data o, "test", Proc.new { a = 2 }, nil, nil, 0
-	GObject.signal_emit o, "test"
-	assert_equal 2, a
-      end
-
-      should "handle return values" do
-	s = Gio::SocketService.new
-
-	argtypes = [:pointer, :pointer, :pointer, :pointer]
-	callback = FFI::Function.new(:bool, argtypes) { |a,b,c,d| true }
-	::GObject::Lib.g_signal_connect_data s, "incoming", callback, nil, nil, 0
-	rv = GObject.signal_emit s, "incoming"
-	assert_equal true, rv.get_boolean
-      end
-
-      should "pass in extra arguments" do
-	o = Regress::TestSubObj.new
-	sb = Regress::TestSimpleBoxedA.new
-	sb.some_int8 = 31
-	sb.some_double = 2.42
-	sb.some_enum = :value2
-	b2 = nil
-
-	argtypes = [:pointer, :pointer, :pointer]
-	callback = FFI::Function.new(:void, argtypes) do |a,b,c|
-	  b2 = b
-	end
-	::GObject::Lib.g_signal_connect_data o, "test-with-static-scope-arg", callback, nil, nil, 0
-	GObject.signal_emit o, "test-with-static-scope-arg", sb
-
-	sb2 = Regress::TestSimpleBoxedA.wrap b2
-	assert sb.equals(sb2)
-      end
-    end
-
-    context "the signal_connect function" do
-      should "install a signal handler" do
-	a = 1
-	o = Regress::TestSubObj.new
-	GObject.signal_connect(o, "test") { a = 2 }
-	GObject.signal_emit o, "test"
-	assert_equal 2, a
-      end
-
-      should "pass user data to handler" do
-	a = 1
-	o = Regress::TestSubObj.new
-	GObject.signal_connect(o, "test", 2) { |i, d| a = d }
-	GObject.signal_emit o, "test"
-	assert_equal 2, a
-      end
-
-      should "pass object to handler" do
-	o = Regress::TestSubObj.new
-	o2 = nil
-	GObject.signal_connect(o, "test") { |i, d| o2 = i }
-	GObject.signal_emit o, "test"
-	assert_instance_of Regress::TestSubObj, o2
-	assert_equal o.to_ptr, o2.to_ptr
-      end
-
-      should "not allow connecting an invalid signal" do
-	o = Regress::TestSubObj.new
-	assert_raises RuntimeError do
-	  GObject.signal_connect(o, "not-really-a-signal") {}
-	end
-      end
-
-      should "handle return values" do
-	s = Gio::SocketService.new
-	GObject.signal_connect(s, "incoming") { true }
-	rv = GObject.signal_emit s, "incoming"
-	assert_equal true, rv.get_boolean
-      end
-
-      should "require a block" do
-	o = Regress::TestSubObj.new
-	assert_raises ArgumentError do
-	  GObject.signal_connect o, "test"
-	end
-      end
-
-      context "connecting a signal with extra arguments" do
-	setup do
-	  @a = nil
-	  @b = 2
-
-	  o = Regress::TestSubObj.new
-	  sb = Regress::TestSimpleBoxedA.new
-	  sb.some_int = 23
-
-	  GObject.signal_connect(o, "test-with-static-scope-arg", 2) { |i, object, d|
-	    @a = d
-	    @b = object
-	  }
-	  GObject.signal_emit o, "test-with-static-scope-arg", sb
-	end
-
-	should "move the user data argument" do
-	  assert_equal 2, @a
-	end
-
-	should "pass on the extra arguments" do
-	  assert_instance_of Regress::TestSimpleBoxedA, @b
-	  assert_equal 23, @b.some_int
-	end
-      end
-
-    end
-
-    context "The GObject overrides Helper module" do
-      context "#signal_arguments_to_gvalue_array" do
-	context "the result of wrapping test-with-static-scope-arg" do
-	  setup do
-	    o = Regress::TestSubObj.new
-	    b = Regress::TestSimpleBoxedA.new
-
-	    @gva =
-	      GObject::Helper.signal_arguments_to_gvalue_array(
-		"test-with-static-scope-arg", o, b)
-	  end
-
-	  should "be a GObject::ValueArray" do
-	    assert_instance_of GObject::ValueArray, @gva
-	  end
-
-	  should "contain two values" do
-	    assert_equal 2, @gva.n_values
-	  end
-
-	  should "have a first value with GType for TestSubObj" do
-	    assert_equal Regress::TestSubObj.get_gtype, (@gva.get_nth 0).current_gtype
-	  end
-
-	  should "have a second value with GType for TestSimpleBoxedA" do
-	    assert_equal Regress::TestSimpleBoxedA.get_gtype, (@gva.get_nth 1).current_gtype
-	  end
-	end
-      end
-
-      describe "#signal_argument_to_gvalue" do
-        it "maps a :utf8 argument to a string-valued GValue" do
-          stub(arg_t = Object.new).tag { :utf8 }
-          stub(info = Object.new).argument_type { arg_t }
-          val =
-            GObject::Helper.signal_argument_to_gvalue(
-              info, "foo")
-          assert_instance_of GObject::Value, val
-          assert_equal "foo", val.get_string
-        end
-      end
-
-      describe "#cast_back_signal_arguments" do
-        it "correctly casts back pointers for the test-with-static-scope-arg signal" do
-          o = Regress::TestSubObj.new
-          b = Regress::TestSimpleBoxedA.new
-          ud = GirFFI::ArgHelper.object_to_inptr "Hello!"
-
-          assert_equal "Hello!", GirFFI::ArgHelper::OBJECT_STORE[ud.address]
-
-          sig = o.class._find_signal "test-with-static-scope-arg"
-
-          gva =
-            GObject::Helper.cast_back_signal_arguments(
-              sig, o.class, o.to_ptr, b.to_ptr, ud)
-
-          klasses = gva.map {|it| it.class}
-          klasses.must_equal [ Regress::TestSubObj,
-                               Regress::TestSimpleBoxedA,
-                               String ]
-          gva[2].must_equal "Hello!"
-        end
-      end
-
-      describe "#cast_signal_argument" do
-        describe "with info for an enum" do
-          before do
-            enuminfo = get_introspection_data 'GLib', 'DateMonth'
-            stub(arg_t = Object.new).interface { enuminfo }
-            stub(arg_t).tag { :interface }
-            stub(@info = Object.new).argument_type { arg_t }
-          end
-
-          it "casts an integer to its enum symbol" do
-            res = GObject::Helper.cast_signal_argument @info, 7
-            assert_equal :july, res
-          end
-        end
-
-        describe "with info for an interface" do
-          before do
-            ifaceinfo = get_introspection_data 'Regress', 'TestInterface'
-            stub(arg_t = Object.new).interface { ifaceinfo }
-            stub(arg_t).tag { :interface }
-            stub(@info = Object.new).argument_type { arg_t }
-          end
-
-          it "casts the argument by calling #to_object on it" do
-            mock(ptr = Object.new).to_object { "good-result" }
-            res = GObject::Helper.cast_signal_argument @info, ptr
-            res.must_equal "good-result"
-          end
-        end
-      end
-    end
-
-    context "The RubyClosure class" do
-      should "have a constructor with a block argument" do
-        assert_raises ArgumentError do
-          GObject::RubyClosure.new
-        end
-      end
-
-      should "be a kind of Closure" do
-        c = GObject::RubyClosure.new {}
-        assert_kind_of GObject::Closure, c
-      end
-
-      should "be able to retrieve its block from its struct" do
-        a = 0
-        c = GObject::RubyClosure.new { a = 2 }
-        c2 = GObject::RubyClosure.wrap(c.to_ptr)
-        c2.block.call
-        assert_equal 2, a
-      end
-
-      context "its #marshaller singleton method" do
-        should "invoke its closure argument's block" do
-          a = 0
-          c = GObject::RubyClosure.new { a = 2 }
-          GObject::RubyClosure.marshaller(c, nil, 0, nil, nil, nil)
-          assert_equal 2, a
-        end
-
-        should "work 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, 0, nil, nil, nil)
-          assert_equal 2, a
-        end
-
-        should "store the closure's return value in the proper gvalue" do
-          c = GObject::RubyClosure.new { 2 }
-          gv = GObject::Value.new
-          GObject::RubyClosure.marshaller(c, gv, 0, nil, nil, nil)
-          assert_equal 2, gv.ruby_value
-        end
-      end
-
-      should "have GObject::Closure#invoke call its block" do
-        a = 0
-        c = GObject::RubyClosure.new { a = 2 }
-        c2 = GObject::Closure.wrap(c.to_ptr)
-        c2.invoke nil, nil, nil
-        assert_equal 2, a
-      end
-    end
-  end
-end