gir_ffi 0.9.5 → 0.10.0.pre1

data/test/gir_ffi/in_out_pointer_test.rb

@@ -11,102 +11,32 @@ describe GirFFI::InOutPointer do
     end
   end
 
-  describe 'an instance created with .from' do
-    before do
-      @result = GirFFI::InOutPointer.from :gint32, 23
-    end
-
-    it 'holds a pointer to the given value' do
-      assert_equal 23, @result.get_int32(0)
-    end
-
-    it 'is an instance of GirFFI::InOutPointer' do
-      assert_instance_of GirFFI::InOutPointer, @result
-    end
-  end
-
-  describe '.from' do
-    it 'handles :gboolean false' do
-      ptr = GirFFI::InOutPointer.from :gboolean, false
-      ptr.read_int.must_equal 0
-    end
-
-    it 'handles :gboolean true' do
-      ptr = GirFFI::InOutPointer.from :gboolean, true
-      ptr.read_int.must_equal(1)
-    end
-
-    it 'handles :utf8 pointers' do
-      str_ptr = GirFFI::InPointer.from :utf8, 'Hello'
-      GirFFI::InOutPointer.from :utf8, str_ptr
-    end
-  end
-
-  describe 'in instance created with .for' do
-    before do
-      @result = GirFFI::InOutPointer.for :gint32
-    end
-
-    it 'holds a pointer to a null value' do
-      assert_equal 0, @result.get_int32(0)
-    end
-
-    it 'is an instance of GirFFI::InOutPointer' do
-      assert_instance_of GirFFI::InOutPointer, @result
-    end
-  end
-
-  describe '.for' do
-    it 'handles :gboolean' do
-      result = GirFFI::InOutPointer.for :gboolean
-      result.to_value.must_equal false
-    end
-
-    it 'handles :utf8' do
-      result = GirFFI::InOutPointer.for :utf8
-      result.to_value.must_be :null?
-    end
-
-    it 'handles GObject::Value' do
-      result = GirFFI::InOutPointer.for GObject::Value
-      type_size = FFI.type_size GObject::Value
-      expected = "\x00" * type_size
-      result.to_value.read_bytes(type_size).must_equal expected
-    end
-  end
-
-  describe '#set_value' do
-    it 'works setting the value to nil for GObject::Value' do
-      pointer = GirFFI::InOutPointer.from GObject::Value, GObject::Value.from(3)
-      pointer.set_value nil
-      type_size = FFI.type_size GObject::Value
-      expected = "\x00" * type_size
-      pointer.to_value.read_bytes(type_size).must_equal expected
-    end
-  end
-
   describe '#to_value' do
     it 'returns the held value' do
-      ptr = GirFFI::InOutPointer.from :gint32, 123
+      ptr = GirFFI::InOutPointer.allocate_new :gint32
+      ptr.write_int32 123
       assert_equal 123, ptr.to_value
     end
 
     describe 'for :gboolean values' do
       it 'works when the value is false' do
-        ptr = GirFFI::InOutPointer.from :gboolean, false
+        ptr = GirFFI::InOutPointer.allocate_new :gboolean
+        ptr.write_int 0
         ptr.to_value.must_equal false
       end
 
       it 'works when the value is true' do
-        ptr = GirFFI::InOutPointer.from :gboolean, true
+        ptr = GirFFI::InOutPointer.allocate_new :gboolean
+        ptr.write_int 1
         ptr.to_value.must_equal true
       end
     end
 
     describe 'for :utf8 values' do
-      it 'returns a pointer to the held value' do
-        str_ptr = GirFFI::InPointer.from :utf8, 'Some value'
-        ptr = GirFFI::InOutPointer.from :utf8, str_ptr
+      it 'returns a pointer to the held string value' do
+        str_ptr = GirFFI::InPointer.from_utf8 'Some value'
+        ptr = GirFFI::InOutPointer.allocate_new :utf8
+        ptr.write_pointer str_ptr
         assert_equal 'Some value', ptr.to_value.read_string
       end
     end
@@ -115,7 +45,8 @@ describe GirFFI::InOutPointer do
       it 'returns a pointer to the held value' do
         val = GObject::EnumValue.new
         val.value = 3
-        ptr = GirFFI::InOutPointer.from GObject::EnumValue, val
+        ptr = GirFFI::InOutPointer.allocate_new GObject::EnumValue
+        GObject::EnumValue.copy_value_to_pointer val, ptr
         result = ptr.to_value
         GObject::EnumValue.wrap(result).value.must_equal 3
       end

data/test/gir_ffi/in_pointer_test.rb

@@ -181,21 +181,4 @@ describe GirFFI::InPointer do
       end
     end
   end
-
-  describe '.from_closure_data' do
-    describe 'when called with nil' do
-      it 'returns a null pointer' do
-        GirFFI::InPointer.from_closure_data(nil).must_be :null?
-      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_closure_data(str)
-        result = GirFFI::ArgHelper::OBJECT_STORE.fetch(ptr)
-        result.must_equal str
-      end
-    end
-  end
 end

data/test/gir_ffi/info_ext/i_type_info_test.rb

@@ -291,16 +291,6 @@ describe GirFFI::InfoExt::ITypeInfo do
       end
     end
 
-    describe 'for a string' do
-      before do
-        allow(type_info).to receive(:tag).and_return :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
         allow(type_info).to receive(:tag).and_return :array

data/test/gir_ffi/sized_array_test.rb

@@ -81,6 +81,68 @@ describe GirFFI::SizedArray do
     end
   end
 
+  describe '.copy_from' do
+    describe 'from a Ruby array' do
+      it 'creates an unowned GirFFI::SizedArray with the same elements' do
+        arr = GirFFI::SizedArray.copy_from :gint32, 3, [3, 2, 1]
+        arr.must_be_instance_of GirFFI::SizedArray
+        assert_equal [3, 2, 1], arr.to_a
+        arr.to_ptr.wont_be :autorelease?
+      end
+
+      it 'creates unowned copies of struct pointer elements' do
+        struct = GIMarshallingTests::BoxedStruct.new
+        struct.long_ = 2342
+        arr = GirFFI::SizedArray.copy_from([:pointer, GIMarshallingTests::BoxedStruct],
+                                           1,
+                                           [struct])
+        arr.must_be_instance_of GirFFI::SizedArray
+        arr.to_ptr.wont_be :autorelease?
+
+        struct_copy = arr.first
+        struct_copy.long_.must_equal struct.long_
+        struct_copy.to_ptr.wont_equal struct.to_ptr
+        struct_copy.to_ptr.wont_be :autorelease?
+      end
+
+      it 'increases the ref count of object pointer elements' do
+        obj = GIMarshallingTests::Object.new 42
+        arr = GirFFI::SizedArray.copy_from([:pointer, GIMarshallingTests::Object],
+                                           -1,
+                                           [obj, nil])
+        arr.must_be_instance_of GirFFI::SizedArray
+        arr.to_ptr.wont_be :autorelease?
+
+        arr.to_a.must_equal [obj, nil]
+        obj.ref_count.must_equal 2
+      end
+    end
+
+    describe 'from a GirFFI::SizedArray' do
+      it 'return an unowned copy of its argument' do
+        arr = GirFFI::SizedArray.from :gint32, 3, [3, 2, 1]
+        arr2 = GirFFI::SizedArray.copy_from :gint32, 3, arr
+        arr.to_ptr.wont_equal arr2.to_ptr
+        arr2.to_a.must_equal [3, 2, 1]
+        arr2.to_ptr.wont_be :autorelease?
+      end
+    end
+
+    it 'returns nil when passed nil' do
+      arr = GirFFI::SizedArray.copy_from :gint32, 0, nil
+      arr.must_be_nil
+    end
+
+    it 'creates an unowned copy of its argument if given a pointer' do
+      arr = GirFFI::SizedArray.from :gint32, 3, [3, 2, 1]
+      arr2 = GirFFI::SizedArray.copy_from :gint32, 3, arr.to_ptr
+      assert_instance_of GirFFI::SizedArray, arr2
+      arr2.to_ptr.wont_equal arr.to_ptr
+      arr2.to_ptr.wont_be :autorelease?
+      arr2.to_a.must_equal [3, 2, 1]
+    end
+  end
+
   describe '#==' do
     it 'returns true when comparing to an array with the same elements' do
       sized = GirFFI::SizedArray.from :int32, 3, [1, 2, 3]

data/test/gir_ffi/struct_base_test.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+require 'gir_ffi_test_helper'
+
+GirFFI.setup :GIMarshallingTests
+
+describe GirFFI::StructBase do
+  describe 'wrap_copy' do
+    it 'returns a wrapped copy with autorelease true' do
+      original = GIMarshallingTests::SimpleStruct.new
+      copy = GIMarshallingTests::SimpleStruct.wrap_copy(original.to_ptr)
+      copy.to_ptr.wont_equal original.to_ptr
+      copy.to_ptr.must_be :autorelease?
+    end
+  end
+
+  describe 'copy_from' do
+    it 'returns a copy with autorelease false' do
+      original = GIMarshallingTests::SimpleStruct.new
+      copy = GIMarshallingTests::SimpleStruct.copy_from(original)
+      copy.to_ptr.wont_equal original.to_ptr
+      copy.to_ptr.wont_be :autorelease?
+    end
+  end
+end

data/test/gir_ffi/union_base_test.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+require 'gir_ffi_test_helper'
+
+GirFFI.setup :GIMarshallingTests
+
+describe GirFFI::UnionBase do
+  describe 'wrap_copy' do
+    it 'returns a wrapped copy with autorelease true' do
+      original = GIMarshallingTests::Union.new
+      copy = GIMarshallingTests::Union.wrap_copy(original.to_ptr)
+      copy.to_ptr.wont_equal original.to_ptr
+      copy.to_ptr.must_be :autorelease?
+    end
+  end
+
+  describe 'copy_from' do
+    it 'returns a copy with autorelease false' do
+      original = GIMarshallingTests::Union.new
+      copy = GIMarshallingTests::Union.copy_from(original)
+      copy.to_ptr.wont_equal original.to_ptr
+      copy.to_ptr.wont_be :autorelease?
+    end
+  end
+end

data/test/gir_ffi/version_test.rb

@@ -3,6 +3,6 @@ require 'gir_ffi_test_helper'
 
 describe GirFFI::VERSION do
   it 'is set to a valid version number' do
-    GirFFI::VERSION.must_match(/\d\.\d\.\d/)
+    GirFFI::VERSION.must_match(/\d+\.\d+\.\d+/)
   end
 end

data/test/integration/generated_gimarshallingtests_test.rb

@@ -45,6 +45,7 @@ describe GIMarshallingTests do
     it 'creates an instance using #new' do
       bx = GIMarshallingTests::BoxedStruct.new
       assert_instance_of GIMarshallingTests::BoxedStruct, bx
+      bx.to_ptr.must_be :autorelease?
     end
 
     it 'has a working method #inv' do
@@ -56,22 +57,27 @@ describe GIMarshallingTests do
     it 'has a working function #inout' do
       bx = GIMarshallingTests::BoxedStruct.new
       bx.long_ = 42
+      bx.to_ptr.must_be :autorelease?
 
-      res = GIMarshallingTests::BoxedStruct.inout bx
+      # FIXME: Temporary check method
+      bx.to_ptr.autorelease = true
 
-      # TODO: Deal with the fact that bx is now invalid (at least with
-      # gobject-introspection 1.40).
+      res = GIMarshallingTests::BoxedStruct.inout bx
+      bx.to_ptr.must_be :autorelease?
+      res.to_ptr.must_be :autorelease?
 
       assert_equal 0, res.long_
     end
 
     it 'has a working function #out' do
       res = GIMarshallingTests::BoxedStruct.out
+      res.to_ptr.must_be :autorelease?
       assert_equal 42, res.long_
     end
 
     it 'has a working function #returnv' do
       res = GIMarshallingTests::BoxedStruct.returnv
+      res.to_ptr.must_be :autorelease?
       assert_equal 42, res.long_
       res.g_strv.must_be :==, %w(0 1 2)
     end
@@ -275,8 +281,9 @@ describe GIMarshallingTests do
     it 'has a writable field pointer' do
       instance.pointer.must_be_nil
       nested = GIMarshallingTests::NestedStruct.new
+      nested.simple_struct.int8 = 23
       instance.pointer = nested
-      instance.pointer.must_equal nested
+      instance.pointer.simple_struct.int8.must_equal 23
     end
   end
 
@@ -302,7 +309,7 @@ describe GIMarshallingTests do
 
       res = GIMarshallingTests::Object.full_inout ob
 
-      ob.ref_count.must_be :>, 0
+      ob.ref_count.must_equal 1
       res.ref_count.must_equal 1
 
       res.must_be_instance_of GIMarshallingTests::Object
@@ -311,12 +318,14 @@ describe GIMarshallingTests do
 
     it 'has a working function #full_out' do
       res = GIMarshallingTests::Object.full_out
-      assert_instance_of GIMarshallingTests::Object, res
+      res.must_be_instance_of GIMarshallingTests::Object
+      res.ref_count.must_equal 1
     end
 
     it 'has a working function #full_return' do
       res = GIMarshallingTests::Object.full_return
-      assert_instance_of GIMarshallingTests::Object, res
+      res.must_be_instance_of GIMarshallingTests::Object
+      res.ref_count.must_equal 1
     end
 
     it 'has a working function #inout_same' do
@@ -325,19 +334,28 @@ describe GIMarshallingTests do
 
     it 'has a working function #none_inout' do
       ob = GIMarshallingTests::Object.new 42
+      ob.ref_count.must_equal 1
+
       res = GIMarshallingTests::Object.none_inout ob
-      assert_instance_of GIMarshallingTests::Object, res
-      ob.wont_equal res
+
+      ob.ref_count.must_equal 1
+      res.ref_count.must_equal 2
+
+      res.must_be_instance_of GIMarshallingTests::Object
+      ob.int.must_equal 42
+      res.int.must_equal 0
     end
 
     it 'has a working function #none_out' do
       res = GIMarshallingTests::Object.none_out
-      assert_instance_of GIMarshallingTests::Object, res
+      res.must_be_instance_of GIMarshallingTests::Object
+      res.ref_count.must_equal 2
     end
 
     it 'has a working function #none_return' do
       res = GIMarshallingTests::Object.none_return
-      assert_instance_of GIMarshallingTests::Object, res
+      res.must_be_instance_of GIMarshallingTests::Object
+      res.ref_count.must_equal 2
     end
 
     it 'has a working function #static_method' do
@@ -1454,12 +1472,14 @@ describe GIMarshallingTests do
     GIMarshallingTests.array_struct_in arr
   end
 
-  # NOTE: Should be run with valgrind. See gimarhallingtests.c.
   it 'has a working function #array_struct_take_in' do
     arr = [1, 2, 3].map do |val|
       GIMarshallingTests::BoxedStruct.new.tap { |struct| struct.long_ = val }
     end
+    # NOTE: This copies values so arr's elements stay valid
     GIMarshallingTests.array_struct_take_in arr
+
+    arr.map(&:long_).must_equal [1, 2, 3]
   end
 
   it 'has a working function #array_struct_value_in' do

data/test/integration/generated_regress_test.rb

@@ -479,6 +479,7 @@ describe Regress do
       rect = Regress::FooBRect.wrap(Regress::FooBRect::Struct.new.to_ptr)
       rect.x = 42
       rect.y = 23
+      skip 'Cannot copy FooBRect structs'
       instance.rect = rect
       instance.rect.x.must_equal 42.0
       instance.rect.y.must_equal 23.0
@@ -894,11 +895,9 @@ describe Regress do
   describe 'Regress::FooStruct' do
     let(:instance) { Regress::FooStruct.new }
 
-    it 'has a writable field priv' do
-      instance.priv.must_be_nil
-      struct = Regress::FooStructPrivate.new
-      instance.priv = struct
-      instance.priv.must_equal struct
+    it 'blocks access to the field priv' do
+      proc { instance.priv = nil }.must_raise NoMethodError
+      proc { instance.priv }.must_raise NoMethodError
     end
 
     it 'has a writable field member' do
@@ -1168,12 +1167,9 @@ describe Regress do
       instance.nested_a.some_int.must_equal 12_345
     end
 
-    it 'has a writable field priv' do
-      instance.priv.wont_be_nil
-      other = Regress::TestBoxed.new
-      instance.priv.wont_equal other.priv
-      instance.priv = other.priv
-      instance.priv.must_equal other.priv
+    it 'blocks access to the field priv' do
+      proc { instance.priv = nil }.must_raise NoMethodError
+      proc { instance.priv }.must_raise NoMethodError
     end
 
     it 'creates an instance using #new' do
@@ -1297,6 +1293,7 @@ describe Regress do
     end
 
     it 'has a working method #free' do
+      skip "#free is used internally and shouldn't be exposed"
       instance.free
       pass
     end
@@ -2567,7 +2564,7 @@ describe Regress do
 
     it 'has a writable field data1' do
       instance.data1.must_be :null?
-      instance.data1 = GirFFI::InOutPointer.from(:gint32, 42)
+      instance.data1 = GirFFI::AllocationHelper.allocate(:int32).tap { |it| it.write_int(42) }
       instance.data1.read_int.must_equal 42
     end