librarian-puppet 0.9.2 → 0.9.3

data/vendor/gems/ruby/1.8/gems/ffi-1.1.5/spec/ffi/rbx/attach_function_spec.rb

@@ -0,0 +1,28 @@
+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
+  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)
+    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/gems/ruby/1.8/gems/ffi-1.1.5/spec/ffi/rbx/memory_pointer_spec.rb

@@ -0,0 +1,115 @@
+# coding: utf-8
+require "rubygems"
+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")
+    m.total.should eq 15
+    m.type_size.should 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("ぱんだ")
+    m.total.should eq 10
+    m.type_size.should eq 1
+  end
+
+  it "reads back a string" do
+    m = FFI::MemoryPointer.from_string("FFI is Awesome")
+    m.read_string.should eq "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 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])
+    m[0].read_int.should eq 1
+    m[1].read_int.should eq 2
+  end
+  
+  it "allows writing as an int" do
+    m = FFI::MemoryPointer.new(:int)
+    m.write_int(1)
+    m.read_int.should eq 1
+  end
+  
+  it "allows writing as a long" do
+    m = FFI::MemoryPointer.new(:long)
+    m.write_long(10)
+    m.read_long.should eq 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 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])
+    m.read_array_of_int(2).should 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])
+    m.read_array_of_int(2).should 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])
+    m.read_array_of_int(2).should eq [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 eq 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 eq 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 eq false
+  end
+end

data/vendor/gems/ruby/1.8/gems/ffi-1.1.5/spec/ffi/rbx/spec_helper.rb

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

data/vendor/gems/ruby/1.8/gems/ffi-1.1.5/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 eq 12
+  end
+end

data/vendor/gems/ruby/1.8/gems/ffi-1.1.5/spec/ffi/spec_helper.rb

@@ -0,0 +1,35 @@
+#
+# 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 'rubygems'
+require 'rbconfig'
+
+if RUBY_PLATFORM =~/java/
+  libdir = File.expand_path(File.join(File.dirname(__FILE__), "..", "..", "lib"))
+  $:.reject! { |p| p == libdir }
+else
+  $:.unshift File.join(File.dirname(__FILE__), "..", "..", "lib"),
+    File.join(File.dirname(__FILE__), "..", "..", "build", "#{RbConfig::CONFIG['host_cpu''arch']}", "ffi_c", RUBY_VERSION)
+end
+# puts "loadpath=#{$:.join(':')}"
+require "ffi"
+
+module TestLibrary
+  PATH = "build/libtest.#{FFI::Platform::LIBSUFFIX}"
+end
+module LibTest
+  extend FFI::Library
+  ffi_lib TestLibrary::PATH
+end

data/vendor/gems/ruby/1.8/gems/ffi-1.1.5/spec/ffi/string_spec.rb

@@ -0,0 +1,119 @@
+#
+# 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 "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)
+    str.tainted?.should eq 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)
+    str.should eq "test"
+    str.tainted?.should eq 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 eq false
+    rescue SecurityError
+    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 eq 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)
+    ptrary.get_array_of_string(0).should 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)
+    ptrary.get_array_of_string(0, 4).should 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)
+    ptrary.get_array_of_string(2 * FFI.type_size(:pointer), 3).should 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)
+    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 = 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)
+    lambda { ptrary.get_array_of_string(-1) }.should raise_error
+  end
+end

data/vendor/gems/ruby/1.8/gems/ffi-1.1.5/spec/ffi/strptr_spec.rb

@@ -0,0 +1,61 @@
+#
+# 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 "functions returning :strptr" do
+
+  it "can attach function with :strptr return type" do
+    lambda 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.should_not 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")
+    result[0].is_a?(String).should be_true
+    result[1].is_a?(FFI::Pointer).should be_true
+  end
+
+  it "should return the correct value" do
+    result = StrPtr.strdup("test")
+    result[0].should eq "test"
+  end
+
+  it "should return non-NULL pointer" do
+    result = StrPtr.strdup("test")
+    result[1].null?.should be_false
+  end
+end

data/vendor/gems/ruby/1.8/gems/ffi-1.1.5/spec/ffi/struct_callback_spec.rb

@@ -0,0 +1,80 @@
+#
+# 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 FFI::Struct, ' with inline callback functions' do
+  it 'should be able to define inline callback field' do
+    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
+  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)
+
+    CallbackMember2.struct_call_add_cb(ts, 1, 2).should 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]
+    fn.respond_to?(:call).should be_true
+    fn.call(1, 2).should eq 3
+  end
+end
+