twitter_cldr 3.0.1 → 3.0.2

data/spec/shared/numbers_spec.rb

@@ -14,22 +14,22 @@ describe Numbers do
     it 'returns numerical symbols for default locale' do
       stub(TwitterCldr).locale { :jp }
       stub(TwitterCldr).get_locale_resource(:jp, :numbers) { { :jp => { :numbers => { :symbols => symbols } } } }
-      TwitterCldr::Shared::Numbers.symbols.should == symbols
+      expect(TwitterCldr::Shared::Numbers.symbols).to eq(symbols)
     end
 
     it 'returns numerical symbols for default locale' do
       stub(TwitterCldr).get_locale_resource(:np, :numbers) { { :np => { :numbers => { :symbols => symbols } } } }
-      TwitterCldr::Shared::Numbers.symbols(:np).should == symbols
+      expect(TwitterCldr::Shared::Numbers.symbols(:np)).to eq(symbols)
     end
 
     it 'converts locale' do
       stub(TwitterCldr).get_locale_resource(:'zh-Hant', :numbers) { { :'zh-Hant' => { :numbers => { :symbols => symbols } } } }
-      TwitterCldr::Shared::Numbers.symbols('zh-tw').should == symbols
+      expect(TwitterCldr::Shared::Numbers.symbols('zh-tw')).to eq(symbols)
     end
 
     it 'returns nil if the resource is missing' do
       stub(TwitterCldr).get_locale_resource(:nop, :numbers) { nil }
-      TwitterCldr::Shared::Numbers.symbols(:nop).should be_nil
+      expect(TwitterCldr::Shared::Numbers.symbols(:nop)).to be_nil
     end
   end
 end

data/spec/shared/phone_codes_spec.rb

@@ -12,15 +12,15 @@ describe PhoneCodes do
     let(:territories) { PhoneCodes.territories }
 
     it 'returns an array' do
-      territories.should be_instance_of(Array)
+      expect(territories).to be_instance_of(Array)
     end
 
     it 'returns symbols' do
-      territories.each { |territory| territory.should be_instance_of(Symbol) }
+      territories.each { |territory| expect(territory).to be_instance_of(Symbol) }
     end
 
     it 'returns supported territories' do
-      territories.should include(:br, :fr, :jp)
+      expect(territories).to include(:br, :fr, :jp)
     end
   end
 
@@ -31,19 +31,19 @@ describe PhoneCodes do
     before(:each) { mock(PhoneCodes).resource { { territory => code } } }
 
     it 'returns phone code for a given territory' do
-      PhoneCodes.code_for_territory(territory).should == code
+      expect(PhoneCodes.code_for_territory(territory)).to eq(code)
     end
 
     it 'returns nil if the regex is missing' do
-      PhoneCodes.code_for_territory(:foo).should be_nil
+      expect(PhoneCodes.code_for_territory(:foo)).to be_nil
     end
 
     it 'accepts strings' do
-      PhoneCodes.code_for_territory(territory.to_s).should == code
+      expect(PhoneCodes.code_for_territory(territory.to_s)).to eq(code)
     end
 
     it 'accepts upper-case strings' do
-      PhoneCodes.code_for_territory(territory.to_s.upcase).should == code
+      expect(PhoneCodes.code_for_territory(territory.to_s.upcase)).to eq(code)
     end
   end
 end

data/spec/shared/postal_code_generator_spec.rb

@@ -0,0 +1,76 @@
+# encoding: UTF-8
+
+# Copyright 2012 Twitter, Inc
+# http://www.apache.org/licenses/LICENSE-2.0
+
+require 'spec_helper'
+
+include TwitterCldr::Shared
+include TwitterCldr::Utils
+
+describe PostalCodeGenerator do
+  let(:generator) do
+    PostalCodeGenerator.new(
+      RegexpAst::Root.new([
+        RegexpAst::Digit.new([], RegexpAst::Quantifier.new(3, 3)),
+        RegexpAst::Literal.new([], nil, '- '),
+        RegexpAst::Word.new([], RegexpAst::Quantifier.new(3, 3))
+      ], nil)
+    )
+  end
+
+  let(:blank_generator) do
+    PostalCodeGenerator.new(
+      RegexpAst::Root.new([
+        RegexpAst::Alternation.new([
+          RegexpAst::Literal.new([], nil, ''),
+          RegexpAst::Word.new([], nil)
+        ], nil)
+      ], nil)
+    )
+  end
+
+  let(:limited_generator) do
+    PostalCodeGenerator.new(
+      RegexpAst::Root.new([
+        RegexpAst::CharacterSet.new([], nil, ['A-C'], false),
+      ], nil)
+    )
+  end
+
+  describe "#generate" do
+    it "should generate correctly and not allow dashes to be followed by spaces" do
+      10.times do
+        generator.generate.should match(/\d{3}-\w{3}/)
+      end
+    end
+  end
+
+  describe "#sample" do
+    it "should generate the given number of unique samples" do
+      samples = generator.sample(10)
+      samples.size.should == 10
+      samples.uniq.should == samples
+      samples.each do |sample|
+        sample.should match(/\d{3}-\w{3}/)
+      end
+    end
+
+    it "should not return blank samples" do
+      10.times do
+        blank_generator.sample(10).all? do |sample|
+          sample.empty?
+        end.should be_false
+      end
+    end
+
+    it "shouldn't loop infinitely if the number of possible samples is less than requested" do
+      limited_generator.sample(10).size.should < 10
+    end
+
+    it "should attempt to generate more samples if the set doesn't contain enough (but shouldn't infinite loop)" do
+      mock.proxy(limited_generator).generate.at_least(10)
+      limited_generator.sample(10).size.should < 10
+    end
+  end
+end

data/spec/shared/postal_codes_spec.rb

@@ -12,57 +12,63 @@ describe PostalCodes do
     let(:territories) { PostalCodes.territories }
 
     it 'returns an array' do
-      territories.should be_instance_of(Array)
+      expect(territories).to be_instance_of(Array)
     end
 
     it 'returns symbols' do
-      territories.each { |territory| territory.should be_instance_of(Symbol) }
+      territories.each { |territory| expect(territory).to be_instance_of(Symbol) }
     end
 
     it 'returns supported territories' do
-      territories.should include(:br, :fr, :jp)
+      expect(territories).to include(:br, :fr, :jp)
     end
   end
 
-  describe '#regex_for_territory' do
-    let(:regex)     { /\d{5}[\-]?\d{3}/ }
-    let(:territory) { :br }
-
-    before(:each) { mock(PostalCodes).resource { { territory => regex } } }
-
-    it 'returns postal code regex for a given territory' do
-      PostalCodes.regex_for_territory(territory).should == regex
-    end
-
-    it 'returns nil if the regex is missing' do
-      PostalCodes.regex_for_territory(:foo).should be_nil
+  describe "#new" do
+    it "should raise an error if the territory isn't supported" do
+      lambda { PostalCodes.for_territory(:xx) }.should raise_error(InvalidTerritoryError)
     end
 
     it 'accepts strings' do
-      PostalCodes.regex_for_territory(territory.to_s).should == regex
+      PostalCodes.for_territory("us").should be_a(PostalCodes)
     end
 
     it 'accepts upper-case strings' do
-      PostalCodes.regex_for_territory(territory.to_s.upcase).should == regex
+      PostalCodes.for_territory("US").should be_a(PostalCodes)
     end
   end
 
-  describe '#valid?' do
-    let(:regex)     { /\d{5}[\-]?\d{3}/ }
-    let(:territory) { :br }
-
-    before(:each) { mock(PostalCodes).resource { { territory => regex } } }
+  context "with a PostalCodes instance" do
+    let(:postal_code) { PostalCodes.for_territory(:us) }
 
-    it 'returns true if a given postal code satisfies the regexp' do
-      PostalCodes.valid?(territory, '12345-321').should be_true
+    describe '#regexp' do
+      it 'returns postal code regex for a given territory' do
+        postal_code.regexp.should be_a(Regexp)
+      end
     end
 
-    it "returns false if a given postal code doesn't satisfy the regexp" do
-      PostalCodes.valid?(territory, 'postal-code').should be_false
+    describe '#valid?' do
+      it 'returns true if a given postal code satisfies the regexp' do
+        postal_code.valid?('12345-6789').should be_true
+      end
+
+      it "returns false if a given postal code doesn't satisfy the regexp" do
+        postal_code.valid?('postal-code').should be_false
+      end
     end
 
-    it 'returns false if the regexp is missing' do
-      PostalCodes.valid?(:foo, '12345-321').should be_false
+    describe "#sample" do
+      PostalCodes.territories.each do |territory|
+        postal_code = PostalCodes.for_territory(territory)
+
+        it "returns samples that match #{territory}" do
+          postal_code.sample(10).each do |sample|
+            result = postal_code.valid?(sample)
+            puts "Failed with example #{sample}" unless result
+            result.should be_true
+          end
+        end
+      end
     end
   end
-end
+end

data/spec/shared/territories_spec.rb

@@ -10,109 +10,109 @@ include TwitterCldr::Shared
 describe Territories do
   describe "#translate_territory" do
     it "should translate country names from one locale to another" do
-      Territories.translate_territory("Russia", :en, :es).should match_normalized("Rusia")
-      Territories.translate_territory("Rusia", :es, :en).should match_normalized("Russia")
-      Territories.translate_territory("Spain", :en, :es).should match_normalized("España")
-      Territories.translate_territory("España", :es, :ru).should match_normalized("Испания")
+      expect(Territories.translate_territory("Russia", :en, :es)).to match_normalized("Rusia")
+      expect(Territories.translate_territory("Rusia", :es, :en)).to match_normalized("Russia")
+      expect(Territories.translate_territory("Spain", :en, :es)).to match_normalized("España")
+      expect(Territories.translate_territory("España", :es, :ru)).to match_normalized("Испания")
     end
 
     it "should use alternate/short names" do
-      Territories.translate_territory("Congo (DRC)", :en, :es).should match_normalized("Congo (República Democrática del Congo)")
-      Territories.translate_territory("Congo (Republic)", :en, :es).should match_normalized("Congo (República)")
-      Territories.translate_territory("East Timor", :en, :es).should match_normalized("Timor Oriental")
-      Territories.translate_territory("Falkland Islands (Islas Malvinas)", :en, :es).should match_normalized("Islas Malvinas (Islas Falkland)")
-      Territories.translate_territory("Hong Kong", :en, :es).should match_normalized("Hong Kong")
-      Territories.translate_territory("Ivory Coast", :en, :es).should match_normalized("Costa de Marfil")
-      Territories.translate_territory("Macau", :en, :es).should match_normalized("Macao")
-      Territories.translate_territory("Macedonia (FYROM)", :en, :es).should match_normalized("Macedonia (ERYM)")
+      expect(Territories.translate_territory("Congo (DRC)", :en, :es)).to match_normalized("Congo (República Democrática del Congo)")
+      expect(Territories.translate_territory("Congo (Republic)", :en, :es)).to match_normalized("Congo (República)")
+      expect(Territories.translate_territory("East Timor", :en, :es)).to match_normalized("Timor Oriental")
+      expect(Territories.translate_territory("Falkland Islands (Islas Malvinas)", :en, :es)).to match_normalized("Islas Malvinas (Islas Falkland)")
+      expect(Territories.translate_territory("Hong Kong", :en, :es)).to match_normalized("Hong Kong")
+      expect(Territories.translate_territory("Ivory Coast", :en, :es)).to match_normalized("Costa de Marfil")
+      expect(Territories.translate_territory("Macau", :en, :es)).to match_normalized("Macao")
+      expect(Territories.translate_territory("Macedonia (FYROM)", :en, :es)).to match_normalized("Macedonia (ERYM)")
     end
 
     it "should be capitalization agnostic" do
-      Territories.translate_territory("russia", :en, :es).should match_normalized("Rusia")
-      Territories.translate_territory("RUSSIA", :en, :es).should match_normalized("Rusia")
+      expect(Territories.translate_territory("russia", :en, :es)).to match_normalized("Rusia")
+      expect(Territories.translate_territory("RUSSIA", :en, :es)).to match_normalized("Rusia")
     end
 
     it "defaults the destination language to English (or whatever the global locale is)" do
-      Territories.translate_territory("Rusia", :es).should match_normalized("Russia")
-      Territories.translate_territory("Россия", :ru).should match_normalized("Russia")
+      expect(Territories.translate_territory("Rusia", :es)).to match_normalized("Russia")
+      expect(Territories.translate_territory("Россия", :ru)).to match_normalized("Russia")
     end
 
     it "defaults source and destination language to English if not given" do
-      Territories.translate_territory("Russia").should match_normalized("Russia")
+      expect(Territories.translate_territory("Russia")).to match_normalized("Russia")
       TwitterCldr.locale = :es
-      Territories.translate_territory("Russia").should match_normalized("Rusia")
+      expect(Territories.translate_territory("Russia")).to match_normalized("Rusia")
     end
 
     it "successfully translates locale codes that are and are not in the CLDR using the locale map" do
-      Territories.translate_territory("Russia", :en, :'zh-cn').should match_normalized("俄罗斯")
-      Territories.translate_territory("Russia", :en, :'zh').should match_normalized("俄罗斯")
+      expect(Territories.translate_territory("Russia", :en, :'zh-cn')).to match_normalized("俄罗斯")
+      expect(Territories.translate_territory("Russia", :en, :'zh')).to match_normalized("俄罗斯")
     end
 
     it "should return nil if no translation was found" do
-      Territories.translate_territory("Russia", :en, :blarg).should == nil
+      expect(Territories.translate_territory("Russia", :en, :blarg)).to eq(nil)
     end
   end
 
   describe "#from_territory_code_for_locale" do
     it "should return the territory in the correct locale for the given locale code (i.e. RU in English should be Russia)" do
-      Territories.from_territory_code_for_locale(:ES, :en).should match_normalized("Spain")
-      Territories.from_territory_code_for_locale(:GB, :es).should match_normalized("UK")
+      expect(Territories.from_territory_code_for_locale(:ES, :en)).to match_normalized("Spain")
+      expect(Territories.from_territory_code_for_locale(:GB, :es)).to match_normalized("UK")
     end
 
     it "should work with lower-case country codes as well" do
-      Territories.from_territory_code_for_locale(:es, :en).should match_normalized("Spain")
-      Territories.from_territory_code_for_locale(:gb, :es).should match_normalized("UK")
+      expect(Territories.from_territory_code_for_locale(:es, :en)).to match_normalized("Spain")
+      expect(Territories.from_territory_code_for_locale(:gb, :es)).to match_normalized("UK")
     end
 
     it "should work with Traditional Chinese" do
-      Territories.from_territory_code_for_locale(:US, :"zh-Hant").should match_normalized("美國")
+      expect(Territories.from_territory_code_for_locale(:US, :"zh-Hant")).to match_normalized("美國")
     end
   end
 
   describe "#from_territory_code" do
     it "should return the language in the default locale for the given locale code" do
-      Territories.from_territory_code(:ES).should match_normalized("Spain")
-      Territories.from_territory_code(:RU).should match_normalized("Russia")
+      expect(Territories.from_territory_code(:ES)).to match_normalized("Spain")
+      expect(Territories.from_territory_code(:RU)).to match_normalized("Russia")
       TwitterCldr.locale = :es
-      Territories.from_territory_code(:ES).should match_normalized("España")
+      expect(Territories.from_territory_code(:ES)).to match_normalized("España")
     end
   end
 
   describe "#all_for" do
     it "should return a hash of all languages for the given language code" do
       territories = Territories.all_for(:es)
-      territories.should be_a(Hash)
-      territories[:ru].should match_normalized("Rusia")
+      expect(territories).to be_a(Hash)
+      expect(territories[:ru]).to match_normalized("Rusia")
     end
 
     it "should return an empty hash for an invalid language" do
       territories = Territories.all_for(:blarg)
-      territories.should == {}
+      expect(territories).to eq({})
     end
   end
 
   describe "#all" do
     it "should use the default language to get the language hash" do
       territories = Territories.all
-      territories.should be_a(Hash)
-      territories[:ru].should match_normalized("Russia")
-      territories[:de].should match_normalized("Germany")
+      expect(territories).to be_a(Hash)
+      expect(territories[:ru]).to match_normalized("Russia")
+      expect(territories[:de]).to match_normalized("Germany")
 
       TwitterCldr.locale = :es
       territories = Territories.all
-      territories.should be_a(Hash)
-      territories[:ru].should match_normalized("Rusia")
-      territories[:de].should match_normalized("Alemania")
+      expect(territories).to be_a(Hash)
+      expect(territories[:ru]).to match_normalized("Rusia")
+      expect(territories[:de]).to match_normalized("Alemania")
     end
   end
 
   describe "the lack of knowledge about three-digit UN area codes" do
     it "should not be able to translate three-digit UN area codes" do
-      Territories.translate_territory("Southern Africa", :en, :es).should == nil
+      expect(Territories.translate_territory("Southern Africa", :en, :es)).to eq(nil)
     end
 
     it "should not be able to name three-digit UN area codes" do
-      Territories.from_territory_code_for_locale(:"18", :es).should == nil
+      expect(Territories.from_territory_code_for_locale(:"18", :es)).to eq(nil)
     end
   end
 

data/spec/shared/unicode_regex_spec.rb

@@ -25,40 +25,40 @@ describe UnicodeRegex do
 
     describe "#compile" do
       it "should return a UnicodeRegex, parsed and ready to go" do
-        regex.should be_a(UnicodeRegex)
+        expect(regex).to be_a(UnicodeRegex)
       end
     end
 
     describe "#to_regexp_str" do
       it "should return the string representation of this regex" do
-        regex.to_regexp_str.should == "(?:[\\141-\\143])"
+        expect(regex.to_regexp_str).to eq("(?:[\\141-\\143])")
       end
     end
 
     describe "#to_regexp" do
       it "should return a ruby Regexp" do
         if RUBY_VERSION <= "1.8.7"
-          regex.to_regexp.should be_a(Oniguruma::ORegexp)
+          expect(regex.to_regexp).to be_a(Oniguruma::ORegexp)
         else
-          regex.to_regexp.should be_a(Regexp)
+          expect(regex.to_regexp).to be_a(Regexp)
         end
       end
 
       it "should properly turn various basic regexes into strings" do
-        compile("^abc$").to_regexp_str.should == "^(?:\\141)(?:\\142)(?:\\143)$"
-        compile("a(b)c").to_regexp_str.should == "(?:\\141)((?:\\142))(?:\\143)"
-        compile("a(?:b)c").to_regexp_str.should == "(?:\\141)(?:(?:\\142))(?:\\143)"
-        compile("a{1,3}").to_regexp_str.should == "(?:\\141){1,3}"
-        compile("[abc]").to_regexp_str.should == "(?:[\\141-\\143])"
+        expect(compile("^abc$").to_regexp_str).to eq("^(?:\\141)(?:\\142)(?:\\143)$")
+        expect(compile("a(b)c").to_regexp_str).to eq("(?:\\141)((?:\\142))(?:\\143)")
+        expect(compile("a(?:b)c").to_regexp_str).to eq("(?:\\141)(?:(?:\\142))(?:\\143)")
+        expect(compile("a{1,3}").to_regexp_str).to eq("(?:\\141){1,3}")
+        expect(compile("[abc]").to_regexp_str).to eq("(?:[\\141-\\143])")
       end
 
       it "should properly turn various complex regexes into strings" do
-        compile("[a-z0-9]").to_regexp_str.should == "(?:[\\60-\\71]|[\\141-\\172])"
-        compile("[\\u0067-\\u0071]").to_regexp_str.should == "(?:[\\147-\\161])"
+        expect(compile("[a-z0-9]").to_regexp_str).to eq("(?:[\\60-\\71]|[\\141-\\172])")
+        expect(compile("[\\u0067-\\u0071]").to_regexp_str).to eq("(?:[\\147-\\161])")
       end
 
       it "should properly substitute variables" do
-        compile("$FOO$BAR", symbol_table).to_regexp_str.should == "(?:[\\147-\\153])(?:[\\160-\\163])"
+        expect(compile("$FOO$BAR", symbol_table).to_regexp_str).to eq("(?:[\\147-\\153])(?:[\\160-\\163])")
       end
     end
   end
@@ -67,10 +67,10 @@ describe UnicodeRegex do
     describe "#match" do
       it "should substitute variables from the symbol table" do
         regex = compile("$FOO $BAR", symbol_table)
-        regex.should exactly_match("h r")
-        regex.should exactly_match("j q")
-        regex.should_not exactly_match("h t")
-        regex.should_not exactly_match("c s")
+        expect(regex).to exactly_match("h r")
+        expect(regex).to exactly_match("j q")
+        expect(regex).not_to exactly_match("h t")
+        expect(regex).not_to exactly_match("c s")
       end
     end
   end
@@ -79,40 +79,40 @@ describe UnicodeRegex do
     describe "#match" do
       it "should match a regex with no char class" do
         regex = compile("^abc$")
-        regex.should exactly_match("abc")
-        regex.should_not exactly_match("cba")
+        expect(regex).to exactly_match("abc")
+        expect(regex).not_to exactly_match("cba")
       end
 
       it "should match a regex with a capturing group" do
         regex = compile("a(b)c")
         match = regex.match("abc")
-        match.should_not be_nil
-        match.captures[0].should == "b"
+        expect(match).not_to be_nil
+        expect(match.captures[0]).to eq("b")
       end
 
       it "should match a regex with a non-capturing group" do
         regex = compile("a(?:b)c")
         match = regex.match("abc")
-        match.should_not be_nil
-        match.captures.should == []
+        expect(match).not_to be_nil
+        expect(match.captures).to eq([])
       end
 
       it "should match a regex with a quantifier" do
         regex = compile("a{1,3}")
-        regex.should exactly_match("a")
-        regex.should exactly_match("aa")
-        regex.should exactly_match("aaa")
-        regex.should_not exactly_match("aaaa")
-        regex.should_not exactly_match("b")
+        expect(regex).to exactly_match("a")
+        expect(regex).to exactly_match("aa")
+        expect(regex).to exactly_match("aaa")
+        expect(regex).not_to exactly_match("aaaa")
+        expect(regex).not_to exactly_match("b")
       end
 
       it "should match a regex with a basic char class" do
         regex = compile("[abc]")
-        regex.should exactly_match("a")
-        regex.should exactly_match("b")
-        regex.should exactly_match("c")
-        regex.should_not exactly_match("ab")
-        regex.should_not exactly_match("d")
+        expect(regex).to exactly_match("a")
+        expect(regex).to exactly_match("b")
+        expect(regex).to exactly_match("c")
+        expect(regex).not_to exactly_match("ab")
+        expect(regex).not_to exactly_match("d")
       end
     end
   end
@@ -121,82 +121,82 @@ describe UnicodeRegex do
     describe "#match" do
       it "should match a regex with a char class containing a range" do
         regex = compile("[a-z0-9]")
-        regex.should exactly_match("a")
-        regex.should exactly_match("m")
-        regex.should exactly_match("z")
-        regex.should exactly_match("0")
-        regex.should exactly_match("3")
-        regex.should exactly_match("9")
-        regex.should_not exactly_match("a0")
-        regex.should_not exactly_match("m4")
+        expect(regex).to exactly_match("a")
+        expect(regex).to exactly_match("m")
+        expect(regex).to exactly_match("z")
+        expect(regex).to exactly_match("0")
+        expect(regex).to exactly_match("3")
+        expect(regex).to exactly_match("9")
+        expect(regex).not_to exactly_match("a0")
+        expect(regex).not_to exactly_match("m4")
       end
 
       it "should match a regex with a char class containing a unicode range" do
         regex = compile("[\\u0067-\\u0071]")  # g-q
-        regex.should exactly_match("g")
-        regex.should exactly_match("q")
-        regex.should exactly_match("h")
-        regex.should_not exactly_match("z")
+        expect(regex).to exactly_match("g")
+        expect(regex).to exactly_match("q")
+        expect(regex).to exactly_match("h")
+        expect(regex).not_to exactly_match("z")
       end
 
       it "should match a regex containing a character set" do
         regex = compile("[\\p{Zs}]")
-        regex.should exactly_match([160].pack("U*"))  # non-breaking space
-        regex.should exactly_match([5760].pack("U*"))  # ogham space mark
-        regex.should_not exactly_match("a")
+        expect(regex).to exactly_match([160].pack("U*"))  # non-breaking space
+        expect(regex).to exactly_match([5760].pack("U*"))  # ogham space mark
+        expect(regex).not_to exactly_match("a")
       end
 
       it "should match a regex containing a negated character set" do
         regex = compile("[\\P{Zs}]")
-        regex.should exactly_match("a")
-        regex.should_not exactly_match([160].pack("U*"))
-        regex.should_not exactly_match([5760].pack("U*"))
+        expect(regex).to exactly_match("a")
+        expect(regex).not_to exactly_match([160].pack("U*"))
+        expect(regex).not_to exactly_match([5760].pack("U*"))
       end
 
       it "should match a regex containing a character set (alternate syntax)" do
         regex = compile("[[:Zs:]]")
-        regex.should exactly_match([160].pack("U*"))  # non-breaking space
-        regex.should exactly_match([5760].pack("U*"))  # ogham space mark
-        regex.should_not exactly_match("a")
+        expect(regex).to exactly_match([160].pack("U*"))  # non-breaking space
+        expect(regex).to exactly_match([5760].pack("U*"))  # ogham space mark
+        expect(regex).not_to exactly_match("a")
       end
 
       it "should match a regex containing a negated character set (alternate syntax)" do
         regex = compile("[[:^Zs:]]")
-        regex.should exactly_match("a")
-        regex.should_not exactly_match([160].pack("U*"))
-        regex.should_not exactly_match([5760].pack("U*"))
+        expect(regex).to exactly_match("a")
+        expect(regex).not_to exactly_match([160].pack("U*"))
+        expect(regex).not_to exactly_match([5760].pack("U*"))
       end
 
       it "should match a regex with a character set and some quantifiers" do
         regex = compile("[\\u0067-\\u0071]+")
-        regex.should exactly_match("gg")
-        regex.should exactly_match("gh")
-        regex.should exactly_match("qjk")
-        regex.should_not exactly_match("")
+        expect(regex).to exactly_match("gg")
+        expect(regex).to exactly_match("gh")
+        expect(regex).to exactly_match("qjk")
+        expect(regex).not_to exactly_match("")
       end
 
       it "should match a regex that uses special switches inside the char class" do
         regex = compile("[\\w]+")
-        regex.should exactly_match("a")
-        regex.should exactly_match("abc")
-        regex.should exactly_match("a0b_1c2")
-        regex.should_not exactly_match("$@#")
+        expect(regex).to exactly_match("a")
+        expect(regex).to exactly_match("abc")
+        expect(regex).to exactly_match("a0b_1c2")
+        expect(regex).not_to exactly_match("$@#")
       end
 
       it "should match a regex that uses negated special switches inside the char class" do
         regex = compile("[\\W]+")
-        regex.should_not exactly_match("a")
-        regex.should_not exactly_match("abc")
-        regex.should_not exactly_match("a0b_1c2")
-        regex.should exactly_match("$@#")
+        expect(regex).not_to exactly_match("a")
+        expect(regex).not_to exactly_match("abc")
+        expect(regex).not_to exactly_match("a0b_1c2")
+        expect(regex).to exactly_match("$@#")
       end
 
       it "should match a regex with a complicated expression inside the char class" do
         # not [separators U space-tilde] diff [letters diff numbers]  (diff is commutative)
         regex = compile("[^[\\p{Z}\\u0020-\\u007f]-[\\p{L}]-[\\p{N}]]")
-        regex.should exactly_match(" ")
-        regex.should exactly_match(",")
-        regex.should_not exactly_match("a")
+        expect(regex).to exactly_match(" ")
+        expect(regex).to exactly_match(",")
+        expect(regex).not_to exactly_match("a")
       end
     end
   end