ffi 1.0.0 → 1.17.1

data/spec/ffi/custom_type_spec.rb

@@ -1,73 +0,0 @@
-require File.expand_path(File.join(File.dirname(__FILE__), "spec_helper"))
-
-describe "functions with custom types" do
-  before :each do
-    
-    Custom_enum = Class.new do
-      extend FFI::DataConverter
-      ToNativeMap= { :a => 1, :b => 2, :c => 3 }
-      FromNativeMap = { 1 => :a, 2 => :b, 3 => :c }
-
-      def self.native_type
-        @native_type_called = true
-        FFI::Type::INT32
-      end
-
-      def self.to_native(val, ctx)
-        @to_native_called = true
-        ToNativeMap[val]
-      end
-
-      def self.from_native(val, ctx)
-        @from_native_called = true
-        FromNativeMap[val]
-      end
-      def self.native_type_called?; @native_type_called; end
-      def self.from_native_called?; @from_native_called; end
-      def self.to_native_called?; @to_native_called; end
-    end
-
-  end
-
-  it "can attach with custom return type" do
-    lambda do
-      m = Module.new do
-        extend FFI::Library
-        ffi_lib TestLibrary::PATH
-        attach_function :ret_s32, [ :int ], Custom_enum
-      end
-    end.should_not raise_error
-  end
-
-  it "should return object of correct type" do
-
-    m = Module.new do
-
-      extend FFI::Library
-      ffi_lib TestLibrary::PATH
-      attach_function :ret_s32, [ :int ], Custom_enum
-    end
-
-    m.ret_s32(1).is_a?(Symbol).should be_true
-  end
-
-  it "from_native should be called for result" do
-    m = Module.new do
-      extend FFI::Library
-      ffi_lib TestLibrary::PATH
-      attach_function :ret_s32, [ :int ], Custom_enum
-    end
-    m.ret_s32(1)
-    Custom_enum.from_native_called?.should be_true
-  end
-
-  it "to_native should be called for parameter" do
-    m = Module.new do
-      extend FFI::Library
-      ffi_lib TestLibrary::PATH
-      attach_function :ret_s32, [ Custom_enum ], :int
-    end
-    m.ret_s32(:a)
-    Custom_enum.to_native_called?.should be_true
-  end
-end

data/spec/ffi/enum_spec.rb

@@ -1,183 +0,0 @@
-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
-
-  it "integers can be used instead of constants" do
-    TestEnum3.test_tagged_typedef_enum1(0).should == :c1
-    TestEnum3.test_tagged_typedef_enum1(1).should == :c2
-    TestEnum3.test_tagged_typedef_enum1(2).should == :c3
-    TestEnum3.test_tagged_typedef_enum1(3).should == :c4
-    TestEnum3.test_tagged_typedef_enum2(42).should == :c5
-    TestEnum3.test_tagged_typedef_enum2(43).should == :c6
-    TestEnum3.test_tagged_typedef_enum2(44).should == :c7
-    TestEnum3.test_tagged_typedef_enum2(45).should == :c8
-    TestEnum3.test_tagged_typedef_enum3(42).should == :c9
-    TestEnum3.test_tagged_typedef_enum3(43).should == :c10
-    TestEnum3.test_tagged_typedef_enum3(4242).should == :c11
-    TestEnum3.test_tagged_typedef_enum3(4243).should == :c12
-    TestEnum3.test_tagged_typedef_enum4(42).should == :c13
-    TestEnum3.test_tagged_typedef_enum4(4242).should == :c14
-    TestEnum3.test_tagged_typedef_enum4(424242).should == :c15
-    TestEnum3.test_tagged_typedef_enum4(42424242).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

@@ -1,13 +0,0 @@
-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/ffi_spec.rb

@@ -1,24 +0,0 @@
-require File.expand_path(File.join(File.dirname(__FILE__), "spec_helper"))
-
-describe "FFI" do
-
-  describe ".map_library_name" do
-
-    let(:prefix) { FFI::Platform::LIBPREFIX }
-    let(:suffix) { FFI::Platform::LIBSUFFIX }
-    
-    it "should add platform library extension if not present" do
-      FFI.map_library_name("#{prefix}dummy").should == "#{prefix}dummy.#{suffix}"
-    end
-
-    it "should add platform library extension even if lib suffix is present in name" do
-      FFI.map_library_name("#{prefix}dummy_with_#{suffix}").should == "#{prefix}dummy_with_#{suffix}.#{suffix}"
-    end
-
-    it "should return Platform::LIBC when called with 'c'" do
-      FFI.map_library_name('c').should == FFI::Library::LIBC
-    end
-
-  end
-
-end

data/spec/ffi/function_spec.rb

@@ -1,73 +0,0 @@
-require File.expand_path(File.join(File.dirname(__FILE__), "spec_helper"))
-
-describe FFI::Function do
-  before do
-    module LibTest
-      extend FFI::Library
-      ffi_lib TestLibrary::PATH
-      attach_function :testFunctionAdd, [:int, :int, :pointer], :int
-    end
-    @libtest = FFI::DynamicLibrary.open(TestLibrary::PATH, 
-                                        FFI::DynamicLibrary::RTLD_LAZY | FFI::DynamicLibrary::RTLD_GLOBAL)
-  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.find_function('testAdd')).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.find_function('testAdd'))
-    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.find_function('testAdd'))
-    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
-  it 'can wrap a blocking function' do
-    unless RUBY_VERSION =~ /1.8/
-      fp = FFI::Function.new(:void, [ :int ], @libtest.find_function('testBlocking'), :blocking => true)
-      time = Time.now
-      threads = []
-      threads << Thread.new { fp.call(2) }
-      threads << Thread.new(time) { (Time.now - time).should < 1 }
-      threads.each { |t| t.join }
-    end
-  end
-  it 'autorelease flag is set to true by default' do
-    fp = FFI::Function.new(:int, [:int, :int], @libtest.find_function('testAdd'))
-    fp.autorelease?.should be_true
-  end
-  it 'can explicity free itself' do
-    fp = FFI::Function.new(:int, []) { }
-    fp.free
-    lambda { fp.free }.should raise_error RuntimeError
-  end
-  it 'can\'t explicity free itself if not previously allocated' do
-    fp = FFI::Function.new(:int, [:int, :int], @libtest.find_function('testAdd'))
-    lambda { fp.free }.should raise_error RuntimeError
-  end
-end

data/spec/ffi/library_spec.rb

@@ -1,174 +0,0 @@
-require File.expand_path(File.join(File.dirname(__FILE__), "spec_helper"))
-describe "Library" do
-
-  unless Config::CONFIG['target_os'] =~ /mswin|mingw/
-    it "attach_function with no library specified" do
-      lambda {
-        Module.new do |m|
-          m.extend FFI::Library
-          attach_function :getpid, [ ], :uint
-        end
-      }.should raise_error
-    end
-    it "attach_function :getpid from this process" do
-      lambda {
-        Module.new do |m|
-          m.extend FFI::Library
-          ffi_lib FFI::Library::CURRENT_PROCESS
-          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
-
-  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
-
-  [ 0, 0x7fffffff, -0x80000000, -1 ].each do |i|
-    it "structure" do
-      class GlobalStruct < FFI::Struct
-        layout :data, :long
-      end
-
-      lib = Module.new do |m|
-        m.extend FFI::Library
-        ffi_lib TestLibrary::PATH
-        attach_variable :gvar, "gvar_gstruct", GlobalStruct
-        attach_function :get, "gvar_gstruct_get", [], GlobalStruct
-        attach_function :set, "gvar_gstruct_set", [ GlobalStruct ], :void
-      end
-
-      val = GlobalStruct.new
-      val[:data] = i
-      lib.set(val)
-      lib.gvar[:data].should == i
-      val[:data] = 0
-      lib.gvar[:data] = i
-      val = GlobalStruct.new(lib.get)
-      val[:data].should == i
-    end
-  end
-end

data/spec/ffi/managed_struct_spec.rb

@@ -1,56 +0,0 @@
-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 = 5
-
-    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