ronin-support 0.5.1 → 0.5.2

data/spec/extensions/resolv_spec.rb

@@ -8,11 +8,11 @@ describe Resolv do
     subject { Resolv }
 
     it "should create a new Resolv::DNS object if a nameserver is given" do
-      subject.resolver(nameserver).should be_kind_of(Resolv::DNS)
+      expect(subject.resolver(nameserver)).to be_kind_of(Resolv::DNS)
     end
 
     it "should return the default resolver otherwise" do
-      subject.resolver.should == Resolv
+      expect(subject.resolver).to eq(Resolv)
     end
   end
 end

data/spec/extensions/string_spec.rb

@@ -7,32 +7,32 @@ describe String do
 
     it "should enumerate over each sub-string within the String" do
       subject.each_substring do |sub_string|
-        should include(sub_string)
+        expect(subject).to include(sub_string)
       end
     end
 
     it "should allow passing the string index back" do
       subject.each_substring do |sub_string,index|
-        subject[index,sub_string.length].should == sub_string
+        expect(subject[index,sub_string.length]).to eq(sub_string)
 
-        should include(sub_string)
+        expect(subject).to include(sub_string)
       end
     end
 
     it "should enumerate over each sub-string of a minimum length" do
       subject.each_substring(2) do |sub_string|
-        sub_string.length.should >= 2
+        expect(sub_string.length).to be >= 2
 
-        should include(sub_string)
+        expect(subject).to include(sub_string)
       end
     end
 
     it "should return an Enumerator when no block is given" do
       substrings = subject.each_substring
       
-      substrings.all? { |sub_string|
+      expect(substrings.all? { |sub_string|
         subject.include?(sub_string)
-      }.should == true
+      }).to be(true)
     end
   end
 
@@ -43,8 +43,8 @@ describe String do
       seen = []
 
       subject.each_unique_substring do |sub_string|
-        should include(sub_string)
-        seen.should_not include(sub_string)
+        expect(subject).to  include(sub_string)
+        expect(seen).to_not include(sub_string)
 
         seen << sub_string
       end
@@ -54,10 +54,10 @@ describe String do
       seen = []
 
       subject.each_unique_substring(2) do |sub_string|
-        sub_string.length.should >= 2
+        expect(sub_string.length).to be >= 2
 
-        should include(sub_string)
-        seen.should_not include(sub_string)
+        expect(subject).to  include(sub_string)
+        expect(seen).to_not include(sub_string)
 
         seen << sub_string
       end
@@ -66,12 +66,13 @@ describe String do
     it "should return an Enumerator when no block is given" do
       seen = subject.each_unique_substring
 
-      seen.all? { |sub_string|
+      expect(seen.all? { |sub_string|
         subject.include?(sub_string)
-      }.should == true
+      }).to be(true)
 
       seen = seen.to_a
-      seen.uniq.should == seen
+
+      expect(seen.uniq).to eq(seen)
     end
   end
 
@@ -81,7 +82,7 @@ describe String do
       two = 'What is puzzling you is the nature of my name'
       common = 'What is puzzling you is the nature of my '
 
-      one.common_prefix(two).should == common
+      expect(one.common_prefix(two)).to eq(common)
     end
 
     it "should return the common prefix between two Strings with no uncommon postfix" do
@@ -89,21 +90,21 @@ describe String do
       two = "12345"
       common = "1234"
 
-      one.common_prefix(two).should == common
+      expect(one.common_prefix(two)).to eq(common)
     end
 
     it "should return an empty String if there is no common prefix" do
       one = 'Tell me people'
       two = 'Whats my name'
 
-      one.common_prefix(two).should == ''
+      expect(one.common_prefix(two)).to eq('')
     end
 
     it "should return an empty String if one of the strings is also empty" do
       one = 'Haha'
       two = ''
 
-      one.common_prefix(two).should == ''
+      expect(one.common_prefix(two)).to eq('')
     end
   end
 
@@ -113,21 +114,21 @@ describe String do
       two = "Can't you guess my name"
       common = 's my name'
 
-      one.common_suffix(two).should == common
+      expect(one.common_suffix(two)).to eq(common)
     end
 
     it "should return an empty String if there is no common postfix" do
       one = 'You got to right up, stand up'
       two = 'stand up for your rights'
 
-      one.common_suffix(two).should == ''
+      expect(one.common_suffix(two)).to eq('')
     end
 
     it "should return an empty String if one of the strings is also empty" do
       one = 'You and I must fight for our rights'
       two = ''
 
-      one.common_suffix(two).should == ''
+      expect(one.common_suffix(two)).to eq('')
     end
   end
 
@@ -137,7 +138,7 @@ describe String do
       two = "Tell me honey whats my name"
       uncommon = 'bab'
 
-      one.uncommon_substring(two).should == uncommon
+      expect(one.uncommon_substring(two)).to eq(uncommon)
     end
 
     it "should find the uncommon substring between two Strings with a common prefix" do
@@ -145,7 +146,7 @@ describe String do
       two = 'You and I must fight to survive'
       uncommon = 'for our rights'
 
-      one.uncommon_substring(two).should == uncommon
+      expect(one.uncommon_substring(two)).to eq(uncommon)
     end
 
     it "should find the uncommon substring between two Strings with a common postfix" do
@@ -153,26 +154,26 @@ describe String do
       two = "Can't you guess my name"
       uncommon = 'Tell me baby what'
 
-      one.uncommon_substring(two).should == uncommon
+      expect(one.uncommon_substring(two)).to eq(uncommon)
     end
   end
 
   if RUBY_VERSION < '1.9.'
     describe "#dump" do
       it "should dump printable strings" do
-        "hello".dump.should == '"hello"'
+        expect("hello".dump).to eq('"hello"')
       end
 
       it "should dump strings containing control characters" do
-        "hello\n\b\a".dump.should == '"hello\n\b\a"'
+        expect("hello\n\b\a".dump).to eq('"hello\n\b\a"')
       end
 
       it "should dump strings containing non-printable characters" do
-        "hello\x90\x05\xEF".dump.should == '"hello\x90\x05\xEF"'
+        expect("hello\x90\x05\xEF".dump).to eq('"hello\x90\x05\xEF"')
       end
 
       it "should dump the string when calling the inspect method" do
-        "hello\x90\x05\xEF".inspect.should == '"hello\x90\x05\xEF"'
+        expect("hello\x90\x05\xEF".inspect).to eq('"hello\x90\x05\xEF"')
       end
     end
   end

data/spec/formatting/binary/array_spec.rb

@@ -13,13 +13,13 @@ describe Array do
 
     context "when only given a String" do
       it "should pack elements using Array#pack codes" do
-        subject.pack('vZ*').should == packed
+        expect(subject.pack('vZ*')).to eq(packed)
       end
     end
 
     context "otherwise" do
       it "should pack fields using Binary::Template" do
-        subject.pack(:uint16_le, :string).should == packed
+        expect(subject.pack(:uint16_le, :string)).to eq(packed)
       end
     end
   end

data/spec/formatting/binary/base64_spec.rb

@@ -13,37 +13,37 @@ describe Base64 do
 
     describe "strict_encode64" do
       it "should strictly encode a String" do
-        subject.strict_encode64(string).should == strict_base64
+        expect(subject.strict_encode64(string)).to eq(strict_base64)
       end
     end
 
     describe "strict_decode64" do
       it "should strict decode an encoded Base64 String" do
-        subject.strict_decode64(strict_base64).should == string
+        expect(subject.strict_decode64(strict_base64)).to eq(string)
       end
 
       it "should raise an ArgumentError for non-strictly encoded Base64" do
-        lambda {
+        expect {
           subject.strict_decode64(base64)
-        }.should raise_error(ArgumentError)
+        }.to raise_error(ArgumentError)
       end
     end
 
     describe "urlsafe_encode64" do
       it "should encode URL-safe Base64 Strings" do
-        subject.urlsafe_encode64(string).should == urlsafe_base64
+        expect(subject.urlsafe_encode64(string)).to eq(urlsafe_base64)
       end
     end
 
     describe "urlsafe_decode64" do
       it "should decode URL-safe Base64 String" do
-        subject.urlsafe_decode64(urlsafe_base64).should == string
+        expect(subject.urlsafe_decode64(urlsafe_base64)).to eq(string)
       end
 
       it "should raise an ArgumentError for non-strictly encoded Base64" do
-        lambda {
+        expect {
           subject.urlsafe_decode64(base64)
-        }.should raise_error(ArgumentError)
+        }.to raise_error(ArgumentError)
       end
     end
   end

data/spec/formatting/binary/float_spec.rb

@@ -1,3 +1,5 @@
+# encoding: US-ASCII
+
 require 'spec_helper'
 require 'ronin/formatting/extensions/binary/float'
 
@@ -13,21 +15,21 @@ describe Float do
 
     context "when only given a String" do
       it "should unpack Strings using String#unpack template Strings" do
-        subject.pack('E').should == packed
+        expect(subject.pack('E')).to eq(packed)
       end
     end
 
     context "when given a Binary::Template Float type" do
       it "should unpack Strings using Binary::Template" do
-        subject.pack(:double_le).should == packed
+        expect(subject.pack(:double_le)).to eq(packed)
       end
     end
 
     context "when given non-Float Binary::Template types" do
       it "should raise an ArgumentError" do
-        lambda {
+        expect {
           subject.pack(:int)
-        }.should raise_error(ArgumentError)
+        }.to raise_error(ArgumentError)
       end
     end
   end

data/spec/formatting/binary/integer_spec.rb

@@ -19,14 +19,14 @@ describe Integer do
   end
 
   it "should alias char to the #chr method" do
-    subject.char.should == subject.chr
+    expect(subject.char).to eq(subject.chr)
   end
 
   describe "#hex_escape" do
     subject { 42 }
 
     it "should hex escape an Integer" do
-      subject.hex_escape.should == "\\x2a"
+      expect(subject.hex_escape).to eq("\\x2a")
     end
   end
 
@@ -44,39 +44,39 @@ describe Integer do
     subject { 0x1337 }
 
     it "should return the bytes in little endian ordering by default" do
-      subject.bytes(4).should == little_endian_long
+      expect(subject.bytes(4)).to eq(little_endian_long)
     end
 
     it "should return the bytes for a char in little endian ordering" do
-      subject.bytes(1, :little).should == little_endian_char
+      expect(subject.bytes(1, :little)).to eq(little_endian_char)
     end
 
     it "should return the bytes for a short in little endian ordering" do
-      subject.bytes(2, :little).should == little_endian_short
+      expect(subject.bytes(2, :little)).to eq(little_endian_short)
     end
 
     it "should return the bytes for a long in little endian ordering" do
-      subject.bytes(4, :little).should == little_endian_long
+      expect(subject.bytes(4, :little)).to eq(little_endian_long)
     end
 
     it "should return the bytes for a quad in little endian ordering" do
-      subject.bytes(8, :little).should == little_endian_quad
+      expect(subject.bytes(8, :little)).to eq(little_endian_quad)
     end
 
     it "should return the bytes for a char in big endian ordering" do
-      subject.bytes(1, :big).should == big_endian_char
+      expect(subject.bytes(1, :big)).to eq(big_endian_char)
     end
 
     it "should return the bytes for a short in big endian ordering" do
-      subject.bytes(2, :big).should == big_endian_short
+      expect(subject.bytes(2, :big)).to eq(big_endian_short)
     end
 
     it "should return the bytes for a long in big endian ordering" do
-      subject.bytes(4, :big).should == big_endian_long
+      expect(subject.bytes(4, :big)).to eq(big_endian_long)
     end
 
     it "should return the bytes for a quad in big endian ordering" do
-      subject.bytes(8, :big).should == big_endian_quad
+      expect(subject.bytes(8, :big)).to eq(big_endian_quad)
     end
   end
 
@@ -87,21 +87,21 @@ describe Integer do
 
     context "when only given a String" do
       it "should pack Integers using Array#pack codes" do
-        subject.pack('V').should == packed
+        expect(subject.pack('V')).to eq(packed)
       end
     end
 
     context "when given a Binary::Template Integer type" do
       it "should pack Integers using Binary::Template" do
-        subject.pack(:uint32_le).should == packed
+        expect(subject.pack(:uint32_le)).to eq(packed)
       end
     end
 
     context "when given non-Integer Binary::Template types" do
       it "should raise an ArgumentError" do
-        lambda {
+        expect {
           subject.pack(:float)
-        }.should raise_error(ArgumentError)
+        }.to raise_error(ArgumentError)
       end
     end
 
@@ -123,43 +123,43 @@ describe Integer do
       end
 
       it "should pack itself for a little-endian architecture by default" do
-        subject.pack(i386).should == uint32_le
+        expect(subject.pack(i386)).to eq(uint32_le)
       end
 
       it "should pack itself as a short for a little-endian architecture" do
-        subject.pack(i386,2).should == uint16_le
+        expect(subject.pack(i386,2)).to eq(uint16_le)
       end
 
       it "should pack itself as a long for a little-endian architecture" do
-        subject.pack(i386,4).should == uint32_le
+        expect(subject.pack(i386,4)).to eq(uint32_le)
       end
 
       it "should pack itself as a quad for a little-endian architecture" do
-        subject.pack(i386,8).should == uint64_le
+        expect(subject.pack(i386,8)).to eq(uint64_le)
       end
 
       it "should pack itself for a big-endian architecture" do
-        subject.pack(ppc).should == uint32_be
+        expect(subject.pack(ppc)).to eq(uint32_be)
       end
 
       it "should pack itself as a short for a big-endian architecture" do
-        subject.pack(ppc,2).should == uint16_be
+        expect(subject.pack(ppc,2)).to eq(uint16_be)
       end
 
       it "should pack itself as a long for a big-endian architecture" do
-        subject.pack(ppc,4).should == uint32_be
+        expect(subject.pack(ppc,4)).to eq(uint32_be)
       end
 
       it "should pack itself as a quad for a big-endian architecture" do
-        subject.pack(ppc,8).should == uint64_be
+        expect(subject.pack(ppc,8)).to eq(uint64_be)
       end
     end
 
     context "when given more than 1 or 2 arguments" do
       it "should raise an ArgumentError" do
-        lambda {
+        expect {
           subject.pack(1,2,3)
-        }.should raise_error(ArgumentError)
+        }.to raise_error(ArgumentError)
       end
     end
   end

data/spec/formatting/binary/string_spec.rb

@@ -1,3 +1,5 @@
+# encoding: US-ASCII
+
 require 'spec_helper'
 require 'ronin/formatting/extensions/binary/string'
 
@@ -7,35 +9,35 @@ describe String do
   subject { "hello" }
 
   it "should provide String#unpack_original" do
-    should respond_to(:unpack_original)
+    expect(subject).to respond_to(:unpack_original)
   end
 
   it "should provide String#unpack" do
-    should respond_to(:unpack)
+    expect(subject).to respond_to(:unpack)
   end
 
   it "should provide String#depack" do
-    should respond_to(:depack)
+    expect(subject).to respond_to(:depack)
   end
 
   it "should provide String#zlib_inflate" do
-    should respond_to(:zlib_inflate)
+    expect(subject).to respond_to(:zlib_inflate)
   end
 
   it "should provide String#zlib_deflate" do
-    should respond_to(:zlib_deflate)
+    expect(subject).to respond_to(:zlib_deflate)
   end
 
   it "should provide String#hex_unescape" do
-    should respond_to(:hex_unescape)
+    expect(subject).to respond_to(:hex_unescape)
   end
 
   it "should provide String#xor" do
-    should respond_to(:xor)
+    expect(subject).to respond_to(:xor)
   end
 
   it "should provide String#unhexdump" do
-    should respond_to(:unhexdump)
+    expect(subject).to respond_to(:unhexdump)
   end
 
   describe "#unpack" do
@@ -45,13 +47,13 @@ describe String do
 
     context "when given only a String" do
       it "should unpack Strings using String#unpack template Strings" do
-        subject.unpack('VZ*').should == data
+        expect(subject.unpack('VZ*')).to eq(data)
       end
     end
 
     context "otherwise" do
       it "should unpack Strings using Binary::Template" do
-        subject.unpack(:uint32_le, :string).should == data
+        expect(subject.unpack(:uint32_le, :string)).to eq(data)
       end
     end
   end
@@ -79,39 +81,39 @@ describe String do
       let(:ppc_packed_quad)  { "\000\000\000\000\000\000\0237" }
 
       it "should depack itself for a little-endian architecture" do
-        i386_packed_int.depack(i386).should == subject
+        expect(i386_packed_int.depack(i386)).to eq(subject)
       end
 
       it "should depack itself as a short for a little-endian architecture" do
-        i386_packed_short.depack(i386,2).should == subject
+        expect(i386_packed_short.depack(i386,2)).to eq(subject)
       end
 
       it "should depack itself as a long for a little-endian architecture" do
-        i386_packed_long.depack(i386,4).should == subject
+        expect(i386_packed_long.depack(i386,4)).to eq(subject)
       end
 
       it "should depack itself as a quad for a little-endian architecture" do
-        i386_packed_quad.depack(i386,8).should == subject
+        expect(i386_packed_quad.depack(i386,8)).to eq(subject)
       end
 
       it "should depack itself for a big-endian architecture" do
-        ppc_packed_int.depack(ppc).should == subject
+        expect(ppc_packed_int.depack(ppc)).to eq(subject)
       end
 
       it "should depack itself as a short for a big-endian architecture" do
-        ppc_packed_short.depack(ppc,2).should == subject
+        expect(ppc_packed_short.depack(ppc,2)).to eq(subject)
       end
 
       it "should depack itself as a long for a big-endian architecture" do
-        ppc_packed_long.depack(ppc,4).should == subject
+        expect(ppc_packed_long.depack(ppc,4)).to eq(subject)
       end
 
       it "should depack itself as a quad for a big-endian architecture" do
-        ppc_packed_quad.depack(ppc,8).should == subject
+        expect(ppc_packed_quad.depack(ppc,8)).to eq(subject)
       end
 
       it "should accept String#unpack template strings" do
-        i386_packed_long.depack('V').should == [subject]
+        expect(i386_packed_long.depack('V')).to eq([subject])
       end
     end
   end
@@ -120,7 +122,7 @@ describe String do
     subject { "hello\0" }
 
     it "should base64 encode a String" do
-      subject.base64_encode.should == "aGVsbG8A\n"
+      expect(subject.base64_encode).to eq("aGVsbG8A\n")
     end
   end
 
@@ -128,7 +130,7 @@ describe String do
     subject { "aGVsbG8A\n" }
 
     it "should base64 decode a String" do
-      subject.base64_decode.should == "hello\0"
+      expect(subject.base64_decode).to eq("hello\0")
     end
   end
 
@@ -138,7 +140,7 @@ describe String do
     end
 
     it "should inflate a zlib deflated String" do
-      subject.zlib_inflate.should == "0f8f5ec6-14dc-46e7-a63a-f89b7d11265b\0"
+      expect(subject.zlib_inflate).to eq("0f8f5ec6-14dc-46e7-a63a-f89b7d11265b\0")
     end
   end
 
@@ -146,7 +148,7 @@ describe String do
     subject { "hello" }
 
     it "should zlib deflate a String" do
-      subject.zlib_deflate.should == "x\x9c\xcbH\xcd\xc9\xc9\a\0\x06,\x02\x15"
+      expect(subject.zlib_deflate).to eq("x\x9c\xcbH\xcd\xc9\xc9\a\0\x06,\x02\x15")
     end
   end
 
@@ -154,7 +156,7 @@ describe String do
     subject { "hello\x4e" }
 
     it "should hex escape a String" do
-      subject.hex_escape.should == "\\x68\\x65\\x6c\\x6c\\x6f\\x4e"
+      expect(subject.hex_escape).to eq("\\x68\\x65\\x6c\\x6c\\x6f\\x4e")
     end
   end
 
@@ -165,23 +167,23 @@ describe String do
     let(:keys) { [0x50, 0x55] }
 
     it "should not contain the key used in the xor" do
-      should_not include(key.chr)
+      expect(subject).to_not include(key.chr)
     end
 
     it "should not equal the original string" do
-      subject.xor(key).should_not == subject
+      expect(subject.xor(key)).to_not be == subject
     end
 
     it "should be able to be decoded with another xor" do
-      subject.xor(key).xor(key).should == subject
+      expect(subject.xor(key).xor(key)).to eq(subject)
     end
 
     it "should allow xoring against a single key" do
-      subject.xor(key).should == "85<<?"
+      expect(subject.xor(key)).to eq("85<<?")
     end
 
     it "should allow xoring against multiple keys" do
-      subject.xor(keys).should == "80<9?"
+      expect(subject.xor(keys)).to eq("80<9?")
     end
   end
 
@@ -191,7 +193,7 @@ describe String do
     let(:raw) { "# Ronin Support\n" }
 
     it "should unhexdump a String" do
-      subject.unhexdump.should == raw
+      expect(subject.unhexdump).to eq(raw)
     end
   end
 end