twitter_cldr 4.3.1 → 4.4.0

data/spec/collation/trie_loader_spec.rb

@@ -66,7 +66,11 @@ describe TrieLoader do
   end
 
   def mock_trie_dump
-    mock(File).open(TrieLoader.dump_path(locale), 'r') { |*args| args.last.call(trie_dump) }
+    expect(File).to(
+      receive(:open)
+        .with(TrieLoader.dump_path(locale), 'r')
+        .and_yield(trie_dump)
+    )
   end
 
 end

data/spec/collation/trie_with_fallback_spec.rb

@@ -16,24 +16,24 @@ describe TrieWithFallback do
 
   describe '#get' do
     it 'returns result if the key is present' do
-      dont_allow(fallback).get
+      expect(fallback).to_not receive(:get)
       expect(trie.get([1, 2, 3])).to eq('value')
     end
 
     it 'resorts to the fallback if the key is not present' do
-      mock(fallback).get([3, 2, 1]) { 'fallback-value' }
+      expect(fallback).to receive(:get).with([3, 2, 1]).and_return('fallback-value')
       expect(trie.get([3, 2, 1])).to eq('fallback-value')
     end
   end
 
   describe '#find_prefix' do
     it 'returns result if the key is present' do
-      dont_allow(fallback).find_prefix
+      expect(fallback).to_not receive(:find_prefix)
       expect(trie.find_prefix([1, 2, 3, 4]).first(2)).to eq(['value', 3])
     end
 
     it 'resorts to the fallback if the key is not present' do
-      mock(fallback).find_prefix([3, 2, 1]) { 'fallback-result' }
+      expect(fallback).to receive(:find_prefix).with([3, 2, 1]).and_return('fallback-result')
       expect(trie.find_prefix([3, 2, 1])).to eq('fallback-result')
     end
   end

data/spec/core_ext_spec.rb

@@ -6,13 +6,7 @@
 require 'spec_helper'
 
 describe 'Core classes localization' do
-  core_classes = [Array, DateTime, Float, String, Symbol, Time]
-
-  if RUBY_VERSION >= '2.4.0'
-    core_classes.push Integer
-  else
-    core_classes.push Bignum, Fixnum
-  end
+  core_classes = [Array, DateTime, Float, String, Symbol, Time, Integer]
 
   core_classes.each do |klass|
     describe klass do

data/spec/data_readers/date_time_data_reader_spec.rb

@@ -19,7 +19,7 @@ describe DateTimeDataReader do
 
   describe "#pattern" do
     it "as of CLDR 23, should choose the medium date time path if no other type is specified" do
-      mock.proxy(data_reader).path_for(:medium, anything)
+      expect(data_reader).to receive(:path_for).with(:medium, anything).and_call_original
       data_reader.pattern
     end
   end

data/spec/data_readers/number_data_reader_spec.rb

@@ -33,7 +33,7 @@ describe NumberDataReader do
     let(:symbols) { { nan: 'NaN', minus_sign: '<->' } } # unique locale-specific minus sign
 
     before(:each) do
-      stub(TwitterCldr).get_locale_resource(:en, :numbers) {
+      allow(TwitterCldr).to receive(:get_locale_resource).with(:en, :numbers) {
         {
           en: {
             numbers: {

data/spec/formatters/calendars/datetime_formatter_spec.rb

@@ -429,17 +429,17 @@ describe DateTimeFormatter do
     end
 
     it "should fall back if the calendar doesn't contain the appropriate era data" do
-      stub(@formatter.data_reader.calendar).eras(:abbr) do
+      allow(@formatter.data_reader.calendar).to receive(:eras).with(:abbr) do
         { 0 => "abbr0", 1 => "abbr1" }
       end
 
-      stub(@formatter.data_reader.calendar).eras(:name) do
+      allow(@formatter.data_reader.calendar).to receive(:eras).with(:name) do
         { 0 => "name0" }
       end
 
       date = Date.new(2012, 1, 1)
-      mock.proxy(@formatter).era(date, "GGGG", 4)  # first attempts to find full name era
-      mock.proxy(@formatter).era(date, "GGG", 3)   # falls back to abbreviated era
+      expect(@formatter).to receive(:era).with(date, "GGGG", 4).and_call_original  # first attempts to find full name era
+      expect(@formatter).to receive(:era).with(date, "GGG", 3).and_call_original   # falls back to abbreviated era
       expect(@formatter.send(:era, date, 'GGGG', 4)).to eq("abbr1")
     end
   end
@@ -470,4 +470,4 @@ describe DateTimeFormatter do
       expect(@formatter.send(:month_stand_alone, Date.new(2010,  10, 1), 'LLLLL', 5)).to eq("O")
     end
   end
-end
+end

data/spec/formatters/plurals/plural_formatter_spec.rb

@@ -23,7 +23,7 @@ describe PluralFormatter do
     subject { PluralFormatter.new }
 
     before(:each) do
-      stub(subject).pluralization_rule { |n| n == 1 ? :one : :other  }
+      allow(subject).to receive(:pluralization_rule) { |n| n == 1 ? :one : :other  }
     end
 
     let(:horses)        { { one: 'is 1 horse', other: 'are %{horses_count} horses' } }
@@ -197,9 +197,9 @@ describe PluralFormatter do
 
   describe '#pluralization_rule' do
     it 'delegates pluralization rule fetching to Rules.rule_for method' do
-      mock(Plurals::Rules).rule_for(42, :jp) { 'result' }
+      expect(Plurals::Rules).to receive(:rule_for).with(42, :jp).and_return('result')
       expect(PluralFormatter.new(:jp).send(:pluralization_rule, 42)).to eq('result')
     end
   end
 
-end
+end

data/spec/formatters/plurals/rules_spec.rb

@@ -45,7 +45,7 @@ describe Rules do
     end
 
     it "returns :other if there's an error" do
-      stub(Rules).get_resource { lambda { raise "Jelly beans" } }
+      allow(Rules).to receive(:get_resource).and_return(lambda { raise "Jelly beans" })
       expect(Rules.rule_for(1, :en)).to eq(:other)
       expect(Rules.rule_for(1, :ru)).to eq(:other)
     end
@@ -88,7 +88,7 @@ describe Rules do
 
   describe "#all" do
     before(:each) do
-      mock(TwitterCldr).locale { :ru }
+      expect(TwitterCldr).to receive(:locale).and_return(:ru)
     end
 
     it "gets rules for the default locale (usually supplied by FastGettext)" do

data/spec/localized/localized_array_spec.rb

@@ -20,7 +20,11 @@ describe LocalizedArray do
     let(:sorted)    { %w[aaa abc bca] }
     let(:localized) { array.localize(locale) }
 
-    before(:each) { mock(TwitterCldr::Collation::Collator).new(locale) { FakeCollator.new } }
+    before(:each) do
+      expect(TwitterCldr::Collation::Collator).to(
+        receive(:new).with(locale).and_return(FakeCollator.new)
+      )
+    end
 
     describe '#sort' do
       it 'returns a new LocalizedArray' do
@@ -84,4 +88,4 @@ class FakeCollator
   def sort!(array)
     array.sort!
   end
-end
+end

data/spec/localized/localized_date_spec.rb

@@ -16,7 +16,7 @@ describe LocalizedDate do
     let(:base_time) { Time.gm(2010, 8, 6, 12, 12, 30) }
 
     it "should ago-ify from now when no base_time given" do
-      stub(Time).now { Time.gm(2010, 8, 6, 12, 12, 30) }
+      allow(Time).to receive(:now).and_return(Time.gm(2010, 8, 6, 12, 12, 30))
       loc_date = date_time.localize(:ko).to_date
       expect(loc_date.ago.to_s(unit: :hour)).to match_normalized("744시간 전")
     end

data/spec/localized/localized_datetime_spec.rb

@@ -90,9 +90,7 @@ describe LocalizedDateTime do
       TwitterCldr.supported_locales.each do |locale|
         data_reader = TwitterCldr::DataReaders::CalendarDataReader.new(locale)
         data_reader.additional_format_selector.patterns.each do |pattern|
-          # puts "#{locale}: #{pattern}"
-          # lambda { date_time.localize(locale).to_additional_s(pattern.to_s) }.should_not raise_error
-          date_time.localize(locale).to_additional_s(pattern.to_s)
+          expect { date_time.localize(locale).to_additional_s(pattern.to_s) }.to_not raise_error
         end
       end
     end
@@ -115,7 +113,7 @@ describe LocalizedDateTime do
   describe "#to_s" do
     it "uses the default format if no :format is given" do
       loc_date = date_time.localize
-      mock.proxy(loc_date).to_default_s
+      expect(loc_date).to receive(:to_default_s).and_call_original
       expect(loc_date.to_s).to eq("Sep 20, 1987, 10:05:00 PM")
     end
   end

data/spec/localized/localized_object_spec.rb

@@ -71,14 +71,14 @@ describe LocalizedObject do
     end
 
     it 'accepts locale and options and pass them to the localized class constructor' do
-      mock(LocalizedClass).new(localizable_object, locale, options)
+      expect(LocalizedClass).to receive(:new).with(localizable_object, locale, options)
       localizable_object.localize(locale, options)
     end
 
     it 'uses default locale and empty options hash by default' do
-      mock(LocalizedClass).new(localizable_object, TwitterCldr.locale, {})
+      expect(LocalizedClass).to receive(:new).with(localizable_object, TwitterCldr.locale, {})
       localizable_object.localize
     end
   end
 
-end
+end

data/spec/localized/localized_string_spec.rb

@@ -32,7 +32,9 @@ describe LocalizedString do
       let(:horses) { { one: '1 horse', other: '%{horses_count} horses' } }
 
       before(:each) do
-        stub(TwitterCldr::Formatters::Plurals::Rules).rule_for { |n, _| n == 1 ? :one : :other  }
+        allow(TwitterCldr::Formatters::Plurals::Rules).to receive(:rule_for) do |n, _|
+          n == 1 ? :one : :other
+        end
       end
 
       it 'interpolates named placeholders' do
@@ -87,7 +89,7 @@ describe LocalizedString do
       result = string.localize.to_s
 
       expect(result).to eq(string)
-      expect(result.equal?(string)).not_to be_true
+      expect(result.equal?(string)).not_to eq(true)
     end
   end
 
@@ -134,12 +136,12 @@ describe LocalizedString do
     end
 
     it 'it uses NFD by default' do
-      mock(Eprun).normalize(string, :nfd) { normalized_string }
+      expect(Eprun).to receive(:normalize).with(string, :nfd).and_return(normalized_string)
       expect(localized_string.normalize.base_obj).to eq(normalized_string)
     end
 
     it "uses specified algorithm if there is any" do
-      mock(Eprun).normalize(string, :nfkd) { normalized_string }
+      expect(Eprun).to receive(:normalize).with(string, :nfkd).and_return(normalized_string)
       expect(localized_string.normalize(using: :NFKD).base_obj).to eq(normalized_string)
     end
 

data/spec/localized/localized_symbol_spec.rb

@@ -49,8 +49,8 @@ describe LocalizedSymbol do
 
   describe "#is_rtl?" do
     it "returns true or false depending on the locale" do
-      expect(:es.localize.is_rtl?).to be_false
-      expect(:ar.localize.is_rtl?).to be_true
+      expect(:es.localize.is_rtl?).to eq(false)
+      expect(:ar.localize.is_rtl?).to eq(true)
     end
   end
 

data/spec/normalization_spec.rb

@@ -12,12 +12,12 @@ describe TwitterCldr::Normalization do
     let(:normalized_string) { 'normalized' }
 
     it 'it uses NFD by default' do
-      mock(Eprun).normalize(string, :nfd) { normalized_string }
+      expect(Eprun).to receive(:normalize).with(string, :nfd).and_return(normalized_string)
       expect(TwitterCldr::Normalization.normalize(string)).to eq(normalized_string)
     end
 
     it "uses specified algorithm if there is any" do
-      mock(Eprun).normalize(string, :nfkd) { normalized_string }
+      expect(Eprun).to receive(:normalize).with(string, :nfkd).and_return(normalized_string)
       expect(TwitterCldr::Normalization.normalize(string, using: :nfkd)).to eq(normalized_string)
     end
 
@@ -28,15 +28,15 @@ describe TwitterCldr::Normalization do
     end
 
     it 'accepts normalizer name in upper case' do
-      mock(Eprun).normalize(string, :nfkd) { normalized_string }
+      expect(Eprun).to receive(:normalize).with(string, :nfkd).and_return(normalized_string)
       expect(TwitterCldr::Normalization.normalize(string, using: :NFKD)).to eq(normalized_string)
     end
 
     it 'accepts a string' do
-      mock(Eprun).normalize(string, :nfkd) { normalized_string }
+      expect(Eprun).to receive(:normalize).with(string, :nfkd).and_return(normalized_string)
       expect(TwitterCldr::Normalization.normalize(string, using: 'nfkd')).to eq(normalized_string)
     end
 
   end
 
-end
+end

data/spec/parsers/number_parser_spec.rb

@@ -77,51 +77,51 @@ describe NumberParser do
   describe "#punct_valid" do
     it "correctly validates a number with no decimal" do
       tokens = @parser.send(:tokenize, "1.337", *separators).reject { |t| t[:type] == :numeric }
-      expect(@parser.send(:punct_valid?, tokens)).to be_true
+      expect(@parser.send(:punct_valid?, tokens)).to eq(true)
     end
 
     it "correctly validates a number with a decimal" do
       tokens = @parser.send(:tokenize, "1.337,00", *separators).reject { |t| t[:type] == :numeric }
-      expect(@parser.send(:punct_valid?, tokens)).to be_true
+      expect(@parser.send(:punct_valid?, tokens)).to eq(true)
     end
 
     it "reports on an invalid number when it has more than one decimal" do
       tokens = @parser.send(:tokenize, "1,337,00", *separators).reject { |t| t[:type] == :numeric }
-      expect(@parser.send(:punct_valid?, tokens)).to be_false
+      expect(@parser.send(:punct_valid?, tokens)).to eq(false)
     end
   end
 
   describe "#is_numeric?" do
     it "returns true if the text is numeric" do
-      expect(NumberParser.is_numeric?("4839", "")).to be_true
-      expect(NumberParser.is_numeric?("1", "")).to be_true
+      expect(NumberParser.is_numeric?("4839", "")).to eq(true)
+      expect(NumberParser.is_numeric?("1", "")).to eq(true)
     end
 
     it "returns false if the text is not purely numeric" do
-      expect(NumberParser.is_numeric?("abc", "")).to be_false
-      expect(NumberParser.is_numeric?("123abc", "")).to be_false
+      expect(NumberParser.is_numeric?("abc", "")).to eq(false)
+      expect(NumberParser.is_numeric?("123abc", "")).to eq(false)
     end
 
     it "returns false if the text is blank" do
-      expect(NumberParser.is_numeric?("", "")).to be_false
+      expect(NumberParser.is_numeric?("", "")).to eq(false)
     end
 
     it "accepts the given characters as valid numerics" do
-      expect(NumberParser.is_numeric?("a123a", "a")).to be_true
-      expect(NumberParser.is_numeric?("1.234,56")).to be_true  # default separator chars used here
+      expect(NumberParser.is_numeric?("a123a", "a")).to eq(true)
+      expect(NumberParser.is_numeric?("1.234,56")).to eq(true)  # default separator chars used here
     end
   end
 
   describe "#valid?" do
     it "correctly identifies a series of valid cases" do
       ["5", "5,0", "1.337", "1.337,0", "0,05", ",5", "1.337.000,00"].each do |num|
-        expect(@parser.valid?(num)).to be_true
+        expect(@parser.valid?(num)).to eq(true)
       end
     end
 
     it "correctly identifies a series of invalid cases" do
       ["12,0,0", "5,", "5."].each do |num|
-        expect(@parser.valid?(num)).to be_false
+        expect(@parser.valid?(num)).to eq(false)
       end
     end
   end

data/spec/parsers/parser_spec.rb

@@ -24,7 +24,7 @@ describe Parser do
 
   describe "#parse" do
     it "should call do_parse" do
-      mock(parser).do_parse({})
+      expect(parser).to receive(:do_parse).and_return({})
       parser.parse(tokens)
     end
   end

data/spec/resources/loader_spec.rb

@@ -25,7 +25,7 @@ describe Loader do
     end
 
     it 'loads the resource only once' do
-      mock(loader).load_resource(resource_path).once { resource_content }
+      expect(loader).to receive(:load_resource).with(resource_path).and_return(resource_content)
 
       result = loader.get_resource(:random, :resource)
       expect(result).to eq(resource_content)
@@ -34,32 +34,32 @@ describe Loader do
     end
 
     it 'accepts a variable length resource path both in symbols and strings' do
-      stub(loader).load_resource('foo/bar/baz.yml') { 'foo-bar-baz' }
+      allow(loader).to receive(:load_resource).with('foo/bar/baz.yml').and_return('foo-bar-baz')
       expect(loader.get_resource('foo', :bar, 'baz')).to eq('foo-bar-baz')
     end
 
     it 'raises an exception if resource file is missing' do
-      mock(File).file?(File.join(TwitterCldr::RESOURCES_DIR, 'foo/bar.yml')) { false }
+      expect(File).to receive(:file?).with(File.join(TwitterCldr::RESOURCES_DIR, 'foo/bar.yml')).and_return(false)
       expect { loader.get_resource(:foo, :bar) }.to raise_error(ResourceLoadError, "Resource 'foo/bar.yml' not found.")
     end
 
     context 'custom resources' do
       it "doesn't merge the custom resource if it doesn't exist" do
-        mock(loader).read_resource_file('foo/bar.yml') { ":foo: bar" }
+        expect(loader).to receive(:read_resource_file).with('foo/bar.yml').and_return(":foo: bar")
         expect(loader.get_resource(:foo, :bar)).to eq({ foo: "bar" })
       end
 
       context 'with a custom resource' do
         before(:each) do
-          stub(loader).read_resource_file('foo/bar.yml') { ":foo: bar" }
-          stub(loader).custom_resource_exists?('custom/foo/bar.yml') { true }
-          stub(loader).read_resource_file('custom/foo/bar.yml') { ":bar: baz" }
+          allow(loader).to receive(:read_resource_file).with('foo/bar.yml').and_return(":foo: bar")
+          allow(loader).to receive(:custom_resource_exists?).with('custom/foo/bar.yml').and_return(true)
+          allow(loader).to receive(:read_resource_file).with('custom/foo/bar.yml').and_return(":bar: baz")
         end
 
         it 'merges the given file with its corresponding custom resource if it exists' do
           # make sure load_resource is called with custom = false the second time
-          mock.proxy(loader).load_resource("foo/bar.yml")
-          mock.proxy(loader).load_resource("custom/foo/bar.yml", false)
+          expect(loader).to receive(:load_resource).with("foo/bar.yml").and_call_original
+          expect(loader).to receive(:load_resource).with("custom/foo/bar.yml", false).and_call_original
 
           expect(loader.get_resource(:foo, :bar)).to eq({ foo: "bar", bar: "baz" })
         end
@@ -75,12 +75,12 @@ describe Loader do
 
   describe '#get_locale_resource' do
     it 'loads the correct locale resource file' do
-      stub(loader).get_resource(:locales, :de, :numbers) { 'foo' }
+      allow(loader).to receive(:get_resource).with(:locales, :de, :numbers).and_return('foo')
       expect(loader.get_locale_resource(:de, :numbers)).to eq('foo')
     end
 
     it 'loads the resource only once' do
-      mock(loader).load_resource('locales/de/numbers.yml').once { 'foo' }
+      expect(loader).to receive(:load_resource).with('locales/de/numbers.yml').and_return('foo')
 
       result = loader.get_locale_resource(:de, :numbers)
       # second time get_resource is not called but we get the same object as before
@@ -88,8 +88,8 @@ describe Loader do
     end
 
     it 'converts locales' do
-      mock(TwitterCldr).convert_locale('zh-tw') { :'zh-Hant' }
-      mock(loader).get_resource(:locales, :'zh-Hant', :numbers) { 'foo' }
+      expect(TwitterCldr).to receive(:convert_locale).with('zh-tw').and_return(:'zh-Hant')
+      expect(loader).to receive(:get_resource).with(:locales, :'zh-Hant', :numbers).and_return('foo')
 
       expect(loader.get_locale_resource('zh-tw', :numbers)).to eq('foo')
     end
@@ -98,16 +98,16 @@ describe Loader do
   describe '#resource_loaded' do
     it 'should return true if the resource is cached, false otherwise' do
       loader.preload_resources_for_locale(:de, :numbers)
-      expect(loader.resource_loaded?(:locales, :de, :numbers)).to be_true
-      expect(loader.resource_loaded?(:locales, :de, :calendars)).to be_false
+      expect(loader.resource_loaded?(:locales, :de, :numbers)).to eq(true)
+      expect(loader.resource_loaded?(:locales, :de, :calendars)).to eq(false)
     end
   end
 
   describe '#locale_resource_loaded' do
     it 'should return true if the locale resource is cached, false otherwise' do
       loader.preload_resources_for_locale(:de, :numbers)
-      expect(loader.locale_resource_loaded?(:de, :numbers)).to be_true
-      expect(loader.locale_resource_loaded?(:de, :calendars)).to be_false
+      expect(loader.locale_resource_loaded?(:de, :numbers)).to eq(true)
+      expect(loader.locale_resource_loaded?(:de, :calendars)).to eq(false)
     end
   end
 
@@ -131,16 +131,16 @@ describe Loader do
   describe '#preload_resources_for_locale' do
     it 'loads potentially multiple resources into the cache' do
       loader.preload_resources_for_locale(:ar, :calendars, :fields)
-      expect(loader.locale_resource_loaded?(:ar, :calendars)).to be_true
-      expect(loader.locale_resource_loaded?(:ar, :fields)).to be_true
-      expect(loader.locale_resource_loaded?(:en, :fields)).to be_false
+      expect(loader.locale_resource_loaded?(:ar, :calendars)).to eq(true)
+      expect(loader.locale_resource_loaded?(:ar, :fields)).to eq(true)
+      expect(loader.locale_resource_loaded?(:en, :fields)).to eq(false)
     end
 
     it 'loads all resources for the locale if the :all resource type is specified' do
       loader.preload_resources_for_locale(:ar, :all)
       loader.resource_types_for(:ar).each do |resource_type|
-        expect(loader.locale_resource_loaded?(:ar, resource_type)).to be_true
-        expect(loader.locale_resource_loaded?(:en, resource_type)).to be_false
+        expect(loader.locale_resource_loaded?(:ar, resource_type)).to eq(true)
+        expect(loader.locale_resource_loaded?(:en, resource_type)).to eq(false)
       end
     end
   end
@@ -148,9 +148,9 @@ describe Loader do
   describe '#preload_resource_for_locales' do
     it 'loads a single resource for potentially multiple locales into the cache' do
       loader.preload_resource_for_locales(:calendars, :sv, :bn)
-      expect(loader.locale_resource_loaded?(:sv, :calendars)).to be_true
-      expect(loader.locale_resource_loaded?(:bn, :calendars)).to be_true
-      expect(loader.locale_resource_loaded?(:sv, :units)).to be_false
+      expect(loader.locale_resource_loaded?(:sv, :calendars)).to eq(true)
+      expect(loader.locale_resource_loaded?(:bn, :calendars)).to eq(true)
+      expect(loader.locale_resource_loaded?(:sv, :units)).to eq(false)
     end
   end
 
@@ -158,9 +158,9 @@ describe Loader do
     it 'loads potentially multiple resources for all locales' do
       loader.preload_resources_for_all_locales(:plurals, :lists)
       TwitterCldr.supported_locales.each do |locale|
-        expect(loader.locale_resource_loaded?(locale, :plurals)).to be_true
-        expect(loader.locale_resource_loaded?(locale, :lists)).to be_true
-        expect(loader.locale_resource_loaded?(locale, :calendars)).to be_false
+        expect(loader.locale_resource_loaded?(locale, :plurals)).to eq(true)
+        expect(loader.locale_resource_loaded?(locale, :lists)).to eq(true)
+        expect(loader.locale_resource_loaded?(locale, :calendars)).to eq(false)
       end
     end
   end
@@ -170,7 +170,7 @@ describe Loader do
       loader.preload_all_resources
       TwitterCldr.supported_locales.each do |locale|
         loader.resource_types_for(locale).each do |resource_type|
-          expect(loader.locale_resource_loaded?(locale, resource_type)).to be_true
+          expect(loader.locale_resource_loaded?(locale, resource_type)).to eq(true)
         end
       end
     end
@@ -178,8 +178,8 @@ describe Loader do
 
   def stub_resource_file(resource_path, content)
     file_path = File.join(TwitterCldr::RESOURCES_DIR, resource_path)
-    stub(File).read(file_path) { content }
-    stub(File).file?(file_path) { true }
+    allow(File).to receive(:read).with(file_path).and_return(content)
+    allow(File).to receive(:file?).with(file_path).and_return(true)
   end
 
 end