ffi 1.0.0 → 1.17.1

data/spec/ffi/number_spec.rb

@@ -1,231 +0,0 @@
-require File.expand_path(File.join(File.dirname(__FILE__), "spec_helper"))
-describe "Function with primitive integer arguments" do
-  module LibTest
-    extend FFI::Library
-    ffi_lib TestLibrary::PATH
-    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
-  it "int8.size" do
-    FFI::TYPE_INT8.size.should == 1
-  end
-  it "uint8.size" do
-    FFI::TYPE_UINT8.size.should == 1
-  end
-  it "int16.size" do
-    FFI::TYPE_INT16.size.should == 2
-  end
-  it "uint16.size" do
-    FFI::TYPE_UINT16.size.should == 2
-  end
-  it "int32.size" do
-    FFI::TYPE_INT32.size.should == 4
-  end
-  it "uint32.size" do
-    FFI::TYPE_UINT32.size.should == 4
-  end
-  it "int64.size" do
-    FFI::TYPE_INT64.size.should == 8
-  end
-  it "uint64.size" do
-    FFI::TYPE_UINT64.size.should == 8
-  end
-  it "float.size" do
-    FFI::TYPE_FLOAT32.size.should == 4
-  end
-  it "double.size" do
-    FFI::TYPE_FLOAT64.size.should == 8
-  end
-  [ 0, 127, -128, -1 ].each do |i|
-    it ":char call(:char (#{i}))" do
-      LibTest.ret_s8(i).should == i
-    end
-  end
-  [ 0, 0x7f, 0x80, 0xff ].each do |i|
-    it ":uchar call(:uchar (#{i}))" do
-      LibTest.ret_u8(i).should == i
-    end
-  end
-  [ 0, 0x7fff, -0x8000, -1 ].each do |i|
-    it ":short call(:short (#{i}))" do
-      LibTest.ret_s16(i).should == i
-    end
-  end
-  [ 0, 0x7fff, 0x8000, 0xffff ].each do |i|
-    it ":ushort call(:ushort (#{i}))" do
-      LibTest.ret_u16(i).should == i
-    end
-  end
-  [ 0, 0x7fffffff, -0x80000000, -1 ].each do |i|
-    it ":int call(:int (#{i}))" do
-      LibTest.ret_s32(i).should == i
-    end
-  end
-  [ 0, 0x7fffffff, 0x80000000, 0xffffffff ].each do |i|
-    it ":uint call(:uint (#{i}))" do
-      LibTest.ret_u32(i).should == i
-    end
-  end
-  [ 0, 0x7fffffffffffffff, -0x8000000000000000, -1 ].each do |i|
-    it ":long_long call(:long_long (#{i}))" do
-      LibTest.ret_s64(i).should == i
-    end
-  end
-  [ 0, 0x7fffffffffffffff, 0x8000000000000000, 0xffffffffffffffff ].each do |i|
-    it ":ulong_long call(:ulong_long (#{i}))" do
-      LibTest.ret_u64(i).should == i
-    end
-  end
-  if FFI::Platform::LONG_SIZE == 32
-    [ 0, 0x7fffffff, -0x80000000, -1 ].each do |i|
-      it ":long call(:long (#{i}))" do
-        LibTest.ret_long(i).should == i
-      end
-    end
-    [ 0, 0x7fffffff, 0x80000000, 0xffffffff ].each do |i|
-      it ":ulong call(:ulong (#{i}))" do
-        LibTest.ret_ulong(i).should == i
-      end
-    end
-  else
-    [ 0, 0x7fffffffffffffff, -0x8000000000000000, -1 ].each do |i|
-      it ":long call(:long (#{i}))" do
-        LibTest.ret_long(i).should == i
-      end
-    end
-    [ 0, 0x7fffffffffffffff, 0x8000000000000000, 0xffffffffffffffff ].each do |i|
-      it ":ulong call(:ulong (#{i}))" do
-        LibTest.ret_ulong(i).should == i
-      end
-    end
-    [ 0.0, 0.1, 1.1, 1.23 ].each do |f|
-      it ":float call(:double (#{f}))" do
-        LibTest.set_float(f)
-        (LibTest.get_float - f).abs.should < 0.001
-      end
-    end
-    [ 0.0, 0.1, 1.1, 1.23 ].each do |f|
-      it ":double call(:double (#{f}))" do
-        LibTest.set_double(f)
-        (LibTest.get_double - f).abs.should < 0.001
-      end
-    end
-  end
-end
-describe "Integer parameter range checking" do
-  [ 128, -129 ].each do |i|
-    it ":char call(:char (#{i}))" do
-      lambda { LibTest.ret_int8_t(i).should == i }.should raise_error
-    end
-  end
-  [ -1, 256 ].each do |i|
-    it ":uchar call(:uchar (#{i}))" do
-      lambda { LibTest.ret_u_int8_t(i).should == i }.should raise_error
-    end
-  end
-  [ 0x8000, -0x8001 ].each do |i|
-    it ":short call(:short (#{i}))" do
-      lambda { LibTest.ret_int16_t(i).should == i }.should raise_error
-    end
-  end
-  [ -1, 0x10000 ].each do |i|
-    it ":ushort call(:ushort (#{i}))" do
-      lambda { LibTest.ret_u_int16_t(i).should == i }.should raise_error
-    end
-  end
-  [ 0x80000000, -0x80000001 ].each do |i|
-    it ":int call(:int (#{i}))" do
-      lambda { LibTest.ret_int32_t(i).should == i }.should raise_error
-    end
-  end
-  [ -1, 0x100000000 ].each do |i|
-    it ":ushort call(:ushort (#{i}))" do
-      lambda { LibTest.ret_u_int32_t(i).should == i }.should raise_error
-    end
-  end
-end
-describe "Three different size Integer arguments" do
-  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
-    extend FFI::Library
-    ffi_lib TestLibrary::PATH
-    
-    
-    [ '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
-
-  PACK_VALUES = {
-    's8' => [ 0x12  ],
-    'u8' => [ 0x34  ],
-    's16' => [ 0x5678 ],
-    'u16' => [ 0x9abc ],
-    's32' => [ 0x7654321f ],
-    'u32' => [ 0xfee1babe ],
-    'sL' => [ 0x1f2e3d4c ],
-    'uL' => [ 0xf7e8d9ca ],
-    's64' => [ 0x1eafdeadbeefa1b2 ],
-#    'f32' => [ 1.234567 ],
-    'f64' => [ 9.87654321 ]
-  }
-  module Number
-    def self.verify(p, off, t, v)
-      if t == 'f32'
-        p.get_float32(off).should == v
-      elsif t == 'f64'
-        p.get_float64(off).should == v
-      else
-        p.get_int64(off).should == v
-      end
-    end
-  end
-  PACK_VALUES.keys.each do |t1|
-    PACK_VALUES.keys.each do |t2|
-      PACK_VALUES.keys.each do |t3|
-        PACK_VALUES[t1].each do |v1|
-          PACK_VALUES[t2].each do |v2|
-            PACK_VALUES[t3].each do |v3|
-              it "call(#{TYPE_MAP[t1]} (#{v1}), #{TYPE_MAP[t2]} (#{v2}), #{TYPE_MAP[t3]} (#{v3}))" do
-                p = FFI::Buffer.new :long_long, 3
-                LibTest.send("pack_#{t1}#{t2}#{t3}_s64", v1, v2, v3, p)
-                Number.verify(p, 0, t1, v1)
-                Number.verify(p, 8, t2, v2)
-                Number.verify(p, 16, t3, v3)
-              end
-            end
-          end
-        end
-      end
-    end
-  end
-end

data/spec/ffi/pointer_spec.rb

@@ -1,210 +0,0 @@
-require File.expand_path(File.join(File.dirname(__FILE__), "spec_helper"))
-require 'delegate'
-require 'java' if RUBY_PLATFORM =~ /java/
-
-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
-  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)
-    LibTest.ptr_ret_int32_t(tp, 0).should == 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)
-    LibTest.ptr_ret_int32_t(ptr, 0).should == magic
-  end
-  it "Fixnum cannot be used as a Pointer argument" do
-    lambda { LibTest.ptr_ret_int32(0, 0) }.should raise_error
-  end
-  it "Bignum cannot be used as a Pointer argument" do
-    lambda { LibTest.ptr_ret_int32(0xfee1deadbeefcafebabe, 0) }.should raise_error
-  end
-
-  describe "pointer type methods" do
-
-    describe "#read_pointer" do
-      memory = FFI::MemoryPointer.new :pointer
-      LibTest.ptr_set_pointer(memory, 0, LibTest.ptr_from_address(0xdeadbeef))
-      memory.read_pointer.address.should == 0xdeadbeef
-    end
-
-    describe "#write_pointer" do
-      memory = FFI::MemoryPointer.new :pointer
-      memory.write_pointer(LibTest.ptr_from_address(0xdeadbeef))
-      LibTest.ptr_ret_pointer(memory, 0).address.should == 0xdeadbeef
-    end
-
-    describe "#read_array_of_pointer" do
-      values = [0x12345678, 0xfeedf00d, 0xdeadbeef]
-      memory = FFI::MemoryPointer.new :pointer, values.size
-      values.each_with_index do |address, j|
-        LibTest.ptr_set_pointer(memory, j * FFI.type_size(:pointer), LibTest.ptr_from_address(address))
-      end
-      array = memory.read_array_of_pointer(values.size)
-      values.each_with_index do |address, j|
-        array[j].address.should == address
-      end
-    end
-
-    describe "#write_array_of_pointer" do
-      values = [0x12345678, 0xfeedf00d, 0xdeadbeef]
-      memory = FFI::MemoryPointer.new :pointer, values.size
-      memory.write_array_of_pointer(values.map { |address| LibTest.ptr_from_address(address) })
-      array = []
-      values.each_with_index do |address, j|
-        array << LibTest.ptr_ret_pointer(memory, j * FFI.type_size(:pointer))
-      end
-      values.each_with_index do |address, j|
-        array[j].address.should == address
-      end
-    end
-    
-  end
-
-  describe 'NULL' do
-    it 'should be obtained using Pointer::NULL constant' do
-      null_ptr = FFI::Pointer::NULL
-      null_ptr.null?.should be_true
-    end
-    it 'should be obtained passing address 0 to constructor' do
-      FFI::Pointer.new(0).null?.should be_true
-    end
-    it 'should raise an error when attempting read/write operations on it' do
-      null_ptr = FFI::Pointer::NULL
-      lambda { null_ptr.read_int }.should raise_error(FFI::NullPointerError)
-      lambda { null_ptr.write_int(0xff1) }.should raise_error(FFI::NullPointerError)
-    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
-        if RUBY_PLATFORM =~ /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
-  class AutoPointerSubclass < FFI::AutoPointer
-    def self.release(ptr); end
-  end
-  it "cleanup via default release method" do
-    AutoPointerSubclass.should_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.
-      ap = AutoPointerSubclass.new(LibTest.ptr_from_address(magic))
-    end
-    AutoPointerTestHelper.gc_everything loop_count
-  end
-
-  it "cleanup when passed a proc" 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.
-    AutoPointerTestHelper.should_receive(:release).at_least(loop_count-wiggle_room).times
-    AutoPointerTestHelper.reset
-    loop_count.times do
-      ap = FFI::AutoPointer.new(LibTest.ptr_from_address(magic),
-                                AutoPointerTestHelper.finalizer)
-    end
-    AutoPointerTestHelper.gc_everything loop_count
-  end
-
-  it "cleanup when passed a method" do
-    AutoPointerTestHelper.should_receive(:release).at_least(loop_count-wiggle_room).times
-    AutoPointerTestHelper.reset
-    loop_count.times do
-      ap = FFI::AutoPointer.new(LibTest.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
-    lambda 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.should_not raise_error
-  end
-end
-
-describe "AutoPointer#new" do
-  class AutoPointerSubclass < FFI::AutoPointer
-    def self.release(ptr); end
-  end
-  it "MemoryPointer argument raises TypeError" do
-    lambda { FFI::AutoPointer.new(FFI::MemoryPointer.new(:int))}.should raise_error(::TypeError)
-  end
-  it "AutoPointer argument raises TypeError" do
-    lambda { AutoPointerSubclass.new(AutoPointerSubclass.new(LibTest.ptr_from_address(0))) }.should raise_error(::TypeError)
-  end
-  it "Buffer argument raises TypeError" do
-    lambda { FFI::AutoPointer.new(FFI::Buffer.new(:int))}.should raise_error(::TypeError)
-  end
-
-end
-

data/spec/ffi/rbx/attach_function_spec.rb

@@ -1,28 +0,0 @@
-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
-
-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)
-    time.should be_kind_of(Integer)
-  end
-  
-  it "correctly populates a struct for gettimeofday" do
-    t = Timeval.new
-    time = LibC.gettimeofday(t.pointer, nil)
-    t[:tv_sec].should be_kind_of(Numeric)
-    t[:tv_usec].should be_kind_of(Numeric)
-  end
-end
-

data/spec/ffi/rbx/memory_pointer_spec.rb

@@ -1,109 +0,0 @@
-# coding: utf-8
-require "rubygems"
-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")
-    m.type_size.should == 15
-  end
-
-  it "makes a pointer from a string with multibyte characters" do
-    m = FFI::MemoryPointer.from_string("ぱんだ")
-    m.type_size.should == 10
-  end
-
-  it "reads back a string" do
-    m = FFI::MemoryPointer.from_string("FFI is Awesome")
-    m.read_string.should == "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])
-    m.read_array_of_int(2).should == [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])
-    m[0].read_int.should == 1
-    m[1].read_int.should == 2
-  end
-  
-  it "allows writing as an int" do
-    m = FFI::MemoryPointer.new(:int)
-    m.write_int(1)
-    m.read_int.should == 1
-  end
-  
-  it "allows writing as a long" do
-    m = FFI::MemoryPointer.new(:long)
-    m.write_long(10)
-    m.read_long.should == 10
-  end
-  
-  it "raises an error if you try putting a long into a pointer of size 1" do
-    m = FFI::MemoryPointer.new(1)
-    lambda { m.write_long(10) }.should 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)
-    lambda { m.write_int(10) }.should 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)
-    m.read_int.should == 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])
-    m.read_array_of_int(2).should == [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])
-    m.read_array_of_int(2).should == [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])
-    m.read_array_of_int(2).should == [1,2]
-  end  
-  it "MemoryPointer#address returns correct value" do
-    m = FFI::MemoryPointer.new(:long_long)
-    magic = 0x12345678
-    m.write_long(magic)
-    m.read_pointer.address.should == magic
-  end
-  it "MemoryPointer#null? returns true for zero value" do
-    m = FFI::MemoryPointer.new(:long_long)
-    m.write_long(0)    
-    m.read_pointer.null?.should == true
-  end
-  it "MemoryPointer#null? returns false for non-zero value" do
-    m = FFI::MemoryPointer.new(:long_long)
-    m.write_long(0x12345678)
-    m.read_pointer.null?.should == false
-  end
-end

data/spec/ffi/rbx/spec_helper.rb

@@ -1 +0,0 @@
-require File.expand_path(File.join(File.dirname(__FILE__), "..", "spec_helper"))

data/spec/ffi/rbx/struct_spec.rb

@@ -1,13 +0,0 @@
-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
-    t[:tv_sec].should == 12
-  end
-end

data/spec/ffi/spec_helper.rb

@@ -1,21 +0,0 @@
-require 'rubygems'
-require 'rbconfig'
-require 'spec'
-
-if RUBY_PLATFORM =~/java/
-  libdir = File.expand_path(File.join(File.dirname(__FILE__), "..", "..", "lib"))
-  $:.reject! { |p| p == libdir }
-else
-  $:.unshift File.join(File.dirname(__FILE__), "..", "..", "lib"),
-    File.join(File.dirname(__FILE__), "..", "..", "build", "#{Config::CONFIG['host_cpu''arch']}", "ffi_c", RUBY_VERSION)
-end
-puts "loadpath=#{$:.join(':')}"
-require "ffi"
-
-module TestLibrary
-  PATH = "build/libtest.#{FFI::Platform::LIBSUFFIX}"
-end
-module LibTest
-  extend FFI::Library
-  ffi_lib TestLibrary::PATH
-end