gir_ffi 0.6.7 → 0.7.0

data/test/gir_ffi/builders/signal_builder_test.rb

@@ -10,10 +10,10 @@ describe GirFFI::Builders::SignalBuilder do
 
       it "returns a valid mapping method including receiver and user data" do
         expected = <<-CODE.reset_indentation
-        def self.call_with_argument_mapping(_proc, _v1, _v2)
-          _v3 = ::Regress::TestObj.wrap(_v1)
-          _v4 = GirFFI::ArgHelper::OBJECT_STORE[_v2.address]
-          _proc.call(_v3, _v4)
+        def self.call_with_argument_mapping(_proc, _instance, _user_data)
+          _v1 = Regress::TestObj.wrap(_instance)
+          _v2 = GirFFI::ArgHelper::OBJECT_STORE[_user_data.address]
+          _proc.call(_v1, _v2)
         end
         CODE
 
@@ -29,11 +29,12 @@ describe GirFFI::Builders::SignalBuilder do
         skip unless signal_info
 
         expected = <<-CODE.reset_indentation
-        def self.call_with_argument_mapping(_proc, _v1, _v2, _v3)
-          _v4 = ::Regress::TestObj.wrap(_v1)
-          _v5 = GirFFI::ArgHelper::OBJECT_STORE[_v3.address]
-          _v6 = _proc.call(_v4, _v2, _v5)
-          return _v6
+        def self.call_with_argument_mapping(_proc, _instance, i, _user_data)
+          _v1 = Regress::TestObj.wrap(_instance)
+          _v2 = i
+          _v3 = GirFFI::ArgHelper::OBJECT_STORE[_user_data.address]
+          _v4 = _proc.call(_v1, _v2, _v3)
+          return _v4
         end
         CODE
 
@@ -47,11 +48,54 @@ describe GirFFI::Builders::SignalBuilder do
 
       it "returns a valid mapping method" do
         expected = <<-CODE.reset_indentation
-        def self.call_with_argument_mapping(_proc, _v1, _v2, _v3)
-          _v4 = ::Gio::MountOperation.wrap(_v1)
-          _v5 = ::Gio::MountOperationResult[_v2]
-          _v6 = GirFFI::ArgHelper::OBJECT_STORE[_v3.address]
-          _proc.call(_v4, _v5, _v6)
+        def self.call_with_argument_mapping(_proc, _instance, result, _user_data)
+          _v1 = Gio::MountOperation.wrap(_instance)
+          _v2 = Gio::MountOperationResult.wrap(result)
+          _v3 = GirFFI::ArgHelper::OBJECT_STORE[_user_data.address]
+          _proc.call(_v1, _v2, _v3)
+        end
+        CODE
+
+        builder.mapping_method_definition.must_equal expected
+      end
+    end
+
+    describe "for a signal with a array plus length arguments" do
+      let(:signal_info) {
+        get_signal_introspection_data "Regress", "TestObj", "sig-with-array-len-prop" }
+
+      it "returns a valid mapping method" do
+        skip unless signal_info
+
+        expected = <<-CODE.reset_indentation
+        def self.call_with_argument_mapping(_proc, _instance, arr, len, _user_data)
+          _v1 = Regress::TestObj.wrap(_instance)
+          _v2 = GirFFI::ArgHelper::OBJECT_STORE[_user_data.address]
+          _v3 = len
+          _v4 = GirFFI::SizedArray.wrap(:guint32, _v3, arr)
+          _proc.call(_v1, _v4, _v2)
+        end
+        CODE
+
+        builder.mapping_method_definition.must_equal expected
+      end
+    end
+
+    describe "for a signal returning an array of integers" do
+      let(:signal_info) {
+        get_signal_introspection_data "Regress", "TestObj", "sig-with-intarray-ret" }
+
+      it "returns a valid mapping method" do
+        skip unless signal_info
+
+        expected = <<-CODE.reset_indentation
+        def self.call_with_argument_mapping(_proc, _instance, i, _user_data)
+          _v1 = Regress::TestObj.wrap(_instance)
+          _v2 = i
+          _v3 = GirFFI::ArgHelper::OBJECT_STORE[_user_data.address]
+          _v4 = _proc.call(_v1, _v2, _v3)
+          _v5 = GLib::Array.from(:gint32, _v4)
+          return _v5
         end
         CODE
 

data/test/gir_ffi/builders/struct_builder_test.rb

@@ -8,28 +8,17 @@ describe GirFFI::Builders::StructBuilder do
       builder.layout_specification.must_equal [:some_int, :int32, 0,
                                                :some_int8, :int8, 4,
                                                :some_double, :double, 8,
-                                               :some_enum, Regress::TestEnum::Enum, 16]
+                                               :some_enum, Regress::TestEnum, 16]
     end
   end
 
   describe "for a struct with a simple layout" do
     before do
-      module Foo
-        class Bar
-          class Struct
-
-          end
-        end
-        module Lib
-
-        end
-      end
       @field = Object.new
 
       @struct = Object.new
-      stub(@struct).safe_name { 'Bar' }
       stub(@struct).namespace { 'Foo' }
-      stub(@struct).safe_namespace { 'Foo' }
+      stub(@struct).safe_name { 'Bar' }
       stub(@struct).fields { [ @field ] }
 
       @builder = GirFFI::Builders::StructBuilder.new @struct
@@ -40,34 +29,6 @@ describe GirFFI::Builders::StructBuilder do
       spec = @builder.send :layout_specification
       assert_equal [:bar, :int32, 0], spec
     end
-
-    it "creates getter and setter methods" do
-      # FIXME: Loads of stubs.
-
-      stub(type = Object.new).pointer? { false }
-      stub(type).tag { :gint32 }
-      stub(type).flattened_tag { :gint32 }
-      stub(type).tag_or_class { :gint32 }
-      stub(type).extra_conversion_arguments { [] }
-
-      stub(@field).field_type { type }
-      stub(@field).name { "bar" }
-      stub(@field).writable? { true }
-      stub(@field).offset { 4 }
-      stub(@field).container { @struct }
-
-      stub(@struct).find_instance_method { }
-
-      stub(GirFFI::Builder).build_module('Foo') { Foo }
-
-      refute Foo::Bar.method_defined?(:bar)
-      refute Foo::Bar.method_defined?(:bar=)
-
-      @builder.send :setup_field_accessors
-
-      assert Foo::Bar.method_defined?(:bar)
-      assert Foo::Bar.method_defined?(:bar=)
-    end
   end
 
   describe "for a struct with a layout with a complex type" do

data/test/gir_ffi/builders/user_defined_builder_test.rb

@@ -3,36 +3,104 @@ require 'gir_ffi_test_helper'
 GirFFI.setup :GIMarshallingTests
 
 describe GirFFI::Builders::UserDefinedBuilder do
-  describe "with type info containing one property" do
+  let(:klass) { Object.const_set("DerivedClass#{Sequence.next}",
+                                 Class.new(GIMarshallingTests::Object)) }
+  let(:builder) { GirFFI::Builders::UserDefinedBuilder.new info }
+  let(:info) { GirFFI::UserDefinedTypeInfo.new klass }
+
+  describe "#build_class" do
     before do
-      @klass = Class.new GIMarshallingTests::OverridesObject
-      Object.const_set "DerivedC#{Sequence.next}", @klass
+      builder.build_class
+    end
+
+    describe "with type info containing one property" do
+      let(:info) { GirFFI::UserDefinedTypeInfo.new klass do |info|
+        info.install_property GObject.param_spec_int("foo", "foo bar",
+                                                     "The Foo Bar Property",
+                                                     10, 20, 15,
+                                                     3)
+      end }
 
-      @info = GirFFI::UserDefinedTypeInfo.new @klass do
-        install_property GObject.param_spec_int("foo", "foo bar",
-                                                "The Foo Bar Property",
-                                                10, 20, 15,
-                                                3)
+      it "registers a type that is bigger than the parent" do
+        gtype = klass.get_gtype
+        q = GObject.type_query gtype
+        q.instance_size.must_be :>, GIMarshallingTests::Object::Struct.size
       end
 
-      @builder = GirFFI::Builders::UserDefinedBuilder.new @info
-      @builder.build_class
+      it "gives the types Struct the fields :parent and :foo" do
+        klass::Struct.members.must_equal [:parent, :foo]
+      end
+
+      it "creates accessor functions for the property" do
+        obj = klass.new
+        obj.foo = 13
+        obj.foo.must_equal 13
+      end
+
+      it "makes the property retrievable using #get_property" do
+        obj = klass.new
+        obj.foo = 13
+        obj.get_property("foo").get_value.must_equal 13
+      end
+
+      it "makes the property settable using #set_property" do
+        obj = klass.new
+        obj.set_property("foo", 20)
+        obj.foo.must_equal 20
+      end
     end
 
-    it "registers a type that is bigger than the parent" do
-      gtype = @klass.get_gtype
-      q = GObject.type_query gtype
-      q.instance_size.must_be :>, GIMarshallingTests::OverridesObject::Struct.size
+    describe "with type info containing an overridden g_name" do
+      let(:info) { GirFFI::UserDefinedTypeInfo.new klass do |info|
+        info.g_name = "OtherName#{Sequence.next}"
+      end }
+
+      it "registers a type under the overridden name" do
+        registered_name = GObject.type_name(klass.get_gtype)
+        registered_name.must_equal info.g_name
+        registered_name.wont_equal klass.name
+      end
+    end
+
+    describe "with type info containing a vfunc" do
+      let(:info) { GirFFI::UserDefinedTypeInfo.new klass do |info|
+        info.install_vfunc_implementation :method_int8_in, proc {|instance, in_|
+          instance.int = in_ }
+      end }
+
+      it "allows the vfunc to be called through its invoker" do
+        obj = klass.new
+        obj.method_int8_in 12
+        obj.int.must_equal 12
+      end
     end
 
-    it "gives the types Struct the fields :parent and :foo" do
-      @klass::Struct.members.must_equal [:parent, :foo]
+    describe "with type info containing a vfunc from an included Interface" do
+      let(:info) do
+        klass.class_eval { include GIMarshallingTests::Interface }
+        GirFFI::UserDefinedTypeInfo.new klass do |info|
+          info.install_vfunc_implementation :test_int8_in,
+            proc {|instance, in_| instance.int = in_ }
+        end
+      end
+
+      it "marks the type as conforming to the included Interface" do
+        iface_gtype = GIMarshallingTests::Interface.get_gtype
+        GObject.type_interfaces(klass.get_gtype).to_a.must_equal [iface_gtype]
+      end
+
+      it "allows the vfunc to be called through its invoker" do
+        obj = klass.new
+        obj.test_int8_in 12
+        obj.int.must_equal 12
+      end
     end
 
-    it "creates accessor functions for the property" do
-      obj = @klass.new
-      obj.foo = 13
-      obj.foo.must_equal 13
+    it "does not attempt to register a registered class" do
+      gtype = klass.get_gtype
+      other_builder = GirFFI::Builders::UserDefinedBuilder.new info
+      other_builder.build_class
+      other_builder.gtype.must_equal gtype
     end
   end
 end

data/test/gir_ffi/builders/vfunc_builder_test.rb

@@ -0,0 +1,44 @@
+require 'gir_ffi_test_helper'
+
+describe GirFFI::Builders::VFuncBuilder do
+  let(:builder) { GirFFI::Builders::VFuncBuilder.new vfunc_info }
+
+  describe "#mapping_method_definition" do
+    describe "for a vfunc with only one argument" do
+      let(:vfunc_info) {
+        get_vfunc_introspection_data "GIMarshallingTests", "Object", "method_int8_in" }
+
+      it "returns a valid mapping method including receiver" do
+        expected = <<-CODE.reset_indentation
+        def self.call_with_argument_mapping(_proc, _instance, in_)
+          _v1 = GIMarshallingTests::Object.wrap(_instance)
+          _v2 = in_
+          _proc.call(_v1, _v2)
+        end
+        CODE
+
+        builder.mapping_method_definition.must_equal expected
+      end
+    end
+
+    describe "for a vfunc returning an enum" do
+      let(:vfunc_info) {
+        get_vfunc_introspection_data "GIMarshallingTests", "Object", "vfunc_return_enum" }
+
+      it "returns a valid mapping method including receiver" do
+        skip unless vfunc_info
+        expected = <<-CODE.reset_indentation
+        def self.call_with_argument_mapping(_proc, _instance)
+          _v1 = GIMarshallingTests::Object.wrap(_instance)
+          _v2 = _proc.call(_v1)
+          _v3 = GIMarshallingTests::Enum.from(_v2)
+          return _v3
+        end
+        CODE
+
+        builder.mapping_method_definition.must_equal expected
+      end
+    end
+  end
+end
+

data/test/gir_ffi/g_type_test.rb

@@ -0,0 +1,29 @@
+require 'gir_ffi_test_helper'
+
+require 'gir_ffi/g_type'
+
+describe GirFFI::GType do
+  let(:gobject_gtype) { GObject::Object.get_gtype }
+  let(:gobject_type_query) { GObject.type_query gobject_gtype }
+
+  describe "#to_i" do
+    it "returns the integer gtype" do
+      gt = GirFFI::GType.new(gobject_gtype)
+      gt.to_i.must_equal gobject_gtype
+    end
+  end
+
+  describe "#class_size" do
+    it "returns the class size for object types" do
+      gt = GirFFI::GType.new(gobject_gtype)
+      gt.class_size.must_equal gobject_type_query.class_size
+    end
+  end
+
+  describe "#instance_size" do
+    it "returns the instance size for object types" do
+      gt = GirFFI::GType.new(gobject_gtype)
+      gt.instance_size.must_equal gobject_type_query.instance_size
+    end
+  end
+end

data/test/gir_ffi/in_pointer_test.rb

@@ -24,7 +24,7 @@ describe GirFFI::InPointer do
 
     it "handles struct types" do
       e = Class.new(GirFFI::StructBase) do
-        self::Struct = Class.new(GirFFI::Struct) do
+        self::Struct = Class.new(FFI::Struct) do
           layout :foo, :int32, :bar, :int32
         end
       end
@@ -42,10 +42,16 @@ describe GirFFI::InPointer do
       p1 = GirFFI::InPointer.from :gint32, 42
       p2 = GirFFI::InPointer.from :gint32, 24
 
-      ptr = GirFFI::InPointer.from_array [:pointer, :uint32], [p1, p2]
+      ptr = GirFFI::InPointer.from_array [:pointer, :gint32], [p1, p2]
 
       ptr.read_array_of_pointer(2).must_equal [p1, p2]
     end
+
+    it "handles pointer casting" do
+      ptr = GirFFI::InPointer.from_array [:pointer, :gint32], [42, 24]
+
+      ptr.read_array_of_pointer(2).map(&:address).must_equal [42, 24]
+    end
   end
 
   describe "an instance created with .from_array :gint32" do
@@ -148,27 +154,40 @@ describe GirFFI::InPointer do
       ptr = GirFFI::InPointer.from e, :bar
       ptr.address.must_equal 1
     end
-  end
 
-  describe ".from_object" do
-    describe "when called with an object implementing to_ptr" do
+    describe "for type :void" do
       it "returns the result of to_ptr" do
         obj = Object.new
         def obj.to_ptr; :test_value; end
-        GirFFI::InPointer.from_object(obj).must_equal :test_value
+        GirFFI::InPointer.from(:void, obj).must_equal :test_value
+      end
+
+      it "returns nil when passed nil" do
+        GirFFI::InPointer.from(:void, nil).must_equal nil
+      end
+    end
+
+    describe "for types that are classes" do
+      it "returns the result of to_ptr" do
+        klass = Class.new
+        obj = klass.new
+        def obj.to_ptr; :test_value; end
+        GirFFI::InPointer.from(klass, obj).must_equal :test_value
       end
     end
+  end
 
+  describe ".from_closure_data" do
     describe "when called with nil" do
-      it "returns nil" do
-        GirFFI::InPointer.from_object(nil).must_equal nil
+      it "returns a pointer pointing to nil.object_id" do
+        GirFFI::InPointer.from_closure_data(nil).address.must_equal nil.object_id
       end
     end
 
     describe "when called with a string" do
       it "stores the string in GirFFI::ArgHelper::OBJECT_STORE" do
         str = "Foo"
-        ptr = GirFFI::InPointer.from_object(str)
+        ptr = GirFFI::InPointer.from_closure_data(str)
         result = GirFFI::ArgHelper::OBJECT_STORE[ptr.address]
         result.must_equal str
       end

data/test/gir_ffi/info_ext/i_callable_info_test.rb

@@ -19,14 +19,5 @@ describe GirFFI::InfoExt::ICallableInfo do
       end
     end
   end
-
-  describe "#return_ffi_type" do
-    it "returns the ffi type of the return type" do
-      stub(return_type_info = Object.new).to_ffitype { :some_type }
-      stub(callable_info).return_type { return_type_info }
-
-      callable_info.return_ffi_type.must_equal :some_type
-    end
-  end
 end
 

data/test/gir_ffi/info_ext/i_callback_info_test.rb

@@ -0,0 +1,19 @@
+require 'gir_ffi_test_helper'
+
+describe GirFFI::InfoExt::ICallbackInfo do
+  let(:klass) { Class.new do
+    include GirFFI::InfoExt::ICallbackInfo
+  end }
+  let(:callback_info) { klass.new }
+
+  describe "#return_ffi_type" do
+    it "returns the callback ffi type of the return type" do
+      stub(return_type_info = Object.new).to_callback_ffitype { :some_type }
+      stub(callback_info).return_type { return_type_info }
+
+      callback_info.return_ffi_type.must_equal :some_type
+    end
+  end
+end
+
+