ffi 0.1.1 → 0.2.0

data/specs/buffer_spec.rb

@@ -1,14 +1,8 @@
 require "rubygems"
 require File.expand_path(File.join(File.dirname(__FILE__), "spec_helper"))
-if RUBY_PLATFORM == "java"
-  Buffer = JRuby::FFI::Buffer
-  Platform = JRuby::FFI::Platform
-  LongSize = JRuby::FFI::Platform::LONG_SIZE / 8
-else
-  Buffer = FFI::Buffer
-  Platform = FFI::Platform
-  LongSize = FFI::Platform::LONG_SIZE / 8
-end
+include FFI
+LongSize = FFI::Platform::LONG_SIZE / 8
+
 describe "Buffer#total" do
   [1,2,3].each do |i|
     { :char => 1, :uchar => 1, :short => 2, :ushort => 2, :int => 4, 
@@ -128,6 +122,67 @@ describe "Buffer#put_ulong_long" do
     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
+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 = MemoryPointer.new :ulong_long

data/specs/callback_spec.rb

@@ -1,4 +1,4 @@
-require 'ffi'
+require File.expand_path(File.join(File.dirname(__FILE__), "spec_helper"))
 
 describe "Callback" do
   module LibC
@@ -21,11 +21,315 @@ describe "Callback" do
     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| 
+    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  
-end
+  end
+  module LibTest
+    extend FFI::Library
+    ffi_lib TestLibrary::PATH
+    callback :cbVrS8, [ ], :char
+    callback :cbVrU8, [ ], :uchar
+    callback :cbVrS16, [ ], :short
+    callback :cbVrU16, [ ], :ushort
+    callback :cbVrS32, [ ], :int
+    callback :cbVrU32, [ ], :uint
+    callback :cbVrS64, [ ], :long_long
+    callback :cbVrU64, [ ], :ulong_long
+    callback :cbCrV, [ :char ], :void
+    callback :cbSrV, [ :short ], :void
+    callback :cbIrV, [ :int ], :void
+    callback :cbLrV, [ :long_long ], :void
+    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 :testCallbackVrS64, :testClosureVrL, [ :cbVrS64 ], :long_long
+    attach_function :testCallbackVrU64, :testClosureVrL, [ :cbVrU64 ], :ulong_long
+    attach_function :testCallbackCrV, :testClosureBrV, [ :cbCrV, :char ], :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 "Callback returning :char (0)" do
+    LibTest.testCallbackVrS8 { 0 }.should == 0
+  end
+  it "Callback returning :char (127)" do
+    LibTest.testCallbackVrS8 { 127 }.should == 127
+  end
+  it "Callback returning :char (-128)" do
+    LibTest.testCallbackVrS8 { -128 }.should == -128
+  end
+  # test wrap around
+  it "Callback returning :char (128)" do
+    LibTest.testCallbackVrS8 { 128 }.should == -128
+  end
+  it "Callback returning :char (255)" do
+    LibTest.testCallbackVrS8 { 0xff }.should == -1
+  end
+  it "Callback returning :uchar (0)" do
+    LibTest.testCallbackVrU8 { 0 }.should == 0
+  end
+  it "Callback returning :uchar (0xff)" do
+    LibTest.testCallbackVrU8 { 0xff }.should == 0xff
+  end
+  it "Callback returning :uchar (-1)" do
+    LibTest.testCallbackVrU8 { -1 }.should == 0xff
+  end
+  it "Callback returning :uchar (128)" do
+    LibTest.testCallbackVrU8 { 128 }.should == 128
+  end
+  it "Callback returning :uchar (-128)" do
+    LibTest.testCallbackVrU8 { -128 }.should == 128
+  end
+  it "Callback returning :short (0)" do
+    LibTest.testCallbackVrS16 { 0 }.should == 0
+  end
+  it "Callback returning :short (0x7fff)" do
+    LibTest.testCallbackVrS16 { 0x7fff }.should == 0x7fff
+  end
+  # test wrap around
+  it "Callback returning :short (0x8000)" do
+    LibTest.testCallbackVrS16 { 0x8000 }.should == -0x8000
+  end
+  it "Callback returning :short (0xffff)" do
+    LibTest.testCallbackVrS16 { 0xffff }.should == -1
+  end
+  it "Callback returning :ushort (0)" do
+    LibTest.testCallbackVrU16 { 0 }.should == 0
+  end
+  it "Callback returning :ushort (0x7fff)" do
+    LibTest.testCallbackVrU16 { 0x7fff }.should == 0x7fff
+  end
+  it "Callback returning :ushort (0x8000)" do
+    LibTest.testCallbackVrU16 { 0x8000 }.should == 0x8000
+  end
+  it "Callback returning :ushort (0xffff)" do
+    LibTest.testCallbackVrU16 { 0xffff }.should == 0xffff
+  end
+  it "Callback returning :ushort (-1)" do
+    LibTest.testCallbackVrU16 { -1 }.should == 0xffff
+  end
+
+  it "Callback returning :int (0)" do
+    LibTest.testCallbackVrS32 { 0 }.should == 0
+  end
+  it "Callback returning :int (0x7fffffff)" do
+    LibTest.testCallbackVrS32 { 0x7fffffff }.should == 0x7fffffff
+  end
+  # test wrap around
+  it "Callback returning :int (-0x80000000)" do
+    LibTest.testCallbackVrS32 { -0x80000000 }.should == -0x80000000
+  end
+  it "Callback returning :int (-1)" do
+    LibTest.testCallbackVrS32 { -1 }.should == -1
+  end
+
+  it "Callback returning :uint (0)" do
+    LibTest.testCallbackVrU32 { 0 }.should == 0
+  end
+  it "Callback returning :uint (0x7fffffff)" do
+    LibTest.testCallbackVrU32 { 0x7fffffff }.should == 0x7fffffff
+  end
+  # test wrap around
+  it "Callback returning :uint (0x80000000)" do
+    LibTest.testCallbackVrU32 { 0x80000000 }.should == 0x80000000
+  end
+  it "Callback returning :uint (0xffffffff)" do
+    LibTest.testCallbackVrU32 { 0xffffffff }.should == 0xffffffff
+  end
+  it "Callback returning :uint (-1)" do
+    LibTest.testCallbackVrU32 { -1 }.should == 0xffffffff
+  end
+
+  it "Callback returning :long_long (0)" do
+    LibTest.testCallbackVrS64 { 0 }.should == 0
+  end
+  it "Callback returning :long_long (0x7fffffffffffffff)" do
+    LibTest.testCallbackVrS64 { 0x7fffffffffffffff }.should == 0x7fffffffffffffff
+  end
+  # test wrap around
+  it "Callback returning :long_long (-0x8000000000000000)" do
+    LibTest.testCallbackVrS64 { -0x8000000000000000 }.should == -0x8000000000000000
+  end
+  it "Callback returning :long_long (-1)" do
+    LibTest.testCallbackVrS64 { -1 }.should == -1
+  end
+
+  
+end
+describe "Callback with primitive argument" do
+  #
+  # Test callbacks that take an argument, returning void
+  #
+  module LibTest
+    extend FFI::Library
+    ffi_lib TestLibrary::PATH
+    callback :cbS8rV, [ :char ], :void
+    callback :cbU8rV, [ :uchar ], :void
+    callback :cbS16rV, [ :short ], :void
+    callback :cbU16rV, [ :ushort ], :void
+    callback :cbS32rV, [ :int ], :void
+    callback :cbU32rV, [ :uint ], :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 :testCallbackIrV, :testClosureIrV, [ :cbS32rV, :int ], :void
+    attach_function :testCallbackU32rV, :testClosureIrV, [ :cbU32rV, :uint ], :void
+    attach_function :testCallbackLrV, :testClosureLrV, [ :cbS64rV, :long_long ], :void
+  end
+  it "Callback with :char (0) argument" do
+    v = 0xdeadbeef
+    LibTest.testCallbackCrV(0) { |i| v = i }
+    v.should == 0
+  end
+  it "Callback with :char (127) argument" do
+    v = 0xdeadbeef
+    LibTest.testCallbackCrV(127) { |i| v = i }
+    v.should == 127
+  end
+  it "Callback with :char (-128) argument" do
+    v = 0xdeadbeef
+    LibTest.testCallbackCrV(-128) { |i| v = i }
+    v.should == -128
+  end
+  it "Callback with :char (-1) argument" do
+    v = 0xdeadbeef
+    LibTest.testCallbackCrV(-1) { |i| v = i }
+    v.should == -1
+  end
+
+  it "Callback with :uchar (0) argument" do
+    v = 0xdeadbeef
+    LibTest.testCallbackU8rV(0) { |i| v = i }
+    v.should == 0
+  end
+  it "Callback with :uchar (127) argument" do
+    v = 0xdeadbeef
+    LibTest.testCallbackU8rV(127) { |i| v = i }
+    v.should == 127
+  end
+  it "Callback with :uchar (128) argument" do
+    v = 0xdeadbeef
+    LibTest.testCallbackU8rV(128) { |i| v = i }
+    v.should == 128
+  end
+  it "Callback with :uchar (255) argument" do
+    v = 0xdeadbeef
+    LibTest.testCallbackU8rV(255) { |i| v = i }
+    v.should == 255
+  end
+
+  it "Callback with :short (0) argument" do
+    v = 0xdeadbeef
+    LibTest.testCallbackSrV(0) { |i| v = i }
+    v.should == 0
+  end
+  it "Callback with :short (0x7fff) argument" do
+    v = 0xdeadbeef
+    LibTest.testCallbackSrV(0x7fff) { |i| v = i }
+    v.should == 0x7fff
+  end
+  it "Callback with :short (-0x8000) argument" do
+    v = 0xdeadbeef
+    LibTest.testCallbackSrV(-0x8000) { |i| v = i }
+    v.should == -0x8000
+  end
+  it "Callback with :short (-1) argument" do
+    v = 0xdeadbeef
+    LibTest.testCallbackSrV(-1) { |i| v = i }
+    v.should == -1
+  end
+
+  it "Callback with :ushort (0) argument" do
+    v = 0xdeadbeef
+    LibTest.testCallbackU16rV(0) { |i| v = i }
+    v.should == 0
+  end
+  it "Callback with :ushort (0x7fff) argument" do
+    v = 0xdeadbeef
+    LibTest.testCallbackU16rV(0x7fff) { |i| v = i }
+    v.should == 0x7fff
+  end
+  it "Callback with :ushort (0x8000) argument" do
+    v = 0xdeadbeef
+    LibTest.testCallbackU16rV(0x8000) { |i| v = i }
+    v.should == 0x8000
+  end
+  it "Callback with :ushort (0xffff) argument" do
+    v = 0xdeadbeef
+    LibTest.testCallbackU16rV(0xffff) { |i| v = i }
+    v.should == 0xffff
+  end
+
+  it "Callback with :int (0) argument" do
+    v = 0xdeadbeef
+    LibTest.testCallbackIrV(0) { |i| v = i }
+    v.should == 0
+  end
+  it "Callback with :int (0x7fffffff) argument" do
+    v = 0xdeadbeef
+    LibTest.testCallbackIrV(0x7fffffff) { |i| v = i }
+    v.should == 0x7fffffff
+  end
+  it "Callback with :int (-0x80000000) argument" do
+    v = 0xdeadbeef
+    LibTest.testCallbackIrV(-0x80000000) { |i| v = i }
+    v.should == -0x80000000
+  end
+  it "Callback with :int (-1) argument" do
+    v = 0xdeadbeef
+    LibTest.testCallbackIrV(-1) { |i| v = i }
+    v.should == -1
+  end
+
+  it "Callback with :uint (0) argument" do
+    v = 0xdeadbeef
+    LibTest.testCallbackU32rV(0) { |i| v = i }
+    v.should == 0
+  end
+  it "Callback with :uint (0x7fffffff) argument" do
+    v = 0xdeadbeef
+    LibTest.testCallbackU32rV(0x7fffffff) { |i| v = i }
+    v.should == 0x7fffffff
+  end
+  it "Callback with :uint (0x80000000) argument" do
+    v = 0xdeadbeef
+    LibTest.testCallbackU32rV(0x80000000) { |i| v = i }
+    v.should == 0x80000000
+  end
+  it "Callback with :uint (0xffffffff) argument" do
+    v = 0xdeadbeef
+    LibTest.testCallbackU32rV(0xffffffff) { |i| v = i }
+    v.should == 0xffffffff
+  end
+
+  it "Callback with :long_long (0) argument" do
+    v = 0xdeadbeef
+    LibTest.testCallbackLrV(0) { |i| v = i }
+    v.should == 0
+  end
+  it "Callback with :long_long (0x7fffffffffffffff) argument" do
+    v = 0xdeadbeef
+    LibTest.testCallbackLrV(0x7fffffffffffffff) { |i| v = i }
+    v.should == 0x7fffffffffffffff
+  end
+  it "Callback with :long_long (-0x8000000000000000) argument" do
+    v = 0xdeadbeef
+    LibTest.testCallbackLrV(-0x8000000000000000) { |i| v = i }
+    v.should == -0x8000000000000000
+  end
+  it "Callback with :long_long (-1) argument" do
+    v = 0xdeadbeef
+    LibTest.testCallbackLrV(-1) { |i| v = i }
+    v.should == -1
+  end
+  
+end unless true

data/specs/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/specs/library_spec.rb

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