ffi 1.2.1-x86-mingw32 → 1.3.0-x86-mingw32

data/spec/ffi/callback_spec.rb

@@ -1,17 +1,6 @@
 #
 # 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/>.
+# For licensing, see LICENSE.SPECS
 #
 
 require File.expand_path(File.join(File.dirname(__FILE__), "spec_helper"))
@@ -29,7 +18,7 @@ describe "Callback" do
 #    cmp = proc do |p1, p2| args.push(p1.get_int(0)); args.push(p2.get_int(0)); 0; end
 #    # this is a bit dodgey, as it relies on qsort passing the args in order
 #    LibC.qsort(p, 2, 4, cmp)
-#    args.should eq [ 1, 2 ]
+#    args.should == [ 1, 2 ]
 #  end
 #
 #  it "Block can be substituted for Callback as last argument" do
@@ -42,7 +31,7 @@ describe "Callback" do
 #      args.push(p2.get_int(0))
 #      0
 #    end
-#    args.should eq [ 1, 2 ]
+#    args.should == [ 1, 2 ]
 #  end
   module LibTest
     extend FFI::Library
@@ -96,138 +85,138 @@ describe "Callback" do
 
   end
   it "returning :char (0)" do
-    LibTest.testCallbackVrS8 { 0 }.should eq 0
+    LibTest.testCallbackVrS8 { 0 }.should == 0
   end
   it "returning :char (127)" do
-    LibTest.testCallbackVrS8 { 127 }.should eq 127
+    LibTest.testCallbackVrS8 { 127 }.should == 127
   end
   it "returning :char (-128)" do
-    LibTest.testCallbackVrS8 { -128 }.should eq(-128)
+    LibTest.testCallbackVrS8 { -128 }.should == -128
   end
   # test wrap around
   it "returning :char (128)" do
-    LibTest.testCallbackVrS8 { 128 }.should eq(-128)
+    LibTest.testCallbackVrS8 { 128 }.should == -128
   end
   it "returning :char (255)" do
-    LibTest.testCallbackVrS8 { 0xff }.should eq(-1)
+    LibTest.testCallbackVrS8 { 0xff }.should == -1
   end
   it "returning :uchar (0)" do
-    LibTest.testCallbackVrU8 { 0 }.should eq 0
+    LibTest.testCallbackVrU8 { 0 }.should == 0
   end
   it "returning :uchar (0xff)" do
-    LibTest.testCallbackVrU8 { 0xff }.should eq 0xff
+    LibTest.testCallbackVrU8 { 0xff }.should == 0xff
   end
   it "returning :uchar (-1)" do
-    LibTest.testCallbackVrU8 { -1 }.should eq 0xff
+    LibTest.testCallbackVrU8 { -1 }.should == 0xff
   end
   it "returning :uchar (128)" do
-    LibTest.testCallbackVrU8 { 128 }.should eq 128
+    LibTest.testCallbackVrU8 { 128 }.should == 128
   end
   it "returning :uchar (-128)" do
-    LibTest.testCallbackVrU8 { -128 }.should eq 128
+    LibTest.testCallbackVrU8 { -128 }.should == 128
   end
   it "returning :short (0)" do
-    LibTest.testCallbackVrS16 { 0 }.should eq 0
+    LibTest.testCallbackVrS16 { 0 }.should == 0
   end
   it "returning :short (0x7fff)" do
-    LibTest.testCallbackVrS16 { 0x7fff }.should eq 0x7fff
+    LibTest.testCallbackVrS16 { 0x7fff }.should == 0x7fff
   end
   # test wrap around
   it "returning :short (0x8000)" do
-    LibTest.testCallbackVrS16 { 0x8000 }.should eq(-0x8000)
+    LibTest.testCallbackVrS16 { 0x8000 }.should == -0x8000
   end
   it "returning :short (0xffff)" do
-    LibTest.testCallbackVrS16 { 0xffff }.should eq(-1)
+    LibTest.testCallbackVrS16 { 0xffff }.should == -1
   end
   it "returning :ushort (0)" do
-    LibTest.testCallbackVrU16 { 0 }.should eq 0
+    LibTest.testCallbackVrU16 { 0 }.should == 0
   end
   it "returning :ushort (0x7fff)" do
-    LibTest.testCallbackVrU16 { 0x7fff }.should eq 0x7fff
+    LibTest.testCallbackVrU16 { 0x7fff }.should == 0x7fff
   end
   it "returning :ushort (0x8000)" do
-    LibTest.testCallbackVrU16 { 0x8000 }.should eq 0x8000
+    LibTest.testCallbackVrU16 { 0x8000 }.should == 0x8000
   end
   it "returning :ushort (0xffff)" do
-    LibTest.testCallbackVrU16 { 0xffff }.should eq 0xffff
+    LibTest.testCallbackVrU16 { 0xffff }.should == 0xffff
   end
   it "returning :ushort (-1)" do
-    LibTest.testCallbackVrU16 { -1 }.should eq 0xffff
+    LibTest.testCallbackVrU16 { -1 }.should == 0xffff
   end
   it "returning :int (0)" do
-    LibTest.testCallbackVrS32 { 0 }.should eq 0
+    LibTest.testCallbackVrS32 { 0 }.should == 0
   end
   it "returning :int (0x7fffffff)" do
-    LibTest.testCallbackVrS32 { 0x7fffffff }.should eq 0x7fffffff
+    LibTest.testCallbackVrS32 { 0x7fffffff }.should == 0x7fffffff
   end
   # test wrap around
   it "returning :int (-0x80000000)" do
-    LibTest.testCallbackVrS32 { -0x80000000 }.should eq(-0x80000000)
+    LibTest.testCallbackVrS32 { -0x80000000 }.should == -0x80000000
   end
   it "returning :int (-1)" do
-    LibTest.testCallbackVrS32 { -1 }.should eq(-1)
+    LibTest.testCallbackVrS32 { -1 }.should == -1
   end
   it "returning :uint (0)" do
-    LibTest.testCallbackVrU32 { 0 }.should eq 0
+    LibTest.testCallbackVrU32 { 0 }.should == 0
   end
   it "returning :uint (0x7fffffff)" do
-    LibTest.testCallbackVrU32 { 0x7fffffff }.should eq 0x7fffffff
+    LibTest.testCallbackVrU32 { 0x7fffffff }.should == 0x7fffffff
   end
   # test wrap around
   it "returning :uint (0x80000000)" do
-    LibTest.testCallbackVrU32 { 0x80000000 }.should eq 0x80000000
+    LibTest.testCallbackVrU32 { 0x80000000 }.should == 0x80000000
   end
   it "returning :uint (0xffffffff)" do
-    LibTest.testCallbackVrU32 { 0xffffffff }.should eq 0xffffffff
+    LibTest.testCallbackVrU32 { 0xffffffff }.should == 0xffffffff
   end
   it "returning :uint (-1)" do
-    LibTest.testCallbackVrU32 { -1 }.should eq 0xffffffff
+    LibTest.testCallbackVrU32 { -1 }.should == 0xffffffff
   end
   it "returning :long (0)" do
-    LibTest.testCallbackVrL { 0 }.should eq 0
+    LibTest.testCallbackVrL { 0 }.should == 0
   end
   it "returning :long (0x7fffffff)" do
-    LibTest.testCallbackVrL { 0x7fffffff }.should eq 0x7fffffff
+    LibTest.testCallbackVrL { 0x7fffffff }.should == 0x7fffffff
   end
   # test wrap around
   it "returning :long (-0x80000000)" do
-    LibTest.testCallbackVrL { -0x80000000 }.should eq(-0x80000000)
+    LibTest.testCallbackVrL { -0x80000000 }.should == -0x80000000
   end
   it "returning :long (-1)" do
-    LibTest.testCallbackVrL { -1 }.should eq(-1)
+    LibTest.testCallbackVrL { -1 }.should == -1
   end
   it "returning :ulong (0)" do
-    LibTest.testCallbackVrUL { 0 }.should eq 0
+    LibTest.testCallbackVrUL { 0 }.should == 0
   end
   it "returning :ulong (0x7fffffff)" do
-    LibTest.testCallbackVrUL { 0x7fffffff }.should eq 0x7fffffff
+    LibTest.testCallbackVrUL { 0x7fffffff }.should == 0x7fffffff
   end
   # test wrap around
   it "returning :ulong (0x80000000)" do
-    LibTest.testCallbackVrUL { 0x80000000 }.should eq 0x80000000
+    LibTest.testCallbackVrUL { 0x80000000 }.should == 0x80000000
   end
   it "returning :ulong (0xffffffff)" do
-    LibTest.testCallbackVrUL { 0xffffffff }.should eq 0xffffffff
+    LibTest.testCallbackVrUL { 0xffffffff }.should == 0xffffffff
   end
   it "Callback returning :ulong (-1)" do
     if FFI::Platform::LONG_SIZE == 32
-      LibTest.testCallbackVrUL { -1 }.should eq 0xffffffff
+      LibTest.testCallbackVrUL { -1 }.should == 0xffffffff
     else
-      LibTest.testCallbackVrUL { -1 }.should eq 0xffffffffffffffff
+      LibTest.testCallbackVrUL { -1 }.should == 0xffffffffffffffff
     end
   end
   it "returning :long_long (0)" do
-    LibTest.testCallbackVrS64 { 0 }.should eq 0
+    LibTest.testCallbackVrS64 { 0 }.should == 0
   end
   it "returning :long_long (0x7fffffffffffffff)" do
-    LibTest.testCallbackVrS64 { 0x7fffffffffffffff }.should eq 0x7fffffffffffffff
+    LibTest.testCallbackVrS64 { 0x7fffffffffffffff }.should == 0x7fffffffffffffff
   end
   # test wrap around
   it "returning :long_long (-0x8000000000000000)" do
-    LibTest.testCallbackVrS64 { -0x8000000000000000 }.should eq(-0x8000000000000000)
+    LibTest.testCallbackVrS64 { -0x8000000000000000 }.should == -0x8000000000000000
   end
   it "returning :long_long (-1)" do
-    LibTest.testCallbackVrS64 { -1 }.should eq(-1)
+    LibTest.testCallbackVrS64 { -1 }.should == -1
   end
   it "returning bool" do
     LibTest.testCallbackVrZ { true }.should be_true
@@ -237,7 +226,7 @@ describe "Callback" do
   end
   it "returning :pointer (MemoryPointer)" do
     p = FFI::MemoryPointer.new :long
-    LibTest.testCallbackVrP { p }.should eq p
+    LibTest.testCallbackVrP { p }.should == p
   end
 
 
@@ -247,9 +236,9 @@ describe "Callback" do
     s[:s32] = 0x1eefbeef
     s[:f32] = 1.234567
     ret = LibTest.testCallbackVrT { s }
-    ret[:s8].should eq s[:s8]
-    ret[:f32].should eq s[:f32]
-    ret[:s32].should eq s[:s32]
+    ret[:s8].should == s[:s8]
+    ret[:f32].should == s[:f32]
+    ret[:s32].should == s[:s32]
 
   end
 
@@ -270,7 +259,7 @@ describe "Callback" do
   it "global variable" do
     proc = Proc.new { 0x1e }
     LibTest.cbVrS8 = proc
-    LibTest.testGVarCallbackVrS8(LibTest.pVrS8).should eq 0x1e
+    LibTest.testGVarCallbackVrS8(LibTest.pVrS8).should == 0x1e
   end
 
   describe "When the callback is considered optional by the underlying library" do
@@ -286,7 +275,7 @@ describe "Callback" do
         ffi_lib TestLibrary::PATH
         attach_function :testAnonymousCallbackVrS8, :testClosureVrB, [ callback([ ], :char) ], :char
       end
-      LibTest.testAnonymousCallbackVrS8 { 0 }.should eq 0
+      LibTest.testAnonymousCallbackVrS8 { 0 }.should == 0
     end
   end
 
@@ -324,7 +313,7 @@ describe "Callback" do
       end
 
       val = LibTest.testReturnsCallback(lookup_proc, 0x1234)
-      val.should eq 0x1234 * 2
+      val.should == 0x1234 * 2
       lookup_proc_called.should be_true
       return_proc_called.should be_true
     end
@@ -346,7 +335,7 @@ describe "Callback" do
         end
       end
 
-      LibTest.testReturnsCallback_2(MethodCallback.method(:lookup), 0x1234).should eq 0x2468
+      LibTest.testReturnsCallback_2(MethodCallback.method(:lookup), 0x1234).should == 0x2468
     end
 
     it 'should not blow up when a callback takes a callback as argument' do
@@ -377,7 +366,7 @@ describe "Callback" do
         cb.call(val)
       end
       val = LibTest.testCallbackAsArgument(callback_with_callback_arg, callback_arg, 0xff1)
-      val.should eq 0xff1 * 2
+      val.should == 0xff1 * 2
       callback_arg_called.should be_true
       callback_with_callback_arg_called.should be_true         
     end
@@ -389,7 +378,7 @@ describe "Callback" do
         attach_function :testReturnsFunctionPointer, [  ], :funcptr
       end
       f = LibTest.testReturnsFunctionPointer
-      f.call(3).should eq 6
+      f.call(3).should == 6
     end
   end
 
@@ -446,83 +435,83 @@ describe "Callback with " do
   it ":char (0) argument" do
     v = 0xdeadbeef
     LibTest.testCallbackCrV(0) { |i| v = i }
-    v.should eq 0
+    v.should == 0
   end
   it ":char (127) argument" do
     v = 0xdeadbeef
     LibTest.testCallbackCrV(127) { |i| v = i }
-    v.should eq 127
+    v.should == 127
   end
   it ":char (-128) argument" do
     v = 0xdeadbeef
     LibTest.testCallbackCrV(-128) { |i| v = i }
-    v.should eq(-128)
+    v.should == -128
   end
   it ":char (-1) argument" do
     v = 0xdeadbeef
     LibTest.testCallbackCrV(-1) { |i| v = i }
-    v.should eq(-1)
+    v.should == -1
   end
   it ":uchar (0) argument" do
     v = 0xdeadbeef
     LibTest.testCallbackU8rV(0) { |i| v = i }
-    v.should eq 0
+    v.should == 0
   end
   it ":uchar (127) argument" do
     v = 0xdeadbeef
     LibTest.testCallbackU8rV(127) { |i| v = i }
-    v.should eq 127
+    v.should == 127
   end
   it ":uchar (128) argument" do
     v = 0xdeadbeef
     LibTest.testCallbackU8rV(128) { |i| v = i }
-    v.should eq 128
+    v.should == 128
   end
   it ":uchar (255) argument" do
     v = 0xdeadbeef
     LibTest.testCallbackU8rV(255) { |i| v = i }
-    v.should eq 255
+    v.should == 255
   end
 
   it ":short (0) argument" do
     v = 0xdeadbeef
     LibTest.testCallbackSrV(0) { |i| v = i }
-    v.should eq 0
+    v.should == 0
   end
   it ":short (0x7fff) argument" do
     v = 0xdeadbeef
     LibTest.testCallbackSrV(0x7fff) { |i| v = i }
-    v.should eq 0x7fff
+    v.should == 0x7fff
   end
   it ":short (-0x8000) argument" do
     v = 0xdeadbeef
     LibTest.testCallbackSrV(-0x8000) { |i| v = i }
-    v.should eq(-0x8000)
+    v.should == -0x8000
   end
   it ":short (-1) argument" do
     v = 0xdeadbeef
     LibTest.testCallbackSrV(-1) { |i| v = i }
-    v.should eq(-1)
+    v.should == -1
   end
   it ":ushort (0) argument" do
     v = 0xdeadbeef
     LibTest.testCallbackU16rV(0) { |i| v = i }
-    v.should eq 0
+    v.should == 0
   end
   it ":ushort (0x7fff) argument" do
     v = 0xdeadbeef
     LibTest.testCallbackU16rV(0x7fff) { |i| v = i }
-    v.should eq 0x7fff
+    v.should == 0x7fff
   end
   it ":ushort (0x8000) argument" do
     v = 0xdeadbeef
     LibTest.testCallbackU16rV(0x8000) { |i| v = i }
-    v.should eq 0x8000
+    v.should == 0x8000
   end
   it ":ushort (0xffff) argument" do
     v = 0xdeadbeef
     LibTest.testCallbackU16rV(0xffff) { |i| v = i }
-    v.should eq 0xffff
+    v.should == 0xffff
   end
   it ":bool (true) argument" do
     v = false
@@ -532,107 +521,107 @@ describe "Callback with " do
   it ":int (0) argument" do
     v = 0xdeadbeef
     LibTest.testCallbackIrV(0) { |i| v = i }
-    v.should eq 0
+    v.should == 0
   end
   it ":int (0x7fffffff) argument" do
     v = 0xdeadbeef
     LibTest.testCallbackIrV(0x7fffffff) { |i| v = i }
-    v.should eq 0x7fffffff
+    v.should == 0x7fffffff
   end
   it ":int (-0x80000000) argument" do
     v = 0xdeadbeef
     LibTest.testCallbackIrV(-0x80000000) { |i| v = i }
-    v.should eq(-0x80000000)
+    v.should == -0x80000000
   end
   it ":int (-1) argument" do
     v = 0xdeadbeef
     LibTest.testCallbackIrV(-1) { |i| v = i }
-    v.should eq(-1)
+    v.should == -1
   end
   it ":uint (0) argument" do
     v = 0xdeadbeef
     LibTest.testCallbackU32rV(0) { |i| v = i }
-    v.should eq 0
+    v.should == 0
   end
   it ":uint (0x7fffffff) argument" do
     v = 0xdeadbeef
     LibTest.testCallbackU32rV(0x7fffffff) { |i| v = i }
-    v.should eq 0x7fffffff
+    v.should == 0x7fffffff
   end
   it ":uint (0x80000000) argument" do
     v = 0xdeadbeef
     LibTest.testCallbackU32rV(0x80000000) { |i| v = i }
-    v.should eq 0x80000000
+    v.should == 0x80000000
   end
   it ":uint (0xffffffff) argument" do
     v = 0xdeadbeef
     LibTest.testCallbackU32rV(0xffffffff) { |i| v = i }
-    v.should eq 0xffffffff
+    v.should == 0xffffffff
   end
   it ":long (0) argument" do
     v = 0xdeadbeef
     LibTest.testCallbackLrV(0) { |i| v = i }
-    v.should eq 0
+    v.should == 0
   end
   it ":long (0x7fffffff) argument" do
     v = 0xdeadbeef
     LibTest.testCallbackLrV(0x7fffffff) { |i| v = i }
-    v.should eq 0x7fffffff
+    v.should == 0x7fffffff
   end
   it ":long (-0x80000000) argument" do
     v = 0xdeadbeef
     LibTest.testCallbackLrV(-0x80000000) { |i| v = i }
-    v.should eq(-0x80000000)
+    v.should == -0x80000000
   end
   it ":long (-1) argument" do
     v = 0xdeadbeef
     LibTest.testCallbackLrV(-1) { |i| v = i }
-    v.should eq(-1)
+    v.should == -1
   end
   it ":ulong (0) argument" do
     v = 0xdeadbeef
     LibTest.testCallbackULrV(0) { |i| v = i }
-    v.should eq 0
+    v.should == 0
   end
   it ":ulong (0x7fffffff) argument" do
     v = 0xdeadbeef
     LibTest.testCallbackULrV(0x7fffffff) { |i| v = i }
-    v.should eq 0x7fffffff
+    v.should == 0x7fffffff
   end
   it ":ulong (0x80000000) argument" do
     v = 0xdeadbeef
     LibTest.testCallbackULrV(0x80000000) { |i| v = i }
-    v.should eq 0x80000000
+    v.should == 0x80000000
   end
   it ":ulong (0xffffffff) argument" do
     v = 0xdeadbeef
     LibTest.testCallbackULrV(0xffffffff) { |i| v = i }
-    v.should eq 0xffffffff
+    v.should == 0xffffffff
   end
   it ":long_long (0) argument" do
     v = 0xdeadbeef
     LibTest.testCallbackLLrV(0) { |i| v = i }
-    v.should eq 0
+    v.should == 0
   end
   it ":long_long (0x7fffffffffffffff) argument" do
     v = 0xdeadbeef
     LibTest.testCallbackLLrV(0x7fffffffffffffff) { |i| v = i }
-    v.should eq 0x7fffffffffffffff
+    v.should == 0x7fffffffffffffff
   end
   it ":long_long (-0x8000000000000000) argument" do
     v = 0xdeadbeef
     LibTest.testCallbackLLrV(-0x8000000000000000) { |i| v = i }
-    v.should eq(-0x8000000000000000)
+    v.should == -0x8000000000000000
   end
   it ":long_long (-1) argument" do
     v = 0xdeadbeef
     LibTest.testCallbackLLrV(-1) { |i| v = i }
-    v.should eq(-1)
+    v.should == -1
   end
   it ":string argument" do
     v = nil
     LibTest.testCallbackArV("Hello, World") { |i| v = i }
-    v.should eq "Hello, World"
+    v.should == "Hello, World"
   end
   it ":string (nil) argument" do
     v = "Hello, World"
@@ -643,18 +632,18 @@ describe "Callback with " do
     v = nil
     magic = FFI::Pointer.new(0xdeadbeef)
     LibTest.testCallbackPrV(magic) { |i| v = i }
-    v.should eq magic
+    v.should == magic
   end
   it ":pointer (nil) argument" do
     v = "Hello, World"
     LibTest.testCallbackPrV(nil) { |i| v = i }
-    v.should eq FFI::Pointer::NULL
+    v.should == FFI::Pointer::NULL
   end
   it "struct by reference argument" do
     v = nil
     magic = LibTest::S8F32S32.new
     LibTest.testCallbackYrV(magic) { |i| v = i }
-    v.class.should eq magic.class
+    v.class.should == magic.class
     v.pointer == magic.pointer
   end
 
@@ -662,7 +651,7 @@ describe "Callback with " do
     v = LibTest::S8F32S32.new
     LibTest.testCallbackYrV(nil) { |i| v = i }
     v.is_a?(FFI::Struct).should be_true
-    v.pointer.should eq FFI::Pointer::NULL
+    v.pointer.should == FFI::Pointer::NULL
   end
 
   it "varargs parameters are rejected" do