ffi 1.9.18 → 1.9.23

data/spec/ffi/fixtures/VariadicTest.c

@@ -1,99 +0,0 @@
-/*
- * Copyright (c) 2007 Wayne Meissner. All rights reserved.
- *
- * For licensing, see LICENSE.SPECS
- */
-
-#include <sys/types.h>
-#include <stdio.h>
-#include <stdint.h>
-#include <string.h>
-#include <stdarg.h>
-
-typedef int8_t s8;
-typedef uint8_t u8;
-typedef int16_t s16;
-typedef uint16_t u16;
-typedef int32_t s32;
-typedef uint32_t u32;
-typedef int64_t s64;
-typedef uint64_t u64;
-typedef signed long sL;
-typedef unsigned long uL;
-typedef float F;
-typedef double D;
-
-void pack_varargs(s64* buf, const char* fmt, ...)
-{
-    va_list ap;
-    int c;
-    double d;
-    va_start(ap, fmt);
-    while ((c = *fmt++)) {
-        switch (c) {
-            case 'c':
-            case 's':
-            case 'i':
-                *buf++ = va_arg(ap, s32);
-                break;
-            case 'l':
-                *buf++ = va_arg(ap, long);
-                break;
-            case 'j':
-                *buf++ = va_arg(ap, s64);
-                break;
-            case 'f':
-            case 'd':
-                d = va_arg(ap, double);
-                memcpy(buf++, &d, sizeof(d));
-                break;
-            case 'C':
-            case 'S':
-            case 'I':
-                *buf++ = va_arg(ap, u32);
-                break;
-            case 'L':
-                *buf++ = va_arg(ap, unsigned long);
-                break;
-        }
-    }
-    va_end(ap);
-}
-
-int pack_varargs2(s64* buf, int retval, const char* fmt, ...)
-{
-    va_list ap;
-    int c;
-    double d;
-    va_start(ap, fmt);
-    while ((c = *fmt++)) {
-        switch (c) {
-            case 'c':
-            case 's':
-            case 'i':
-                *buf++ = va_arg(ap, s32);
-                break;
-            case 'l':
-                *buf++ = va_arg(ap, long);
-                break;
-            case 'j':
-                *buf++ = va_arg(ap, s64);
-                break;
-            case 'f':
-            case 'd':
-                d = va_arg(ap, double);
-                memcpy(buf++, &d, sizeof(d));
-                break;
-            case 'C':
-            case 'S':
-            case 'I':
-                *buf++ = va_arg(ap, u32);
-                break;
-            case 'L':
-                *buf++ = va_arg(ap, unsigned long);
-                break;
-        }
-    }
-    va_end(ap);
-    return retval + 1;
-}

data/spec/ffi/fixtures/classes.rb

@@ -1,438 +0,0 @@
-module FFISpecs
-  #
-  # Callback fixtures
-  #
-  module LibTest
-    callback :cbVrS8, [ ], :char
-    callback :cbVrU8, [ ], :uchar
-    callback :cbVrS16, [ ], :short
-    callback :cbVrU16, [ ], :ushort
-    callback :cbVrS32, [ ], :int
-    callback :cbVrU32, [ ], :uint
-    callback :cbVrL, [ ], :long
-    callback :cbVrUL, [ ], :ulong
-    callback :cbVrS64, [ ], :long_long
-    callback :cbVrU64, [ ], :ulong_long
-    callback :cbVrP, [], :pointer
-    callback :cbCrV, [ :char ], :void
-    callback :cbSrV, [ :short ], :void
-    callback :cbIrV, [ :int ], :void
-    callback :cbLrV, [ :long ], :void
-    callback :cbULrV, [ :ulong ], :void
-    callback :cbLrV, [ :long_long ], :void
-
-    attach_function :testCallbackVrS8, :testClosureVrB, [ :cbVrS8 ], :char
-    attach_function :testCallbackVrU8, :testClosureVrB, [ :cbVrU8 ], :uchar
-    attach_function :testCallbackVrS16, :testClosureVrS, [ :cbVrS16 ], :short
-    attach_function :testCallbackVrU16, :testClosureVrS, [ :cbVrU16 ], :ushort
-    attach_function :testCallbackVrS32, :testClosureVrI, [ :cbVrS32 ], :int
-    attach_function :testCallbackVrU32, :testClosureVrI, [ :cbVrU32 ], :uint
-    attach_function :testCallbackVrL, :testClosureVrL, [ :cbVrL ], :long
-    attach_function :testCallbackVrUL, :testClosureVrL, [ :cbVrUL ], :ulong
-    attach_function :testCallbackVrS64, :testClosureVrLL, [ :cbVrS64 ], :long_long
-    attach_function :testCallbackVrU64, :testClosureVrLL, [ :cbVrU64 ], :ulong_long
-    attach_function :testCallbackVrP, :testClosureVrP, [ :cbVrP ], :pointer
-    attach_function :testCallbackCrV, :testClosureBrV, [ :cbCrV, :char ], :void
-    attach_variable :cbVrS8, :gvar_pointer, :cbVrS8
-    attach_variable :pVrS8, :gvar_pointer, :pointer
-    attach_function :testGVarCallbackVrS8, :testClosureVrB, [ :pointer ], :char
-    attach_function :testOptionalCallbackCrV, :testOptionalClosureBrV, [ :cbCrV, :char ], :void
-
-    attach_function :testCallbackVrS8, :testClosureVrB, [ callback([ ], :char) ], :char
-
-    callback :cb_return_type, [ :int ], :int
-    callback :cb_lookup, [ ], :cb_return_type
-    attach_function :testReturnsCallback, :testReturnsClosure, [ :cb_lookup, :int ], :int
-
-    callback :funcptr, [ :int ], :int
-    attach_function :testReturnsFunctionPointer, [  ], :funcptr
-
-    callback :cbS8rV, [ :char ], :void
-    callback :cbU8rV, [ :uchar ], :void
-    callback :cbS16rV, [ :short ], :void
-    callback :cbU16rV, [ :ushort ], :void
-
-    callback :cbS32rV, [ :int ], :void
-    callback :cbU32rV, [ :uint ], :void
-
-    callback :cbLrV, [ :long ], :void
-    callback :cbULrV, [ :ulong ], :void
-
-    callback :cbS64rV, [ :long_long ], :void
-    attach_function :testCallbackCrV, :testClosureBrV, [ :cbS8rV, :char ], :void
-    attach_function :testCallbackU8rV, :testClosureBrV, [ :cbU8rV, :uchar ], :void
-    attach_function :testCallbackSrV, :testClosureSrV, [ :cbS16rV, :short ], :void
-    attach_function :testCallbackU16rV, :testClosureSrV, [ :cbU16rV, :ushort ], :void
-    attach_function :testCallbackIrV, :testClosureIrV, [ :cbS32rV, :int ], :void
-    attach_function :testCallbackU32rV, :testClosureIrV, [ :cbU32rV, :uint ], :void
-
-    attach_function :testCallbackLrV, :testClosureLrV, [ :cbLrV, :long ], :void
-    attach_function :testCallbackULrV, :testClosureULrV, [ :cbULrV, :ulong ], :void
-
-    attach_function :testCallbackLLrV, :testClosureLLrV, [ :cbS64rV, :long_long ], :void
-  end
-
-  #
-  # Enum fixtures
-  #
-  module TestEnum0
-    extend FFI::Library
-  end
-
-  module TestEnum1
-    extend FFI::Library
-    ffi_lib LIBRARY
-
-    enum [:c1, :c2, :c3, :c4]
-    enum [:c5, 42, :c6, :c7, :c8]
-    enum [:c9, 42, :c10, :c11, 4242, :c12]
-    enum [:c13, 42, :c14, 4242, :c15, 424242, :c16, 42424242]
-
-    attach_function :test_untagged_enum, [:int], :int
-  end
-
-  module TestEnum3
-    extend FFI::Library
-    ffi_lib LIBRARY
-
-    enum :enum_type1, [:c1, :c2, :c3, :c4]
-    enum :enum_type2, [:c5, 42, :c6, :c7, :c8]
-    enum :enum_type3, [:c9, 42, :c10, :c11, 4242, :c12]
-    enum :enum_type4, [:c13, 42, :c14, 4242, :c15, 424242, :c16, 42424242]
-
-    attach_function :test_tagged_typedef_enum1, [:enum_type1], :enum_type1
-    attach_function :test_tagged_typedef_enum2, [:enum_type2], :enum_type2
-    attach_function :test_tagged_typedef_enum3, [:enum_type3], :enum_type3
-    attach_function :test_tagged_typedef_enum4, [:enum_type4], :enum_type4
-  end
-
-  #
-  # Errno fixtures
-  #
-  module LibTest
-    attach_function :setLastError, [ :int ], :void
-  end
-
-  #
-  # ManagedStruct fixtures
-  #
-  module LibTest
-    attach_function :ptr_from_address, [ FFI::Platform::ADDRESS_SIZE == 32 ? :uint : :ulong_long ], :pointer
-  end
-
-  class NoRelease < ManagedStruct
-    layout :i, :int
-  end
-
-  class WhatClassAmI < ManagedStruct
-    layout :i, :int
-    def self.release; end
-  end
-
-  class PleaseReleaseMe < ManagedStruct
-    layout :i, :int
-    @@count = 0
-    def self.release
-      @@count += 1
-    end
-    def self.wait_gc(count)
-      loop = 5
-      while loop > 0 && @@count < count
-        loop -= 1
-        if RUBY_PLATFORM =~ /java/
-          require 'java'
-          java.lang.System.gc
-        else
-          GC.start
-        end
-        sleep 0.05 if @@count < count
-      end
-    end
-  end
-
-  #
-  # Number fixtures
-  #
-  module LibTest
-    attach_function :ret_s8, [ :char ], :char
-    attach_function :ret_u8, [ :uchar ], :uchar
-    attach_function :ret_s16, [ :short ], :short
-    attach_function :ret_u16, [ :ushort ], :ushort
-    attach_function :ret_s32, [ :int ], :int
-    attach_function :ret_u32, [ :uint ], :uint
-    attach_function :ret_s64, [ :long_long ], :long_long
-    attach_function :ret_u64, [ :ulong_long ], :ulong_long
-    attach_function :ret_long, [ :long ], :long
-    attach_function :ret_ulong, [ :ulong ], :ulong
-    attach_function :set_s8, [ :char ], :void
-    attach_function :get_s8, [ ], :char
-    attach_function :set_float, [ :float ], :void
-    attach_function :get_float, [ ], :float
-    attach_function :set_double, [ :double ], :void
-    attach_function :get_double, [ ], :double
-  end
-
-  PACK_VALUES = {
-    's8' => [ 0x12  ],
-    'u8' => [ 0x34  ],
-    's16' => [ 0x5678 ],
-    'u16' => [ 0x9abc ],
-    's32' => [ 0x7654321f ],
-    'u32' => [ 0xfee1babe ],
-    'sL' => [ 0x1f2e3d4c ],
-    'uL' => [ 0xf7e8d9ca ],
-    's64' => [ 0x1eafdeadbeefa1b2 ],
-    #'f32' => [ 1.234567 ], # TODO: Why is this disabled?
-    'f64' => [ 9.87654321 ]
-  }
-
-  TYPE_MAP = {
-    's8' => :char, 'u8' => :uchar, 's16' => :short, 'u16' => :ushort,
-    's32' => :int, 'u32' => :uint, 's64' => :long_long, 'u64' => :ulong_long,
-    'sL' => :long, 'uL' => :ulong, 'f32' => :float, 'f64' => :double
-  }
-  TYPES = TYPE_MAP.keys
-
-  module LibTest
-    [ 's32', 'u32', 's64', 'u64' ].each do |rt|
-      TYPES.each do |t1|
-        TYPES.each do |t2|
-          TYPES.each do |t3|
-            begin
-              attach_function "pack_#{t1}#{t2}#{t3}_#{rt}",
-                [ TYPE_MAP[t1], TYPE_MAP[t2], TYPE_MAP[t3], :buffer_out ], :void
-            rescue FFI::NotFoundError
-            end
-          end
-        end
-      end
-    end
-  end
-
-  #
-  # Pointer fixtures
-  #
-  module LibTest
-    attach_function :ptr_ret_int32_t, [ :pointer, :int ], :int
-    attach_function :ptr_from_address, [ FFI::Platform::ADDRESS_SIZE == 32 ? :uint : :ulong_long ], :pointer
-    attach_function :ptr_set_pointer, [ :pointer, :int, :pointer ], :void
-  end
-
-  class ToPtrTest
-    def initialize(ptr)
-      @ptr = ptr
-    end
-    def to_ptr
-      @ptr
-    end
-  end
-
-  require 'delegate'
-  class PointerDelegate < DelegateClass(FFI::Pointer)
-    def initialize(ptr)
-      super
-      @ptr = ptr
-    end
-    def to_ptr
-      @ptr
-    end
-  end
-
-  class AutoPointerTestHelper
-    @@count = 0
-    def self.release
-      @@count += 1 if @@count > 0
-    end
-    def self.reset
-      @@count = 0
-    end
-    def self.gc_everything(count)
-      loop = 5
-      while @@count < count && loop > 0
-        loop -= 1
-        if RUBY_PLATFORM =~ /java/
-          require "java"
-          java.lang.System.gc
-        else
-          GC.start
-        end
-        sleep 0.05 unless @@count == count
-      end
-      @@count = 0
-    end
-    def self.finalizer
-      self.method(:release).to_proc
-    end
-  end
-
-  #
-  # String fixtures
-  #
-  module LibTest
-    attach_function :ptr_ret_pointer, [ :pointer, :int], :string
-    attach_function :string_equals, [ :string, :string ], :int
-    attach_function :string_dummy, [ :string ], :void
-  end
-
-  #
-  # Struct initialize fixtures
-  #
-  class StructWithInitialize < FFI::Struct
-    layout :string, :string
-    attr_accessor :magic
-    def initialize
-      super
-      self.magic = 42
-    end
-  end
-
-  #
-  # Struct fixtures
-  #
-  StructTypes = {
-    's8' => :char,
-    's16' => :short,
-    's32' => :int,
-    's64' => :long_long,
-    'long' => :long,
-    'f32' => :float,
-    'f64' => :double
-  }
-
-  module LibTest
-    attach_function :ptr_ret_pointer, [ :pointer, :int], :string
-    attach_function :ptr_ret_int32_t, [ :pointer, :int ], :int
-    attach_function :ptr_from_address, [ :ulong ], :pointer
-    attach_function :string_equals, [ :string, :string ], :int
-    [ 's8', 's16', 's32', 's64', 'f32', 'f64', 'long' ].each do |t|
-      attach_function "struct_align_#{t}", [ :pointer ], StructTypes[t]
-    end
-  end
-
-  class PointerMember < FFI::Struct
-    layout :pointer, :pointer
-  end
-
-  class StringMember < FFI::Struct
-    layout :string, :string
-  end
-
-  module CallbackMember
-    extend FFI::Library
-    ffi_lib LIBRARY
-    callback :add, [ :int, :int ], :int
-    callback :sub, [ :int, :int ], :int
-
-    class TestStruct < FFI::Struct
-      layout :add, :add,
-        :sub, :sub
-    end
-
-    attach_function :struct_call_add_cb, [TestStruct, :int, :int], :int
-    attach_function :struct_call_sub_cb, [TestStruct, :int, :int], :int
-  end
-
-  module LibTest
-    class NestedStruct < FFI::Struct
-      layout :i, :int
-    end
-
-    class ContainerStruct < FFI::Struct
-      layout :first, :char, :ns, NestedStruct
-    end
-
-    attach_function :struct_align_nested_struct, [ :pointer ], :int
-    attach_function :struct_make_container_struct, [ :int ], :pointer
-
-    class StructWithArray < FFI::Struct
-      layout :first, :char, :a, [:int, 5]
-    end
-
-    attach_function :struct_make_struct_with_array, [:int, :int, :int, :int, :int], :pointer
-    attach_function :struct_field_array, [:pointer], :pointer
-
-    class BuggedStruct < FFI::Struct
-      layout :visible, :uchar,
-              :x, :uint,
-              :y, :uint,
-              :rx, :short,
-              :ry, :short,
-              :order, :uchar,
-              :size, :uchar
-    end
-
-    attach_function :bugged_struct_size, [], :uint
-  end
-
-  module StructCustomTypedef
-    extend FFI::Library
-    ffi_lib LIBRARY
-    typedef :uint, :fubar3_t
-
-    class S < FFI::Struct
-      layout :a, :fubar3_t
-    end
-  end
-
-  #
-  # Union fixtures
-  #
-  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
-
-  #
-  # Variadic fixtures
-  #
-  module LibTest
-    attach_function :pack_varargs, [ :buffer_out, :string, :varargs ], :void
-  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
-end

data/spec/ffi/function_spec.rb

@@ -1,97 +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 FFI::Function do
-  module LibTest
-    extend FFI::Library
-    ffi_lib TestLibrary::PATH
-    attach_function :testFunctionAdd, [:int, :int, :pointer], :int
-  end
-  before do
-    @libtest = FFI::DynamicLibrary.open(TestLibrary::PATH,
-                                        FFI::DynamicLibrary::RTLD_LAZY | FFI::DynamicLibrary::RTLD_GLOBAL)
-  end
-
-  it 'is initialized with a signature and a block' do
-    fn = FFI::Function.new(:int, []) { 5 }
-    expect(fn.call).to eql 5
-  end
-
-  it 'raises an error when passing a wrong signature' do
-    expect { FFI::Function.new([], :int).new { } }.to raise_error TypeError
-  end
-
-  it 'returns a native pointer' do
-    expect(FFI::Function.new(:int, []) { }).to be_a_kind_of FFI::Pointer
-  end
-
-  it 'can be used as callback from C passing to it a block' do
-    function_add = FFI::Function.new(:int, [:int, :int]) { |a, b| a + b }
-    expect(LibTest.testFunctionAdd(10, 10, function_add)).to eq(20)
-  end
-
-  it 'can be used as callback from C passing to it a Proc object' do
-    function_add = FFI::Function.new(:int, [:int, :int], Proc.new { |a, b| a + b })
-    expect(LibTest.testFunctionAdd(10, 10, function_add)).to eq(20)
-  end
-
-  it 'can be used to wrap an existing function pointer' do
-    expect(FFI::Function.new(:int, [:int, :int], @libtest.find_function('testAdd')).call(10, 10)).to eq(20)
-  end
-
-  it 'can be attached to a module' do
-    module Foo; end
-    fp = FFI::Function.new(:int, [:int, :int], @libtest.find_function('testAdd'))
-    fp.attach(Foo, 'add')
-    expect(Foo.add(10, 10)).to eq(20)
-  end
-
-  it 'can be used to extend an object' do
-    fp = FFI::Function.new(:int, [:int, :int], @libtest.find_function('testAdd'))
-    foo = Object.new
-    class << foo
-      def singleton_class
-        class << self; self; end
-      end
-    end
-    fp.attach(foo.singleton_class, 'add')
-    expect(foo.add(10, 10)).to eq(20)
-  end
-
-  it 'can wrap a blocking function' do
-    fpOpen = FFI::Function.new(:pointer, [ ], @libtest.find_function('testBlockingOpen'))
-    fpRW = FFI::Function.new(:char, [ :pointer, :char ], @libtest.find_function('testBlockingRW'), :blocking => true)
-    fpWR = FFI::Function.new(:char, [ :pointer, :char ], @libtest.find_function('testBlockingWR'), :blocking => true)
-    fpClose = FFI::Function.new(:void, [ :pointer ], @libtest.find_function('testBlockingClose'))
-    handle = fpOpen.call
-    expect(handle).not_to be_null
-    begin
-      thWR = Thread.new { fpWR.call(handle, 63) }
-      thRW = Thread.new { fpRW.call(handle, 64) }
-      expect(thWR.value).to eq(64)
-      expect(thRW.value).to eq(63)
-    ensure
-      fpClose.call(handle)
-    end
-  end
-
-  it 'autorelease flag is set to true by default' do
-    fp = FFI::Function.new(:int, [:int, :int], @libtest.find_function('testAdd'))
-    expect(fp.autorelease?).to be true
-  end
-
-  it 'can explicity free itself' do
-    fp = FFI::Function.new(:int, []) { }
-    fp.free
-    expect { fp.free }.to raise_error RuntimeError
-  end
-
-  it 'can\'t explicity free itself if not previously allocated' do
-    fp = FFI::Function.new(:int, [:int, :int], @libtest.find_function('testAdd'))
-    expect { fp.free }.to raise_error RuntimeError
-  end
-end

data/spec/ffi/io_spec.rb

@@ -1,16 +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"))
-
-if false # disabled for #390
-  describe "FFI::IO.for_fd" do
-    it "produces an IO wrapping the specified file descriptor" do
-      expect do
-        FFI::IO.for_fd(2, "r")
-      end.to_not raise_error
-    end
-  end
-end