ronin-support 0.5.1 → 0.5.2

data/spec/extensions/enumerable_spec.rb

@@ -4,21 +4,21 @@ require 'ronin/extensions/enumerable'
 describe Enumerable do
   describe "#map_hash" do
     it "should map elements to a Hash" do
-      [1, 2, 3].map_hash { |i| i ** 2 }.should == {
+      expect([1, 2, 3].map_hash { |i| i ** 2 }).to eq({
         1 => 1,
         2 => 4,
         3 => 9
-      }
+      })
     end
 
     it "should not map the same element twice" do
-      [1, 2, 2].map_hash { |i| rand }.keys.should =~ [1, 2]
+      expect([1, 2, 2].map_hash { |i| rand }.keys).to match_array([1, 2])
     end
 
     it "should set the default_proc of the Hash" do
       hash = [].map_hash { |i| i ** 2 }
 
-      hash[3].should == 9
+      expect(hash[3]).to eq(9)
     end
   end
 end

data/spec/extensions/file_spec.rb

@@ -7,20 +7,19 @@ describe File do
   subject { File }
 
   it "should provide File.escape_path" do
-    subject.should respond_to(:escape_path)
+    expect(subject).to respond_to(:escape_path)
   end
 
   describe "each_line" do
     let(:lines) { %w[one two three] }
+    let(:path)  { Tempfile.new('ronin-support-File#each_line') }
 
-    before(:all) do
-      @file = Tempfile.new('ronin-support')
-      @file.puts(*lines)
-      @file.close
+    before do
+      File.open(path,'w') { |file| file.puts(*lines) }
     end
 
     it "should enumerate over each line in the file" do
-      File.each_line(@file.path).to_a.should == lines
+      expect(File.each_line(path).to_a).to eq(lines)
     end
   end
 
@@ -35,29 +34,28 @@ describe File do
     let(:separator) { '|' }
     let(:newline)   { "\r\n" }
     let(:lines)     { rows.map { |row| row.join(separator) }.join(newline) }
+    let(:path)      { Tempfile.new('ronin-support-File#each_row') }
 
-    before(:all) do
-      @file = Tempfile.new('ronin-support')
-      @file.write(lines)
-      @file.close
+    before do
+      File.open(path,'w') { |file| file.puts(*lines) }
     end
 
     it "should enumerate over each row from each line" do
-      File.each_row(@file.path,separator).to_a.should == rows
+      expect(File.each_row(path,separator).to_a).to eq(rows)
     end
   end
 
   describe "escape_path" do
     it "should remove null-bytes" do
-      File.escape_path("hello\0world\0").should == "helloworld"
+      expect(File.escape_path("hello\0world\0")).to eq("helloworld")
     end
 
     it "should escape home-dir expansions" do
-      File.escape_path("hello/~world").should == "hello/\\~world"
+      expect(File.escape_path("hello/~world")).to eq("hello/\\~world")
     end
 
     it "should remove '.' and '..' directories" do
-      File.escape_path("hello/./../world").should == "world"
+      expect(File.escape_path("hello/./../world")).to eq("world")
     end
   end
 end

data/spec/extensions/ip_addr_spec.rb

@@ -7,47 +7,47 @@ describe IPAddr do
       it "should extract a single IPv4 address" do
         addr = '127.0.0.1'
 
-        IPAddr.extract(addr,:ipv4).should == [addr]
+        expect(IPAddr.extract(addr,:ipv4)).to eq([addr])
       end
 
       it "should extract multiple IPv4 addresses" do
         addrs = %w[127.0.0.1 192.168.0.1]
         text = "#{addrs[0]} #{addrs[1]}"
 
-        IPAddr.extract(text,:ipv4).should == addrs
+        expect(IPAddr.extract(text,:ipv4)).to eq(addrs)
       end
 
       it "should extract IPv4 addresses from text" do
         addr = '127.0.0.1'
         text = "ip (#{addr})"
 
-        IPAddr.extract(text,:ipv4).should == [addr]
+        expect(IPAddr.extract(text,:ipv4)).to eq([addr])
       end
 
       it "should ignore leading periods" do
         addr = '127.0.0.1'
         text = ".#{addr}"
 
-        IPAddr.extract(text,:ipv4).should == [addr]
+        expect(IPAddr.extract(text,:ipv4)).to eq([addr])
       end
 
       it "should ignore tailing periods" do
         addr = '127.0.0.1'
         text = "#{addr}."
 
-        IPAddr.extract(text,:ipv4).should == [addr]
+        expect(IPAddr.extract(text,:ipv4)).to eq([addr])
       end
 
       it "should ignore less than 3 octet IPv4 addresses" do
         text = '127.0.0. 1'
 
-        IPAddr.extract(text,:ipv4).should be_empty
+        expect(IPAddr.extract(text,:ipv4)).to be_empty
       end
 
       it "should ignore IPv4 addresses with more than 3 diget octets" do
         text = '127.1111.0.1'
 
-        IPAddr.extract(text,:ipv4).should be_empty
+        expect(IPAddr.extract(text,:ipv4)).to be_empty
       end
     end
 
@@ -55,42 +55,42 @@ describe IPAddr do
       it "should extract a single IPv6 address" do
         addr = 'fe80:0000:0000:0000:0204:61ff:fe9d:f156'
 
-        IPAddr.extract(addr,:ipv6).should == [addr]
+        expect(IPAddr.extract(addr,:ipv6)).to eq([addr])
       end
 
       it "should extract multiple IPv6 addresses" do
         addrs = %w[::1 fe80:0000:0000:0000:0204:61ff:fe9d:f156]
         text = "#{addrs[0]} #{addrs[1]}"
 
-        IPAddr.extract(text,:ipv6).should == addrs
+        expect(IPAddr.extract(text,:ipv6)).to eq(addrs)
       end
 
       it "should extract collapsed IPv6 addresses" do
         addr = 'fe80::0204:61ff:fe9d:f156'
         text = "ipv6: #{addr}"
 
-        IPAddr.extract(text,:ipv6).should == [addr]
+        expect(IPAddr.extract(text,:ipv6)).to eq([addr])
       end
 
       it "should extract IPv6 addresses from text" do
         addr = 'fe80:0000:0000:0000:0204:61ff:fe9d:f156'
         text = "hello #{addr} world"
 
-        IPAddr.extract(text,:ipv6).should == [addr]
+        expect(IPAddr.extract(text,:ipv6)).to eq([addr])
       end
 
       it "should extract trailing IPv4 suffixes" do
         addr = '::ffff:192.0.2.128'
         text = "#{addr} 1.1.1.1"
 
-        IPAddr.extract(text,:ipv6).should == [addr]
+        expect(IPAddr.extract(text,:ipv6)).to eq([addr])
       end
 
       it "should extract short-hand IPv6 addresses" do
         addr = '::f0:0d'
         text = "ipv6: #{addr}"
 
-        IPAddr.extract(text,:ipv6).should == [addr]
+        expect(IPAddr.extract(text,:ipv6)).to eq([addr])
       end
     end
 
@@ -99,13 +99,13 @@ describe IPAddr do
       ipv6 = '::1'
       text = "ipv4: #{ipv4}, ipv6: #{ipv6}"
 
-      IPAddr.extract(text).should == [ipv4, ipv6]
+      expect(IPAddr.extract(text)).to eq([ipv4, ipv6])
     end
 
     it "should ignore non-IP addresses" do
       text = 'one: two.three.'
 
-      IPAddr.extract(text).should be_empty
+      expect(IPAddr.extract(text)).to be_empty
     end
   end
 
@@ -117,20 +117,20 @@ describe IPAddr do
       it "should only iterate over one IP address for an address" do
         addresses = fixed_addr.map { |ip| IPAddr.new(ip) }
 
-        addresses.length.should == 1
-        fixed_addr.should include(addresses.first)
+        expect(addresses.length).to eq(1)
+        expect(fixed_addr).to include(addresses.first)
       end
 
       it "should iterate over all IP addresses contained within the IP range" do
         class_c.each do |ip|
-          class_c.should include(IPAddr.new(ip))
+          expect(class_c).to include(IPAddr.new(ip))
         end
       end
 
       it "should return an Enumerator when no block is given" do
-        class_c.each.all? { |ip|
+        expect(class_c.each.all? { |ip|
           class_c.include?(IPAddr.new(ip))
-        }.should == true
+        }).to be(true)
       end
     end
 
@@ -141,43 +141,43 @@ describe IPAddr do
       it "should expand '*' ranges" do
         octets = IPAddr.each("10.1.1.*").map { |ip| ip.split('.',4).last }
 
-        octets.should == ('1'..'254').to_a
+        expect(octets).to eq(('1'..'254').to_a)
       end
 
       it "should expend 'i-j' ranges" do
         octets = IPAddr.each("10.1.1.10-20").map { |ip| ip.split('.',4).last }
 
-        octets.should == ('10'..'20').to_a
+        expect(octets).to eq(('10'..'20').to_a)
       end
 
       it "should expand 'i,j,k' ranges" do
         octets = IPAddr.each("10.1.1.1,2,3").map { |ip| ip.split('.',4).last }
 
-        octets.should == ['1', '2', '3']
+        expect(octets).to eq(['1', '2', '3'])
       end
 
       it "should expand combination 'i,j-k' ranges" do
         octets = IPAddr.each("10.1.1.1,3-4").map { |ip| ip.split('.',4).last }
 
-        octets.should == ['1', '3', '4']
+        expect(octets).to eq(['1', '3', '4'])
       end
 
       it "should iterate over all IP addresses in an IPv4 range" do
         IPAddr.each(ipv4_range) do |ip|
-          ip.should =~ /^10\.1\.[1-5]\.1$/
+          expect(ip).to match(/^10\.1\.[1-5]\.1$/)
         end
       end
 
       it "should iterate over all IP addresses in an IPv6 range" do
         IPAddr.each(ipv6_range) do |ip|
-          ip.should =~ /^::ff::0[2-9a]::c3$/
+          expect(ip).to match(/^::ff::0[2-9a]::c3$/)
         end
       end
 
       it "should return an Enumerator when no block is given" do
         ips = IPAddr.each(ipv4_range)
 
-        ips.all? { |ip| ip =~ /^10\.1\.[1-5]\.1$/ }.should == true
+        expect(ips.all? { |ip| ip =~ /^10\.1\.[1-5]\.1$/ }).to be(true)
       end
     end
   end
@@ -189,15 +189,15 @@ describe IPAddr do
     let(:nameserver) { '4.2.2.1' }
 
     it "should lookup the host-name for an IP" do
-      ip.lookup.should include('localhost')
+      expect(ip.lookup).to include('localhost')
     end
 
     it "may lookup host-names via other nameservers" do
-      ip.lookup(nameserver).should be_empty
+      expect(ip.lookup(nameserver)).to be_empty
     end
 
     it "should return an empty Array for unknown IP addresses" do
-      bad_ip.lookup.should be_empty
+      expect(bad_ip.lookup).to be_empty
     end
   end
 end

data/spec/extensions/kernel_spec.rb

@@ -3,28 +3,28 @@ require 'ronin/extensions/kernel'
 
 describe Kernel do
   it "should provide Kernel#try" do
-    Kernel.should respond_to('try')
+    expect(Kernel).to respond_to('try')
   end
 
   describe "#try" do
     it "should return the result of the block if nothing is raised" do
-      try { 2 + 2 }.should == 4
+      expect(try { 2 + 2 }).to eq(4)
     end
 
     it "should return nil if an exception is raised" do
-      try { 2 + 'a' }.should be_nil
+      expect(try { 2 + 'a' }).to be_nil
     end
 
     it "should rescue RuntimeError exceptions" do
-      lambda {
+      expect {
         try { raise(RuntimeError,"something happened",caller) }
-      }.should_not raise_error(RuntimeError)
+      }.not_to raise_error
     end
 
     it "should rescue StandardError exceptions" do
-      lambda {
+      expect {
         try { raise(StandardError,"not allowed to do that",caller) }
-      }.should_not raise_error(StandardError)
+      }.not_to raise_error
     end
   end
 end

data/spec/extensions/regexp_spec.rb

@@ -8,29 +8,29 @@ describe Regexp do
     subject { Regexp::WORD }
 
     it "should not match single letters" do
-      subject.match('A').should be_nil
+      expect(subject.match('A')).to be_nil
     end
 
     it "should not match numeric letters" do
-      subject.match("123#{word}123")[0].should == word
+      expect(subject.match("123#{word}123")[0]).to eq(word)
     end
 
     it "should not include ending periods" do
-      subject.match("#{word}.")[0].should == word
+      expect(subject.match("#{word}.")[0]).to eq(word)
     end
 
     it "should not include leading punctuation" do
-      subject.match("'#{word}")[0].should == word
+      expect(subject.match("'#{word}")[0]).to eq(word)
     end
 
     it "should not include tailing punctuation" do
-      subject.match("#{word}'")[0].should == word
+      expect(subject.match("#{word}'")[0]).to eq(word)
     end
 
     it "should include punctuation in the middle of the word" do
       name = "O'Brian"
 
-      subject.match(name)[0].should == name
+      expect(subject.match(name)[0]).to eq(name)
     end
   end
 
@@ -38,13 +38,13 @@ describe Regexp do
     subject { Regexp::OCTET }
 
     it "should match 0 - 255" do
-      (0..255).all? { |n|
+      expect((0..255).all? { |n|
         subject.match(n.to_s)[0] == n.to_s
-      }.should be_true
+      }).to be(true)
     end
 
     it "should not match numbers greater than 255" do
-      subject.match('256')[0].should == '25'
+      expect(subject.match('256')[0]).to eq('25')
     end
   end
 
@@ -54,7 +54,7 @@ describe Regexp do
     it "should match six hexadecimal bytes" do
       mac = '12:34:56:78:9a:bc'
 
-      subject.match(mac)[0].should == mac
+      expect(subject.match(mac)[0]).to eq(mac)
     end
   end
 
@@ -64,37 +64,37 @@ describe Regexp do
     it "should match valid addresses" do
       ip = '127.0.0.1'
 
-      subject.match(ip)[0].should == ip
+      expect(subject.match(ip)[0]).to eq(ip)
     end
 
     it "should match the Any address" do
       ip = '0.0.0.0'
 
-      subject.match(ip)[0].should == ip
+      expect(subject.match(ip)[0]).to eq(ip)
     end
 
     it "should match the broadcast address" do
       ip = '255.255.255.255'
 
-      subject.match(ip)[0].should == ip
+      expect(subject.match(ip)[0]).to eq(ip)
     end
 
     it "should match addresses with netmasks" do
       ip = '10.1.1.1/24'
 
-      subject.match(ip)[0].should == ip
+      expect(subject.match(ip)[0]).to eq(ip)
     end
 
     it "should not match addresses with octets > 255" do
       ip = '10.1.256.1'
 
-      subject.match(ip).should be_nil
+      expect(subject.match(ip)).to be_nil
     end
 
     it "should not match addresses with more than three digits per octet" do
       ip = '10.1111.1.1'
 
-      subject.match(ip).should be_nil
+      expect(subject.match(ip)).to be_nil
     end
   end
 
@@ -104,25 +104,25 @@ describe Regexp do
     it "should match valid IPv6 addresses" do
       ip = '2001:db8:85a3:0:0:8a2e:370:7334'
 
-      subject.match(ip)[0].should == ip
+      expect(subject.match(ip)[0]).to eq(ip)
     end
 
     it "should match IPv6 addresses with netmasks" do
       ip = '2001:db8:1234::/48'
 
-      subject.match(ip)[0].should == ip
+      expect(subject.match(ip)[0]).to eq(ip)
     end
 
     it "should match truncated IPv6 addresses" do
       ip = '2001:db8:85a3::8a2e:370:7334'
 
-      subject.match(ip)[0].should == ip
+      expect(subject.match(ip)[0]).to eq(ip)
     end
 
     it "should match IPv4-mapped IPv6 addresses" do
       ip = '::ffff:192.0.2.128'
 
-      subject.match(ip)[0].should == ip
+      expect(subject.match(ip)[0]).to eq(ip)
     end
   end
 
@@ -132,13 +132,13 @@ describe Regexp do
     it "should match IPv4 addresses" do
       ip = '10.1.1.1'
 
-      subject.match(ip)[0].should == ip
+      expect(subject.match(ip)[0]).to eq(ip)
     end
 
     it "should match IPv6 addresses" do
       ip = '2001:db8:85a3:0:0:8a2e:370:7334'
 
-      subject.match(ip)[0].should == ip
+      expect(subject.match(ip)[0]).to eq(ip)
     end
   end
 
@@ -148,15 +148,15 @@ describe Regexp do
     it "should match valid hostnames" do
       hostname = 'www.google.com'
 
-      subject.match(hostname)[0].should == hostname
+      expect(subject.match(hostname)[0]).to eq(hostname)
     end
 
     it "should not match hostnames without a TLD" do
-      subject.match('foo').should be_nil
+      expect(subject.match('foo')).to be_nil
     end
 
     it "should not match hostnames with unknown TLDs" do
-      subject.match('foo.zzz').should be_nil
+      expect(subject.match('foo.zzz')).to be_nil
     end
   end
 
@@ -166,31 +166,31 @@ describe Regexp do
     it "should match valid user-names" do
       username = 'alice1234'
 
-      subject.match(username)[0].should == username
+      expect(subject.match(username)[0]).to eq(username)
     end
 
     it "should match user-names containing '_' characters" do
       username = 'alice_1234'
 
-      subject.match(username)[0].should == username
+      expect(subject.match(username)[0]).to eq(username)
     end
 
     it "should match user-names containing '.' characters" do
       username = 'alice.1234'
 
-      subject.match(username)[0].should == username
+      expect(subject.match(username)[0]).to eq(username)
     end
 
     it "should not match user-names beginning with numbers" do
-      subject.match('1234bob')[0].should == 'bob'
+      expect(subject.match('1234bob')[0]).to eq('bob')
     end
 
     it "should not match user-names containing spaces" do
-      subject.match('alice eve')[0].should == 'alice'
+      expect(subject.match('alice eve')[0]).to eq('alice')
     end
 
     it "should not match user-names containing other symbols" do
-      subject.match('alice^eve')[0].should == 'alice'
+      expect(subject.match('alice^eve')[0]).to eq('alice')
     end
   end
 
@@ -200,7 +200,7 @@ describe Regexp do
     it "should match valid email addresses" do
       email = 'alice@example.com'
 
-      subject.match(email)[0].should == email
+      expect(subject.match(email)[0]).to eq(email)
     end
   end
 
@@ -210,25 +210,25 @@ describe Regexp do
     it "should match 111-2222" do
       number = '111-2222'
 
-      subject.match(number)[0].should == number
+      expect(subject.match(number)[0]).to eq(number)
     end
 
     it "should match 111-2222x9" do
       number = '111-2222x9'
 
-      subject.match(number)[0].should == number
+      expect(subject.match(number)[0]).to eq(number)
     end
 
     it "should match 800-111-2222" do
       number = '800-111-2222'
 
-      subject.match(number)[0].should == number
+      expect(subject.match(number)[0]).to eq(number)
     end
 
     it "should match 1-800-111-2222" do
       number = '1-800-111-2222'
 
-      subject.match(number)[0].should == number
+      expect(subject.match(number)[0]).to eq(number)
     end
   end
 
@@ -238,23 +238,23 @@ describe Regexp do
     it "should match Strings beginning with a '_' character" do
       identifier = '_foo'
 
-      subject.match(identifier)[0].should == identifier
+      expect(subject.match(identifier)[0]).to eq(identifier)
     end
 
     it "should match Strings ending with a '_' character" do
       identifier = 'foo_'
 
-      subject.match(identifier)[0].should == identifier
+      expect(subject.match(identifier)[0]).to eq(identifier)
     end
 
     it "should not match Strings beginning with numberic characters" do
-      subject.match('1234foo')[0].should == 'foo'
+      expect(subject.match('1234foo')[0]).to eq('foo')
     end
 
     it "should not match Strings not containing any alpha characters" do
       identifier = '_1234_'
 
-      subject.match(identifier).should be_nil
+      expect(subject.match(identifier)).to be_nil
     end
   end
 
@@ -264,15 +264,15 @@ describe Regexp do
     it "should match the '.' separator character" do
       ext = '.txt'
 
-      subject.match(ext)[0].should == ext
+      expect(subject.match(ext)[0]).to eq(ext)
     end
 
     it "should not allow '_' characters" do
-      subject.match('.foo_bar')[0].should == '.foo'
+      expect(subject.match('.foo_bar')[0]).to eq('.foo')
     end
 
     it "should not allow '-' characters" do
-      subject.match('.foo-bar')[0].should == '.foo'
+      expect(subject.match('.foo-bar')[0]).to eq('.foo')
     end
   end
 
@@ -282,13 +282,13 @@ describe Regexp do
     it "should match file names" do
       filename = 'foo_bar'
 
-      subject.match(filename)[0].should == filename
+      expect(subject.match(filename)[0]).to eq(filename)
     end
 
     it "should match '\\' escapped characters" do
       filename = 'foo\\ bar'
 
-      subject.match(filename)[0].should == filename
+      expect(subject.match(filename)[0]).to eq(filename)
     end
   end
 
@@ -298,7 +298,7 @@ describe Regexp do
     it "should match the filename and extension" do
       filename = 'foo_bar.txt'
 
-      subject.match(filename)[0].should == filename
+      expect(subject.match(filename)[0]).to eq(filename)
     end
   end
 
@@ -308,19 +308,19 @@ describe Regexp do
     it "should match directory names" do
       dir = 'foo_bar'
 
-      subject.match(dir)[0].should == dir
+      expect(subject.match(dir)[0]).to eq(dir)
     end
 
     it "should match '.'" do
       dir = '.'
 
-      subject.match(dir)[0].should == dir
+      expect(subject.match(dir)[0]).to eq(dir)
     end
 
     it "should match '..'" do
       dir = '..'
 
-      subject.match(dir)[0].should == dir
+      expect(subject.match(dir)[0]).to eq(dir)
     end
   end
 
@@ -330,7 +330,7 @@ describe Regexp do
     it "should match multiple directories" do
       path = 'foo/./bar/../baz'
 
-      subject.match(path)[0].should == path
+      expect(subject.match(path)[0]).to eq(path)
     end
   end
 
@@ -340,19 +340,19 @@ describe Regexp do
     it "should match absolute paths" do
       path = '/foo/bar/baz'
 
-      subject.match(path)[0].should == path
+      expect(subject.match(path)[0]).to eq(path)
     end
 
     it "should match trailing '/' characters" do
       path = '/foo/bar/baz/'
 
-      subject.match(path)[0].should == path
+      expect(subject.match(path)[0]).to eq(path)
     end
 
     it "should not match relative directories" do
       path = '/foo/./bar/../baz'
 
-      subject.match(path)[0].should == '/foo/'
+      expect(subject.match(path)[0]).to eq('/foo/')
     end
   end
 
@@ -362,13 +362,13 @@ describe Regexp do
     it "should match relative paths" do
       path = 'foo/./bar/../baz'
 
-      subject.match(path)[0].should == path
+      expect(subject.match(path)[0]).to eq(path)
     end
 
     it "should match absolute paths" do
       path = '/foo/bar/baz'
 
-      subject.match(path)[0].should == path
+      expect(subject.match(path)[0]).to eq(path)
     end
   end
 
@@ -378,7 +378,7 @@ describe Regexp do
     it "should match multiple directories" do
       path = 'foo\\.\\bar\\..\\baz'
 
-      subject.match(path)[0].should == path
+      expect(subject.match(path)[0]).to eq(path)
     end
   end
 
@@ -388,19 +388,19 @@ describe Regexp do
     it "should match absolute paths" do
       path = 'C:\\foo\\bar\\baz'
 
-      subject.match(path)[0].should == path
+      expect(subject.match(path)[0]).to eq(path)
     end
 
     it "should match trailing '/' characters" do
       path = 'C:\\foo\\bar\\baz\\'
 
-      subject.match(path)[0].should == path
+      expect(subject.match(path)[0]).to eq(path)
     end
 
     it "should not match relative directories" do
       path = 'C:\\foo\\.\\bar\\..\\baz'
 
-      subject.match(path)[0].should == 'C:\\foo\\'
+      expect(subject.match(path)[0]).to eq('C:\\foo\\')
     end
   end
 
@@ -410,13 +410,13 @@ describe Regexp do
     it "should match relative paths" do
       path = 'foo\\.\\bar\\..\\baz'
 
-      subject.match(path)[0].should == path
+      expect(subject.match(path)[0]).to eq(path)
     end
 
     it "should match absolute paths" do
       path = 'C:\\foo\\bar\\baz'
 
-      subject.match(path)[0].should == path
+      expect(subject.match(path)[0]).to eq(path)
     end
   end
 
@@ -426,13 +426,13 @@ describe Regexp do
     it "should match relative UNIX paths" do
       path = 'foo/./bar/../baz'
 
-      subject.match(path)[0].should == path
+      expect(subject.match(path)[0]).to eq(path)
     end
 
     it "should match relative Windows paths" do
       path = 'foo\\.\\bar\\..\\baz'
 
-      subject.match(path)[0].should == path
+      expect(subject.match(path)[0]).to eq(path)
     end
   end
 
@@ -442,13 +442,13 @@ describe Regexp do
     it "should match absolute UNIX paths" do
       path = '/foo/bar/baz'
 
-      subject.match(path)[0].should == path
+      expect(subject.match(path)[0]).to eq(path)
     end
 
     it "should match absolute Windows paths" do
       path = 'C:\\foo\\bar\\baz'
 
-      subject.match(path)[0].should == path
+      expect(subject.match(path)[0]).to eq(path)
     end
   end
 
@@ -458,25 +458,25 @@ describe Regexp do
     it "should match relative UNIX paths" do
       path = 'foo/./bar/../baz'
 
-      subject.match(path)[0].should == path
+      expect(subject.match(path)[0]).to eq(path)
     end
 
     it "should match absolute UNIX paths" do
       path = '/foo/bar/baz'
 
-      subject.match(path)[0].should == path
+      expect(subject.match(path)[0]).to eq(path)
     end
 
     it "should match relative Windows paths" do
       path = 'foo\\.\\bar\\..\\baz'
 
-      subject.match(path)[0].should == path
+      expect(subject.match(path)[0]).to eq(path)
     end
 
     it "should match absolute Windows paths" do
       path = 'C:\\foo\\bar\\baz'
 
-      subject.match(path)[0].should == path
+      expect(subject.match(path)[0]).to eq(path)
     end
   end
 end