ffi 1.9.21-x86-mingw32 → 1.9.22-x86-mingw32

data/spec/ffi/rbx/attach_function_spec.rb

@@ -1,34 +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"))
-
-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

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

@@ -1,6 +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"))

data/spec/ffi/rbx/struct_spec.rb

@@ -1,18 +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"))
-
-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

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