ffi 1.1.2 → 1.17.0

data/spec/ffi/library_spec.rb

@@ -1,208 +0,0 @@
-#
-# This file is part of ruby-ffi.
-#
-# This code is free software: you can redistribute it and/or modify it under
-# the terms of the GNU Lesser General Public License version 3 only, as
-# published by the Free Software Foundation.
-#
-# This code is distributed in the hope that it will be useful, but WITHOUT
-# ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
-# FITNESS FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public License
-# version 3 for more details.
-#
-# You should have received a copy of the GNU Lesser General Public License
-# version 3 along with this work.  If not, see <http://www.gnu.org/licenses/>.
-#
-
-require File.expand_path(File.join(File.dirname(__FILE__), "spec_helper"))
-describe "Library" do
-  describe "#ffi_convention" do
-    it "defaults to :default" do
-      m = Module.new do
-        extend FFI::Library
-      end
-      m.ffi_convention.should eq :default
-    end
-
-    it "should be settable" do
-      m = Module.new do
-        extend FFI::Library
-      end
-
-      m.ffi_convention.should eq :default
-      m.ffi_convention :stdcall
-      m.ffi_convention.should eq :stdcall
-    end
-  end
-
-  unless RbConfig::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 eq 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 eq 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 eq 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 eq 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 eq 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 eq val
-    lib.set(0)
-    lib.gvar = val
-    lib.get.should eq 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 eq val
-    lib.set(nil)
-    lib.gvar = val
-    lib.get.should eq 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 eq i
-      val[:data] = 0
-      lib.gvar[:data] = i
-      val = GlobalStruct.new(lib.get)
-      val[:data].should eq i
-    end
-  end
-end

data/spec/ffi/long_double.rb

@@ -1,41 +0,0 @@
-#
-# This file is part of ruby-ffi.
-#
-# This code is free software: you can redistribute it and/or modify it under
-# the terms of the GNU Lesser General Public License version 3 only, as
-# published by the Free Software Foundation.
-#
-# This code is distributed in the hope that it will be useful, but WITHOUT
-# ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
-# FITNESS FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public License
-# version 3 for more details.
-#
-# You should have received a copy of the GNU Lesser General Public License
-# version 3 along with this work.  If not, see <http://www.gnu.org/licenses/>.
-#
-
-require File.expand_path(File.join(File.dirname(__FILE__), "spec_helper"))
-require 'bigdecimal'
-
-describe ":long_double arguments and return values" do
-  module LibTest
-    extend FFI::Library
-    ffi_lib TestLibrary::PATH
-    attach_function :add_f128, [ :long_double, :long_double ], :long_double
-    attach_function :ret_f128, [ :long_double ], :long_double
-  end
-
-  it "returns first parameter" do
-    LibTest.ret_f128(0.1).should be_within(0.01).of(0.1)
-  end
-
-  it "returns first parameter with high precision" do
-    ld =        BigDecimal.new("1.234567890123456789")
-    tolerance = BigDecimal.new("0.0000000000000000001")
-    LibTest.ret_f128(ld).should be_within(tolerance).of(ld)
-  end
-
-  it "add two long double numbers" do
-    LibTest.add_f128(0.1, 0.2).should be_within(0.01).of(0.3)
-  end
-end

data/spec/ffi/managed_struct_spec.rb

@@ -1,72 +0,0 @@
-#
-# This file is part of ruby-ffi.
-#
-# This code is free software: you can redistribute it and/or modify it under
-# the terms of the GNU Lesser General Public License version 3 only, as
-# published by the Free Software Foundation.
-#
-# This code is distributed in the hope that it will be useful, but WITHOUT
-# ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
-# FITNESS FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public License
-# version 3 for more details.
-#
-# You should have received a copy of the GNU Lesser General Public License
-# version 3 along with this work.  If not, see <http://www.gnu.org/licenses/>.
-#
-
-require File.expand_path(File.join(File.dirname(__FILE__), "spec_helper"))
-require 'java' if RUBY_PLATFORM =~ /java/
-
-describe "Managed Struct" do
-  include FFI
-  module ManagedStructTestLib
-    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(ManagedStructTestLib.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(ManagedStructTestLib.ptr_from_address(0x12345678)).class.should eq 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
-      PleaseReleaseMe.new(ManagedStructTestLib.ptr_from_address(0x12345678))
-    end
-    PleaseReleaseMe.wait_gc loop_count
-  end
-end

data/spec/ffi/number_spec.rb

@@ -1,247 +0,0 @@
-#
-# This file is part of ruby-ffi.
-#
-# This code is free software: you can redistribute it and/or modify it under
-# the terms of the GNU Lesser General Public License version 3 only, as
-# published by the Free Software Foundation.
-#
-# This code is distributed in the hope that it will be useful, but WITHOUT
-# ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
-# FITNESS FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public License
-# version 3 for more details.
-#
-# You should have received a copy of the GNU Lesser General Public License
-# version 3 along with this work.  If not, see <http://www.gnu.org/licenses/>.
-#
-
-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 eq 1
-  end
-  it "uint8.size" do
-    FFI::TYPE_UINT8.size.should eq 1
-  end
-  it "int16.size" do
-    FFI::TYPE_INT16.size.should eq 2
-  end
-  it "uint16.size" do
-    FFI::TYPE_UINT16.size.should eq 2
-  end
-  it "int32.size" do
-    FFI::TYPE_INT32.size.should eq 4
-  end
-  it "uint32.size" do
-    FFI::TYPE_UINT32.size.should eq 4
-  end
-  it "int64.size" do
-    FFI::TYPE_INT64.size.should eq 8
-  end
-  it "uint64.size" do
-    FFI::TYPE_UINT64.size.should eq 8
-  end
-  it "float.size" do
-    FFI::TYPE_FLOAT32.size.should eq 4
-  end
-  it "double.size" do
-    FFI::TYPE_FLOAT64.size.should eq 8
-  end
-  [ 0, 127, -128, -1 ].each do |i|
-    it ":char call(:char (#{i}))" do
-      LibTest.ret_s8(i).should eq i
-    end
-  end
-  [ 0, 0x7f, 0x80, 0xff ].each do |i|
-    it ":uchar call(:uchar (#{i}))" do
-      LibTest.ret_u8(i).should eq i
-    end
-  end
-  [ 0, 0x7fff, -0x8000, -1 ].each do |i|
-    it ":short call(:short (#{i}))" do
-      LibTest.ret_s16(i).should eq i
-    end
-  end
-  [ 0, 0x7fff, 0x8000, 0xffff ].each do |i|
-    it ":ushort call(:ushort (#{i}))" do
-      LibTest.ret_u16(i).should eq i
-    end
-  end
-  [ 0, 0x7fffffff, -0x80000000, -1 ].each do |i|
-    it ":int call(:int (#{i}))" do
-      LibTest.ret_s32(i).should eq i
-    end
-  end
-  [ 0, 0x7fffffff, 0x80000000, 0xffffffff ].each do |i|
-    it ":uint call(:uint (#{i}))" do
-      LibTest.ret_u32(i).should eq i
-    end
-  end
-  [ 0, 0x7fffffffffffffff, -0x8000000000000000, -1 ].each do |i|
-    it ":long_long call(:long_long (#{i}))" do
-      LibTest.ret_s64(i).should eq i
-    end
-  end
-  [ 0, 0x7fffffffffffffff, 0x8000000000000000, 0xffffffffffffffff ].each do |i|
-    it ":ulong_long call(:ulong_long (#{i}))" do
-      LibTest.ret_u64(i).should eq 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 eq i
-      end
-    end
-    [ 0, 0x7fffffff, 0x80000000, 0xffffffff ].each do |i|
-      it ":ulong call(:ulong (#{i}))" do
-        LibTest.ret_ulong(i).should eq i
-      end
-    end
-  else
-    [ 0, 0x7fffffffffffffff, -0x8000000000000000, -1 ].each do |i|
-      it ":long call(:long (#{i}))" do
-        LibTest.ret_long(i).should eq i
-      end
-    end
-    [ 0, 0x7fffffffffffffff, 0x8000000000000000, 0xffffffffffffffff ].each do |i|
-      it ":ulong call(:ulong (#{i}))" do
-        LibTest.ret_ulong(i).should eq 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 eq 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 eq i }.should raise_error
-    end
-  end
-  [ 0x8000, -0x8001 ].each do |i|
-    it ":short call(:short (#{i}))" do
-      lambda { LibTest.ret_int16_t(i).should eq 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 eq i }.should raise_error
-    end
-  end
-  [ 0x80000000, -0x80000001 ].each do |i|
-    it ":int call(:int (#{i}))" do
-      lambda { LibTest.ret_int32_t(i).should eq 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 eq 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 ]
-  }
-
-  def verify(p, off, t, v)
-    if t == 'f32'
-      p.get_float32(off).should eq v
-    elsif t == 'f64'
-      p.get_float64(off).should eq v
-    else
-      p.get_int64(off).should eq v
-    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)
-                verify(p, 0, t1, v1)
-                verify(p, 8, t2, v2)
-                verify(p, 16, t3, v3)
-              end
-            end
-          end
-        end
-      end
-    end
-  end
-end