ffi 1.9.3-x64-mingw32

data/libtest/UnionTest.c

@@ -0,0 +1,43 @@
+/*
+ * Copyright (c) 2007 Wayne Meissner. All rights reserved.
+ *
+ * For licensing, see LICENSE.SPECS
+ */
+
+#include <stdio.h>
+#include <stdbool.h>
+#include <stdint.h>
+#include <string.h>
+#include <stdlib.h>
+
+typedef char s8;
+typedef short s16;
+typedef int s32;
+typedef long long s64;
+typedef float f32;
+typedef double f64;
+
+typedef union union_test {
+    char b;
+    short s;
+    int i;
+    long long j;
+    long l;
+    float f;
+    double d;
+    s8 a[10];
+} union_test_t;
+
+#define T(x, type) \
+  type union_align_##type(union_test_t* u) { return u->x; } \
+  union_test_t* union_make_union_with_##type(type value) { static union_test_t u; u.x = value; return &u; }
+
+T(b, s8);
+T(s, s16);
+T(i, s32);
+T(j, s64);
+T(f, f32);
+T(d, f64);
+T(l, long);
+
+unsigned int union_size() { return sizeof(union_test_t); }

data/libtest/VariadicTest.c

@@ -0,0 +1,62 @@
+/*
+ * 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);
+}
+

data/spec/ffi/async_callback_spec.rb

@@ -0,0 +1,35 @@
+#
+# This file is part of ruby-ffi.
+# For licensing, see LICENSE.SPECS
+#
+
+require File.expand_path(File.join(File.dirname(__FILE__), "spec_helper"))
+
+describe "async callback" do
+  module LibTest
+    extend FFI::Library
+    ffi_lib TestLibrary::PATH
+    AsyncIntCallback = callback [ :int ], :void
+
+    @blocking = true
+    attach_function :testAsyncCallback, [ AsyncIntCallback, :int ], :void
+  end
+
+  it ":int (0x7fffffff) argument" do
+    v = 0xdeadbeef
+    called = false
+    cb = Proc.new {|i| v = i; called = true }
+    LibTest.testAsyncCallback(cb, 0x7fffffff) 
+    called.should be_true
+    v.should == 0x7fffffff
+  end
+  
+  it "called a second time" do
+    v = 0xdeadbeef
+    called = false
+    cb = Proc.new {|i| v = i; called = true }
+    LibTest.testAsyncCallback(cb, 0x7fffffff) 
+    called.should be_true
+    v.should == 0x7fffffff
+  end
+end

data/spec/ffi/bool_spec.rb

@@ -0,0 +1,29 @@
+#
+# 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 primitive boolean arguments and return values" do
+  module LibTest
+    extend FFI::Library
+    ffi_lib TestLibrary::PATH
+    attach_function :bool_return_true, [ ], :bool
+    attach_function :bool_return_false, [ ], :bool
+    attach_function :bool_return_val, [ :bool ], :bool
+    attach_function :bool_reverse_val, [ :bool ], :bool
+  end
+  it "bools" do
+    LibTest.bool_return_true.should == true
+    LibTest.bool_return_false.should == false
+
+    LibTest.bool_return_val(true).should == true
+    LibTest.bool_return_val(false).should == false
+
+    LibTest.bool_reverse_val(true).should == false
+    LibTest.bool_reverse_val(false).should == true
+  end
+  it "raise error on invalid types" do
+    lambda { LibTest.bool_return_val(nil) }.should raise_error(::TypeError)
+  end
+end

data/spec/ffi/buffer_spec.rb

@@ -0,0 +1,251 @@
+#
+# This file is part of ruby-ffi.
+# For licensing, see LICENSE.SPECS
+#
+
+require File.expand_path(File.join(File.dirname(__FILE__), "spec_helper"))
+
+describe "Buffer#total" do
+  [1,2,3].each do |i|
+    { :char => 1, :uchar => 1, :short => 2, :ushort => 2, :int => 4, 
+      :uint => 4, :long => FFI::Type::LONG.size, :ulong => FFI::Type::ULONG.size, 
+      :long_long => 8, :ulong_long => 8, :float => 4, :double => 8
+    }.each_pair do |t, s|
+      it "Buffer.alloc_in(#{t}, #{i}).total == #{i * s}" do
+        FFI::Buffer.alloc_in(t, i).total.should == i * s
+      end
+      it "Buffer.alloc_out(#{t}, #{i}).total == #{i * s}" do
+        FFI::Buffer.alloc_out(t, i).total.should == i * s
+      end
+      it "Buffer.alloc_inout(#{t}, #{i}).total == #{i * s}" do
+        FFI::Buffer.alloc_inout(t, i).total.should == i * s
+      end
+    end
+  end
+end
+
+describe "Buffer#put_char" do
+  bufsize = 4
+  (0..127).each do |i|
+    (0..bufsize-1).each do |offset|
+      it "put_char(#{offset}, #{i}).get_char(#{offset}) == #{i}" do
+        FFI::Buffer.alloc_in(bufsize).put_char(offset, i).get_char(offset).should == i
+      end
+    end
+  end
+end
+describe "Buffer#put_uchar" do
+  bufsize = 4
+  (0..255).each do |i|
+    (0..bufsize-1).each do |offset|
+      it "Buffer.put_uchar(#{offset}, #{i}).get_uchar(#{offset}) == #{i}" do
+        FFI::Buffer.alloc_in(bufsize).put_uchar(offset, i).get_uchar(offset).should == i
+      end
+    end
+  end 
+end
+describe "Buffer#put_short" do
+  bufsize = 4
+  [0, 1, 128, 32767].each do |i|
+    (0..bufsize-2).each do |offset|
+      it "put_short(#{offset}, #{i}).get_short(#{offset}) == #{i}" do
+        FFI::Buffer.alloc_in(bufsize).put_short(offset, i).get_short(offset).should == i
+      end
+    end
+  end
+end
+describe "Buffer#put_ushort" do
+  bufsize = 4
+  [ 0, 1, 128, 32767, 65535, 0xfee1, 0xdead, 0xbeef, 0xcafe ].each do |i|
+    (0..bufsize-2).each do |offset|
+      it "put_ushort(#{offset}, #{i}).get_ushort(#{offset}) == #{i}" do
+        FFI::Buffer.alloc_in(bufsize).put_ushort(offset, i).get_ushort(offset).should == i
+      end
+    end
+  end
+end
+describe "Buffer#put_int" do
+  bufsize = 8
+  [0, 1, 128, 32767, 0x7ffffff ].each do |i|
+    (0..bufsize-4).each do |offset|
+      it "put_int(#{offset}, #{i}).get_int(#{offset}) == #{i}" do
+        FFI::Buffer.alloc_in(bufsize).put_int(offset, i).get_int(offset).should == i
+      end
+    end
+  end
+end
+describe "Buffer#put_uint" do
+  bufsize = 8
+  [ 0, 1, 128, 32767, 65535, 0xfee1dead, 0xcafebabe, 0xffffffff ].each do |i|
+    (0..bufsize-4).each do |offset|
+      it "put_uint(#{offset}, #{i}).get_uint(#{offset}) == #{i}" do
+        FFI::Buffer.alloc_in(bufsize).put_uint(offset, i).get_uint(offset).should == i
+      end
+    end
+  end
+end
+describe "Buffer#put_long" do
+  bufsize = 16
+  [0, 1, 128, 32767, 0x7ffffff ].each do |i|
+    (0..bufsize-FFI::Type::LONG.size).each do |offset|
+      it "put_long(#{offset}, #{i}).get_long(#{offset}) == #{i}" do
+        FFI::Buffer.alloc_in(bufsize).put_long(offset, i).get_long(offset).should == i
+      end
+    end
+  end
+end
+describe "Buffer#put_ulong" do
+  bufsize = 16
+  [ 0, 1, 128, 32767, 65535, 0xfee1dead, 0xcafebabe, 0xffffffff ].each do |i|
+    (0..bufsize-FFI::Type::LONG.size).each do |offset|
+      it "put_ulong(#{offset}, #{i}).get_ulong(#{offset}) == #{i}" do
+        FFI::Buffer.alloc_in(bufsize).put_ulong(offset, i).get_ulong(offset).should == i
+      end
+    end
+  end
+end
+describe "Buffer#put_long_long" do
+  bufsize = 16
+  [0, 1, 128, 32767, 0x7ffffffffffffff ].each do |i|
+    (0..bufsize-8).each do |offset|
+      it "put_long_long(#{offset}, #{i}).get_long_long(#{offset}) == #{i}" do
+        FFI::Buffer.alloc_in(bufsize).put_long_long(offset, i).get_long_long(offset).should == i
+      end
+    end
+  end
+end
+describe "Buffer#put_ulong_long" do
+  bufsize = 16
+  [ 0, 1, 128, 32767, 65535, 0xdeadcafebabe, 0x7fffffffffffffff ].each do |i|
+    (0..bufsize-8).each do |offset|
+      it "put_ulong_long(#{offset}, #{i}).get_ulong_long(#{offset}) == #{i}" do
+        FFI::Buffer.alloc_in(bufsize).put_ulong_long(offset, i).get_ulong_long(offset).should == i
+      end
+    end
+  end
+end
+describe "Reading/Writing binary strings" do
+  it "Buffer#put_bytes" do
+    str = "hello\0world"
+    buf = FFI::Buffer.new 1024
+    buf.put_bytes(0, str);
+    s2 = buf.get_bytes(0, 11);
+    s2.should == str
+  end
+  it "Buffer#put_bytes with index and length" do
+    str = "hello\0world"
+    buf = FFI::Buffer.new 1024
+    buf.put_bytes(0, str, 5, 6);
+    s2 = buf.get_bytes(0, 6);
+    s2.should == str[5..-1]
+  end
+  it "Buffer#put_bytes with only index" do
+    str = "hello\0world"
+    buf = FFI::Buffer.new 1024
+    buf.put_bytes(0, str, 5);
+    s2 = buf.get_bytes(0, 6);
+    s2.should == str[5..-1]
+  end
+  it "Buffer#put_bytes with index > str.length" do
+    str = "hello\0world"
+    buf = FFI::Buffer.new 1024
+    lambda { buf.put_bytes(0, str, 12); }.should raise_error
+  end
+  it "Buffer#put_bytes with length > str.length" do
+    str = "hello\0world"
+    buf = FFI::Buffer.new 1024
+    lambda { buf.put_bytes(0, str, 0, 12); }.should raise_error
+  end
+   it "Buffer#put_bytes with negative index" do
+    str = "hello\0world"
+    buf = FFI::Buffer.new 1024
+    lambda { buf.put_bytes(0, str, -1, 12); }.should raise_error
+   end
+
+  it "Buffer#write_bytes" do
+    str = "hello\0world"
+    buf = FFI::Buffer.new 1024
+    buf.write_bytes(str)
+    s2 = buf.get_bytes(0, 11)
+    s2.should == str
+  end
+  it "Buffer#write_bytes with index and length" do
+    str = "hello\0world"
+    buf = FFI::Buffer.new 1024
+    buf.write_bytes(str, 5, 6)
+    s2 = buf.get_bytes(0, 6)
+    s2.should == str[5..-1]
+  end
+  it "Buffer#write_bytes with only index" do
+    str = "hello\0world"
+    buf = FFI::Buffer.new 1024
+    buf.write_bytes(str, 5)
+    s2 = buf.get_bytes(0, 6)
+    s2.should == str[5..-1]
+  end
+  it "Buffer#write_bytes with index > str.length" do
+    str = "hello\0world"
+    buf = FFI::Buffer.new 1024
+    lambda { buf.write_bytes(str, 12) }.should raise_error
+  end
+  it "Buffer#put_bytes with length > str.length" do
+    str = "hello\0world"
+    buf = FFI::Buffer.new 1024
+    lambda { buf.put_bytes(0, str, 0, 12) }.should raise_error
+  end
+   it "Buffer#write_bytes with negative index" do
+    str = "hello\0world"
+    buf = FFI::Buffer.new 1024
+    lambda { buf.write_bytes(str, -1, 12) }.should raise_error
+  end
+end
+describe "Reading/Writing ascii strings" do
+  it "Buffer#put_string with string containing zero byte" do
+    str = "hello\0world"
+    buf = FFI::Buffer.new 1024
+    buf.put_string(0, str);
+    s2 = buf.get_bytes(0, 11);
+    s2.should == str
+  end
+  it "Buffer#get_string with string containing zero byte" do
+    str = "hello\0world"
+    buf = FFI::Buffer.new 1024
+    buf.put_bytes(0, str);
+    s2 = buf.get_string(0, 11);
+    s2.should == "hello"
+  end
+  it "Buffer#put_string without length should NUL terminate" do
+    str = "hello"
+    buf = FFI::Buffer.new 1024
+    buf.put_string(0, str);
+    s2 = buf.get_bytes(0, 6);
+    s2.should == "hello\0"
+  end
+end
+describe "Buffer#put_pointer" do
+  it "put_pointer(0, p).get_pointer(0) == p" do
+    p = FFI::MemoryPointer.new :ulong_long
+    p.put_uint(0, 0xdeadbeef)
+    buf = FFI::Buffer.alloc_inout 8
+    p2 = buf.put_pointer(0, p).get_pointer(0)
+    p2.should_not be_nil
+    p2.should == p
+    p2.get_uint(0).should == 0xdeadbeef
+  end
+end
+describe "Buffer#size" do
+  it "should return size" do
+    buf = FFI::Buffer.new 14
+    buf.size.should == 14
+  end
+end
+
+describe "Buffer#initialize" do
+  it "with block should execute block" do
+    block_executed = false
+    FFI::Buffer.new(:pointer) do |ptr|
+      block_executed = true
+    end
+    block_executed.should be_true
+  end
+end

data/spec/ffi/callback_spec.rb

@@ -0,0 +1,667 @@
+#
+# This file is part of ruby-ffi.
+# For licensing, see LICENSE.SPECS
+#
+
+require File.expand_path(File.join(File.dirname(__FILE__), "spec_helper"))
+
+describe "Callback" do
+#  module LibC
+#    extend FFI::Library
+#    callback :qsort_cmp, [ :pointer, :pointer ], :int
+#    attach_function :qsort, [ :pointer, :int, :int, :qsort_cmp ], :int
+#  end
+#  it "arguments get passed correctly" do
+#    p = MemoryPointer.new(:int, 2)
+#    p.put_array_of_int32(0, [ 1 , 2 ])
+#    args = []
+#    cmp = proc do |p1, p2| args.push(p1.get_int(0)); args.push(p2.get_int(0)); 0; end
+#    # this is a bit dodgey, as it relies on qsort passing the args in order
+#    LibC.qsort(p, 2, 4, cmp)
+#    args.should == [ 1, 2 ]
+#  end
+#
+#  it "Block can be substituted for Callback as last argument" do
+#    p = MemoryPointer.new(:int, 2)
+#    p.put_array_of_int32(0, [ 1 , 2 ])
+#    args = []
+#    # this is a bit dodgey, as it relies on qsort passing the args in order
+#    LibC.qsort(p, 2, 4) do |p1, p2|
+#      args.push(p1.get_int(0))
+#      args.push(p2.get_int(0))
+#      0
+#    end
+#    args.should == [ 1, 2 ]
+#  end
+  module LibTest
+    extend FFI::Library
+    ffi_lib TestLibrary::PATH
+    class S8F32S32 < FFI::Struct
+      layout :s8, :char, :f32, :float, :s32, :int
+    end
+
+    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 :cbVrZ, [], :bool
+    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
+    callback :cbVrT, [ ], S8F32S32.by_value
+    callback :cbTrV, [ S8F32S32.by_value ], :void
+    callback :cbYrV, [ S8F32S32.ptr ], :void
+    callback :cbVrY, [ ], S8F32S32.ptr
+
+    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 :testCallbackVrZ, :testClosureVrZ, [ :cbVrZ ], :bool
+    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 :testCallbackVrY, :testClosureVrP, [ :cbVrY ], S8F32S32.ptr
+    attach_function :testCallbackVrT, :testClosureVrT, [ :cbVrT ], S8F32S32.by_value
+    attach_function :testCallbackTrV, :testClosureTrV, [ :cbTrV, S8F32S32.ptr ], :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
+
+  end
+  it "returning :char (0)" do
+    LibTest.testCallbackVrS8 { 0 }.should == 0
+  end
+  it "returning :char (127)" do
+    LibTest.testCallbackVrS8 { 127 }.should == 127
+  end
+  it "returning :char (-128)" do
+    LibTest.testCallbackVrS8 { -128 }.should == -128
+  end
+  # test wrap around
+  it "returning :char (128)" do
+    LibTest.testCallbackVrS8 { 128 }.should == -128
+  end
+  it "returning :char (255)" do
+    LibTest.testCallbackVrS8 { 0xff }.should == -1
+  end
+  it "returning :uchar (0)" do
+    LibTest.testCallbackVrU8 { 0 }.should == 0
+  end
+  it "returning :uchar (0xff)" do
+    LibTest.testCallbackVrU8 { 0xff }.should == 0xff
+  end
+  it "returning :uchar (-1)" do
+    LibTest.testCallbackVrU8 { -1 }.should == 0xff
+  end
+  it "returning :uchar (128)" do
+    LibTest.testCallbackVrU8 { 128 }.should == 128
+  end
+  it "returning :uchar (-128)" do
+    LibTest.testCallbackVrU8 { -128 }.should == 128
+  end
+  it "returning :short (0)" do
+    LibTest.testCallbackVrS16 { 0 }.should == 0
+  end
+  it "returning :short (0x7fff)" do
+    LibTest.testCallbackVrS16 { 0x7fff }.should == 0x7fff
+  end
+  # test wrap around
+  it "returning :short (0x8000)" do
+    LibTest.testCallbackVrS16 { 0x8000 }.should == -0x8000
+  end
+  it "returning :short (0xffff)" do
+    LibTest.testCallbackVrS16 { 0xffff }.should == -1
+  end
+  it "returning :ushort (0)" do
+    LibTest.testCallbackVrU16 { 0 }.should == 0
+  end
+  it "returning :ushort (0x7fff)" do
+    LibTest.testCallbackVrU16 { 0x7fff }.should == 0x7fff
+  end
+  it "returning :ushort (0x8000)" do
+    LibTest.testCallbackVrU16 { 0x8000 }.should == 0x8000
+  end
+  it "returning :ushort (0xffff)" do
+    LibTest.testCallbackVrU16 { 0xffff }.should == 0xffff
+  end
+  it "returning :ushort (-1)" do
+    LibTest.testCallbackVrU16 { -1 }.should == 0xffff
+  end
+  it "returning :int (0)" do
+    LibTest.testCallbackVrS32 { 0 }.should == 0
+  end
+  it "returning :int (0x7fffffff)" do
+    LibTest.testCallbackVrS32 { 0x7fffffff }.should == 0x7fffffff
+  end
+  # test wrap around
+  it "returning :int (-0x80000000)" do
+    LibTest.testCallbackVrS32 { -0x80000000 }.should == -0x80000000
+  end
+  it "returning :int (-1)" do
+    LibTest.testCallbackVrS32 { -1 }.should == -1
+  end
+  it "returning :uint (0)" do
+    LibTest.testCallbackVrU32 { 0 }.should == 0
+  end
+  it "returning :uint (0x7fffffff)" do
+    LibTest.testCallbackVrU32 { 0x7fffffff }.should == 0x7fffffff
+  end
+  # test wrap around
+  it "returning :uint (0x80000000)" do
+    LibTest.testCallbackVrU32 { 0x80000000 }.should == 0x80000000
+  end
+  it "returning :uint (0xffffffff)" do
+    LibTest.testCallbackVrU32 { 0xffffffff }.should == 0xffffffff
+  end
+  it "returning :uint (-1)" do
+    LibTest.testCallbackVrU32 { -1 }.should == 0xffffffff
+  end
+  it "returning :long (0)" do
+    LibTest.testCallbackVrL { 0 }.should == 0
+  end
+  it "returning :long (0x7fffffff)" do
+    LibTest.testCallbackVrL { 0x7fffffff }.should == 0x7fffffff
+  end
+  # test wrap around
+  it "returning :long (-0x80000000)" do
+    LibTest.testCallbackVrL { -0x80000000 }.should == -0x80000000
+  end
+  it "returning :long (-1)" do
+    LibTest.testCallbackVrL { -1 }.should == -1
+  end
+  it "returning :ulong (0)" do
+    LibTest.testCallbackVrUL { 0 }.should == 0
+  end
+  it "returning :ulong (0x7fffffff)" do
+    LibTest.testCallbackVrUL { 0x7fffffff }.should == 0x7fffffff
+  end
+  # test wrap around
+  it "returning :ulong (0x80000000)" do
+    LibTest.testCallbackVrUL { 0x80000000 }.should == 0x80000000
+  end
+  it "returning :ulong (0xffffffff)" do
+    LibTest.testCallbackVrUL { 0xffffffff }.should == 0xffffffff
+  end
+  it "Callback returning :ulong (-1)" do
+    if FFI::Platform::LONG_SIZE == 32
+      LibTest.testCallbackVrUL { -1 }.should == 0xffffffff
+    else
+      LibTest.testCallbackVrUL { -1 }.should == 0xffffffffffffffff
+    end
+  end
+  it "returning :long_long (0)" do
+    LibTest.testCallbackVrS64 { 0 }.should == 0
+  end
+  it "returning :long_long (0x7fffffffffffffff)" do
+    LibTest.testCallbackVrS64 { 0x7fffffffffffffff }.should == 0x7fffffffffffffff
+  end
+  # test wrap around
+  it "returning :long_long (-0x8000000000000000)" do
+    LibTest.testCallbackVrS64 { -0x8000000000000000 }.should == -0x8000000000000000
+  end
+  it "returning :long_long (-1)" do
+    LibTest.testCallbackVrS64 { -1 }.should == -1
+  end
+  it "returning bool" do
+    LibTest.testCallbackVrZ { true }.should be_true
+  end
+  it "returning :pointer (nil)" do
+    LibTest.testCallbackVrP { nil }.null?.should be_true
+  end
+  it "returning :pointer (MemoryPointer)" do
+    p = FFI::MemoryPointer.new :long
+    LibTest.testCallbackVrP { p }.should == p
+  end
+
+
+  it "returning struct by value" do
+    s = LibTest::S8F32S32.new
+    s[:s8] = 0x12
+    s[:s32] = 0x1eefbeef
+    s[:f32] = 1.234567
+    ret = LibTest.testCallbackVrT { s }
+    ret[:s8].should == s[:s8]
+    ret[:f32].should == s[:f32]
+    ret[:s32].should == s[:s32]
+
+  end
+
+  it "struct by value parameter" do
+    s = LibTest::S8F32S32.new
+    s[:s8] = 0x12
+    s[:s32] = 0x1eefbeef
+    s[:f32] = 1.234567
+    s2 = LibTest::S8F32S32.new
+    LibTest.testCallbackTrV(s) do |struct|
+      s2[:s8] = struct[:s8]
+      s2[:f32] = struct[:f32]
+      s2[:s32] = struct[:s32]
+    end
+  end
+
+  
+  it "global variable" do
+    proc = Proc.new { 0x1e }
+    LibTest.cbVrS8 = proc
+    LibTest.testGVarCallbackVrS8(LibTest.pVrS8).should == 0x1e
+  end
+
+  describe "When the callback is considered optional by the underlying library" do
+    it "should handle receiving 'nil' in place of the closure" do
+      LibTest.testOptionalCallbackCrV(nil, 13)
+    end
+  end
+
+  describe 'when inlined' do
+    it 'could be anonymous' do
+      module LibTest
+        extend FFI::Library
+        ffi_lib TestLibrary::PATH
+        attach_function :testAnonymousCallbackVrS8, :testClosureVrB, [ callback([ ], :char) ], :char
+      end
+      LibTest.testAnonymousCallbackVrS8 { 0 }.should == 0
+    end
+  end
+
+  describe "as return value" do
+
+    it "should not blow up when a callback is defined that returns a callback" do
+      module LibTest
+        extend FFI::Library
+        ffi_lib TestLibrary::PATH
+        callback :cb_return_type_1, [ :short ], :short
+        callback :cb_lookup_1, [ :short ], :cb_return_type_1
+        attach_function :testReturnsCallback_1, :testReturnsClosure, [ :cb_lookup_1, :short ], :cb_return_type_1
+      end      
+    end
+
+    it "should return a callback" do
+      module LibTest
+        extend FFI::Library
+        ffi_lib TestLibrary::PATH
+        callback :cb_return_type, [ :int ], :int
+        callback :cb_lookup, [ ], :cb_return_type
+        attach_function :testReturnsCallback, :testReturnsClosure, [ :cb_lookup, :int ], :int
+      end      
+
+      lookup_proc_called = false
+      return_proc_called = false
+
+      return_proc = Proc.new do |a|
+        return_proc_called = true
+        a * 2
+      end
+      lookup_proc = Proc.new do
+        lookup_proc_called = true
+        return_proc
+      end
+
+      val = LibTest.testReturnsCallback(lookup_proc, 0x1234)
+      val.should == 0x1234 * 2
+      lookup_proc_called.should be_true
+      return_proc_called.should be_true
+    end
+
+    it "should return a method callback" do
+      module LibTest
+        extend FFI::Library
+        ffi_lib TestLibrary::PATH
+        callback :cb_return_type, [ :int ], :int
+        callback :cb_lookup, [ ], :cb_return_type
+        attach_function :testReturnsCallback_2, :testReturnsClosure, [ :cb_lookup, :int ], :int
+      end
+      module MethodCallback
+        def self.lookup
+          method(:perform)
+        end
+        def self.perform num
+          num * 2
+        end
+      end
+
+      LibTest.testReturnsCallback_2(MethodCallback.method(:lookup), 0x1234).should == 0x2468
+    end
+
+    it 'should not blow up when a callback takes a callback as argument' do
+      module LibTest
+        extend FFI::Library
+        ffi_lib TestLibrary::PATH
+        callback :cb_argument, [ :int ], :int
+        callback :cb_with_cb_argument, [ :cb_argument, :int ], :int
+        attach_function :testCallbackAsArgument_2, :testArgumentClosure, [ :cb_with_cb_argument, :int ], :int
+      end   
+    end
+    it 'should be able to use the callback argument' do
+      module LibTest
+        extend FFI::Library
+        ffi_lib TestLibrary::PATH
+        callback :cb_argument, [ :int ], :int
+        callback :cb_with_cb_argument, [ :cb_argument, :int ], :int
+        attach_function :testCallbackAsArgument, :testArgumentClosure, [ :cb_with_cb_argument, :cb_argument, :int ], :int
+      end   
+      callback_arg_called = false
+      callback_with_callback_arg_called = false         
+      callback_arg = Proc.new do |val|
+        callback_arg_called = true
+        val * 2
+      end
+      callback_with_callback_arg = Proc.new do |cb, val|
+        callback_with_callback_arg_called = true
+        cb.call(val)
+      end
+      val = LibTest.testCallbackAsArgument(callback_with_callback_arg, callback_arg, 0xff1)
+      val.should == 0xff1 * 2
+      callback_arg_called.should be_true
+      callback_with_callback_arg_called.should be_true         
+    end
+    it 'function returns callable object' do
+      module LibTest
+        extend FFI::Library
+        ffi_lib TestLibrary::PATH
+        callback :funcptr, [ :int ], :int
+        attach_function :testReturnsFunctionPointer, [  ], :funcptr
+      end
+      f = LibTest.testReturnsFunctionPointer
+      f.call(3).should == 6
+    end
+  end
+
+end
+
+
+describe "Callback with " do
+  #
+  # Test callbacks that take an argument, returning void
+  #
+  module LibTest
+    extend FFI::Library
+    ffi_lib TestLibrary::PATH
+
+    class S8F32S32 < FFI::Struct
+      layout :s8, :char, :f32, :float, :s32, :int
+    end
+
+    callback :cbS8rV, [ :char ], :void
+    callback :cbU8rV, [ :uchar ], :void
+    callback :cbS16rV, [ :short ], :void
+    callback :cbU16rV, [ :ushort ], :void
+
+    callback :cbZrV, [ :bool ], :void
+    callback :cbS32rV, [ :int ], :void
+    callback :cbU32rV, [ :uint ], :void
+
+    callback :cbLrV, [ :long ], :void
+    callback :cbULrV, [ :ulong ], :void
+    callback :cbArV, [ :string ], :void
+    callback :cbPrV, [ :pointer], :void
+    callback :cbYrV, [ S8F32S32.ptr ], :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 :testCallbackZrV, :testClosureZrV, [ :cbZrV, :bool ], :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
+    attach_function :testCallbackArV, :testClosurePrV, [ :cbArV, :string ], :void
+    attach_function :testCallbackPrV, :testClosurePrV, [ :cbPrV, :pointer], :void
+    attach_function :testCallbackYrV, :testClosurePrV, [ :cbYrV, S8F32S32.in ], :void
+  end
+  it "function with Callback plus another arg should raise error if no arg given" do
+    lambda { LibTest.testCallbackCrV { |*a| }}.should raise_error
+  end
+  it ":char (0) argument" do
+    v = 0xdeadbeef
+    LibTest.testCallbackCrV(0) { |i| v = i }
+    v.should == 0
+  end
+  it ":char (127) argument" do
+    v = 0xdeadbeef
+    LibTest.testCallbackCrV(127) { |i| v = i }
+    v.should == 127
+  end
+  it ":char (-128) argument" do
+    v = 0xdeadbeef
+    LibTest.testCallbackCrV(-128) { |i| v = i }
+    v.should == -128
+  end
+  it ":char (-1) argument" do
+    v = 0xdeadbeef
+    LibTest.testCallbackCrV(-1) { |i| v = i }
+    v.should == -1
+  end
+  it ":uchar (0) argument" do
+    v = 0xdeadbeef
+    LibTest.testCallbackU8rV(0) { |i| v = i }
+    v.should == 0
+  end
+  it ":uchar (127) argument" do
+    v = 0xdeadbeef
+    LibTest.testCallbackU8rV(127) { |i| v = i }
+    v.should == 127
+  end
+  it ":uchar (128) argument" do
+    v = 0xdeadbeef
+    LibTest.testCallbackU8rV(128) { |i| v = i }
+    v.should == 128
+  end
+  it ":uchar (255) argument" do
+    v = 0xdeadbeef
+    LibTest.testCallbackU8rV(255) { |i| v = i }
+    v.should == 255
+  end
+
+  it ":short (0) argument" do
+    v = 0xdeadbeef
+    LibTest.testCallbackSrV(0) { |i| v = i }
+    v.should == 0
+  end
+  it ":short (0x7fff) argument" do
+    v = 0xdeadbeef
+    LibTest.testCallbackSrV(0x7fff) { |i| v = i }
+    v.should == 0x7fff
+  end
+  it ":short (-0x8000) argument" do
+    v = 0xdeadbeef
+    LibTest.testCallbackSrV(-0x8000) { |i| v = i }
+    v.should == -0x8000
+  end
+  it ":short (-1) argument" do
+    v = 0xdeadbeef
+    LibTest.testCallbackSrV(-1) { |i| v = i }
+    v.should == -1
+  end
+  it ":ushort (0) argument" do
+    v = 0xdeadbeef
+    LibTest.testCallbackU16rV(0) { |i| v = i }
+    v.should == 0
+  end
+  it ":ushort (0x7fff) argument" do
+    v = 0xdeadbeef
+    LibTest.testCallbackU16rV(0x7fff) { |i| v = i }
+    v.should == 0x7fff
+  end
+  it ":ushort (0x8000) argument" do
+    v = 0xdeadbeef
+    LibTest.testCallbackU16rV(0x8000) { |i| v = i }
+    v.should == 0x8000
+  end
+  it ":ushort (0xffff) argument" do
+    v = 0xdeadbeef
+    LibTest.testCallbackU16rV(0xffff) { |i| v = i }
+    v.should == 0xffff
+  end
+  it ":bool (true) argument" do
+    v = false
+    LibTest.testCallbackZrV(true) { |i| v = i }
+    v.should be_true
+  end
+  it ":int (0) argument" do
+    v = 0xdeadbeef
+    LibTest.testCallbackIrV(0) { |i| v = i }
+    v.should == 0
+  end
+  it ":int (0x7fffffff) argument" do
+    v = 0xdeadbeef
+    LibTest.testCallbackIrV(0x7fffffff) { |i| v = i }
+    v.should == 0x7fffffff
+  end
+  it ":int (-0x80000000) argument" do
+    v = 0xdeadbeef
+    LibTest.testCallbackIrV(-0x80000000) { |i| v = i }
+    v.should == -0x80000000
+  end
+  it ":int (-1) argument" do
+    v = 0xdeadbeef
+    LibTest.testCallbackIrV(-1) { |i| v = i }
+    v.should == -1
+  end
+  it ":uint (0) argument" do
+    v = 0xdeadbeef
+    LibTest.testCallbackU32rV(0) { |i| v = i }
+    v.should == 0
+  end
+  it ":uint (0x7fffffff) argument" do
+    v = 0xdeadbeef
+    LibTest.testCallbackU32rV(0x7fffffff) { |i| v = i }
+    v.should == 0x7fffffff
+  end
+  it ":uint (0x80000000) argument" do
+    v = 0xdeadbeef
+    LibTest.testCallbackU32rV(0x80000000) { |i| v = i }
+    v.should == 0x80000000
+  end
+  it ":uint (0xffffffff) argument" do
+    v = 0xdeadbeef
+    LibTest.testCallbackU32rV(0xffffffff) { |i| v = i }
+    v.should == 0xffffffff
+  end
+  it ":long (0) argument" do
+    v = 0xdeadbeef
+    LibTest.testCallbackLrV(0) { |i| v = i }
+    v.should == 0
+  end
+  it ":long (0x7fffffff) argument" do
+    v = 0xdeadbeef
+    LibTest.testCallbackLrV(0x7fffffff) { |i| v = i }
+    v.should == 0x7fffffff
+  end
+  it ":long (-0x80000000) argument" do
+    v = 0xdeadbeef
+    LibTest.testCallbackLrV(-0x80000000) { |i| v = i }
+    v.should == -0x80000000
+  end
+  it ":long (-1) argument" do
+    v = 0xdeadbeef
+    LibTest.testCallbackLrV(-1) { |i| v = i }
+    v.should == -1
+  end
+  it ":ulong (0) argument" do
+    v = 0xdeadbeef
+    LibTest.testCallbackULrV(0) { |i| v = i }
+    v.should == 0
+  end
+  it ":ulong (0x7fffffff) argument" do
+    v = 0xdeadbeef
+    LibTest.testCallbackULrV(0x7fffffff) { |i| v = i }
+    v.should == 0x7fffffff
+  end
+  it ":ulong (0x80000000) argument" do
+    v = 0xdeadbeef
+    LibTest.testCallbackULrV(0x80000000) { |i| v = i }
+    v.should == 0x80000000
+  end
+  it ":ulong (0xffffffff) argument" do
+    v = 0xdeadbeef
+    LibTest.testCallbackULrV(0xffffffff) { |i| v = i }
+    v.should == 0xffffffff
+  end
+  it ":long_long (0) argument" do
+    v = 0xdeadbeef
+    LibTest.testCallbackLLrV(0) { |i| v = i }
+    v.should == 0
+  end
+  it ":long_long (0x7fffffffffffffff) argument" do
+    v = 0xdeadbeef
+    LibTest.testCallbackLLrV(0x7fffffffffffffff) { |i| v = i }
+    v.should == 0x7fffffffffffffff
+  end
+  it ":long_long (-0x8000000000000000) argument" do
+    v = 0xdeadbeef
+    LibTest.testCallbackLLrV(-0x8000000000000000) { |i| v = i }
+    v.should == -0x8000000000000000
+  end
+  it ":long_long (-1) argument" do
+    v = 0xdeadbeef
+    LibTest.testCallbackLLrV(-1) { |i| v = i }
+    v.should == -1
+  end
+  it ":string argument" do
+    v = nil
+    LibTest.testCallbackArV("Hello, World") { |i| v = i }
+    v.should == "Hello, World"
+  end
+  it ":string (nil) argument" do
+    v = "Hello, World"
+    LibTest.testCallbackArV(nil) { |i| v = i }
+    v.should be_nil
+  end
+  it ":pointer argument" do
+    v = nil
+    magic = FFI::Pointer.new(0xdeadbeef)
+    LibTest.testCallbackPrV(magic) { |i| v = i }
+    v.should == magic
+  end
+  it ":pointer (nil) argument" do
+    v = "Hello, World"
+    LibTest.testCallbackPrV(nil) { |i| v = i }
+    v.should == FFI::Pointer::NULL
+  end
+  it "struct by reference argument" do
+    v = nil
+    magic = LibTest::S8F32S32.new
+    LibTest.testCallbackYrV(magic) { |i| v = i }
+    v.class.should == magic.class
+    v.pointer == magic.pointer
+  end
+
+  it "struct by reference argument with nil value" do
+    v = LibTest::S8F32S32.new
+    LibTest.testCallbackYrV(nil) { |i| v = i }
+    v.is_a?(FFI::Struct).should be_true
+    v.pointer.should == FFI::Pointer::NULL
+  end
+
+  it "varargs parameters are rejected" do
+    lambda {
+      Module.new do
+        extend FFI::Library
+        ffi_lib TestLibrary::PATH
+        callback :cbVrL, [ :varargs ], :long
+      end
+    }.should raise_error(ArgumentError)
+  end
+
+end