ffi 1.1.5 → 1.15.5

data/spec/ffi/pointer_spec.rb

@@ -1,214 +0,0 @@
-#
-# This file is part of ruby-ffi.
-#
-# This code is free software: you can redistribute it and/or modify it under
-# the terms of the GNU Lesser General Public License version 3 only, as
-# published by the Free Software Foundation.
-#
-# This code is distributed in the hope that it will be useful, but WITHOUT
-# ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
-# FITNESS FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public License
-# version 3 for more details.
-#
-# You should have received a copy of the GNU Lesser General Public License
-# version 3 along with this work.  If not, see <http://www.gnu.org/licenses/>.
-#
-require File.expand_path(File.join(File.dirname(__FILE__), "spec_helper"))
-require 'delegate'
-require 'java' if RUBY_PLATFORM =~ /java/
-
-module PointerTestLib
-  extend FFI::Library
-  ffi_lib TestLibrary::PATH
-  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)
-    PointerTestLib.ptr_ret_int32_t(tp, 0).should 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)
-    PointerTestLib.ptr_ret_int32_t(ptr, 0).should eq magic
-  end
-  it "Fixnum cannot be used as a Pointer argument" do
-    lambda { PointerTestLib.ptr_ret_int32(0, 0) }.should raise_error
-  end
-  it "Bignum cannot be used as a Pointer argument" do
-    lambda { PointerTestLib.ptr_ret_int32(0xfee1deadbeefcafebabe, 0) }.should raise_error
-  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))
-      memory.read_pointer.address.should eq 0xdeadbeef
-    end
-
-    it "#write_pointer" do
-      memory = FFI::MemoryPointer.new :pointer
-      memory.write_pointer(PointerTestLib.ptr_from_address(0xdeadbeef))
-      PointerTestLib.ptr_ret_pointer(memory, 0).address.should 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|
-        array[j].address.should eq 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
-    it 'returns true when compared with nil' do
-      (FFI::Pointer::NULL == nil).should be_true
-    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.
-      AutoPointerSubclass.new(PointerTestLib.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
-      FFI::AutoPointer.new(PointerTestLib.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
-      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
-    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
-
-  describe "#new" do
-    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(PointerTestLib.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
-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,115 +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.total.should eq 15
-    m.type_size.should 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("ぱんだ")
-    m.total.should eq 10
-    m.type_size.should eq 1
-  end
-
-  it "reads back a string" do
-    m = FFI::MemoryPointer.from_string("FFI is Awesome")
-    m.read_string.should 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])
-    m.read_array_of_int(2).should 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])
-    m[0].read_int.should eq 1
-    m[1].read_int.should eq 2
-  end
-  
-  it "allows writing as an int" do
-    m = FFI::MemoryPointer.new(:int)
-    m.write_int(1)
-    m.read_int.should eq 1
-  end
-  
-  it "allows writing as a long" do
-    m = FFI::MemoryPointer.new(:long)
-    m.write_long(10)
-    m.read_long.should eq 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 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])
-    m.read_array_of_int(2).should 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])
-    m.read_array_of_int(2).should 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])
-    m.read_array_of_int(2).should eq [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 eq 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 eq 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 eq 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 eq 12
-  end
-end

data/spec/ffi/spec_helper.rb

@@ -1,35 +0,0 @@
-#
-# This file is part of ruby-ffi.
-#
-# This code is free software: you can redistribute it and/or modify it under
-# the terms of the GNU Lesser General Public License version 3 only, as
-# published by the Free Software Foundation.
-#
-# This code is distributed in the hope that it will be useful, but WITHOUT
-# ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
-# FITNESS FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public License
-# version 3 for more details.
-#
-# You should have received a copy of the GNU Lesser General Public License
-# version 3 along with this work.  If not, see <http://www.gnu.org/licenses/>.
-#
-require 'rubygems'
-require 'rbconfig'
-
-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", "#{RbConfig::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

data/spec/ffi/string_spec.rb

@@ -1,119 +0,0 @@
-#
-# This file is part of ruby-ffi.
-#
-# This code is free software: you can redistribute it and/or modify it under
-# the terms of the GNU Lesser General Public License version 3 only, as
-# published by the Free Software Foundation.
-#
-# This code is distributed in the hope that it will be useful, but WITHOUT
-# ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
-# FITNESS FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public License
-# version 3 for more details.
-#
-# You should have received a copy of the GNU Lesser General Public License
-# version 3 along with this work.  If not, see <http://www.gnu.org/licenses/>.
-#
-
-require File.expand_path(File.join(File.dirname(__FILE__), "spec_helper"))
-describe "String tests" do
-  include FFI
-  module StrLibTest
-    extend FFI::Library
-    ffi_lib TestLibrary::PATH
-    attach_function :ptr_ret_pointer, [ :pointer, :int], :string
-    attach_function :string_equals, [ :string, :string ], :int
-    attach_function :string_dummy, [ :string ], :void
-    attach_function :string_null, [ ], :string
-  end
-  it "MemoryPointer#get_string returns a tainted string" do
-    mp = FFI::MemoryPointer.new 1024
-    mp.put_string(0, "test\0")
-    str = mp.get_string(0)
-    str.tainted?.should eq true
-  end
-  it "String returned by a method is tainted" do
-    mp = FFI::MemoryPointer.new :pointer
-    sp = FFI::MemoryPointer.new 1024
-    sp.put_string(0, "test")
-    mp.put_pointer(0, sp)
-    str = StrLibTest.ptr_ret_pointer(mp, 0)
-    str.should eq "test"
-    str.tainted?.should eq true
-  end
-  it "Poison null byte raises error" do
-    s = "123\0abc"
-    lambda { StrLibTest.string_equals(s, s) }.should raise_error
-  end
-  it "Tainted String parameter should throw a SecurityError" do
-    $SAFE = 1
-    str = "test"
-    str.taint
-    begin
-      LibTest.string_equals(str, str).should eq false
-    rescue SecurityError
-    end
-  end if false
-  it "casts nil as NULL pointer" do
-    StrLibTest.string_dummy(nil)
-  end
-  it "return nil for NULL char*" do
-    StrLibTest.string_null.should eq nil
-  end
-  it "reads an array of strings until encountering a NULL pointer" do
-    strings = ["foo", "bar", "baz", "testing", "ffi"]
-    ptrary = FFI::MemoryPointer.new(:pointer, 6)
-    ary = strings.inject([]) do |a, str|
-      f = FFI::MemoryPointer.new(1024)
-      f.put_string(0, str)
-      a << f
-    end
-    ary.insert(3, nil)
-    ptrary.write_array_of_pointer(ary)
-    ptrary.get_array_of_string(0).should eq ["foo", "bar", "baz"]
-  end
-  it "reads an array of strings of the size specified, substituting nil when a pointer is NULL" do
-    strings = ["foo", "bar", "baz", "testing", "ffi"]
-    ptrary = FFI::MemoryPointer.new(:pointer, 6)
-    ary = strings.inject([]) do |a, str|
-      f = FFI::MemoryPointer.new(1024)
-      f.put_string(0, str)
-      a << f
-    end
-    ary.insert(2, nil)
-    ptrary.write_array_of_pointer(ary)
-    ptrary.get_array_of_string(0, 4).should eq ["foo", "bar", nil, "baz"]
-  end
-  it "reads an array of strings, taking a memory offset parameter" do
-    strings = ["foo", "bar", "baz", "testing", "ffi"]
-    ptrary = FFI::MemoryPointer.new(:pointer, 5)
-    ary = strings.inject([]) do |a, str|
-      f = FFI::MemoryPointer.new(1024)
-      f.put_string(0, str)
-      a << f
-    end
-    ptrary.write_array_of_pointer(ary)
-    ptrary.get_array_of_string(2 * FFI.type_size(:pointer), 3).should eq ["baz", "testing", "ffi"]
-  end
-  it "raises an IndexError when trying to read an array of strings out of bounds" do
-    strings = ["foo", "bar", "baz", "testing", "ffi"]
-    ptrary = FFI::MemoryPointer.new(:pointer, 5)
-    ary = strings.inject([]) do |a, str|
-      f = FFI::MemoryPointer.new(1024)
-      f.put_string(0, str)
-      a << f
-    end
-    ptrary.write_array_of_pointer(ary)
-    lambda { ptrary.get_array_of_string(0, 6) }.should raise_error
-  end
-  it "raises an IndexError when trying to read an array of strings using a negative offset" do
-    strings = ["foo", "bar", "baz", "testing", "ffi"]
-    ptrary = FFI::MemoryPointer.new(:pointer, 5)
-    ary = strings.inject([]) do |a, str|
-      f = FFI::MemoryPointer.new(1024)
-      f.put_string(0, str)
-      a << f
-    end
-    ptrary.write_array_of_pointer(ary)
-    lambda { ptrary.get_array_of_string(-1) }.should raise_error
-  end
-end

data/spec/ffi/strptr_spec.rb

@@ -1,61 +0,0 @@
-#
-# This file is part of ruby-ffi.
-#
-# This code is free software: you can redistribute it and/or modify it under
-# the terms of the GNU Lesser General Public License version 3 only, as
-# published by the Free Software Foundation.
-#
-# This code is distributed in the hope that it will be useful, but WITHOUT
-# ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
-# FITNESS FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public License
-# version 3 for more details.
-#
-# You should have received a copy of the GNU Lesser General Public License
-# version 3 along with this work.  If not, see <http://www.gnu.org/licenses/>.
-#
-
-require File.expand_path(File.join(File.dirname(__FILE__), "spec_helper"))
-
-describe "functions returning :strptr" do
-
-  it "can attach function with :strptr return type" do
-    lambda do
-      Module.new do
-        extend FFI::Library
-        ffi_lib FFI::Library::LIBC
-        if !FFI::Platform.windows?
-          attach_function :strdup, [ :string ], :strptr
-        else
-          attach_function :_strdup, [ :string ], :strptr
-        end
-      end
-    end.should_not raise_error
-  end
-
-  module StrPtr
-    extend FFI::Library
-    ffi_lib FFI::Library::LIBC
-    attach_function :free, [ :pointer ], :void
-    if !FFI::Platform.windows?
-      attach_function :strdup, [ :string ], :strptr
-    else
-      attach_function :strdup, :_strdup, [ :string ], :strptr
-    end
-  end
-
-  it "should return [ String, Pointer ]" do
-    result = StrPtr.strdup("test")
-    result[0].is_a?(String).should be_true
-    result[1].is_a?(FFI::Pointer).should be_true
-  end
-
-  it "should return the correct value" do
-    result = StrPtr.strdup("test")
-    result[0].should eq "test"
-  end
-
-  it "should return non-NULL pointer" do
-    result = StrPtr.strdup("test")
-    result[1].null?.should be_false
-  end
-end

data/spec/ffi/struct_callback_spec.rb

@@ -1,80 +0,0 @@
-#
-# This file is part of ruby-ffi.
-#
-# This code is free software: you can redistribute it and/or modify it under
-# the terms of the GNU Lesser General Public License version 3 only, as
-# published by the Free Software Foundation.
-#
-# This code is distributed in the hope that it will be useful, but WITHOUT
-# ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
-# FITNESS FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public License
-# version 3 for more details.
-#
-# You should have received a copy of the GNU Lesser General Public License
-# version 3 along with this work.  If not, see <http://www.gnu.org/licenses/>.
-#
-
-require File.expand_path(File.join(File.dirname(__FILE__), "spec_helper"))
-
-describe FFI::Struct, ' with inline callback functions' do
-  it 'should be able to define inline callback field' do
-    module CallbackMember1
-      extend FFI::Library
-      ffi_lib TestLibrary::PATH
-      DUMMY_CB = callback :dummy_cb, [ :int ], :int
-      class TestStruct < FFI::Struct
-        layout \
-          :add, callback([ :int, :int ], :int),
-          :sub, callback([ :int, :int ], :int),
-          :cb_with_cb_parameter, callback([ DUMMY_CB, :int ], :int)
-      end
-      attach_function :struct_call_add_cb, [TestStruct, :int, :int], :int
-      attach_function :struct_call_sub_cb, [TestStruct, :int, :int], :int
-    end
-  end
-  it 'should take methods as callbacks' do
-    module CallbackMember2
-      extend FFI::Library
-      ffi_lib TestLibrary::PATH
-      class TestStruct < FFI::Struct
-        layout \
-          :add, callback([ :int, :int ], :int),
-          :sub, callback([ :int, :int ], :int)
-      end
-      attach_function :struct_call_add_cb, [TestStruct, :int, :int], :int
-      attach_function :struct_call_sub_cb, [TestStruct, :int, :int], :int
-    end
-    module StructCallbacks
-      def self.add a, b
-        a+b
-      end
-    end
-
-    ts = CallbackMember2::TestStruct.new
-    ts[:add] = StructCallbacks.method(:add)
-
-    CallbackMember2.struct_call_add_cb(ts, 1, 2).should eq 3
-  end
-
-  it 'should return callable object from []' do
-    module CallbackMember3
-      extend FFI::Library
-      ffi_lib TestLibrary::PATH
-      class TestStruct < FFI::Struct
-        layout \
-          :add, callback([ :int, :int ], :int),
-          :sub, callback([ :int, :int ], :int)
-      end
-      attach_function :struct_call_add_cb, [TestStruct, :int, :int], :int
-      attach_function :struct_call_sub_cb, [TestStruct, :int, :int], :int
-    end
-
-    s = CallbackMember3::TestStruct.new
-    add = Proc.new { |a,b| a+b}
-    s[:add] = add
-    fn = s[:add]
-    fn.respond_to?(:call).should be_true
-    fn.call(1, 2).should eq 3
-  end
-end
-