remogatto-ffi 0.5.0

data/spec/ffi/enum_spec.rb

@@ -0,0 +1,164 @@
+require File.expand_path(File.join(File.dirname(__FILE__), "spec_helper"))
+
+module TestEnum0
+  extend FFI::Library
+end
+
+module TestEnum1
+  extend FFI::Library
+  ffi_lib TestLibrary::PATH
+
+  enum [:c1, :c2, :c3, :c4]
+  enum [:c5, 42, :c6, :c7, :c8]
+  enum [:c9, 42, :c10, :c11, 4242, :c12]
+  enum [:c13, 42, :c14, 4242, :c15, 424242, :c16, 42424242]
+  
+  attach_function :test_untagged_enum, [:int], :int
+end
+
+module TestEnum3
+  extend FFI::Library
+  ffi_lib TestLibrary::PATH
+
+  enum :enum_type1, [:c1, :c2, :c3, :c4]
+  enum :enum_type2, [:c5, 42, :c6, :c7, :c8]
+  enum :enum_type3, [:c9, 42, :c10, :c11, 4242, :c12]
+  enum :enum_type4, [:c13, 42, :c14, 4242, :c15, 424242, :c16, 42424242]
+
+  attach_function :test_tagged_typedef_enum1, [:enum_type1], :enum_type1
+  attach_function :test_tagged_typedef_enum2, [:enum_type2], :enum_type2
+  attach_function :test_tagged_typedef_enum3, [:enum_type3], :enum_type3
+  attach_function :test_tagged_typedef_enum4, [:enum_type4], :enum_type4
+end
+
+describe "A library with no enum defined" do
+  it "returns nil when asked for an enum" do
+    TestEnum0.enum_type(:foo).should == nil
+  end
+end
+
+describe "An untagged enum" do
+  it "constants can be used as function parameters and return value" do
+    TestEnum1.test_untagged_enum(:c1).should == 0
+    TestEnum1.test_untagged_enum(:c2).should == 1
+    TestEnum1.test_untagged_enum(:c3).should == 2
+    TestEnum1.test_untagged_enum(:c4).should == 3
+    TestEnum1.test_untagged_enum(:c5).should == 42
+    TestEnum1.test_untagged_enum(:c6).should == 43
+    TestEnum1.test_untagged_enum(:c7).should == 44
+    TestEnum1.test_untagged_enum(:c8).should == 45
+    TestEnum1.test_untagged_enum(:c9).should == 42
+    TestEnum1.test_untagged_enum(:c10).should == 43
+    TestEnum1.test_untagged_enum(:c11).should == 4242
+    TestEnum1.test_untagged_enum(:c12).should == 4243
+    TestEnum1.test_untagged_enum(:c13).should == 42
+    TestEnum1.test_untagged_enum(:c14).should == 4242
+    TestEnum1.test_untagged_enum(:c15).should == 424242
+    TestEnum1.test_untagged_enum(:c16).should == 42424242
+  end
+end
+
+describe "A tagged typedef enum" do
+  it "is accessible through its tag" do
+    TestEnum3.enum_type(:enum_type1).should_not == nil
+    TestEnum3.enum_type(:enum_type2).should_not == nil
+    TestEnum3.enum_type(:enum_type3).should_not == nil
+    TestEnum3.enum_type(:enum_type4).should_not == nil
+  end
+  it "contains enum constants" do
+    TestEnum3.enum_type(:enum_type1).symbols.length.should == 4
+    TestEnum3.enum_type(:enum_type2).symbols.length.should == 4
+    TestEnum3.enum_type(:enum_type3).symbols.length.should == 4
+    TestEnum3.enum_type(:enum_type4).symbols.length.should == 4
+  end
+  it "constants can be used as function parameters and return value" do
+    TestEnum3.test_tagged_typedef_enum1(:c1).should == :c1
+    TestEnum3.test_tagged_typedef_enum1(:c2).should == :c2
+    TestEnum3.test_tagged_typedef_enum1(:c3).should == :c3
+    TestEnum3.test_tagged_typedef_enum1(:c4).should == :c4
+    TestEnum3.test_tagged_typedef_enum2(:c5).should == :c5
+    TestEnum3.test_tagged_typedef_enum2(:c6).should == :c6
+    TestEnum3.test_tagged_typedef_enum2(:c7).should == :c7
+    TestEnum3.test_tagged_typedef_enum2(:c8).should == :c8
+    TestEnum3.test_tagged_typedef_enum3(:c9).should == :c9
+    TestEnum3.test_tagged_typedef_enum3(:c10).should == :c10
+    TestEnum3.test_tagged_typedef_enum3(:c11).should == :c11
+    TestEnum3.test_tagged_typedef_enum3(:c12).should == :c12
+    TestEnum3.test_tagged_typedef_enum4(:c13).should == :c13
+    TestEnum3.test_tagged_typedef_enum4(:c14).should == :c14
+    TestEnum3.test_tagged_typedef_enum4(:c15).should == :c15
+    TestEnum3.test_tagged_typedef_enum4(:c16).should == :c16
+  end
+end
+
+describe "All enums" do
+  it "have autonumbered constants when defined with names only" do
+    TestEnum1.enum_value(:c1).should == 0
+    TestEnum1.enum_value(:c2).should == 1
+    TestEnum1.enum_value(:c3).should == 2
+    TestEnum1.enum_value(:c4).should == 3
+
+    TestEnum3.enum_value(:c1).should == 0
+    TestEnum3.enum_value(:c2).should == 1
+    TestEnum3.enum_value(:c3).should == 2
+    TestEnum3.enum_value(:c4).should == 3
+  end
+  it "can have an explicit first constant and autonumbered subsequent constants" do
+    TestEnum1.enum_value(:c5).should == 42
+    TestEnum1.enum_value(:c6).should == 43
+    TestEnum1.enum_value(:c7).should == 44
+    TestEnum1.enum_value(:c8).should == 45
+
+    TestEnum3.enum_value(:c5).should == 42
+    TestEnum3.enum_value(:c6).should == 43
+    TestEnum3.enum_value(:c7).should == 44
+    TestEnum3.enum_value(:c8).should == 45
+  end
+  it "can have a mix of explicit and autonumbered constants" do
+    TestEnum1.enum_value(:c9).should  == 42
+    TestEnum1.enum_value(:c10).should == 43
+    TestEnum1.enum_value(:c11).should == 4242
+    TestEnum1.enum_value(:c12).should == 4243
+
+    TestEnum3.enum_value(:c9).should  == 42
+    TestEnum3.enum_value(:c10).should == 43
+    TestEnum3.enum_value(:c11).should == 4242
+    TestEnum3.enum_value(:c12).should == 4243
+  end
+  it "can have all its constants explicitely valued" do
+    TestEnum1.enum_value(:c13).should == 42
+    TestEnum1.enum_value(:c14).should == 4242
+    TestEnum1.enum_value(:c15).should == 424242
+    TestEnum1.enum_value(:c16).should == 42424242
+    
+    TestEnum3.enum_value(:c13).should == 42
+    TestEnum3.enum_value(:c14).should == 4242
+    TestEnum3.enum_value(:c15).should == 424242
+    TestEnum3.enum_value(:c16).should == 42424242
+  end
+  it "return the constant corresponding to a specific value" do
+    enum = TestEnum3.enum_type(:enum_type1)
+    enum[0].should == :c1
+    enum[1].should == :c2
+    enum[2].should == :c3
+    enum[3].should == :c4
+
+    enum = TestEnum3.enum_type(:enum_type2)
+    enum[42].should == :c5
+    enum[43].should == :c6
+    enum[44].should == :c7
+    enum[45].should == :c8
+
+    enum = TestEnum3.enum_type(:enum_type3)
+    enum[42].should == :c9
+    enum[43].should == :c10
+    enum[4242].should == :c11
+    enum[4243].should == :c12
+
+    enum = TestEnum3.enum_type(:enum_type4)
+    enum[42].should == :c13
+    enum[4242].should == :c14
+    enum[424242].should == :c15
+    enum[42424242].should == :c16
+  end
+end

data/spec/ffi/errno_spec.rb

@@ -0,0 +1,13 @@
+require File.expand_path(File.join(File.dirname(__FILE__), "spec_helper"))
+describe "FFI.errno" do
+  module LibTest
+    extend FFI::Library
+    ffi_lib TestLibrary::PATH
+    attach_function :setLastError, [ :int ], :void
+  end
+  it "FFI.errno contains errno from last function" do
+    LibTest.setLastError(0)
+    LibTest.setLastError(0x12345678)
+    FFI.errno.should == 0x12345678
+  end
+end

data/spec/ffi/function_spec.rb

@@ -0,0 +1,47 @@
+require File.expand_path(File.join(File.dirname(__FILE__), "spec_helper"))
+
+describe FFI::Function do
+  module LibTest
+    extend FFI::Library
+    ffi_lib TestLibrary::PATH
+    attach_function :testFunctionAdd, [:int, :int, :pointer], :int
+    attach_function :testAddPointer, [], :pointer
+  end
+  it 'is initialized with a signature and a block' do
+    FFI::Function.new(:int, []) { }
+  end
+  it 'raises an error when passing a wrong signature' do
+    lambda { FFI::Function.new([], :int).new { } }.should raise_error TypeError 
+  end
+  it 'returns a native pointer' do
+    FFI::Function.new(:int, []) { }.kind_of? FFI::Pointer
+  end
+  it 'can be used as callback from C passing to it a block' do
+    function_add = FFI::Function.new(:int, [:int, :int]) { |a, b| a + b }
+    LibTest.testFunctionAdd(10, 10, function_add).should == 20
+  end
+  it 'can be used as callback from C passing to it a Proc object' do
+    function_add = FFI::Function.new(:int, [:int, :int], Proc.new { |a, b| a + b })
+    LibTest.testFunctionAdd(10, 10, function_add).should == 20
+  end
+  it 'can be used to wrap an existing function pointer' do
+    FFI::Function.new(:int, [:int, :int], LibTest.testAddPointer).call(10, 10).should == 20
+  end
+  it 'can be attached to a module' do
+    module Foo; end
+    fp = FFI::Function.new(:int, [:int, :int], LibTest.testAddPointer)
+    fp.attach(Foo, 'add')
+    Foo.add(10, 10).should == 20
+  end
+  it 'can be used to extend an object' do
+    fp = FFI::Function.new(:int, [:int, :int], LibTest.testAddPointer)
+    foo = Object.new
+    class << foo
+      def singleton_class
+        class << self; self; end
+      end
+    end
+    fp.attach(foo.singleton_class, 'add')
+    foo.add(10, 10).should == 20    
+  end
+end

data/spec/ffi/library_spec.rb

@@ -0,0 +1,144 @@
+require File.expand_path(File.join(File.dirname(__FILE__), "spec_helper"))
+describe "Library" do
+  it "attach_function with no library specified" do
+    lambda {
+      Module.new do |m|
+        m.extend FFI::Library
+        attach_function :getpid, [ ], :uint
+      end
+    }.should_not raise_error
+  end
+  it "attach_function :getpid from this process" do
+    lambda {
+      Module.new do |m|
+        m.extend FFI::Library
+        attach_function :getpid, [ ], :uint
+      end.getpid.should == Process.pid
+    }.should_not raise_error
+  end
+  it "attach_function :getpid from [ 'c', 'libc.so.6'] " do
+    lambda {
+      Module.new do |m|
+        m.extend FFI::Library
+        ffi_lib 'c', 'libc.so.6'
+        attach_function :getpid, [ ], :uint
+      end.getpid.should == Process.pid
+    }.should_not raise_error
+  end
+  it "attach_function :getpid from [ 'libc.so.6', 'c' ] " do
+    lambda {
+      Module.new do |m|
+        m.extend FFI::Library
+        ffi_lib 'libc.so.6', 'c'
+        attach_function :getpid, [ ], :uint
+      end.getpid.should == Process.pid
+    }.should_not raise_error
+  end
+  it "attach_function :getpid from [ 'libfubar.so.0xdeadbeef', nil, 'c' ] " do
+    lambda {
+      Module.new do |m|
+        m.extend FFI::Library
+        ffi_lib 'libfubar.so.0xdeadbeef', nil, 'c'
+        attach_function :getpid, [ ], :uint
+      end.getpid.should == Process.pid
+    }.should_not raise_error
+  end
+  it "attach_function :getpid from [ 'libfubar.so.0xdeadbeef' ] " do
+    lambda {
+      Module.new do |m|
+        m.extend FFI::Library
+        ffi_lib 'libfubar.so.0xdeadbeef'
+        attach_function :getpid, [ ], :uint
+      end.getpid.should == Process.pid
+    }.should raise_error(LoadError)
+  end
+  def gvar_lib(name, type)
+    Module.new do |m|
+      m.extend FFI::Library
+      ffi_lib TestLibrary::PATH
+      attach_variable :gvar, "gvar_#{name}", type
+      attach_function :get, "gvar_#{name}_get", [], type
+      attach_function :set, "gvar_#{name}_set", [ type ], :void
+    end
+  end
+  def gvar_test(name, type, val)
+    lib = gvar_lib(name, type)
+    lib.set(val)
+    lib.gvar.should == val
+    lib.set(0)
+    lib.gvar = val
+    lib.get.should == val
+  end
+  [ 0, 127, -128, -1 ].each do |i|
+    it ":char variable" do
+      gvar_test("s8", :char, i)
+    end
+  end
+  [ 0, 0x7f, 0x80, 0xff ].each do |i|
+    it ":uchar variable" do
+      gvar_test("u8", :uchar, i)
+    end
+  end
+  [ 0, 0x7fff, -0x8000, -1 ].each do |i|
+    it ":short variable" do
+      gvar_test("s16", :short, i)
+    end
+  end
+  [ 0, 0x7fff, 0x8000, 0xffff ].each do |i|
+    it ":ushort variable" do
+      gvar_test("u16", :ushort, i)
+    end
+  end
+  [ 0, 0x7fffffff, -0x80000000, -1 ].each do |i|
+    it ":int variable" do
+      gvar_test("s32", :int, i)
+    end
+  end
+  [ 0, 0x7fffffff, 0x80000000, 0xffffffff ].each do |i|
+    it ":uint variable" do
+      gvar_test("u32", :uint, i)
+    end
+  end
+  [ 0, 0x7fffffffffffffff, -0x8000000000000000, -1 ].each do |i|
+    it ":long_long variable" do
+      gvar_test("s64", :long_long, i)
+    end
+  end
+  [ 0, 0x7fffffffffffffff, 0x8000000000000000, 0xffffffffffffffff ].each do |i|
+    it ":ulong_long variable" do
+      gvar_test("u64", :ulong_long, i)
+    end
+  end
+  if FFI::Platform::LONG_SIZE == 32
+    [ 0, 0x7fffffff, -0x80000000, -1 ].each do |i|
+      it ":long variable" do
+        gvar_test("long", :long, i)
+      end
+    end
+    [ 0, 0x7fffffff, 0x80000000, 0xffffffff ].each do |i|
+      it ":ulong variable" do
+        gvar_test("ulong", :ulong, i)
+      end
+    end
+  else
+    [ 0, 0x7fffffffffffffff, -0x8000000000000000, -1 ].each do |i|
+      it ":long variable" do
+        gvar_test("long", :long, i)
+      end
+    end
+    [ 0, 0x7fffffffffffffff, 0x8000000000000000, 0xffffffffffffffff ].each do |i|
+      it ":ulong variable" do
+        gvar_test("ulong", :ulong, i)
+      end
+    end
+  end
+  it "Pointer variable" do
+    lib = gvar_lib("pointer", :pointer)
+    val = FFI::MemoryPointer.new :long
+    lib.set(val)
+    lib.gvar.should == val
+    lib.set(nil)
+    lib.gvar = val
+    lib.get.should == val
+  end
+end

data/spec/ffi/managed_struct_spec.rb

@@ -0,0 +1,56 @@
+require File.expand_path(File.join(File.dirname(__FILE__), "spec_helper"))
+require 'java' if RUBY_PLATFORM =~ /java/
+
+describe "Managed Struct" do
+  include FFI
+  module LibTest
+    extend FFI::Library
+    ffi_lib TestLibrary::PATH
+    attach_function :ptr_from_address, [ FFI::Platform::ADDRESS_SIZE == 32 ? :uint : :ulong_long ], :pointer
+  end
+  it "should raise an error if release() is not defined" do
+    class NoRelease < FFI::ManagedStruct ; layout :i, :int; end
+    lambda { NoRelease.new(LibTest.ptr_from_address(0x12345678)) }.should raise_error(NoMethodError)
+  end
+
+  it "should be the right class" do
+    class WhatClassAmI < FFI::ManagedStruct
+      layout :i, :int
+      def self.release
+      end
+    end    
+
+    WhatClassAmI.new(LibTest.ptr_from_address(0x12345678)).class.should == WhatClassAmI
+  end
+
+  it "should release memory properly" do
+    class PleaseReleaseMe < FFI::ManagedStruct
+      layout :i, :int
+      @@count = 0
+      def self.release
+        @@count += 1
+      end
+      def self.wait_gc(count)
+        loop = 5
+        while loop > 0 && @@count < count
+          loop -= 1
+          if RUBY_PLATFORM =~ /java/
+            java.lang.System.gc
+          else
+            GC.start
+          end
+          sleep 0.05 if @@count < count
+        end
+      end
+    end
+
+    loop_count = 30
+    wiggle_room = 2
+
+    PleaseReleaseMe.should_receive(:release).at_least(loop_count-wiggle_room).times
+    loop_count.times do
+      s = PleaseReleaseMe.new(LibTest.ptr_from_address(0x12345678))
+    end
+    PleaseReleaseMe.wait_gc loop_count
+  end
+end

data/spec/ffi/number_spec.rb

@@ -0,0 +1,231 @@
+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