ffi 1.9.5 → 1.9.6

data/spec/ffi/rbx/attach_function_spec.rb

@@ -4,7 +4,6 @@
 #
 
 require File.expand_path(File.join(File.dirname(__FILE__), "spec_helper"))
-require 'ffi'
 
 class Timeval < FFI::Struct
   layout :tv_sec, :ulong, 0, :tv_usec, :ulong, 4  
@@ -21,14 +20,14 @@ 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)
+    expect(time).to 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)
+    expect(t[:tv_sec]).to be_kind_of(Numeric)
+    expect(t[:tv_usec]).to be_kind_of(Numeric)
   end
 end
 

data/spec/ffi/rbx/memory_pointer_spec.rb

@@ -5,7 +5,6 @@
 #
 
 require File.expand_path(File.join(File.dirname(__FILE__), "spec_helper"))
-require 'ffi'
 
 module CTest
   extend FFI::Library
@@ -17,58 +16,58 @@ end
 describe "MemoryPointer" do
   it "makes a pointer from a string" do
     m = FFI::MemoryPointer.from_string("FFI is Awesome")
-    m.total.should == 15
-    m.type_size.should == 1
+    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)
+    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 == 10
-    m.type_size.should == 1
+    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")
-    m.read_string.should == "FFI is Awesome"
+    expect(m.read_string).to 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 == [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])
-    m[0].read_int.should == 1
-    m[1].read_int.should == 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)
-    m.read_int.should == 1
+    expect(m.read_int).to eq(1)
   end
   
   it "allows writing as a long" do
     m = FFI::MemoryPointer.new(:long)
     m.write_long(10)
-    m.read_long.should == 10
+    expect(m.read_long).to 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
+    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)
-    lambda { m.write_int(10) }.should raise_error
+    expect { m.write_int(10) }.to raise_error
   end
 #  it "does not raise IndexError for opaque pointers" do
 #    m = FFI::MemoryPointer.new(8)
@@ -81,41 +80,44 @@ describe "MemoryPointer" do
   it "makes a pointer for a certain type" do
     m = FFI::MemoryPointer.new(:int)
     m.write_int(10)
-    m.read_int.should == 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])
-    m.read_array_of_int(2).should == [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])
-    m.read_array_of_int(2).should == [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])
-    m.read_array_of_int(2).should == [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)
-    m.read_pointer.address.should == 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)    
-    m.read_pointer.null?.should == true
+    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)
-    m.read_pointer.null?.should == false
+    expect(m.read_pointer.null?).to be false
   end
   
   it "initialize with block should execute block" do
@@ -123,6 +125,6 @@ describe "MemoryPointer" do
     FFI::MemoryPointer.new(:pointer) do |ptr|
       block_executed = true
     end
-    block_executed.should be_true
+    expect(block_executed).to be true
   end
 end

data/spec/ffi/rbx/spec_helper.rb

@@ -4,4 +4,3 @@
 #
 
 require File.expand_path(File.join(File.dirname(__FILE__), "../spec_helper"))
-require 'ffi'

data/spec/ffi/rbx/struct_spec.rb

@@ -4,7 +4,6 @@
 #
 
 require File.expand_path(File.join(File.dirname(__FILE__), "spec_helper"))
-require 'ffi'
 
 class Timeval < FFI::Struct
   layout :tv_sec, :ulong, 0, :tv_usec, :ulong, 4  
@@ -14,6 +13,6 @@ describe FFI::Struct do
   it "allows setting fields" do
     t = Timeval.new
     t[:tv_sec] = 12
-    t[:tv_sec].should == 12
+    expect(t[:tv_sec]).to eq(12)
   end
 end

data/spec/ffi/spec_helper.rb

@@ -4,6 +4,7 @@
 #
 
 require 'rbconfig'
+require 'fileutils'
 require 'ffi'
 
 CPU = case RbConfig::CONFIG['host_cpu'].downcase
@@ -53,17 +54,19 @@ def compile_library(path, lib)
   dir = File.expand_path(path, File.dirname(__FILE__))
   lib = "#{dir}/#{lib}"
   if !File.exists?(lib)
-    ldshared  = RbConfig::CONFIG["LDSHARED"]
+    ldshared  = RbConfig::CONFIG["LDSHARED"] || "clang -dynamic -bundle"
     libs      = RbConfig::CONFIG["LIBS"]
-    dldflags  = RbConfig::CONFIG["DLDFLAGS"]
+    dldflags  = RbConfig::CONFIG["DLDFLAGS"] || "-Wl,-undefined,dynamic_lookup -Wl,-multiply_defined,suppress"
 
     puts Dir.pwd, dir, File.dirname(__FILE__)
 
+    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

data/spec/ffi/string_spec.rb

@@ -4,8 +4,6 @@
 #
 
 require File.expand_path(File.join(File.dirname(__FILE__), "spec_helper"))
-require 'ffi'
-
 describe "String tests" do
   include FFI
   module StrLibTest
@@ -16,40 +14,46 @@ describe "String tests" do
     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 == true
+    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)
-    str.should == "test"
-    str.tainted?.should == true
+    expect(str).to eq("test")
+    expect(str).to be_tainted
   end
+
   it "Poison null byte raises error" do
     s = "123\0abc"
-    lambda { StrLibTest.string_equals(s, s) }.should raise_error
+    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
-      LibTest.string_equals(str, str).should == false
+      expect(LibTest.string_equals(str, str)).to be false
     rescue SecurityError
     end
   end if false
   it "casts nil as NULL pointer" do
-    StrLibTest.string_dummy(nil).should == nil
+    expect(StrLibTest.string_dummy(nil)).to be_nil
   end
+
   it "return nil for NULL char*" do
-    StrLibTest.string_null.should == nil
+    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)
@@ -60,8 +64,9 @@ describe "String tests" do
     end
     ary.insert(3, nil)
     ptrary.write_array_of_pointer(ary)
-    ptrary.get_array_of_string(0).should == ["foo", "bar", "baz"]
+    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)
@@ -72,8 +77,9 @@ describe "String tests" do
     end
     ary.insert(2, nil)
     ptrary.write_array_of_pointer(ary)
-    ptrary.get_array_of_string(0, 4).should == ["foo", "bar", nil, "baz"]
+    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)
@@ -83,8 +89,9 @@ describe "String tests" do
       a << f
     end
     ptrary.write_array_of_pointer(ary)
-    ptrary.get_array_of_string(2 * FFI.type_size(:pointer), 3).should == ["baz", "testing", "ffi"]
+    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)
@@ -94,8 +101,9 @@ describe "String tests" do
       a << f
     end
     ptrary.write_array_of_pointer(ary)
-    lambda { ptrary.get_array_of_string(0, 6) }.should raise_error
+    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)
@@ -105,6 +113,6 @@ describe "String tests" do
       a << f
     end
     ptrary.write_array_of_pointer(ary)
-    lambda { ptrary.get_array_of_string(-1) }.should raise_error
+    expect { ptrary.get_array_of_string(-1) }.to raise_error
   end
 end

data/spec/ffi/strptr_spec.rb

@@ -4,12 +4,11 @@
 #
 
 require File.expand_path(File.join(File.dirname(__FILE__), "spec_helper"))
-require 'ffi'
 
 describe "functions returning :strptr" do
 
   it "can attach function with :strptr return type" do
-    lambda do
+    expect do
       Module.new do
         extend FFI::Library
         ffi_lib FFI::Library::LIBC
@@ -19,7 +18,7 @@ describe "functions returning :strptr" do
           attach_function :_strdup, [ :string ], :strptr
         end
       end
-    end.should_not raise_error
+    end.not_to raise_error
   end
 
   module StrPtr
@@ -35,17 +34,17 @@ describe "functions returning :strptr" do
 
   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
+    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")
-    result[0].should == "test"
+    expect(result[0]).to eq("test")
   end
 
   it "should return non-NULL pointer" do
     result = StrPtr.strdup("test")
-    result[1].null?.should be_false
+    expect(result[1]).not_to be_null
   end
 end

data/spec/ffi/struct_by_ref_spec.rb

@@ -4,7 +4,6 @@
 #
 
 require File.expand_path(File.join(File.dirname(__FILE__), "spec_helper"))
-require 'ffi'
 
 describe FFI::Struct, ' by_ref' do
   before :all do
@@ -22,15 +21,15 @@ describe FFI::Struct, ' by_ref' do
 
   it "should accept instances of exact struct class" do
     s = @struct_class.new
-    @api.struct_test(s).should == s.pointer
+    expect(@api.struct_test(s)).to eq(s.pointer)
   end
 
   it "should accept nil" do
-    @api.struct_test(nil).should == nil
+    expect(@api.struct_test(nil)).to be_null
   end
 
   it "should reject other types" do
-    lambda { @api.struct_test('test').should == nil }.should raise_error(TypeError)
+    expect { expect(@api.struct_test('test')).to be_nil }.to raise_error(TypeError)
   end
 
   it "should reject instances of other struct classes" do
@@ -38,7 +37,7 @@ describe FFI::Struct, ' by_ref' do
       layout :a, :pointer
     end
 
-    lambda { @api.struct_test(other_class.new) }.should raise_error(TypeError)
+    expect { @api.struct_test(other_class.new) }.to raise_error(TypeError)
   end
 end
 

data/spec/ffi/struct_callback_spec.rb

@@ -4,11 +4,10 @@
 #
 
 require File.expand_path(File.join(File.dirname(__FILE__), "spec_helper"))
-require 'ffi'
 
 describe FFI::Struct, ' with inline callback functions' do
   it 'should be able to define inline callback field' do
-    module CallbackMember1
+    expect(module CallbackMember1
       extend FFI::Library
       ffi_lib TestLibrary::PATH
       DUMMY_CB = callback :dummy_cb, [ :int ], :int
@@ -20,8 +19,9 @@ describe FFI::Struct, ' with inline callback functions' do
       end
       attach_function :struct_call_add_cb, [TestStruct, :int, :int], :int
       attach_function :struct_call_sub_cb, [TestStruct, :int, :int], :int
-    end.should be_an_instance_of FFI::Function
+    end).to be_an_instance_of FFI::Function
   end
+
   it 'should take methods as callbacks' do
     module CallbackMember2
       extend FFI::Library
@@ -43,7 +43,7 @@ describe FFI::Struct, ' with inline callback functions' do
     ts = CallbackMember2::TestStruct.new
     ts[:add] = StructCallbacks.method(:add)
 
-    CallbackMember2.struct_call_add_cb(ts, 1, 2).should == 3
+    expect(CallbackMember2.struct_call_add_cb(ts, 1, 2)).to eq(3)
   end
 
   it 'should return callable object from []' do
@@ -63,8 +63,7 @@ describe FFI::Struct, ' with inline callback functions' do
     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 == 3
+    expect(fn.respond_to?(:call)).to be true
+    expect(fn.call(1, 2)).to eq(3)
   end
 end
-