ffi 1.9.18 → 1.9.23

data/spec/ffi/spec_helper.rb

@@ -1,93 +0,0 @@
-#
-# This file is part of ruby-ffi.
-# For licensing, see LICENSE.SPECS
-#
-
-require 'rbconfig'
-require 'fileutils'
-require 'ffi'
-
-RSpec.configure do |c|
-  c.filter_run_excluding :broken => true
-end
-
-CPU = case RbConfig::CONFIG['host_cpu'].downcase
-  when /i[3456]86/
-    # Darwin always reports i686, even when running in 64bit mode
-    if RbConfig::CONFIG['host_os'] =~ /darwin/ && 0xfee1deadbeef.is_a?(Fixnum)
-      "x86_64"
-    else
-      "i386"
-    end
-
-  when /amd64|x86_64/
-    "x86_64"
-
-  when /ppc64|powerpc64/
-    "powerpc64"
-
-  when /ppc|powerpc/
-    "powerpc"
-
-  when /^arm/
-    "arm"
-
-  else
-    RbConfig::CONFIG['host_cpu']
-  end
-
-OS = case RbConfig::CONFIG['host_os'].downcase
-  when /linux/
-    "linux"
-  when /darwin/
-    "darwin"
-  when /freebsd/
-    "freebsd"
-  when /openbsd/
-    "openbsd"
-  when /sunos|solaris/
-    "solaris"
-  when /mswin|mingw/
-    "win32"
-  else
-    RbConfig::CONFIG['host_os'].downcase
-  end
-
-def compile_library(path, lib)
-
-  dir = File.expand_path(path, File.dirname(__FILE__))
-  lib = "#{dir}/#{lib}"
-  if !File.exist?(lib)
-    output = nil
-    FileUtils.cd(dir) do
-      output = system(*%{#{system('which gmake >/dev/null') && 'gmake' || 'make'} CPU=#{CPU} OS=#{OS} }.tap{|x| puts x.inspect})
-    end
-
-    if $?.exitstatus != 0
-      puts "ERROR:\n#{output}"
-      raise "Unable to compile \"#{lib}\""
-    end
-  end
-
-  lib
-end
-
-require "ffi"
-
-module TestLibrary
-  PATH = compile_library("fixtures", "libtest.#{FFI::Platform::LIBSUFFIX}")
-
-  def self.force_gc
-    if RUBY_PLATFORM =~ /java/
-      java.lang.System.gc
-    elsif defined?(RUBY_ENGINE) && RUBY_ENGINE == 'rbx'
-      GC.run(true)
-    else
-      GC.start
-    end
-  end
-end
-module LibTest
-  extend FFI::Library
-  ffi_lib TestLibrary::PATH
-end

data/spec/ffi/string_spec.rb

@@ -1,118 +0,0 @@
-#
-# This file is part of ruby-ffi.
-# For licensing, see LICENSE.SPECS
-#
-
-require File.expand_path(File.join(File.dirname(__FILE__), "spec_helper"))
-describe "String tests" do
-  include FFI
-  module StrLibTest
-    extend FFI::Library
-    ffi_lib TestLibrary::PATH
-    attach_function :ptr_ret_pointer, [ :pointer, :int], :string
-    attach_function :string_equals, [ :string, :string ], :int
-    attach_function :string_dummy, [ :string ], :void
-    attach_function :string_null, [ ], :string
-  end
-
-  it "MemoryPointer#get_string returns a tainted string" do
-    mp = FFI::MemoryPointer.new 1024
-    mp.put_string(0, "test\0")
-    str = mp.get_string(0)
-    expect(str.tainted?).to be true
-  end
-
-  it "String returned by a method is tainted" do
-    mp = FFI::MemoryPointer.new :pointer
-    sp = FFI::MemoryPointer.new 1024
-    sp.put_string(0, "test")
-    mp.put_pointer(0, sp)
-    str = StrLibTest.ptr_ret_pointer(mp, 0)
-    expect(str).to eq("test")
-    expect(str).to be_tainted
-  end
-
-  it "Poison null byte raises error" do
-    s = "123\0abc"
-    expect { StrLibTest.string_equals(s, s) }.to raise_error
-  end
-
-  it "Tainted String parameter should throw a SecurityError" do
-    $SAFE = 1
-    str = "test"
-    str.taint
-    begin
-      expect(LibTest.string_equals(str, str)).to be false
-    rescue SecurityError
-    end
-  end if false
-  it "casts nil as NULL pointer" do
-    expect(StrLibTest.string_dummy(nil)).to be_nil
-  end
-
-  it "return nil for NULL char*" do
-    expect(StrLibTest.string_null).to be_nil
-  end
-
-  it "reads an array of strings until encountering a NULL pointer" do
-    strings = ["foo", "bar", "baz", "testing", "ffi"]
-    ptrary = FFI::MemoryPointer.new(:pointer, 6)
-    ary = strings.inject([]) do |a, str|
-      f = FFI::MemoryPointer.new(1024)
-      f.put_string(0, str)
-      a << f
-    end
-    ary.insert(3, nil)
-    ptrary.write_array_of_pointer(ary)
-    expect(ptrary.get_array_of_string(0)).to eq(["foo", "bar", "baz"])
-  end
-
-  it "reads an array of strings of the size specified, substituting nil when a pointer is NULL" do
-    strings = ["foo", "bar", "baz", "testing", "ffi"]
-    ptrary = FFI::MemoryPointer.new(:pointer, 6)
-    ary = strings.inject([]) do |a, str|
-      f = FFI::MemoryPointer.new(1024)
-      f.put_string(0, str)
-      a << f
-    end
-    ary.insert(2, nil)
-    ptrary.write_array_of_pointer(ary)
-    expect(ptrary.get_array_of_string(0, 4)).to eq(["foo", "bar", nil, "baz"])
-  end
-
-  it "reads an array of strings, taking a memory offset parameter" do
-    strings = ["foo", "bar", "baz", "testing", "ffi"]
-    ptrary = FFI::MemoryPointer.new(:pointer, 5)
-    ary = strings.inject([]) do |a, str|
-      f = FFI::MemoryPointer.new(1024)
-      f.put_string(0, str)
-      a << f
-    end
-    ptrary.write_array_of_pointer(ary)
-    expect(ptrary.get_array_of_string(2 * FFI.type_size(:pointer), 3)).to eq(["baz", "testing", "ffi"])
-  end
-
-  it "raises an IndexError when trying to read an array of strings out of bounds" do
-    strings = ["foo", "bar", "baz", "testing", "ffi"]
-    ptrary = FFI::MemoryPointer.new(:pointer, 5)
-    ary = strings.inject([]) do |a, str|
-      f = FFI::MemoryPointer.new(1024)
-      f.put_string(0, str)
-      a << f
-    end
-    ptrary.write_array_of_pointer(ary)
-    expect { ptrary.get_array_of_string(0, 6) }.to raise_error
-  end
-
-  it "raises an IndexError when trying to read an array of strings using a negative offset" do
-    strings = ["foo", "bar", "baz", "testing", "ffi"]
-    ptrary = FFI::MemoryPointer.new(:pointer, 5)
-    ary = strings.inject([]) do |a, str|
-      f = FFI::MemoryPointer.new(1024)
-      f.put_string(0, str)
-      a << f
-    end
-    ptrary.write_array_of_pointer(ary)
-    expect { ptrary.get_array_of_string(-1) }.to raise_error
-  end
-end

data/spec/ffi/strptr_spec.rb

@@ -1,50 +0,0 @@
-#
-# 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 returning :strptr" do
-
-  it "can attach function with :strptr return type" do
-    expect do
-      Module.new do
-        extend FFI::Library
-        ffi_lib FFI::Library::LIBC
-        if !FFI::Platform.windows?
-          attach_function :strdup, [ :string ], :strptr
-        else
-          attach_function :_strdup, [ :string ], :strptr
-        end
-      end
-    end.not_to raise_error
-  end
-
-  module StrPtr
-    extend FFI::Library
-    ffi_lib FFI::Library::LIBC
-    attach_function :free, [ :pointer ], :void
-    if !FFI::Platform.windows?
-      attach_function :strdup, [ :string ], :strptr
-    else
-      attach_function :strdup, :_strdup, [ :string ], :strptr
-    end
-  end
-
-  it "should return [ String, Pointer ]" do
-    result = StrPtr.strdup("test")
-    expect(result[0].is_a?(String)).to be true
-    expect(result[1].is_a?(FFI::Pointer)).to be true
-  end
-
-  it "should return the correct value" do
-    result = StrPtr.strdup("test")
-    expect(result[0]).to eq("test")
-  end
-
-  it "should return non-NULL pointer" do
-    result = StrPtr.strdup("test")
-    expect(result[1]).not_to be_null
-  end
-end

data/spec/ffi/struct_by_ref_spec.rb

@@ -1,43 +0,0 @@
-#
-# 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::Struct, ' by_ref' do
-  before :all do
-    @struct_class = struct_class = Class.new(FFI::Struct) do
-      layout :a, :pointer
-    end
-
-    @api = Module.new do
-      extend FFI::Library
-      ffi_lib TestLibrary::PATH
-      fn = FFI::Type::POINTER.size == FFI::Type::LONG.size ? :ret_ulong : :ret_u64
-      attach_function :struct_test, fn, [ struct_class.by_ref ], :pointer
-    end
-  end
-
-  it "should accept instances of exact struct class" do
-    s = @struct_class.new
-    expect(@api.struct_test(s)).to eq(s.pointer)
-  end
-
-  it "should accept nil" do
-    expect(@api.struct_test(nil)).to be_null
-  end
-
-  it "should reject other types" do
-    expect { expect(@api.struct_test('test')).to be_nil }.to raise_error(TypeError)
-  end
-
-  it "should reject instances of other struct classes" do
-    other_class = Class.new(FFI::Struct) do
-      layout :a, :pointer
-    end
-
-    expect { @api.struct_test(other_class.new) }.to raise_error(TypeError)
-  end
-end
-

data/spec/ffi/struct_callback_spec.rb

@@ -1,69 +0,0 @@
-#
-# 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::Struct, ' with inline callback functions' do
-  it 'should be able to define inline callback field' do
-    expect(module CallbackMember1
-      extend FFI::Library
-      ffi_lib TestLibrary::PATH
-      DUMMY_CB = callback :dummy_cb, [ :int ], :int
-      class TestStruct < FFI::Struct
-        layout \
-          :add, callback([ :int, :int ], :int),
-          :sub, callback([ :int, :int ], :int),
-          :cb_with_cb_parameter, callback([ DUMMY_CB, :int ], :int)
-      end
-      attach_function :struct_call_add_cb, [TestStruct, :int, :int], :int
-      attach_function :struct_call_sub_cb, [TestStruct, :int, :int], :int
-    end).to be_an_instance_of FFI::Function
-  end
-
-  it 'should take methods as callbacks' do
-    module CallbackMember2
-      extend FFI::Library
-      ffi_lib TestLibrary::PATH
-      class TestStruct < FFI::Struct
-        layout \
-          :add, callback([ :int, :int ], :int),
-          :sub, callback([ :int, :int ], :int)
-      end
-      attach_function :struct_call_add_cb, [TestStruct, :int, :int], :int
-      attach_function :struct_call_sub_cb, [TestStruct, :int, :int], :int
-    end
-    module StructCallbacks
-      def self.add a, b
-        a+b
-      end
-    end
-
-    ts = CallbackMember2::TestStruct.new
-    ts[:add] = StructCallbacks.method(:add)
-
-    expect(CallbackMember2.struct_call_add_cb(ts, 1, 2)).to eq(3)
-  end
-
-  it 'should return callable object from []' do
-    module CallbackMember3
-      extend FFI::Library
-      ffi_lib TestLibrary::PATH
-      class TestStruct < FFI::Struct
-        layout \
-          :add, callback([ :int, :int ], :int),
-          :sub, callback([ :int, :int ], :int)
-      end
-      attach_function :struct_call_add_cb, [TestStruct, :int, :int], :int
-      attach_function :struct_call_sub_cb, [TestStruct, :int, :int], :int
-    end
-
-    s = CallbackMember3::TestStruct.new
-    add = Proc.new { |a,b| a+b}
-    s[:add] = add
-    fn = s[:add]
-    expect(fn.respond_to?(:call)).to be true
-    expect(fn.call(1, 2)).to eq(3)
-  end
-end

data/spec/ffi/struct_initialize_spec.rb

@@ -1,35 +0,0 @@
-#
-# 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::Struct, ' with an initialize function' do
-  it "should call the initialize function" do
-    class StructWithInitialize < FFI::Struct
-      layout :string, :string
-      attr_accessor :magic
-      def initialize
-        super
-        self.magic = 42
-      end
-    end
-    expect(StructWithInitialize.new.magic).to eq(42)
-  end
-end
-
-describe FFI::ManagedStruct, ' with an initialize function' do
-  it "should call the initialize function" do
-    class ManagedStructWithInitialize < FFI::ManagedStruct
-      layout :string, :string
-      attr_accessor :magic
-      def initialize
-        super FFI::MemoryPointer.new(:pointer).put_int(0, 0x1234).get_pointer(0)
-        self.magic = 42
-      end
-      def self.release;end
-    end
-    expect(ManagedStructWithInitialize.new.magic).to eq(42)
-  end
-end

data/spec/ffi/struct_packed_spec.rb

@@ -1,50 +0,0 @@
-#
-# 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::Struct do
-  it "packed :char followed by :int should have size of 5" do
-    expect(Class.new(FFI::Struct) do
-      packed
-      layout :c, :char, :i, :int
-    end.size).to eq(5)
-  end
-
-  it "packed :char followed by :int should have alignment of 1" do
-    expect(Class.new(FFI::Struct) do
-      packed
-      layout :c, :char, :i, :int
-    end.alignment).to eq(1)
-  end
-
-  it "packed(2) :char followed by :int should have size of 6" do
-    expect(Class.new(FFI::Struct) do
-      packed 2
-      layout :c, :char, :i, :int
-    end.size).to eq(6)
-  end
-
-  it "packed(2)  :char followed by :int should have alignment of 2" do
-    expect(Class.new(FFI::Struct) do
-      packed 2
-      layout :c, :char, :i, :int
-    end.alignment).to eq(2)
-  end
-
-  it "packed :short followed by int should have size of 6" do
-    expect(Class.new(FFI::Struct) do
-      packed
-      layout :s, :short, :i, :int
-    end.size).to eq(6)
-  end
-
-  it "packed :short followed by int should have alignment of 1" do
-    expect(Class.new(FFI::Struct) do
-      packed
-      layout :s, :short, :i, :int
-    end.alignment).to eq(1)
-  end
-end