gir_ffi 0.6.6 → 0.6.7

data/test/gir_ffi/builders/union_builder_test.rb

@@ -0,0 +1,29 @@
+require 'gir_ffi_test_helper'
+
+describe GirFFI::Builders::UnionBuilder do
+  let(:union_info) { get_introspection_data('GObject', 'TypeCValue') }
+  let(:builder) { GirFFI::Builders::UnionBuilder.new union_info }
+
+  describe "#setup_instance_method" do
+    it "returns false looking for a method that doesn't exist" do
+      builder.setup_instance_method('blub').must_equal false
+    end
+  end
+
+  describe "#layout_specification" do
+    it "returns the correct layout for GObject::TypeCValue" do
+      builder.layout_specification.must_equal [:v_int, :int32, 0,
+                                               :v_long, :int64, 0,
+                                               :v_int64, :int64, 0,
+                                               :v_double, :double, 0,
+                                               :v_pointer, :pointer, 0]
+    end
+  end
+
+  describe "#layout_superclass" do
+    it "returns FFI::Union" do
+      builder.layout_superclass.must_equal FFI::Union
+    end
+  end
+end
+

data/test/gir_ffi/{builder/type/user_defined_test.rb → builders/user_defined_builder_test.rb}

@@ -2,7 +2,7 @@ require 'gir_ffi_test_helper'
 
 GirFFI.setup :GIMarshallingTests
 
-describe GirFFI::Builder::Type::UserDefined do
+describe GirFFI::Builders::UserDefinedBuilder do
   describe "with type info containing one property" do
     before do
       @klass = Class.new GIMarshallingTests::OverridesObject
@@ -15,7 +15,7 @@ describe GirFFI::Builder::Type::UserDefined do
                                                 3)
       end
 
-      @builder = GirFFI::Builder::Type::UserDefined.new @info
+      @builder = GirFFI::Builders::UserDefinedBuilder.new @info
       @builder.build_class
     end
 

data/test/gir_ffi/callback_base_test.rb

@@ -0,0 +1,11 @@
+require 'gir_ffi_test_helper'
+
+describe GirFFI::CallbackBase do
+  describe ".store_callback" do
+    it "stores the passed in proc in CALLBACKS" do
+      GirFFI::CallbackBase.store_callback "some-callback"
+      GirFFI::CallbackBase::CALLBACKS.last.must_equal "some-callback"
+    end
+  end
+end
+

data/test/gir_ffi/class_base_test.rb

@@ -21,51 +21,51 @@ describe GirFFI::ClassBase do
         other = klass.wrap object.to_ptr
 
         object.must_be :==, other
+        other.must_be :==, object
       end
 
-      it "returns false when comparing to an object of the same class and different pointer" do
-        other = klass.wrap FFI::MemoryPointer.new(:int32)
-
-        object.wont_be :==, other
-      end
-
-      it "returns false when comparing to an object of a different class" do
-        other = Object.new
+      it "returns true when comparing to an object of the same class and a pointer with the same address" do
+        ptr = FFI::Pointer.new object.to_ptr
+        other = klass.wrap ptr
 
-        object.wont_be :==, other
+        object.must_be :==, other
+        other.must_be :==, object
       end
 
-      it "returns true when comparing to an object of a subclass and the same pointer" do
+      it "returns false when comparing to an object of a sub/superclass and the same pointer" do
         subclass = Class.new(klass)
         other = subclass.wrap object.to_ptr
 
-        object.must_be :==, other
+        object.wont_be :==, other
+        other.wont_be :==, object
       end
-    end
 
-    describe "#eql?" do
-      it "returns true when comparing to an object of the same class and pointer" do
-        other = klass.wrap object.to_ptr
+      it "returns false when comparing to an object of the same class and different pointer" do
+        other = klass.wrap FFI::MemoryPointer.new(:int32)
 
-        object.must_equal other
+        object.wont_be :==, other
+        other.wont_be :==, object
       end
 
-      it "returns false when comparing to an object of the same class and different pointer" do
-        other = klass.wrap FFI::MemoryPointer.new(:int32)
+      it "returns false when comparing to an object that doesn't respond to #to_ptr" do
+        other = Object.new
 
-        object.wont_equal other
+        object.wont_be :==, other
+        other.wont_be :==, object
       end
 
-      it "returns true when comparing to an object of a different class and same pointer" do
+      it "returns false when comparing to an object of a different class and same pointer" do
         stub(other = Object.new).to_ptr { object.to_ptr }
 
-        object.wont_equal other
+        object.wont_be :==, other
+        other.wont_be :==, object
       end
 
       it "returns false when comparing to an object of a different class and different pointer" do
         stub(other = Object.new).to_ptr { FFI::MemoryPointer.new(:int32) }
 
-        object.wont_equal other
+        object.wont_be :==, other
+        other.wont_be :==, object
       end
     end
   end

data/test/gir_ffi/ffi_ext/pointer_test.rb

@@ -0,0 +1,18 @@
+require 'gir_ffi_test_helper'
+
+describe GirFFI::FFIExt::Pointer do
+  let(:klass) { Class.new { include GirFFI::FFIExt::Pointer } }
+  describe "#to_object" do
+    it "finds the wrapping class by gtype and wraps the pointer in it" do
+      ptr = klass.new
+      mock(ptr).null? { false }
+      object_class = Class.new
+
+      mock(GObject).type_from_instance_pointer(ptr) { 0xdeadbeef }
+      mock(GirFFI::Builder).build_by_gtype(0xdeadbeef) { object_class }
+      mock(object_class).direct_wrap(ptr) { "good-result" }
+
+      ptr.to_object.must_equal "good-result"
+    end
+  end
+end

data/test/gir_ffi/in_out_pointer_test.rb

@@ -103,11 +103,4 @@ describe GirFFI::InOutPointer do
       end
     end
   end
-
-  describe "#value_ffi_type" do
-    it "returns :int for the :gboolean value type" do
-      ptr = GirFFI::InOutPointer.from :gboolean, true
-      ptr.value_ffi_type.must_equal :int
-    end
-  end
 end

data/test/gir_ffi/in_pointer_test.rb

@@ -23,8 +23,8 @@ describe GirFFI::InPointer do
     end
 
     it "handles struct types" do
-      e = Class.new do
-        self::Struct = Class.new(FFI::Struct) do
+      e = Class.new(GirFFI::StructBase) do
+        self::Struct = Class.new(GirFFI::Struct) do
           layout :foo, :int32, :bar, :int32
         end
       end
@@ -149,5 +149,29 @@ describe GirFFI::InPointer do
       ptr.address.must_equal 1
     end
   end
-end
 
+  describe ".from_object" do
+    describe "when called with an object implementing to_ptr" 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
+      end
+    end
+
+    describe "when called with nil" do
+      it "returns nil" do
+        GirFFI::InPointer.from_object(nil).must_equal nil
+      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)
+        result = GirFFI::ArgHelper::OBJECT_STORE[ptr.address]
+        result.must_equal str
+      end
+    end
+  end
+end

data/test/gir_ffi/info_ext/i_signal_info_test.rb

@@ -7,53 +7,25 @@ describe GirFFI::InfoExt::ISignalInfo do
   end }
   let(:signal_info) { klass.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
-      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 = sig.cast_back_signal_arguments(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 "#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
-        b = Regress::TestSimpleBoxedA.new
-        sig = o.class.find_signal "test-with-static-scope-arg"
-
-        @gva = sig.signal_arguments_to_gvalue_array(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
+    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
 
-      should "have a first value with GType for TestSubObj" do
-        assert_equal Regress::TestSubObj.get_gtype, (@gva.get_nth 0).current_gtype
-      end
+    it "correctly wraps :object" do
+      result.get_nth(0).get_value.must_equal object
+    end
 
-      should "have a second value with GType for TestSimpleBoxedA" do
-        assert_equal Regress::TestSimpleBoxedA.get_gtype, (@gva.get_nth 1).current_gtype
-      end
+    it "correctly wraps :struct" do
+      result_boxed = result.get_nth(1).get_value
+      result_boxed.some_int8.must_equal boxed.some_int8
+      result_boxed.some_int.must_equal boxed.some_int
     end
   end
 

data/test/gir_ffi/info_ext/i_type_info_test.rb

@@ -4,12 +4,16 @@ describe GirFFI::InfoExt::ITypeInfo do
   let(:klass) { Class.new do
     include GirFFI::InfoExt::ITypeInfo
   end }
+
   let(:type_info) { klass.new }
   let(:elmtype_info) { klass.new }
   let(:keytype_info) { klass.new }
   let(:valtype_info) { klass.new }
   let(:iface_info) { Object.new }
 
+  let(:callback_type_info) {
+    get_introspection_data('Regress', 'test_callback').args[0].argument_type }
+
   describe "#to_ffitype" do
     it "returns an array with elements subtype and size for type :array" do
       mock(type_info).pointer? { false }
@@ -90,14 +94,14 @@ describe GirFFI::InfoExt::ITypeInfo do
       end
     end
 
-    context "for a zero-terminated array" do
+    describe "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 }
       end
 
-      context "of utf8" do
+      describe "of utf8" do
         it "returns :strv" do
           stub(elmtype_info).tag { :utf8 }
           stub(elmtype_info).pointer? { true }
@@ -106,7 +110,7 @@ describe GirFFI::InfoExt::ITypeInfo do
         end
       end
 
-      context "of filename" do
+      describe "of filename" do
         it "returns :strv" do
           stub(elmtype_info).tag { :filename }
           stub(elmtype_info).pointer? { true }
@@ -115,7 +119,7 @@ describe GirFFI::InfoExt::ITypeInfo do
         end
       end
 
-      context "of another type" do
+      describe "of another type" do
         it "returns :zero_terminated" do
           stub(elmtype_info).tag { :foo }
           stub(elmtype_info).pointer? { false }
@@ -135,16 +139,13 @@ describe GirFFI::InfoExt::ITypeInfo do
       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" }
-
-        mock(type_info).param_type(0) { elmtype_info }
+    describe "for a GLib array" do
+      it "returns :c" do
+        mock(type_info).tag { :array }
+        mock(type_info).zero_terminated? { false }
+        mock(type_info).array_type { :array }
 
-        type_info.subtype_tag_or_class_name.must_equal ":foo"
+        type_info.flattened_tag.must_equal :array
       end
     end
   end
@@ -161,64 +162,6 @@ describe GirFFI::InfoExt::ITypeInfo do
     end
   end
 
-  describe "#tag_or_class_name" do
-    describe "for the simple type :foo" do
-      it "returns the string ':foo'" do
-        stub(type_info).tag { :foo }
-        mock(type_info).pointer? { false }
-
-        assert_equal ":foo", type_info.tag_or_class_name
-      end
-    end
-
-    describe "for :utf8" do
-      it "returns the string ':utf8'" do
-        stub(type_info).tag { :utf8 }
-        mock(type_info).pointer? { true }
-
-        assert_equal ":utf8", type_info.tag_or_class_name
-      end
-    end
-
-    describe "for an interface named Foo::Bar" do
-      let(:interface) { Object.new }
-
-      before do
-        stub(type_info).tag { :interface }
-        stub(type_info).interface { iface_info }
-        mock(type_info).pointer? { false }
-        stub(interface).inspect { "Foo::Bar" }
-
-        mock(GirFFI::Builder).build_class(iface_info) { interface }
-      end
-
-      context "when the interface type is :enum" do
-        it "returns the interface's full class name" do
-          stub(iface_info).info_type { :enum }
-
-          assert_equal "Foo::Bar", type_info.tag_or_class_name
-        end
-      end
-
-      context "when the interface type is :object" do
-        it "returns the string [:pointer, Foo::Bar]" do
-          stub(iface_info).info_type { :object }
-
-          assert_equal "[:pointer, Foo::Bar]", type_info.tag_or_class_name
-        end
-      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 "#tag_or_class" do
     describe "for a simple type" do
       it "returns the type's tag" do
@@ -258,7 +201,7 @@ describe GirFFI::InfoExt::ITypeInfo do
         mock(GirFFI::Builder).build_class(iface_info) { interface }
       end
 
-      context "when the interface type is :enum" do
+      describe "when the interface type is :enum" do
         it "returns the built interface module" do
           stub(iface_info).info_type { :enum }
 
@@ -266,7 +209,7 @@ describe GirFFI::InfoExt::ITypeInfo do
         end
       end
 
-      context "when the interface type is :object" do
+      describe "when the interface type is :object" do
         it "returns an array with elements :pointer and built interface class" do
           stub(iface_info).info_type { :object }
 
@@ -274,13 +217,20 @@ describe GirFFI::InfoExt::ITypeInfo do
         end
       end
 
-      context "when the interface type is :struct" do
+      describe "when the interface type is :struct" do
         it "returns the built interface class" do
           stub(iface_info).info_type { :struct }
 
           type_info.tag_or_class.must_equal interface
         end
       end
+
+    end
+
+    describe "for a callback" do
+      it "returns :callback" do
+        callback_type_info.tag_or_class.must_equal :callback
+      end
     end
 
     describe "for a pointer to simple type :foo" do
@@ -323,4 +273,295 @@ describe GirFFI::InfoExt::ITypeInfo do
       end
     end
   end
+
+  describe "#extra_conversion_arguments" do
+    describe "for normal types" do
+      before do
+        stub(type_info).tag { :foo }
+      end
+
+      it "returns an empty array" do
+        type_info.extra_conversion_arguments.must_equal []
+      end
+    end
+
+    describe "for a string" do
+      before do
+        stub(type_info).tag { :utf8 }
+      end
+
+      it "returns an array containing :utf8" do
+        type_info.extra_conversion_arguments.must_equal [:utf8]
+      end
+    end
+
+    describe "for a fixed-size array" do
+      before do
+        stub(type_info).tag { :array }
+        stub(type_info).zero_terminated? { false }
+        stub(type_info).array_type { :c }
+        stub(type_info).array_fixed_size { 3 }
+
+        stub(type_info).param_type(0) { elmtype_info }
+        stub(elmtype_info).tag_or_class { :foo }
+      end
+
+      it "returns an array containing the element type" do
+        type_info.extra_conversion_arguments.must_equal [:foo, 3]
+      end
+    end
+
+    describe "for a zero-terminated array" do
+      before do
+        stub(type_info).tag { :array }
+        stub(type_info).zero_terminated? { true }
+
+        stub(type_info).param_type(0) { elmtype_info }
+        stub(elmtype_info).tag_or_class { :foo }
+      end
+
+      it "returns an array containing the element type" do
+        type_info.extra_conversion_arguments.must_equal [:foo]
+      end
+    end
+
+    describe "for a GArray" do
+      before do
+        stub(type_info).tag { :array }
+        stub(type_info).zero_terminated? { false }
+        stub(type_info).array_type { :array }
+
+        stub(type_info).param_type(0) { elmtype_info }
+        stub(elmtype_info).tag_or_class { :foo }
+      end
+
+      it "returns an array containing the element type" do
+        type_info.extra_conversion_arguments.must_equal [:foo]
+      end
+    end
+
+    describe "for a GHashTable" do
+      before do
+        stub(type_info).tag {:ghash}
+        stub(type_info).param_type(0) { keytype_info }
+        stub(type_info).param_type(1) { valtype_info }
+
+        stub(keytype_info).tag_or_class { :foo }
+        stub(valtype_info).tag_or_class { :bar }
+      end
+
+      it "returns an array containing the element type pair" do
+        type_info.extra_conversion_arguments.must_equal [[:foo, :bar]]
+      end
+    end
+
+    describe "for a GList" do
+      before do
+        stub(type_info).tag { :glist }
+
+        stub(type_info).param_type(0) { elmtype_info }
+        stub(elmtype_info).tag_or_class { :foo }
+      end
+
+      it "returns an array containing the element type" do
+        type_info.extra_conversion_arguments.must_equal [:foo]
+      end
+    end
+
+    describe "for a GSList" do
+      before do
+        stub(type_info).tag { :gslist }
+
+        stub(type_info).param_type(0) { elmtype_info }
+        stub(elmtype_info).tag_or_class { :foo }
+      end
+
+      it "returns an array containing the element type" do
+        type_info.extra_conversion_arguments.must_equal [:foo]
+      end
+    end
+
+    describe "for a GPtrArray" do
+      before do
+        stub(type_info).tag { :array }
+        stub(type_info).zero_terminated? { false }
+        stub(type_info).array_type { :ptr_array }
+
+
+        stub(type_info).param_type(0) { elmtype_info }
+        stub(elmtype_info).tag_or_class { :foo }
+      end
+
+      it "returns an array containing the element type" do
+        type_info.extra_conversion_arguments.must_equal [:foo]
+      end
+    end
+
+    describe "for a :callback" do
+      before do
+        stub(interface_type_info = Object.new).namespace { "Bar" }
+        stub(interface_type_info).name { "Foo" }
+
+        stub(type_info).tag { :callback }
+        stub(type_info).interface { interface_type_info }
+      end
+
+      it "has the correct value for #pre" do
+        type_info.extra_conversion_arguments.must_equal []
+      end
+    end
+  end
+
+  describe "#argument_class_name" do
+    before do
+      stub(type_info).tag { tag }
+    end
+
+    describe "for :gint32" do
+      let(:tag) { :gint32 }
+
+      it "is nil" do
+        type_info.argument_class_name.must_be_nil
+      end
+    end
+
+    describe "for interfaces" do
+      let(:tag) { :interface }
+
+      before do
+        stub(type_info).interface { iface_info }
+        stub(iface_info).info_type { interface_type }
+        stub(iface_info).full_type_name { 'Bar::Foo' }
+      end
+
+      describe "for :struct" do
+        let(:interface_type) { :struct }
+        it "equals the struct class name" do
+          type_info.argument_class_name.must_equal 'Bar::Foo'
+        end
+      end
+
+      describe "for :union" do
+        let(:interface_type) { :union }
+        it "equals the union class name" do
+          type_info.argument_class_name.must_equal 'Bar::Foo'
+        end
+      end
+
+      describe "for :interface" do
+        let(:interface_type) { :interface }
+
+        it "equals the interface module name" do
+          type_info.argument_class_name.must_equal 'Bar::Foo'
+        end
+      end
+
+      describe "for :object" do
+        let(:interface_type) { :object }
+
+        it "equals the object class name" do
+          type_info.argument_class_name.must_equal 'Bar::Foo'
+        end
+      end
+
+      describe "for :callback" do
+        let(:interface_type) { :callback }
+
+        it "equals the callback type name" do
+          type_info.argument_class_name.must_equal 'Bar::Foo'
+        end
+      end
+    end
+
+    describe "for :strv" do
+      let(:tag) { :strv }
+
+      it "equals GLib::Strv" do
+        type_info.argument_class_name.must_equal 'GLib::Strv'
+      end
+    end
+
+    describe "for arrays" do
+      let(:tag) { :array }
+      before do
+        stub(type_info).param_type(0) { elmtype_info }
+        stub(elmtype_info).tag_or_class { :foo }
+      end
+
+      describe "for :zero_terminated" do
+        before do
+          stub(type_info).zero_terminated? { true }
+        end
+
+        it "equals GirFFI::ZeroTerminated" do
+          type_info.argument_class_name.must_equal "GirFFI::ZeroTerminated"
+        end
+      end
+
+      describe "for :byte_array" do
+        before do
+          stub(type_info).zero_terminated? { false }
+          stub(type_info).array_type { :byte_array }
+        end
+
+        it "equals GLib::ByteArray" do
+          type_info.argument_class_name.must_equal 'GLib::ByteArray'
+        end
+      end
+
+      describe "for :ptr_array" do
+        before do
+          stub(type_info).zero_terminated? { false }
+          stub(type_info).array_type { :ptr_array }
+        end
+
+        it "equals GLib::PtrArray" do
+          type_info.argument_class_name.must_equal 'GLib::PtrArray'
+        end
+      end
+
+      describe "for :array" do
+        before do
+          stub(type_info).zero_terminated? { false }
+          stub(type_info).array_type { :array }
+        end
+
+        it "equals GLib::Array" do
+          type_info.argument_class_name.must_equal 'GLib::Array'
+        end
+      end
+    end
+
+    describe "for :glist" do
+      let(:tag) { :glist }
+
+      it "equals GLib::List" do
+        type_info.argument_class_name.must_equal 'GLib::List'
+      end
+    end
+
+    describe "for :gslist" do
+      let(:tag) { :gslist }
+
+      it "equals GLib::SList" do
+        type_info.argument_class_name.must_equal 'GLib::SList'
+      end
+    end
+
+    describe "for :ghash" do
+      let(:tag) { :ghash }
+
+      it "equals GLib::HashTable" do
+        type_info.argument_class_name.must_equal 'GLib::HashTable'
+      end
+    end
+
+    describe "for :error" do
+      let(:tag) { :error }
+
+      it "equals GLib::Error" do
+        type_info.argument_class_name.must_equal 'GLib::Error'
+      end
+    end
+  end
 end