icu_tournament 1.9.3 → 1.10.0

data/spec/tournament_spx_spec.rb

@@ -49,72 +49,72 @@ EXPORT
         end
 
         it "should parse without exception" do
-          lambda { @p.parse!(@x, @opt) }.should_not raise_error
+          expect { @p.parse!(@x, @opt) }.not_to raise_error
         end
 
         it "should parse without error" do
           @p.parse(@x, @opt)
-          @p.error.should be_nil
+          expect(@p.error).to be_nil
         end
 
         it "players should have all the right names and numbers" do
-          @t.player(1).name.should == "Duck, Daffy"
-          @t.player(2).name.should == "Mouse, Minerva"
-          @t.player(3).name.should == "Mouse, Mickey"
+          expect(@t.player(1).name).to eq("Duck, Daffy")
+          expect(@t.player(2).name).to eq("Mouse, Minerva")
+          expect(@t.player(3).name).to eq("Mouse, Mickey")
         end
 
         it "players should have correct ICU IDs" do
-          @t.player(1).id.should == 12345
-          @t.player(2).id.should be_nil
-          @t.player(3).id.should be_nil
+          expect(@t.player(1).id).to eq(12345)
+          expect(@t.player(2).id).to be_nil
+          expect(@t.player(3).id).to be_nil
         end
 
         it "players should have correct FIDE IDs" do
-          @t.player(1).fide_id.should be_nil
-          @t.player(2).fide_id.should == 1234568
-          @t.player(3).fide_id.should == 1234567
+          expect(@t.player(1).fide_id).to be_nil
+          expect(@t.player(2).fide_id).to eq(1234568)
+          expect(@t.player(3).fide_id).to eq(1234567)
         end
 
         it "players should have correct ICU ratings" do
-          @t.player(1).rating.should == 2200
-          @t.player(2).rating.should be_nil
-          @t.player(3).rating.should be_nil
+          expect(@t.player(1).rating).to eq(2200)
+          expect(@t.player(2).rating).to be_nil
+          expect(@t.player(3).rating).to be_nil
         end
 
         it "players should have correct FIDE ratings" do
-          @t.player(1).fide_rating.should be_nil
-          @t.player(2).fide_rating.should == 1900
-          @t.player(3).fide_rating.should be_nil
+          expect(@t.player(1).fide_rating).to be_nil
+          expect(@t.player(2).fide_rating).to eq(1900)
+          expect(@t.player(3).fide_rating).to be_nil
         end
 
         it "players should have correct titles" do
-          @t.player(1).title.should == "IM"
-          @t.player(2).title.should be_nil
-          @t.player(3).title.should == "GM"
+          expect(@t.player(1).title).to eq("IM")
+          expect(@t.player(2).title).to be_nil
+          expect(@t.player(3).title).to eq("GM")
         end
 
         it "players should have correct federations" do
-          @t.player(1).fed.should == "IRL"
-          @t.player(2).fed.should be_nil
-          @t.player(3).fed.should == "USA"
+          expect(@t.player(1).fed).to eq("IRL")
+          expect(@t.player(2).fed).to be_nil
+          expect(@t.player(3).fed).to eq("USA")
         end
 
         it "players should have correct scores" do
-          @t.player(1).points.should == 2.0
-          @t.player(2).points.should == 1.5
-          @t.player(3).points.should == 1.0
+          expect(@t.player(1).points).to eq(2.0)
+          expect(@t.player(2).points).to eq(1.5)
+          expect(@t.player(3).points).to eq(1.0)
         end
 
         it "players should have correct ranks" do
-          @t.player(1).rank.should == 1
-          @t.player(2).rank.should == 2
-          @t.player(3).rank.should == 3
+          expect(@t.player(1).rank).to eq(1)
+          expect(@t.player(2).rank).to eq(2)
+          expect(@t.player(3).rank).to eq(3)
         end
 
         it "players should have correct results" do
-          @t.player(1).spx_signature2.should == '123|DWD|FTT'
-          @t.player(2).spx_signature2.should == '123|DDD|TFT'
-          @t.player(3).spx_signature2.should == '123|DLD|TTF'
+          expect(@t.player(1).spx_signature2).to eq('123|DWD|FTT')
+          expect(@t.player(2).spx_signature2).to eq('123|DDD|TFT')
+          expect(@t.player(3).spx_signature2).to eq('123|DLD|TTF')
         end
       end
 
@@ -135,43 +135,43 @@ EXPORT
         end
 
         it "should round trip" do
-          @p.error.should be_nil
-          @r.spx_signature.should == "Bangor Masters|3|2009-11-09|3"
-          @r.player(1).spx_signature.should == "Fischer, Bobby||1.5|123|DLW|---|TFT"
-          @r.player(2).spx_signature.should == "Kasparov, Garry||1.0|123|LWL|---|FTT"
-          @r.player(3).spx_signature.should == "Orr, Mark|1350|0.5|123|DLL|---|TTF"
+          expect(@p.error).to be_nil
+          expect(@r.spx_signature).to eq("Bangor Masters|3|2009-11-09|3")
+          expect(@r.player(1).spx_signature).to eq("Fischer, Bobby||1.5|123|DLW|---|TFT")
+          expect(@r.player(2).spx_signature).to eq("Kasparov, Garry||1.0|123|LWL|---|FTT")
+          expect(@r.player(3).spx_signature).to eq("Orr, Mark|1350|0.5|123|DLL|---|TTF")
         end
 
         it "should show all columns by default" do
-          @x.should match(/^No\s*Name\s*Feder\s*Intl Id\s*Loc Id\s*Rtg\s*Loc\s*Title\s*Total\s*1\s*2\s*3\s*/)
-          @x.should match(/1\s*Fischer,\s*Bobby\s*1\.5\s*3:D\s*0?:L?\s*2:W\s*/)
+          expect(@x).to match(/^No\s*Name\s*Feder\s*Intl Id\s*Loc Id\s*Rtg\s*Loc\s*Title\s*Total\s*1\s*2\s*3\s*/)
+          expect(@x).to match(/1\s*Fischer,\s*Bobby\s*1\.5\s*3:D\s*0?:L?\s*2:W\s*/)
         end
 
         it "can have custom columns" do
           @x = @t.serialize('SPExport', :only => [])
-          @x.should match(/^No\s*Name\s*1\s*2\s*3\s*/)
+          expect(@x).to match(/^No\s*Name\s*1\s*2\s*3\s*/)
           @x = @t.serialize('SPExport', :only => [:points])
-          @x.should match(/^No\s*Name\s*Total\s*1\s*2\s*3\s*/)
+          expect(@x).to match(/^No\s*Name\s*Total\s*1\s*2\s*3\s*/)
           @x = @t.serialize('SPExport', :only => [:points, :id])
-          @x.should match(/^No\s*Name\s*Loc Id\s*Total\s*1\s*2\s*3\s*/)
+          expect(@x).to match(/^No\s*Name\s*Loc Id\s*Total\s*1\s*2\s*3\s*/)
           @x = @t.serialize('SPExport', :only => [:points, :id, :fed])
-          @x.should match(/^No\s*Name\s*Feder\s*Loc Id\s*Total\s*1\s*2\s*3\s*/)
+          expect(@x).to match(/^No\s*Name\s*Feder\s*Loc Id\s*Total\s*1\s*2\s*3\s*/)
           @x = @t.serialize('SPExport', :only => [:points, :id, :fed, "fed", :rubbish, "fide_id"])
-          @x.should match(/^No\s*Name\s*Feder\s*Intl Id\s*Loc Id\s*Total\s*1\s*2\s*3\s*/)
+          expect(@x).to match(/^No\s*Name\s*Feder\s*Intl Id\s*Loc Id\s*Total\s*1\s*2\s*3\s*/)
           @x = @t.serialize('SPExport', :only => [:fed, "fide_id", :points, :id, :rating])
-          @x.should match(/^No\s*Name\s*Feder\s*Intl Id\s*Loc Id\s*Loc\s*Total\s*1\s*2\s*3\s*/)
+          expect(@x).to match(/^No\s*Name\s*Feder\s*Intl Id\s*Loc Id\s*Loc\s*Total\s*1\s*2\s*3\s*/)
           @x = @t.serialize('SPExport', :only => [:fed, :fide_id, "fide_rating", :points, :id, :rating])
-          @x.should match(/^No\s*Name\s*Feder\s*Intl Id\s*Loc Id\s*Rtg\s*Loc\s*Total\s*1\s*2\s*3\s*/)
-          @x.should match(/3\s*Orr,\s*Mark\s*IRL\s*2500035\s*1350\s*2250\s*2200\s*0.5\s*1:D\s*2:L\s*:\s*/)
+          expect(@x).to match(/^No\s*Name\s*Feder\s*Intl Id\s*Loc Id\s*Rtg\s*Loc\s*Total\s*1\s*2\s*3\s*/)
+          expect(@x).to match(/3\s*Orr,\s*Mark\s*IRL\s*2500035\s*1350\s*2250\s*2200\s*0.5\s*1:D\s*2:L\s*:\s*/)
         end
 
         it "the :only and :except options are logical opposites" do
-          @t.serialize('SPExport', :only => [:points, :id, "fed"]).should == @t.serialize('SPExport', :except => [:fide_id, :rating, "fide_rating", :title])
-          @t.serialize('SPExport', :only => ["points"]).should == @t.serialize('SPExport', :except => ["fide_id", :rating, :fide_rating, :title, :id, :fed])
-          @t.serialize('SPExport', :only => [:rating, :fide_rating, :title, :id, :fed, :points]).should == @t.serialize('SPExport', :except => [:fide_id])
-          @t.serialize('SPExport', :only => %w{rating fide_rating fide_id title id fed points}).should == @t.serialize('SPExport', :except => [])
-          @t.serialize('SPExport', :only => []).should == @t.serialize('SPExport', :except => [:rating, :fide_rating, :fide_id, :title, :id, :fed, :points])
-          @t.serialize('SPExport', :except => []).should == @t.serialize('SPExport')
+          expect(@t.serialize('SPExport', :only => [:points, :id, "fed"])).to eq(@t.serialize('SPExport', :except => [:fide_id, :rating, "fide_rating", :title]))
+          expect(@t.serialize('SPExport', :only => ["points"])).to eq(@t.serialize('SPExport', :except => ["fide_id", :rating, :fide_rating, :title, :id, :fed]))
+          expect(@t.serialize('SPExport', :only => [:rating, :fide_rating, :title, :id, :fed, :points])).to eq(@t.serialize('SPExport', :except => [:fide_id]))
+          expect(@t.serialize('SPExport', :only => %w{rating fide_rating fide_id title id fed points})).to eq(@t.serialize('SPExport', :except => []))
+          expect(@t.serialize('SPExport', :only => [])).to eq(@t.serialize('SPExport', :except => [:rating, :fide_rating, :fide_id, :title, :id, :fed, :points]))
+          expect(@t.serialize('SPExport', :except => [])).to eq(@t.serialize('SPExport'))
         end
       end
 
@@ -189,9 +189,9 @@ EXPORT
         end
 
         it "players should have correct results" do
-          @t.player(1).spx_signature2.should == '123|DWD|FTT'
-          @t.player(2).spx_signature2.should == '123|DDD|TFT'
-          @t.player(3).spx_signature2.should == '123|DLD|TTF'
+          expect(@t.player(1).spx_signature2).to eq('123|DWD|FTT')
+          expect(@t.player(2).spx_signature2).to eq('123|DDD|TFT')
+          expect(@t.player(3).spx_signature2).to eq('123|DLD|TTF')
         end
       end
 
@@ -209,9 +209,9 @@ EXPORT
         end
 
         it "players should have correct results" do
-          @t.player(1).spx_signature2.should == '123|WWD|FFF'
-          @t.player(2).spx_signature2.should == '123|WDD|FFF'
-          @t.player(3).spx_signature2.should == '123|DDL|FFF'
+          expect(@t.player(1).spx_signature2).to eq('123|WWD|FFF')
+          expect(@t.player(2).spx_signature2).to eq('123|WDD|FFF')
+          expect(@t.player(3).spx_signature2).to eq('123|DDL|FFF')
         end
       end
 
@@ -229,15 +229,15 @@ EXPORT
         end
 
         it "players should have canonicalised names" do
-          @t.player(1).name.should == 'Duck, Daffy'
-          @t.player(2).name.should == 'Mouse, Minerva'
-          @t.player(3).name.should == 'Mouse, Mickey'
+          expect(@t.player(1).name).to eq('Duck, Daffy')
+          expect(@t.player(2).name).to eq('Mouse, Minerva')
+          expect(@t.player(3).name).to eq('Mouse, Mickey')
         end
 
         it "players should have original names" do
-          @t.player(1).original_name.should == 'daffy duck'
-          @t.player(2).original_name.should == 'MOUSE, minerva'
-          @t.player(3).original_name.should == 'mouse, MICKEY'
+          expect(@t.player(1).original_name).to eq('daffy duck')
+          expect(@t.player(2).original_name).to eq('MOUSE, minerva')
+          expect(@t.player(3).original_name).to eq('mouse, MICKEY')
         end
       end
 
@@ -255,21 +255,21 @@ EXPORT
         end
 
         it "players should have all the right names and numbers" do
-          @t.player(1).name.should == "Duck, Daffy"
-          @t.player(2).name.should == "Mouse, Minerva"
-          @t.player(3).name.should == "Mouse, Mickey"
+          expect(@t.player(1).name).to eq("Duck, Daffy")
+          expect(@t.player(2).name).to eq("Mouse, Minerva")
+          expect(@t.player(3).name).to eq("Mouse, Mickey")
         end
 
         it "players should have correct results" do
-          @t.player(1).spx_signature2.should == '123|DWD|FFT'
-          @t.player(2).spx_signature2.should == '123|DLD|FFT'
-          @t.player(3).spx_signature2.should == '123|DLD|FFF'
+          expect(@t.player(1).spx_signature2).to eq('123|DWD|FFT')
+          expect(@t.player(2).spx_signature2).to eq('123|DLD|FFT')
+          expect(@t.player(3).spx_signature2).to eq('123|DLD|FFF')
         end
 
         it "players should have correct ranks given default name tie-break" do
-          @t.player(1).rank.should == 1
-          @t.player(2).rank.should == 3
-          @t.player(3).rank.should == 2
+          expect(@t.player(1).rank).to eq(1)
+          expect(@t.player(2).rank).to eq(3)
+          expect(@t.player(3).rank).to eq(2)
         end
       end
 
@@ -287,16 +287,16 @@ EXPORT
 
         it "UTF-8" do
           t = @p.parse(@x, @opt)
-          @p.error.should be_nil
-          t.player(1).name.should == "Dück, Dâffy"
-          t.player(2).name.should == "Möuse, Mickéy"
+          expect(@p.error).to be_nil
+          expect(t.player(1).name).to eq("Dück, Dâffy")
+          expect(t.player(2).name).to eq("Möuse, Mickéy")
         end
 
         it "Latin-1" do
           t = @p.parse(@x.encode("ISO-8859-1"), @opt)
-          @p.error.should be_nil
-          t.player(1).name.should == "Dück, Dâffy"
-          t.player(2).name.should == "Möuse, Mickéy"
+          expect(@p.error).to be_nil
+          expect(t.player(1).name).to eq("Dück, Dâffy")
+          expect(t.player(2).name).to eq("Möuse, Mickéy")
         end
       end
 
@@ -313,7 +313,7 @@ No	Name          	Total	1  	2
 1 	Duck, Daffy   	1.5  	2:W	2:D
 2 	Mouse, Mickey 	0.5  	1:L	1:D
 EXPORT
-          lambda { @p.parse!(data, @opt) }.should_not raise_error
+          expect { @p.parse!(data, @opt) }.not_to raise_error
         end
 
         it "no header" do
@@ -321,7 +321,7 @@ EXPORT
 1 	Duck, Daffy   	1.5  	2:W	2:D
 2 	Mouse, Mickey 	0.5  	1:L	1:L
 EXPORT
-          lambda { @p.parse!(data, @opt) }.should raise_error(/header/)
+          expect { @p.parse!(data, @opt) }.to raise_error(/header/)
         end
 
         it "invalid header" do
@@ -331,7 +331,7 @@ Xx	Name          	Total	1  	2
 1 	Duck, Daffy   	1.5  	2:W	2:D
 2 	Mouse, Mickey 	0.5  	1:L	1:D
 EXPORT
-          lambda { @p.parse!(data, @opt) }.should raise_error(/header/)
+          expect { @p.parse!(data, @opt) }.to raise_error(/header/)
         end
 
         it "missing round 1" do
@@ -341,7 +341,7 @@ No	Name          	Total	2  	3
 1 	Duck, Daffy   	1.5  	2:W	2:D
 2 	Mouse, Mickey 	0.0  	1:L	1:L
 EXPORT
-          lambda { @p.parse!(data, @opt) }.should raise_error(/round 1/)
+          expect { @p.parse!(data, @opt) }.to raise_error(/round 1/)
         end
 
         it "missing round 2" do
@@ -351,7 +351,7 @@ No	Name          	Total	1  	3
 1 	Duck, Daffy   	1.5  	2:W	2:D
 2 	Mouse, Mickey 	0.0  	1:L	1:L
 EXPORT
-          lambda { @p.parse!(data, @opt) }.should raise_error(/round 2/)
+          expect { @p.parse!(data, @opt) }.to raise_error(/round 2/)
         end
 
         it "incorrect total" do
@@ -361,7 +361,7 @@ No	Name          	Total	1  	2
 1 	Duck, Daffy   	1.5  	2:W	2:D
 2 	Mouse, Mickey 	1.0  	1:L	1:D
 EXPORT
-          lambda { @p.parse!(data, @opt) }.should raise_error(/total/)
+          expect { @p.parse!(data, @opt) }.to raise_error(/total/)
         end
 
 
@@ -372,7 +372,7 @@ No	Name          	Total	1  	2
 1 	Duck, Daffy   	1.5  	2:W	2:D
 2 	Mouse, Mickey 	0.0  	1:L	1:L
 EXPORT
-          lambda { @p.parse!(data, @opt) }.should raise_error(/result/)
+          expect { @p.parse!(data, @opt) }.to raise_error(/result/)
         end
 
         it "invalid attribute, title for example)" do
@@ -382,7 +382,7 @@ No	Name          	Title	Total	1  	2
 1 	Duck, Daffy   	mg   	1.5  	2:W	2:D
 2 	Mouse, Mickey 	     	0.5  	1:L	1:D
 EXPORT
-          lambda { @p.parse!(data, @opt) }.should raise_error(/title/)
+          expect { @p.parse!(data, @opt) }.to raise_error(/title/)
         end
       end
 
@@ -394,19 +394,19 @@ EXPORT
         end
 
         it "should parse and have the right basic details" do
-          @p.error.should be_nil
-          @t.spx_signature.should == "Gonzaga Chess Classic 2010 Challengers Section|6|2010-01-29|56"
+          expect(@p.error).to be_nil
+          expect(@t.spx_signature).to eq("Gonzaga Chess Classic 2010 Challengers Section|6|2010-01-29|56")
         end
 
         it "should have correct details for selected players" do
-          @t.player(2).spx_signature.should  == "Mullooly, Neil M.|6438|6.0|123456|WWWWWW|------|TTTTTT" # winner
-          @t.player(4).spx_signature.should  == "Gallagher, Mark|12138|4.0|123456|WLWWWL|------|FTTTTT"  # had one bye
-          @t.player(45).spx_signature.should == "Catre, Loredan||3.5|123456|WDLWLW|------|FTTTFT"        # had two byes
-          @t.player(56).spx_signature.should == "McDonnell, Cathal||0.0|123456|LLLLLL|------|FFFFFF"     # last, all defaults
+          expect(@t.player(2).spx_signature).to  eq("Mullooly, Neil M.|6438|6.0|123456|WWWWWW|------|TTTTTT") # winner
+          expect(@t.player(4).spx_signature).to  eq("Gallagher, Mark|12138|4.0|123456|WLWWWL|------|FTTTTT")  # had one bye
+          expect(@t.player(45).spx_signature).to eq("Catre, Loredan||3.5|123456|WDLWLW|------|FTTTFT")        # had two byes
+          expect(@t.player(56).spx_signature).to eq("McDonnell, Cathal||0.0|123456|LLLLLL|------|FFFFFF")     # last, all defaults
         end
 
         it "should have consistent ranks" do
-          @t.players.map{ |p| p.rank }.sort.join('').should == (1..@t.players.size).to_a.join('')
+          expect(@t.players.map{ |p| p.rank }.sort.join('')).to eq((1..@t.players.size).to_a.join(''))
         end
       end
     end

data/spec/util_spec.rb

@@ -6,33 +6,33 @@ module ICU
     describe Date do
       context "#parse" do
         it "should parse standard dates" do
-          Date.parse('2001-01-01').should == '2001-01-01'
-          Date.parse('1955-11-09').should == '1955-11-09'
+          expect(Date.parse('2001-01-01')).to eq('2001-01-01')
+          expect(Date.parse('1955-11-09')).to eq('1955-11-09')
         end
     
         it "should handle US format" do
-          Date.parse('03/30/2009').should == '2009-03-30'
+          expect(Date.parse('03/30/2009')).to eq('2009-03-30')
         end
     
         it "should handle European format" do
-          Date.parse('30/03/2009').should == '2009-03-30'
+          expect(Date.parse('30/03/2009')).to eq('2009-03-30')
         end
     
         it "should prefer European format" do
-          Date.parse('02/03/2009').should == '2009-03-02'
+          expect(Date.parse('02/03/2009')).to eq('2009-03-02')
         end
     
         it "should handle US style when there's no alternative" do
-          Date.parse('02/23/2009').should == '2009-02-23'
+          expect(Date.parse('02/23/2009')).to eq('2009-02-23')
         end
     
         it "should handle single digits" do
-          Date.parse('9/8/2006').should == '2006-08-09'
+          expect(Date.parse('9/8/2006')).to eq('2006-08-09')
         end
     
         it "should handle names of monthsx" do
-          Date.parse('9th Nov 1955').should == '1955-11-09'
-          Date.parse('16th June 1986').should == '1986-06-16'
+          expect(Date.parse('9th Nov 1955')).to eq('1955-11-09')
+          expect(Date.parse('16th June 1986')).to eq('1986-06-16')
         end
       end
     end
@@ -44,23 +44,23 @@ module ICU
         end
 
         it "should read ASCII" do
-          File.read_utf8("#{@s}/ascii.txt").should == "Resume\nResume\n"
+          expect(File.read_utf8("#{@s}/ascii.txt")).to eq("Resume\nResume\n")
         end
 
         it "should read Latin-1" do
-          File.read_utf8("#{@s}/latin1.txt").should == "Résumé\nRésumé\n"
+          expect(File.read_utf8("#{@s}/latin1.txt")).to eq("Résumé\nRésumé\n")
         end
 
         it "should read Windows CP1252" do
-          File.read_utf8("#{@s}/cp1252.txt").should == "€3\n£7\n¥1\n"
+          expect(File.read_utf8("#{@s}/cp1252.txt")).to eq("€3\n£7\n¥1\n")
         end
 
         it "should read UTF-8" do
-          File.read_utf8("#{@s}/utf8.txt").should == "ヒラガナ\nヒラガナ\n"
+          expect(File.read_utf8("#{@s}/utf8.txt")).to eq("ヒラガナ\nヒラガナ\n")
         end
 
         it "should thow an exception for a non-existant file" do
-          lambda { File.read_utf8("#{@s}/no_such_file.txt") }.should raise_error
+          expect { File.read_utf8("#{@s}/no_such_file.txt") }.to raise_error
         end
       end
 
@@ -71,44 +71,44 @@ module ICU
 
         it "should read ASCII" do
           data = File.load_ini("#{@s}/ascii.ini")
-          data.should be_an_instance_of(Hash)
-          data["Pairing"]["UseRating"].should == "0"
+          expect(data).to be_an_instance_of(Hash)
+          expect(data["Pairing"]["UseRating"]).to eq("0")
           data["NoKeys"] == nil
-          data["Tournament Info"]["Arbiter"].should == "Herbert Scarry"
-          data["Tournament Info"]["DrawSymbol"].should == "D"
+          expect(data["Tournament Info"]["Arbiter"]).to eq("Herbert Scarry")
+          expect(data["Tournament Info"]["DrawSymbol"]).to eq("D")
         end
 
         it "should read Latin1" do
           data = File.load_ini("#{@s}/latin1.ini")
-          data.should be_an_instance_of(Hash)
-          data["Tournament Info"]["Arbiter"].should == "Gearóidín"
-          data["Tournament Info"]["DrawSymbol"].should == "½"
+          expect(data).to be_an_instance_of(Hash)
+          expect(data["Tournament Info"]["Arbiter"]).to eq("Gearóidín")
+          expect(data["Tournament Info"]["DrawSymbol"]).to eq("½")
         end
 
         it "should read Windows-1252" do
           data = File.load_ini("#{@s}/cp1252.ini")
-          data.should be_an_instance_of(Hash)
-          data["Tournament Info"]["Entry Fee"].should == "€50"
+          expect(data).to be_an_instance_of(Hash)
+          expect(data["Tournament Info"]["Entry Fee"]).to eq("€50")
         end
 
         it "should read UTF8" do
           data = File.load_ini("#{@s}/utf8.ini")
-          data.should be_an_instance_of(Hash)
-          data["Tournament Info"]["Entry Fee"].should == "€50"
-          data["Tournament Info"]["Arbiter"].should == "ヒラガナ"
-          data["Tournament Info"]["DrawSymbol"].should == "½"
+          expect(data).to be_an_instance_of(Hash)
+          expect(data["Tournament Info"]["Entry Fee"]).to eq("€50")
+          expect(data["Tournament Info"]["Arbiter"]).to eq("ヒラガナ")
+          expect(data["Tournament Info"]["DrawSymbol"]).to eq("½")
         end
 
         it "should handle untidily formatted files" do
           data = File.load_ini("#{@s}/untidy.ini")
-          data.should be_an_instance_of(Hash)
-          data["Tournament Info"]["Entry Fee"].should == "€50"
-          data["Tournament Info"]["DrawSymbol"].should == "½"
-          data["Pairing"]["Use  Rating"].should == "0"
+          expect(data).to be_an_instance_of(Hash)
+          expect(data["Tournament Info"]["Entry Fee"]).to eq("€50")
+          expect(data["Tournament Info"]["DrawSymbol"]).to eq("½")
+          expect(data["Pairing"]["Use  Rating"]).to eq("0")
         end
 
         it "should thow an exception for a non-existant file" do
-          lambda { File.read_utf8("#{@s}/no_such_file.ini") }.should raise_error
+          expect { File.read_utf8("#{@s}/no_such_file.ini") }.to raise_error
         end
       end
     end
@@ -122,16 +122,16 @@ module ICU
         end
 
         it "should not have an accessor unless declared" do
-          @obj.respond_to?(:myatr).should be_false
-          @obj.respond_to?(:myatr=).should be_false
+          expect(@obj.respond_to?(:myatr)).to be_falsey
+          expect(@obj.respond_to?(:myatr=)).to be_falsey
         end
 
         it "should have a getter but no setter with the default declaration" do
           @class.attr_accessor('myatr')
-          @obj.respond_to?(:myatr).should be_true
-          @obj.respond_to?(:myatr=).should be_false
+          expect(@obj.respond_to?(:myatr)).to be_truthy
+          expect(@obj.respond_to?(:myatr=)).to be_falsey
           @obj.instance_eval { @myatr = 42 }
-          @obj.myatr.should == 42
+          expect(@obj.myatr).to eq(42)
         end
 
         it "should be able to create do-it-yourself setters such as for a positive integer" do
@@ -140,17 +140,17 @@ module ICU
             raise "invalid positive integer (#{val})" unless tmp > 0
             tmp
           end
-          @obj.respond_to?(:myatr).should be_true
-          @obj.respond_to?(:myatr=).should be_true
-          lambda { @obj.myatr = "no number here" }.should raise_error(/invalid positive integer \(no number here\)/)
-          lambda { @obj.myatr = -1 }.should raise_error
-          lambda { @obj.myatr = 0 }.should raise_error
-          lambda { @obj.myatr = 1 }.should_not raise_error
-          @obj.myatr.should == 1
-          lambda { @obj.myatr = '42' }.should_not raise_error
-          @obj.myatr.should == 42
-          lambda { @obj.myatr = '  0371  ' }.should_not raise_error
-          @obj.myatr.should == 371
+          expect(@obj.respond_to?(:myatr)).to be_truthy
+          expect(@obj.respond_to?(:myatr=)).to be_truthy
+          expect { @obj.myatr = "no number here" }.to raise_error(/invalid positive integer \(no number here\)/)
+          expect { @obj.myatr = -1 }.to raise_error
+          expect { @obj.myatr = 0 }.to raise_error
+          expect { @obj.myatr = 1 }.not_to raise_error
+          expect(@obj.myatr).to eq(1)
+          expect { @obj.myatr = '42' }.not_to raise_error
+          expect(@obj.myatr).to eq(42)
+          expect { @obj.myatr = '  0371  ' }.not_to raise_error
+          expect(@obj.myatr).to eq(371)
         end
       end
 
@@ -163,36 +163,36 @@ module ICU
         end
 
         it "should have a getter and setter" do
-          @obj.respond_to?(:myint).should be_true
-          @obj.respond_to?(:myint=).should be_true
+          expect(@obj.respond_to?(:myint)).to be_truthy
+          expect(@obj.respond_to?(:myint=)).to be_truthy
         end
 
         it "should work with ints" do
           @obj.myint = -43
-          @obj.myint.should == -43
+          expect(@obj.myint).to eq(-43)
         end
 
         it "should work with strings" do
           @obj.myint = "  -99 "
-          @obj.myint.should == -99
+          expect(@obj.myint).to eq(-99)
         end
 
         it "should handle zero" do
-          lambda { @obj.myint = 0 }.should_not raise_error
-          lambda { @obj.myint = '0' }.should_not raise_error
+          expect { @obj.myint = 0 }.not_to raise_error
+          expect { @obj.myint = '0' }.not_to raise_error
         end
 
         it "should reject nil and other non-numbers" do
-          lambda { @obj.myint = nil }.should raise_error(/invalid/)
-          lambda { @obj.myint = "N" }.should raise_error(/invalid/)
-          lambda { @obj.myint = " " }.should raise_error(/invalid/)
-          lambda { @obj.myint = ''  }.should raise_error(/invalid/)
+          expect { @obj.myint = nil }.to raise_error(/invalid/)
+          expect { @obj.myint = "N" }.to raise_error(/invalid/)
+          expect { @obj.myint = " " }.to raise_error(/invalid/)
+          expect { @obj.myint = ''  }.to raise_error(/invalid/)
         end
 
         it "should handle multiple names" do
           @class.attr_integer :yourint, :hisint
-          @obj.respond_to?(:yourint).should be_true
-          @obj.respond_to?(:hisint=).should be_true
+          expect(@obj.respond_to?(:yourint)).to be_truthy
+          expect(@obj.respond_to?(:hisint=)).to be_truthy
         end
       end
 
@@ -205,27 +205,27 @@ module ICU
         end
 
         it "should have a getter and setter" do
-          @obj.respond_to?(:myint).should be_true
-          @obj.respond_to?(:myint=).should be_true
+          expect(@obj.respond_to?(:myint)).to be_truthy
+          expect(@obj.respond_to?(:myint=)).to be_truthy
         end
 
         it "should work with ints and nil and spaces" do
           @obj.myint = 43
-          @obj.myint.should == 43
+          expect(@obj.myint).to eq(43)
           @obj.myint = nil
-          @obj.myint.should == nil
+          expect(@obj.myint).to eq(nil)
           @obj.myint = '  '
-          @obj.myint.should == nil
+          expect(@obj.myint).to eq(nil)
         end
 
         it "should reject non-numbers" do
-          lambda { @obj.myint = "N" }.should raise_error(/invalid/)
+          expect { @obj.myint = "N" }.to raise_error(/invalid/)
         end
 
         it "should handle multiple names" do
           @class.attr_integer :yourint, :hisint
-          @obj.respond_to?(:yourint).should be_true
-          @obj.respond_to?(:hisint=).should be_true
+          expect(@obj.respond_to?(:yourint)).to be_truthy
+          expect(@obj.respond_to?(:hisint=)).to be_truthy
         end
       end
 
@@ -238,26 +238,26 @@ module ICU
         end
 
         it "should have a getter and setter" do
-          @obj.respond_to?(:mypos).should be_true
-          @obj.respond_to?(:mypos=).should be_true
+          expect(@obj.respond_to?(:mypos)).to be_truthy
+          expect(@obj.respond_to?(:mypos=)).to be_truthy
         end
 
         it "should work as expected" do
           @obj.mypos = "34"
-          @obj.mypos.should == 34
+          expect(@obj.mypos).to eq(34)
         end
 
         it "should reject nil and other non-positive integers" do
-          lambda { @obj.mypos = nil }.should raise_error(/invalid/)
-          lambda { @obj.mypos = 'X' }.should raise_error(/invalid/)
-          lambda { @obj.mypos = '0' }.should raise_error(/invalid/)
-          lambda { @obj.mypos = -13 }.should raise_error(/invalid/)
+          expect { @obj.mypos = nil }.to raise_error(/invalid/)
+          expect { @obj.mypos = 'X' }.to raise_error(/invalid/)
+          expect { @obj.mypos = '0' }.to raise_error(/invalid/)
+          expect { @obj.mypos = -13 }.to raise_error(/invalid/)
         end
 
         it "should handle multiple names" do
           @class.attr_integer :ourpos, :theirpos
-          @obj.respond_to?(:ourpos).should be_true
-          @obj.respond_to?(:theirpos=).should be_true
+          expect(@obj.respond_to?(:ourpos)).to be_truthy
+          expect(@obj.respond_to?(:theirpos=)).to be_truthy
         end
       end
 
@@ -270,31 +270,31 @@ module ICU
         end
 
         it "should have a getter and setter" do
-          @obj.respond_to?(:mypon).should be_true
-          @obj.respond_to?(:mypon=).should be_true
+          expect(@obj.respond_to?(:mypon)).to be_truthy
+          expect(@obj.respond_to?(:mypon=)).to be_truthy
         end
 
         it "should work with numbers, nil, empty strings and spaces" do
           @obj.mypon = " 54 "
-          @obj.mypon.should == 54
+          expect(@obj.mypon).to eq(54)
           @obj.mypon = nil
-          @obj.mypon.should be_nil
+          expect(@obj.mypon).to be_nil
           @obj.mypon = ''
-          @obj.mypon.should be_nil
+          expect(@obj.mypon).to be_nil
           @obj.mypon = '  '
-          @obj.mypon.should be_nil
+          expect(@obj.mypon).to be_nil
         end
 
         it "should reject non-integers and non-positive integers" do
-          lambda { @obj.mypon = 'X' }.should raise_error(/invalid/)
-          lambda { @obj.mypon = '0' }.should raise_error(/invalid/)
-          lambda { @obj.mypon = -13 }.should raise_error(/invalid/)
+          expect { @obj.mypon = 'X' }.to raise_error(/invalid/)
+          expect { @obj.mypon = '0' }.to raise_error(/invalid/)
+          expect { @obj.mypon = -13 }.to raise_error(/invalid/)
         end
 
         it "should handle multiple names" do
           @class.attr_integer :ourpon, :theirpon
-          @obj.respond_to?(:ourpon).should be_true
-          @obj.respond_to?(:theirpon=).should be_true
+          expect(@obj.respond_to?(:ourpon)).to be_truthy
+          expect(@obj.respond_to?(:theirpon=)).to be_truthy
         end
       end
 
@@ -307,26 +307,26 @@ module ICU
         end
 
         it "should have a getter and setter" do
-          @obj.respond_to?(:mydate).should be_true
-          @obj.respond_to?(:mydate=).should be_true
+          expect(@obj.respond_to?(:mydate)).to be_truthy
+          expect(@obj.respond_to?(:mydate=)).to be_truthy
         end
 
         it "should work as expected" do
           @obj.mydate = "2009/11/09"
-          @obj.mydate.should == '2009-11-09'
+          expect(@obj.mydate).to eq('2009-11-09')
         end
 
         it "should reject nil and other non-dates" do
-          lambda { @obj.mydate = nil }.should raise_error(/invalid/)
-          lambda { @obj.mydate = 'blah de blah' }.should raise_error(/invalid/)
-          lambda { @obj.mydate = ' ' }.should raise_error(/invalid/)
-          lambda { @obj.mydate = 0 }.should raise_error(/invalid/)
+          expect { @obj.mydate = nil }.to raise_error(/invalid/)
+          expect { @obj.mydate = 'blah de blah' }.to raise_error(/invalid/)
+          expect { @obj.mydate = ' ' }.to raise_error(/invalid/)
+          expect { @obj.mydate = 0 }.to raise_error(/invalid/)
         end
 
         it "should handle multiple names" do
           @class.attr_date :ourdate, :theirdate
-          @obj.respond_to?(:ourdate).should be_true
-          @obj.respond_to?(:theirdate=).should be_true
+          expect(@obj.respond_to?(:ourdate)).to be_truthy
+          expect(@obj.respond_to?(:theirdate=)).to be_truthy
         end
       end
 
@@ -339,26 +339,26 @@ module ICU
         end
 
         it "should have a getter and setter" do
-          @obj.respond_to?(:mydate).should be_true
-          @obj.respond_to?(:mydate=).should be_true
+          expect(@obj.respond_to?(:mydate)).to be_truthy
+          expect(@obj.respond_to?(:mydate=)).to be_truthy
         end
 
         it "should work as expected, including with nil" do
           @obj.mydate = "2009/11/09"
-          @obj.mydate.should == '2009-11-09'
+          expect(@obj.mydate).to eq('2009-11-09')
           @obj.mydate = nil
-          @obj.mydate.should be_nil
+          expect(@obj.mydate).to be_nil
         end
 
         it "should reject non-dates" do
-          lambda { @obj.mydate = 'blah de blah' }.should raise_error(/invalid/)
-          lambda { @obj.mydate = 0 }.should raise_error(/invalid/)
+          expect { @obj.mydate = 'blah de blah' }.to raise_error(/invalid/)
+          expect { @obj.mydate = 0 }.to raise_error(/invalid/)
         end
 
         it "should handle multiple names" do
           @class.attr_date :ourdate, :theirdate
-          @obj.respond_to?(:ourdate).should be_true
-          @obj.respond_to?(:theirdate=).should be_true
+          expect(@obj.respond_to?(:ourdate)).to be_truthy
+          expect(@obj.respond_to?(:theirdate=)).to be_truthy
         end
       end
 
@@ -371,28 +371,28 @@ module ICU
         end
 
         it "should have a getter and setter" do
-          @obj.respond_to?(:mystring).should be_true
-          @obj.respond_to?(:mystring=).should be_true
+          expect(@obj.respond_to?(:mystring)).to be_truthy
+          expect(@obj.respond_to?(:mystring=)).to be_truthy
         end
 
         it "should work as expected" do
           @obj.mystring = "  mark   "
-          @obj.mystring.should == 'mark'
+          expect(@obj.mystring).to eq('mark')
         end
 
         it "should reject values that don't match" do
-          lambda { @obj.mystring = nil }.should raise_error(/invalid/)
-          lambda { @obj.mystring = ' 123 ' }.should raise_error(/invalid/)
-          lambda { @obj.mystring = ' ' }.should raise_error(/invalid/)
-          lambda { @obj.mystring = 0 }.should raise_error(/invalid/)
-          lambda { @obj.mystring = ' a ' }.should_not raise_error
-          lambda { @obj.mystring = 'ZYX' }.should_not raise_error
+          expect { @obj.mystring = nil }.to raise_error(/invalid/)
+          expect { @obj.mystring = ' 123 ' }.to raise_error(/invalid/)
+          expect { @obj.mystring = ' ' }.to raise_error(/invalid/)
+          expect { @obj.mystring = 0 }.to raise_error(/invalid/)
+          expect { @obj.mystring = ' a ' }.not_to raise_error
+          expect { @obj.mystring = 'ZYX' }.not_to raise_error
         end
 
         it "should handle multiple names" do
           @class.attr_string %r%^[A-Z]{3}$%, :ourstring, :theirstring
-          @obj.respond_to?(:ourstring=).should be_true
-          @obj.respond_to?(:theirstring).should be_true
+          expect(@obj.respond_to?(:ourstring=)).to be_truthy
+          expect(@obj.respond_to?(:theirstring)).to be_truthy
         end
       end
 
@@ -405,30 +405,30 @@ module ICU
         end
 
         it "should have a getter and setter" do
-          @obj.respond_to?(:mystring).should be_true
-          @obj.respond_to?(:mystring=).should be_true
+          expect(@obj.respond_to?(:mystring)).to be_truthy
+          expect(@obj.respond_to?(:mystring=)).to be_truthy
         end
 
         it "should work as expected" do
           @obj.mystring = " 12345  "
-          @obj.mystring.should == '12345'
+          expect(@obj.mystring).to eq('12345')
           @obj.mystring = nil
-          @obj.mystring.should be_nil
+          expect(@obj.mystring).to be_nil
           @obj.mystring = '   '
-          @obj.mystring.should be_nil
+          expect(@obj.mystring).to be_nil
         end
 
         it "should reject values that don't match" do
-          lambda { @obj.mystring = ' 0 ' }.should raise_error(/invalid/)
-          lambda { @obj.mystring = 0 }.should raise_error(/invalid/)
-          lambda { @obj.mystring = -1 }.should raise_error(/invalid/)
-          lambda { @obj.mystring = 98 }.should_not raise_error
+          expect { @obj.mystring = ' 0 ' }.to raise_error(/invalid/)
+          expect { @obj.mystring = 0 }.to raise_error(/invalid/)
+          expect { @obj.mystring = -1 }.to raise_error(/invalid/)
+          expect { @obj.mystring = 98 }.not_to raise_error
         end
 
         it "should handle multiple names" do
           @class.attr_string %r%^[A-Z][a-z]+%, :ourstring, :theirstring
-          @obj.respond_to?(:ourstring=).should be_true
-          @obj.respond_to?(:theirstring).should be_true
+          expect(@obj.respond_to?(:ourstring=)).to be_truthy
+          expect(@obj.respond_to?(:theirstring)).to be_truthy
         end
       end
     end