minilab 1.1.0-x86-mswin32-60

data/vendor/ffi-0.4.0-x86-mswin32/spec/ffi/pointer_spec.rb

@@ -0,0 +1,195 @@
+require File.expand_path(File.join(File.dirname(__FILE__), "spec_helper"))
+require 'delegate'
+require 'java' if RUBY_PLATFORM =~ /java/
+
+module LibTest
+  attach_function :ptr_ret_int32_t, [ :pointer, :int ], :int
+  attach_function :ptr_from_address, [ FFI::Platform::ADDRESS_SIZE == 32 ? :uint : :ulong_long ], :pointer
+  attach_function :ptr_set_pointer, [ :pointer, :int, :pointer ], :void
+  attach_function :ptr_ret_pointer, [ :pointer, :int ], :pointer
+end
+describe "Pointer" do
+  include FFI
+  class ToPtrTest
+    def initialize(ptr)
+      @ptr = ptr
+    end
+    def to_ptr
+      @ptr
+    end
+  end
+  it "Any object implementing #to_ptr can be passed as a :pointer parameter" do
+    memory = FFI::MemoryPointer.new :long_long
+    magic = 0x12345678
+    memory.put_int32(0, magic)
+    tp = ToPtrTest.new(memory)
+    LibTest.ptr_ret_int32_t(tp, 0).should == magic
+  end
+  class PointerDelegate < DelegateClass(FFI::Pointer)
+    def initialize(ptr)
+      @ptr = ptr
+    end
+    def to_ptr
+      @ptr
+    end
+  end
+  it "A DelegateClass(Pointer) can be passed as a :pointer parameter" do
+    memory = FFI::MemoryPointer.new :long_long
+    magic = 0x12345678
+    memory.put_int32(0, magic)
+    ptr = PointerDelegate.new(memory)
+    LibTest.ptr_ret_int32_t(ptr, 0).should == magic
+  end
+  it "Fixnum cannot be used as a Pointer argument" do
+    lambda { LibTest.ptr_ret_int32(0, 0) }.should raise_error
+  end
+  it "Bignum cannot be used as a Pointer argument" do
+    lambda { LibTest.ptr_ret_int32(0xfee1deadbeefcafebabe, 0) }.should raise_error
+  end
+
+  describe "pointer type methods" do
+
+    describe "#read_pointer" do
+      memory = FFI::MemoryPointer.new :pointer
+      LibTest.ptr_set_pointer(memory, 0, LibTest.ptr_from_address(0xdeadbeef))
+      memory.read_pointer.address.should == 0xdeadbeef
+    end
+
+    describe "#write_pointer" do
+      memory = FFI::MemoryPointer.new :pointer
+      memory.write_pointer(LibTest.ptr_from_address(0xdeadbeef))
+      LibTest.ptr_ret_pointer(memory, 0).address.should == 0xdeadbeef
+    end
+
+    describe "#read_array_of_pointer" do
+      values = [0x12345678, 0xfeedf00d, 0xdeadbeef]
+      memory = FFI::MemoryPointer.new :pointer, values.size
+      values.each_with_index do |address, j|
+        LibTest.ptr_set_pointer(memory, j * FFI.type_size(:pointer), LibTest.ptr_from_address(address))
+      end
+      array = memory.read_array_of_pointer(values.size)
+      values.each_with_index do |address, j|
+        array[j].address.should == address
+      end
+    end
+
+    describe "#write_array_of_pointer" do
+      values = [0x12345678, 0xfeedf00d, 0xdeadbeef]
+      memory = FFI::MemoryPointer.new :pointer, values.size
+      memory.write_array_of_pointer(values.map { |address| LibTest.ptr_from_address(address) })
+      array = []
+      values.each_with_index do |address, j|
+        array << LibTest.ptr_ret_pointer(memory, j * FFI.type_size(:pointer))
+      end
+      values.each_with_index do |address, j|
+        array[j].address.should == address
+      end
+    end
+    
+  end
+
+  describe 'NULL' do
+    it 'should be obtained using Pointer::NULL constant' do
+      null_ptr = FFI::Pointer::NULL
+      null_ptr.null?.should be_true
+    end
+    it 'should be obtained passing address 0 to constructor' do
+      FFI::Pointer.new(0).null?.should be_true
+    end
+    it 'should raise an error when attempting read/write operations on it' do
+      null_ptr = FFI::Pointer::NULL
+      lambda { null_ptr.read_int }.should raise_error(FFI::NullPointerError)
+      lambda { null_ptr.write_int(0xff1) }.should raise_error(FFI::NullPointerError)
+    end
+  end
+
+end
+
+describe "AutoPointer" do
+  loop_count = 30
+  wiggle_room = 2 # GC rarely cleans up all objects. we can get most of them, and that's enough to determine if the basic functionality is working.
+  magic = 0x12345678
+
+  class AutoPointerTestHelper
+    @@count = 0
+    def self.release
+      @@count += 1 if @@count > 0
+    end
+    def self.reset
+      @@count = 0
+    end
+    def self.gc_everything(count)
+      loop = 5
+      while @@count < count && loop > 0
+        loop -= 1
+        if RUBY_PLATFORM =~ /java/
+          java.lang.System.gc
+        else
+          GC.start
+        end
+        sleep 0.05 unless @@count == count
+      end
+      @@count = 0
+    end
+    def self.finalizer
+      self.method(:release).to_proc
+    end
+  end
+  class AutoPointerSubclass < FFI::AutoPointer
+    def self.release(ptr); end
+  end
+  it "cleanup via default release method" do
+    AutoPointerSubclass.should_receive(:release).at_least(loop_count-wiggle_room).times
+    AutoPointerTestHelper.reset
+    loop_count.times do
+      # note that if we called
+      # AutoPointerTestHelper.method(:release).to_proc inline, we'd
+      # have a reference to the pointer and it would never get GC'd.
+      ap = AutoPointerSubclass.new(LibTest.ptr_from_address(magic))
+    end
+    AutoPointerTestHelper.gc_everything loop_count
+  end
+
+  it "cleanup when passed a proc" do
+    #  NOTE: passing a proc is touchy, because it's so easy to create a memory leak.
+    #
+    #  specifically, if we made an inline call to
+    #
+    #      AutoPointerTestHelper.method(:release).to_proc
+    #
+    #  we'd have a reference to the pointer and it would
+    #  never get GC'd.
+    AutoPointerTestHelper.should_receive(:release).at_least(loop_count-wiggle_room).times
+    AutoPointerTestHelper.reset
+    loop_count.times do
+      ap = FFI::AutoPointer.new(LibTest.ptr_from_address(magic),
+                                AutoPointerTestHelper.finalizer)
+    end
+    AutoPointerTestHelper.gc_everything loop_count
+  end
+
+  it "cleanup when passed a method" do
+    AutoPointerTestHelper.should_receive(:release).at_least(loop_count-wiggle_room).times
+    AutoPointerTestHelper.reset
+    loop_count.times do
+      ap = FFI::AutoPointer.new(LibTest.ptr_from_address(magic),
+                                AutoPointerTestHelper.method(:release))
+    end
+    AutoPointerTestHelper.gc_everything loop_count
+  end
+end
+describe "AutoPointer#new" do
+  class AutoPointerSubclass < FFI::AutoPointer
+    def self.release(ptr); end
+  end
+  it "MemoryPointer argument raises ArgumentError" do
+    lambda { FFI::AutoPointer.new(FFI::MemoryPointer.new(:int))}.should raise_error(::TypeError)
+  end
+  it "AutoPointer argument raises ArgumentError" do
+    lambda { AutoPointerSubclass.new(AutoPointerSubclass.new(LibTest.ptr_from_address(0))) }.should raise_error(::TypeError)
+  end
+  it "Buffer argument raises ArgumentError" do
+    lambda { FFI::AutoPointer.new(FFI::Buffer.new(:int))}.should raise_error(::TypeError)
+  end
+
+end

data/vendor/ffi-0.4.0-x86-mswin32/spec/ffi/rbx/attach_function_spec.rb

@@ -0,0 +1,27 @@
+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
+
+module LibC
+  extend FFI::Library
+  
+  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)
+    time.should be_kind_of(Integer)
+  end
+  
+  it "correctly populates a struct for gettimeofday" do
+    t = Timeval.new
+    time = LibC.gettimeofday(t.pointer, nil)
+    t[:tv_sec].should be_kind_of(Numeric)
+    t[:tv_usec].should be_kind_of(Numeric)
+  end
+end
+

data/vendor/ffi-0.4.0-x86-mswin32/spec/ffi/rbx/memory_pointer_spec.rb

@@ -0,0 +1,102 @@
+require "rubygems"
+require File.expand_path(File.join(File.dirname(__FILE__), "spec_helper"))
+
+module CTest
+  extend FFI::Library
+  
+  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")
+    m.type_size.should == 15
+  end
+  
+  it "reads back a string" do
+    m = FFI::MemoryPointer.from_string("FFI is Awesome")
+    m.read_string.should == "FFI is Awesome"
+  end
+  
+  it "makes a pointer for a certain number of bytes" do
+    m = FFI::MemoryPointer.new(8)
+    m.write_array_of_int([1,2])
+    m.read_array_of_int(2).should == [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])
+    m[0].read_int.should == 1
+    m[1].read_int.should == 2
+  end
+  
+  it "allows writing as an int" do
+    m = FFI::MemoryPointer.new(:int)
+    m.write_int(1)
+    m.read_int.should == 1
+  end
+  
+  it "allows writing as a long" do
+    m = FFI::MemoryPointer.new(:long)
+    m.write_long(10)
+    m.read_long.should == 10
+  end
+  
+  it "raises an error if you try putting a long into a pointer of size 1" do
+    m = FFI::MemoryPointer.new(1)
+    lambda { m.write_long(10) }.should 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)
+    lambda { m.write_int(10) }.should 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)
+    m.read_int.should == 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])
+    m.read_array_of_int(2).should == [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])
+    m.read_array_of_int(2).should == [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])
+    m.read_array_of_int(2).should == [1,2]
+  end  
+  it "MemoryPointer#address returns correct value" do
+    m = FFI::MemoryPointer.new(:long_long)
+    magic = 0x12345678
+    m.write_long(magic)
+    m.read_pointer.address.should == magic
+  end
+  it "MemoryPointer#null? returns true for zero value" do
+    m = FFI::MemoryPointer.new(:long_long)
+    m.write_long(0)    
+    m.read_pointer.null?.should == true
+  end
+  it "MemoryPointer#null? returns false for non-zero value" do
+    m = FFI::MemoryPointer.new(:long_long)
+    m.write_long(0x12345678)
+    m.read_pointer.null?.should == false
+  end
+end

data/vendor/ffi-0.4.0-x86-mswin32/spec/ffi/rbx/spec_helper.rb

@@ -0,0 +1 @@
+require File.expand_path(File.join(File.dirname(__FILE__), "..", "spec_helper"))

data/vendor/ffi-0.4.0-x86-mswin32/spec/ffi/rbx/struct_spec.rb

@@ -0,0 +1,13 @@
+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
+    t[:tv_sec].should == 12
+  end
+end

data/vendor/ffi-0.4.0-x86-mswin32/spec/ffi/spec_helper.rb

@@ -0,0 +1,17 @@
+require 'rubygems'
+require 'rbconfig'
+require 'spec'
+
+if ENV["MRI_FFI"]
+  $:.unshift File.join(File.dirname(__FILE__), "..", "..", "lib"),
+    File.join(File.dirname(__FILE__), "..", "..", "build", "#{Config::CONFIG['host_cpu''arch']}", "ffi_c", RUBY_VERSION)
+end
+require "ffi"
+
+module TestLibrary
+  PATH = "build/libtest.#{FFI::Platform::LIBSUFFIX}"
+end
+module LibTest
+  extend FFI::Library
+  ffi_lib TestLibrary::PATH
+end

data/vendor/ffi-0.4.0-x86-mswin32/spec/ffi/string_spec.rb

@@ -0,0 +1,103 @@
+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 = MemoryPointer.new 1024
+    mp.put_string(0, "test\0")
+    str = mp.get_string(0)
+    str.tainted?.should == true
+  end
+  it "String returned by a method is tainted" do
+    mp = MemoryPointer.new :pointer
+    sp = MemoryPointer.new 1024
+    sp.put_string(0, "test")
+    mp.put_pointer(0, sp)
+    str = StrLibTest.ptr_ret_pointer(mp, 0)
+    str.should == "test"
+    str.tainted?.should == true
+  end
+  it "Poison null byte raises error" do
+    s = "123\0abc"
+    lambda { StrLibTest.string_equals(s, s) }.should raise_error
+  end
+  it "Tainted String parameter should throw a SecurityError" do
+    $SAFE = 1
+    str = "test"
+    str.taint
+    begin
+      LibTest.string_equals(str, str).should == false
+    rescue SecurityError => e
+    end
+  end if false
+  it "casts nil as NULL pointer" do
+    StrLibTest.string_dummy(nil)
+  end
+  it "return nil for NULL char*" do
+    StrLibTest.string_null.should == nil
+  end
+  it "reads an array of strings until encountering a NULL pointer" do
+    strings = ["foo", "bar", "baz", "testing", "ffi"]
+    ptrary = MemoryPointer.new(:pointer, 6)
+    ary = strings.inject([]) do |a, str|
+      f = MemoryPointer.new(1024)
+      f.put_string(0, str)
+      a << f
+    end
+    ary.insert(3, nil)
+    ptrary.write_array_of_pointer(ary)
+    ptrary.get_array_of_string(0).should == ["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 = MemoryPointer.new(:pointer, 6)
+    ary = strings.inject([]) do |a, str|
+      f = MemoryPointer.new(1024)
+      f.put_string(0, str)
+      a << f
+    end
+    ary.insert(2, nil)
+    ptrary.write_array_of_pointer(ary)
+    ptrary.get_array_of_string(0, 4).should == ["foo", "bar", nil, "baz"]
+  end
+  it "reads an array of strings, taking a memory offset parameter" do
+    strings = ["foo", "bar", "baz", "testing", "ffi"]
+    ptrary = MemoryPointer.new(:pointer, 5)
+    ary = strings.inject([]) do |a, str|
+      f = MemoryPointer.new(1024)
+      f.put_string(0, str)
+      a << f
+    end
+    ptrary.write_array_of_pointer(ary)
+    ptrary.get_array_of_string(2 * FFI.type_size(:pointer), 3).should == ["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 = MemoryPointer.new(:pointer, 5)
+    ary = strings.inject([]) do |a, str|
+      f = MemoryPointer.new(1024)
+      f.put_string(0, str)
+      a << f
+    end
+    ptrary.write_array_of_pointer(ary)
+    lambda { ptrary.get_array_of_string(0, 6) }.should 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 = MemoryPointer.new(:pointer, 5)
+    ary = strings.inject([]) do |a, str|
+      f = MemoryPointer.new(1024)
+      f.put_string(0, str)
+      a << f
+    end
+    ptrary.write_array_of_pointer(ary)
+    lambda { ptrary.get_array_of_string(-1) }.should raise_error
+  end
+end