gir_ffi 0.10.2 → 0.11.0

data/test/gir_ffi/boolean_test.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+require 'gir_ffi_test_helper'
+
+describe GirFFI::Boolean do
+  it 'has the same native size as an int' do
+    FFI.type_size(GirFFI::Boolean).must_equal FFI.type_size :int
+  end
+
+  describe '.from_native' do
+    it 'converts 0 to false' do
+      GirFFI::Boolean.from_native(0, 'whatever').must_equal false
+    end
+
+    it 'converts 1 to true' do
+      GirFFI::Boolean.from_native(1, 'whatever').must_equal true
+    end
+  end
+
+  describe '.to_native' do
+    it 'converts false to 0' do
+      GirFFI::Boolean.to_native(false, 'whatever').must_equal 0
+    end
+
+    it 'converts true to 1' do
+      GirFFI::Boolean.to_native(true, 'whatever').must_equal 1
+    end
+  end
+
+  describe '.size' do
+    it 'returns the correct type size' do
+      GirFFI::Boolean.size.must_equal FFI.type_size :int
+    end
+  end
+end

data/test/gir_ffi/boxed_base_test.rb

@@ -4,12 +4,12 @@ require 'gir_ffi_test_helper'
 GirFFI.setup :GIMarshallingTests
 
 describe GirFFI::BoxedBase do
-  describe 'wrap_copy' do
-    it 'returns a wrapped copy with owned true' do
-      original = GIMarshallingTests::BoxedStruct.new
-      copy = GIMarshallingTests::BoxedStruct.wrap_copy(original.to_ptr)
-      copy.to_ptr.wont_equal original.to_ptr
-      copy.struct.must_be :owned?
+  describe 'initialize' do
+    it 'sets up the held struct pointer' do
+      # NOTE: GObject::Value uses the generic constructor, unlike
+      # GIMarshallingTests::BoxedStruct, which has its own constructor.
+      value = GObject::Value.new
+      value.to_ptr.wont_be_nil
     end
   end
 
@@ -18,7 +18,47 @@ describe GirFFI::BoxedBase do
       original = GIMarshallingTests::BoxedStruct.new
       copy = GIMarshallingTests::BoxedStruct.copy_from(original)
       copy.to_ptr.wont_equal original.to_ptr
+      copy.to_ptr.wont_be :autorelease?
       copy.struct.wont_be :owned?
     end
   end
+
+  describe 'wrap_own' do
+    it 'wraps and owns the supplied pointer' do
+      original = GIMarshallingTests::BoxedStruct.new
+      copy = GIMarshallingTests::BoxedStruct.wrap_own(original.to_ptr)
+      copy.to_ptr.must_equal original.to_ptr
+      copy.to_ptr.wont_be :autorelease?
+      copy.struct.must_be :owned?
+    end
+  end
+
+  describe 'upon garbage collection' do
+    it 'frees and disowns the underlying struct if it is owned' do
+      if jruby? || rubinius?
+        skip 'cannot be reliably tested on JRuby and Rubinius'
+      end
+
+      allow(GObject).to receive(:boxed_free)
+      gtype = GIMarshallingTests::BoxedStruct.gtype
+
+      owned_struct = GIMarshallingTests::BoxedStruct.new.struct
+      owned_ptr = owned_struct.to_ptr
+
+      unowned_struct = GIMarshallingTests::BoxedStruct.new.struct
+      unowned_struct.owned = false
+      unowned_ptr = unowned_struct.to_ptr
+
+      GC.start
+      # Creating a new object is sometimes needed to trigger enough garbage collection.
+      GIMarshallingTests::BoxedStruct.new
+      sleep 1
+      GC.start
+      GC.start
+
+      expect(GObject).to have_received(:boxed_free).with(gtype, owned_ptr)
+      expect(GObject).not_to have_received(:boxed_free).with(gtype, unowned_ptr)
+      owned_struct.wont_be :owned?
+    end
+  end
 end

data/test/gir_ffi/builder_test.rb

@@ -2,6 +2,7 @@
 require 'gir_ffi_test_helper'
 
 GirFFI.setup :Regress
+GirFFI.setup :GIMarshallingTests
 
 describe GirFFI::Builder do
   let(:gir) { GObjectIntrospection::IRepository.default }
@@ -14,8 +15,84 @@ describe GirFFI::Builder do
     end
   end
 
+  describe '.build_module' do
+    it 'refuses to build existing modules defined elsewhere' do
+      result = -> { GirFFI::Builder.build_module('Array') }.must_raise
+      result.message.must_equal 'The module Array was already defined elsewhere'
+    end
+
+    describe 'building a module for the first time' do
+      before do
+        save_module :Regress
+        GirFFI::Builder.build_module 'Regress'
+      end
+
+      it 'creates a Lib module ready to attach functions from the shared library' do
+        gir = GObjectIntrospection::IRepository.default
+        expected = [gir.shared_library('Regress')]
+        assert_equal expected, Regress::Lib.ffi_libraries.map(&:name)
+      end
+
+      after do
+        restore_module :Regress
+      end
+    end
+
+    describe 'building a module that already exists' do
+      it 'does not replace the existing module' do
+        oldmodule = Regress
+        GirFFI::Builder.build_module 'Regress'
+        assert_equal oldmodule, Regress
+      end
+
+      it 'does not replace the existing Lib module' do
+        oldmodule = Regress::Lib
+        GirFFI::Builder.build_module 'Regress'
+        assert_equal oldmodule, Regress::Lib
+      end
+    end
+
+    it 'passes the version on to ModuleBuilder' do
+      builder = double(generate: nil)
+      expect(GirFFI::Builders::ModuleBuilder).to receive(:new).
+        with('Foo', namespace: 'Foo', version: '1.0').
+        and_return builder
+
+      GirFFI::Builder.build_module 'Foo', '1.0'
+    end
+  end
+
+  describe '.build_by_gtype' do
+    it 'returns the class types known to the GIR' do
+      result = GirFFI::Builder.build_by_gtype GObject::Object.gtype
+      result.must_equal GObject::Object
+    end
+
+    it 'returns the class for user-defined types' do
+      klass = Class.new GIMarshallingTests::OverridesObject
+      Object.const_set "Derived#{Sequence.next}", klass
+      gtype = GirFFI.define_type klass
+
+      found_klass = GirFFI::Builder.build_by_gtype gtype
+      found_klass.must_equal klass
+    end
+
+    it 'returns a valid class for boxed classes unknown to GIR' do
+      object_class = GIMarshallingTests::PropertiesObject.object_class
+      property = object_class.find_property 'some-boxed-glist'
+      gtype = property.value_type
+
+      gtype.wont_equal GObject::TYPE_NONE
+
+      found_klass = GirFFI::Builder.build_by_gtype gtype
+      found_klass.name.must_be_nil
+      found_klass.ancestors.must_include GirFFI::BoxedBase
+    end
+  end
+
   describe '.attach_ffi_function' do
     let(:lib) { Module.new }
+
     it 'calls attach_function with the correct types for Regress.test_callback_destroy_notify' do
       function_info = get_introspection_data 'Regress', 'test_callback_destroy_notify'
 
@@ -57,8 +134,19 @@ describe GirFFI::Builder do
         and_return true
       GirFFI::Builder.attach_ffi_function(lib, info)
     end
+
+    it 'does not attach the function if it is already defined' do
+      info = get_introspection_data 'Regress', 'test_array_gint32_in'
+      allow(lib).to receive(:method_defined?).and_return true
+      expect(lib).not_to receive(:attach_function)
+      GirFFI::Builder.attach_ffi_function(lib, info)
+    end
   end
 
+  #
+  # NOTE: Legacy tests below.
+  #
+
   describe 'looking at Regress.test_callback_destroy_notify' do
     before do
       save_module :GObject
@@ -202,33 +290,4 @@ describe GirFFI::Builder do
       restore_module :Regress
     end
   end
-
-  describe 'building Regress' do
-    before do
-      save_module :Regress
-      GirFFI::Builder.build_module 'Regress'
-    end
-
-    it 'creates a Lib module ready to attach functions from the shared library' do
-      gir = GObjectIntrospection::IRepository.default
-      expected = [gir.shared_library('Regress')]
-      assert_equal expected, Regress::Lib.ffi_libraries.map(&:name)
-    end
-
-    it 'does not replace existing module' do
-      oldmodule = Regress
-      GirFFI::Builder.build_module 'Regress'
-      assert_equal oldmodule, Regress
-    end
-
-    it 'does not replace existing Lib module' do
-      oldmodule = Regress::Lib
-      GirFFI::Builder.build_module 'Regress'
-      assert_equal oldmodule, Regress::Lib
-    end
-
-    after do
-      restore_module :Regress
-    end
-  end
 end

data/test/gir_ffi/builders/argument_builder_test.rb

@@ -378,6 +378,25 @@ describe GirFFI::Builders::ArgumentBuilder do
         end
       end
     end
+
+    describe 'for :void' do
+      let(:function_info) do
+        get_introspection_data('Everything', 'one_outparam_gpointer')
+      end
+      let(:arg_info) { function_info.args[0] }
+
+      before do
+        skip unless function_info
+      end
+
+      it 'has the correct value for #pre_conversion' do
+        builder.pre_conversion.must_equal ['_v1 = FFI::MemoryPointer.new :pointer']
+      end
+
+      it 'has the correct value for #post_conversion' do
+        builder.post_conversion.must_equal ['_v2 = _v1.get_pointer(0)']
+      end
+    end
   end
 
   describe 'for an argument with direction :inout' do

data/test/gir_ffi/builders/callback_argument_builder_test.rb

@@ -23,6 +23,23 @@ describe GirFFI::Builders::CallbackArgumentBuilder do
         builder.post_conversion.must_equal ['_v1.put_pointer 0, GirFFI::ZeroTerminated.from(:gfloat, _v2)']
       end
     end
+
+    describe 'when the argument is allocated by us, the callee' do
+      let(:vfunc_info) do
+        get_vfunc_introspection_data('GIMarshallingTests', 'Object',
+                                     'method_int8_arg_and_out_callee')
+      end
+
+      let(:arg_info) { vfunc_info.args[1] }
+
+      it 'has the correct value for #pre_conversion' do
+        builder.pre_conversion.must_equal ['_v1 = FFI::MemoryPointer.new(:int8).tap { |ptr| out.put_pointer 0, ptr }']
+      end
+
+      it 'has the correct value for #post_conversion' do
+        builder.post_conversion.must_equal ['_v1.put_int8 0, _v2']
+      end
+    end
   end
 
   describe 'for an argument with direction :error' do

data/test/gir_ffi/builders/callback_return_value_builder_test.rb

@@ -73,7 +73,7 @@ describe GirFFI::Builders::CallbackReturnValueBuilder do
     it 'increases the refcount of the result and converts it to a pointer' do
       # Ensure variable names are generated in order
       builder.capture_variable_name.must_equal '_v1'
-      builder.post_conversion.must_equal ['_v2 = GObject::Object.from(_v1.ref).to_ptr']
+      builder.post_conversion.must_equal ['_v1.ref', '_v2 = GObject::Object.from(_v1).to_ptr']
     end
 
     it 'returns the result of the conversion' do

data/test/gir_ffi/builders/field_builder_test.rb

@@ -2,7 +2,8 @@
 require 'gir_ffi_test_helper'
 
 describe GirFFI::Builders::FieldBuilder do
-  let(:instance) { GirFFI::Builders::FieldBuilder.new field_info }
+  let(:klass) { 'dummy' }
+  let(:instance) { GirFFI::Builders::FieldBuilder.new field_info, klass }
 
   describe 'for a field of type :gint8 with an offset' do
     let(:field_info) { get_field_introspection_data 'Regress', 'TestSimpleBoxedA', 'some_int8' }

data/test/gir_ffi/builders/struct_builder_test.rb

@@ -11,39 +11,39 @@ describe GirFFI::Builders::StructBuilder do
                                                :some_double, :double, 8,
                                                :some_enum, Regress::TestEnum, 16]
     end
-  end
 
-  describe 'for a struct with a simple layout' do
-    before do
-      @field = Object.new
+    describe 'for a struct with a simple layout' do
+      before do
+        @field = Object.new
 
-      @struct = Object.new
-      allow(@struct).to receive(:namespace).and_return 'Foo'
-      allow(@struct).to receive(:safe_name).and_return 'Bar'
-      allow(@struct).to receive(:fields).and_return [@field]
+        @struct = Object.new
+        allow(@struct).to receive(:namespace).and_return 'Foo'
+        allow(@struct).to receive(:safe_name).and_return 'Bar'
+        allow(@struct).to receive(:fields).and_return [@field]
 
-      @builder = GirFFI::Builders::StructBuilder.new @struct
-    end
+        @builder = GirFFI::Builders::StructBuilder.new @struct
+      end
 
-    it 'creates the correct layout specification' do
-      expect(@field).to receive(:layout_specification).and_return [:bar, :int32, 0]
-      spec = @builder.send :layout_specification
-      assert_equal [:bar, :int32, 0], spec
+      it 'creates the correct layout specification' do
+        expect(@field).to receive(:layout_specification).and_return [:bar, :int32, 0]
+        spec = @builder.layout_specification
+        assert_equal [:bar, :int32, 0], spec
+      end
     end
-  end
 
-  describe 'for a struct with a layout with a complex type' do
-    it 'does not flatten the complex type specification' do
-      expect(simplefield = Object.new).to receive(:layout_specification).and_return [:bar, :foo, 0]
-      expect(complexfield = Object.new).to receive(:layout_specification).and_return [:baz, [:qux, 2], 0]
-      expect(struct = Object.new).to receive(:fields).and_return [simplefield, complexfield]
+    describe 'for a struct with a layout with a complex type' do
+      it 'does not flatten the complex type specification' do
+        expect(simplefield = Object.new).to receive(:layout_specification).and_return [:bar, :foo, 0]
+        expect(complexfield = Object.new).to receive(:layout_specification).and_return [:baz, [:qux, 2], 0]
+        expect(struct = Object.new).to receive(:fields).and_return [simplefield, complexfield]
 
-      allow(struct).to receive(:safe_name).and_return 'Bar'
-      allow(struct).to receive(:namespace).and_return 'Foo'
+        allow(struct).to receive(:safe_name).and_return 'Bar'
+        allow(struct).to receive(:namespace).and_return 'Foo'
 
-      builder = GirFFI::Builders::StructBuilder.new struct
-      spec = builder.send :layout_specification
-      assert_equal [:bar, :foo, 0, :baz, [:qux, 2], 0], spec
+        builder = GirFFI::Builders::StructBuilder.new struct
+        spec = builder.layout_specification
+        assert_equal [:bar, :foo, 0, :baz, [:qux, 2], 0], spec
+      end
     end
   end
 
@@ -72,4 +72,21 @@ describe GirFFI::Builders::StructBuilder do
       builder.superclass.must_equal GObject::ObjectClass
     end
   end
+
+  describe '#setup_class' do
+    before do
+      save_module :Regress
+    end
+
+    it 'stubs the structs methods' do
+      info = get_introspection_data 'Regress', 'TestStructA'
+      builder = GirFFI::Builders::StructBuilder.new info
+      builder.setup_class
+      assert_defines_instance_method Regress::TestStructA, :clone
+    end
+
+    after do
+      restore_module :Regress
+    end
+  end
 end