linguistics 2.0.2 → 2.0.3

data/spec/linguistics/en/linkparser_spec.rb

@@ -1,17 +1,8 @@
 #!/usr/bin/env spec -cfs
 
-BEGIN {
-	require 'pathname'
-	basedir = Pathname.new( __FILE__ ).dirname.parent.parent.parent
-
-	libdir = basedir + "lib"
-
-	$LOAD_PATH.unshift( basedir.to_s ) unless $LOAD_PATH.include?( basedir.to_s )
-	$LOAD_PATH.unshift( libdir.to_s ) unless $LOAD_PATH.include?( libdir.to_s )
-}
+require_relative '../../helpers'
 
 require 'rspec'
-require 'spec/lib/helpers'
 
 require 'linguistics'
 require 'linguistics/en/linkparser'
@@ -20,17 +11,12 @@ require 'linguistics/en/linkparser'
 describe Linguistics::EN::LinkParser do
 
 	before( :all ) do
-		setup_logging( :fatal )
 		Linguistics.use( :en )
 	end
 
-	after( :all ) do
-		reset_logging()
-	end
-
 
 	it "adds EN::LinkParser to the list of English language modules" do
-		Linguistics::EN::MODULES.include?( Linguistics::EN::LinkParser )
+		expect( Linguistics::EN::MODULES ).to include( Linguistics::EN::LinkParser )
 	end
 
 
@@ -39,7 +25,7 @@ describe Linguistics::EN::LinkParser do
 		it "can create a LinkParser::Sentence from a sentence in a string" do
 			pending "installation of the linkparser library" unless
 				Linguistics::EN.has_linkparser?
-			"This is a sentence.".en.sentence.should be_a( LinkParser::Sentence )
+			expect( "This is a sentence.".en.sentence ).to be_a( LinkParser::Sentence )
 		end
 
 	end
@@ -50,9 +36,12 @@ describe Linguistics::EN::LinkParser do
 
 			# If the system *does* have linkparser support, pretend it doesn't.
 			if Linguistics::EN.has_linkparser?
-				Linguistics::EN::LinkParser.stub( :has_linkparser? ).and_return( false )
-				exception = stub( "linkparser load error", :message => 'no such file to load' )
-				Linguistics::EN::LinkParser.stub( :lp_error ).and_return( exception )
+				exception = LoadError.new( 'no such file to load -- linkparser' )
+
+				allow( Linguistics::EN::LinkParser ).to receive( :has_linkparser? ).
+					and_return( false )
+				allow( Linguistics::EN::LinkParser ).to receive( :lp_error ).
+					and_return( exception )
 			end
 
 			expect {

data/spec/linguistics/en/numbers_spec.rb

@@ -1,17 +1,8 @@
 #!/usr/bin/env spec -cfs
 
-BEGIN {
-	require 'pathname'
-	basedir = Pathname.new( __FILE__ ).dirname.parent.parent.parent
-
-	libdir = basedir + "lib"
-
-	$LOAD_PATH.unshift( basedir.to_s ) unless $LOAD_PATH.include?( basedir.to_s )
-	$LOAD_PATH.unshift( libdir.to_s ) unless $LOAD_PATH.include?( libdir.to_s )
-}
+require_relative '../../helpers'
 
 require 'rspec'
-require 'spec/lib/helpers'
 
 require 'linguistics'
 require 'linguistics/en/numbers'
@@ -20,1272 +11,1268 @@ require 'linguistics/en/numbers'
 describe Linguistics::EN::Numbers do
 
 	before( :all ) do
-		setup_logging( :fatal )
 		Linguistics.use( :en )
 	end
 
-	after( :all ) do
-		reset_logging()
-	end
-
 
 	it "adds EN::Numbers to the list of English language modules" do
-		Linguistics::EN.should have_extension( :numbers )
+		expect( Linguistics::EN ).to have_extension( :numbers )
 	end
 
+
 	describe "numbers to words" do
 
 		it "can transform 0 into english words" do
-			"0".en.numwords.should == "zero"
+			expect( "0".en.numwords ).to eq( "zero" )
 		end
 
 		it "can transform 0 into english words in single-digit groups" do
-			"0".en.numwords( :group => 1 ).should == "zero"
+			expect( "0".en.numwords(group: 1) ).to eq( "zero" )
 		end
 
 		it "can transform 0 into english words in double-digit groups" do
-			"0".en.numwords( :group => 2 ).should == "zero"
+			expect( "0".en.numwords(group: 2) ).to eq( "zero" )
 		end
 
 		it "can transform 0 into english words in triple-digit groups" do
-			"0".en.numwords( :group => 3 ).should == "zero"
+			expect( "0".en.numwords(group: 3) ).to eq( "zero" )
 		end
 
 
 		it "can transform the english words for 0 into an ordinal" do
-			"0".en.numwords.en.ordinal.should.should == "zeroth"
+			expect( "0".en.numwords.en.ordinal ).to eq( "zeroth" )
 		end
 
 
 		it "can transform 1 into english words" do
-			"1".en.numwords.should == "one"
+			expect( "1".en.numwords ).to eq( "one" )
 		end
 
 		it "can transform 1 into english words in single-digit groups" do
-			"1".en.numwords( :group => 1 ).should == "one"
+			expect( "1".en.numwords(group: 1) ).to eq( "one" )
 		end
 
 		it "can transform 1 into english words in double-digit groups" do
-			"1".en.numwords( :group => 2 ).should == "one"
+			expect( "1".en.numwords(group: 2) ).to eq( "one" )
 		end
 
 		it "can transform 1 into english words in triple-digit groups" do
-			"1".en.numwords( :group => 3 ).should == "one"
+			expect( "1".en.numwords(group: 3) ).to eq( "one" )
 		end
 
 
 		it "can transform the english words for 1 into an ordinal" do
-			"1".en.numwords.en.ordinal.should == "first"
+			expect( "1".en.numwords.en.ordinal ).to eq( "first" )
 		end
 
 
 		it "can transform 2 into english words" do
-			"2".en.numwords.should == "two"
+			expect( "2".en.numwords ).to eq( "two" )
 		end
 
 		it "can transform 2 into english words in single-digit groups" do
-			"2".en.numwords( :group => 1 ).should == "two"
+			expect( "2".en.numwords(group: 1) ).to eq( "two" )
 		end
 
 		it "can transform 2 into english words in double-digit groups" do
-			"2".en.numwords( :group => 2 ).should == "two"
+			expect( "2".en.numwords(group: 2) ).to eq( "two" )
 		end
 
 		it "can transform 2 into english words in triple-digit groups" do
-			"2".en.numwords( :group => 3 ).should == "two"
+			expect( "2".en.numwords(group: 3) ).to eq( "two" )
 		end
 
 
 		it "can transform the english words for 2 into an ordinal" do
-			"2".en.numwords.en.ordinal.should == "second"
+			expect( "2".en.numwords.en.ordinal ).to eq( "second" )
 		end
 
 
 		it "can transform 3 into english words" do
-			"3".en.numwords.should == "three"
+			expect( "3".en.numwords ).to eq( "three" )
 		end
 
 		it "can transform 3 into english words in single-digit groups" do
-			"3".en.numwords( :group => 1 ).should == "three"
+			expect( "3".en.numwords(group: 1) ).to eq( "three" )
 		end
 
 		it "can transform 3 into english words in double-digit groups" do
-			"3".en.numwords( :group => 2 ).should == "three"
+			expect( "3".en.numwords(group: 2) ).to eq( "three" )
 		end
 
 		it "can transform 3 into english words in triple-digit groups" do
-			"3".en.numwords( :group => 3 ).should == "three"
+			expect( "3".en.numwords(group: 3) ).to eq( "three" )
 		end
 
 
 		it "can transform the english words for 3 into an ordinal" do
-			"3".en.numwords.en.ordinal.should == "third"
+			expect( "3".en.numwords.en.ordinal ).to eq( "third" )
 		end
 
 
 		it "can transform 4 into english words" do
-			"4".en.numwords.should == "four"
+			expect( "4".en.numwords ).to eq( "four" )
 		end
 
 		it "can transform 4 into english words in single-digit groups" do
-			"4".en.numwords( :group => 1 ).should == "four"
+			expect( "4".en.numwords(group: 1) ).to eq( "four" )
 		end
 
 		it "can transform 4 into english words in double-digit groups" do
-			"4".en.numwords( :group => 2 ).should == "four"
+			expect( "4".en.numwords(group: 2) ).to eq( "four" )
 		end
 
 		it "can transform 4 into english words in triple-digit groups" do
-			"4".en.numwords( :group => 3 ).should == "four"
+			expect( "4".en.numwords(group: 3) ).to eq( "four" )
 		end
 
 
 		it "can transform the english words for 4 into an ordinal" do
-			"4".en.numwords.en.ordinal.should == "fourth"
+			expect( "4".en.numwords.en.ordinal ).to eq( "fourth" )
 		end
 
 
 		it "can transform 5 into english words" do
-			"5".en.numwords.should == "five"
+			expect( "5".en.numwords ).to eq( "five" )
 		end
 
 		it "can transform 5 into english words in single-digit groups" do
-			"5".en.numwords( :group => 1 ).should == "five"
+			expect( "5".en.numwords(group: 1) ).to eq( "five" )
 		end
 
 		it "can transform 5 into english words in double-digit groups" do
-			"5".en.numwords( :group => 2 ).should == "five"
+			expect( "5".en.numwords(group: 2) ).to eq( "five" )
 		end
 
 		it "can transform 5 into english words in triple-digit groups" do
-			"5".en.numwords( :group => 3 ).should == "five"
+			expect( "5".en.numwords(group: 3) ).to eq( "five" )
 		end
 
 
 		it "can transform the english words for 5 into an ordinal" do
-			"5".en.numwords.en.ordinal.should == "fifth"
+			expect( "5".en.numwords.en.ordinal ).to eq( "fifth" )
 		end
 
 
 		it "can transform 6 into english words" do
-			"6".en.numwords.should == "six"
+			expect( "6".en.numwords ).to eq( "six" )
 		end
 
 		it "can transform 6 into english words in single-digit groups" do
-			"6".en.numwords( :group => 1 ).should == "six"
+			expect( "6".en.numwords(group: 1) ).to eq( "six" )
 		end
 
 		it "can transform 6 into english words in double-digit groups" do
-			"6".en.numwords( :group => 2 ).should == "six"
+			expect( "6".en.numwords(group: 2) ).to eq( "six" )
 		end
 
 		it "can transform 6 into english words in triple-digit groups" do
-			"6".en.numwords( :group => 3 ).should == "six"
+			expect( "6".en.numwords(group: 3) ).to eq( "six" )
 		end
 
 
 		it "can transform the english words for 6 into an ordinal" do
-			"6".en.numwords.en.ordinal.should == "sixth"
+			expect( "6".en.numwords.en.ordinal ).to eq( "sixth" )
 		end
 
 
 		it "can transform 7 into english words" do
-			"7".en.numwords.should == "seven"
+			expect( "7".en.numwords ).to eq( "seven" )
 		end
 
 		it "can transform 7 into english words in single-digit groups" do
-			"7".en.numwords( :group => 1 ).should == "seven"
+			expect( "7".en.numwords(group: 1) ).to eq( "seven" )
 		end
 
 		it "can transform 7 into english words in double-digit groups" do
-			"7".en.numwords( :group => 2 ).should == "seven"
+			expect( "7".en.numwords(group: 2) ).to eq( "seven" )
 		end
 
 		it "can transform 7 into english words in triple-digit groups" do
-			"7".en.numwords( :group => 3 ).should == "seven"
+			expect( "7".en.numwords(group: 3) ).to eq( "seven" )
 		end
 
 
 		it "can transform the english words for 7 into an ordinal" do
-			"7".en.numwords.en.ordinal.should == "seventh"
+			expect( "7".en.numwords.en.ordinal ).to eq( "seventh" )
 		end
 
 
 		it "can transform 8 into english words" do
-			"8".en.numwords.should == "eight"
+			expect( "8".en.numwords ).to eq( "eight" )
 		end
 
 		it "can transform 8 into english words in single-digit groups" do
-			"8".en.numwords( :group => 1 ).should == "eight"
+			expect( "8".en.numwords(group: 1) ).to eq( "eight" )
 		end
 
 		it "can transform 8 into english words in double-digit groups" do
-			"8".en.numwords( :group => 2 ).should == "eight"
+			expect( "8".en.numwords(group: 2) ).to eq( "eight" )
 		end
 
 		it "can transform 8 into english words in triple-digit groups" do
-			"8".en.numwords( :group => 3 ).should == "eight"
+			expect( "8".en.numwords(group: 3) ).to eq( "eight" )
 		end
 
 
 		it "can transform the english words for 8 into an ordinal" do
-			"8".en.numwords.en.ordinal.should == "eighth"
+			expect( "8".en.numwords.en.ordinal ).to eq( "eighth" )
 		end
 
 
 		it "can transform 9 into english words" do
-			"9".en.numwords.should == "nine"
+			expect( "9".en.numwords ).to eq( "nine" )
 		end
 
 		it "can transform 9 into english words in single-digit groups" do
-			"9".en.numwords( :group => 1 ).should == "nine"
+			expect( "9".en.numwords(group: 1) ).to eq( "nine" )
 		end
 
 		it "can transform 9 into english words in double-digit groups" do
-			"9".en.numwords( :group => 2 ).should == "nine"
+			expect( "9".en.numwords(group: 2) ).to eq( "nine" )
 		end
 
 		it "can transform 9 into english words in triple-digit groups" do
-			"9".en.numwords( :group => 3 ).should == "nine"
+			expect( "9".en.numwords(group: 3) ).to eq( "nine" )
 		end
 
 
 		it "can transform the english words for 9 into an ordinal" do
-			"9".en.numwords.en.ordinal.should == "ninth"
+			expect( "9".en.numwords.en.ordinal ).to eq( "ninth" )
 		end
 
 
 		it "can transform 10 into english words" do
-			"10".en.numwords.should == "ten"
+			expect( "10".en.numwords ).to eq( "ten" )
 		end
 
 		it "can transform 10 into english words in single-digit groups" do
-			"10".en.numwords( :group => 1 ).should == "one, zero"
+			expect( "10".en.numwords(group: 1) ).to eq( "one, zero" )
 		end
 
 		it "can transform 10 into english words in double-digit groups" do
-			"10".en.numwords( :group => 2 ).should == "ten"
+			expect( "10".en.numwords(group: 2) ).to eq( "ten" )
 		end
 
 		it "can transform 10 into english words in triple-digit groups" do
-			"10".en.numwords( :group => 3 ).should == "ten"
+			expect( "10".en.numwords(group: 3) ).to eq( "ten" )
 		end
 
 
 		it "can transform the english words for 10 into an ordinal" do
-			"10".en.numwords.en.ordinal.should == "tenth"
+			expect( "10".en.numwords.en.ordinal ).to eq( "tenth" )
 		end
 
 
 		it "can transform 11 into english words" do
-			"11".en.numwords.should == "eleven"
+			expect( "11".en.numwords ).to eq( "eleven" )
 		end
 
 		it "can transform 11 into english words in single-digit groups" do
-			"11".en.numwords( :group => 1 ).should == "one, one"
+			expect( "11".en.numwords(group: 1) ).to eq( "one, one" )
 		end
 
 		it "can transform 11 into english words in double-digit groups" do
-			"11".en.numwords( :group => 2 ).should == "eleven"
+			expect( "11".en.numwords(group: 2) ).to eq( "eleven" )
 		end
 
 		it "can transform 11 into english words in triple-digit groups" do
-			"11".en.numwords( :group => 3 ).should == "eleven"
+			expect( "11".en.numwords(group: 3) ).to eq( "eleven" )
 		end
 
 
 		it "can transform the english words for 11 into an ordinal" do
-			"11".en.numwords.en.ordinal.should == "eleventh"
+			expect( "11".en.numwords.en.ordinal ).to eq( "eleventh" )
 		end
 
 
 		it "can transform 12 into english words" do
-			"12".en.numwords.should == "twelve"
+			expect( "12".en.numwords ).to eq( "twelve" )
 		end
 
 		it "can transform 12 into english words in single-digit groups" do
-			"12".en.numwords( :group => 1 ).should == "one, two"
+			expect( "12".en.numwords(group: 1) ).to eq( "one, two" )
 		end
 
 		it "can transform 12 into english words in double-digit groups" do
-			"12".en.numwords( :group => 2 ).should == "twelve"
+			expect( "12".en.numwords(group: 2) ).to eq( "twelve" )
 		end
 
 		it "can transform 12 into english words in triple-digit groups" do
-			"12".en.numwords( :group => 3 ).should == "twelve"
+			expect( "12".en.numwords(group: 3) ).to eq( "twelve" )
 		end
 
 
 		it "can transform the english words for 12 into an ordinal" do
-			"12".en.numwords.en.ordinal.should == "twelfth"
+			expect( "12".en.numwords.en.ordinal ).to eq( "twelfth" )
 		end
 
 
 		it "can transform 13 into english words" do
-			"13".en.numwords.should == "thirteen"
+			expect( "13".en.numwords ).to eq( "thirteen" )
 		end
 
 		it "can transform 13 into english words in single-digit groups" do
-			"13".en.numwords( :group => 1 ).should == "one, three"
+			expect( "13".en.numwords(group: 1) ).to eq( "one, three" )
 		end
 
 		it "can transform 13 into english words in double-digit groups" do
-			"13".en.numwords( :group => 2 ).should == "thirteen"
+			expect( "13".en.numwords(group: 2) ).to eq( "thirteen" )
 		end
 
 		it "can transform 13 into english words in triple-digit groups" do
-			"13".en.numwords( :group => 3 ).should == "thirteen"
+			expect( "13".en.numwords(group: 3) ).to eq( "thirteen" )
 		end
 
 
 		it "can transform the english words for 13 into an ordinal" do
-			"13".en.numwords.en.ordinal.should == "thirteenth"
+			expect( "13".en.numwords.en.ordinal ).to eq( "thirteenth" )
 		end
 
 
 		it "can transform 14 into english words" do
-			"14".en.numwords.should == "fourteen"
+			expect( "14".en.numwords ).to eq( "fourteen" )
 		end
 
 		it "can transform 14 into english words in single-digit groups" do
-			"14".en.numwords( :group => 1 ).should == "one, four"
+			expect( "14".en.numwords(group: 1) ).to eq( "one, four" )
 		end
 
 		it "can transform 14 into english words in double-digit groups" do
-			"14".en.numwords( :group => 2 ).should == "fourteen"
+			expect( "14".en.numwords(group: 2) ).to eq( "fourteen" )
 		end
 
 		it "can transform 14 into english words in triple-digit groups" do
-			"14".en.numwords( :group => 3 ).should == "fourteen"
+			expect( "14".en.numwords(group: 3) ).to eq( "fourteen" )
 		end
 
 
 		it "can transform the english words for 14 into an ordinal" do
-			"14".en.numwords.en.ordinal.should == "fourteenth"
+			expect( "14".en.numwords.en.ordinal ).to eq( "fourteenth" )
 		end
 
 
 		it "can transform 15 into english words" do
-			"15".en.numwords.should == "fifteen"
+			expect( "15".en.numwords ).to eq( "fifteen" )
 		end
 
 		it "can transform 15 into english words in single-digit groups" do
-			"15".en.numwords( :group => 1 ).should == "one, five"
+			expect( "15".en.numwords(group: 1) ).to eq( "one, five" )
 		end
 
 		it "can transform 15 into english words in double-digit groups" do
-			"15".en.numwords( :group => 2 ).should == "fifteen"
+			expect( "15".en.numwords(group: 2) ).to eq( "fifteen" )
 		end
 
 		it "can transform 15 into english words in triple-digit groups" do
-			"15".en.numwords( :group => 3 ).should == "fifteen"
+			expect( "15".en.numwords(group: 3) ).to eq( "fifteen" )
 		end
 
 
 		it "can transform the english words for 15 into an ordinal" do
-			"15".en.numwords.en.ordinal.should == "fifteenth"
+			expect( "15".en.numwords.en.ordinal ).to eq( "fifteenth" )
 		end
 
 
 		it "can transform 16 into english words" do
-			"16".en.numwords.should == "sixteen"
+			expect( "16".en.numwords ).to eq( "sixteen" )
 		end
 
 		it "can transform 16 into english words in single-digit groups" do
-			"16".en.numwords( :group => 1 ).should == "one, six"
+			expect( "16".en.numwords(group: 1) ).to eq( "one, six" )
 		end
 
 		it "can transform 16 into english words in double-digit groups" do
-			"16".en.numwords( :group => 2 ).should == "sixteen"
+			expect( "16".en.numwords(group: 2) ).to eq( "sixteen" )
 		end
 
 		it "can transform 16 into english words in triple-digit groups" do
-			"16".en.numwords( :group => 3 ).should == "sixteen"
+			expect( "16".en.numwords(group: 3) ).to eq( "sixteen" )
 		end
 
 
 		it "can transform the english words for 16 into an ordinal" do
-			"16".en.numwords.en.ordinal.should == "sixteenth"
+			expect( "16".en.numwords.en.ordinal ).to eq( "sixteenth" )
 		end
 
 
 		it "can transform 17 into english words" do
-			"17".en.numwords.should == "seventeen"
+			expect( "17".en.numwords ).to eq( "seventeen" )
 		end
 
 		it "can transform 17 into english words in single-digit groups" do
-			"17".en.numwords( :group => 1 ).should == "one, seven"
+			expect( "17".en.numwords(group: 1) ).to eq( "one, seven" )
 		end
 
 		it "can transform 17 into english words in double-digit groups" do
-			"17".en.numwords( :group => 2 ).should == "seventeen"
+			expect( "17".en.numwords(group: 2) ).to eq( "seventeen" )
 		end
 
 		it "can transform 17 into english words in triple-digit groups" do
-			"17".en.numwords( :group => 3 ).should == "seventeen"
+			expect( "17".en.numwords(group: 3) ).to eq( "seventeen" )
 		end
 
 
 		it "can transform the english words for 17 into an ordinal" do
-			"17".en.numwords.en.ordinal.should == "seventeenth"
+			expect( "17".en.numwords.en.ordinal ).to eq( "seventeenth" )
 		end
 
 
 		it "can transform 18 into english words" do
-			"18".en.numwords.should == "eighteen"
+			expect( "18".en.numwords ).to eq( "eighteen" )
 		end
 
 		it "can transform 18 into english words in single-digit groups" do
-			"18".en.numwords( :group => 1 ).should == "one, eight"
+			expect( "18".en.numwords(group: 1) ).to eq( "one, eight" )
 		end
 
 		it "can transform 18 into english words in double-digit groups" do
-			"18".en.numwords( :group => 2 ).should == "eighteen"
+			expect( "18".en.numwords(group: 2) ).to eq( "eighteen" )
 		end
 
 		it "can transform 18 into english words in triple-digit groups" do
-			"18".en.numwords( :group => 3 ).should == "eighteen"
+			expect( "18".en.numwords(group: 3) ).to eq( "eighteen" )
 		end
 
 
 		it "can transform the english words for 18 into an ordinal" do
-			"18".en.numwords.en.ordinal.should == "eighteenth"
+			expect( "18".en.numwords.en.ordinal ).to eq( "eighteenth" )
 		end
 
 
 		it "can transform 19 into english words" do
-			"19".en.numwords.should == "nineteen"
+			expect( "19".en.numwords ).to eq( "nineteen" )
 		end
 
 		it "can transform 19 into english words in single-digit groups" do
-			"19".en.numwords( :group => 1 ).should == "one, nine"
+			expect( "19".en.numwords(group: 1) ).to eq( "one, nine" )
 		end
 
 		it "can transform 19 into english words in double-digit groups" do
-			"19".en.numwords( :group => 2 ).should == "nineteen"
+			expect( "19".en.numwords(group: 2) ).to eq( "nineteen" )
 		end
 
 		it "can transform 19 into english words in triple-digit groups" do
-			"19".en.numwords( :group => 3 ).should == "nineteen"
+			expect( "19".en.numwords(group: 3) ).to eq( "nineteen" )
 		end
 
 
 		it "can transform the english words for 19 into an ordinal" do
-			"19".en.numwords.en.ordinal.should == "nineteenth"
+			expect( "19".en.numwords.en.ordinal ).to eq( "nineteenth" )
 		end
 
 
 		it "can transform 20 into english words" do
-			"20".en.numwords.should == "twenty"
+			expect( "20".en.numwords ).to eq( "twenty" )
 		end
 
 		it "can transform 20 into english words in single-digit groups" do
-			"20".en.numwords( :group => 1 ).should == "two, zero"
+			expect( "20".en.numwords(group: 1) ).to eq( "two, zero" )
 		end
 
 		it "can transform 20 into english words in double-digit groups" do
-			"20".en.numwords( :group => 2 ).should == "twenty"
+			expect( "20".en.numwords(group: 2) ).to eq( "twenty" )
 		end
 
 		it "can transform 20 into english words in triple-digit groups" do
-			"20".en.numwords( :group => 3 ).should == "twenty"
+			expect( "20".en.numwords(group: 3) ).to eq( "twenty" )
 		end
 
 
 		it "can transform the english words for 20 into an ordinal" do
-			"20".en.numwords.en.ordinal.should == "twentieth"
+			expect( "20".en.numwords.en.ordinal ).to eq( "twentieth" )
 		end
 
 
 		it "can transform 21 into english words" do
-			"21".en.numwords.should == "twenty-one"
+			expect( "21".en.numwords ).to eq( "twenty-one" )
 		end
 
 		it "can transform 21 into english words in single-digit groups" do
-			"21".en.numwords( :group => 1 ).should == "two, one"
+			expect( "21".en.numwords(group: 1) ).to eq( "two, one" )
 		end
 
 		it "can transform 21 into english words in double-digit groups" do
-			"21".en.numwords( :group => 2 ).should == "twenty-one"
+			expect( "21".en.numwords(group: 2) ).to eq( "twenty-one" )
 		end
 
 		it "can transform 21 into english words in triple-digit groups" do
-			"21".en.numwords( :group => 3 ).should == "twenty-one"
+			expect( "21".en.numwords(group: 3) ).to eq( "twenty-one" )
 		end
 
 
 		it "can transform the english words for 21 into an ordinal" do
-			"21".en.numwords.en.ordinal.should == "twenty-first"
+			expect( "21".en.numwords.en.ordinal ).to eq( "twenty-first" )
 		end
 
 
 		it "can transform 29 into english words" do
-			"29".en.numwords.should == "twenty-nine"
+			expect( "29".en.numwords ).to eq( "twenty-nine" )
 		end
 
 		it "can transform 29 into english words in single-digit groups" do
-			"29".en.numwords( :group => 1 ).should == "two, nine"
+			expect( "29".en.numwords(group: 1) ).to eq( "two, nine" )
 		end
 
 		it "can transform 29 into english words in double-digit groups" do
-			"29".en.numwords( :group => 2 ).should == "twenty-nine"
+			expect( "29".en.numwords(group: 2) ).to eq( "twenty-nine" )
 		end
 
 		it "can transform 29 into english words in triple-digit groups" do
-			"29".en.numwords( :group => 3 ).should == "twenty-nine"
+			expect( "29".en.numwords(group: 3) ).to eq( "twenty-nine" )
 		end
 
 
 		it "can transform the english words for 29 into an ordinal" do
-			"29".en.numwords.en.ordinal.should == "twenty-ninth"
+			expect( "29".en.numwords.en.ordinal ).to eq( "twenty-ninth" )
 		end
 
 
 		it "can transform 99 into english words" do
-			"99".en.numwords.should == "ninety-nine"
+			expect( "99".en.numwords ).to eq( "ninety-nine" )
 		end
 
 		it "can transform 99 into english words in single-digit groups" do
-			"99".en.numwords( :group => 1 ).should == "nine, nine"
+			expect( "99".en.numwords(group: 1) ).to eq( "nine, nine" )
 		end
 
 		it "can transform 99 into english words in double-digit groups" do
-			"99".en.numwords( :group => 2 ).should == "ninety-nine"
+			expect( "99".en.numwords(group: 2) ).to eq( "ninety-nine" )
 		end
 
 		it "can transform 99 into english words in triple-digit groups" do
-			"99".en.numwords( :group => 3 ).should == "ninety-nine"
+			expect( "99".en.numwords(group: 3) ).to eq( "ninety-nine" )
 		end
 
 
 		it "can transform the english words for 99 into an ordinal" do
-			"99".en.numwords.en.ordinal.should == "ninety-ninth"
+			expect( "99".en.numwords.en.ordinal ).to eq( "ninety-ninth" )
 		end
 
 
 		it "can transform 100 into english words" do
-			"100".en.numwords.should == "one hundred"
+			expect( "100".en.numwords ).to eq( "one hundred" )
 		end
 
 		it "can transform 100 into english words in single-digit groups" do
-			"100".en.numwords( :group => 1 ).should == "one, zero, zero"
+			expect( "100".en.numwords(group: 1) ).to eq( "one, zero, zero" )
 		end
 
 		it "can transform 100 into english words in double-digit groups" do
-			"100".en.numwords( :group => 2 ).should == "ten, zero"
+			expect( "100".en.numwords(group: 2) ).to eq( "ten, zero" )
 		end
 
 		it "can transform 100 into english words in triple-digit groups" do
-			"100".en.numwords( :group => 3 ).should == "one zero zero"
+			expect( "100".en.numwords(group: 3) ).to eq( "one zero zero" )
 		end
 
 
 		it "can transform the english words for 100 into an ordinal" do
-			"100".en.numwords.en.ordinal.should == "one hundredth"
+			expect( "100".en.numwords.en.ordinal ).to eq( "one hundredth" )
 		end
 
 
 		it "can transform 101 into english words" do
-			"101".en.numwords.should == "one hundred and one"
+			expect( "101".en.numwords ).to eq( "one hundred and one" )
 		end
 
 		it "can transform 101 into english words in single-digit groups" do
-			"101".en.numwords( :group => 1 ).should == "one, zero, one"
+			expect( "101".en.numwords(group: 1) ).to eq( "one, zero, one" )
 		end
 
 		it "can transform 101 into english words in double-digit groups" do
-			"101".en.numwords( :group => 2 ).should == "ten, one"
+			expect( "101".en.numwords(group: 2) ).to eq( "ten, one" )
 		end
 
 		it "can transform 101 into english words in triple-digit groups" do
-			"101".en.numwords( :group => 3 ).should == "one zero one"
+			expect( "101".en.numwords(group: 3) ).to eq( "one zero one" )
 		end
 
 
 		it "can transform the english words for 101 into an ordinal" do
-			"101".en.numwords.en.ordinal.should == "one hundred and first"
+			expect( "101".en.numwords.en.ordinal ).to eq( "one hundred and first" )
 		end
 
 		it "can transform the english words for 101 into an ordinal" do
-			"101".en.numwords.en.ordinal.should == "one hundred and first"
+			expect( "101".en.numwords.en.ordinal ).to eq( "one hundred and first" )
 		end
 
 
 		it "can transform 110 into english words" do
-			"110".en.numwords.should == "one hundred and ten"
+			expect( "110".en.numwords ).to eq( "one hundred and ten" )
 		end
 
 		it "can transform 110 into english words in single-digit groups" do
-			"110".en.numwords( :group => 1 ).should == "one, one, zero"
+			expect( "110".en.numwords(group: 1) ).to eq( "one, one, zero" )
 		end
 
 		it "can transform 110 into english words in double-digit groups" do
-			"110".en.numwords( :group => 2 ).should == "eleven, zero"
+			expect( "110".en.numwords(group: 2) ).to eq( "eleven, zero" )
 		end
 
 		it "can transform 110 into english words in triple-digit groups" do
-			"110".en.numwords( :group => 3 ).should == "one ten"
+			expect( "110".en.numwords(group: 3) ).to eq( "one ten" )
 		end
 
 
 		it "can transform the english words for 110 into an ordinal" do
-			"110".en.numwords.en.ordinal.should == "one hundred and tenth"
+			expect( "110".en.numwords.en.ordinal ).to eq( "one hundred and tenth" )
 		end
 
 
 		it "can transform 111 into english words" do
-			"111".en.numwords.should == "one hundred and eleven"
+			expect( "111".en.numwords ).to eq( "one hundred and eleven" )
 		end
 
 		it "can transform 111 into english words in single-digit groups" do
-			"111".en.numwords( :group => 1 ).should == "one, one, one"
+			expect( "111".en.numwords(group: 1) ).to eq( "one, one, one" )
 		end
 
 		it "can transform 111 into english words in double-digit groups" do
-			"111".en.numwords( :group => 2 ).should == "eleven, one"
+			expect( "111".en.numwords(group: 2) ).to eq( "eleven, one" )
 		end
 
 		it "can transform 111 into english words in triple-digit groups" do
-			"111".en.numwords( :group => 3 ).should == "one eleven"
+			expect( "111".en.numwords(group: 3) ).to eq( "one eleven" )
 		end
 
 
 		it "can transform the english words for 111 into an ordinal" do
-			"111".en.numwords.en.ordinal.should == "one hundred and eleventh"
+			expect( "111".en.numwords.en.ordinal ).to eq( "one hundred and eleventh" )
 		end
 
 
 		it "can transform 900 into english words" do
-			"900".en.numwords.should == "nine hundred"
+			expect( "900".en.numwords ).to eq( "nine hundred" )
 		end
 
 		it "can transform 900 into english words in single-digit groups" do
-			"900".en.numwords( :group => 1 ).should == "nine, zero, zero"
+			expect( "900".en.numwords(group: 1) ).to eq( "nine, zero, zero" )
 		end
 
 		it "can transform 900 into english words in double-digit groups" do
-			"900".en.numwords( :group => 2 ).should == "ninety, zero"
+			expect( "900".en.numwords(group: 2) ).to eq( "ninety, zero" )
 		end
 
 		it "can transform 900 into english words in triple-digit groups" do
-			"900".en.numwords( :group => 3 ).should == "nine zero zero"
+			expect( "900".en.numwords(group: 3) ).to eq( "nine zero zero" )
 		end
 
 
 		it "can transform the english words for 900 into an ordinal" do
-			"900".en.numwords.en.ordinal.should == "nine hundredth"
+			expect( "900".en.numwords.en.ordinal ).to eq( "nine hundredth" )
 		end
 
 
 		it "can transform 999 into english words" do
-			"999".en.numwords.should == "nine hundred and ninety-nine"
+			expect( "999".en.numwords ).to eq( "nine hundred and ninety-nine" )
 		end
 
 		it "can transform 999 into english words in single-digit groups" do
-			"999".en.numwords( :group => 1 ).should == "nine, nine, nine"
+			expect( "999".en.numwords(group: 1) ).to eq( "nine, nine, nine" )
 		end
 
 		it "can transform 999 into english words in double-digit groups" do
-			"999".en.numwords( :group => 2 ).should == "ninety-nine, nine"
+			expect( "999".en.numwords(group: 2) ).to eq( "ninety-nine, nine" )
 		end
 
 		it "can transform 999 into english words in triple-digit groups" do
-			"999".en.numwords( :group => 3 ).should == "nine ninety-nine"
+			expect( "999".en.numwords(group: 3) ).to eq( "nine ninety-nine" )
 		end
 
 
 		it "can transform the english words for 999 into an ordinal" do
-			"999".en.numwords.en.ordinal.should == "nine hundred and ninety-ninth"
+			expect( "999".en.numwords.en.ordinal ).to eq( "nine hundred and ninety-ninth" )
 		end
 
 
 		it "can transform 1000 into english words" do
-			"1000".en.numwords.should == "one thousand"
+			expect( "1000".en.numwords ).to eq( "one thousand" )
 		end
 
 		it "can transform 1000 into english words in single-digit groups" do
-			"1000".en.numwords( :group => 1 ).should == "one, zero, zero, zero"
+			expect( "1000".en.numwords(group: 1) ).to eq( "one, zero, zero, zero" )
 		end
 
 		it "can transform 1000 into english words in double-digit groups" do
-			"1000".en.numwords( :group => 2 ).should == "ten, zero zero"
+			expect( "1000".en.numwords(group: 2) ).to eq( "ten, zero zero" )
 		end
 
 		it "can transform 1000 into english words in triple-digit groups" do
-			"1000".en.numwords( :group => 3 ).should == "one zero zero, zero"
+			expect( "1000".en.numwords(group: 3) ).to eq( "one zero zero, zero" )
 		end
 
 
 		it "can transform the english words for 1000 into an ordinal" do
-			"1000".en.numwords.en.ordinal.should == "one thousandth"
+			expect( "1000".en.numwords.en.ordinal ).to eq( "one thousandth" )
 		end
 
 
 		it "can transform 1001 into english words" do
-			"1001".en.numwords.should == "one thousand and one"
+			expect( "1001".en.numwords ).to eq( "one thousand and one" )
 		end
 
 		it "can transform 1001 into english words in single-digit groups" do
-			"1001".en.numwords( :group => 1 ).should == "one, zero, zero, one"
+			expect( "1001".en.numwords(group: 1) ).to eq( "one, zero, zero, one" )
 		end
 
 		it "can transform 1001 into english words in double-digit groups" do
-			"1001".en.numwords( :group => 2 ).should == "ten, zero one"
+			expect( "1001".en.numwords(group: 2) ).to eq( "ten, zero one" )
 		end
 
 		it "can transform 1001 into english words in triple-digit groups" do
-			"1001".en.numwords( :group => 3 ).should == "one zero zero, one"
+			expect( "1001".en.numwords(group: 3) ).to eq( "one zero zero, one" )
 		end
 
 
 		it "can transform the english words for 1001 into an ordinal" do
-			"1001".en.numwords.en.ordinal.should == "one thousand and first"
+			expect( "1001".en.numwords.en.ordinal ).to eq( "one thousand and first" )
 		end
 
 
 		it "can transform 1010 into english words" do
-			"1010".en.numwords.should == "one thousand and ten"
+			expect( "1010".en.numwords ).to eq( "one thousand and ten" )
 		end
 
 		it "can transform 1010 into english words in single-digit groups" do
-			"1010".en.numwords( :group => 1 ).should == "one, zero, one, zero"
+			expect( "1010".en.numwords(group: 1) ).to eq( "one, zero, one, zero" )
 		end
 
 		it "can transform 1010 into english words in double-digit groups" do
-			"1010".en.numwords( :group => 2 ).should == "ten, ten"
+			expect( "1010".en.numwords(group: 2) ).to eq( "ten, ten" )
 		end
 
 		it "can transform 1010 into english words in triple-digit groups" do
-			"1010".en.numwords( :group => 3 ).should == "one zero one, zero"
+			expect( "1010".en.numwords(group: 3) ).to eq( "one zero one, zero" )
 		end
 
 
 		it "can transform the english words for 1010 into an ordinal" do
-			"1010".en.numwords.en.ordinal.should == "one thousand and tenth"
+			expect( "1010".en.numwords.en.ordinal ).to eq( "one thousand and tenth" )
 		end
 
 
 		it "can transform 1100 into english words" do
-			"1100".en.numwords.should == "one thousand, one hundred"
+			expect( "1100".en.numwords ).to eq( "one thousand, one hundred" )
 		end
 
 		it "can transform 1100 into english words in single-digit groups" do
-			"1100".en.numwords( :group => 1 ).should == "one, one, zero, zero"
+			expect( "1100".en.numwords(group: 1) ).to eq( "one, one, zero, zero" )
 		end
 
 		it "can transform 1100 into english words in double-digit groups" do
-			"1100".en.numwords( :group => 2 ).should == "eleven, zero zero"
+			expect( "1100".en.numwords(group: 2) ).to eq( "eleven, zero zero" )
 		end
 
 		it "can transform 1100 into english words in triple-digit groups" do
-			"1100".en.numwords( :group => 3 ).should == "one ten, zero"
+			expect( "1100".en.numwords(group: 3) ).to eq( "one ten, zero" )
 		end
 
 
 		it "can transform the english words for 1100 into an ordinal" do
-			"1100".en.numwords.en.ordinal.should == "one thousand, one hundredth"
+			expect( "1100".en.numwords.en.ordinal ).to eq( "one thousand, one hundredth" )
 		end
 
 
 		it "can transform 2000 into english words" do
-			"2000".en.numwords.should == "two thousand"
+			expect( "2000".en.numwords ).to eq( "two thousand" )
 		end
 
 		it "can transform 2000 into english words in single-digit groups" do
-			"2000".en.numwords( :group => 1 ).should == "two, zero, zero, zero"
+			expect( "2000".en.numwords(group: 1) ).to eq( "two, zero, zero, zero" )
 		end
 
 		it "can transform 2000 into english words in double-digit groups" do
-			"2000".en.numwords( :group => 2 ).should == "twenty, zero zero"
+			expect( "2000".en.numwords(group: 2) ).to eq( "twenty, zero zero" )
 		end
 
 		it "can transform 2000 into english words in triple-digit groups" do
-			"2000".en.numwords( :group => 3 ).should == "two zero zero, zero"
+			expect( "2000".en.numwords(group: 3) ).to eq( "two zero zero, zero" )
 		end
 
 
 		it "can transform the english words for 2000 into an ordinal" do
-			"2000".en.numwords.en.ordinal.should == "two thousandth"
+			expect( "2000".en.numwords.en.ordinal ).to eq( "two thousandth" )
 		end
 
 
 		it "can transform 10000 into english words" do
-			"10000".en.numwords.should == "ten thousand"
+			expect( "10000".en.numwords ).to eq( "ten thousand" )
 		end
 
 		it "can transform 10000 into english words in single-digit groups" do
-			"10000".en.numwords( :group => 1 ).should == "one, zero, zero, zero, zero"
+			expect( "10000".en.numwords(group: 1) ).to eq( "one, zero, zero, zero, zero" )
 		end
 
 		it "can transform 10000 into english words in double-digit groups" do
-			"10000".en.numwords( :group => 2 ).should == "ten, zero zero, zero"
+			expect( "10000".en.numwords(group: 2) ).to eq( "ten, zero zero, zero" )
 		end
 
 		it "can transform 10000 into english words in triple-digit groups" do
-			"10000".en.numwords( :group => 3 ).should == "one zero zero, zero zero"
+			expect( "10000".en.numwords(group: 3) ).to eq( "one zero zero, zero zero" )
 		end
 
 
 		it "can transform the english words for 10000 into an ordinal" do
-			"10000".en.numwords.en.ordinal.should == "ten thousandth"
+			expect( "10000".en.numwords.en.ordinal ).to eq( "ten thousandth" )
 		end
 
 
 		it "can transform 100000 into english words" do
-			"100000".en.numwords.should == "one hundred thousand"
+			expect( "100000".en.numwords ).to eq( "one hundred thousand" )
 		end
 
 		it "can transform 100000 into english words in single-digit groups" do
-			"100000".en.numwords( :group => 1 ).should == "one, zero, zero, zero, zero, zero"
+			expect( "100000".en.numwords(group: 1) ).to eq( "one, zero, zero, zero, zero, zero" )
 		end
 
 		it "can transform 100000 into english words in double-digit groups" do
-			"100000".en.numwords( :group => 2 ).should == "ten, zero zero, zero zero"
+			expect( "100000".en.numwords(group: 2) ).to eq( "ten, zero zero, zero zero" )
 		end
 
 		it "can transform 100000 into english words in triple-digit groups" do
-			"100000".en.numwords( :group => 3 ).should == "one zero zero, zero zero zero"
+			expect( "100000".en.numwords(group: 3) ).to eq( "one zero zero, zero zero zero" )
 		end
 
 
 		it "can transform the english words for 100000 into an ordinal" do
-			"100000".en.numwords.en.ordinal.should == "one hundred thousandth"
+			expect( "100000".en.numwords.en.ordinal ).to eq( "one hundred thousandth" )
 		end
 
 
 		it "can transform 100001 into english words" do
-			"100001".en.numwords.should == "one hundred thousand and one"
+			expect( "100001".en.numwords ).to eq( "one hundred thousand and one" )
 		end
 
 		it "can transform 100001 into english words in single-digit groups" do
-			"100001".en.numwords( :group => 1 ).should == "one, zero, zero, zero, zero, one"
+			expect( "100001".en.numwords(group: 1) ).to eq( "one, zero, zero, zero, zero, one" )
 		end
 
 		it "can transform 100001 into english words in double-digit groups" do
-			"100001".en.numwords( :group => 2 ).should == "ten, zero zero, zero one"
+			expect( "100001".en.numwords(group: 2) ).to eq( "ten, zero zero, zero one" )
 		end
 
 		it "can transform 100001 into english words in triple-digit groups" do
-			"100001".en.numwords( :group => 3 ).should == "one zero zero, zero zero one"
+			expect( "100001".en.numwords(group: 3) ).to eq( "one zero zero, zero zero one" )
 		end
 
 
 		it "can transform the english words for 100001 into an ordinal" do
-			"100001".en.numwords.en.ordinal.should == "one hundred thousand and first"
+			expect( "100001".en.numwords.en.ordinal ).to eq( "one hundred thousand and first" )
 		end
 
 
 		it "can transform 123456 into english words" do
-			"123456".en.numwords.should == "one hundred and twenty-three thousand, four hundred and fifty-six"
+			expect( "123456".en.numwords ).to eq( "one hundred and twenty-three thousand, four hundred and fifty-six" )
 		end
 
 		it "can transform 123456 into english words in single-digit groups" do
-			"123456".en.numwords( :group => 1 ).should == "one, two, three, four, five, six"
+			expect( "123456".en.numwords(group: 1) ).to eq( "one, two, three, four, five, six" )
 		end
 
 		it "can transform 123456 into english words in double-digit groups" do
-			"123456".en.numwords( :group => 2 ).should == "twelve, thirty-four, fifty-six"
+			expect( "123456".en.numwords(group: 2) ).to eq( "twelve, thirty-four, fifty-six" )
 		end
 
 		it "can transform 123456 into english words in triple-digit groups" do
-			"123456".en.numwords( :group => 3 ).should == "one twenty-three, four fifty-six"
+			expect( "123456".en.numwords(group: 3) ).to eq( "one twenty-three, four fifty-six" )
 		end
 
 
 		it "can transform the english words for 123456 into an ordinal" do
-			"123456".en.numwords.en.ordinal.should == "one hundred and twenty-three thousand, four hundred and fifty-sixth"
+			expect( "123456".en.numwords.en.ordinal ).to eq( "one hundred and twenty-three thousand, four hundred and fifty-sixth" )
 		end
 
 
 		it "can transform 0123456 into english words" do
-			"0123456".en.numwords.should == "one hundred and twenty-three thousand, four hundred and fifty-six"
+			expect( "0123456".en.numwords ).to eq( "one hundred and twenty-three thousand, four hundred and fifty-six" )
 		end
 
 		it "can transform 0123456 into english words in single-digit groups" do
-			"0123456".en.numwords( :group => 1 ).should == "zero, one, two, three, four, five, six"
+			expect( "0123456".en.numwords(group: 1) ).to eq( "zero, one, two, three, four, five, six" )
 		end
 
 		it "can transform 0123456 into english words in double-digit groups" do
-			"0123456".en.numwords( :group => 2 ).should == "zero one, twenty-three, forty-five, six"
+			expect( "0123456".en.numwords(group: 2) ).to eq( "zero one, twenty-three, forty-five, six" )
 		end
 
 		it "can transform 0123456 into english words in triple-digit groups" do
-			"0123456".en.numwords( :group => 3 ).should == "zero twelve, three forty-five, six"
+			expect( "0123456".en.numwords(group: 3) ).to eq( "zero twelve, three forty-five, six" )
 		end
 
 
 		it "can transform the english words for 0123456 into an ordinal" do
-			"0123456".en.numwords.en.ordinal.should == "one hundred and twenty-three thousand, four hundred and fifty-sixth"
+			expect( "0123456".en.numwords.en.ordinal ).to eq( "one hundred and twenty-three thousand, four hundred and fifty-sixth" )
 		end
 
 
 		it "can transform 1234567 into english words" do
-			"1234567".en.numwords.should == "one million, two hundred and thirty-four thousand, five hundred and sixty-seven"
+			expect( "1234567".en.numwords ).to eq( "one million, two hundred and thirty-four thousand, five hundred and sixty-seven" )
 		end
 
 		it "can transform 1234567 into english words in single-digit groups" do
-			"1234567".en.numwords( :group => 1 ).should == "one, two, three, four, five, six, seven"
+			expect( "1234567".en.numwords(group: 1) ).to eq( "one, two, three, four, five, six, seven" )
 		end
 
 		it "can transform 1234567 into english words in double-digit groups" do
-			"1234567".en.numwords( :group => 2 ).should == "twelve, thirty-four, fifty-six, seven"
+			expect( "1234567".en.numwords(group: 2) ).to eq( "twelve, thirty-four, fifty-six, seven" )
 		end
 
 		it "can transform 1234567 into english words in triple-digit groups" do
-			"1234567".en.numwords( :group => 3 ).should == "one twenty-three, four fifty-six, seven"
+			expect( "1234567".en.numwords(group: 3) ).to eq( "one twenty-three, four fifty-six, seven" )
 		end
 
 
 		it "can transform the english words for 1234567 into an ordinal" do
-			"1234567".en.numwords.en.ordinal.should == "one million, two hundred and thirty-four thousand, five hundred and sixty-seventh"
+			expect( "1234567".en.numwords.en.ordinal ).to eq( "one million, two hundred and thirty-four thousand, five hundred and sixty-seventh" )
 		end
 
 
 		it "can transform 12345678 into english words" do
-			"12345678".en.numwords.should == "twelve million, three hundred and forty-five thousand, six hundred and seventy-eight"
+			expect( "12345678".en.numwords ).to eq( "twelve million, three hundred and forty-five thousand, six hundred and seventy-eight" )
 		end
 
 		it "can transform 12345678 into english words in single-digit groups" do
-			"12345678".en.numwords( :group => 1 ).should == "one, two, three, four, five, six, seven, eight"
+			expect( "12345678".en.numwords(group: 1) ).to eq( "one, two, three, four, five, six, seven, eight" )
 		end
 
 		it "can transform 12345678 into english words in double-digit groups" do
-			"12345678".en.numwords( :group => 2 ).should == "twelve, thirty-four, fifty-six, seventy-eight"
+			expect( "12345678".en.numwords(group: 2) ).to eq( "twelve, thirty-four, fifty-six, seventy-eight" )
 		end
 
 		it "can transform 12345678 into english words in triple-digit groups" do
-			"12345678".en.numwords( :group => 3 ).should == "one twenty-three, four fifty-six, seventy-eight"
+			expect( "12345678".en.numwords(group: 3) ).to eq( "one twenty-three, four fifty-six, seventy-eight" )
 		end
 
 
 		it "can transform the english words for 12345678 into an ordinal" do
-			"12345678".en.numwords.en.ordinal.should == "twelve million, three hundred and forty-five thousand, six hundred and seventy-eighth"
+			expect( "12345678".en.numwords.en.ordinal ).to eq( "twelve million, three hundred and forty-five thousand, six hundred and seventy-eighth" )
 		end
 
 
 		it "can transform 12_345_678 into english words" do
-			"12_345_678".en.numwords.should == "twelve million, three hundred and forty-five thousand, six hundred and seventy-eight"
+			expect( "12_345_678".en.numwords ).to eq( "twelve million, three hundred and forty-five thousand, six hundred and seventy-eight" )
 		end
 
 		it "can transform 12_345_678 into english words in single-digit groups" do
-			"12_345_678".en.numwords( :group => 1 ).should == "one, two, three, four, five, six, seven, eight"
+			expect( "12_345_678".en.numwords(group: 1) ).to eq( "one, two, three, four, five, six, seven, eight" )
 		end
 
 		it "can transform 12_345_678 into english words in double-digit groups" do
-			"12_345_678".en.numwords( :group => 2 ).should == "twelve, thirty-four, fifty-six, seventy-eight"
+			expect( "12_345_678".en.numwords(group: 2) ).to eq( "twelve, thirty-four, fifty-six, seventy-eight" )
 		end
 
 		it "can transform 12_345_678 into english words in triple-digit groups" do
-			"12_345_678".en.numwords( :group => 3 ).should == "one twenty-three, four fifty-six, seventy-eight"
+			expect( "12_345_678".en.numwords(group: 3) ).to eq( "one twenty-three, four fifty-six, seventy-eight" )
 		end
 
 
 		it "can transform 1234,5678 into english words" do
-			"1234,5678".en.numwords.should == "twelve million, three hundred and forty-five thousand, six hundred and seventy-eight"
+			expect( "1234,5678".en.numwords ).to eq( "twelve million, three hundred and forty-five thousand, six hundred and seventy-eight" )
 		end
 
 		it "can transform 1234,5678 into english words in single-digit groups" do
-			"1234,5678".en.numwords( :group => 1 ).should == "one, two, three, four, five, six, seven, eight"
+			expect( "1234,5678".en.numwords(group: 1) ).to eq( "one, two, three, four, five, six, seven, eight" )
 		end
 
 		it "can transform 1234,5678 into english words in double-digit groups" do
-			"1234,5678".en.numwords( :group => 2 ).should == "twelve, thirty-four, fifty-six, seventy-eight"
+			expect( "1234,5678".en.numwords(group: 2) ).to eq( "twelve, thirty-four, fifty-six, seventy-eight" )
 		end
 
 		it "can transform 1234,5678 into english words in triple-digit groups" do
-			"1234,5678".en.numwords( :group => 3 ).should == "one twenty-three, four fifty-six, seventy-eight"
+			expect( "1234,5678".en.numwords(group: 3) ).to eq( "one twenty-three, four fifty-six, seventy-eight" )
 		end
 
 
 		it "can transform 1234567890 into english words" do
-			"1234567890".en.numwords.should == "one billion, two hundred and thirty-four million, five hundred and sixty-seven thousand, eight hundred and ninety"
+			expect( "1234567890".en.numwords ).to eq( "one billion, two hundred and thirty-four million, five hundred and sixty-seven thousand, eight hundred and ninety" )
 		end
 
 		it "can transform 1234567890 into english words in single-digit groups" do
-			"1234567890".en.numwords( :group => 1 ).should == "one, two, three, four, five, six, seven, eight, nine, zero"
+			expect( "1234567890".en.numwords(group: 1) ).to eq( "one, two, three, four, five, six, seven, eight, nine, zero" )
 		end
 
 		it "can transform 1234567890 into english words in double-digit groups" do
-			"1234567890".en.numwords( :group => 2 ).should == "twelve, thirty-four, fifty-six, seventy-eight, ninety"
+			expect( "1234567890".en.numwords(group: 2) ).to eq( "twelve, thirty-four, fifty-six, seventy-eight, ninety" )
 		end
 
 		it "can transform 1234567890 into english words in triple-digit groups" do
-			"1234567890".en.numwords( :group => 3 ).should == "one twenty-three, four fifty-six, seven eighty-nine, zero"
+			expect( "1234567890".en.numwords(group: 3) ).to eq( "one twenty-three, four fifty-six, seven eighty-nine, zero" )
 		end
 
 
 		it "can transform the english words for 1234567890 into an ordinal" do
-			"1234567890".en.numwords.en.ordinal.should == "one billion, two hundred and thirty-four million, five hundred and sixty-seven thousand, eight hundred and ninetieth"
+			expect( "1234567890".en.numwords.en.ordinal ).to eq( "one billion, two hundred and thirty-four million, five hundred and sixty-seven thousand, eight hundred and ninetieth" )
 		end
 
 
 		it "can transform 123456789012345 into english words" do
-			"123456789012345".en.numwords.should == "one hundred and twenty-three trillion, four hundred and fifty-six billion, seven hundred and eighty-nine million, twelve thousand, three hundred and forty-five"
+			expect( "123456789012345".en.numwords ).to eq( "one hundred and twenty-three trillion, four hundred and fifty-six billion, seven hundred and eighty-nine million, twelve thousand, three hundred and forty-five" )
 		end
 
 		it "can transform 123456789012345 into english words in single-digit groups" do
-			"123456789012345".en.numwords( :group => 1 ).should == "one, two, three, four, five, six, seven, eight, nine, zero, one, two, three, four, five"
+			expect( "123456789012345".en.numwords(group: 1) ).to eq( "one, two, three, four, five, six, seven, eight, nine, zero, one, two, three, four, five" )
 		end
 
 		it "can transform 123456789012345 into english words in double-digit groups" do
-			"123456789012345".en.numwords( :group => 2 ).should == "twelve, thirty-four, fifty-six, seventy-eight, ninety, twelve, thirty-four, five"
+			expect( "123456789012345".en.numwords(group: 2) ).to eq( "twelve, thirty-four, fifty-six, seventy-eight, ninety, twelve, thirty-four, five" )
 		end
 
 		it "can transform 123456789012345 into english words in triple-digit groups" do
-			"123456789012345".en.numwords( :group => 3 ).should == "one twenty-three, four fifty-six, seven eighty-nine, zero twelve, three forty-five"
+			expect( "123456789012345".en.numwords(group: 3) ).to eq( "one twenty-three, four fifty-six, seven eighty-nine, zero twelve, three forty-five" )
 		end
 
 
 		it "can transform the english words for 123456789012345 into an ordinal" do
-			"123456789012345".en.numwords.en.ordinal.should == "one hundred and twenty-three trillion, four hundred and fifty-six billion, seven hundred and eighty-nine million, twelve thousand, three hundred and forty-fifth"
+			expect( "123456789012345".en.numwords.en.ordinal ).to eq( "one hundred and twenty-three trillion, four hundred and fifty-six billion, seven hundred and eighty-nine million, twelve thousand, three hundred and forty-fifth" )
 		end
 
 
 		it "can transform 12345678901234567890 into english words" do
-			"12345678901234567890".en.numwords.should == "twelve quintillion, three hundred and forty-five quadrillion, six hundred and seventy-eight trillion, nine hundred and one billion, two hundred and thirty-four million, five hundred and sixty-seven thousand, eight hundred and ninety"
+			expect( "12345678901234567890".en.numwords ).to eq( "twelve quintillion, three hundred and forty-five quadrillion, six hundred and seventy-eight trillion, nine hundred and one billion, two hundred and thirty-four million, five hundred and sixty-seven thousand, eight hundred and ninety" )
 		end
 
 		it "can transform 12345678901234567890 into english words in single-digit groups" do
-			"12345678901234567890".en.numwords( :group => 1 ).should == "one, two, three, four, five, six, seven, eight, nine, zero, one, two, three, four, five, six, seven, eight, nine, zero"
+			expect( "12345678901234567890".en.numwords(group: 1) ).to eq( "one, two, three, four, five, six, seven, eight, nine, zero, one, two, three, four, five, six, seven, eight, nine, zero" )
 		end
 
 		it "can transform 12345678901234567890 into english words in double-digit groups" do
-			"12345678901234567890".en.numwords( :group => 2 ).should == "twelve, thirty-four, fifty-six, seventy-eight, ninety, twelve, thirty-four, fifty-six, seventy-eight, ninety"
+			expect( "12345678901234567890".en.numwords(group: 2) ).to eq( "twelve, thirty-four, fifty-six, seventy-eight, ninety, twelve, thirty-four, fifty-six, seventy-eight, ninety" )
 		end
 
 		it "can transform 12345678901234567890 into english words in triple-digit groups" do
-			"12345678901234567890".en.numwords( :group => 3 ).should == "one twenty-three, four fifty-six, seven eighty-nine, zero twelve, three forty-five, six seventy-eight, ninety"
+			expect( "12345678901234567890".en.numwords(group: 3) ).to eq( "one twenty-three, four fifty-six, seven eighty-nine, zero twelve, three forty-five, six seventy-eight, ninety" )
 		end
 
 
 		it "can transform the english words for 12345678901234567890 into an ordinal" do
-			"12345678901234567890".en.numwords.en.ordinal.should == "twelve quintillion, three hundred and forty-five quadrillion, six hundred and seventy-eight trillion, nine hundred and one billion, two hundred and thirty-four million, five hundred and sixty-seven thousand, eight hundred and ninetieth"
+			expect( "12345678901234567890".en.numwords.en.ordinal ).to eq( "twelve quintillion, three hundred and forty-five quadrillion, six hundred and seventy-eight trillion, nine hundred and one billion, two hundred and thirty-four million, five hundred and sixty-seven thousand, eight hundred and ninetieth" )
 		end
 
 
 		it "can transform 0.987654 into english words" do
-			"0.987654".en.numwords.should == "zero point nine eight seven six five four"
+			expect( "0.987654".en.numwords ).to eq( "zero point nine eight seven six five four" )
 		end
 
 		it "can transform 0.987654 into english words in single-digit groups" do
-			"0.987654".en.numwords( :group => 1 ).should == "zero, point, nine, eight, seven, six, five, four"
+			expect( "0.987654".en.numwords(group: 1) ).to eq( "zero, point, nine, eight, seven, six, five, four" )
 		end
 
 		it "can transform 0.987654 into english words in double-digit groups" do
-			"0.987654".en.numwords( :group => 2 ).should == "zero, point, ninety-eight, seventy-six, fifty-four"
+			expect( "0.987654".en.numwords(group: 2) ).to eq( "zero, point, ninety-eight, seventy-six, fifty-four" )
 		end
 
 		it "can transform 0.987654 into english words in triple-digit groups" do
-			"0.987654".en.numwords( :group => 3 ).should == "zero, point, nine eighty-seven, six fifty-four"
+			expect( "0.987654".en.numwords(group: 3) ).to eq( "zero, point, nine eighty-seven, six fifty-four" )
 		end
 
 
 		it "can transform the english words for 0.987654 into an ordinal" do
-			"0.987654".en.numwords.en.ordinal.should == "zero point nine eight seven six five fourth"
+			expect( "0.987654".en.numwords.en.ordinal ).to eq( "zero point nine eight seven six five fourth" )
 		end
 
 
 		it "can transform .987654 into english words" do
-			".987654".en.numwords.should == "point nine eight seven six five four"
+			expect( ".987654".en.numwords ).to eq( "point nine eight seven six five four" )
 		end
 
 		it "can transform .987654 into english words in single-digit groups" do
-			".987654".en.numwords( :group => 1 ).should == "point, nine, eight, seven, six, five, four"
+			expect( ".987654".en.numwords(group: 1) ).to eq( "point, nine, eight, seven, six, five, four" )
 		end
 
 		it "can transform .987654 into english words in double-digit groups" do
-			".987654".en.numwords( :group => 2 ).should == "point, ninety-eight, seventy-six, fifty-four"
+			expect( ".987654".en.numwords(group: 2) ).to eq( "point, ninety-eight, seventy-six, fifty-four" )
 		end
 
 		it "can transform .987654 into english words in triple-digit groups" do
-			".987654".en.numwords( :group => 3 ).should == "point, nine eighty-seven, six fifty-four"
+			expect( ".987654".en.numwords(group: 3) ).to eq( "point, nine eighty-seven, six fifty-four" )
 		end
 
 
 		it "can transform the english words for .987654 into an ordinal" do
-			".987654".en.numwords.en.ordinal.should == "point nine eight seven six five fourth"
+			expect( ".987654".en.numwords.en.ordinal ).to eq( "point nine eight seven six five fourth" )
 		end
 
 
 		it "can transform 9.87654 into english words" do
-			"9.87654".en.numwords.should == "nine point eight seven six five four"
+			expect( "9.87654".en.numwords ).to eq( "nine point eight seven six five four" )
 		end
 
 		it "can transform 9.87654 into english words in single-digit groups" do
-			"9.87654".en.numwords( :group => 1 ).should == "nine, point, eight, seven, six, five, four"
+			expect( "9.87654".en.numwords(group: 1) ).to eq( "nine, point, eight, seven, six, five, four" )
 		end
 
 		it "can transform 9.87654 into english words in double-digit groups" do
-			"9.87654".en.numwords( :group => 2 ).should == "nine, point, eighty-seven, sixty-five, four"
+			expect( "9.87654".en.numwords(group: 2) ).to eq( "nine, point, eighty-seven, sixty-five, four" )
 		end
 
 		it "can transform 9.87654 into english words in triple-digit groups" do
-			"9.87654".en.numwords( :group => 3 ).should == "nine, point, eight seventy-six, fifty-four"
+			expect( "9.87654".en.numwords(group: 3) ).to eq( "nine, point, eight seventy-six, fifty-four" )
 		end
 
 
 		it "can transform the english words for 9.87654 into an ordinal" do
-			"9.87654".en.numwords.en.ordinal.should == "nine point eight seven six five fourth"
+			expect( "9.87654".en.numwords.en.ordinal ).to eq( "nine point eight seven six five fourth" )
 		end
 
 
 		it "can transform 98.7654 into english words" do
-			"98.7654".en.numwords.should == "ninety-eight point seven six five four"
+			expect( "98.7654".en.numwords ).to eq( "ninety-eight point seven six five four" )
 		end
 
 		it "can transform 98.7654 into english words in single-digit groups" do
-			"98.7654".en.numwords( :group => 1 ).should == "nine, eight, point, seven, six, five, four"
+			expect( "98.7654".en.numwords(group: 1) ).to eq( "nine, eight, point, seven, six, five, four" )
 		end
 
 		it "can transform 98.7654 into english words in double-digit groups" do
-			"98.7654".en.numwords( :group => 2 ).should == "ninety-eight, point, seventy-six, fifty-four"
+			expect( "98.7654".en.numwords(group: 2) ).to eq( "ninety-eight, point, seventy-six, fifty-four" )
 		end
 
 		it "can transform 98.7654 into english words in triple-digit groups" do
-			"98.7654".en.numwords( :group => 3 ).should == "ninety-eight, point, seven sixty-five, four"
+			expect( "98.7654".en.numwords(group: 3) ).to eq( "ninety-eight, point, seven sixty-five, four" )
 		end
 
 
 		it "can transform the english words for 98.7654 into an ordinal" do
-			"98.7654".en.numwords.en.ordinal.should == "ninety-eight point seven six five fourth"
+			expect( "98.7654".en.numwords.en.ordinal ).to eq( "ninety-eight point seven six five fourth" )
 		end
 
 
 		it "can transform 987.654 into english words" do
-			"987.654".en.numwords.should == "nine hundred and eighty-seven point six five four"
+			expect( "987.654".en.numwords ).to eq( "nine hundred and eighty-seven point six five four" )
 		end
 
 		it "can transform 987.654 into english words in single-digit groups" do
-			"987.654".en.numwords( :group => 1 ).should == "nine, eight, seven, point, six, five, four"
+			expect( "987.654".en.numwords(group: 1) ).to eq( "nine, eight, seven, point, six, five, four" )
 		end
 
 		it "can transform 987.654 into english words in double-digit groups" do
-			"987.654".en.numwords( :group => 2 ).should == "ninety-eight, seven, point, sixty-five, four"
+			expect( "987.654".en.numwords(group: 2) ).to eq( "ninety-eight, seven, point, sixty-five, four" )
 		end
 
 		it "can transform 987.654 into english words in triple-digit groups" do
-			"987.654".en.numwords( :group => 3 ).should == "nine eighty-seven, point, six fifty-four"
+			expect( "987.654".en.numwords(group: 3) ).to eq( "nine eighty-seven, point, six fifty-four" )
 		end
 
 
 		it "can transform the english words for 987.654 into an ordinal" do
-			"987.654".en.numwords.en.ordinal.should == "nine hundred and eighty-seven point six five fourth"
+			expect( "987.654".en.numwords.en.ordinal ).to eq( "nine hundred and eighty-seven point six five fourth" )
 		end
 
 
 		it "can transform 9876.54 into english words" do
-			"9876.54".en.numwords.should == "nine thousand, eight hundred and seventy-six point five four"
+			expect( "9876.54".en.numwords ).to eq( "nine thousand, eight hundred and seventy-six point five four" )
 		end
 
 		it "can transform 9876.54 into english words in single-digit groups" do
-			"9876.54".en.numwords( :group => 1 ).should == "nine, eight, seven, six, point, five, four"
+			expect( "9876.54".en.numwords(group: 1) ).to eq( "nine, eight, seven, six, point, five, four" )
 		end
 
 		it "can transform 9876.54 into english words in double-digit groups" do
-			"9876.54".en.numwords( :group => 2 ).should == "ninety-eight, seventy-six, point, fifty-four"
+			expect( "9876.54".en.numwords(group: 2) ).to eq( "ninety-eight, seventy-six, point, fifty-four" )
 		end
 
 		it "can transform 9876.54 into english words in triple-digit groups" do
-			"9876.54".en.numwords( :group => 3 ).should == "nine eighty-seven, six, point, fifty-four"
+			expect( "9876.54".en.numwords(group: 3) ).to eq( "nine eighty-seven, six, point, fifty-four" )
 		end
 
 
 		it "can transform the english words for 9876.54 into an ordinal" do
-			"9876.54".en.numwords.en.ordinal.should == "nine thousand, eight hundred and seventy-six point five fourth"
+			expect( "9876.54".en.numwords.en.ordinal ).to eq( "nine thousand, eight hundred and seventy-six point five fourth" )
 		end
 
 
 		it "can transform 98765.4 into english words" do
-			"98765.4".en.numwords.should == "ninety-eight thousand, seven hundred and sixty-five point four"
+			expect( "98765.4".en.numwords ).to eq( "ninety-eight thousand, seven hundred and sixty-five point four" )
 		end
 
 		it "can transform 98765.4 into english words in single-digit groups" do
-			"98765.4".en.numwords( :group => 1 ).should == "nine, eight, seven, six, five, point, four"
+			expect( "98765.4".en.numwords(group: 1) ).to eq( "nine, eight, seven, six, five, point, four" )
 		end
 
 		it "can transform 98765.4 into english words in double-digit groups" do
-			"98765.4".en.numwords( :group => 2 ).should == "ninety-eight, seventy-six, five, point, four"
+			expect( "98765.4".en.numwords(group: 2) ).to eq( "ninety-eight, seventy-six, five, point, four" )
 		end
 
 		it "can transform 98765.4 into english words in triple-digit groups" do
-			"98765.4".en.numwords( :group => 3 ).should == "nine eighty-seven, sixty-five, point, four"
+			expect( "98765.4".en.numwords(group: 3) ).to eq( "nine eighty-seven, sixty-five, point, four" )
 		end
 
 
 		it "can transform the english words for 98765.4 into an ordinal" do
-			"98765.4".en.numwords.en.ordinal.should == "ninety-eight thousand, seven hundred and sixty-five point fourth"
+			expect( "98765.4".en.numwords.en.ordinal ).to eq( "ninety-eight thousand, seven hundred and sixty-five point fourth" )
 		end
 
 
 		it "can transform 101.202.303 into english words" do
-			"101.202.303".en.numwords.should == "one hundred and one point two zero two three zero three"
+			expect( "101.202.303".en.numwords ).to eq( "one hundred and one point two zero two three zero three" )
 		end
 
 		it "can transform 101.202.303 into english words in single-digit groups" do
-			"101.202.303".en.numwords( :group => 1 ).should == "one, zero, one, point, two, zero, two, point, three, zero, three"
+			expect( "101.202.303".en.numwords(group: 1) ).to eq( "one, zero, one, point, two, zero, two, point, three, zero, three" )
 		end
 
 		it "can transform 101.202.303 into english words in double-digit groups" do
-			"101.202.303".en.numwords( :group => 2 ).should == "ten, one, point, twenty, two, point, thirty, three"
+			expect( "101.202.303".en.numwords(group: 2) ).to eq( "ten, one, point, twenty, two, point, thirty, three" )
 		end
 
 		it "can transform 101.202.303 into english words in triple-digit groups" do
-			"101.202.303".en.numwords( :group => 3 ).should == "one zero one, point, two zero two, point, three zero three"
+			expect( "101.202.303".en.numwords(group: 3) ).to eq( "one zero one, point, two zero two, point, three zero three" )
 		end
 	end
 
 
 	describe "quantification" do
 		it "quantifies 0 objects as 'no'" do
-			"driver".en.quantify( 0 ).should == 'no drivers'
+			expect( "driver".en.quantify( 0 ) ).to eq( 'no drivers' )
 		end
 
 		it "quantifies 1 object as 'a'" do
-			"driver".en.quantify( 1 ).should == 'a driver'
+			expect( "driver".en.quantify( 1 ) ).to eq( 'a driver' )
 		end
 
 		it "quantifies 1 object that starts with a vowel sound as 'an'" do
-			"hour".en.quantify( 1 ).should == 'an hour'
+			expect( "hour".en.quantify( 1 ) ).to eq( 'an hour' )
 		end
 
 		it "quantifies 2-5 objects as 'several'" do
-			"driver".en.quantify( 4 ).should == 'several drivers'
+			expect( "driver".en.quantify( 4 ) ).to eq( 'several drivers' )
 		end
 
 		it "quantifies 6-19 objects as 'a number of'" do
-			"driver".en.quantify( 11 ).should == 'a number of drivers'
+			expect( "driver".en.quantify( 11 ) ).to eq( 'a number of drivers' )
 		end
 
 		it "quantifies 20-45 objects as 'numerous'" do
-			"driver".en.quantify( 41 ).should == 'numerous drivers'
+			expect( "driver".en.quantify( 41 ) ).to eq( 'numerous drivers' )
 		end
 
 		it "quantifies 46-99 objects as 'many'" do
-			"driver".en.quantify( 58 ).should == 'many drivers'
+			expect( "driver".en.quantify( 58 ) ).to eq( 'many drivers' )
 		end
 
 		it "quantifies 100-999 objects as 'hundreds of'" do
-			"driver".en.quantify( 318 ).should == 'hundreds of drivers'
+			expect( "driver".en.quantify( 318 ) ).to eq( 'hundreds of drivers' )
 		end
 
 		it "quantifies 1000-9999 objects as 'thousands of'" do
-			"driver".en.quantify( 4158 ).should == 'thousands of drivers'
+			expect( "driver".en.quantify( 4158 ) ).to eq( 'thousands of drivers' )
 		end
 
 		it "quantifies 10000-99999 objects as 'tens of thousands of'" do
-			"driver".en.quantify( 14158 ).should == 'tens of thousands of drivers'
+			expect( "driver".en.quantify( 14158 ) ).to eq( 'tens of thousands of drivers' )
 		end
 
 		it "quantifies 100000-999999 objects as 'hundreds of thousands of'" do
-			"driver".en.quantify( 614158 ).should == 'hundreds of thousands of drivers'
+			expect( "driver".en.quantify( 614158 ) ).to eq( 'hundreds of thousands of drivers' )
 		end
 
 		it "quantifies 2.6M objects as 'millions of'" do
-			"driver".en.quantify( 2614158 ).should == 'millions of drivers'
+			expect( "driver".en.quantify( 2614158 ) ).to eq( 'millions of drivers' )
 		end
 
 		it "quantifies 8.122B objects as 'billions of'" do
-			"driver".en.quantify( 8122614158 ).should == 'billions of drivers'
+			expect( "driver".en.quantify( 8122614158 ) ).to eq( 'billions of drivers' )
 		end