ffi 1.9.3-x64-mingw32

data/spec/ffi/custom_param_type.rb

@@ -0,0 +1,36 @@
+#
+# This file is part of ruby-ffi.
+# For licensing, see LICENSE.SPECS
+#
+
+require File.expand_path(File.join(File.dirname(__FILE__), "spec_helper"))
+
+describe "functions with custom parameter types" do
+  before :each do
+
+    Custom_enum = Class.new do
+      extend FFI::DataConverter
+      ToNativeMap= { :a => 1, :b => 2 }
+      FromNativeMap = { 1 => :a, 2 => :b }
+
+      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
+end

data/spec/ffi/custom_type_spec.rb

@@ -0,0 +1,74 @@
+#
+# This file is part of ruby-ffi.
+# For licensing, see LICENSE.SPECS
+#
+
+require File.expand_path(File.join(File.dirname(__FILE__), "spec_helper"))
+
+describe "functions with custom types" do
+  class Custom_enum
+    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
+
+  it "can attach with custom return type" do
+    lambda do
+      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/dup_spec.rb

@@ -0,0 +1,54 @@
+#
+# This file is part of ruby-ffi.
+# For licensing, see LICENSE.SPECS
+#
+
+
+require File.expand_path(File.join(File.dirname(__FILE__), "spec_helper"))
+
+describe "Pointer#dup" do 
+  it "clone should be independent" do
+    p1 = FFI::MemoryPointer.new(:char, 1024)
+    p1.put_string(0, "test123");
+    p2 = p1.dup
+    p1.put_string(0, "deadbeef")
+    
+    p2.get_string(0).should == "test123"
+  end
+  
+  it "sliced pointer can be cloned" do
+    p1 = FFI::MemoryPointer.new(:char, 1024)
+    p1.put_string(0, "test123");
+    p2 = p1[1].dup
+    
+    # first char will be excised
+    p2.get_string(0).should == "est123"
+    p1.get_string(0).should == "test123"
+  end
+  
+  it "sliced pointer when cloned is independent" do
+    p1 = FFI::MemoryPointer.new(:char, 1024)
+    p1.put_string(0, "test123");
+    p2 = p1[1].dup
+    
+    p1.put_string(0, "deadbeef")
+    # first char will be excised
+    p2.get_string(0).should == "est123"
+  end
+end
+
+
+describe "Struct#dup" do
+  it "clone should be independent" do
+    s = Class.new(FFI::Struct) do
+      layout :i, :int
+    end
+    s1 = s.new
+    s1[:i] = 0x12345
+    s2 = s1.dup
+    s1[:i] = 0x98765
+    s2[:i].should == 0x12345
+    s1[:i].should == 0x98765
+  end
+  
+end

data/spec/ffi/enum_spec.rb

@@ -0,0 +1,220 @@
+#
+# This file is part of ruby-ffi.
+# For licensing, see LICENSE.SPECS
+#
+
+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
+  it "return nil for values that don't have a symbol" do
+    enum = TestEnum3.enum_type(:enum_type1)
+    enum[-1].should == nil
+    enum[4].should == nil
+
+    enum = TestEnum3.enum_type(:enum_type2)
+    enum[0].should == nil
+    enum[41].should == nil
+    enum[46].should == nil
+
+    enum = TestEnum3.enum_type(:enum_type3)
+    enum[0].should == nil
+    enum[41].should == nil
+    enum[44].should == nil
+    enum[4241].should == nil
+    enum[4244].should == nil
+
+    enum = TestEnum3.enum_type(:enum_type4)
+    enum[0].should == nil
+    enum[41].should == nil
+    enum[43].should == nil
+    enum[4241].should == nil
+    enum[4243].should == nil
+    enum[424241].should == nil
+    enum[424243].should == nil
+    enum[42424241].should == nil
+    enum[42424243].should == nil
+  end
+
+  it "duplicate enum keys rejected" do
+    lambda { enum [ :a, 0xfee1dead, :b, 0xdeadbeef, :a, 0 ] }.should raise_error
+  end
+end

data/spec/ffi/errno_spec.rb

@@ -0,0 +1,18 @@
+#
+# This file is part of ruby-ffi.
+# For licensing, see LICENSE.SPECS
+#
+
+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

@@ -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 "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

@@ -0,0 +1,76 @@
+#
+# This file is part of ruby-ffi.
+# For licensing, see LICENSE.SPECS
+#
+
+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
+  end
+  before do
+    @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
+    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
+  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