gir_ffi 0.4.3 → 0.5.0

data/test/gir_ffi/in_out_pointer_test.rb

@@ -90,26 +90,6 @@ describe GirFFI::InOutPointer do
     end
   end
 
-  describe "::for_array" do
-    it "handles :gint32" do
-      @ptr = GirFFI::InOutPointer.for_array :gint32
-      assert_equal :pointer, @ptr.value_type
-      assert_equal :gint32, @ptr.sub_type
-    end
-
-    it "handles GObject" do
-      @ptr = GirFFI::InOutPointer.for_array GObject::Object
-      assert_equal :pointer, @ptr.value_type
-      assert_equal GObject::Object, @ptr.sub_type
-    end
-
-    it "handles pointer to GObject" do
-      @ptr = GirFFI::InOutPointer.for_array [:pointer, GObject::Object]
-      assert_equal :pointer, @ptr.value_type
-      assert_equal [:pointer, GObject::Object], @ptr.sub_type
-    end
-  end
-
   describe "#to_value" do
     it "returns the held value" do
       ptr = GirFFI::InOutPointer.from :gint32, 123

data/test/gir_ffi/info_ext/i_type_info_test.rb

@@ -4,51 +4,49 @@ describe GirFFI::InfoExt::ITypeInfo do
   let(:testclass) { Class.new do
     include GirFFI::InfoExt::ITypeInfo
   end }
+  let(:type_info) { testclass.new }
+  let(:elmtype_info) { testclass.new }
+  let(:keytype_info) { testclass.new }
+  let(:valtype_info) { testclass.new }
 
   describe "#layout_specification_type" do
     it "returns an array with elements subtype and size for type :array" do
-      mock(subtype = Object.new).layout_specification_type { :foo }
+      mock(elmtype_info).layout_specification_type { :foo }
 
-      type = testclass.new
-      mock(type).array_fixed_size { 2 }
-      mock(type).param_type(0) { subtype }
+      mock(type_info).array_fixed_size { 2 }
+      mock(type_info).param_type(0) { elmtype_info }
 
-      mock(GirFFI::Builder).itypeinfo_to_ffitype(type) { :array }
-
-      result = type.layout_specification_type
+      mock(GirFFI::Builder).itypeinfo_to_ffitype(type_info) { :array }
 
+      result = type_info.layout_specification_type
       assert_equal [:foo, 2], result
     end
   end
 
   describe "#element_type" do
     it "returns the element type for lists" do
-      type_info = testclass.new
-      mock(elm_type = Object.new).tag { :foo }
+      mock(elmtype_info).tag { :foo }
 
       mock(type_info).tag {:glist}
-      mock(type_info).param_type(0) { elm_type }
+      mock(type_info).param_type(0) { elmtype_info }
 
       result = type_info.element_type
       result.must_equal :foo
     end
 
     it "returns the key and value types for ghashes" do
-      type_info = testclass.new
-      mock(key_type = Object.new).tag { :foo }
-      mock(val_type = Object.new).tag { :bar }
+      mock(keytype_info).tag { :foo }
+      mock(valtype_info).tag { :bar }
 
       mock(type_info).tag {:ghash}
-      mock(type_info).param_type(0) { key_type }
-      mock(type_info).param_type(1) { val_type }
+      mock(type_info).param_type(0) { keytype_info }
+      mock(type_info).param_type(1) { valtype_info }
 
       result = type_info.element_type
       result.must_equal [:foo, :bar]
     end
 
     it "returns nil for other types" do
-      type_info = testclass.new
-
       mock(type_info).tag {:foo}
 
       result = type_info.element_type
@@ -56,8 +54,6 @@ describe GirFFI::InfoExt::ITypeInfo do
     end
 
     it "returns :gpointer if the element type is a pointer with tag :void" do
-      type_info = testclass.new
-
       stub(elm_type = Object.new).tag { :void }
       stub(elm_type).pointer? { true }
 
@@ -71,21 +67,111 @@ describe GirFFI::InfoExt::ITypeInfo do
   describe "#type_specification" do
     describe "for a simple type" do
       it "returns the type tag" do
-	type_info = testclass.new
-	mock(type_info).tag { :uint32 }
+	stub(type_info).tag { :uint32 }
+
 	type_info.type_specification.must_equal ":uint32"
       end
     end
 
-    describe "for a zero-terminated array" do
-      it "returns the pair [:strv, element_type]" do
-	type_info = testclass.new
-	mock(type_info).tag { :array }
-	stub(type_info).element_type { :utf8 }
+    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 }
+
+	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.type_specification.must_equal "[:strv, :utf8]"
       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 }
+
+	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.type_specification.must_equal "[:zero_terminated, :foo]"
+      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 }
+
+	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 }
+
+	type_info.type_specification.must_equal "[:c, :foo]"
+      end
+    end
+
+  end
+
+  describe "#subtype_tag_or_class_name" 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 }
+
+        assert_equal ":void", info.subtype_tag_or_class_name
+      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 }
+
+        mock(info = testclass.new).param_type(0) { subtype }
+
+        assert_equal ":foo", info.subtype_tag_or_class_name
+      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 }
+
+        mock(info = testclass.new).param_type(0) { subtype }
+
+        assert_equal ":utf8", info.subtype_tag_or_class_name
+      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 }
+
+        mock(info = testclass.new).param_type(0) { subtype }
+
+        assert_equal "-full-type-name-", info.subtype_tag_or_class_name
+      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 }
+
+        mock(info = testclass.new).param_type(0) { subtype }
+
+        assert_equal "[:pointer, :foo]", info.subtype_tag_or_class_name
+      end
+    end
   end
 end

data/test/gir_ffi/info_ext/safe_constant_name_test.rb

@@ -0,0 +1,16 @@
+require 'gir_ffi_test_helper'
+
+describe GirFFI::InfoExt::SafeConstantName do
+  let(:testclass) { Class.new do
+    include GirFFI::InfoExt::SafeConstantName
+  end }
+  let(:info) { testclass.new }
+
+  describe "#safe_name" do
+    it "makes names starting with an underscore safe" do
+      mock(info).name { "_foo" }
+
+      assert_equal "Private___foo", info.safe_name
+    end
+  end
+end

data/test/gir_ffi/info_ext/safe_function_name_test.rb

@@ -0,0 +1,22 @@
+require 'gir_ffi_test_helper'
+
+describe GirFFI::InfoExt::SafeFunctionName do
+  let(:testclass) { Class.new do
+    include GirFFI::InfoExt::SafeFunctionName
+  end }
+  let(:info) { testclass.new }
+
+  describe "#safe_name" do
+    it "keeps lower case names lower case" do
+      mock(info).name { "foo" }
+
+      assert_equal "foo", info.safe_name
+    end
+
+    it "returns a non-empty string if name is empty" do
+      mock(info).name { "" }
+
+      assert_equal "_", info.safe_name
+    end
+  end
+end

data/test/gir_ffi/return_value_builder_test.rb

@@ -0,0 +1,355 @@
+require 'gir_ffi_test_helper'
+
+describe GirFFI::ReturnValueBuilder do
+  let(:type_info) { Object.new }
+  let(:var_gen) { GirFFI::VariableNameGenerator.new }
+  let(:for_constructor) { "irrelevant" }
+  let(:builder) { GirFFI::ReturnValueBuilder.new(var_gen,
+                                                 type_info,
+                                                 for_constructor) }
+
+  before do
+    stub(type_info).interface_type_name { 'Bar::Foo' }
+  end
+
+  describe "for :gint32" do
+    before do
+      stub(type_info).flattened_tag { :gint32 }
+    end
+
+    it "has no statements in #post" do
+      builder.post.must_equal []
+    end
+
+    it "returns the result of the c function directly" do
+      builder.callarg.must_equal "_v1"
+      builder.retval.must_equal "_v1"
+    end
+  end
+
+  describe "for :struct" do
+    before do
+      stub(type_info).flattened_tag { :struct }
+    end
+
+    it "wraps the result in #post" do
+      builder.callarg.must_equal "_v1"
+      builder.post.must_equal [ "_v2 = Bar::Foo.wrap(_v1)" ]
+    end
+
+    it "returns the wrapped result" do
+      builder.callarg.must_equal "_v1"
+      builder.retval.must_equal "_v2"
+    end
+  end
+
+  describe "for :union" do
+    before do
+      stub(type_info).flattened_tag { :union }
+    end
+
+    it "wraps the result in #post" do
+      builder.callarg.must_equal "_v1"
+      builder.post.must_equal [ "_v2 = Bar::Foo.wrap(_v1)" ]
+    end
+
+    it "returns the wrapped result" do
+      builder.callarg.must_equal "_v1"
+      builder.retval.must_equal "_v2"
+    end
+  end
+
+  describe "for :interface" do
+    before do
+      stub(type_info).flattened_tag { :interface }
+    end
+
+    describe "when the method is not a constructor" do
+      let(:for_constructor) { false }
+
+      it "wraps the result in #post" do
+        builder.callarg.must_equal "_v1"
+        builder.post.must_equal [ "_v2 = Bar::Foo.wrap(_v1)" ]
+      end
+
+      it "returns the wrapped result" do
+        builder.callarg.must_equal "_v1"
+        builder.retval.must_equal "_v2"
+      end
+    end
+
+    describe "when the method is a constructor" do
+      let(:for_constructor) { true }
+
+      it "wraps the result in #post" do
+        builder.callarg.must_equal "_v1"
+        builder.post.must_equal [ "_v2 = self.constructor_wrap(_v1)" ]
+      end
+
+      it "returns the wrapped result" do
+        builder.callarg.must_equal "_v1"
+        builder.retval.must_equal "_v2"
+      end
+    end
+  end
+
+  describe "for :object" do
+    before do
+      stub(type_info).flattened_tag { :object }
+    end
+
+    describe "when the method is not a constructor" do
+      let(:for_constructor) { false }
+
+      it "wraps the result in #post" do
+        builder.callarg.must_equal "_v1"
+        builder.post.must_equal [ "_v2 = Bar::Foo.wrap(_v1)" ]
+      end
+
+      it "returns the wrapped result" do
+        builder.callarg.must_equal "_v1"
+        builder.retval.must_equal "_v2"
+      end
+    end
+
+    describe "when the method is a constructor" do
+      let(:for_constructor) { true }
+
+      it "wraps the result in #post" do
+        builder.callarg.must_equal "_v1"
+        builder.post.must_equal [ "_v2 = self.constructor_wrap(_v1)" ]
+      end
+
+      it "returns the wrapped result" do
+        builder.callarg.must_equal "_v1"
+        builder.retval.must_equal "_v2"
+      end
+    end
+  end
+
+  describe "for :strv" do
+    before do
+      stub(type_info).flattened_tag { :strv }
+    end
+
+    it "wraps the result in #post" do
+      builder.callarg.must_equal "_v1"
+      builder.post.must_equal [ "_v2 = GLib::Strv.wrap(_v1)" ]
+    end
+
+    it "returns the wrapped result" do
+      builder.callarg.must_equal "_v1"
+      builder.retval.must_equal "_v2"
+    end
+  end
+
+  describe "for :zero_terminated" do
+    before do
+      stub(type_info).flattened_tag { :zero_terminated }
+    end
+
+    it "wraps the result in #post" do
+      builder.callarg.must_equal "_v1"
+      # FIXME: This is almost certainly wrong, but matches original behavior.
+      builder.post.must_equal [ "_v2 = GirFFI::InPointer.wrap(_v1)" ]
+    end
+
+    it "returns the wrapped result" do
+      builder.callarg.must_equal "_v1"
+      builder.retval.must_equal "_v2"
+    end
+  end
+
+  describe "for :byte_array" do
+    before do
+      stub(type_info).flattened_tag { :byte_array }
+    end
+
+    it "wraps the result in #post" do
+      builder.callarg.must_equal "_v1"
+      builder.post.must_equal [ "_v2 = GLib::ByteArray.wrap(_v1)" ]
+    end
+
+    it "returns the wrapped result" do
+      builder.callarg.must_equal "_v1"
+      builder.retval.must_equal "_v2"
+    end
+  end
+
+  describe "for :ptr_array" do
+    before do
+      stub(type_info).flattened_tag { :ptr_array }
+    end
+
+    it "wraps the result in #post" do
+      builder.callarg.must_equal "_v1"
+      builder.post.must_equal [ "_v2 = GLib::PtrArray.wrap(_v1)" ]
+    end
+
+    it "returns the wrapped result" do
+      builder.callarg.must_equal "_v1"
+      builder.retval.must_equal "_v2"
+    end
+  end
+
+  describe "for :glist" do
+    before do
+      stub(type_info).flattened_tag { :glist }
+      stub(type_info).element_type { :foo }
+    end
+
+    it "wraps the result in #post" do
+      builder.callarg.must_equal "_v1"
+      builder.post.must_equal [ "_v2 = GLib::List.wrap(:foo, _v1)" ]
+    end
+
+    it "returns the wrapped result" do
+      builder.callarg.must_equal "_v1"
+      builder.retval.must_equal "_v2"
+    end
+  end
+
+  describe "for :gslist" do
+    before do
+      stub(type_info).flattened_tag { :gslist }
+      stub(type_info).element_type { :foo }
+    end
+
+    it "wraps the result in #post" do
+      builder.callarg.must_equal "_v1"
+      builder.post.must_equal [ "_v2 = GLib::SList.wrap(:foo, _v1)" ]
+    end
+
+    it "returns the wrapped result" do
+      builder.callarg.must_equal "_v1"
+      builder.retval.must_equal "_v2"
+    end
+  end
+
+  describe "for :ghash" do
+    before do
+      stub(type_info).flattened_tag { :ghash }
+      stub(type_info).element_type { [:foo, :bar] }
+    end
+
+    it "wraps the result in #post" do
+      builder.callarg.must_equal "_v1"
+      builder.post.must_equal [ "_v2 = GLib::HashTable.wrap([:foo, :bar], _v1)" ]
+    end
+
+    it "returns the wrapped result" do
+      builder.callarg.must_equal "_v1"
+      builder.retval.must_equal "_v2"
+    end
+  end
+
+  describe "for :array" do
+    before do
+      stub(type_info).flattened_tag { :array }
+      stub(type_info).element_type { :foo }
+    end
+
+    it "wraps the result in #post" do
+      builder.callarg.must_equal "_v1"
+      builder.post.must_equal [ "_v2 = GLib::Array.wrap(:foo, _v1)" ]
+    end
+
+    it "returns the wrapped result" do
+      builder.callarg.must_equal "_v1"
+      builder.retval.must_equal "_v2"
+    end
+  end
+
+  describe "for :c" do
+    describe "with fixed size" do
+      before do
+        stub(type_info).flattened_tag { :c }
+        stub(type_info).subtype_tag_or_class_name { ":foo" }
+        stub(type_info).array_fixed_size { 3 }
+      end
+
+      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" ]
+      end
+
+      it "returns the wrapped result" do
+        builder.callarg.must_equal "_v1"
+        builder.retval.must_equal "_v2"
+      end
+    end
+
+    describe "with separate size parameter" do
+      let(:length_argument) { Object.new }
+      before do
+        stub(type_info).flattened_tag { :c }
+        stub(type_info).subtype_tag_or_class_name { ":foo" }
+        stub(type_info).array_fixed_size { -1 }
+
+        stub(length_argument).retname { "bar" }
+        builder.length_arg = length_argument
+      end
+
+      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" ]
+      end
+
+      it "returns the wrapped result" do
+        builder.callarg.must_equal "_v1"
+        builder.retval.must_equal "_v2"
+      end
+    end
+  end
+
+  describe "for :utf8" do
+    before do
+      stub(type_info).flattened_tag { :utf8 }
+    end
+
+    it "converts the result in #post" do
+      builder.callarg.must_equal "_v1"
+      builder.post.must_equal [ "_v2 = GirFFI::ArgHelper.ptr_to_utf8(_v1)" ]
+    end
+
+    it "returns the converted result" do
+      builder.callarg.must_equal "_v1"
+      builder.retval.must_equal "_v2"
+    end
+  end
+
+  describe "for :void pointer" do
+    before do
+      stub(type_info).flattened_tag { :void }
+      stub(type_info).pointer? { true }
+    end
+
+    it "has no statements in #post" do
+      builder.post.must_equal []
+    end
+
+    it "returns the result of the c function directly" do
+      builder.callarg.must_equal "_v1"
+      builder.retval.must_equal "_v1"
+    end
+  end
+
+  describe "for :void" do
+    before do
+      stub(type_info).flattened_tag { :void }
+      stub(type_info).pointer? { false }
+    end
+
+    it "has no statements in #post" do
+      builder.post.must_equal []
+    end
+
+    it "does not capture the result of the c function" do
+      builder.cvar.must_be_nil
+    end
+
+    it "returns nothing" do
+      builder.retval.must_be_nil
+    end
+  end
+end