gir_ffi 0.14.1 → 0.15.0

data/test/gir_ffi/ffi_ext/pointer_test.rb

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

data/test/gir_ffi/g_type_test.rb

@@ -1,31 +1,31 @@
 # frozen_string_literal: true
 
-require 'gir_ffi_test_helper'
+require "gir_ffi_test_helper"
 
-require 'gir_ffi/g_type'
+require "gir_ffi/g_type"
 
 describe GirFFI::GType do
   let(:gobject_gtype) { GObject::Object.gtype }
   let(:gobject_type_query) { GObject.type_query gobject_gtype }
 
-  describe '#to_i' do
-    it 'returns the integer gtype' do
+  describe "#to_i" do
+    it "returns the integer gtype" do
       gt = GirFFI::GType.new(gobject_gtype)
-      gt.to_i.must_equal gobject_gtype
+      _(gt.to_i).must_equal gobject_gtype
     end
   end
 
-  describe '#class_size' do
-    it 'returns the class size for object types' do
+  describe "#class_size" do
+    it "returns the class size for object types" do
       gt = GirFFI::GType.new(gobject_gtype)
-      gt.class_size.must_equal gobject_type_query.class_size
+      _(gt.class_size).must_equal gobject_type_query.class_size
     end
   end
 
-  describe '#instance_size' do
-    it 'returns the instance size for object types' do
+  describe "#instance_size" do
+    it "returns the instance size for object types" do
       gt = GirFFI::GType.new(gobject_gtype)
-      gt.instance_size.must_equal gobject_type_query.instance_size
+      _(gt.instance_size).must_equal gobject_type_query.instance_size
     end
   end
 end

data/test/gir_ffi/in_pointer_test.rb

@@ -1,30 +1,30 @@
 # frozen_string_literal: true
 
-require 'gir_ffi_test_helper'
+require "gir_ffi_test_helper"
 
-require 'gir_ffi/in_pointer'
+require "gir_ffi/in_pointer"
 
 describe GirFFI::InPointer do
-  describe '.from_array' do
-    it 'returns nil when passed nil' do
+  describe ".from_array" do
+    it "returns nil when passed nil" do
       result = GirFFI::InPointer.from_array :gint32, nil
       assert_nil result
     end
 
-    it 'handles type tag :GType' do
+    it "handles type tag :GType" do
       GirFFI::InPointer.from_array :GType, [2]
     end
 
-    it 'handles enum types' do
+    it "handles enum types" do
       e = Module.new do
         extend GirFFI::EnumBase
         self::Enum = FFI::Enum.new [:foo, :bar, :baz], :qux
       end
       ptr = GirFFI::InPointer.from_array e, [:bar, :foo, :baz]
-      ptr.read_array_of_int32(3).must_equal [1, 0, 2]
+      _(ptr.read_array_of_int32(3)).must_equal [1, 0, 2]
     end
 
-    it 'handles struct types' do
+    it "handles struct types" do
       e = Class.new(GirFFI::StructBase) do
         self::Struct = Class.new(GirFFI::Struct) do
           layout :foo, :int32, :bar, :int32
@@ -34,109 +34,109 @@ describe GirFFI::InPointer do
       struct[:foo] = 42
       struct[:bar] = 24
       ptr = GirFFI::InPointer.from_array e, [struct]
-      ptr.wont_be :==, struct.to_ptr
+      _(ptr).wont_be :==, struct.to_ptr
       new_struct = e::Struct.new ptr
-      new_struct[:foo].must_equal 42
-      new_struct[:bar].must_equal 24
+      _(new_struct[:foo]).must_equal 42
+      _(new_struct[:bar]).must_equal 24
     end
 
-    it 'handles typed pointers' do
+    it "handles typed pointers" do
       p1 = GirFFI::InPointer.from :gint32, 42
       p2 = GirFFI::InPointer.from :gint32, 24
 
       ptr = GirFFI::InPointer.from_array [:pointer, :gint32], [p1, p2]
 
-      ptr.read_array_of_pointer(2).must_equal [p1, p2]
+      _(ptr.read_array_of_pointer(2)).must_equal [p1, p2]
     end
 
-    it 'handles pointer casting' do
+    it "handles pointer casting" do
       ptr = GirFFI::InPointer.from_array [:pointer, :gint32], [42, 24]
 
-      ptr.read_array_of_pointer(2).map(&:address).must_equal [42, 24]
+      _(ptr.read_array_of_pointer(2).map(&:address)).must_equal [42, 24]
     end
   end
 
-  describe 'an instance created with .from_array :gint32' do
+  describe "an instance created with .from_array :gint32" do
     before do
       @result = GirFFI::InPointer.from_array :gint32, [24, 13]
     end
 
-    it 'holds a pointer to the correct input values' do
+    it "holds a pointer to the correct input values" do
       assert_equal 24, @result.get_int(0)
       assert_equal 13, @result.get_int(4)
     end
 
-    it 'is an instance of FFI::MemoryPointer' do
-      @result.must_be_instance_of FFI::MemoryPointer
+    it "is an instance of FFI::MemoryPointer" do
+      _(@result).must_be_instance_of FFI::MemoryPointer
     end
 
-    it 'is zero-terminated' do
+    it "is zero-terminated" do
       assert_equal 0, @result.get_int(8)
     end
   end
 
-  describe 'an instance created with .from_array :utf8' do
+  describe "an instance created with .from_array :utf8" do
     before do
       @result = GirFFI::InPointer.from_array :utf8, %w(foo bar baz)
     end
 
-    it 'returns an array of pointers to strings' do
+    it "returns an array of pointers to strings" do
       ary = @result.read_array_of_pointer(3)
       assert_equal %w(foo bar baz), ary.map(&:read_string)
     end
   end
 
-  describe 'an instance created with .from_array :filename' do
+  describe "an instance created with .from_array :filename" do
     before do
       @result = GirFFI::InPointer.from_array :filename, %w(foo bar baz)
     end
 
-    it 'returns an array of pointers to strings' do
+    it "returns an array of pointers to strings" do
       ary = @result.read_array_of_pointer(3)
       assert_equal %w(foo bar baz), ary.map(&:read_string)
     end
   end
 
-  describe 'an instance created with .from :utf8' do
+  describe "an instance created with .from :utf8" do
     before do
-      @result = GirFFI::InPointer.from :utf8, 'foo'
+      @result = GirFFI::InPointer.from :utf8, "foo"
     end
 
-    it 'returns a pointer to the given string' do
-      assert_equal 'foo', @result.read_string
+    it "returns a pointer to the given string" do
+      assert_equal "foo", @result.read_string
     end
 
-    it 'is an instance of FFI::MemoryPointer' do
-      @result.must_be_instance_of FFI::MemoryPointer
+    it "is an instance of FFI::MemoryPointer" do
+      _(@result).must_be_instance_of FFI::MemoryPointer
     end
   end
 
-  describe 'an instance created with .from :guint32' do
+  describe "an instance created with .from :guint32" do
     before do
       @result = GirFFI::InPointer.from :guint32, 12_345
     end
 
-    it 'returns a pointer with an address equal to the given value' do
+    it "returns a pointer with an address equal to the given value" do
       assert_equal 12_345, @result.address
     end
 
-    it 'is an instance of FFI::Pointer' do
-      @result.must_be_instance_of FFI::Pointer
+    it "is an instance of FFI::Pointer" do
+      _(@result).must_be_instance_of FFI::Pointer
     end
   end
 
-  describe 'an instance created with .from :filename' do
+  describe "an instance created with .from :filename" do
     before do
-      @result = GirFFI::InPointer.from :filename, 'foo'
+      @result = GirFFI::InPointer.from :filename, "foo"
     end
 
-    it 'returns a pointer to the given string' do
-      assert_equal 'foo', @result.read_string
+    it "returns a pointer to the given string" do
+      assert_equal "foo", @result.read_string
     end
   end
 
-  describe '.from' do
-    it 'returns nil when passed nil' do
+  describe ".from" do
+    it "returns nil when passed nil" do
       result = GirFFI::InPointer.from :foo, nil
       assert_nil result
     end
@@ -146,37 +146,57 @@ describe GirFFI::InPointer do
       assert_equal 23, result.address
     end
 
-    it 'handles enum types' do
+    it "returns a pointer to the value for type :gint64" do
+      result = GirFFI::InPointer.from :gint64, -0x90000000
+      assert_equal(-0x90000000, result.get_int64(0))
+    end
+
+    it "returns a pointer to the value for type :guint64" do
+      result = GirFFI::InPointer.from :guint64, 0xf0000000
+      assert_equal 0xf0000000, result.get_uint64(0)
+    end
+
+    it "returns a pointer to the value for type :gdouble" do
+      result = GirFFI::InPointer.from :gdouble, 0.1
+      assert_in_epsilon 0.1, result.read_double
+    end
+
+    it "returns a pointer to the value for type :gfloat" do
+      result = GirFFI::InPointer.from :gfloat, 0.1
+      assert_in_epsilon 0.1, result.read_float
+    end
+
+    it "handles enum types" do
       e = Module.new do
         extend GirFFI::EnumBase
         self::Enum = FFI::Enum.new [:foo, :bar, :baz], :qux
       end
       ptr = GirFFI::InPointer.from e, :bar
-      ptr.address.must_equal 1
+      _(ptr.address).must_equal 1
     end
 
-    describe 'for type :void' do
-      it 'returns the result of to_ptr' do
+    describe "for type :void" do
+      it "returns the result of to_ptr" do
         obj = Object.new
         def obj.to_ptr
           :test_value
         end
-        GirFFI::InPointer.from(:void, obj).must_equal :test_value
+        _(GirFFI::InPointer.from(:void, obj)).must_equal :test_value
       end
 
-      it 'returns nil when passed nil' do
-        GirFFI::InPointer.from(:void, nil).must_be_nil
+      it "returns nil when passed nil" do
+        _(GirFFI::InPointer.from(:void, nil)).must_be_nil
       end
     end
 
-    describe 'for types that are classes' do
-      it 'returns the result of to_ptr' do
+    describe "for types that are classes" do
+      it "returns the result of to_ptr" do
         klass = Class.new
         obj = klass.new
         def obj.to_ptr
           :test_value
         end
-        GirFFI::InPointer.from(klass, obj).must_equal :test_value
+        _(GirFFI::InPointer.from(klass, obj)).must_equal :test_value
       end
     end
   end

data/test/gir_ffi/info_ext/i_callable_info_test.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-require 'gir_ffi_test_helper'
+require "gir_ffi_test_helper"
 
 describe GirFFI::InfoExt::ICallableInfo do
   let(:info_class) do
@@ -10,16 +10,16 @@ describe GirFFI::InfoExt::ICallableInfo do
   end
   let(:callable_info) { info_class.new }
 
-  describe '#argument_ffi_types' do
-    describe 'for a simple callable with several arguments' do
+  describe "#argument_ffi_types" do
+    describe "for a simple callable with several arguments" do
       before do
         allow(arg_info1 = Object.new).to receive(:to_ffi_type).and_return :type1
         allow(arg_info2 = Object.new).to receive(:to_ffi_type).and_return :type2
         allow(callable_info).to receive(:args).and_return [arg_info1, arg_info2]
       end
 
-      it 'returns the ffi types of the arguments' do
-        callable_info.argument_ffi_types.must_equal [:type1, :type2]
+      it "returns the ffi types of the arguments" do
+        _(callable_info.argument_ffi_types).must_equal [:type1, :type2]
       end
     end
   end

data/test/gir_ffi/info_ext/i_callback_info_test.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-require 'gir_ffi_test_helper'
+require "gir_ffi_test_helper"
 
 describe GirFFI::InfoExt::ICallbackInfo do
   let(:callback_class) do
@@ -10,12 +10,12 @@ describe GirFFI::InfoExt::ICallbackInfo do
   end
   let(:callback_info) { callback_class.new }
 
-  describe '#return_ffi_type' do
-    it 'returns the callback ffi type of the return type' do
+  describe "#return_ffi_type" do
+    it "returns the callback ffi type of the return type" do
       allow(return_type_info = Object.new).to receive(:to_callback_ffi_type).and_return :some_type
       allow(callback_info).to receive(:return_type).and_return return_type_info
 
-      callback_info.return_ffi_type.must_equal :some_type
+      _(callback_info.return_ffi_type).must_equal :some_type
     end
   end
 end

data/test/gir_ffi/info_ext/i_field_info_test.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-require 'gir_ffi_test_helper'
+require "gir_ffi_test_helper"
 
 describe GirFFI::InfoExt::IFieldInfo do
   let(:info_class) do
@@ -9,11 +9,11 @@ describe GirFFI::InfoExt::IFieldInfo do
     end
   end
   let(:field_info) { info_class.new }
-  describe '#layout_specification' do
-    it 'returns an array of name, typespec and offset' do
+  describe "#layout_specification" do
+    it "returns an array of name, typespec and offset" do
       expect(type = Object.new).to receive(:to_ffi_type).and_return :bar
 
-      expect(field_info).to receive(:name).and_return 'foo'
+      expect(field_info).to receive(:name).and_return "foo"
       expect(field_info).to receive(:field_type).and_return type
       expect(field_info).to receive(:offset).and_return 0
 
@@ -22,10 +22,10 @@ describe GirFFI::InfoExt::IFieldInfo do
       assert_equal [:foo, :bar, 0], result
     end
 
-    it 'keeps a complex typespec intact' do
+    it "keeps a complex typespec intact" do
       expect(type = Object.new).to receive(:to_ffi_type).and_return [:bar, 2]
 
-      expect(field_info).to receive(:name).and_return 'foo'
+      expect(field_info).to receive(:name).and_return "foo"
       expect(field_info).to receive(:field_type).and_return type
       expect(field_info).to receive(:offset).and_return 0
 

data/test/gir_ffi/info_ext/i_function_info_test.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-require 'gir_ffi_test_helper'
+require "gir_ffi_test_helper"
 
 describe GirFFI::InfoExt::IFunctionInfo do
   let(:info_class) do
@@ -11,64 +11,64 @@ describe GirFFI::InfoExt::IFunctionInfo do
   end
   let(:function_info) { info_class.new }
 
-  describe '#argument_ffi_types' do
+  describe "#argument_ffi_types" do
     before do
       allow(arg_info1 = Object.new).to receive(:to_ffi_type).and_return :type1
       allow(arg_info2 = Object.new).to receive(:to_ffi_type).and_return :type2
       allow(function_info).to receive(:args).and_return [arg_info1, arg_info2]
     end
 
-    describe 'for a simple function with several arguments' do
+    describe "for a simple function with several arguments" do
       before do
         allow(function_info).to receive(:method?).and_return false
         allow(function_info).to receive(:throws?).and_return false
       end
 
-      it 'returns the ffi types of the arguments' do
-        function_info.argument_ffi_types.must_equal [:type1, :type2]
+      it "returns the ffi types of the arguments" do
+        _(function_info.argument_ffi_types).must_equal [:type1, :type2]
       end
     end
 
-    describe 'for a throwing function with several arguments' do
+    describe "for a throwing function with several arguments" do
       before do
         allow(function_info).to receive(:method?).and_return false
         allow(function_info).to receive(:throws?).and_return true
       end
 
-      it 'appends :pointer to represent the error argument' do
-        function_info.argument_ffi_types.must_equal [:type1, :type2, :pointer]
+      it "appends :pointer to represent the error argument" do
+        _(function_info.argument_ffi_types).must_equal [:type1, :type2, :pointer]
       end
     end
 
-    describe 'for a method with several arguments' do
+    describe "for a method with several arguments" do
       before do
         allow(function_info).to receive(:method?).and_return true
         allow(function_info).to receive(:throws?).and_return false
       end
 
-      it 'prepends :pointer to represent the method reciever' do
-        function_info.argument_ffi_types.must_equal [:pointer, :type1, :type2]
+      it "prepends :pointer to represent the method reciever" do
+        _(function_info.argument_ffi_types).must_equal [:pointer, :type1, :type2]
       end
     end
 
-    describe 'for a throwing method with several arguments' do
+    describe "for a throwing method with several arguments" do
       before do
         allow(function_info).to receive(:method?).and_return true
         allow(function_info).to receive(:throws?).and_return true
       end
 
-      it 'adds :pointer for both the reciever and the error argument' do
-        function_info.argument_ffi_types.must_equal [:pointer, :type1, :type2, :pointer]
+      it "adds :pointer for both the reciever and the error argument" do
+        _(function_info.argument_ffi_types).must_equal [:pointer, :type1, :type2, :pointer]
       end
     end
   end
 
-  describe '#return_ffi_type' do
-    it 'returns the ffi type of the return type' do
+  describe "#return_ffi_type" do
+    it "returns the ffi type of the return type" do
       allow(return_type_info = Object.new).to receive(:to_ffi_type).and_return :some_type
       allow(function_info).to receive(:return_type).and_return return_type_info
 
-      function_info.return_ffi_type.must_equal :some_type
+      _(function_info.return_ffi_type).must_equal :some_type
     end
   end
 end