ffi 1.9.5-x64-mingw32 → 1.9.6-x64-mingw32

data/spec/ffi/custom_param_type.rb

@@ -4,7 +4,6 @@
 #
 
 require File.expand_path(File.join(File.dirname(__FILE__), "spec_helper"))
-require 'ffi'
 
 describe "functions with custom parameter types" do
   before :each do
@@ -33,5 +32,6 @@ describe "functions with custom parameter types" do
       def self.to_native_called?; @to_native_called; end
     end
 
+    # FIXME add tests
   end
 end

data/spec/ffi/custom_type_spec.rb

@@ -4,7 +4,6 @@
 #
 
 require File.expand_path(File.join(File.dirname(__FILE__), "spec_helper"))
-require 'ffi'
 
 describe "functions with custom types" do
   class Custom_enum
@@ -32,13 +31,13 @@ describe "functions with custom types" do
   end
 
   it "can attach with custom return type" do
-    lambda do
+    expect do
       Module.new do
         extend FFI::Library
         ffi_lib TestLibrary::PATH
         attach_function :ret_s32, [ :int ], Custom_enum
       end
-    end.should_not raise_error
+    end.not_to raise_error
   end
 
   it "should return object of correct type" do
@@ -50,7 +49,7 @@ describe "functions with custom types" do
       attach_function :ret_s32, [ :int ], Custom_enum
     end
 
-    m.ret_s32(1).is_a?(Symbol).should be_true
+    expect(m.ret_s32(1).is_a?(Symbol)).to be true
   end
 
   it "from_native should be called for result" do
@@ -60,7 +59,7 @@ describe "functions with custom types" do
       attach_function :ret_s32, [ :int ], Custom_enum
     end
     m.ret_s32(1)
-    Custom_enum.from_native_called?.should be_true
+    expect(Custom_enum.from_native_called?).to be true
   end
 
   it "to_native should be called for parameter" do
@@ -70,6 +69,6 @@ describe "functions with custom types" do
       attach_function :ret_s32, [ Custom_enum ], :int
     end
     m.ret_s32(:a)
-    Custom_enum.to_native_called?.should be_true
+    expect(Custom_enum.to_native_called?).to be true
   end
 end

data/spec/ffi/dup_spec.rb

@@ -4,7 +4,6 @@
 #
 
 require File.expand_path(File.join(File.dirname(__FILE__), "spec_helper"))
-require 'ffi'
 
 describe "Pointer#dup" do 
   it "clone should be independent" do
@@ -13,7 +12,7 @@ describe "Pointer#dup" do
     p2 = p1.dup
     p1.put_string(0, "deadbeef")
     
-    p2.get_string(0).should == "test123"
+    expect(p2.get_string(0)).to eq("test123")
   end
   
   it "sliced pointer can be cloned" do
@@ -22,8 +21,8 @@ describe "Pointer#dup" do
     p2 = p1[1].dup
     
     # first char will be excised
-    p2.get_string(0).should == "est123"
-    p1.get_string(0).should == "test123"
+    expect(p2.get_string(0)).to eq("est123")
+    expect(p1.get_string(0)).to eq("test123")
   end
   
   it "sliced pointer when cloned is independent" do
@@ -33,7 +32,7 @@ describe "Pointer#dup" do
     
     p1.put_string(0, "deadbeef")
     # first char will be excised
-    p2.get_string(0).should == "est123"
+    expect(p2.get_string(0)).to eq("est123")
   end
 end
 
@@ -47,8 +46,7 @@ describe "Struct#dup" do
     s1[:i] = 0x12345
     s2 = s1.dup
     s1[:i] = 0x98765
-    s2[:i].should == 0x12345
-    s1[:i].should == 0x98765
+    expect(s2[:i]).to eq(0x12345)
+    expect(s1[:i]).to eq(0x98765)
   end
-  
 end

data/spec/ffi/enum_spec.rb

@@ -4,7 +4,6 @@
 #
 
 require File.expand_path(File.join(File.dirname(__FILE__), "spec_helper"))
-require 'ffi'
 
 module TestEnum0
   extend FFI::Library
@@ -39,183 +38,190 @@ end
 
 describe "A library with no enum defined" do
   it "returns nil when asked for an enum" do
-    TestEnum0.enum_type(:foo).should == nil
+    expect(TestEnum0.enum_type(:foo)).to be_nil
   end
 end
 
 describe "An untagged enum" do
   it "constants can be used as function parameters and return value" do
-    TestEnum1.test_untagged_enum(:c1).should == 0
-    TestEnum1.test_untagged_enum(:c2).should == 1
-    TestEnum1.test_untagged_enum(:c3).should == 2
-    TestEnum1.test_untagged_enum(:c4).should == 3
-    TestEnum1.test_untagged_enum(:c5).should == 42
-    TestEnum1.test_untagged_enum(:c6).should == 43
-    TestEnum1.test_untagged_enum(:c7).should == 44
-    TestEnum1.test_untagged_enum(:c8).should == 45
-    TestEnum1.test_untagged_enum(:c9).should == 42
-    TestEnum1.test_untagged_enum(:c10).should == 43
-    TestEnum1.test_untagged_enum(:c11).should == 4242
-    TestEnum1.test_untagged_enum(:c12).should == 4243
-    TestEnum1.test_untagged_enum(:c13).should == 42
-    TestEnum1.test_untagged_enum(:c14).should == 4242
-    TestEnum1.test_untagged_enum(:c15).should == 424242
-    TestEnum1.test_untagged_enum(:c16).should == 42424242
+    expect(TestEnum1.test_untagged_enum(:c1)).to eq(0)
+    expect(TestEnum1.test_untagged_enum(:c2)).to eq(1)
+    expect(TestEnum1.test_untagged_enum(:c3)).to eq(2)
+    expect(TestEnum1.test_untagged_enum(:c4)).to eq(3)
+    expect(TestEnum1.test_untagged_enum(:c5)).to eq(42)
+    expect(TestEnum1.test_untagged_enum(:c6)).to eq(43)
+    expect(TestEnum1.test_untagged_enum(:c7)).to eq(44)
+    expect(TestEnum1.test_untagged_enum(:c8)).to eq(45)
+    expect(TestEnum1.test_untagged_enum(:c9)).to eq(42)
+    expect(TestEnum1.test_untagged_enum(:c10)).to eq(43)
+    expect(TestEnum1.test_untagged_enum(:c11)).to eq(4242)
+    expect(TestEnum1.test_untagged_enum(:c12)).to eq(4243)
+    expect(TestEnum1.test_untagged_enum(:c13)).to eq(42)
+    expect(TestEnum1.test_untagged_enum(:c14)).to eq(4242)
+    expect(TestEnum1.test_untagged_enum(:c15)).to eq(424242)
+    expect(TestEnum1.test_untagged_enum(:c16)).to eq(42424242)
   end
 end
 
 describe "A tagged typedef enum" do
   it "is accessible through its tag" do
-    TestEnum3.enum_type(:enum_type1).should_not == nil
-    TestEnum3.enum_type(:enum_type2).should_not == nil
-    TestEnum3.enum_type(:enum_type3).should_not == nil
-    TestEnum3.enum_type(:enum_type4).should_not == nil
+    expect(TestEnum3.enum_type(:enum_type1)).not_to be_nil
+    expect(TestEnum3.enum_type(:enum_type2)).not_to be_nil
+    expect(TestEnum3.enum_type(:enum_type3)).not_to be_nil
+    expect(TestEnum3.enum_type(:enum_type4)).not_to be_nil
   end
+
   it "contains enum constants" do
-    TestEnum3.enum_type(:enum_type1).symbols.length.should == 4
-    TestEnum3.enum_type(:enum_type2).symbols.length.should == 4
-    TestEnum3.enum_type(:enum_type3).symbols.length.should == 4
-    TestEnum3.enum_type(:enum_type4).symbols.length.should == 4
+    expect(TestEnum3.enum_type(:enum_type1).symbols.length).to eq(4)
+    expect(TestEnum3.enum_type(:enum_type2).symbols.length).to eq(4)
+    expect(TestEnum3.enum_type(:enum_type3).symbols.length).to eq(4)
+    expect(TestEnum3.enum_type(:enum_type4).symbols.length).to eq(4)
   end
+
   it "constants can be used as function parameters and return value" do
-    TestEnum3.test_tagged_typedef_enum1(:c1).should == :c1
-    TestEnum3.test_tagged_typedef_enum1(:c2).should == :c2
-    TestEnum3.test_tagged_typedef_enum1(:c3).should == :c3
-    TestEnum3.test_tagged_typedef_enum1(:c4).should == :c4
-    TestEnum3.test_tagged_typedef_enum2(:c5).should == :c5
-    TestEnum3.test_tagged_typedef_enum2(:c6).should == :c6
-    TestEnum3.test_tagged_typedef_enum2(:c7).should == :c7
-    TestEnum3.test_tagged_typedef_enum2(:c8).should == :c8
-    TestEnum3.test_tagged_typedef_enum3(:c9).should == :c9
-    TestEnum3.test_tagged_typedef_enum3(:c10).should == :c10
-    TestEnum3.test_tagged_typedef_enum3(:c11).should == :c11
-    TestEnum3.test_tagged_typedef_enum3(:c12).should == :c12
-    TestEnum3.test_tagged_typedef_enum4(:c13).should == :c13
-    TestEnum3.test_tagged_typedef_enum4(:c14).should == :c14
-    TestEnum3.test_tagged_typedef_enum4(:c15).should == :c15
-    TestEnum3.test_tagged_typedef_enum4(:c16).should == :c16
+    expect(TestEnum3.test_tagged_typedef_enum1(:c1)).to be :c1
+    expect(TestEnum3.test_tagged_typedef_enum1(:c2)).to be :c2
+    expect(TestEnum3.test_tagged_typedef_enum1(:c3)).to be :c3
+    expect(TestEnum3.test_tagged_typedef_enum1(:c4)).to be :c4
+    expect(TestEnum3.test_tagged_typedef_enum2(:c5)).to be :c5
+    expect(TestEnum3.test_tagged_typedef_enum2(:c6)).to be :c6
+    expect(TestEnum3.test_tagged_typedef_enum2(:c7)).to be :c7
+    expect(TestEnum3.test_tagged_typedef_enum2(:c8)).to be :c8
+    expect(TestEnum3.test_tagged_typedef_enum3(:c9)).to be :c9
+    expect(TestEnum3.test_tagged_typedef_enum3(:c10)).to be :c10
+    expect(TestEnum3.test_tagged_typedef_enum3(:c11)).to be :c11
+    expect(TestEnum3.test_tagged_typedef_enum3(:c12)).to be :c12
+    expect(TestEnum3.test_tagged_typedef_enum4(:c13)).to be :c13
+    expect(TestEnum3.test_tagged_typedef_enum4(:c14)).to be :c14
+    expect(TestEnum3.test_tagged_typedef_enum4(:c15)).to be :c15
+    expect(TestEnum3.test_tagged_typedef_enum4(:c16)).to be :c16
   end
 
   it "integers can be used instead of constants" do
-    TestEnum3.test_tagged_typedef_enum1(0).should == :c1
-    TestEnum3.test_tagged_typedef_enum1(1).should == :c2
-    TestEnum3.test_tagged_typedef_enum1(2).should == :c3
-    TestEnum3.test_tagged_typedef_enum1(3).should == :c4
-    TestEnum3.test_tagged_typedef_enum2(42).should == :c5
-    TestEnum3.test_tagged_typedef_enum2(43).should == :c6
-    TestEnum3.test_tagged_typedef_enum2(44).should == :c7
-    TestEnum3.test_tagged_typedef_enum2(45).should == :c8
-    TestEnum3.test_tagged_typedef_enum3(42).should == :c9
-    TestEnum3.test_tagged_typedef_enum3(43).should == :c10
-    TestEnum3.test_tagged_typedef_enum3(4242).should == :c11
-    TestEnum3.test_tagged_typedef_enum3(4243).should == :c12
-    TestEnum3.test_tagged_typedef_enum4(42).should == :c13
-    TestEnum3.test_tagged_typedef_enum4(4242).should == :c14
-    TestEnum3.test_tagged_typedef_enum4(424242).should == :c15
-    TestEnum3.test_tagged_typedef_enum4(42424242).should == :c16
+    expect(TestEnum3.test_tagged_typedef_enum1(0)).to be :c1
+    expect(TestEnum3.test_tagged_typedef_enum1(1)).to be :c2
+    expect(TestEnum3.test_tagged_typedef_enum1(2)).to be :c3
+    expect(TestEnum3.test_tagged_typedef_enum1(3)).to be :c4
+    expect(TestEnum3.test_tagged_typedef_enum2(42)).to be :c5
+    expect(TestEnum3.test_tagged_typedef_enum2(43)).to be :c6
+    expect(TestEnum3.test_tagged_typedef_enum2(44)).to be :c7
+    expect(TestEnum3.test_tagged_typedef_enum2(45)).to be :c8
+    expect(TestEnum3.test_tagged_typedef_enum3(42)).to be :c9
+    expect(TestEnum3.test_tagged_typedef_enum3(43)).to be :c10
+    expect(TestEnum3.test_tagged_typedef_enum3(4242)).to be :c11
+    expect(TestEnum3.test_tagged_typedef_enum3(4243)).to be :c12
+    expect(TestEnum3.test_tagged_typedef_enum4(42)).to be :c13
+    expect(TestEnum3.test_tagged_typedef_enum4(4242)).to be :c14
+    expect(TestEnum3.test_tagged_typedef_enum4(424242)).to be :c15
+    expect(TestEnum3.test_tagged_typedef_enum4(42424242)).to be :c16
   end
 end
 
 describe "All enums" do
   it "have autonumbered constants when defined with names only" do
-    TestEnum1.enum_value(:c1).should == 0
-    TestEnum1.enum_value(:c2).should == 1
-    TestEnum1.enum_value(:c3).should == 2
-    TestEnum1.enum_value(:c4).should == 3
-
-    TestEnum3.enum_value(:c1).should == 0
-    TestEnum3.enum_value(:c2).should == 1
-    TestEnum3.enum_value(:c3).should == 2
-    TestEnum3.enum_value(:c4).should == 3
+    expect(TestEnum1.enum_value(:c1)).to eq(0)
+    expect(TestEnum1.enum_value(:c2)).to eq(1)
+    expect(TestEnum1.enum_value(:c3)).to eq(2)
+    expect(TestEnum1.enum_value(:c4)).to eq(3)
+
+    expect(TestEnum3.enum_value(:c1)).to eq(0)
+    expect(TestEnum3.enum_value(:c2)).to eq(1)
+    expect(TestEnum3.enum_value(:c3)).to eq(2)
+    expect(TestEnum3.enum_value(:c4)).to eq(3)
   end
+
   it "can have an explicit first constant and autonumbered subsequent constants" do
-    TestEnum1.enum_value(:c5).should == 42
-    TestEnum1.enum_value(:c6).should == 43
-    TestEnum1.enum_value(:c7).should == 44
-    TestEnum1.enum_value(:c8).should == 45
-
-    TestEnum3.enum_value(:c5).should == 42
-    TestEnum3.enum_value(:c6).should == 43
-    TestEnum3.enum_value(:c7).should == 44
-    TestEnum3.enum_value(:c8).should == 45
+    expect(TestEnum1.enum_value(:c5)).to eq(42)
+    expect(TestEnum1.enum_value(:c6)).to eq(43)
+    expect(TestEnum1.enum_value(:c7)).to eq(44)
+    expect(TestEnum1.enum_value(:c8)).to eq(45)
+
+    expect(TestEnum3.enum_value(:c5)).to eq(42)
+    expect(TestEnum3.enum_value(:c6)).to eq(43)
+    expect(TestEnum3.enum_value(:c7)).to eq(44)
+    expect(TestEnum3.enum_value(:c8)).to eq(45)
   end
+
   it "can have a mix of explicit and autonumbered constants" do
-    TestEnum1.enum_value(:c9).should  == 42
-    TestEnum1.enum_value(:c10).should == 43
-    TestEnum1.enum_value(:c11).should == 4242
-    TestEnum1.enum_value(:c12).should == 4243
-
-    TestEnum3.enum_value(:c9).should  == 42
-    TestEnum3.enum_value(:c10).should == 43
-    TestEnum3.enum_value(:c11).should == 4242
-    TestEnum3.enum_value(:c12).should == 4243
+    expect(TestEnum1.enum_value(:c9)).to eq(42)
+    expect(TestEnum1.enum_value(:c10)).to eq(43)
+    expect(TestEnum1.enum_value(:c11)).to eq(4242)
+    expect(TestEnum1.enum_value(:c12)).to eq(4243)
+
+    expect(TestEnum3.enum_value(:c9)).to eq(42)
+    expect(TestEnum3.enum_value(:c10)).to eq(43)
+    expect(TestEnum3.enum_value(:c11)).to eq(4242)
+    expect(TestEnum3.enum_value(:c12)).to eq(4243)
   end
+
   it "can have all its constants explicitely valued" do
-    TestEnum1.enum_value(:c13).should == 42
-    TestEnum1.enum_value(:c14).should == 4242
-    TestEnum1.enum_value(:c15).should == 424242
-    TestEnum1.enum_value(:c16).should == 42424242
+    expect(TestEnum1.enum_value(:c13)).to eq(42)
+    expect(TestEnum1.enum_value(:c14)).to eq(4242)
+    expect(TestEnum1.enum_value(:c15)).to eq(424242)
+    expect(TestEnum1.enum_value(:c16)).to eq(42424242)
     
-    TestEnum3.enum_value(:c13).should == 42
-    TestEnum3.enum_value(:c14).should == 4242
-    TestEnum3.enum_value(:c15).should == 424242
-    TestEnum3.enum_value(:c16).should == 42424242
+    expect(TestEnum3.enum_value(:c13)).to eq(42)
+    expect(TestEnum3.enum_value(:c14)).to eq(4242)
+    expect(TestEnum3.enum_value(:c15)).to eq(424242)
+    expect(TestEnum3.enum_value(:c16)).to eq(42424242)
   end
+
   it "return the constant corresponding to a specific value" do
     enum = TestEnum3.enum_type(:enum_type1)
-    enum[0].should == :c1
-    enum[1].should == :c2
-    enum[2].should == :c3
-    enum[3].should == :c4
+    expect(enum[0]).to be :c1
+    expect(enum[1]).to be :c2
+    expect(enum[2]).to be :c3
+    expect(enum[3]).to be :c4
 
     enum = TestEnum3.enum_type(:enum_type2)
-    enum[42].should == :c5
-    enum[43].should == :c6
-    enum[44].should == :c7
-    enum[45].should == :c8
+    expect(enum[42]).to be :c5
+    expect(enum[43]).to be :c6
+    expect(enum[44]).to be :c7
+    expect(enum[45]).to be :c8
 
     enum = TestEnum3.enum_type(:enum_type3)
-    enum[42].should == :c9
-    enum[43].should == :c10
-    enum[4242].should == :c11
-    enum[4243].should == :c12
+    expect(enum[42]).to be :c9
+    expect(enum[43]).to be :c10
+    expect(enum[4242]).to be :c11
+    expect(enum[4243]).to be :c12
 
     enum = TestEnum3.enum_type(:enum_type4)
-    enum[42].should == :c13
-    enum[4242].should == :c14
-    enum[424242].should == :c15
-    enum[42424242].should == :c16
+    expect(enum[42]).to be :c13
+    expect(enum[4242]).to be :c14
+    expect(enum[424242]).to be :c15
+    expect(enum[42424242]).to be :c16
   end
+
   it "return nil for values that don't have a symbol" do
     enum = TestEnum3.enum_type(:enum_type1)
-    enum[-1].should == nil
-    enum[4].should == nil
+    expect(enum[-1]).to be_nil
+    expect(enum[4]).to be_nil
 
     enum = TestEnum3.enum_type(:enum_type2)
-    enum[0].should == nil
-    enum[41].should == nil
-    enum[46].should == nil
+    expect(enum[0]).to be_nil
+    expect(enum[41]).to be_nil
+    expect(enum[46]).to be_nil
 
     enum = TestEnum3.enum_type(:enum_type3)
-    enum[0].should == nil
-    enum[41].should == nil
-    enum[44].should == nil
-    enum[4241].should == nil
-    enum[4244].should == nil
+    expect(enum[0]).to be_nil
+    expect(enum[41]).to be_nil
+    expect(enum[44]).to be_nil
+    expect(enum[4241]).to be_nil
+    expect(enum[4244]).to be_nil
 
     enum = TestEnum3.enum_type(:enum_type4)
-    enum[0].should == nil
-    enum[41].should == nil
-    enum[43].should == nil
-    enum[4241].should == nil
-    enum[4243].should == nil
-    enum[424241].should == nil
-    enum[424243].should == nil
-    enum[42424241].should == nil
-    enum[42424243].should == nil
+    expect(enum[0]).to be_nil
+    expect(enum[41]).to be_nil
+    expect(enum[43]).to be_nil
+    expect(enum[4241]).to be_nil
+    expect(enum[4243]).to be_nil
+    expect(enum[424241]).to be_nil
+    expect(enum[424243]).to be_nil
+    expect(enum[42424241]).to be_nil
+    expect(enum[42424243]).to be_nil
   end
 
   it "duplicate enum keys rejected" do
-    lambda { enum [ :a, 0xfee1dead, :b, 0xdeadbeef, :a, 0 ] }.should raise_error
+    expect { enum [ :a, 0xfee1dead, :b, 0xdeadbeef, :a, 0 ] }.to raise_error
   end
 end

data/spec/ffi/errno_spec.rb

@@ -4,7 +4,6 @@
 #
 
 require File.expand_path(File.join(File.dirname(__FILE__), "spec_helper"))
-require 'ffi'
 
 describe "FFI.errno" do
   module LibTest
@@ -12,9 +11,10 @@ describe "FFI.errno" do
     ffi_lib TestLibrary::PATH
     attach_function :setLastError, [ :int ], :void
   end
+
   it "FFI.errno contains errno from last function" do
     LibTest.setLastError(0)
     LibTest.setLastError(0x12345678)
-    FFI.errno.should == 0x12345678
+    expect(FFI.errno).to eq(0x12345678)
   end
 end