gir_ffi 0.6.7 → 0.7.0

data/test/gir_ffi/info_ext/i_function_info_test.rb

@@ -58,4 +58,13 @@ describe GirFFI::InfoExt::IFunctionInfo 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(function_info).return_type { return_type_info }
+
+      function_info.return_ffi_type.must_equal :some_type
+    end
+  end
 end

data/test/gir_ffi/info_ext/i_signal_info_test.rb

@@ -1,5 +1,7 @@
 require 'gir_ffi_test_helper'
 
+GirFFI.setup :Regress
+
 describe GirFFI::InfoExt::ISignalInfo do
   let(:klass) { Class.new do
     include GirFFI::InfoExt::ICallableInfo
@@ -7,31 +9,26 @@ describe GirFFI::InfoExt::ISignalInfo do
   end }
   let(:signal_info) { klass.new }
 
-  describe "#signal_arguments_to_gvalue_array" do
+  describe "#arguments_to_gvalues" do
     let(:object) { Regress::TestSubObj.new }
     let(:boxed) { Regress::TestSimpleBoxedA.const_return }
     let(:signal_info) { Regress::TestSubObj.find_signal "test-with-static-scope-arg" }
-    let(:result) { signal_info.signal_arguments_to_gvalue_array(object, boxed) }
-
-    it "wraps its arguments in a GObject::ValueArray" do
-      result.must_be_instance_of GObject::ValueArray
-      result.n_values.must_equal 2
-    end
+    let(:result) { signal_info.arguments_to_gvalues(object, [boxed]) }
 
     it "correctly wraps :object" do
-      result.get_nth(0).get_value.must_equal object
+      result[0].get_value.must_equal object
     end
 
     it "correctly wraps :struct" do
-      result_boxed = result.get_nth(1).get_value
+      result_boxed = result[1].get_value
       result_boxed.some_int8.must_equal boxed.some_int8
       result_boxed.some_int.must_equal boxed.some_int
     end
   end
 
   describe "#return_ffi_type" do
-    # FIXME: This is needed because callbacks are limited in the accepted
-    # types. This should be fixed in FFI.
+    # NOTE: This is needed because FFI callbacks are limited in the
+    # accepted types.
     it "returns :bool for the :gboolean type" do
       stub(return_type_info = Object.new).to_ffitype { GLib::Boolean }
       stub(signal_info).return_type { return_type_info }

data/test/gir_ffi/info_ext/i_type_info_test.rb

@@ -13,6 +13,9 @@ describe GirFFI::InfoExt::ITypeInfo do
 
   let(:callback_type_info) {
     get_introspection_data('Regress', 'test_callback').args[0].argument_type }
+  let(:ghash_type_info) {
+    get_introspection_data('Regress',
+                           'test_ghash_nested_everything_return').return_type }
 
   describe "#to_ffitype" do
     it "returns an array with elements subtype and size for type :array" do
@@ -150,18 +153,6 @@ describe GirFFI::InfoExt::ITypeInfo do
     end
   end
 
-  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 }
-
-        mock(type_info).param_type(0) { elmtype_info }
-
-        type_info.subtype_tag_or_class.must_equal :foo
-      end
-    end
-  end
-
   describe "#tag_or_class" do
     describe "for a simple type" do
       it "returns the type's tag" do
@@ -210,10 +201,10 @@ describe GirFFI::InfoExt::ITypeInfo do
       end
 
       describe "when the interface type is :object" do
-        it "returns an array with elements :pointer and built interface class" do
+        it "returns the built interface class" do
           stub(iface_info).info_type { :object }
 
-          type_info.tag_or_class.must_equal [:pointer, interface]
+          type_info.tag_or_class.must_equal interface
         end
       end
 
@@ -228,8 +219,8 @@ describe GirFFI::InfoExt::ITypeInfo do
     end
 
     describe "for a callback" do
-      it "returns :callback" do
-        callback_type_info.tag_or_class.must_equal :callback
+      it "returns the callback's wrapper class" do
+        callback_type_info.tag_or_class.must_equal Regress::TestCallback
       end
     end
 
@@ -250,6 +241,17 @@ describe GirFFI::InfoExt::ITypeInfo do
         type_info.tag_or_class.must_equal [:pointer, :void]
       end
     end
+
+    describe "for a complex nested hash type" do
+      it "returns a representeation of the nested structure" do
+        ghash_type_info.tag_or_class.must_equal(
+          [ :pointer,
+            [ :ghash,
+              :utf8,
+              [ :pointer,
+                [ :ghash, :utf8, :utf8 ] ] ] ])
+      end
+    end
   end
 
   describe "#to_callback_ffitype" do
@@ -564,4 +566,126 @@ describe GirFFI::InfoExt::ITypeInfo do
       end
     end
   end
+
+  describe "#g_type" do
+    before do
+      stub(type_info).tag { tag }
+      stub(type_info).pointer? { pointer? }
+    end
+
+    describe "for :void" do
+      let(:tag) { :void }
+      let(:pointer?) { false }
+
+      it "equals the none type" do
+        GObject.type_name(type_info.g_type).must_equal "void"
+      end
+    end
+
+    describe "for :gboolean" do
+      let(:tag) { :gboolean }
+      let(:pointer?) { false }
+
+      it "equals the gboolean type" do
+        GObject.type_name(type_info.g_type).must_equal "gboolean"
+      end
+    end
+
+    describe "for :gint32" do
+      let(:tag) { :gint32 }
+      let(:pointer?) { false }
+
+      it "equals the gint type" do
+        GObject.type_name(type_info.g_type).must_equal "gint"
+      end
+    end
+
+    describe "for :gint64" do
+      let(:tag) { :gint64 }
+      let(:pointer?) { false }
+
+      it "equals the gint64 type" do
+        GObject.type_name(type_info.g_type).must_equal "gint64"
+      end
+    end
+
+    describe "for :guint64" do
+      let(:tag) { :guint64 }
+      let(:pointer?) { false }
+
+      it "equals the guint64 type" do
+        GObject.type_name(type_info.g_type).must_equal "guint64"
+      end
+    end
+
+    describe "for pointer to :utf8" do
+      let(:tag) { :utf8 }
+      let(:pointer?) { true }
+
+      it "equals the gchararray type" do
+        GObject.type_name(type_info.g_type).must_equal "gchararray"
+      end
+    end
+
+    describe "for pointer to :ghash" do
+      let(:tag) { :ghash }
+      let(:pointer?) { true }
+
+      it "equals the GHashTable type" do
+        GObject.type_name(type_info.g_type).must_equal "GHashTable"
+      end
+    end
+
+    describe "for arrays" do
+      let(:tag) { :array }
+      let(:pointer?) { true }
+
+      describe "for pointer to GArray" do
+        before do
+          stub(type_info).zero_terminated? { false }
+          stub(type_info).array_type { :array }
+        end
+
+        it "equals the GArray type" do
+          GObject.type_name(type_info.g_type).must_equal "GArray"
+        end
+      end
+
+      describe "for a C array" do
+        before do
+          stub(type_info).zero_terminated? { false }
+          stub(type_info).array_type { :c }
+        end
+
+        it "equals the gpointer type" do
+          GObject.type_name(type_info.g_type).must_equal "gpointer"
+        end
+      end
+
+      describe "for a zero-terminated array" do
+        before do
+          stub(type_info).param_type(0) { elmtype_info }
+          stub(type_info).zero_terminated? { true }
+        end
+
+        describe "of utf8" do
+          it "equals the GStrv type" do
+            stub(elmtype_info).tag { :utf8 }
+            stub(elmtype_info).pointer? { true }
+
+            GObject.type_name(type_info.g_type).must_equal "GStrv"
+          end
+        end
+
+        describe "of filename" do
+          it "equals the GStrv type" do
+            stub(elmtype_info).tag { :filename }
+            stub(elmtype_info).pointer? { true }
+
+            GObject.type_name(type_info.g_type).must_equal "GStrv"
+          end
+        end
+      end
+    end
+  end
 end

data/test/gir_ffi/interface_base_test.rb

@@ -1,12 +1,18 @@
 require 'gir_ffi_test_helper'
 
 describe GirFFI::InterfaceBase do
+  let(:interface) { Module.new { extend GirFFI::InterfaceBase } }
+
   describe "#wrap" do
     it "delegates conversion to the wrapped pointer" do
-      mod = Module.new { extend GirFFI::InterfaceBase }
       mock(ptr = Object.new).to_object { "good-result" }
-      mod.wrap(ptr).must_equal "good-result"
+      interface.wrap(ptr).must_equal "good-result"
     end
   end
-end
 
+  describe ".to_ffitype" do
+    it "returns :pointer" do
+      interface.to_ffitype.must_equal :pointer
+    end
+  end
+end

data/test/gir_ffi/object_base_test.rb

@@ -2,6 +2,7 @@ require 'gir_ffi_test_helper'
 
 describe GirFFI::ObjectBase do
   let(:derived_class) { Class.new GirFFI::ObjectBase }
+
   describe ".wrap" do
     it "delegates conversion to the wrapped pointer" do
       mock(ptr = Object.new).to_object { "good-result" }
@@ -15,5 +16,3 @@ describe GirFFI::ObjectBase do
     end
   end
 end
-
-

data/test/{ffi-glib → gir_ffi}/sized_array_test.rb

@@ -1,11 +1,11 @@
-require 'base_test_helper'
+require 'gir_ffi_test_helper'
 
-describe GLib::SizedArray do
+describe GirFFI::SizedArray do
   describe "::wrap" do
-    it "takes a type, size and pointer and returns a GLib::SizedArray wrapping them" do
+    it "takes a type, size and pointer and returns a GirFFI::SizedArray wrapping them" do
       mock(ptr = Object.new).null? { false }
-      sarr = GLib::SizedArray.wrap :gint32, 3, ptr
-      assert_instance_of GLib::SizedArray, sarr
+      sarr = GirFFI::SizedArray.wrap :gint32, 3, ptr
+      assert_instance_of GirFFI::SizedArray, sarr
       assert_equal ptr, sarr.to_ptr
       assert_equal 3, sarr.size
       assert_equal :gint32, sarr.element_type
@@ -13,7 +13,7 @@ describe GLib::SizedArray do
 
     it "returns nil if the wrapped pointer is null" do
       mock(ptr = Object.new).null? { true }
-      sarr = GLib::SizedArray.wrap :gint32, 3, ptr
+      sarr = GirFFI::SizedArray.wrap :gint32, 3, ptr
       sarr.must_be_nil
     end
   end
@@ -26,7 +26,7 @@ describe GLib::SizedArray do
       block = FFI::MemoryPointer.new(:pointer, ptrs.length)
       block.write_array_of_pointer ptrs
 
-      sarr = GLib::SizedArray.new :utf8, 3, block
+      sarr = GirFFI::SizedArray.new :utf8, 3, block
       arr = []
       sarr.each do |str|
         arr << str
@@ -37,44 +37,44 @@ describe GLib::SizedArray do
 
   describe "::from" do
     describe "from a Ruby array" do
-      it "creates a GLib::SizedArray with the same elements" do
-        arr = GLib::SizedArray.from :gint32, 3, [3, 2, 1]
-        arr.must_be_instance_of GLib::SizedArray
+      it "creates a GirFFI::SizedArray with the same elements" do
+        arr = GirFFI::SizedArray.from :gint32, 3, [3, 2, 1]
+        arr.must_be_instance_of GirFFI::SizedArray
         assert_equal [3, 2, 1], arr.to_a
       end
 
       it "raises an error if the array has the wrong number of elements" do
-        lambda { GLib::SizedArray.from :gint32, 4, [3, 2, 1] }.must_raise ArgumentError
+        lambda { GirFFI::SizedArray.from :gint32, 4, [3, 2, 1] }.must_raise ArgumentError
       end
 
       it "uses the array's size if passed -1 as the size" do
-        arr = GLib::SizedArray.from :gint32, -1, [3, 2, 1]
+        arr = GirFFI::SizedArray.from :gint32, -1, [3, 2, 1]
         arr.size.must_equal 3
       end
     end
 
-    describe "from a GLib::SizedArray" do
+    describe "from a GirFFI::SizedArray" do
       it "return its argument" do
-        arr = GLib::SizedArray.from :gint32, 3, [3, 2, 1]
-        arr2 = GLib::SizedArray.from :gint32, 3, arr
+        arr = GirFFI::SizedArray.from :gint32, 3, [3, 2, 1]
+        arr2 = GirFFI::SizedArray.from :gint32, 3, arr
         assert_equal arr, arr2
       end
 
       it "raises an error if the argument has the wrong number of elements" do
-        arr = GLib::SizedArray.from :gint32, 3, [3, 2, 1]
-        lambda { GLib::SizedArray.from :gint32, 4, arr }.must_raise ArgumentError
+        arr = GirFFI::SizedArray.from :gint32, 3, [3, 2, 1]
+        lambda { GirFFI::SizedArray.from :gint32, 4, arr }.must_raise ArgumentError
       end
     end
 
     it "returns nil when passed nil" do
-      arr = GLib::SizedArray.from :gint32, 0, nil
+      arr = GirFFI::SizedArray.from :gint32, 0, nil
       arr.must_be_nil
     end
 
     it "wraps its argument if given a pointer" do
-      arr = GLib::SizedArray.from :gint32, 3, [3, 2, 1]
-      arr2 = GLib::SizedArray.from :gint32, 3, arr.to_ptr
-      assert_instance_of GLib::SizedArray, arr2
+      arr = GirFFI::SizedArray.from :gint32, 3, [3, 2, 1]
+      arr2 = GirFFI::SizedArray.from :gint32, 3, arr.to_ptr
+      assert_instance_of GirFFI::SizedArray, arr2
       refute arr2.equal? arr
       arr2.to_ptr.must_equal arr.to_ptr
     end
@@ -82,33 +82,33 @@ describe GLib::SizedArray do
 
   describe "#==" do
     it "returns true when comparing to an array with the same elements" do
-      sized = GLib::SizedArray.from :int32, 3, [1, 2, 3]
+      sized = GirFFI::SizedArray.from :int32, 3, [1, 2, 3]
 
       sized.must_be :==, [1, 2, 3]
     end
 
     it "returns false when comparing to an array with different elements" do
-      sized = GLib::SizedArray.from :int32, 3, [1, 2, 3]
+      sized = GirFFI::SizedArray.from :int32, 3, [1, 2, 3]
 
       sized.wont_be :==, [1, 2]
     end
 
     it "returns true when comparing to a sized array with the same elements" do
-      sized = GLib::SizedArray.from :int32, 3, [1, 2, 3]
-      other = GLib::SizedArray.from :int32, 3, [1, 2, 3]
+      sized = GirFFI::SizedArray.from :int32, 3, [1, 2, 3]
+      other = GirFFI::SizedArray.from :int32, 3, [1, 2, 3]
 
       sized.must_be :==, other
     end
 
     it "returns false when comparing to a sized array with different elements" do
-      sized = GLib::SizedArray.from :int32, 3, [1, 2, 3]
-      other = GLib::SizedArray.from :int32, 2, [1, 2]
+      sized = GirFFI::SizedArray.from :int32, 3, [1, 2, 3]
+      other = GirFFI::SizedArray.from :int32, 2, [1, 2]
 
       sized.wont_be :==, other
     end
   end
 
   it "includes Enumerable" do
-    GLib::SizedArray.must_include Enumerable
+    GirFFI::SizedArray.must_include Enumerable
   end
 end

data/test/gir_ffi/type_map_test.rb

@@ -4,7 +4,7 @@ describe GirFFI::TypeMap do
   describe ".type_specification_to_ffitype" do
     it "returns the nested FFI::Enum for an Enum module" do
       GirFFI::TypeMap.type_specification_to_ffitype(GLib::DateMonth).
-        must_equal GLib::DateMonth::Enum
+        must_equal GLib::DateMonth
     end
 
     it "returns the class itself for a Struct class" do

data/test/gir_ffi/user_defined_type_info_test.rb

@@ -19,16 +19,48 @@ describe GirFFI::UserDefinedTypeInfo do
     end
   end
 
+  describe "#install_vfunc_implementation" do
+    let(:info) { GirFFI::UserDefinedTypeInfo.new :some_class }
+    let(:implementation) { Object.new }
+
+    it "adds to the list of vfunc implementations" do
+      info.vfunc_implementations.must_equal []
+      info.install_vfunc_implementation :foo, implementation
+      info.vfunc_implementations.map(&:name).must_equal [:foo]
+    end
+
+    it "stores the passed-in implementation in the implementation object" do
+      info.install_vfunc_implementation :foo, implementation
+      impl =  info.vfunc_implementations.first
+      impl.implementation.must_equal implementation
+    end
+  end
+
   describe "#initialize" do
-    it "takes a block that is evaluated in the context of the instance" do
+    it "yields the new object to the block passed" do
       mock(foo_spec = Object.new).get_name { :foo }
       mock(bar_spec = Object.new).get_name { :bar }
 
-      info = GirFFI::UserDefinedTypeInfo.new :some_class do
-        install_property foo_spec
-        install_property bar_spec
+      info = GirFFI::UserDefinedTypeInfo.new :some_class do |inf|
+        inf.install_property foo_spec
+        inf.install_property bar_spec
       end
       info.properties.map(&:name).must_equal [:foo, :bar]
     end
   end
+
+  describe "#g_name" do
+    it "returns the described class' name by default" do
+      mock(klass = Object.new).name { "foo" }
+      info = GirFFI::UserDefinedTypeInfo.new klass
+      info.g_name.must_equal "foo"
+    end
+
+    it "returns the the name set by #g_name= if present" do
+      stub(klass = Object.new).name { "foo" }
+      info = GirFFI::UserDefinedTypeInfo.new klass
+      info.g_name = "bar"
+      info.g_name.must_equal "bar"
+    end
+  end
 end