ffi 0.2.0 → 0.3.0

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/{specs → spec/ffi}/managed_struct_spec.rb

@@ -8,12 +8,23 @@ describe "Managed Struct" do
     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 ; end
+    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

data/{specs → spec/ffi}/number_spec.rb

@@ -3,55 +3,61 @@ describe "Function with primitive integer arguments" do
   module LibTest
     extend FFI::Library
     ffi_lib TestLibrary::PATH
-    attach_function :ret_int8_t, [ :char ], :char
-    attach_function :ret_u_int8_t, [ :uchar ], :uchar
-    attach_function :ret_int16_t, [ :short ], :short
-    attach_function :ret_u_int16_t, [ :ushort ], :ushort
-    attach_function :ret_int32_t, [ :int ], :int
-    attach_function :ret_u_int32_t, [ :uint ], :uint
-    attach_function :ret_int64_t, [ :long_long ], :long_long
-    attach_function :ret_u_int64_t, [ :ulong_long ], :ulong_long
+    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
   [ 0, 127, -128, -1 ].each do |i|
     it ":char call(:char (#{i}))" do
-      LibTest.ret_int8_t(i).should == i
+      LibTest.ret_s8(i).should == i
     end
   end
   [ 0, 0x7f, 0x80, 0xff ].each do |i|
     it ":uchar call(:uchar (#{i}))" do
-      LibTest.ret_u_int8_t(i).should == i
+      LibTest.ret_u8(i).should == i
     end
   end
   [ 0, 0x7fff, -0x8000, -1 ].each do |i|
     it ":short call(:short (#{i}))" do
-      LibTest.ret_int16_t(i).should == i
+      LibTest.ret_s16(i).should == i
     end
   end
   [ 0, 0x7fff, 0x8000, 0xffff ].each do |i|
     it ":ushort call(:ushort (#{i}))" do
-      LibTest.ret_u_int16_t(i).should == i
+      LibTest.ret_u16(i).should == i
     end
   end
   [ 0, 0x7fffffff, -0x80000000, -1 ].each do |i|
     it ":int call(:int (#{i}))" do
-      LibTest.ret_int32_t(i).should == i
+      LibTest.ret_s32(i).should == i
     end
   end
   [ 0, 0x7fffffff, 0x80000000, 0xffffffff ].each do |i|
     it ":uint call(:uint (#{i}))" do
-      LibTest.ret_u_int32_t(i).should == i
+      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_int64_t(i).should == i
+      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_u_int64_t(i).should == i
+      LibTest.ret_u64(i).should == i
     end
   end
   if FFI::Platform::LONG_SIZE == 32
@@ -76,6 +82,18 @@ describe "Function with primitive integer arguments" 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

data/{specs → spec/ffi}/pointer_spec.rb

@@ -3,6 +3,8 @@ require 'delegate'
 module LibTest
   attach_function :ptr_ret_int32_t, [ :pointer, :int ], :int
   attach_function :ptr_from_address, [ FFI::Platform::ADDRESS_SIZE == 32 ? :uint : :ulong_long ], :pointer
+  attach_function :ptr_set_pointer, [ :pointer, :int, :pointer ], :void
+  attach_function :ptr_ret_pointer, [ :pointer, :int ], :pointer
 end
 describe "Pointer" do
   include FFI
@@ -15,7 +17,7 @@ describe "Pointer" do
     end
   end
   it "Any object implementing #to_ptr can be passed as a :pointer parameter" do
-    memory = MemoryPointer.new :long_long
+    memory = FFI::MemoryPointer.new :long_long
     magic = 0x12345678
     memory.put_int32(0, magic)
     tp = ToPtrTest.new(memory)
@@ -31,7 +33,7 @@ describe "Pointer" do
     end
   end
   it "A DelegateClass(Pointer) can be passed as a :pointer parameter" do
-    memory = MemoryPointer.new :long_long
+    memory = FFI::MemoryPointer.new :long_long
     magic = 0x12345678
     memory.put_int32(0, magic)
     ptr = PointerDelegate.new(memory)
@@ -43,6 +45,48 @@ describe "Pointer" do
   it "Bignum cannot be used as a Pointer argument" do
     lambda { LibTest.ptr_ret_int32(0xfee1deadbeefcafebabe, 0) }.should raise_error
   end
+
+  describe "pointer type methods" do
+
+    describe "#read_pointer" do
+      memory = FFI::MemoryPointer.new :pointer
+      LibTest.ptr_set_pointer(memory, 0, LibTest.ptr_from_address(0xdeadbeef))
+      memory.read_pointer.address.should == 0xdeadbeef
+    end
+
+    describe "#write_pointer" do
+      memory = FFI::MemoryPointer.new :pointer
+      memory.write_pointer(LibTest.ptr_from_address(0xdeadbeef))
+      LibTest.ptr_ret_pointer(memory, 0).address.should == 0xdeadbeef
+    end
+
+    describe "#read_array_of_pointer" do
+      values = [0x12345678, 0xfeedf00d, 0xdeadbeef]
+      memory = FFI::MemoryPointer.new :pointer, values.size
+      values.each_with_index do |address, j|
+        LibTest.ptr_set_pointer(memory, j * FFI.type_size(:pointer), LibTest.ptr_from_address(address))
+      end
+      array = memory.read_array_of_pointer(values.size)
+      values.each_with_index do |address, j|
+        array[j].address.should == address
+      end
+    end
+
+    describe "#write_array_of_pointer" do
+      values = [0x12345678, 0xfeedf00d, 0xdeadbeef]
+      memory = FFI::MemoryPointer.new :pointer, values.size
+      memory.write_array_of_pointer(values.map { |address| LibTest.ptr_from_address(address) })
+      array = []
+      values.each_with_index do |address, j|
+        array << LibTest.ptr_ret_pointer(memory, j * FFI.type_size(:pointer))
+      end
+      values.each_with_index do |address, j|
+        array[j].address.should == address
+      end
+    end
+
+  end
+
 end
 
 describe "AutoPointer" do

data/{specs → spec/ffi}/rbx/attach_function_spec.rb

@@ -23,4 +23,5 @@ describe FFI::Library, "#attach_function" do
     t[:tv_sec].should be_kind_of(Numeric)
     t[:tv_usec].should be_kind_of(Numeric)
   end
-end
+end
+

data/{specs → spec/ffi}/rbx/memory_pointer_spec.rb

@@ -7,101 +7,101 @@ module CTest
   attach_function :strcat, [:pointer, :pointer], :pointer
 end
 
-describe MemoryPointer do
+describe "MemoryPointer" do
   it "makes a pointer from a string" do
-    m = MemoryPointer.from_string("FFI is Awesome")
+    m = FFI::MemoryPointer.from_string("FFI is Awesome")
     m.type_size.should == 15
   end
   
   it "reads back a string" do
-    m = MemoryPointer.from_string("FFI is Awesome")
+    m = FFI::MemoryPointer.from_string("FFI is Awesome")
     m.read_string.should == "FFI is Awesome"
   end
   
   it "reads back a string from an Array of ints" do
-    m = MemoryPointer.new(:int, 4)
+    m = FFI::MemoryPointer.new(:int, 4)
     m.write_array_of_int([541673030, 1092645737, 1869833591, 538994029])
     m.read_string(16).should == "FFI is Awesome  "
   end
   
   it "makes a pointer for a certain number of bytes" do
-    m = MemoryPointer.new(8)
+    m = FFI::MemoryPointer.new(8)
     m.write_array_of_int([1,2])
     m.read_array_of_int(2).should == [1,2]
   end
 
   it "allows access to an element of the pointer (as an array)" do
-    m = MemoryPointer.new(:int, 2)
+    m = FFI::MemoryPointer.new(:int, 2)
     m.write_array_of_int([1,2])
     m[0].read_int.should == 1
     m[1].read_int.should == 2
   end
   
   it "allows writing as an int" do
-    m = MemoryPointer.new(:int)
+    m = FFI::MemoryPointer.new(:int)
     m.write_int(1)
     m.read_int.should == 1
   end
   
   it "allows writing as a long" do
-    m = MemoryPointer.new(:long)
+    m = FFI::MemoryPointer.new(:long)
     m.write_long(10)
     m.read_long.should == 10
   end
   
   it "raises an error if you try putting a long into a pointer of size 1" do
-    m = MemoryPointer.new(1)
+    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 = MemoryPointer.new(1)
+    m = FFI::MemoryPointer.new(1)
     lambda { m.write_int(10) }.should raise_error
   end
 #  it "does not raise IndexError for opaque pointers" do
-#    m = MemoryPointer.new(8)
-#    p2 = MemoryPointer.new(1024)
+#    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 = MemoryPointer.new(:int)
+    m = FFI::MemoryPointer.new(:int)
     m.write_int(10)
     m.read_int.should == 10
   end
   
   it "makes a memory pointer for a number of a certain type" do
-    m = MemoryPointer.new(:int, 2)
+    m = FFI::MemoryPointer.new(:int, 2)
     m.write_array_of_int([1,2])
     m.read_array_of_int(2).should == [1,2]
   end
   
   it "makes a pointer for an object responding to #size" do
-    m = MemoryPointer.new(Struct.new(:size).new(8))
+    m = FFI::MemoryPointer.new(Struct.new(:size).new(8))
     m.write_array_of_int([1,2])
     m.read_array_of_int(2).should == [1,2]
   end
 
   it "makes a pointer for a number of an object responding to #size" do
-    m = MemoryPointer.new(Struct.new(:size).new(4), 2)
+    m = FFI::MemoryPointer.new(Struct.new(:size).new(4), 2)
     m.write_array_of_int([1,2])
     m.read_array_of_int(2).should == [1,2]
   end  
   it "MemoryPointer#address returns correct value" do
-    m = MemoryPointer.new(:long_long)
+    m = FFI::MemoryPointer.new(:long_long)
     magic = 0x12345678
     m.write_long(magic)
     m.read_pointer.address.should == magic
   end
   it "MemoryPointer#null? returns true for zero value" do
-    m = MemoryPointer.new(:long_long)
+    m = FFI::MemoryPointer.new(:long_long)
     m.write_long(0)    
     m.read_pointer.null?.should == true
   end
   it "MemoryPointer#null? returns false for non-zero value" do
-    m = MemoryPointer.new(:long_long)
+    m = FFI::MemoryPointer.new(:long_long)
     m.write_long(0x12345678)
     m.read_pointer.null?.should == false
   end