ffi 1.9.21-x64-mingw32 → 1.9.22-x64-mingw32

data/spec/ffi/typedef_spec.rb

@@ -1,91 +0,0 @@
-#
-# This file is part of ruby-ffi.
-# For licensing, see LICENSE.SPECS
-#
-
-require File.expand_path(File.join(File.dirname(__FILE__), "spec_helper"))
-describe "Custom type definitions" do
-  it "attach_function with custom typedef" do
-    module CustomTypedef
-      extend FFI::Library
-      ffi_lib TestLibrary::PATH
-      typedef :uint, :fubar_t
-      attach_function :ret_u32, [ :fubar_t ], :fubar_t
-    end
-    expect(CustomTypedef.ret_u32(0x12345678)).to eq(0x12345678)
-  end
-
-  it "variadic invoker with custom typedef" do
-    module VariadicCustomTypedef
-      extend FFI::Library
-      ffi_lib TestLibrary::PATH
-      typedef :uint, :fubar_t
-      attach_function :pack_varargs, [ :buffer_out, :string, :varargs ], :void
-    end
-    buf = FFI::Buffer.new :uint, 10
-    VariadicCustomTypedef.pack_varargs(buf, "i", :fubar_t, 0x12345678)
-    expect(buf.get_int64(0)).to eq(0x12345678)
-  end
-
-  it "Callback with custom typedef parameter" do
-    module CallbackCustomTypedef
-      extend FFI::Library
-      ffi_lib TestLibrary::PATH
-      typedef :uint, :fubar3_t
-      callback :cbIrV, [ :fubar3_t ], :void
-      attach_function :testCallbackU32rV, :testClosureIrV, [ :cbIrV, :fubar3_t ], :void
-    end
-    i = 0
-    CallbackCustomTypedef.testCallbackU32rV(0xdeadbeef) { |v| i = v }
-    expect(i).to eq(0xdeadbeef)
-  end
-    module StructCustomTypedef
-      extend FFI::Library
-      ffi_lib TestLibrary::PATH
-      typedef :uint, :fubar3_t
-      class S < FFI::Struct
-        layout :a, :fubar3_t
-      end
-    end
-
-  it "Struct with custom typedef field" do
-    s = StructCustomTypedef::S.new
-    s[:a] = 0x12345678
-    expect(s.pointer.get_uint(0)).to eq(0x12345678)
-  end
-
-  it "attach_function after a typedef should not reject normal types" do
-    expect do
-      Module.new do
-        extend FFI::Library
-        # enum() will insert a custom typedef called :foo for the enum
-        enum :foo, [ :a, :b ]
-        typedef :int, :bar
-        
-        ffi_lib TestLibrary::PATH
-        begin
-          attach_function :ptr_ret_int32_t, [ :string, :foo ], :bar
-        rescue FFI::NotFoundError
-          # NetBSD uses #define instead of typedef for these
-          attach_function :ptr_ret_int32_t, :ptr_ret___int32_t, [ :string, :foo ], :bar
-        end
-      end
-    end.not_to raise_error
-  end
-
-  it "detects the correct type for size_t" do
-    expect do
-      Module.new do
-        extend FFI::Library
-        ffi_lib "c"
-        if FFI::Platform.windows?
-          # _read() is a function of msvcrt.dll
-          attach_function :_read, [:int, :pointer, :uint], :int
-        else
-          # read(2) is a standard UNIX function
-          attach_function :read, [:int, :pointer, :size_t], :ssize_t
-        end
-      end
-    end.not_to raise_error
-  end
-end

data/spec/ffi/union_spec.rb

@@ -1,67 +0,0 @@
-#
-# This file is part of ruby-ffi.
-# For licensing, see LICENSE.SPECS
-#
-
-require File.expand_path(File.join(File.dirname(__FILE__), "spec_helper"))
-
-module LibTest
-  Types = {
-    's8' => [:char, :c, 1],
-    's16' => [:short, :s, 0xff0], 
-    's32' => [:int, :i, 0xff00],
-    's64' => [:long_long, :j, 0xffff00],
-    'long' => [:long, :l, 0xffff],
-    'f32' => [:float, :f, 1.0001],
-    'f64' => [:double, :d, 1.000000001]
-  }
-  class TestUnion < FFI::Union
-    layout( :a, [:char, 10], 
-            :i, :int, 
-            :f, :float,
-            :d, :double,
-            :s, :short,
-            :l, :long,
-            :j, :long_long,
-            :c, :char )
-  end
-  Types.keys.each do |k| 
-    attach_function "union_align_#{k}", [ :pointer ], Types[k][0]
-    attach_function "union_make_union_with_#{k}", [ Types[k][0] ], :pointer
-  end
-  attach_function :union_size, [], :uint
-end
-
-describe 'Union' do
-  before do
-    @u = LibTest::TestUnion.new
-  end
-
-  it 'should place all the fields at offset 0' do
-    expect(LibTest::TestUnion.members.all? { |m| LibTest::TestUnion.offset_of(m) == 0 }).to be true
-  end
-  LibTest::Types.each do |k, type|
-    it "should correctly align/write a #{type[0]} value" do
-      @u[type[1]] = type[2]
-      if k == 'f32' or k == 'f64'
-        expect((@u[type[1]] - LibTest.send("union_align_#{k}", @u.to_ptr)).abs).to be < 0.00001
-      else
-        expect(@u[type[1]]).to eq(LibTest.send("union_align_#{k}", @u.to_ptr))
-      end
-    end
-  end
-  LibTest::Types.each do |k, type|
-    it "should read a #{type[0]} value from memory" do
-      @u = LibTest::TestUnion.new(LibTest.send("union_make_union_with_#{k}", type[2]))
-      if k == 'f32' or k == 'f64'
-        expect((@u[type[1]] - type[2]).abs).to be < 0.00001
-      else
-        expect(@u[type[1]]).to eq(type[2])
-      end
-    end
-  end
-
-  it 'should return a size equals to the size of the biggest field' do
-    expect(LibTest::TestUnion.size).to eq(LibTest.union_size)
-  end
-end

data/spec/ffi/variadic_spec.rb

@@ -1,132 +0,0 @@
-#
-# This file is part of ruby-ffi.
-# For licensing, see LICENSE.SPECS
-#
-
-require File.expand_path(File.join(File.dirname(__FILE__), "spec_helper"))
-
-describe "Function with variadic arguments" do
-  module LibTest
-    extend FFI::Library
-    ffi_lib TestLibrary::PATH
-    enum :enum_type1, [:c1, :c2]
-    enum :enum_type2, [:c3, 42, :c4]
-    attach_function :pack_varargs, [ :buffer_out, :string, :varargs ], :void
-    attach_function :pack_varargs2, [ :buffer_out, :enum_type1, :string, :varargs ], :enum_type1
-
-    attach_function :testBlockingOpen, [ ], :pointer
-    attach_function :testBlockingRWva, [ :pointer, :char, :varargs ], :char, :blocking => true
-    attach_function :testBlockingWRva, [ :pointer, :char, :varargs ], :char, :blocking => true
-    attach_function :testBlockingClose, [ :pointer ], :void
-  end
-
-  it "takes enum arguments" do
-    buf = FFI::Buffer.new :long_long, 2
-    LibTest.pack_varargs(buf, "ii", :int, :c3, :int, :c4)
-    expect(buf.get_int64(0)).to eq(42)
-    expect(buf.get_int64(8)).to eq(43)
-  end
-
-  it "returns symbols for enums" do
-    buf = FFI::Buffer.new :long_long, 2
-    expect(LibTest.pack_varargs2(buf, :c1, "ii", :int, :c3, :int, :c4)).to eq(:c2)
-  end
-
-  it 'can wrap a blocking function with varargs' do
-    pending("not supported in 1.8") if RUBY_VERSION =~ /^1\.8\..*/
-    handle = LibTest.testBlockingOpen
-    expect(handle).not_to be_null
-    begin
-      thWR = Thread.new { LibTest.testBlockingWRva(handle, 63, :int, 40, :int, 23, :int, 0) }
-      thRW = Thread.new { LibTest.testBlockingRWva(handle, 64, :int, 40, :int, 24, :int, 0) }
-      expect(thWR.value).to eq(64)
-      expect(thRW.value).to eq(63)
-    ensure
-      LibTest.testBlockingClose(handle)
-    end
-  end
-
-  [ 0, 127, -128, -1 ].each do |i|
-    it "call variadic with (:char (#{i})) argument" do
-      buf = FFI::Buffer.new :long_long
-      LibTest.pack_varargs(buf, "c", :char, i)
-      expect(buf.get_int64(0)).to eq(i)
-    end
-  end
-
-  [ 0, 0x7f, 0x80, 0xff ].each do |i|
-    it "call variadic with (:uchar (#{i})) argument" do
-      buf = FFI::Buffer.new :long_long
-      LibTest.pack_varargs(buf, "C", :uchar, i)
-      expect(buf.get_int64(0)).to eq(i)
-    end
-  end
-
-  [ 0, 1.234567, 9.87654321 ].each do |v|
-    it "call variadic with (:float (#{v})) argument" do
-      buf = FFI::Buffer.new :long_long
-      LibTest.pack_varargs(buf, "f", :float, v.to_f)
-      expect(buf.get_float64(0)).to eq(v)
-    end
-  end
-
-  [ 0, 1.234567, 9.87654321 ].each do |v|
-    it "call variadic with (:double (#{v})) argument" do
-      buf = FFI::Buffer.new :long_long
-      LibTest.pack_varargs(buf, "f", :double, v.to_f)
-      expect(buf.get_float64(0)).to eq(v)
-    end
-  end
-
-  module Varargs
-    PACK_VALUES = {
-      'c' => [ 0x12  ],
-      'C' => [ 0x34  ],
-      's' => [ 0x5678 ],
-      'S' => [ 0x9abc ],
-      'i' => [ 0x7654321f ],
-      'I' => [ 0xfee1babe ],
-      'l' => [ 0x1f2e3d4c ],
-      'L' => [ 0xf7e8d9ca ],
-      'j' => [ 0x1eafdeadbeefa1b2 ],
-      'f' => [ 1.23456789 ],
-      'd' => [ 9.87654321 ]
-    }
-
-    TYPE_MAP = {
-      'c' => :char, 'C' => :uchar, 's' => :short, 'S' => :ushort,
-      'i' => :int, 'I' => :uint, 'j' => :long_long, 'J' => :ulong_long,
-      'l' => :long, 'L' => :ulong, 'f' => :float, 'd' => :double
-    }
-  end
-
-  def verify(p, off, v)
-    if v.kind_of?(Float)
-      expect(p.get_float64(off)).to eq(v)
-    else
-      expect(p.get_int64(off)).to eq(v)
-    end
-  end
-
-  Varargs::PACK_VALUES.keys.each do |t1|
-    Varargs::PACK_VALUES.keys.each do |t2|
-      Varargs::PACK_VALUES.keys.each do |t3|
-        Varargs::PACK_VALUES[t1].each do |v1|
-          Varargs::PACK_VALUES[t2].each do |v2|
-            Varargs::PACK_VALUES[t3].each do |v3|
-              fmt = "#{t1}#{t2}#{t3}"
-              params = [ Varargs::TYPE_MAP[t1], v1, Varargs::TYPE_MAP[t2], v2, Varargs::TYPE_MAP[t3], v3 ]
-              it "call(#{fmt}, #{params.join(',')})" do
-                buf = FFI::Buffer.new :long_long, 3
-                LibTest.pack_varargs(buf, fmt, *params)
-                verify(buf, 0, v1)
-                verify(buf, 8, v2)
-                verify(buf, 16, v3)
-              end
-            end
-          end
-        end
-      end
-    end
-  end
-end

data/spec/spec.opts

@@ -1,4 +0,0 @@
---color
--w
---format
-documentation