ffi 1.9.18 → 1.9.23

data/spec/ffi/platform_spec.rb

@@ -1,114 +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::Platform::LIBSUFFIX" do
-  case OS
-  when "linux"
-    it "returns 'so'" do
-      expect(FFI::Platform::LIBSUFFIX).to eq('so')
-    end
-  when "windows"
-    it "returns 'dll'" do
-      expect(FFI::Platform::LIBSUFFIX).to eq('dll')
-    end
-  when "darwin"
-    it "returns 'dylib'" do
-      expect(FFI::Platform::LIBSUFFIX).to eq('dylib')
-    end
-  end
-end
-
-describe "FFI::Platform::IS_WINDOWS" do
-  case OS
-  when "linux"
-    it "returns false" do
-      expect(FFI::Platform::IS_WINDOWS).to be false
-    end
-  when "windows"
-    it "returns true" do
-      expect(FFI::Platform::IS_WINDOWS).to be true
-    end
-  when "darwin"
-    it "returns false" do
-      expect(FFI::Platform::IS_WINDOWS).to be false
-    end
-  end
-end
-
-describe "FFI::Platform::ARCH" do
-  it "returns the architecture type" do
-    expect(FFI::Platform::ARCH).to eq(CPU)
-  end
-end
-
-describe "FFI::Platform::OS" do
-  case OS
-  when "linux"
-    it "returns 'linux' as a string" do
-      expect(FFI::Platform::OS).to eq('linux')
-    end
-  when "windows"
-    it "returns 'windows' as a string" do
-      expect(FFI::Platform::OS).to eq('windows')
-    end
-  when "darwin"
-    it "returns 'darwin' as a string" do
-      expect(FFI::Platform::OS).to eq('darwin')
-    end
-  end
-end
-
-describe "FFI::Platform.windows?" do
-  case OS
-  when "linux"
-    it "returns false" do
-      expect(FFI::Platform.windows?).to be false
-    end
-  when "windows"
-    it "returns true" do
-      expect(FFI::Platform.windows?).to be true
-    end
-  when "darwin"
-    it "returns false" do
-      expect(FFI::Platform.windows?).to be false
-    end
-  end
-end
-
-describe "FFI::Platform.mac?" do
-  case OS
-  when "linux"
-    it "returns false" do
-      expect(FFI::Platform.mac?).to be false
-    end
-  when "windows"
-    it "returns false" do
-      expect(FFI::Platform.mac?).to be false
-    end
-  when "darwin"
-    it "returns true" do
-      expect(FFI::Platform.mac?).to be true
-    end
-  end
-end
-
-describe "FFI::Platform.unix?" do
-  case OS
-  when "linux"
-    it "returns true" do
-      expect(FFI::Platform.unix?).to be true
-    end
-  when "windows"
-    it "returns false" do
-      expect(FFI::Platform.unix?).to be false
-    end
-  when "darwin"
-    it "returns true" do
-      expect(FFI::Platform.unix?).to be true
-    end
-  end
-end

data/spec/ffi/pointer_spec.rb

@@ -1,285 +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"))
-require 'delegate'
-
-module PointerTestLib
-  extend FFI::Library
-  ffi_lib TestLibrary::PATH
-  begin
-    attach_function :ptr_ret_int32_t, [ :pointer, :int ], :int
-  rescue FFI::NotFoundError
-    # NetBSD uses #define instead of typedef for these
-    attach_function :ptr_ret_int32_t, :ptr_ret___int32_t, [ :pointer, :int ], :int
-  end
-  attach_function :ptr_from_address, [ FFI::Platform::ADDRESS_SIZE == 32 ? :uint : :ulong_long ], :pointer
-  attach_function :ptr_set_pointer, [ :pointer, :int, :pointer ], :void
-  attach_function :ptr_ret_pointer, [ :pointer, :int ], :pointer
-end
-describe "Pointer" do
-  include FFI
-  class ToPtrTest
-    def initialize(ptr)
-      @ptr = ptr
-    end
-    def to_ptr
-      @ptr
-    end
-  end
-
-  it "Any object implementing #to_ptr can be passed as a :pointer parameter" do
-    memory = FFI::MemoryPointer.new :long_long
-    magic = 0x12345678
-    memory.put_int32(0, magic)
-    tp = ToPtrTest.new(memory)
-    expect(PointerTestLib.ptr_ret_int32_t(tp, 0)).to eq(magic)
-  end
-  class PointerDelegate < DelegateClass(FFI::Pointer)
-    def initialize(ptr)
-      @ptr = ptr
-    end
-    def to_ptr
-      @ptr
-    end
-  end
-
-  it "A DelegateClass(Pointer) can be passed as a :pointer parameter" do
-    memory = FFI::MemoryPointer.new :long_long
-    magic = 0x12345678
-    memory.put_int32(0, magic)
-    ptr = PointerDelegate.new(memory)
-    expect(PointerTestLib.ptr_ret_int32_t(ptr, 0)).to eq(magic)
-  end
-
-  it "Fixnum cannot be used as a Pointer argument" do
-    expect { PointerTestLib.ptr_ret_int32(0, 0) }.to raise_error
-  end
-
-  it "Bignum cannot be used as a Pointer argument" do
-    expect { PointerTestLib.ptr_ret_int32(0xfee1deadbeefcafebabe, 0) }.to raise_error
-  end
-
-  it "#to_ptr" do
-    memory = FFI::MemoryPointer.new :pointer
-    expect(memory.to_ptr).to eq(memory)
-
-    expect(FFI::Pointer::NULL.to_ptr).to eq(FFI::Pointer::NULL)
-  end
-
-  describe "pointer type methods" do
-
-    it "#read_pointer" do
-      memory = FFI::MemoryPointer.new :pointer
-      PointerTestLib.ptr_set_pointer(memory, 0, PointerTestLib.ptr_from_address(0xdeadbeef))
-      expect(memory.read_pointer.address).to eq(0xdeadbeef)
-    end
-
-    it "#write_pointer" do
-      memory = FFI::MemoryPointer.new :pointer
-      memory.write_pointer(PointerTestLib.ptr_from_address(0xdeadbeef))
-      expect(PointerTestLib.ptr_ret_pointer(memory, 0).address).to eq(0xdeadbeef)
-    end
-
-    it "#read_array_of_pointer" do
-      values = [0x12345678, 0xfeedf00d, 0xdeadbeef]
-      memory = FFI::MemoryPointer.new :pointer, values.size
-      values.each_with_index do |address, j|
-        PointerTestLib.ptr_set_pointer(memory, j * FFI.type_size(:pointer), PointerTestLib.ptr_from_address(address))
-      end
-      array = memory.read_array_of_pointer(values.size)
-      values.each_with_index do |address, j|
-        expect(array[j].address).to eq(address)
-      end
-    end
-    
-  end
-
-  describe 'NULL' do
-    it 'should be obtained using Pointer::NULL constant' do
-      null_ptr = FFI::Pointer::NULL
-      expect(null_ptr).to be_null
-    end
-    it 'should be obtained passing address 0 to constructor' do
-      expect(FFI::Pointer.new(0)).to be_null
-    end
-    it 'should raise an error when attempting read/write operations on it' do
-      null_ptr = FFI::Pointer::NULL
-      expect { null_ptr.read_int }.to raise_error(FFI::NullPointerError)
-      expect { null_ptr.write_int(0xff1) }.to raise_error(FFI::NullPointerError)
-    end
-    it 'returns true when compared with nil' do
-      expect((FFI::Pointer::NULL == nil)).to be true
-    end
-  end
-
-  it "Pointer.size returns sizeof pointer on platform" do
-    expect(FFI::Pointer.size).to eq((FFI::Platform::ADDRESS_SIZE / 8))
-  end
-
-  describe "#slice" do
-    before(:each) do
-      @mptr = FFI::MemoryPointer.new(:char, 12)
-      @mptr.put_uint(0, 0x12345678)
-      @mptr.put_uint(4, 0xdeadbeef)
-    end
-
-    it "contents of sliced pointer matches original pointer at offset" do
-      expect(@mptr.slice(4, 4).get_uint(0)).to eq(0xdeadbeef)
-    end
-
-    it "modifying sliced pointer is reflected in original pointer" do
-      @mptr.slice(4, 4).put_uint(0, 0xfee1dead)
-      expect(@mptr.get_uint(4)).to eq(0xfee1dead)
-    end
-
-    it "access beyond bounds should raise IndexError" do
-      expect { @mptr.slice(4, 4).get_int(4) }.to raise_error(IndexError)
-    end
-  end
-
-  describe "#type_size" do
-    it "should be same as FFI.type_size(type)" do
-      expect(FFI::MemoryPointer.new(:int, 1).type_size).to eq(FFI.type_size(:int))
-    end
-  end
-end
-
-describe "AutoPointer" do
-  loop_count = 30
-  wiggle_room = 5 # GC rarely cleans up all objects. we can get most of them, and that's enough to determine if the basic functionality is working.
-  magic = 0x12345678
-
-  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
-        TestLibrary.force_gc
-        sleep 0.05 unless @@count == count
-      end
-      @@count = 0
-    end
-    def self.finalizer
-      self.method(:release).to_proc
-    end
-  end
-  class AutoPointerSubclass < FFI::AutoPointer
-    def self.release(ptr); end
-  end
-
-  # see #427
-  it "cleanup via default release method", :broken => true do
-    expect(AutoPointerSubclass).to receive(:release).at_least(loop_count-wiggle_room).times
-    AutoPointerTestHelper.reset
-    loop_count.times do
-      # note that if we called
-      # AutoPointerTestHelper.method(:release).to_proc inline, we'd
-      # have a reference to the pointer and it would never get GC'd.
-      AutoPointerSubclass.new(PointerTestLib.ptr_from_address(magic))
-    end
-    AutoPointerTestHelper.gc_everything loop_count
-  end
-
-  # see #427
-  it "cleanup when passed a proc", :broken => true do
-    #  NOTE: passing a proc is touchy, because it's so easy to create a memory leak.
-    #
-    #  specifically, if we made an inline call to
-    #
-    #      AutoPointerTestHelper.method(:release).to_proc
-    #
-    #  we'd have a reference to the pointer and it would
-    #  never get GC'd.
-    expect(AutoPointerTestHelper).to receive(:release).at_least(loop_count-wiggle_room).times
-    AutoPointerTestHelper.reset
-    loop_count.times do
-      FFI::AutoPointer.new(PointerTestLib.ptr_from_address(magic),
-                           AutoPointerTestHelper.finalizer)
-    end
-    AutoPointerTestHelper.gc_everything loop_count
-  end
-
-  # see #427
-  it "cleanup when passed a method", :broken => true do
-    expect(AutoPointerTestHelper).to receive(:release).at_least(loop_count-wiggle_room).times
-    AutoPointerTestHelper.reset
-    loop_count.times do
-      FFI::AutoPointer.new(PointerTestLib.ptr_from_address(magic),
-                           AutoPointerTestHelper.method(:release))
-    end
-    AutoPointerTestHelper.gc_everything loop_count
-  end
-
-  it "can be used as the return type of a function" do
-    expect do
-      Module.new do
-        extend FFI::Library
-        ffi_lib TestLibrary::PATH
-        class CustomAutoPointer < FFI::AutoPointer
-          def self.release(ptr); end
-        end
-        attach_function :ptr_from_address, [ FFI::Platform::ADDRESS_SIZE == 32 ? :uint : :ulong_long ], CustomAutoPointer
-      end
-    end.not_to raise_error
-  end
-
-  describe "#new" do
-    it "MemoryPointer argument raises TypeError" do
-      expect { FFI::AutoPointer.new(FFI::MemoryPointer.new(:int))}.to raise_error(::TypeError)
-    end
-    it "AutoPointer argument raises TypeError" do
-      expect { AutoPointerSubclass.new(AutoPointerSubclass.new(PointerTestLib.ptr_from_address(0))) }.to raise_error(::TypeError)
-    end
-    it "Buffer argument raises TypeError" do
-      expect { FFI::AutoPointer.new(FFI::Buffer.new(:int))}.to raise_error(::TypeError)
-    end
-
-  end
-
-  describe "#autorelease?" do
-    ptr_class = Class.new(FFI::AutoPointer) do
-      def self.release(ptr); end
-    end
-
-    it "should be true by default" do
-      expect(ptr_class.new(FFI::Pointer.new(0xdeadbeef)).autorelease?).to be true
-    end
-
-    it "should return false when autorelease=(false)" do
-      ptr = ptr_class.new(FFI::Pointer.new(0xdeadbeef))
-      ptr.autorelease = false
-      expect(ptr.autorelease?).to be false
-    end
-  end
-
-  describe "#type_size" do
-    ptr_class = Class.new(FFI::AutoPointer) do
-      def self.release(ptr); end
-    end
-
-    it "type_size of AutoPointer should match wrapped Pointer" do
-      aptr = ptr_class.new(FFI::Pointer.new(:int, 0xdeadbeef))
-      expect(aptr.type_size).to eq(FFI.type_size(:int))
-    end
-    
-    it "[] offset should match wrapped Pointer" do
-      mptr = FFI::MemoryPointer.new(:int, 1024)
-      aptr = ptr_class.new(FFI::Pointer.new(:int, mptr))
-      aptr[0].write_uint(0xfee1dead)
-      aptr[1].write_uint(0xcafebabe)
-      expect(mptr[0].read_uint).to eq(0xfee1dead)
-      expect(mptr[1].read_uint).to eq(0xcafebabe)
-    end
-  end
-end
-

data/spec/ffi/rbx/attach_function_spec.rb

@@ -1,34 +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"))
-
-unless FFI::Platform.windows?
-  class Timeval < FFI::Struct
-    layout :tv_sec, :ulong, 0, :tv_usec, :ulong, 4
-  end
-
-  module LibC
-    extend FFI::Library
-    ffi_lib FFI::Library::LIBC
-
-    attach_function :gettimeofday, [:pointer, :pointer], :int
-  end
-
-  describe FFI::Library, "#attach_function" do
-    it "correctly returns a value for gettimeofday" do
-      t = Timeval.new
-      time = LibC.gettimeofday(t.pointer, nil)
-      expect(time).to be_kind_of(Integer)
-    end
-
-    it "correctly populates a struct for gettimeofday" do
-      t = Timeval.new
-      LibC.gettimeofday(t.pointer, nil)
-      expect(t[:tv_sec]).to be_kind_of(Numeric)
-      expect(t[:tv_usec]).to be_kind_of(Numeric)
-    end
-  end
-end

data/spec/ffi/rbx/memory_pointer_spec.rb

@@ -1,194 +0,0 @@
-# coding: utf-8
-#
-# This file is part of ruby-ffi.
-# For licensing, see LICENSE.SPECS
-#
-
-require File.expand_path(File.join(File.dirname(__FILE__), "spec_helper"))
-
-module CTest
-  extend FFI::Library
-  ffi_lib FFI::Library::LIBC
-
-  attach_function :strcat, [:pointer, :pointer], :pointer
-end
-
-describe "MemoryPointer" do
-  it "makes a pointer from a string" do
-    m = FFI::MemoryPointer.from_string("FFI is Awesome")
-    expect(m.total).to eq(15)
-    expect(m.type_size).to eq(1)
-  end
-
-  it "does not make a pointer from non-strings" do
-    expect { FFI::MemoryPointer.from_string(nil) }.to raise_error(TypeError)
-  end
-
-  it "makes a pointer from a string with multibyte characters" do
-    m = FFI::MemoryPointer.from_string("ぱんだ")
-    expect(m.total).to eq(10)
-    expect(m.type_size).to eq(1)
-  end
-
-  it "reads back a string" do
-    m = FFI::MemoryPointer.from_string("FFI is Awesome")
-    expect(m.read_string).to eq("FFI is Awesome")
-  end
-  
-  it "makes a pointer for a certain number of bytes" do
-    m = FFI::MemoryPointer.new(8)
-    m.write_array_of_int([1,2])
-    expect(m.read_array_of_int(2)).to eq([1,2])
-  end
-
-  it "allows access to an element of the pointer (as an array)" do
-    m = FFI::MemoryPointer.new(:int, 2)
-    m.write_array_of_int([1,2])
-    expect(m[0].read_int).to eq(1)
-    expect(m[1].read_int).to eq(2)
-  end
-  
-  it "allows writing as an int" do
-    m = FFI::MemoryPointer.new(:int)
-    m.write_int(1)
-    expect(m.read_int).to eq(1)
-    expect(m.read :int).to eq(1)
-    expect(m.read FFI::Type::INT).to eq(1)
-  end
-
-  it "allows writing as a sized int" do
-    m = FFI::MemoryPointer.new(:uint32)
-    m.write_uint32(1)
-    expect(m.read_uint32).to eq(1)
-    expect(m.read :uint32).to eq(1)
-    expect(m.read FFI::Type::UINT32).to eq(1)
-
-    m = FFI::MemoryPointer.new(:uint32)
-    m.write :uint32, 1
-    expect(m.read :uint32).to eq(1)
-
-    m = FFI::MemoryPointer.new(:int64)
-    m.write_int64(1)
-    expect(m.read_int64).to eq(1)
-    expect(m.read :int64).to eq(1)
-    expect(m.read FFI::Type::INT64).to eq(1)
-
-    m = FFI::MemoryPointer.new(:int64)
-    m.write :int64, 1
-    expect(m.read :int64).to eq(1)
-  end
-
-  it "allows writing as a long" do
-    m = FFI::MemoryPointer.new(:long)
-    m.write_long(10)
-    expect(m.read_long).to eq(10)
-    expect(m.read :long).to eq(10)
-    expect(m.read FFI::Type::LONG).to eq(10)
-
-    m.write :long, 10
-    expect(m.read :long).to eq(10)
-  end
-
-  it "allows writing as a size_t" do
-    m = FFI::MemoryPointer.new(:size_t)
-    m.write(:size_t, 10)
-    expect(m.read :size_t).to eq(10)
-  end
-
-  it "allows writing as a bool" do
-    m = FFI::MemoryPointer.new(:bool)
-    m.write(:bool, true)
-    expect(m.read :bool).to eq(true)
-    expect(m.read FFI::Type::BOOL).to eq(true)
-
-    m.write(:bool, false)
-    expect(m.read :bool).to eq(false)
-    expect(m.read FFI::Type::BOOL).to eq(false)
-  end
-
-  it "allows writing a custom typedef" do
-    FFI.typedef :uint, :fubar_t
-    FFI.typedef :size_t, :fubar2_t
-
-    m = FFI::MemoryPointer.new(:fubar_t)
-    m.write(:fubar_t, 10)
-    expect(m.read :fubar_t).to eq(10)
-
-    m = FFI::MemoryPointer.new(:fubar2_t)
-    m.write(:fubar2_t, 10)
-    expect(m.read :fubar2_t).to eq(10)
-  end
-
-  it "raises an error if you try to read an undefined type" do
-    m = FFI::MemoryPointer.new(:long)
-    expect { m.read(:undefined_type) }.to raise_error(ArgumentError)
-  end
-  
-  it "raises an error if you try putting a long into a pointer of size 1" do
-    m = FFI::MemoryPointer.new(1)
-    expect { m.write_long(10) }.to raise_error
-  end
-  
-  it "raises an error if you try putting an int into a pointer of size 1" do
-    m = FFI::MemoryPointer.new(1)
-    expect { m.write_int(10) }.to raise_error
-  end
-#  it "does not raise IndexError for opaque pointers" do
-#    m = FFI::MemoryPointer.new(8)
-#    p2 = FFI::MemoryPointer.new(1024)
-#    m.write_long(p2.address)
-#    p = m.read_pointer
-#    lambda { p.write_int(10) }.should_not raise_error
-#  end
-  
-  it "makes a pointer for a certain type" do
-    m = FFI::MemoryPointer.new(:int)
-    m.write_int(10)
-    expect(m.read_int).to eq(10)
-  end
-  
-  it "makes a memory pointer for a number of a certain type" do
-    m = FFI::MemoryPointer.new(:int, 2)
-    m.write_array_of_int([1,2])
-    expect(m.read_array_of_int(2)).to eq([1,2])
-  end
-  
-  it "makes a pointer for an object responding to #size" do
-    m = FFI::MemoryPointer.new(Struct.new(:size).new(8))
-    m.write_array_of_int([1,2])
-    expect(m.read_array_of_int(2)).to eq([1,2])
-  end
-
-  it "makes a pointer for a number of an object responding to #size" do
-    m = FFI::MemoryPointer.new(Struct.new(:size).new(4), 2)
-    m.write_array_of_int([1,2])
-    expect(m.read_array_of_int(2)).to eq([1,2])
-  end  
-
-  it "MemoryPointer#address returns correct value" do
-    m = FFI::MemoryPointer.new(:long_long)
-    magic = 0x12345678
-    m.write_long(magic)
-    expect(m.read_pointer.address).to eq(magic)
-  end
-
-  it "MemoryPointer#null? returns true for zero value" do
-    m = FFI::MemoryPointer.new(:long_long)
-    m.write_long(0)    
-    expect(m.read_pointer.null?).to be true
-  end
-
-  it "MemoryPointer#null? returns false for non-zero value" do
-    m = FFI::MemoryPointer.new(:long_long)
-    m.write_long(0x12345678)
-    expect(m.read_pointer.null?).to be false
-  end
-  
-  it "initialize with block should execute block" do
-    block_executed = false
-    FFI::MemoryPointer.new(:pointer) do |ptr|
-      block_executed = true
-    end
-    expect(block_executed).to be true
-  end
-end

data/spec/ffi/rbx/spec_helper.rb

@@ -1,6 +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"))

data/spec/ffi/rbx/struct_spec.rb

@@ -1,18 +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"))
-
-class Timeval < FFI::Struct
-  layout :tv_sec, :ulong, 0, :tv_usec, :ulong, 4  
-end
-
-describe FFI::Struct do
-  it "allows setting fields" do
-    t = Timeval.new
-    t[:tv_sec] = 12
-    expect(t[:tv_sec]).to eq(12)
-  end
-end