Update structfu spec to use expects

spec/structfu_spec.rb

@@ -1,7 +1,6 @@
 require 'spec_helper'
 
 describe StructFu, "mixin methods" do
-
   before :each do
     class StructClass
       include StructFu
@@ -10,42 +9,40 @@ class StructClass
   end
 
   it "should provide the basic StructFu methods" do
-    @sc.respond_to?(:sz).should be true
-    @sc.respond_to?(:len).should be true
-    @sc.respond_to?(:typecast).should be true
-    @sc.respond_to?(:body=).should be true
+    expect(@sc).to respond_to(:sz)
+    expect(@sc).to respond_to(:len)
+    expect(@sc).to respond_to(:typecast)
+    expect(@sc).to respond_to(:body=)
   end
 end
 
 describe StructFu::Int, "basic Int class" do
-
   before :each do
     @int = StructFu::Int.new(8)
   end
 
   it "should have an initial state" do
     new_int = StructFu::Int.new
-    new_int.value.should be_nil
-    new_int.endian.should be_nil
-    new_int.width.should be_nil
-    new_int.default.should == 0
+    expect(new_int.value).to be_nil
+    expect(new_int.endian).to be_nil
+    expect(new_int.width).to be_nil
+    expect(new_int.default).to eql(0)
   end
 
   it "should raise when to_s'ed directly" do
-    expect { @int.to_s}.to raise_error(StandardError, "StructFu::Int#to_s accessed, must be redefined.")
+    expect{ @int.to_s}.to raise_error(StandardError, "StructFu::Int#to_s accessed, must be redefined.")
   end
 
   it "should have a value of 8" do
-    @int.value.should == 8
-    @int.to_i.should == 8
-    @int.to_f.to_s.should == "8.0"
+    expect(@int.value).to eql(8)
+    expect(@int.to_i).to eql(8)
+    expect(@int.to_f.to_s).to eql("8.0")
   end
 
   it "should read an integer" do
     @int.read(7)
-    @int.to_i.should == 7
+    expect(@int.to_i).to eql(7)
   end
-
 end
 
 describe StructFu::Int8, "one byte value" do
@@ -56,82 +53,85 @@ class StructClass
 
   it "should have an initial state" do
     new_int = StructFu::Int8.new
-    new_int.value.should be_nil
-    new_int.endian.should be_nil
-    new_int.width.should == 1
-    new_int.default.should == 0
+    expect(new_int.value).to be_nil
+    expect(new_int.endian).to be_nil
+    expect(new_int.width).to eql(1)
+    expect(new_int.default).to eql(0)
   end
 
   it "should print a one character packed string" do
-    @int.to_s.should == "\x0b"
+    expect(@int.to_s).to eql("\x0b")
   end
 
   it "should have a value of 11" do
-    @int.value.should == 11
-    @int.to_i.should == 11
-    @int.to_f.to_s.should == "11.0"
+    expect(@int.value).to eql(11)
+    expect(@int.to_i).to eql(11)
+    expect(@int.to_f.to_s).to eql("11.0")
   end
 
   it "should reset with a new integer" do
     @int.read(2)
-    @int.to_i.should == 2
-    @int.to_s.should == "\x02"
+    expect(@int.to_i).to eql(2)
+    expect(@int.to_s).to eql("\x02")
+
     @int.read(254)
-    @int.to_i.should == 254
-    @int.to_s.should == "\xfe".force_encoding("binary")
+    expect(@int.to_i).to eql(254)
+    expect(@int.to_s).to eql("\xfe".force_encoding("binary"))
   end
 
 end
 
 describe StructFu::Int16, "two byte value" do
-
   before :each do
     @int = StructFu::Int16.new(11)
   end
 
   it "should have an initial state" do
     new_int = StructFu::Int16.new
-    new_int.value.should be_nil
-    new_int.endian.should == :big
-    new_int.width.should == 2
-    new_int.default.should == 0
+    expect(new_int.value).to be_nil
+    expect(new_int.endian).to eql(:big)
+    expect(new_int.width).to eql(2)
+    expect(new_int.default).to eql(0)
   end
 
   it "should print a two character packed string" do
-    @int.to_s.should == "\x00\x0b".force_encoding("binary")
+    expect(@int.to_s).to eql("\x00\x0b".force_encoding("binary"))
   end
 
   it "should have a value of 11" do
-    @int.value.should == 11
-    @int.to_i.should == 11
-    @int.to_f.to_s.should == "11.0"
+    expect(@int.value).to eql(11)
+    expect(@int.to_i).to eql(11)
+    expect(@int.to_f.to_s).to eql("11.0")
   end
 
   it "should reset with a new integer" do
     @int.read(2)
-    @int.to_i.should == 2
-    @int.to_s.should == "\x00\x02"
+    expect(@int.to_i).to eql(2)
+    expect(@int.to_s).to eql("\x00\x02")
+
     @int.read(254)
-    @int.to_i.should == 254
-    @int.to_s.should == "\x00\xfe".force_encoding("binary")
+    expect(@int.to_i).to eql(254)
+    expect(@int.to_s).to eql("\x00\xfe".force_encoding("binary"))
   end
 
   it "should be able to set endianness" do
     int_be = StructFu::Int16.new(11,:big)
-    int_be.to_s.should == "\x00\x0b"
+    expect(int_be.to_s).to eql("\x00\x0b")
+
     int_le = StructFu::Int16.new(11,:little)
-    int_le.to_s.should == "\x0b\x00"
+    expect(int_le.to_s).to eql("\x0b\x00")
   end
 
   it "should be able to switch endianness" do
     @int.endian.should == :big
-    @int.to_s.should == "\x00\x0b"
+    expect(@int.to_s).to eql("\x00\x0b")
+
     @int.endian = :little
-    @int.endian.should == :little
+    expect(@int.endian).to eql(:little)
+
     @int.read(11)
-    @int.to_s.should == "\x0b\x00"
+    expect(@int.to_s).to eql("\x0b\x00")
   end
-
 end
 
 describe StructFu::Int16le, "2 byte little-endian value" do
@@ -141,7 +141,7 @@ class StructClass
   end
 
   it "should behave pretty much like any other 16 bit int" do
-    @int.to_s.should == "\x0b\x00"
+    expect(@int.to_s).to eql("\x0b\x00")
   end
 
   it "should raise when you try to change endianness" do
@@ -158,7 +158,7 @@ class StructClass
   end
 
   it "should behave pretty much like any other 16 bit int" do
-    @int.to_s.should == "\x00\x0b"
+    expect(@int.to_s).to eql("\x00\x0b")
   end
 
   it "should raise when you try to change endianness" do
@@ -176,45 +176,49 @@ class StructClass
 
   it "should have an initial state" do
     new_int = StructFu::Int32.new
-    new_int.value.should be_nil
-    new_int.endian.should == :big
-    new_int.width.should == 4
-    new_int.default.should == 0
+    expect(new_int.value).to be_nil
+    expect(new_int.endian).to eql(:big)
+    expect(new_int.width).to eql(4)
+    expect(new_int.default).to eql(0)
   end
 
   it "should print a four character packed string" do
-    @int.to_s.should == "\x00\x00\x00\x0b"
+    expect(@int.to_s).to eql("\x00\x00\x00\x0b")
   end
 
   it "should have a value of 11" do
-    @int.value.should == 11
-    @int.to_i.should == 11
-    @int.to_f.to_s.should == "11.0"
+    expect(@int.value).to eql(11)
+    expect(@int.to_i).to eql(11)
+    expect(@int.to_f.to_s).to eql("11.0")
   end
 
   it "should reset with a new integer" do
     @int.read(2)
-    @int.to_i.should == 2
-    @int.to_s.should == "\x00\x00\x00\x02"
+    expect(@int.to_i).to eql(2)
+    expect(@int.to_s).to eql("\x00\x00\x00\x02")
+
     @int.read(254)
-    @int.to_i.should == 254
-    @int.to_s.should == "\x00\x00\x00\xfe".force_encoding("binary")
+    expect(@int.to_i).to eql(254)
+    expect(@int.to_s).to eql("\x00\x00\x00\xfe".force_encoding("binary"))
   end
 
   it "should be able to set endianness" do
     int_be = StructFu::Int32.new(11,:big)
-    int_be.to_s.should == "\x00\x00\x00\x0b"
+    expect(int_be.to_s).to eql("\x00\x00\x00\x0b")
+
     int_le = StructFu::Int32.new(11,:little)
-    int_le.to_s.should == "\x0b\x00\x00\x00"
+    expect(int_le.to_s).to eql("\x0b\x00\x00\x00")
   end
 
   it "should be able to switch endianness" do
     @int.endian.should == :big
-    @int.to_s.should == "\x00\x00\x00\x0b"
+    expect(@int.to_s).to eql("\x00\x00\x00\x0b")
+
     @int.endian = :little
-    @int.endian.should == :little
+    expect(@int.endian).to eql(:little)
+
     @int.read(11)
-    @int.to_s.should == "\x0b\x00\x00\x00"
+    expect(@int.to_s).to eql("\x0b\x00\x00\x00")
   end
 
 end
@@ -226,7 +230,7 @@ class StructClass
   end
 
   it "should behave pretty much like any other 32 bit int" do
-    @int.to_s.should == "\x0b\x00\x00\x00"
+    expect(@int.to_s).to eql("\x0b\x00\x00\x00")
   end
 
   it "should raise when you try to change endianness" do
@@ -243,7 +247,7 @@ class StructClass
   end
 
   it "should behave pretty much like any other 32 bit int" do
-    @int.to_s.should == "\x00\x00\x00\x0b"
+    expect(@int.to_s).to eql("\x00\x00\x00\x0b")
   end
 
   it "should raise when you try to change endianness" do
@@ -260,16 +264,16 @@ class StructClass
   end
 
   it "should behave pretty much like a string" do
-    @str.should be_kind_of(String)
+    expect(@str).to be_kind_of(String)
   end
 
   it "should have a read method" do
-    @str.should respond_to(:read)
+    expect(@str).to respond_to(:read)
   end
 
   it "should read data like other StructFu things" do
     @str.read("hello")
-    @str.should == "hello"
+    expect(@str).to eql("hello")
   end
 
 end
@@ -282,53 +286,53 @@ class StructClass
 
   it "should have a length and value" do
     istr = StructFu::IntString.new("Avast!")
-    istr.to_s.should == "\x06Avast!"
+    expect(istr.to_s).to eql("\x06Avast!")
   end
 
   it "should have a 16-bit length and a value" do
     istr = StructFu::IntString.new("Avast!",StructFu::Int16)
-    istr.to_s.should == "\x00\x06Avast!"
+    expect(istr.to_s).to eql("\x00\x06Avast!")
   end
 
   it "should have a 32-bit length and a value" do
     istr = StructFu::IntString.new("Avast!",StructFu::Int32)
-    istr.to_s.should == "\x00\x00\x00\x06Avast!"
+    expect(istr.to_s).to eql("\x00\x00\x00\x06Avast!")
   end
 
   before :each do
     @istr = StructFu::IntString.new("Avast!",StructFu::Int32)
   end
 
   it "should report the correct length with a new string" do
-    @istr.to_s.should == "\x00\x00\x00\x06Avast!"
+    expect(@istr.to_s).to eql("\x00\x00\x00\x06Avast!")
+
     @istr.string = "Ahoy!"
-    @istr.to_s.should == "\x00\x00\x00\x05Ahoy!"
+    expect(@istr.to_s).to eql("\x00\x00\x00\x05Ahoy!")
   end
 
   it "should report the correct length with a new string" do
     @istr.string = "Ahoy!"
-    @istr.to_s.should == "\x00\x00\x00\x05Ahoy!"
+    expect(@istr.to_s).to eql("\x00\x00\x00\x05Ahoy!")
   end
 
   it "should keep the old length with a new string" do
     @istr[:string] = "Ahoy!"
-    @istr.to_s.should == "\x00\x00\x00\x06Ahoy!"
+    expect(@istr.to_s).to eql("\x00\x00\x00\x06Ahoy!")
   end
 
   it "should allow for adjusting the length manually" do
     @istr.len = 16
-    @istr.to_s.should == "\x00\x00\x00\x10Avast!"
+    expect(@istr.to_s).to eql("\x00\x00\x00\x10Avast!")
   end
 
   it "should read in an expected string" do
     data = "\x00\x00\x00\x09Yo ho ho!"
     @istr.read(data)
-    @istr.to_s.should == data
+    expect(@istr.to_s).to eql(data)
   end
 
   it "should raise when a string is too short" do
     data = "\x01A"
-    expect { @istr.read(data) }.to raise_error(StandardError, "String is too short for type StructFu::Int32")
+    expect{ @istr.read(data) }.to raise_error(StandardError, "String is too short for type StructFu::Int32")
   end
-
 end