ronin-support 0.5.1 → 0.5.2

data/spec/binary/struct_spec.rb

@@ -14,28 +14,28 @@ describe Binary::Struct do
     end
 
     it "should return the layout" do
-      subject.class.layout.should == [
+      expect(subject.class.layout).to eq([
         :x,
         :y
-      ]
+      ])
     end
 
     context "when given fields" do
       it "should populate fields" do
-        subject.class.fields.should == {
+        expect(subject.class.fields).to eq({
           :x => [:uint, nil],
           :y => [:uint, nil]
-        }
+        })
       end
 
       it "should define reader methods" do
-        subject.should respond_to(:x)
-        subject.should respond_to(:y)
+        expect(subject).to respond_to(:x)
+        expect(subject).to respond_to(:y)
       end
 
       it "should define writer methods" do
-        subject.should respond_to(:x=)
-        subject.should respond_to(:y=)
+        expect(subject).to respond_to(:x=)
+        expect(subject).to respond_to(:y=)
       end
     end
   end
@@ -48,8 +48,8 @@ describe Binary::Struct do
     end
 
     it "should determine if fields exist" do
-      subject.field?(:x).should == true
-      subject.field?(:foo).should == false
+      expect(subject.field?(:x)).to be(true)
+      expect(subject.field?(:foo)).to be(false)
     end
   end
 
@@ -61,14 +61,14 @@ describe Binary::Struct do
     end
 
     it "should return the endianness of the Struct" do
-      subject.endian.should == :little
+      expect(subject.endian).to eq(:little)
     end
 
     context "when given an argument" do
       it "should set the endianness" do
         subject.endian :big
 
-        subject.endian.should == :big
+        expect(subject.endian).to eq(:big)
       end
     end
   end
@@ -87,11 +87,11 @@ describe Binary::Struct do
     end
 
     it "should register a new type in typedefs" do
-      subject.typedefs.should have_key(:test_t)
+      expect(subject.typedefs).to have_key(:test_t)
     end
 
     it "should resolve the existing type" do
-      subject.typedefs[:test_t].should == :uint32
+      expect(subject.typedefs[:test_t]).to eq(:uint32)
     end
   end
 
@@ -119,40 +119,40 @@ describe Binary::Struct do
     end
 
     it "should set integers to 0" do
-      subject[:int].should == 0
+      expect(subject[:int]).to eq(0)
     end
 
     it "should set arrays of integers to [0, ...]" do
-      subject[:int_array].should == [0, 0]
+      expect(subject[:int_array]).to eq([0, 0])
     end
 
     it "should set floats to 0.0" do
-      subject[:float].should == 0.0
+      expect(subject[:float]).to eq(0.0)
     end
 
     it "should set arrays of floats to [0.0, ...]" do
-      subject[:float_array].should == [0.0, 0.0]
+      expect(subject[:float_array]).to eq([0.0, 0.0])
     end
 
     it "should set chars to '\\0'" do
-      subject[:char].should == "\0"
+      expect(subject[:char]).to eq("\0")
     end
 
     it "should set arrays of chars to ''" do
-      subject[:char_array].should == ''
+      expect(subject[:char_array]).to eq('')
     end
 
     it "should set strings to ''" do
-      subject[:string].should == ''
+      expect(subject[:string]).to eq('')
     end
 
     it "should initialize nested structs" do
-      subject[:struct][:int].should == 0
+      expect(subject[:struct][:int]).to eq(0)
     end
 
     it "should initialize arrays of nested structs" do
-      subject[:struct_array][0][:int].should == 0
-      subject[:struct_array][1][:int].should == 0
+      expect(subject[:struct_array][0][:int]).to eq(0)
+      expect(subject[:struct_array][1][:int]).to eq(0)
     end
   end
 
@@ -167,24 +167,24 @@ describe Binary::Struct do
       struct.new
     end
 
-    before(:all) do
+    before do
       subject.instance_variable_set('@x',10)
     end
 
     it "should access the instance variable" do
-      subject[:x].should == 10
+      expect(subject[:x]).to eq(10)
     end
 
     it "should still call the underlying reader method" do
-      subject.should_receive(:x).and_return(10)
+      expect(subject).to receive(:x).and_return(10)
 
       subject[:x]
     end
 
     it "should raise ArgumentError for unknown fields" do
-      lambda {
+      expect {
         subject[:foo]
-      }.should raise_error(ArgumentError)
+      }.to raise_error(ArgumentError)
     end
   end
 
@@ -199,26 +199,26 @@ describe Binary::Struct do
       struct.new
     end
 
-    before(:each) do
+    before do
       subject.instance_variable_set('@x',0)
     end
 
     it "should set the underlying instance variable" do
       subject[:x] = 20
 
-      subject.instance_variable_get('@x').should == 20
+      expect(subject.instance_variable_get('@x')).to eq(20)
     end
 
     it "should still call the underlying writer method" do
-      subject.should_receive(:x=).with(20)
+      expect(subject).to receive(:x=).with(20)
 
       subject[:x] = 20
     end
 
     it "should raise ArgumentError for unknown fields" do
-      lambda {
+      expect {
         subject[:foo] = 20
-      }.should raise_error(ArgumentError)
+      }.to raise_error(ArgumentError)
     end
   end
 
@@ -236,13 +236,13 @@ describe Binary::Struct do
       struct.new
     end
 
-    before(:each) do
+    before do
       subject.x = x
       subject.y = y
     end
 
     it "should return the values of the fields" do
-      subject.values.should == [x, y]
+      expect(subject.values).to eq([x, y])
     end
 
     context "nested structs" do
@@ -264,12 +264,12 @@ describe Binary::Struct do
         struct.new
       end
 
-      before(:each) do
+      before do
         subject.z.int = z
       end
 
       it "should nest the values of nested structs" do
-        subject.values.should == [x, y, [z]]
+        expect(subject.values).to eq([x, y, [z]])
       end
     end
 
@@ -292,13 +292,13 @@ describe Binary::Struct do
         struct.new
       end
 
-      before(:each) do
+      before do
         subject.z[0].int = z
         subject.z[1].int = z
       end
 
       it "should nest the values of nested structs" do
-        subject.values.should == [x, y, [[z], [z]]]
+        expect(subject.values).to eq([x, y, [[z], [z]]])
       end
     end
   end
@@ -320,7 +320,7 @@ describe Binary::Struct do
       struct.new
     end
 
-    before(:all) do
+    before do
       subject.x = 100
       subject.y = 15.0
       subject.z.int = -1
@@ -329,12 +329,12 @@ describe Binary::Struct do
     end
 
     it "should reset fields to their default values" do
-      subject.x.should == 0
-      subject.y.should == 0.0
+      expect(subject.x).to eq(0)
+      expect(subject.y).to eq(0.0)
     end
 
     it "should reinitialize nested structs" do
-      subject.z.int.should == 0
+      expect(subject.z.int).to eq(0)
     end
   end
 
@@ -352,12 +352,12 @@ describe Binary::Struct do
         struct.new
       end
 
-      before(:each) do
+      before do
         subject.chars = string
       end
 
       it "should pack arrays of chars into a String" do
-        subject.pack.should == packed
+        expect(subject.pack).to eq(packed)
       end
     end
 
@@ -379,13 +379,13 @@ describe Binary::Struct do
         struct.new
       end
 
-      before(:each) do
+      before do
         subject.int = 10
         subject.struct.int = 20
       end
 
       it "should pack the nested struct fields" do
-        subject.pack.should == packed
+        expect(subject.pack).to eq(packed)
       end
     end
 
@@ -407,14 +407,14 @@ describe Binary::Struct do
         struct.new
       end
 
-      before(:each) do
+      before do
         subject.int = 10
         subject.struct[0].int = 20
         subject.struct[1].int = 30
       end
 
       it "should pack the nested fields" do
-        subject.pack.should == packed
+        expect(subject.pack).to eq(packed)
       end
     end
   end
@@ -436,7 +436,7 @@ describe Binary::Struct do
       it "should unpack arrays of chars into a String" do
         subject.unpack(packed)
 
-        subject.chars.should == string
+        expect(subject.chars).to eq(string)
       end
     end
 
@@ -461,8 +461,8 @@ describe Binary::Struct do
       it "should unpack the nested struct fields" do
         subject.unpack(packed)
 
-        subject.int.should        == 10
-        subject.struct.int.should == 20
+        expect(subject.int).to        eq(10)
+        expect(subject.struct.int).to eq(20)
       end
     end
 
@@ -487,9 +487,9 @@ describe Binary::Struct do
       it "should unpack the nested fields" do
         subject.unpack(packed)
         
-        subject.int.should           == 10
-        subject.struct[0].int.should == 20
-        subject.struct[1].int.should == 30
+        expect(subject.int).to           eq(10)
+        expect(subject.struct[0].int).to eq(20)
+        expect(subject.struct[1].int).to eq(30)
       end
     end
   end

data/spec/binary/template_spec.rb

@@ -1,3 +1,5 @@
+# encoding: US-ASCII
+
 require 'spec_helper'
 require 'ronin/binary/template'
 
@@ -5,71 +7,71 @@ describe Binary::Template do
   describe "TYPES" do
     subject { described_class::TYPES }
 
-    it("uint8      => C") { subject[:uint8].should       == 'C' }
-    it("uint16     => S") { subject[:uint16].should      == 'S' }
-    it("uint32     => L") { subject[:uint32].should      == 'L' }
-    it("uint64     => Q") { subject[:uint64].should      == 'Q' }
-    it("int8       => C") { subject[:int8].should        == 'c' }
-    it("int16      => S") { subject[:int16].should       == 's' }
-    it("int32      => L") { subject[:int32].should       == 'l' }
-    it("int64      => Q") { subject[:int64].should       == 'q' }
+    it("uint8      => C")  { expect(subject[:uint8]).to       eq('C' ) }
+    it("uint16     => S")  { expect(subject[:uint16]).to      eq('S' ) }
+    it("uint32     => L")  { expect(subject[:uint32]).to      eq('L' ) }
+    it("uint64     => Q")  { expect(subject[:uint64]).to      eq('Q' ) }
+    it("int8       => C")  { expect(subject[:int8]).to        eq('c' ) }
+    it("int16      => S")  { expect(subject[:int16]).to       eq('s' ) }
+    it("int32      => L")  { expect(subject[:int32]).to       eq('l' ) }
+    it("int64      => Q")  { expect(subject[:int64]).to       eq('q' ) }
     if RUBY_VERSION < '1.9.'
-    it("uint16_le  => v") { subject[:uint16_le].should   == 'v' }
-    it("uint32_le  => V") { subject[:uint32_le].should   == 'V' }
-    it("uint16_be  => n") { subject[:uint16_be].should   == 'n' }
-    it("uint32_be  => N") { subject[:uint32_be].should   == 'N' }
-    end
-    it("uchar      => Z")  { subject[:uchar].should      == 'Z' }
-    it("ushort     => S!") { subject[:ushort].should     == 'S!'}
-    it("uint       => I!") { subject[:uint].should       == 'I!'}
-    it("ulong      => L!") { subject[:ulong].should      == 'L!'}
-    it("ulong_long => Q")  { subject[:ulong_long].should == 'Q' }
-    it("char       => Z")  { subject[:char].should       == 'Z' }
-    it("short      => s!") { subject[:short].should      == 's!'}
-    it("int        => i!") { subject[:int].should        == 'i!'}
-    it("long       => l!") { subject[:long].should       == 'l!'}
-    it("long_long  => q")  { subject[:long_long].should  == 'q' }
-    it("utf8       => U")  { subject[:utf8].should       == 'U' }
-    it("float      => F") { subject[:float].should       == 'F' }
-    it("double     => D") { subject[:double].should      == 'D' }
-    it("float_le   => e") { subject[:float_le].should    == 'e' }
-    it("double_le  => E") { subject[:double_le].should   == 'E' }
-    it("float_be   => g") { subject[:float_be].should    == 'g' }
-    it("double_ge  => G") { subject[:double_be].should   == 'G' }
-    it("ubyte      => C") { subject[:ubyte].should       == 'C' }
-    it("byte       => c") { subject[:byte].should        == 'c' }
-    it("string     => Z*") { subject[:string].should     == 'Z*'}
+    it("uint16_le  => v")  { expect(subject[:uint16_le]).to   eq('v' ) }
+    it("uint32_le  => V")  { expect(subject[:uint32_le]).to   eq('V' ) }
+    it("uint16_be  => n")  { expect(subject[:uint16_be]).to   eq('n' ) }
+    it("uint32_be  => N")  { expect(subject[:uint32_be]).to   eq('N' ) }
+    end
+    it("uchar      => Z")  { expect(subject[:uchar]).to      eq('Z' ) }
+    it("ushort     => S!") { expect(subject[:ushort]).to     eq('S!') }
+    it("uint       => I!") { expect(subject[:uint]).to       eq('I!') }
+    it("ulong      => L!") { expect(subject[:ulong]).to      eq('L!') }
+    it("ulong_long => Q")  { expect(subject[:ulong_long]).to eq('Q' ) }
+    it("char       => Z")  { expect(subject[:char]).to       eq('Z' ) }
+    it("short      => s!") { expect(subject[:short]).to      eq('s!') }
+    it("int        => i!") { expect(subject[:int]).to        eq('i!') }
+    it("long       => l!") { expect(subject[:long]).to       eq('l!') }
+    it("long_long  => q")  { expect(subject[:long_long]).to  eq('q' ) }
+    it("utf8       => U")  { expect(subject[:utf8]).to       eq('U' ) }
+    it("float      => F")  { expect(subject[:float]).to       eq('F' ) }
+    it("double     => D")  { expect(subject[:double]).to      eq('D' ) }
+    it("float_le   => e")  { expect(subject[:float_le]).to    eq('e' ) }
+    it("double_le  => E")  { expect(subject[:double_le]).to   eq('E' ) }
+    it("float_be   => g")  { expect(subject[:float_be]).to    eq('g' ) }
+    it("double_ge  => G")  { expect(subject[:double_be]).to   eq('G' ) }
+    it("ubyte      => C")  { expect(subject[:ubyte]).to       eq('C' ) }
+    it("byte       => c")  { expect(subject[:byte]).to        eq('c' ) }
+    it("string     => Z*") { expect(subject[:string]).to     eq('Z*') }
 
     if RUBY_VERSION > '1.9.'
       context "Ruby 1.9" do
-        it("uint16_le     => S<") { subject[:uint16_le].should      == 'S<' }
-        it("uint32_le     => L<") { subject[:uint32_le].should      == 'L<' }
-        it("uint64_le     => Q<") { subject[:uint64_le].should      == 'Q<' }
-        it("int16_le      => S<") { subject[:int16_le].should       == 's<' }
-        it("int32_le      => L<") { subject[:int32_le].should       == 'l<' }
-        it("int64_le      => Q<") { subject[:int64_le].should       == 'q<' }
-        it("uint16_be     => S>") { subject[:uint16_be].should      == 'S>' }
-        it("uint32_be     => L>") { subject[:uint32_be].should      == 'L>' }
-        it("uint64_be     => Q>") { subject[:uint64_be].should      == 'Q>' }
-        it("int16_be      => S>") { subject[:int16_be].should       == 's>' }
-        it("int32_be      => L>") { subject[:int32_be].should       == 'l>' }
-        it("int64_be      => Q>") { subject[:int64_be].should       == 'q>' }
-        it("ushort_le     => S!<") { subject[:ushort_le].should     == 'S!<'}
-        it("uint_le       => I!<") { subject[:uint_le].should       == 'I!<'}
-        it("ulong_le      => L!<") { subject[:ulong_le].should      == 'L!<'}
-        it("ulong_long_le => L!<") { subject[:ulong_long_le].should == 'Q<' }
-        it("short_le      => S!<") { subject[:short_le].should      == 's!<'}
-        it("int_le        => I!<") { subject[:int_le].should        == 'i!<'}
-        it("long_le       => L!<") { subject[:long_le].should       == 'l!<'}
-        it("long_long_le  => L!<") { subject[:long_long_le].should  == 'q<' }
-        it("ushort_be     => S!>") { subject[:ushort_be].should     == 'S!>'}
-        it("uint_be       => I!>") { subject[:uint_be].should       == 'I!>'}
-        it("ulong_be      => L!>") { subject[:ulong_be].should      == 'L!>'}
-        it("ulong_long_be => L!>") { subject[:ulong_long_be].should == 'Q>' }
-        it("short_be      => S!>") { subject[:short_be].should      == 's!>'}
-        it("int_be        => I!>") { subject[:int_be].should        == 'i!>'}
-        it("long_be       => L!>") { subject[:long_be].should       == 'l!>'}
-        it("long_long_be  => L!>") { subject[:long_long_be].should  == 'q>' }
+        it("uint16_le     => S<") { expect(subject[:uint16_le]).to      eq('S<' ) }
+        it("uint32_le     => L<") { expect(subject[:uint32_le]).to      eq('L<' ) }
+        it("uint64_le     => Q<") { expect(subject[:uint64_le]).to      eq('Q<' ) }
+        it("int16_le      => S<") { expect(subject[:int16_le]).to       eq('s<' ) }
+        it("int32_le      => L<") { expect(subject[:int32_le]).to       eq('l<' ) }
+        it("int64_le      => Q<") { expect(subject[:int64_le]).to       eq('q<' ) }
+        it("uint16_be     => S>") { expect(subject[:uint16_be]).to      eq('S>' ) }
+        it("uint32_be     => L>") { expect(subject[:uint32_be]).to      eq('L>' ) }
+        it("uint64_be     => Q>") { expect(subject[:uint64_be]).to      eq('Q>' ) }
+        it("int16_be      => S>") { expect(subject[:int16_be]).to       eq('s>' ) }
+        it("int32_be      => L>") { expect(subject[:int32_be]).to       eq('l>' ) }
+        it("int64_be      => Q>") { expect(subject[:int64_be]).to       eq('q>' ) }
+        it("ushort_le     => S!<") { expect(subject[:ushort_le]).to     eq('S!<') }
+        it("uint_le       => I!<") { expect(subject[:uint_le]).to       eq('I!<') }
+        it("ulong_le      => L!<") { expect(subject[:ulong_le]).to      eq('L!<') }
+        it("ulong_long_le => L!<") { expect(subject[:ulong_long_le]).to eq('Q<' ) }
+        it("short_le      => S!<") { expect(subject[:short_le]).to      eq('s!<') }
+        it("int_le        => I!<") { expect(subject[:int_le]).to        eq('i!<') }
+        it("long_le       => L!<") { expect(subject[:long_le]).to       eq('l!<') }
+        it("long_long_le  => L!<") { expect(subject[:long_long_le]).to  eq('q<' ) }
+        it("ushort_be     => S!>") { expect(subject[:ushort_be]).to     eq('S!>') }
+        it("uint_be       => I!>") { expect(subject[:uint_be]).to       eq('I!>') }
+        it("ulong_be      => L!>") { expect(subject[:ulong_be]).to      eq('L!>') }
+        it("ulong_long_be => L!>") { expect(subject[:ulong_long_be]).to eq('Q>' ) }
+        it("short_be      => S!>") { expect(subject[:short_be]).to      eq('s!>') }
+        it("int_be        => I!>") { expect(subject[:int_be]).to        eq('i!>') }
+        it("long_be       => L!>") { expect(subject[:long_be]).to       eq('l!>') }
+        it("long_long_be  => L!>") { expect(subject[:long_long_be]).to  eq('q>' ) }
       end
     end
   end
@@ -79,17 +81,17 @@ describe Binary::Template do
 
     context "when given :endian" do
       it "should translate endian-types" do
-        subject.translate(:uint, :endian => :little).should == :uint_le
+        expect(subject.translate(:uint, :endian => :little)).to eq(:uint_le)
       end
 
       it "should not translate non-endian-types" do
-        subject.translate(:string, :endian => :little).should == :string
+        expect(subject.translate(:string, :endian => :little)).to eq(:string)
       end
 
       it "should raise an ArgumentError for unknown endianness" do
-        lambda {
+        expect {
           subject.translate(:uint, :endian => :foo)
-        }.should raise_error(ArgumentError)
+        }.to raise_error(ArgumentError)
       end
     end
   end
@@ -101,17 +103,17 @@ describe Binary::Template do
     subject { described_class }
 
     it "should translate types to their pack codes" do
-      subject.compile([type]).should == code
+      expect(subject.compile([type])).to eq(code)
     end
 
     it "should support specifying the length of a field" do
-      subject.compile([[type, 10]]).should == "#{code}10"
+      expect(subject.compile([[type, 10]])).to eq("#{code}10")
     end
 
     it "should raise ArgumentError for unknown types" do
-      lambda {
+      expect {
         subject.compile([:foo])
-      }.should raise_error(ArgumentError)
+      }.to raise_error(ArgumentError)
     end
   end
 
@@ -119,16 +121,16 @@ describe Binary::Template do
     subject { described_class.new [:uint32, :string] }
 
     it "should store the types" do
-      subject.fields.should == [
+      expect(subject.fields).to eq([
         :uint32,
         :string
-      ]
+      ])
     end
 
     it "should raise ArgumentError for unknown types" do
-      lambda {
+      expect {
         described_class.new [:foo]
-      }.should raise_error(ArgumentError)
+      }.to raise_error(ArgumentError)
     end
   end
 
@@ -161,7 +163,7 @@ describe Binary::Template do
       subject { described_class.new [:byte] }
 
       it "should pack a signed byte" do
-        subject.pack(byte).should == char
+        expect(subject.pack(byte)).to eq(char)
       end
     end
 
@@ -170,7 +172,7 @@ describe Binary::Template do
       subject { described_class.new [[:byte, n]] }
 
       it "should pack multiple signed characters" do
-        subject.pack(*bytes).should == chars
+        expect(subject.pack(*bytes)).to eq(chars)
       end
     end
 
@@ -178,7 +180,7 @@ describe Binary::Template do
       subject { described_class.new [:char] }
 
       it "should pack a signed character" do
-        subject.pack(char).should == char
+        expect(subject.pack(char)).to eq(char)
       end
     end
 
@@ -187,7 +189,7 @@ describe Binary::Template do
       subject { described_class.new [[:char, n]] }
 
       it "should pack multiple signed characters" do
-        subject.pack(*chars).should == string
+        expect(subject.pack(*chars)).to eq(string)
       end
 
       context "padding" do
@@ -195,7 +197,7 @@ describe Binary::Template do
         subject { described_class.new [[:char, n + padding]] }
 
         it "should pad the string with '\\0' characters" do
-          subject.pack(*chars).should == (string + ("\0" * padding))
+          expect(subject.pack(*chars)).to eq((string + ("\0" * padding)))
         end
       end
     end
@@ -204,7 +206,7 @@ describe Binary::Template do
       subject { described_class.new [:uint8] }
 
       it "should pack an unsigned 8bit integer" do
-        subject.pack(uint8).should == "\xff"
+        expect(subject.pack(uint8)).to eq("\xff")
       end
     end
 
@@ -212,7 +214,7 @@ describe Binary::Template do
       subject { described_class.new [:uint16] }
 
       it "should pack an unsigned 16bit integer" do
-        subject.pack(uint16).should == "\xff\xff"
+        expect(subject.pack(uint16)).to eq("\xff\xff")
       end
     end
 
@@ -220,7 +222,7 @@ describe Binary::Template do
       subject { described_class.new [:uint32] }
 
       it "should pack an unsigned 32bit integer" do
-        subject.pack(uint32).should == "\xff\xff\xff\xff"
+        expect(subject.pack(uint32)).to eq("\xff\xff\xff\xff")
       end
     end
 
@@ -228,7 +230,7 @@ describe Binary::Template do
       subject { described_class.new [:uint64] }
 
       it "should pack an unsigned 64bit integer" do
-        subject.pack(uint64).should == "\xff\xff\xff\xff\xff\xff\xff\xff"
+        expect(subject.pack(uint64)).to eq("\xff\xff\xff\xff\xff\xff\xff\xff")
       end
     end
 
@@ -236,7 +238,7 @@ describe Binary::Template do
       subject { described_class.new [:int8] }
 
       it "should pack an signed 8bit integer" do
-        subject.pack(int8).should == "\xff"
+        expect(subject.pack(int8)).to eq("\xff")
       end
     end
 
@@ -244,7 +246,7 @@ describe Binary::Template do
       subject { described_class.new [:int16] }
 
       it "should pack an unsigned 16bit integer" do
-        subject.pack(int16).should == "\xff\xff"
+        expect(subject.pack(int16)).to eq("\xff\xff")
       end
     end
 
@@ -252,7 +254,7 @@ describe Binary::Template do
       subject { described_class.new [:int32] }
 
       it "should pack an unsigned 32bit integer" do
-        subject.pack(int32).should == "\xff\xff\xff\xff"
+        expect(subject.pack(int32)).to eq("\xff\xff\xff\xff")
       end
     end
 
@@ -260,7 +262,7 @@ describe Binary::Template do
       subject { described_class.new [:int64] }
 
       it "should pack an unsigned 64bit integer" do
-        subject.pack(int64).should == "\xff\xff\xff\xff\xff\xff\xff\xff"
+        expect(subject.pack(int64)).to eq("\xff\xff\xff\xff\xff\xff\xff\xff")
       end
     end
 
@@ -268,7 +270,7 @@ describe Binary::Template do
       subject { described_class.new [:string] }
 
       it "should pack a string" do
-        subject.pack(string).should == "#{string}\0"
+        expect(subject.pack(string)).to eq("#{string}\0")
       end
     end
   end
@@ -278,7 +280,7 @@ describe Binary::Template do
       subject { described_class.new [:byte] }
 
       it "should unpack a signed byte" do
-        subject.unpack(char).should == [byte]
+        expect(subject.unpack(char)).to eq([byte])
       end
     end
 
@@ -287,7 +289,7 @@ describe Binary::Template do
       subject { described_class.new [[:byte, n]] }
 
       it "should pack multiple signed characters" do
-        subject.unpack(chars).should == bytes
+        expect(subject.unpack(chars)).to eq(bytes)
       end
     end
 
@@ -295,7 +297,7 @@ describe Binary::Template do
       subject { described_class.new [:char] }
 
       it "should unpack a signed character" do
-        subject.unpack(char).should == [char]
+        expect(subject.unpack(char)).to eq([char])
       end
     end
 
@@ -304,7 +306,7 @@ describe Binary::Template do
       subject { described_class.new [[:char, n]] }
 
       it "should unpack multiple signed characters" do
-        subject.unpack(string).should == [chars]
+        expect(subject.unpack(string)).to eq([chars])
       end
 
       context "padding" do
@@ -312,7 +314,7 @@ describe Binary::Template do
         subject { described_class.new [[:char, n + padding]] }
 
         it "should strip '\\0' padding characters" do
-          subject.unpack(string + ("\0" * padding)).should == [chars]
+          expect(subject.unpack(string + ("\0" * padding))).to eq([chars])
         end
       end
     end
@@ -321,7 +323,7 @@ describe Binary::Template do
       subject { described_class.new [:uint8] }
 
       it "should unpack an unsigned 8bit integer" do
-        subject.unpack("\xff").should == [uint8]
+        expect(subject.unpack("\xff")).to eq([uint8])
       end
     end
 
@@ -329,7 +331,7 @@ describe Binary::Template do
       subject { described_class.new [:uint16] }
 
       it "should unpack an unsigned 16bit integer" do
-        subject.unpack("\xff\xff").should == [uint16]
+        expect(subject.unpack("\xff\xff")).to eq([uint16])
       end
     end
 
@@ -337,7 +339,7 @@ describe Binary::Template do
       subject { described_class.new [:uint32] }
 
       it "should unpack an unsigned 32bit integer" do
-        subject.unpack("\xff\xff\xff\xff").should == [uint32]
+        expect(subject.unpack("\xff\xff\xff\xff")).to eq([uint32])
       end
     end
 
@@ -345,7 +347,7 @@ describe Binary::Template do
       subject { described_class.new [:uint64] }
 
       it "should unpack an unsigned 64bit integer" do
-        subject.unpack("\xff\xff\xff\xff\xff\xff\xff\xff").should == [uint64]
+        expect(subject.unpack("\xff\xff\xff\xff\xff\xff\xff\xff")).to eq([uint64])
       end
     end
 
@@ -353,7 +355,7 @@ describe Binary::Template do
       subject { described_class.new [:int8] }
 
       it "should unpack an signed 8bit integer" do
-        subject.unpack("\xff").should == [int8]
+        expect(subject.unpack("\xff")).to eq([int8])
       end
     end
 
@@ -361,7 +363,7 @@ describe Binary::Template do
       subject { described_class.new [:int16] }
 
       it "should unpack an unsigned 16bit integer" do
-        subject.unpack("\xff\xff").should == [int16]
+        expect(subject.unpack("\xff\xff")).to eq([int16])
       end
     end
 
@@ -369,7 +371,7 @@ describe Binary::Template do
       subject { described_class.new [:int32] }
 
       it "should unpack an unsigned 32bit integer" do
-        subject.unpack("\xff\xff\xff\xff").should == [int32]
+        expect(subject.unpack("\xff\xff\xff\xff")).to eq([int32])
       end
     end
 
@@ -377,7 +379,7 @@ describe Binary::Template do
       subject { described_class.new [:int64] }
 
       it "should unpack an unsigned 64bit integer" do
-        subject.unpack("\xff\xff\xff\xff\xff\xff\xff\xff").should == [int64]
+        expect(subject.unpack("\xff\xff\xff\xff\xff\xff\xff\xff")).to eq([int64])
       end
     end
 
@@ -385,7 +387,7 @@ describe Binary::Template do
       subject { described_class.new [:string] }
 
       it "should unpack a string" do
-        subject.unpack("#{string}\0").should == [string]
+        expect(subject.unpack("#{string}\0")).to eq([string])
       end
     end
   end
@@ -394,7 +396,7 @@ describe Binary::Template do
     subject { described_class.new [:uint32, :string] }
 
     it "should return the pack format String" do
-      subject.to_s.should == "LZ*"
+      expect(subject.to_s).to eq("LZ*")
     end
   end
 
@@ -404,11 +406,11 @@ describe Binary::Template do
     subject { template.inspect }
 
     it "should inspect the class" do
-      subject.should include(described_class.name)
+      expect(subject).to include(described_class.name)
     end
 
     it "should inspect the template" do
-      subject.should include(template.fields.inspect)
+      expect(subject).to include(template.fields.inspect)
     end
   end
 end