alinta-ffi 1.9.19

data/spec/ffi/rbx/attach_function_spec.rb

@@ -0,0 +1,34 @@
+#
+# This file is part of ruby-ffi.
+# For licensing, see LICENSE.SPECS
+#
+
+require File.expand_path(File.join(File.dirname(__FILE__), "spec_helper"))
+
+unless FFI::Platform.windows?
+  class Timeval < FFI::Struct
+    layout :tv_sec, :ulong, 0, :tv_usec, :ulong, 4
+  end
+
+  module LibC
+    extend FFI::Library
+    ffi_lib FFI::Library::LIBC
+
+    attach_function :gettimeofday, [:pointer, :pointer], :int
+  end
+
+  describe FFI::Library, "#attach_function" do
+    it "correctly returns a value for gettimeofday" do
+      t = Timeval.new
+      time = LibC.gettimeofday(t.pointer, nil)
+      expect(time).to be_kind_of(Integer)
+    end
+
+    it "correctly populates a struct for gettimeofday" do
+      t = Timeval.new
+      LibC.gettimeofday(t.pointer, nil)
+      expect(t[:tv_sec]).to be_kind_of(Numeric)
+      expect(t[:tv_usec]).to be_kind_of(Numeric)
+    end
+  end
+end

data/spec/ffi/rbx/memory_pointer_spec.rb

@@ -0,0 +1,198 @@
+# coding: utf-8
+#
+# This file is part of ruby-ffi.
+# For licensing, see LICENSE.SPECS
+#
+
+require File.expand_path(File.join(File.dirname(__FILE__), "spec_helper"))
+
+module CTest
+  extend FFI::Library
+  ffi_lib FFI::Library::LIBC
+
+  attach_function :strcat, [:pointer, :pointer], :pointer
+end
+
+describe "MemoryPointer" do
+  it "makes a pointer from a string" do
+    m = FFI::MemoryPointer.from_string("FFI is Awesome")
+    expect(m.total).to eq(15)
+    expect(m.type_size).to eq(1)
+  end
+
+  it "does not make a pointer from non-strings" do
+    expect { FFI::MemoryPointer.from_string(nil) }.to raise_error(TypeError)
+  end
+
+  it "makes a pointer from a string with multibyte characters" do
+    m = FFI::MemoryPointer.from_string("ぱんだ")
+    expect(m.total).to eq(10)
+    expect(m.type_size).to eq(1)
+  end
+
+  it "reads back a string" do
+    m = FFI::MemoryPointer.from_string("FFI is Awesome")
+    expect(m.read_string).to eq("FFI is Awesome")
+  end
+
+  it "reads back an empty string" do
+    expect(FFI::Pointer::NULL.read_string(0)).to eq('')
+  end
+  
+  it "makes a pointer for a certain number of bytes" do
+    m = FFI::MemoryPointer.new(8)
+    m.write_array_of_int([1,2])
+    expect(m.read_array_of_int(2)).to eq([1,2])
+  end
+
+  it "allows access to an element of the pointer (as an array)" do
+    m = FFI::MemoryPointer.new(:int, 2)
+    m.write_array_of_int([1,2])
+    expect(m[0].read_int).to eq(1)
+    expect(m[1].read_int).to eq(2)
+  end
+  
+  it "allows writing as an int" do
+    m = FFI::MemoryPointer.new(:int)
+    m.write_int(1)
+    expect(m.read_int).to eq(1)
+    expect(m.read :int).to eq(1)
+    expect(m.read FFI::Type::INT).to eq(1)
+  end
+
+  it "allows writing as a sized int" do
+    m = FFI::MemoryPointer.new(:uint32)
+    m.write_uint32(1)
+    expect(m.read_uint32).to eq(1)
+    expect(m.read :uint32).to eq(1)
+    expect(m.read FFI::Type::UINT32).to eq(1)
+
+    m = FFI::MemoryPointer.new(:uint32)
+    m.write :uint32, 1
+    expect(m.read :uint32).to eq(1)
+
+    m = FFI::MemoryPointer.new(:int64)
+    m.write_int64(1)
+    expect(m.read_int64).to eq(1)
+    expect(m.read :int64).to eq(1)
+    expect(m.read FFI::Type::INT64).to eq(1)
+
+    m = FFI::MemoryPointer.new(:int64)
+    m.write :int64, 1
+    expect(m.read :int64).to eq(1)
+  end
+
+  it "allows writing as a long" do
+    m = FFI::MemoryPointer.new(:long)
+    m.write_long(10)
+    expect(m.read_long).to eq(10)
+    expect(m.read :long).to eq(10)
+    expect(m.read FFI::Type::LONG).to eq(10)
+
+    m.write :long, 10
+    expect(m.read :long).to eq(10)
+  end
+
+  it "allows writing as a size_t" do
+    m = FFI::MemoryPointer.new(:size_t)
+    m.write(:size_t, 10)
+    expect(m.read :size_t).to eq(10)
+  end
+
+  it "allows writing as a bool" do
+    m = FFI::MemoryPointer.new(:bool)
+    m.write(:bool, true)
+    expect(m.read :bool).to eq(true)
+    expect(m.read FFI::Type::BOOL).to eq(true)
+
+    m.write(:bool, false)
+    expect(m.read :bool).to eq(false)
+    expect(m.read FFI::Type::BOOL).to eq(false)
+  end
+
+  it "allows writing a custom typedef" do
+    FFI.typedef :uint, :fubar_t
+    FFI.typedef :size_t, :fubar2_t
+
+    m = FFI::MemoryPointer.new(:fubar_t)
+    m.write(:fubar_t, 10)
+    expect(m.read :fubar_t).to eq(10)
+
+    m = FFI::MemoryPointer.new(:fubar2_t)
+    m.write(:fubar2_t, 10)
+    expect(m.read :fubar2_t).to eq(10)
+  end
+
+  it "raises an error if you try to read an undefined type" do
+    m = FFI::MemoryPointer.new(:long)
+    expect { m.read(:undefined_type) }.to raise_error(ArgumentError)
+  end
+  
+  it "raises an error if you try putting a long into a pointer of size 1" do
+    m = FFI::MemoryPointer.new(1)
+    expect { m.write_long(10) }.to raise_error
+  end
+  
+  it "raises an error if you try putting an int into a pointer of size 1" do
+    m = FFI::MemoryPointer.new(1)
+    expect { m.write_int(10) }.to raise_error
+  end
+#  it "does not raise IndexError for opaque pointers" do
+#    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 = FFI::MemoryPointer.new(:int)
+    m.write_int(10)
+    expect(m.read_int).to eq(10)
+  end
+  
+  it "makes a memory pointer for a number of a certain type" do
+    m = FFI::MemoryPointer.new(:int, 2)
+    m.write_array_of_int([1,2])
+    expect(m.read_array_of_int(2)).to eq([1,2])
+  end
+  
+  it "makes a pointer for an object responding to #size" do
+    m = FFI::MemoryPointer.new(Struct.new(:size).new(8))
+    m.write_array_of_int([1,2])
+    expect(m.read_array_of_int(2)).to eq([1,2])
+  end
+
+  it "makes a pointer for a number of an object responding to #size" do
+    m = FFI::MemoryPointer.new(Struct.new(:size).new(4), 2)
+    m.write_array_of_int([1,2])
+    expect(m.read_array_of_int(2)).to eq([1,2])
+  end  
+
+  it "MemoryPointer#address returns correct value" do
+    m = FFI::MemoryPointer.new(:long_long)
+    magic = 0x12345678
+    m.write_long(magic)
+    expect(m.read_pointer.address).to eq(magic)
+  end
+
+  it "MemoryPointer#null? returns true for zero value" do
+    m = FFI::MemoryPointer.new(:long_long)
+    m.write_long(0)    
+    expect(m.read_pointer.null?).to be true
+  end
+
+  it "MemoryPointer#null? returns false for non-zero value" do
+    m = FFI::MemoryPointer.new(:long_long)
+    m.write_long(0x12345678)
+    expect(m.read_pointer.null?).to be false
+  end
+  
+  it "initialize with block should execute block" do
+    block_executed = false
+    FFI::MemoryPointer.new(:pointer) do |ptr|
+      block_executed = true
+    end
+    expect(block_executed).to be true
+  end
+end

data/spec/ffi/rbx/spec_helper.rb

@@ -0,0 +1,6 @@
+#
+# This file is part of ruby-ffi.
+# For licensing, see LICENSE.SPECS
+#
+
+require File.expand_path(File.join(File.dirname(__FILE__), "../spec_helper"))

data/spec/ffi/rbx/struct_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"))
+
+class Timeval < FFI::Struct
+  layout :tv_sec, :ulong, 0, :tv_usec, :ulong, 4  
+end
+
+describe FFI::Struct do
+  it "allows setting fields" do
+    t = Timeval.new
+    t[:tv_sec] = 12
+    expect(t[:tv_sec]).to eq(12)
+  end
+end

data/spec/ffi/spec_helper.rb

@@ -0,0 +1,93 @@
+#
+# 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

@@ -0,0 +1,118 @@
+#
+# 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