ffi-icu 0.1.10 → 0.3.0

data/spec/locale_spec.rb

@@ -1,31 +1,38 @@
 # encoding: UTF-8
 
-require 'spec_helper'
-
 module ICU
   describe Locale do
     describe 'the available locales' do
       subject { Locale.available }
 
-      it { should be_an Array }
-      it { should_not be_empty }
-      its(:first) { should be_a Locale }
+      it { is_expected.to be_an Array }
+      it { is_expected.to_not be_empty }
+
+      it 'should be an array of available Locales' do
+        expect(subject.first).to be_a(Locale)
+      end
     end
 
     describe 'the available ISO 639 country codes' do
       subject { Locale.iso_countries }
 
-      it { should be_an Array }
-      it { should_not be_empty }
-      its(:first) { should be_a String }
+      it { is_expected.to be_an Array }
+      it { is_expected.to_not be_empty }
+
+      it 'should be an array of Strings' do
+        expect(subject.first).to be_a(String)
+      end
     end
 
     describe 'the available ISO 639 language codes' do
       subject { Locale.iso_languages }
 
-      it { should be_an Array }
-      it { should_not be_empty }
-      its(:first) { should be_a String }
+      it { is_expected.to be_an Array }
+      it { is_expected.to_not be_empty }
+
+      it 'should be an array of Strings' do
+        expect(subject.first).to be_a(String)
+      end
     end
 
     describe 'the default' do
@@ -37,44 +44,49 @@ module ICU
         locales.respond_to?(:sample) ? locales.sample : locales.choice
       end
 
-      it { should be_a Locale }
+      it { is_expected.to be_a Locale }
 
       it 'can be assigned using Locale' do
-        (Locale.default = locale).should == locale
-        Locale.default.should == locale
+        expect(Locale.default = locale).to eq(locale)
+        expect(Locale.default).to eq(locale)
       end
 
       it 'can be assigned using string' do
         string = locale.to_s
 
-        (Locale.default = string).should == string
-        Locale.default.should == Locale.new(string)
+        expect(Locale.default = string).to eq(string)
+        expect(Locale.default).to eq(Locale.new(string))
       end
 
       it 'can be assigned using symbol' do
         symbol = locale.to_s.to_sym
 
-        (Locale.default = symbol).should == symbol
-        Locale.default.should == Locale.new(symbol)
+        expect(Locale.default = symbol).to eq(symbol)
+        expect(Locale.default).to eq(Locale.new(symbol))
       end
     end
 
     if Gem::Version.new('4.2') <= Gem::Version.new(Lib.version)
       describe 'BCP 47 language tags' do
         it 'converts a language tag to a locale' do
-          Locale.for_language_tag('en-us').should == Locale.new('en_US')
-          Locale.for_language_tag('nan-Hant-tw').should == Locale.new('nan_Hant_TW')
+          expect(Locale.for_language_tag('en-us')).to eq(Locale.new('en_US'))
+          expect(Locale.for_language_tag('nan-Hant-tw')).to eq(Locale.new('nan_Hant_TW'))
         end
 
         it 'returns a language tag for a locale' do
           if Gem::Version.new('4.4') <= Gem::Version.new(Lib.version)
-            Locale.new('en_US').to_language_tag.should == 'en-US'
-            Locale.new('zh_TW').to_language_tag.should == 'zh-TW'
-            Locale.new('zh_Hans_CH_PINYIN').to_language_tag.should == 'zh-Hans-CH-u-co-pinyin'
+            expect(Locale.new('en_US').to_language_tag).to eq('en-US')
+            expect(Locale.new('zh_TW').to_language_tag).to eq('zh-TW')
+            # Support for this "magic" transform was dropped with https://unicode-org.atlassian.net/browse/ICU-20187, so don't test it
+            if Gem::Version.new(Lib.version) < Gem::Version.new('64')
+              expect(Locale.new('zh_Hans_CH_PINYIN').to_language_tag).to eq('zh-Hans-CH-u-co-pinyin')
+            else
+              expect(Locale.new('zh_Hans_CH@collation=pinyin').to_language_tag).to eq('zh-Hans-CH-u-co-pinyin')
+            end
           else
-            Locale.new('en_US').to_language_tag.should == 'en-us'
-            Locale.new('zh_TW').to_language_tag.should == 'zh-tw'
-            Locale.new('zh_Hans_CH_PINYIN').to_language_tag.should == 'zh-hans-ch-u-co-pinyin'
+            expect(Locale.new('en_US').to_language_tag).to eq('en-us')
+            expect(Locale.new('zh_TW').to_language_tag).to eq('zh-tw')
+            expect(Locale.new('zh_Hans_CH_PINYIN').to_language_tag).to eq('zh-hans-ch-u-co-pinyin')
           end
         end
       end
@@ -82,41 +94,54 @@ module ICU
 
     describe 'Win32 locale IDs' do
       it 'converts an LCID to a locale' do
-        Locale.for_lcid(1033).should == Locale.new('en_US')
-        Locale.for_lcid(1036).should == Locale.new('fr_FR')
+        expect(Locale.for_lcid(1033)).to eq(Locale.new('en_US'))
+        expect(Locale.for_lcid(1036)).to eq(Locale.new('fr_FR'))
       end
 
       it 'returns an LCID for a locale' do
-        Locale.new('en_US').lcid.should == 1033
-        Locale.new('es_US').lcid.should == 21514
+        expect(Locale.new('en_US').lcid).to eq(1033)
+        expect(Locale.new('es_US').lcid).to eq(21514)
       end
     end
 
     describe 'display' do
+      let(:locale_ids) { Locale.available.map(&:id) }
+
       context 'in a specific locale' do
         it 'returns the country' do
-          Locale.new('de_DE').display_country('en').should == 'Germany'
-          Locale.new('en_US').display_country('fr').should == 'États-Unis'
+          expect(Locale.new('de_DE').display_country('en')).to eq('Germany')
+          expect(Locale.new('en_US').display_country('fr')).to eq('États-Unis')
         end
 
         it 'returns the language' do
-          Locale.new('fr_FR').display_language('de').should == 'Französisch'
-          Locale.new('zh_CH').display_language('en').should == 'Chinese'
+          expect(Locale.new('fr_FR').display_language('de')).to eq('Französisch')
+          expect(Locale.new('zh_CH').display_language('en')).to eq('Chinese')
         end
 
         it 'returns the name' do
-          Locale.new('en_US').display_name('de').should == 'Englisch (Vereinigte Staaten)'
-          Locale.new('zh_CH').display_name('fr').should == 'chinois (Suisse)'
+          expect(Locale.new('en_US').display_name('de')).to eq('Englisch (Vereinigte Staaten)')
+          expect(Locale.new('zh_CH').display_name('fr')).to eq('chinois (Suisse)')
         end
 
         it 'returns the script' do
-          Locale.new('ja_Hira_JP').display_script('en').should == 'Hiragana'
-          Locale.new('ja_Hira_JP').display_script('ru').should == 'Хирагана'
+          expect(Locale.new('ja_Hira_JP').display_script('en')).to eq('Hiragana')
+          expect(Locale.new('ja_Hira_JP').display_script('ru')).to eq('хирагана')
         end
 
         it 'returns the variant' do
-          Locale.new('be_BY_TARASK').display_variant('de').should == 'Taraskievica-Orthographie'
-          Locale.new('zh_CH_POSIX').display_variant('en').should == 'Computer'
+          expect(Locale.new('be_BY_TARASK').display_variant('de')).to eq('Taraskievica-Orthographie')
+          expect(Locale.new('zh_CH_POSIX').display_variant('en')).to eq('Computer')
+        end
+
+        # If memory set for 'read_uchar_buffer' is set too low it will throw an out
+        # of bounds memory error, which results in a Segmentation fault error.
+        it 'insures memory sizes is set correctly' do
+          # Currently, testing the longest known locales. May need to be update in the future.
+          expect(Locale.new('en_VI').display_country('ccp')).to_not be_nil
+          expect(Locale.new('yue_Hant').display_language('ccp')).to_not be_nil
+          expect(Locale.new('en_VI').display_name('ccp')).to_not be_nil
+          expect(Locale.new('yue_Hant').display_script('ccp')).to_not be_nil
+          expect(Locale.new('en_US_POSIX').display_variant('sl')).to_not be_nil
         end
       end
 
@@ -124,23 +149,23 @@ module ICU
         let(:locale) { Locale.new('de_DE') }
 
         it 'returns the country' do
-          locale.display_country.should == locale.display_country(Locale.default)
+          expect(locale.display_country).to eq(locale.display_country(Locale.default))
         end
 
         it 'returns the language' do
-          locale.display_language.should == locale.display_language(Locale.default)
+          expect(locale.display_language).to eq(locale.display_language(Locale.default))
         end
 
         it 'returns the name' do
-          locale.display_name.should == locale.display_name(Locale.default)
+          expect(locale.display_name).to eq(locale.display_name(Locale.default))
         end
 
         it 'returns the script' do
-          locale.display_script.should == locale.display_script(Locale.default)
+          expect(locale.display_script).to eq(locale.display_script(Locale.default))
         end
 
         it 'returns the variant' do
-          locale.display_variant.should == locale.display_variant(Locale.default)
+          expect(locale.display_variant).to eq(locale.display_variant(Locale.default))
         end
       end
     end
@@ -148,26 +173,26 @@ module ICU
     describe 'formatting' do
       let(:locale) { Locale.new('de-de.utf8@collation = phonebook') }
 
-      it('is formatted') { locale.name.should == 'de_DE.utf8@collation=phonebook' }
-      it('is formatted without keywords') { locale.base_name.should == 'de_DE.utf8' }
-      it('is formatted for ICU') { locale.canonical.should == 'de_DE@collation=phonebook' }
+      it('is formatted') { expect(locale.name).to eq('de_DE.utf8@collation=phonebook') }
+      it('is formatted without keywords') { expect(locale.base_name).to eq('de_DE.utf8') }
+      it('is formatted for ICU') { expect(locale.canonical).to eq('de_DE@collation=phonebook') }
     end
 
     it 'truncates a properly formatted locale, returning the "parent"' do
-      Locale.new('es-mx').parent.should == ''
-      Locale.new('es_MX').parent.should == 'es'
-      Locale.new('zh_Hans_CH_PINYIN').parent.should == 'zh_Hans_CH'
+      expect(Locale.new('es-mx').parent).to eq('')
+      expect(Locale.new('es_MX').parent).to eq('es')
+      expect(Locale.new('zh_Hans_CH_PINYIN').parent).to eq('zh_Hans_CH')
     end
 
     describe 'ISO codes' do
       it 'returns the ISO 3166 alpha-3 country code' do
-        Locale.new('en_US').iso_country.should == 'USA'
-        Locale.new('zh_CN').iso_country.should == 'CHN'
+        expect(Locale.new('en_US').iso_country).to eq('USA')
+        expect(Locale.new('zh_CN').iso_country).to eq('CHN')
       end
 
       it 'returns the ISO 639 three-letter language code' do
-        Locale.new('en_US').iso_language.should == 'eng'
-        Locale.new('zh_CN').iso_language.should == 'zho'
+        expect(Locale.new('en_US').iso_language).to eq('eng')
+        expect(Locale.new('zh_CN').iso_language).to eq('zho')
       end
     end
 
@@ -184,64 +209,64 @@ module ICU
         let(:locale) { Locale.new('de_DE@currency=EUR') }
 
         it 'returns the list of keywords' do
-          locale.keywords.should == ['currency']
+          expect(locale.keywords).to eq(['currency'])
         end
       end
 
       it 'can be read' do
-        Locale.new('en_US@calendar=chinese').keyword('calendar').should == 'chinese'
-        Locale.new('en_US@calendar=chinese').keyword(:calendar).should == 'chinese'
-        Locale.new('en_US@some=thing').keyword('missing').should == ''
+        expect(Locale.new('en_US@calendar=chinese').keyword('calendar')).to eq('chinese')
+        expect(Locale.new('en_US@calendar=chinese').keyword(:calendar)).to eq('chinese')
+        expect(Locale.new('en_US@some=thing').keyword('missing')).to eq('')
       end
 
       it 'can be added' do
-        Locale.new('de_DE').with_keyword('currency', 'EUR').should == Locale.new('de_DE@currency=EUR')
-        Locale.new('de_DE').with_keyword(:currency, :EUR).should == Locale.new('de_DE@currency=EUR')
+        expect(Locale.new('de_DE').with_keyword('currency', 'EUR')).to eq(Locale.new('de_DE@currency=EUR'))
+        expect(Locale.new('de_DE').with_keyword(:currency, :EUR)).to eq(Locale.new('de_DE@currency=EUR'))
       end
 
       it 'can be added using hash' do
-        Locale.new('fr').with_keywords(:a => :b, :c => :d).should == Locale.new('fr@a=b;c=d')
+        expect(Locale.new('fr').with_keywords(:a => :b, :c => :d)).to eq(Locale.new('fr@a=b;c=d'))
       end
 
       it 'can be removed' do
-        Locale.new('en_US@some=thing').with_keyword(:some, nil).should == Locale.new('en_US')
-        Locale.new('en_US@some=thing').with_keyword(:some, '').should == Locale.new('en_US')
+        expect(Locale.new('en_US@some=thing').with_keyword(:some, nil)).to eq(Locale.new('en_US'))
+        expect(Locale.new('en_US@some=thing').with_keyword(:some, '')).to eq(Locale.new('en_US'))
       end
     end
 
     describe 'orientation' do
       it 'returns the character orientation' do
-        Locale.new('ar').character_orientation.should == :rtl
-        Locale.new('en').character_orientation.should == :ltr
-        Locale.new('fa').character_orientation.should == :rtl
+        expect(Locale.new('ar').character_orientation).to eq(:rtl)
+        expect(Locale.new('en').character_orientation).to eq(:ltr)
+        expect(Locale.new('fa').character_orientation).to eq(:rtl)
       end
 
       it 'returns the line orientation' do
-        Locale.new('ar').line_orientation.should == :ttb
-        Locale.new('en').line_orientation.should == :ttb
-        Locale.new('fa').line_orientation.should == :ttb
+        expect(Locale.new('ar').line_orientation).to eq(:ttb)
+        expect(Locale.new('en').line_orientation).to eq(:ttb)
+        expect(Locale.new('fa').line_orientation).to eq(:ttb)
       end
     end
 
     describe 'subtags' do
       let(:locale) { Locale.new('zh-hans-ch-pinyin') }
 
-      it('returns the country code')  { locale.country.should == 'CH' }
-      it('returns the language code') { locale.language.should == 'zh' }
-      it('returns the script code')   { locale.script.should == 'Hans' }
-      it('returns the variant code')  { locale.variant.should == 'PINYIN' }
+      it('returns the country code')  { expect(locale.country).to eq('CH') }
+      it('returns the language code') { expect(locale.language).to eq('zh') }
+      it('returns the script code')   { expect(locale.script).to eq('Hans') }
+      it('returns the variant code')  { expect(locale.variant).to eq('PINYIN') }
 
       describe 'likely subtags according to UTS #35' do
         it 'adds likely subtags' do
-          Locale.new('en').with_likely_subtags.should == Locale.new('en_Latn_US')
-          Locale.new('sr').with_likely_subtags.should == Locale.new('sr_Cyrl_RS')
-          Locale.new('zh_TW').with_likely_subtags.should == Locale.new('zh_Hant_TW')
+          expect(Locale.new('en').with_likely_subtags).to eq(Locale.new('en_Latn_US'))
+          expect(Locale.new('sr').with_likely_subtags).to eq(Locale.new('sr_Cyrl_RS'))
+          expect(Locale.new('zh_TW').with_likely_subtags).to eq(Locale.new('zh_Hant_TW'))
         end
 
         it 'removes likely subtags' do
-          Locale.new('en_US').with_minimized_subtags.should == Locale.new('en')
-          Locale.new('sr_RS').with_minimized_subtags.should == Locale.new('sr')
-          Locale.new('zh_Hant_TW').with_minimized_subtags.should == Locale.new('zh_TW')
+          expect(Locale.new('en_US').with_minimized_subtags).to eq(Locale.new('en'))
+          expect(Locale.new('sr_RS').with_minimized_subtags).to eq(Locale.new('sr'))
+          expect(Locale.new('zh_Hant_TW').with_minimized_subtags).to eq(Locale.new('zh_TW'))
         end
       end
     end

data/spec/normalization_spec.rb

@@ -1,7 +1,5 @@
 # encoding: UTF-8
 
-require 'spec_helper'
-
 module ICU
   module Normalization
     #  http://bugs.icu-project.org/trac/browser/icu/trunk/source/test/cintltst/cnormtst.c
@@ -9,11 +7,11 @@ module ICU
     describe "Normalization" do
 
       it "should normalize a string - decomposed" do
-        ICU::Normalization.normalize("Å", :nfd).unpack("U*").should == [65, 778]
+        expect(ICU::Normalization.normalize("Å", :nfd).unpack("U*")).to eq([65, 778])
       end
 
       it "should normalize a string - composed" do
-        ICU::Normalization.normalize("Å", :nfc).unpack("U*").should == [197]
+        expect(ICU::Normalization.normalize("Å", :nfc).unpack("U*")).to eq([197])
       end
 
       # TODO: add more normalization tests

data/spec/normalizer_spec.rb

@@ -1,21 +1,19 @@
 # encoding: UTF-8
 
-require 'spec_helper'
-
 module ICU
   describe Normalizer do
     describe 'NFD: nfc decompose' do
       let(:normalizer) { ICU::Normalizer.new(nil, 'nfc', :decompose) }
 
       it "should normalize a string" do
-        normalizer.normalize("Å").unpack("U*").should == [65, 778]
-        normalizer.normalize("ô").unpack("U*").should == [111, 770]
-        normalizer.normalize("a").unpack("U*").should == [97]
-        normalizer.normalize("中文").unpack("U*").should == [20013, 25991]
-        normalizer.normalize("Äffin").unpack("U*").should == [65, 776, 102, 102, 105, 110]
-        normalizer.normalize("Äffin").unpack("U*").should == [65, 776, 64259, 110]
-        normalizer.normalize("Henry IV").unpack("U*").should == [72, 101, 110, 114, 121, 32, 73, 86]
-        normalizer.normalize("Henry Ⅳ").unpack("U*").should == [72, 101, 110, 114, 121, 32, 8547]
+        expect(normalizer.normalize("Å").unpack("U*")).to eq([65, 778])
+        expect(normalizer.normalize("ô").unpack("U*")).to eq([111, 770])
+        expect(normalizer.normalize("a").unpack("U*")).to eq([97])
+        expect(normalizer.normalize("中文").unpack("U*")).to eq([20013, 25991])
+        expect(normalizer.normalize("Äffin").unpack("U*")).to eq([65, 776, 102, 102, 105, 110])
+        expect(normalizer.normalize("Äffin").unpack("U*")).to eq([65, 776, 64259, 110])
+        expect(normalizer.normalize("Henry IV").unpack("U*")).to eq([72, 101, 110, 114, 121, 32, 73, 86])
+        expect(normalizer.normalize("Henry Ⅳ").unpack("U*")).to eq([72, 101, 110, 114, 121, 32, 8547])
       end
     end
 
@@ -23,14 +21,14 @@ module ICU
       let(:normalizer) { ICU::Normalizer.new(nil, 'nfc', :compose) }
 
       it "should normalize a string" do
-        normalizer.normalize("Å").unpack("U*").should == [197]
-        normalizer.normalize("ô").unpack("U*").should == [244]
-        normalizer.normalize("a").unpack("U*").should == [97]
-        normalizer.normalize("中文").unpack("U*").should == [20013, 25991]
-        normalizer.normalize("Äffin").unpack("U*").should == [196, 102, 102, 105, 110]
-        normalizer.normalize("Äffin").unpack("U*").should == [196, 64259, 110]
-        normalizer.normalize("Henry IV").unpack("U*").should == [72, 101, 110, 114, 121, 32, 73, 86]
-        normalizer.normalize("Henry Ⅳ").unpack("U*").should == [72, 101, 110, 114, 121, 32, 8547]
+        expect(normalizer.normalize("Å").unpack("U*")).to eq([197])
+        expect(normalizer.normalize("ô").unpack("U*")).to eq([244])
+        expect(normalizer.normalize("a").unpack("U*")).to eq([97])
+        expect(normalizer.normalize("中文").unpack("U*")).to eq([20013, 25991])
+        expect(normalizer.normalize("Äffin").unpack("U*")).to eq([196, 102, 102, 105, 110])
+        expect(normalizer.normalize("Äffin").unpack("U*")).to eq([196, 64259, 110])
+        expect(normalizer.normalize("Henry IV").unpack("U*")).to eq([72, 101, 110, 114, 121, 32, 73, 86])
+        expect(normalizer.normalize("Henry Ⅳ").unpack("U*")).to eq([72, 101, 110, 114, 121, 32, 8547])
       end
     end
 
@@ -38,10 +36,10 @@ module ICU
       let(:normalizer) { ICU::Normalizer.new(nil, 'nfkc', :decompose) }
 
       it "should normalize a string" do
-        normalizer.normalize("Äffin").unpack("U*").should == [65, 776, 102, 102, 105, 110]
-        normalizer.normalize("Äffin").unpack("U*").should == [65, 776, 102, 102, 105, 110]
-        normalizer.normalize("Henry IV").unpack("U*").should == [72, 101, 110, 114, 121, 32, 73, 86]
-        normalizer.normalize("Henry Ⅳ").unpack("U*").should == [72, 101, 110, 114, 121, 32, 73, 86]
+        expect(normalizer.normalize("Äffin").unpack("U*")).to eq([65, 776, 102, 102, 105, 110])
+        expect(normalizer.normalize("Äffin").unpack("U*")).to eq([65, 776, 102, 102, 105, 110])
+        expect(normalizer.normalize("Henry IV").unpack("U*")).to eq([72, 101, 110, 114, 121, 32, 73, 86])
+        expect(normalizer.normalize("Henry Ⅳ").unpack("U*")).to eq([72, 101, 110, 114, 121, 32, 73, 86])
       end
     end
 
@@ -49,10 +47,10 @@ module ICU
       let(:normalizer) { ICU::Normalizer.new(nil, 'nfkc', :compose) }
 
       it "should normalize a string" do
-        normalizer.normalize("Äffin").unpack("U*").should == [196, 102, 102, 105, 110]
-        normalizer.normalize("Äffin").unpack("U*").should == [196, 102, 102, 105, 110]
-        normalizer.normalize("Henry IV").unpack("U*").should == [72, 101, 110, 114, 121, 32, 73, 86]
-        normalizer.normalize("Henry Ⅳ").unpack("U*").should == [72, 101, 110, 114, 121, 32, 73, 86]
+        expect(normalizer.normalize("Äffin").unpack("U*")).to eq([196, 102, 102, 105, 110])
+        expect(normalizer.normalize("Äffin").unpack("U*")).to eq([196, 102, 102, 105, 110])
+        expect(normalizer.normalize("Henry IV").unpack("U*")).to eq([72, 101, 110, 114, 121, 32, 73, 86])
+        expect(normalizer.normalize("Henry Ⅳ").unpack("U*")).to eq([72, 101, 110, 114, 121, 32, 73, 86])
       end
     end
   end # Normalizer

data/spec/number_formatting_spec.rb

@@ -1,68 +1,71 @@
 # encoding: UTF-8
 
-require 'spec_helper'
-
 module ICU
   module NumberFormatting
     describe 'NumberFormatting' do
       it 'should format a simple integer' do
-        NumberFormatting.format_number("en", 1).should == "1"
-        NumberFormatting.format_number("en", 1_000).should == "1,000"
-        NumberFormatting.format_number("de-DE", 1_000_000).should == "1.000.000"
+        expect(NumberFormatting.format_number("en", 1)).to eq("1")
+        expect(NumberFormatting.format_number("en", 1_000)).to eq("1,000")
+        expect(NumberFormatting.format_number("de-DE", 1_000_000)).to eq("1.000.000")
       end
 
       it 'should format a float' do
-        NumberFormatting.format_number("en", 1.0).should == "1"
-        NumberFormatting.format_number("en", 1.123).should == "1.123"
-        NumberFormatting.format_number("en", 1_000.1238).should == "1,000.124"
-        NumberFormatting.format_number("en", 1_000.1238, max_fraction_digits: 4).should == "1,000.1238"
+        expect(NumberFormatting.format_number("en", 1.0)).to eq("1")
+        expect(NumberFormatting.format_number("en", 1.123)).to eq("1.123")
+        expect(NumberFormatting.format_number("en", 1_000.1238)).to eq("1,000.124")
+        expect(NumberFormatting.format_number("en", 1_000.1238, max_fraction_digits: 4)).to eq("1,000.1238")
         NumberFormatting.set_default_options(fraction_digits: 5)
-        NumberFormatting.format_number("en", 1_000.1238).should == "1,000.12380"
+        expect(NumberFormatting.format_number("en", 1_000.1238)).to eq("1,000.12380")
         NumberFormatting.clear_default_options
       end
 
       it 'should format a decimal' do
-        NumberFormatting.format_number("en", BigDecimal.new("10000.123")).should == "10,000.123"
+        expect(NumberFormatting.format_number("en", BigDecimal("10000.123"))).to eq("10,000.123")
       end
 
       it 'should format a currency' do
-        NumberFormatting.format_currency("en", 123.45, 'USD').should == "$123.45"
-        NumberFormatting.format_currency("en", 123_123.45, 'USD').should == "$123,123.45"
-        NumberFormatting.format_currency("de-DE", 123_123.45, 'EUR').should == "123.123,45\u{A0}€"
+        expect(NumberFormatting.format_currency("en", 123.45, 'USD')).to eq("$123.45")
+        expect(NumberFormatting.format_currency("en", 123_123.45, 'USD')).to eq("$123,123.45")
+        expect(NumberFormatting.format_currency("de-DE", 123_123.45, 'EUR')).to eq("123.123,45\u{A0}€")
       end
 
       it 'should format a percent' do
-        NumberFormatting.format_percent("en", 1.1).should == "110%"
-        NumberFormatting.format_percent("da", 0.15).should == "15\u{A0}%"
-        NumberFormatting.format_percent("da", -0.1545, max_fraction_digits: 10).should == "-15,45\u{A0}%"
+        expect(NumberFormatting.format_percent("en", 1.1)).to eq("110%")
+        expect(NumberFormatting.format_percent("da", 0.15)).to eq("15\u{A0}%")
+        expect(NumberFormatting.format_percent("da", -0.1545, max_fraction_digits: 10)).to eq("-15,45\u{A0}%")
       end
 
       it 'should spell numbers' do
-        NumberFormatting.spell("en_US", 1_000).should == 'one thousand'
-        NumberFormatting.spell("de-DE", 123.456).should == "ein\u{AD}hundert\u{AD}drei\u{AD}und\u{AD}zwanzig Komma vier fünf sechs"
+        expect(NumberFormatting.spell("en_US", 1_000)).to eq('one thousand')
+        expect(NumberFormatting.spell("de-DE", 123.456)).to eq("ein\u{AD}hundert\u{AD}drei\u{AD}und\u{AD}zwanzig Komma vier fünf sechs")
       end
 
       it 'should be able to re-use number formatter objects' do
         numf = NumberFormatting.create('fr-CA')
-        numf.format(1_000).should == "1\u{A0}000"
-        numf.format(1_000.123).should == "1\u{A0}000,123"
+        expect(numf.format(1_000)).to eq("1\u{A0}000")
+        expect(numf.format(1_000.123)).to eq("1\u{A0}000,123")
       end
 
       it 'should be able to re-use currency formatter objects' do
         curf = NumberFormatting.create('en-US', :currency)
-        curf.format(1_000.12, 'USD').should == "$1,000.12"
+        expect(curf.format(1_000.12, 'USD')).to eq("$1,000.12")
       end
 
       it 'should allow for various styles of currency formatting if the version is new enough' do
         if ICU::Lib.version.to_a.first >= 53
           curf = NumberFormatting.create('en-US', :currency, style: :iso)
-          curf.format(1_000.12, 'USD').should == "USD1,000.12"
+          expected = if ICU::Lib.version.to_a.first >= 62
+            "USD\u00A01,000.12"
+          else
+            "USD1,000.12"
+          end
+          expect(curf.format(1_000.12, 'USD')).to eq(expected)
           curf = NumberFormatting.create('en-US', :currency, style: :plural)
-          curf.format(1_000.12, 'USD').should == "1,000.12 US dollars"
+          expect(curf.format(1_000.12, 'USD')).to eq("1,000.12 US dollars")
           expect { NumberFormatting.create('en-US', :currency, style: :fake) }.to raise_error(StandardError)
         else
           curf = NumberFormatting.create('en-US', :currency, style: :default)
-          curf.format(1_000.12, 'USD').should == '$1,000.12'
+          expect(curf.format(1_000.12, 'USD')).to eq('$1,000.12')
           expect { NumberFormatting.create('en-US', :currency, style: :iso) }.to raise_error(StandardError)
         end
       end