ffi-icu 0.5.2 → 0.6.0

data/spec/collation_spec.rb

@@ -1,84 +0,0 @@
-# encoding: UTF-8
-
-module ICU
-  module Collation
-    describe "Collation" do
-      it "should collate an array of strings" do
-        expect(Collation.collate("nb", %w[æ å ø])).to eq(%w[æ ø å])
-      end
-    end
-
-    describe Collator do
-      let(:collator) { Collator.new("nb") }
-
-      it "should collate an array of strings" do
-        expect(collator.collate(%w[å ø æ])).to eq(%w[æ ø å])
-      end
-
-      it "raises an error if argument does not respond to :sort" do
-        expect { collator.collate(1) }.to raise_error(ArgumentError)
-      end
-
-      it "should return available locales" do
-        locales = ICU::Collation.available_locales
-        expect(locales).to be_an(Array)
-        expect(locales).to_not be_empty
-        expect(locales).to include("nb")
-      end
-
-      it "should return the locale of the collator" do
-        expect(collator.locale).to eq('nb')
-      end
-
-      it "should compare two strings" do
-        expect(collator.compare("blåbærsyltetøy", "blah")).to eq(1)
-        expect(collator.compare("blah", "blah")).to eq(0)
-        expect(collator.compare("ba", "bl")).to eq(-1)
-      end
-
-      it "should know if a string is greater than another" do
-        expect(collator).to be_greater("z", "a")
-        expect(collator).to_not be_greater("a", "z")
-      end
-
-      it "should know if a string is greater or equal to another" do
-        expect(collator).to be_greater_or_equal("z", "a")
-        expect(collator).to be_greater_or_equal("z", "z")
-        expect(collator).to_not be_greater_or_equal("a", "z")
-      end
-
-      it "should know if a string is equal to another" do
-        expect(collator).to be_equal("a", "a")
-        expect(collator).to_not be_equal("a", "b")
-      end
-
-      it "should return rules" do
-        expect(collator.rules).to_not be_empty
-        # ö sorts before Ö
-        expect(collator.rules).to include('ö<<<Ö')
-      end
-
-      it "returns usable collation keys" do
-        collator.collation_key("abc").should be < collator.collation_key("xyz")
-      end
-
-      context "attributes" do
-        it "can set and get normalization_mode" do
-          collator.normalization_mode = true
-          collator.normalization_mode.should be true
-
-          collator[:normalization_mode].should be true
-          collator[:normalization_mode] = false
-          collator.normalization_mode.should be false
-
-          collator.case_first.should be false
-          collator.case_first = :lower_first
-          collator.case_first.should == :lower_first
-
-          collator.strength = :tertiary
-          collator.strength.should == :tertiary
-        end
-      end
-    end
-  end # Collate
-end # ICU

data/spec/duration_formatting_spec.rb

@@ -1,143 +0,0 @@
-module ICU
-    module DurationFormatting
-        describe 'DurationFormatting::format' do
-            before(:each) do
-                skip("Only works on ICU >= 67") if Lib.version.to_a[0] < 67
-              end
-
-            it 'produces hours, minutes, and seconds in order' do
-                result = DurationFormatting.format({hours: 1, minutes: 2, seconds: 3}, locale: 'C', style: :long)
-                expect(result).to match(/1.*hour.*2.*minute.*3.*second/i)
-            end
-
-            it 'rounds down fractional seconds < 0.5' do
-                result = DurationFormatting.format({seconds: 5.4}, locale: 'C', style: :long)
-                expect(result).to match(/5.*second/i)
-            end
-
-            it 'rounds up fractional seconds > 0.5' do
-                result = DurationFormatting.format({seconds: 5.6}, locale: 'C', style: :long)
-                expect(result).to match(/6.*second/i)
-            end
-
-            it 'trims off leading zero values' do
-                result = DurationFormatting.format({hours: 0, minutes: 1, seconds: 30}, locale: 'C', style: :long)
-                expect(result).to match(/1.*minute.*30.*second/i)
-                expect(result).to_not match(/hour/i)
-            end
-
-            it 'trims off leading missing values' do
-                result = DurationFormatting.format({minutes: 1, seconds: 30}, locale: 'C', style: :long)
-                expect(result).to match(/1.*minute.*30.*second/i)
-                expect(result).to_not match(/hour/i)
-            end
-
-            it 'trims off non-leading zero values' do
-                result = DurationFormatting.format({hours: 1, minutes: 0, seconds: 10}, locale: 'C', style: :long)
-                expect(result).to match(/1.*hour.*10.*second/i)
-                expect(result).to_not match(/minute/i)
-            end
-
-            it 'trims off non-leading missing values' do
-                result = DurationFormatting.format({hours: 1, seconds: 10}, locale: 'C', style: :long)
-                expect(result).to match(/1.*hour.*10.*second/i)
-                expect(result).to_not match(/minute/i)
-            end
-
-            it 'uses comma-based number formatting as appropriate for locale' do
-                result = DurationFormatting.format({seconds: 90123}, locale: 'en-AU', style: :long)
-                expect(result).to match(/90,123.*second/i)
-                expect(result).to_not match(/hour/i)
-                expect(result).to_not match(/minute/i)
-            end
-
-            it 'localizes unit names' do
-                result = DurationFormatting.format({hours: 1, minutes: 2, seconds: 3}, locale: 'el', style: :long)
-                expect(result).to match(/1.*ώρα.*2.*λεπτά.*3.*δευτερόλεπτα/i)
-            end
-
-            it 'can format long' do
-                result = DurationFormatting.format({hours: 1, minutes: 2, seconds: 3}, locale: 'en-AU', style: :long)
-                expect(result).to match(/hour.*minute.*second/i)
-            end
-
-            it 'can format short' do
-                result = DurationFormatting.format({hours: 1, minutes: 2, seconds: 3}, locale: 'en-AU', style: :short)
-                expect(result).to match(/hr.*min.*sec/i)
-                expect(result).to_not match(/hour/i)
-                expect(result).to_not match(/minute/i)
-                expect(result).to_not match(/second/i)
-            end
-
-            it 'can format narrow' do
-                result = DurationFormatting.format({hours: 1, minutes: 2, seconds: 3}, locale: 'en-AU', style: :narrow)
-                expect(result).to match(/h.*min.*s/i)
-                expect(result).to_not match(/hr/i)
-                expect(result).to_not match(/sec/i)
-            end
-
-            it 'can format digital' do
-                result = DurationFormatting.format({hours: 1, minutes: 2, seconds: 3}, locale: 'en-AU', style: :digital)
-                expect(result).to eql('1:02:03')
-            end
-
-            it 'can format the full sequence of time units in order' do
-                duration = {
-                    years: 1,
-                    months: 2,
-                    weeks: 3,
-                    days: 4,
-                    hours: 5,
-                    minutes: 6,
-                    seconds: 7,
-                    milliseconds: 8,
-                    microseconds: 9,
-                    nanoseconds: 10,
-                }
-                result = DurationFormatting.format(duration, locale: 'en-AU', style: :short)
-                expect(result).to match(/1.yr.*2.*mths.*3.*wks.*4.*days.*5.*hrs.*6.*mins.*7.*secs.*8.*ms.*9.*μs.*10.*ns/)
-            end
-
-            it 'joins ms, us, ns values to seconds in digital format' do
-                duration = {minutes: 10, seconds: 5, milliseconds: 325, microseconds: 53, nanoseconds: 236}
-                result = DurationFormatting.format(duration, locale: 'en-AU', style: :digital)
-                expect(result).to eql('10:05.325053236')
-            end
-
-            it 'includes trailing zeros as appropriate for the last unit in digital format' do
-                duration = {minutes: 10, seconds: 5, milliseconds: 325, microseconds: 400}
-                result = DurationFormatting.format(duration, locale: 'en-AU', style: :digital)
-                expect(result).to eql('10:05.325400')
-            end
-
-            it 'joins h:mm:ss and other units in digital format' do
-                duration = {days: 8, hours: 23, minutes: 10, seconds: 9}
-                result = DurationFormatting.format(duration, locale: 'en-AU', style: :digital)
-                expect(result).to match(/8.*d.*23:10:09/  )
-            end
-
-            it 'ignores all decimal parts except the last, if it is seconds' do
-                duration = {hours: 7.3, minutes: 9.7, seconds: 8.93}
-                result = DurationFormatting.format(duration, locale: 'en-AU', style: :short)
-                expect(result).to match(/7[^0-9]*hrs.*9[^0-9]*min.*8\.93[^0-9]*secs/)
-            end
-
-            it 'ignores all decimal parts except the last, if it is milliseconds' do
-                duration = {hours: 7.3, minutes: 9.7, seconds: 8.93, milliseconds: 632.2}
-                result = DurationFormatting.format(duration, locale: 'en-AU', style: :short)
-                expect(result).to match(/7[^0-9]*hrs.*9[^0-9]*min.*8[^0-9]*secs.*632\.2[^0-9]*ms/)
-            end
-
-            it 'ignores all decimal parts including the last, if it is > seconds' do
-                duration = {hours: 7.3, minutes: 9.7}
-                result = DurationFormatting.format(duration, locale: 'en-AU', style: :short)
-                expect(result).to match(/7[^0-9]*hrs.*9[^0-9]*min/)
-            end
-
-            it 'raises on durations with any negative component' do
-                duration = {hours: 7.3, minutes: -9.7}
-                expect { DurationFormatting.format(duration, locale: 'en-AU') }.to raise_error(ArgumentError)
-            end
-        end
-    end
-end

data/spec/lib/version_info_spec.rb

@@ -1,20 +0,0 @@
-# encoding: UTF-8
-
-module ICU
-  module Lib
-    describe VersionInfo do
-      describe '.to_a' do
-        subject { described_class.new.to_a }
-
-        it { is_expected.to be_an(Array) }
-      end
-
-      describe '.to_s' do
-        subject { described_class.new.to_s }
-
-        it { is_expected.to be_a(String) }
-        it { is_expected.to match(/^[0-9.]+$/) }
-      end
-    end
-  end
-end

data/spec/lib_spec.rb

@@ -1,63 +0,0 @@
-# encoding: UTF-8
-
-module ICU
-  describe Lib do
-    describe 'error checking' do
-      let(:return_value) { double }
-
-      context 'upon success' do
-        it 'returns the block result' do
-          expect(Lib.check_error { |status| return_value }).to eq(return_value)
-          expect(Lib.check_error { |status| status.write_int(0); return_value }).to eq(return_value)
-        end
-      end
-
-      context 'upon failure' do
-        it 'raises an error' do
-          expect { Lib.check_error { |status| status.write_int(1) } }.to raise_error ICU::Error, /U_.*_ERROR/
-        end
-      end
-
-      context 'upon warning' do
-        before(:each) { @verbose = $VERBOSE }
-        after(:each) { $VERBOSE = @verbose }
-
-        context 'when warnings are enabled' do
-          before(:each) { $VERBOSE = true }
-
-          it 'prints to STDERR and returns the block result' do
-            expect($stderr).to receive(:puts) { |message| expect(message).to match /U_.*_WARNING/ }
-            error_check = Lib.check_error { |status| status.write_int(-127); return_value }
-            expect(error_check).to eq(return_value)
-          end
-        end
-
-        context 'when warnings are disabled' do
-          before(:each) { $VERBOSE = false }
-
-          it 'returns the block result' do
-            expect($stderr).to_not receive(:puts)
-            error_check = Lib.check_error { |status| status.write_int(-127); return_value }
-            expect(error_check).to eq(return_value)
-          end
-        end
-      end
-    end
-
-    if Gem::Version.new('4.2') <= Gem::Version.new(Lib.version)
-      describe 'CLDR version' do
-        subject { Lib.cldr_version }
-
-        it { should be_a Lib::VersionInfo }
-        it('is populated') { expect(subject.to_a).to_not eq([0,0,0,0]) }
-      end
-    end
-
-    describe 'ICU version' do
-      subject { Lib.version }
-
-      it { is_expected.to be_a Lib::VersionInfo }
-      it('is populated') { expect(subject.to_a).to_not eq([0,0,0,0]) }
-    end
-  end
-end

data/spec/locale_spec.rb

@@ -1,280 +0,0 @@
-# encoding: UTF-8
-
-module ICU
-  describe Locale do
-    describe 'the available locales' do
-      subject { Locale.available }
-
-      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 { 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 { 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
-      subject { Locale.default }
-
-      let(:locale) do
-        locales = Locale.available
-        locales.delete(Locale.default)
-        locales.respond_to?(:sample) ? locales.sample : locales.choice
-      end
-
-      it { is_expected.to be_a Locale }
-
-      it 'can be assigned using Locale' do
-        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
-
-        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
-
-        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
-          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)
-            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
-            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
-    end
-
-    describe 'Win32 locale IDs' do
-      it 'converts an LCID to a locale' do
-        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
-        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
-          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
-          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
-          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 name using display context' do
-          expect(Locale.new('en_US').display_name_with_context('en_HK', [:length_full])).to eq('English (Hong Kong SAR China)')
-          expect(Locale.new('en_US').display_name_with_context('en_HK', [:length_short])).to eq('English (Hong Kong)')
-        end
-
-        it 'returns the script' do
-          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
-          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('ccp').display_name_with_context('en_VI')).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
-
-      context 'in the default locale' do
-        let(:locale) { Locale.new('de_DE') }
-
-        it 'returns the country' do
-          expect(locale.display_country).to eq(locale.display_country(Locale.default))
-        end
-
-        it 'returns the language' do
-          expect(locale.display_language).to eq(locale.display_language(Locale.default))
-        end
-
-        it 'returns the name' do
-          expect(locale.display_name).to eq(locale.display_name(Locale.default))
-        end
-
-        it 'returns the script' do
-          expect(locale.display_script).to eq(locale.display_script(Locale.default))
-        end
-
-        it 'returns the variant' do
-          expect(locale.display_variant).to eq(locale.display_variant(Locale.default))
-        end
-      end
-    end
-
-    describe 'formatting' do
-      let(:locale) { Locale.new('de-de.utf8@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
-      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
-        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
-        expect(Locale.new('en_US').iso_language).to eq('eng')
-        expect(Locale.new('zh_CN').iso_language).to eq('zho')
-      end
-    end
-
-    describe 'keywords' do
-      context 'when improperly formatted' do
-        let(:locale) { Locale.new('de_DE@euro') }
-
-        it 'raises an error' do
-          expect { locale.keywords }.to raise_error(ICU::Error)
-        end
-      end
-
-      context 'when properly formatted' do
-        let(:locale) { Locale.new('de_DE@currency=EUR') }
-
-        it 'returns the list of keywords' do
-          expect(locale.keywords).to eq(['currency'])
-        end
-      end
-
-      it 'can be read' do
-        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
-        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
-        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
-        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
-        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
-        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')  { 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
-          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
-          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
-  end
-end

data/spec/normalization_spec.rb

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

data/spec/normalizer_spec.rb

@@ -1,57 +0,0 @@
-# encoding: UTF-8
-
-module ICU
-  describe Normalizer do
-    describe 'NFD: nfc decompose' do
-      let(:normalizer) { ICU::Normalizer.new(nil, 'nfc', :decompose) }
-
-      it "should normalize a string" do
-        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
-
-    describe 'NFC: nfc compose' do
-      let(:normalizer) { ICU::Normalizer.new(nil, 'nfc', :compose) }
-
-      it "should normalize a string" do
-        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
-
-    describe 'NFKD: nfkc decompose' do
-      let(:normalizer) { ICU::Normalizer.new(nil, 'nfkc', :decompose) }
-
-      it "should normalize a string" do
-        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
-
-    describe 'NFKC: nfkc compose' do
-      let(:normalizer) { ICU::Normalizer.new(nil, 'nfkc', :compose) }
-
-      it "should normalize a string" do
-        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
-end # ICU