gir_ffi 0.5.2 → 0.6.0

data/test/gir_ffi/in_out_pointer_test.rb

@@ -27,45 +27,6 @@ describe GirFFI::InOutPointer do
     end
   end
 
-  describe "an instance created with .from_array" do
-    before do
-      @result = GirFFI::InOutPointer.from_array :gint32, [24, 13]
-    end
-
-    it "holds a pointer to a non-null pointer" do
-      ptr = @result.read_pointer
-      refute ptr.null?
-    end
-
-    it "holds a pointer to a pointer to the correct input values" do
-      ptr = @result.read_pointer
-      assert_equal [24, 13], [ptr.get_int(0), ptr.get_int(4)]
-    end
-
-    it "is an instance of GirFFI::InPointer" do
-      assert_instance_of GirFFI::InOutPointer, @result
-    end
-  end
-
-  describe ".from_array" do
-    it "returns nil when passed nil" do
-      result = GirFFI::InOutPointer.from_array :gint32, nil
-      assert_nil result
-    end
-  end
-
-  describe "an instance created with .from_array :utf8" do
-    before do
-      @result = GirFFI::InOutPointer.from_array :utf8, ["foo", "bar", "baz"]
-    end
-
-    it "returns a pointer to an array of pointers to strings" do
-      ptr = @result.read_pointer
-      ary = ptr.read_array_of_pointer(3)
-      assert_equal ["foo", "bar", "baz"], ary.map {|p| p.read_string}
-    end
-  end
-
   describe "in instance created with .for" do
     before do
       @result = GirFFI::InOutPointer.for :gint32
@@ -109,21 +70,9 @@ describe GirFFI::InOutPointer do
     end
 
     describe "for :utf8 values" do
-      it "returns the held value" do
+      it "returns a pointer to the held value" do
         ptr = GirFFI::InOutPointer.from :utf8, "Some value"
-        assert_equal "Some value", ptr.to_value
-      end
-    end
-  end
-
-  describe "#to_sized_array_value" do
-    describe "for an array of :gint32" do
-      before do
-        @ptr = GirFFI::InOutPointer.from_array :gint32, [1, 2, 3]
-      end
-
-      it "returns an array of integers with the correct values" do
-        assert_equal [1, 2, 3], @ptr.to_sized_array_value(3)
+        assert_equal "Some value", ptr.to_value.read_string
       end
     end
   end

data/test/gir_ffi/in_pointer_test.rb

@@ -13,24 +13,11 @@ describe GirFFI::InPointer do
       GirFFI::InPointer.from_array :GType, [2]
     end
 
-    it "handles type tag :interface_pointer" do
-      GirFFI::InPointer.from_array :interface_pointer, []
-    end
-
     it "handles enum types" do
       e = FFI::Enum.new [:foo, :bar, :baz]
       ptr = GirFFI::InPointer.from_array e, [:bar, :foo, :baz]
       ptr.read_array_of_int32(3).must_equal [1, 0, 2]
     end
-
-    it "handles typed pointers" do
-      p1 = GirFFI::InPointer.from :gint32, 42
-      p2 = GirFFI::InPointer.from :gint32, 24
-
-      ptr = GirFFI::InPointer.from_array [:pointer, :uint32], [p1, p2]
-
-      ptr.read_array_of_pointer(2).must_equal [p1, p2]
-    end
   end
 
   describe "an instance created with .from_array :gint32" do

data/test/gir_ffi/info_ext/i_callable_info_test.rb

@@ -0,0 +1,32 @@
+require 'gir_ffi_test_helper'
+
+describe GirFFI::InfoExt::ICallableInfo do
+  let(:testclass) { Class.new do
+    include GirFFI::InfoExt::ICallableInfo
+  end }
+  let(:callable_info) { testclass.new }
+
+  describe "#argument_ffi_types" do
+    describe "for a simple callable with several arguments" do
+      before do
+        stub(arg_info1 = Object.new).to_ffitype { :type1 }
+        stub(arg_info2 = Object.new).to_ffitype { :type2 }
+        stub(callable_info).args { [arg_info1, arg_info2] }
+      end
+
+      it "returns the ffi types of the arguments" do
+        callable_info.argument_ffi_types.must_equal [:type1, :type2]
+      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_function_info_test.rb

@@ -0,0 +1,61 @@
+require 'gir_ffi_test_helper'
+
+describe GirFFI::InfoExt::IFunctionInfo do
+  let(:testclass) { Class.new do
+    include GirFFI::InfoExt::ICallableInfo
+    include GirFFI::InfoExt::IFunctionInfo
+  end }
+  let(:function_info) { testclass.new }
+
+  describe "#argument_ffi_types" do
+    before do
+      stub(arg_info1 = Object.new).to_ffitype { :type1 }
+      stub(arg_info2 = Object.new).to_ffitype { :type2 }
+      stub(function_info).args { [arg_info1, arg_info2] }
+    end
+
+    describe "for a simple function with several arguments" do
+      before do
+        stub(function_info).method? { false }
+        stub(function_info).throws? { false }
+      end
+
+      it "returns the ffi types of the arguments" do
+        function_info.argument_ffi_types.must_equal [:type1, :type2]
+      end
+    end
+
+    describe "for a throwing function with several arguments" do
+      before do
+        stub(function_info).method? { false }
+        stub(function_info).throws? { true }
+      end
+
+      it "appends :pointer to represent the error argument" do
+        function_info.argument_ffi_types.must_equal [:type1, :type2, :pointer]
+      end
+    end
+
+    describe "for a method with several arguments" do
+      before do
+        stub(function_info).method? { true }
+        stub(function_info).throws? { false }
+      end
+
+      it "prepends :pointer to represent the method reciever" do
+        function_info.argument_ffi_types.must_equal [:pointer, :type1, :type2]
+      end
+    end
+
+    describe "for a throwing method with several arguments" do
+      before do
+        stub(function_info).method? { true }
+        stub(function_info).throws? { true }
+      end
+
+      it "adds :pointer for both the reciever and the error argument" do
+        function_info.argument_ffi_types.must_equal [:pointer, :type1, :type2, :pointer]
+      end
+    end
+  end
+end

data/test/gir_ffi/info_ext/i_signal_info_test.rb

@@ -1,7 +1,13 @@
 require 'gir_ffi_test_helper'
 
 describe GirFFI::InfoExt::ISignalInfo do
+  let(:testclass) { Class.new do
+    include GirFFI::InfoExt::ISignalInfo
+  end }
+  let(:signal_info) { testclass.new }
+
   describe "#cast_back_signal_arguments" do
+    # TODO: Move to integration tests
     it "correctly casts back pointers for the test-with-static-scope-arg signal" do
       o = Regress::TestSubObj.new
       b = Regress::TestSimpleBoxedA.new
@@ -22,6 +28,7 @@ describe GirFFI::InfoExt::ISignalInfo do
   end
 
   describe "#signal_arguments_to_gvalue_array" do
+    # TODO: Move to integration tests
     describe "the result of wrapping test-with-static-scope-arg" do
       setup do
         o = Regress::TestSubObj.new

data/test/gir_ffi/info_ext/i_type_info_test.rb

@@ -11,12 +11,12 @@ describe GirFFI::InfoExt::ITypeInfo do
 
   describe "#layout_specification_type" do
     it "returns an array with elements subtype and size for type :array" do
-      mock(elmtype_info).layout_specification_type { :foo }
-
+      mock(type_info).pointer? { false }
+      stub(type_info).tag { :array }
       mock(type_info).array_fixed_size { 2 }
-      mock(type_info).param_type(0) { elmtype_info }
 
-      mock(GirFFI::Builder).itypeinfo_to_ffitype(type_info) { :array }
+      mock(elmtype_info).layout_specification_type { :foo }
+      mock(type_info).param_type(0) { elmtype_info }
 
       result = type_info.layout_specification_type
       assert_equal [:foo, 2], result
@@ -26,6 +26,7 @@ describe GirFFI::InfoExt::ITypeInfo do
   describe "#element_type" do
     it "returns the element type for lists" do
       mock(elmtype_info).tag { :foo }
+      mock(elmtype_info).pointer? { false }
 
       mock(type_info).tag {:glist}
       mock(type_info).param_type(0) { elmtype_info }
@@ -36,7 +37,9 @@ describe GirFFI::InfoExt::ITypeInfo do
 
     it "returns the key and value types for ghashes" do
       mock(keytype_info).tag { :foo }
+      mock(keytype_info).pointer? { false }
       mock(valtype_info).tag { :bar }
+      mock(valtype_info).pointer? { false }
 
       mock(type_info).tag {:ghash}
       mock(type_info).param_type(0) { keytype_info }
@@ -53,138 +56,216 @@ describe GirFFI::InfoExt::ITypeInfo do
       result.must_be_nil
     end
 
-    it "returns :gpointer if the element type is a pointer with tag :void" do
-      stub(elm_type = Object.new).tag { :void }
-      stub(elm_type).pointer? { true }
+    it "returns [:pointer, :void] if the element type is a pointer with tag :void" do
+      stub(elmtype_info).tag_or_class { [:pointer, :void] }
 
       mock(type_info).tag {:glist}
-      mock(type_info).param_type(0) { elm_type }
+      mock(type_info).param_type(0) { elmtype_info }
 
-      assert_equal :gpointer, type_info.element_type
+      assert_equal [:pointer, :void], type_info.element_type
     end
   end
 
-  describe "#type_specification" do
+  describe "#flattened_tag" do
     describe "for a simple type" do
       it "returns the type tag" do
         stub(type_info).tag { :uint32 }
 
-        type_info.type_specification.must_equal ":uint32"
+        type_info.flattened_tag.must_equal :uint32
       end
     end
 
-    describe "for a zero-terminated utf8 array" do
-      it "returns the pair [:strv, :utf8]" do
-        stub(elmtype_info).tag { :utf8 }
-        stub(elmtype_info).pointer? { true }
-
+    context "for a zero-terminated array" do
+      before do
         stub(type_info).tag { :array }
         stub(type_info).param_type(0) { elmtype_info }
         stub(type_info).zero_terminated? { true }
-        stub(type_info).array_type { :c }
+      end
+
+      context "of utf8" do
+        it "returns :strv" do
+          stub(elmtype_info).tag { :utf8 }
+          stub(elmtype_info).pointer? { true }
 
-        type_info.type_specification.must_equal "[:strv, :utf8]"
+          type_info.flattened_tag.must_equal :strv
+        end
+      end
+
+      context "of filename" do
+        it "returns :strv" do
+          stub(elmtype_info).tag { :filename }
+          stub(elmtype_info).pointer? { true }
+
+          type_info.flattened_tag.must_equal :strv
+        end
+      end
+
+      context "of another type" do
+        it "returns :zero_terminated" do
+          stub(elmtype_info).tag { :foo }
+          stub(elmtype_info).pointer? { false }
+
+          type_info.flattened_tag.must_equal :zero_terminated
+        end
       end
     end
 
-    describe "for a zero-terminated filename array" do
-      it "returns the pair [:strv, :filename]" do
-        stub(elmtype_info).tag { :filename }
-        stub(elmtype_info).pointer? { true }
+    describe "for a fixed length c-like array" do
+      it "returns :c" do
+        mock(type_info).tag { :array }
+        mock(type_info).zero_terminated? { false }
+        mock(type_info).array_type { :c }
 
-        stub(type_info).tag { :array }
-        stub(type_info).param_type(0) { elmtype_info }
-        stub(type_info).zero_terminated? { true }
-        stub(type_info).array_type { :c }
+        type_info.flattened_tag.must_equal :c
+      end
+    end
+
+  end
+
+  describe "#subtype_tag_or_class_name" do
+    describe "without a parameter" do
+      it "returns the result of calling #tag_or_class_name on the first param_type" do
+        mock(elmtype_info).tag_or_class_name { ":foo" }
 
-        type_info.type_specification.must_equal "[:strv, :filename]"
+        mock(type_info).param_type(0) { elmtype_info }
+
+        type_info.subtype_tag_or_class_name.must_equal ":foo"
       end
     end
+  end
 
-    describe "for a zero-terminated array" do
-      it "returns the pair [:zero_terminated, element_type]" do
-        stub(elmtype_info).tag { :foo }
-        stub(elmtype_info).pointer? { false }
+  describe "#subtype_tag_or_class" do
+    describe "without a parameter" do
+      it "returns the result of calling #tag_or_class on the first param_type" do
+        mock(elmtype_info).tag_or_class { :foo }
 
-        stub(type_info).tag { :array }
-        stub(type_info).param_type(0) { elmtype_info }
-        stub(type_info).zero_terminated? { true }
-        stub(type_info).array_type { :c }
+        mock(type_info).param_type(0) { elmtype_info }
 
-        type_info.type_specification.must_equal "[:zero_terminated, :foo]"
+        type_info.subtype_tag_or_class.must_equal :foo
       end
     end
+  end
 
-    describe "for a fixed length c-like array of type :foo" do
-      it "returns the pair [:c, :foo]" do
-        mock(elmtype_info).tag { :foo }
-        mock(elmtype_info).pointer? { false }
+  describe "#tag_or_class_name" do
+    describe "for the simple type :foo" do
+      it "returns the string ':foo'" do
+        mock(type_info).tag { :foo }
+        mock(type_info).pointer? { false }
 
-        mock(type_info).tag { :array }
-        stub(type_info).param_type(0) { elmtype_info }
-        stub(type_info).zero_terminated? { false }
-        stub(type_info).array_type { :c }
+        assert_equal ":foo", type_info.tag_or_class_name
+      end
+    end
+
+    describe "for :utf8" do
+      it "returns the string ':utf8'" do
+        mock(type_info).tag { :utf8 }
+        mock(type_info).pointer? { true }
+
+        assert_equal ":utf8", type_info.tag_or_class_name
+      end
+    end
 
-        type_info.type_specification.must_equal "[:c, :foo]"
+    describe "for an interface class" do
+      it "returns the interface's full class name" do
+        mock(type_info).tag { :interface }
+        mock(type_info).interface_type_name { "-full-type-name-" }
+        mock(type_info).pointer? { false }
+
+        assert_equal "-full-type-name-", type_info.tag_or_class_name
       end
     end
 
+    describe "for a pointer to simple type :foo" do
+      it "returns the string '[:pointer, :foo]'" do
+        mock(type_info).tag { :foo }
+        mock(type_info).pointer? { true }
+
+        assert_equal "[:pointer, :foo]", type_info.tag_or_class_name
+      end
+    end
   end
 
-  describe "#subtype_tag_or_class_name" do
+  describe "#tag_or_class" do
     describe "for a simple type" do
-      it "returns the string ':void'" do
-        mock(subtype = Object.new).tag { :void }
-        mock(subtype).pointer? { false }
-
-        mock(info = testclass.new).param_type(0) { subtype }
+      it "returns the type's tag" do
+        mock(type_info).tag { :foo }
+        mock(type_info).pointer? { false }
 
-        assert_equal ":void", info.subtype_tag_or_class_name
+        type_info.tag_or_class.must_equal :foo
       end
     end
 
-    describe "for an array of simple type :foo" do
-      it "returns the string ':foo'" do
-        mock(subtype = Object.new).tag { :foo }
-        mock(subtype).pointer? { false }
+    describe "for utf8 strings" do
+      it "returns the tag :utf8" do
+        mock(type_info).tag { :utf8 }
+        mock(type_info).pointer? { true }
+
+        type_info.tag_or_class.must_equal :utf8
+      end
+    end
 
-        mock(info = testclass.new).param_type(0) { subtype }
+    describe "for filename strings" do
+      it "returns the tag :filename" do
+        mock(type_info).tag { :filename }
+        mock(type_info).pointer? { true }
 
-        assert_equal ":foo", info.subtype_tag_or_class_name
+        type_info.tag_or_class.must_equal :filename
       end
     end
 
-    describe "for an array of :utf8" do
-      it "returns the string ':utf8'" do
-        mock(subtype = Object.new).tag { :utf8 }
-        mock(subtype).pointer? { true }
+    describe "for an interface class" do
+      it "returns the class built from the interface" do
+        interface_info = Object.new
+        interface = Object.new
+
+        mock(type_info).tag { :interface }
+        mock(type_info).interface { interface_info }
+        mock(type_info).pointer? { false }
 
-        mock(info = testclass.new).param_type(0) { subtype }
+        mock(GirFFI::Builder).build_class(interface_info) { interface }
 
-        assert_equal ":utf8", info.subtype_tag_or_class_name
+        type_info.tag_or_class.must_equal interface
       end
     end
 
-    describe "for an array of an interface class" do
-      it "returns the interface's full class name" do
-        mock(subtype = Object.new).tag { :interface }
-        mock(subtype).interface_type_name { "-full-type-name-" }
-        mock(subtype).pointer? { false }
+    describe "for a pointer to simple type :foo" do
+      it "returns [:pointer, :foo]" do
+        mock(type_info).tag { :foo }
+        mock(type_info).pointer? { true }
+
+        type_info.tag_or_class.must_equal [:pointer, :foo]
+      end
+    end
 
-        mock(info = testclass.new).param_type(0) { subtype }
+    describe "for a pointer to :void" do
+      it "returns [:pointer, :void]" do
+        stub(type_info).tag { :void }
+        stub(type_info).pointer? { true }
 
-        assert_equal "-full-type-name-", info.subtype_tag_or_class_name
+        type_info.tag_or_class.must_equal [:pointer, :void]
       end
     end
+  end
 
-    describe "for an array of pointer to simple type :foo" do
-      it "returns the string '[:pointer, :foo]'" do
-        mock(subtype = Object.new).tag { :foo }
-        mock(subtype).pointer? { true }
+  describe "#to_callback_ffitype" do
+    let(:iface) { Object.new }
+    describe "for an :interface argument" do
+      before do
+        stub(type_info).interface { iface }
+        stub(type_info).tag { :interface }
+        stub(type_info).pointer? { false }
+      end
+
+      it "correctly maps a :union argument to :pointer" do
+        stub(iface).info_type { :union }
+
+        type_info.to_callback_ffitype.must_equal :pointer
+      end
 
-        mock(info = testclass.new).param_type(0) { subtype }
+      it "correctly maps a :flags argument to :int32" do
+        stub(iface).info_type { :flags }
 
-        assert_equal "[:pointer, :foo]", info.subtype_tag_or_class_name
+        type_info.to_callback_ffitype.must_equal :int32
       end
     end
   end

data/test/gir_ffi/return_value_builder_test.rb

@@ -270,7 +270,7 @@ describe GirFFI::ReturnValueBuilder do
 
       it "converts the result in #post" do
         builder.callarg.must_equal "_v1"
-        builder.post.must_equal [ "_v2 = GirFFI::ArgHelper.ptr_to_typed_array :foo, _v1, 3" ]
+        builder.post.must_equal [ "_v2 = GLib::SizedArray.wrap(:foo, 3, _v1)" ]
       end
 
       it "returns the wrapped result" do
@@ -292,7 +292,7 @@ describe GirFFI::ReturnValueBuilder do
 
       it "converts the result in #post" do
         builder.callarg.must_equal "_v1"
-        builder.post.must_equal [ "_v2 = GirFFI::ArgHelper.ptr_to_typed_array :foo, _v1, bar" ]
+        builder.post.must_equal [ "_v2 = GLib::SizedArray.wrap(:foo, bar, _v1)" ]
       end
 
       it "returns the wrapped result" do

data/test/gir_ffi/unintrospectable_type_info_test.rb

@@ -0,0 +1,95 @@
+require 'gir_ffi_test_helper'
+require 'gir_ffi/unintrospectable_type_info'
+
+describe GirFFI::UnintrospectableTypeInfo do
+  describe "#info_type" do
+    it "returns :unintrospectable" do
+      info = GirFFI::UnintrospectableTypeInfo.new :some_type
+      info.info_type.must_equal :unintrospectable
+    end
+  end
+
+  describe "#parent" do
+    it "finds the parent's info by gtype" do
+      gobject = Object.new
+      gir = Object.new
+
+      mock(gobject).type_parent(:some_type) { :foo }
+      mock(gir).find_by_gtype(:foo) { :foo_info }
+
+      info = GirFFI::UnintrospectableTypeInfo.new(:some_type, gir, gobject)
+
+      info.parent.must_equal :foo_info
+    end
+  end
+
+  describe "#interfaces" do
+    it "finds interface infos by gtype" do
+      gobject = Object.new
+      gir = Object.new
+
+      mock(gobject).type_interfaces(:some_type) { [:foo, :bar ] }
+      mock(gir).find_by_gtype(:foo) { :foo_info }
+      mock(gir).find_by_gtype(:bar) { :bar_info }
+
+      info = GirFFI::UnintrospectableTypeInfo.new(:some_type, gir, gobject)
+
+      info.interfaces.must_equal [:foo_info, :bar_info]
+    end
+
+    it "skips interfaces that have no introspection data" do
+      gobject = Object.new
+      gir = Object.new
+
+      mock(gobject).type_interfaces(:some_type) { [:foo, :bar ] }
+      mock(gir).find_by_gtype(:foo) { :foo_info }
+      mock(gir).find_by_gtype(:bar) { nil }
+
+      info = GirFFI::UnintrospectableTypeInfo.new(:some_type, gir, gobject)
+
+      info.interfaces.must_equal [:foo_info]
+    end
+  end
+
+  describe "#g_type" do
+    it "returns the passed-in gtype" do
+      info = GirFFI::UnintrospectableTypeInfo.new(:some_type)
+      info.g_type.must_equal :some_type
+    end
+  end
+
+  describe "#fields" do
+    it "returns an empty array" do
+      info = GirFFI::UnintrospectableTypeInfo.new(:some_type)
+      info.fields.must_equal []
+    end
+  end
+
+  describe "#namespace" do
+    it "returns the parent class' namespace" do
+      gobject = Object.new
+      gir = Object.new
+      parent_info = Object.new
+
+      mock(gobject).type_parent(:some_type) { :foo }
+      mock(gir).find_by_gtype(:foo) { parent_info }
+      mock(parent_info).namespace { 'FooNamespace' }
+
+      info = GirFFI::UnintrospectableTypeInfo.new(:some_type, gir, gobject)
+
+      info.namespace.must_equal 'FooNamespace'
+    end
+  end
+
+  describe "#safe_name" do
+    it "finds the class name by gtype" do
+      gobject = Object.new
+
+      mock(gobject).type_name(:some_type) { 'GSomeType' }
+
+      info = GirFFI::UnintrospectableTypeInfo.new(:some_type, nil, gobject)
+
+      info.safe_name.must_equal 'GSomeType'
+    end
+  end
+end

data/test/gir_ffi/user_defined_property_info_test.rb

@@ -0,0 +1,19 @@
+require 'gir_ffi_test_helper'
+require 'gir_ffi/user_defined_property_info'
+
+describe GirFFI::UserDefinedPropertyInfo do
+  describe "#param_spec" do
+    it "returns the passed in parameter specification" do
+      info = GirFFI::UserDefinedPropertyInfo.new :some_param_spec
+      info.param_spec.must_equal :some_param_spec
+    end
+  end
+
+  describe "#name" do
+    it "returns the name retrieved from the parameter specification" do
+      mock(param_spec = Object.new).get_name { :property_name }
+      info = GirFFI::UserDefinedPropertyInfo.new param_spec
+      info.name.must_equal :property_name
+    end
+  end
+end