i18n 0.9.5 → 1.10.0

data/test/backend/chain_test.rb

@@ -1,122 +0,0 @@
-require 'test_helper'
-
-class I18nBackendChainTest < I18n::TestCase
-  def setup
-    super
-    @first  = backend(:en => {
-      :foo => 'Foo', :formats => {
-        :short => 'short',
-        :subformats => {:short => 'short'},
-      },
-      :plural_1 => { :one => '%{count}' },
-      :dates => {:a => "A"}
-    })
-    @second = backend(:en => {
-      :bar => 'Bar', :formats => {
-        :long => 'long',
-        :subformats => {:long => 'long'},
-      },
-      :plural_2 => { :one => 'one' },
-      :dates => {:a => "B", :b => "B"}
-    })
-    @chain  = I18n.backend = I18n::Backend::Chain.new(@first, @second)
-  end
-
-  test "looks up translations from the first chained backend" do
-    assert_equal 'Foo', @first.send(:translations)[:en][:foo]
-    assert_equal 'Foo', I18n.t(:foo)
-  end
-
-  test "looks up translations from the second chained backend" do
-    assert_equal 'Bar', @second.send(:translations)[:en][:bar]
-    assert_equal 'Bar', I18n.t(:bar)
-  end
-
-  test "defaults only apply to lookups on the last backend in the chain" do
-    assert_equal 'Foo', I18n.t(:foo, :default => 'Bah')
-    assert_equal 'Bar', I18n.t(:bar, :default => 'Bah')
-    assert_equal 'Bah', I18n.t(:bah, :default => 'Bah') # default kicks in only here
-  end
-
-  test "default" do
-    assert_equal 'Fuh',  I18n.t(:default => 'Fuh')
-    assert_equal 'Zero', I18n.t(:default => { :zero => 'Zero' }, :count => 0)
-    assert_equal({ :zero => 'Zero' }, I18n.t(:default => { :zero => 'Zero' }))
-    assert_equal 'Foo', I18n.t(:default => :foo)
-  end
-
-  test 'default is returned if translation is missing' do
-    assert_equal({}, I18n.t(:'i18n.transliterate.rule', :locale => 'en', :default => {}))
-  end
-
-  test "namespace lookup collects results from all backends and merges deep hashes" do
-    assert_equal({:long=>"long", :subformats=>{:long=>"long", :short=>"short"}, :short=>"short"}, I18n.t(:formats))
-  end
-
-  test "namespace lookup collects results from all backends and lets leftmost backend take priority" do
-    assert_equal({ :a => "A", :b => "B" }, I18n.t(:dates))
-  end
-
-  test "namespace lookup with only the first backend returning a result" do
-    assert_equal({ :one => '%{count}' }, I18n.t(:plural_1))
-  end
-
-  test "pluralization still works" do
-    assert_equal '1',   I18n.t(:plural_1, :count => 1)
-    assert_equal 'one', I18n.t(:plural_2, :count => 1)
-  end
-
-  test "bulk lookup collects results from all backends" do
-    assert_equal ['Foo', 'Bar'], I18n.t([:foo, :bar])
-    assert_equal ['Foo', 'Bar', 'Bah'], I18n.t([:foo, :bar, :bah], :default => 'Bah')
-    assert_equal [{
-      :long=>"long",
-      :subformats=>{:long=>"long", :short=>"short"},
-      :short=>"short"}, {:one=>"one"},
-      "Bah"], I18n.t([:formats, :plural_2, :bah], :default => 'Bah')
-  end
-
-  test "store_translations options are not dropped while transfering to backend" do
-    @first.expects(:store_translations).with(:foo, {:bar => :baz}, {:option => 'persists'})
-    I18n.backend.store_translations :foo, {:bar => :baz}, {:option => 'persists'}
-  end
-
-  protected
-
-    def backend(translations)
-      backend = I18n::Backend::Simple.new
-      translations.each { |locale, data| backend.store_translations(locale, data) }
-      backend
-    end
-end
-
-class I18nBackendChainWithKeyValueTest < I18n::TestCase
-  def setup_backend!(subtrees = true)
-    first = I18n::Backend::KeyValue.new({}, subtrees)
-    first.store_translations(:en, :plural_1 => { :one => '%{count}' })
-
-    second = I18n::Backend::Simple.new
-    second.store_translations(:en, :plural_2 => { :one => 'one' })
-    I18n.backend = I18n::Backend::Chain.new(first, second)
-  end
-
-  test "subtrees enabled: looks up pluralization translations from the first chained backend" do
-    setup_backend!
-    assert_equal '1', I18n.t(:plural_1, count: 1)
-  end
-
-  test "subtrees disabled: looks up pluralization translations from the first chained backend" do
-    setup_backend!(false)
-    assert_equal '1', I18n.t(:plural_1, count: 1)
-  end
-
-  test "subtrees enabled: looks up translations from the second chained backend" do
-    setup_backend!
-    assert_equal 'one', I18n.t(:plural_2, count: 1)
-  end
-
-  test "subtrees disabled: looks up translations from the second chained backend" do
-    setup_backend!(false)
-    assert_equal 'one', I18n.t(:plural_2, count: 1)
-  end
-end if I18n::TestCase.key_value?

data/test/backend/exceptions_test.rb

@@ -1,36 +0,0 @@
-require 'test_helper'
-
-class I18nBackendExceptionsTest < I18n::TestCase
-  def setup
-    super
-    I18n.backend = I18n::Backend::Simple.new
-  end
-
-  test "throw message: MissingTranslation message from #translate includes the given scope and full key" do
-    exception = catch(:exception) do
-      I18n.t(:'baz.missing', :scope => :'foo.bar', :throw => true)
-    end
-    assert_equal "translation missing: en.foo.bar.baz.missing", exception.message
-  end
-
-  test "exceptions: MissingTranslationData message from #translate includes the given scope and full key" do
-    begin
-      I18n.t(:'baz.missing', :scope => :'foo.bar', :raise => true)
-    rescue I18n::MissingTranslationData => exception
-    end
-    assert_equal "translation missing: en.foo.bar.baz.missing", exception.message
-  end
-
-  test "exceptions: MissingTranslationData message from #localize includes the given scope and full key" do
-    begin
-      I18n.l(Time.now, :format => :foo)
-    rescue I18n::MissingTranslationData => exception
-    end
-    assert_equal "translation missing: en.time.formats.foo", exception.message
-  end
-
-  test "exceptions: MissingInterpolationArgument message includes missing key, provided keys and full string" do
-    exception = I18n::MissingInterpolationArgument.new('key', {:this => 'was given'}, 'string')
-    assert_equal 'missing interpolation argument "key" in "string" ({:this=>"was given"} given)', exception.message
-  end
-end

data/test/backend/fallbacks_test.rb

@@ -1,219 +0,0 @@
-require 'test_helper'
-
-class I18nBackendFallbacksTranslateTest < I18n::TestCase
-  class Backend < I18n::Backend::Simple
-    include I18n::Backend::Fallbacks
-  end
-
-  def setup
-    super
-    I18n.backend = Backend.new
-    store_translations(:en, :foo => 'Foo in :en', :bar => 'Bar in :en', :buz => 'Buz in :en', :interpolate => 'Interpolate %{value}')
-    store_translations(:de, :bar => 'Bar in :de', :baz => 'Baz in :de')
-    store_translations(:'de-DE', :baz => 'Baz in :de-DE')
-    store_translations(:'pt-BR', :baz => 'Baz in :pt-BR')
-  end
-
-  test "still returns an existing translation as usual" do
-    assert_equal 'Foo in :en', I18n.t(:foo, :locale => :en)
-    assert_equal 'Bar in :de', I18n.t(:bar, :locale => :de)
-    assert_equal 'Baz in :de-DE', I18n.t(:baz, :locale => :'de-DE')
-  end
-
-  test "returns interpolated value if no key provided" do
-    assert_equal 'Interpolate %{value}', I18n.t(:interpolate)
-  end
-
-  test "returns the :en translation for a missing :de translation" do
-    assert_equal 'Foo in :en', I18n.t(:foo, :locale => :de)
-  end
-
-  test "returns the :de translation for a missing :'de-DE' translation" do
-    assert_equal 'Bar in :de', I18n.t(:bar, :locale => :'de-DE')
-  end
-
-  test "returns the :en translation for translation missing in both :de and :'de-De'" do
-    assert_equal 'Buz in :en', I18n.t(:buz, :locale => :'de-DE')
-  end
-
-  test "returns the :de translation for a missing :'de-DE' when :default is a String" do
-    assert_equal 'Bar in :de', I18n.t(:bar, :locale => :'de-DE', :default => "Default Bar")
-    assert_equal "Default Bar", I18n.t(:missing_bar, :locale => :'de-DE', :default => "Default Bar")
-  end
-
-  test "returns the :de translation for a missing :'de-DE' when defaults is a Symbol (which exists in :en)" do
-    assert_equal "Bar in :de", I18n.t(:bar, :locale => :'de-DE', :default => [:buz])
-  end
-
-  test "returns the :'de-DE' default :baz translation for a missing :'de-DE' (which exists in :de)" do
-    assert_equal "Baz in :de-DE", I18n.t(:bar, :locale => :'de-DE', :default => [:baz])
-  end
-
-  test "returns the :de translation for a missing :'de-DE' when :default is a Proc" do
-    assert_equal 'Bar in :de', I18n.t(:bar, :locale => :'de-DE', :default => Proc.new { "Default Bar" })
-    assert_equal "Default Bar", I18n.t(:missing_bar, :locale => :'de-DE', :default => Proc.new { "Default Bar" })
-  end
-
-  test "returns the :de translation for a missing :'de-DE' when :default is a Hash" do
-    assert_equal 'Bar in :de', I18n.t(:bar, :locale => :'de-DE', :default => {})
-    assert_equal({}, I18n.t(:missing_bar, :locale => :'de-DE', :default => {}))
-  end
-
-  test "returns the :de translation for a missing :'de-DE' when :default is nil" do
-    assert_equal 'Bar in :de', I18n.t(:bar, :locale => :'de-DE', :default => nil)
-    assert_nil I18n.t(:missing_bar, :locale => :'de-DE', :default => nil)
-  end
-
-  test "returns the translation missing message if the default is also missing" do
-    assert_equal 'translation missing: de-DE.missing_bar', I18n.t(:missing_bar, :locale => :'de-DE', :default => [:missing_baz])
-  end
-
-  test "returns the :'de-DE' default :baz translation for a missing :'de-DE' when defaults contains Symbol" do
-    assert_equal 'Baz in :de-DE', I18n.t(:missing_foo, :locale => :'de-DE', :default => [:baz, "Default Bar"])
-  end
-
-  test "returns the defaults translation for a missing :'de-DE' when defaults contains a String or Proc before Symbol" do
-    assert_equal "Default Bar", I18n.t(:missing_foo, :locale => :'de-DE', :default => [:missing_bar, "Default Bar", :baz])
-    assert_equal "Default Bar", I18n.t(:missing_foo, :locale => :'de-DE', :default => [:missing_bar, Proc.new { "Default Bar" }, :baz])
-  end
-
-  test "returns the default translation for a missing :'de-DE' and existing :de when default is a Hash" do
-    assert_equal 'Default 6 Bars', I18n.t(:missing_foo, :locale => :'de-DE', :default => [:missing_bar, {:other => "Default %{count} Bars"}, "Default Bar"], :count => 6)
-  end
-
-  test "returns the default translation for a missing :de translation even when default is a String when fallback is disabled" do
-    assert_equal 'Default String', I18n.t(:foo, :locale => :de, :default => 'Default String', :fallback => false)
-  end
-
-  test "raises I18n::MissingTranslationData exception when fallback is disabled even when fallback translation exists" do
-    assert_raise(I18n::MissingTranslationData) { I18n.t(:foo, :locale => :de, :fallback => false, :raise => true) }
-  end
-
-  test "raises I18n::MissingTranslationData exception when no translation was found" do
-    assert_raise(I18n::MissingTranslationData) { I18n.t(:faa, :locale => :en, :raise => true) }
-    assert_raise(I18n::MissingTranslationData) { I18n.t(:faa, :locale => :de, :raise => true) }
-  end
-
-  test "should ensure that default is not splitted on new line char" do
-    assert_equal "Default \n Bar", I18n.t(:missing_bar, :default => "Default \n Bar")
-  end
-
-  test "should not raise error when enforce_available_locales is true, :'pt' is missing and default is a Symbol" do
-    I18n.enforce_available_locales = true
-    begin
-      assert_equal 'Foo', I18n.t(:'model.attrs.foo', :locale => :'pt-BR', :default => [:'attrs.foo', "Foo"])
-    ensure
-      I18n.enforce_available_locales = false
-    end
-  end
-end
-
-class I18nBackendFallbacksLocalizeTest < I18n::TestCase
-  class Backend < I18n::Backend::Simple
-    include I18n::Backend::Fallbacks
-  end
-
-  def setup
-    super
-    I18n.backend = Backend.new
-    store_translations(:en, :date => { :formats => { :en => 'en' }, :day_names => %w(Sunday) })
-    store_translations(:de, :date => { :formats => { :de => 'de' } })
-  end
-
-  test "still uses an existing format as usual" do
-    assert_equal 'en', I18n.l(Date.today, :format => :en, :locale => :en)
-  end
-
-  test "looks up and uses a fallback locale's format for a key missing in the given locale (1)" do
-    assert_equal 'en', I18n.l(Date.today, :format => :en, :locale => :de)
-  end
-
-  test "looks up and uses a fallback locale's format for a key missing in the given locale (2)" do
-    assert_equal 'de', I18n.l(Date.today, :format => :de, :locale => :'de-DE')
-  end
-
-  test "still uses an existing day name translation as usual" do
-    assert_equal 'Sunday', I18n.l(Date.new(2010, 1, 3), :format => '%A', :locale => :en)
-  end
-
-  test "uses a fallback locale's translation for a key missing in the given locale" do
-    assert_equal 'Sunday', I18n.l(Date.new(2010, 1, 3), :format => '%A', :locale => :de)
-  end
-end
-
-class I18nBackendFallbacksWithChainTest < I18n::TestCase
-  class Backend < I18n::Backend::Simple
-    include I18n::Backend::Fallbacks
-  end
-
-  class Chain < I18n::Backend::Chain
-    include I18n::Backend::Fallbacks
-  end
-
-  def setup
-    super
-    backend = Backend.new
-    backend.store_translations(:de, :foo => 'FOO')
-    backend.store_translations(:'pt-BR', :foo => 'Baz in :pt-BR')
-    I18n.backend = Chain.new(I18n::Backend::Simple.new, backend)
-  end
-
-  test "falls back from de-DE to de when there is no translation for de-DE available" do
-    assert_equal 'FOO', I18n.t(:foo, :locale => :'de-DE')
-  end
-
-  test "falls back from de-DE to de when there is no translation for de-DE available when using arrays, too" do
-    assert_equal ['FOO', 'FOO'], I18n.t([:foo, :foo], :locale => :'de-DE')
-  end
-
-  test "should not raise error when enforce_available_locales is true, :'pt' is missing and default is a Symbol" do
-    I18n.enforce_available_locales = true
-    begin
-      assert_equal 'Foo', I18n.t(:'model.attrs.foo', :locale => :'pt-BR', :default => [:'attrs.foo', "Foo"])
-    ensure
-      I18n.enforce_available_locales = false
-    end
-  end
-end
-
-class I18nBackendFallbacksExistsTest < I18n::TestCase
-  class Backend < I18n::Backend::Simple
-    include I18n::Backend::Fallbacks
-  end
-
-  def setup
-    super
-    I18n.backend = Backend.new
-    store_translations(:en, :foo => 'Foo in :en', :bar => 'Bar in :en')
-    store_translations(:de, :bar => 'Bar in :de')
-    store_translations(:'de-DE', :baz => 'Baz in :de-DE')
-  end
-
-  test "exists? given an existing key will return true" do
-    assert_equal true, I18n.exists?(:foo)
-  end
-
-  test "exists? given a non-existing key will return false" do
-    assert_equal false, I18n.exists?(:bogus)
-  end
-
-  test "exists? given an existing key and an existing locale will return true" do
-    assert_equal true, I18n.exists?(:foo, :en)
-    assert_equal true, I18n.exists?(:bar, :de)
-  end
-
-  test "exists? given a non-existing key and an existing locale will return false" do
-    assert_equal false, I18n.exists?(:bogus, :en)
-    assert_equal false, I18n.exists?(:bogus, :de)
-  end
-
-  test "exists? should return true given a key which is missing from the given locale and exists in a fallback locale" do
-    assert_equal true, I18n.exists?(:foo, :de)
-    assert_equal true, I18n.exists?(:foo, :'de-DE')
-  end
-
-  test "exists? should return false given a key which is missing from the given locale and all its fallback locales" do
-    assert_equal false, I18n.exists?(:baz, :de)
-    assert_equal false, I18n.exists?(:bogus, :'de-DE')
-  end
-end

data/test/backend/interpolation_compiler_test.rb

@@ -1,118 +0,0 @@
-require 'test_helper'
-
-class InterpolationCompilerTest < I18n::TestCase
-  Compiler = I18n::Backend::InterpolationCompiler::Compiler
-
-  def compile_and_interpolate(str, values = {})
-    Compiler.compile_if_an_interpolation(str).i18n_interpolate(values)
-  end
-
-  def assert_escapes_interpolation_key(expected, malicious_str)
-    assert_equal(expected, Compiler.send(:escape_key_sym, malicious_str))
-  end
-
-  def test_escape_key_properly_escapes
-    assert_escapes_interpolation_key ':"\""',       '"'
-    assert_escapes_interpolation_key ':"\\\\"',     '\\'
-    assert_escapes_interpolation_key ':"\\\\\""',   '\\"'
-    assert_escapes_interpolation_key ':"\#{}"',     '#{}'
-    assert_escapes_interpolation_key ':"\\\\\#{}"', '\#{}'
-  end
-
-  def assert_escapes_plain_string(expected, plain_str)
-    assert_equal expected, Compiler.send(:escape_plain_str, plain_str)
-  end
-
-  def test_escape_plain_string_properly_escapes
-    assert_escapes_plain_string '\\"',    '"'
-    assert_escapes_plain_string '\'',     '\''
-    assert_escapes_plain_string '\\#',    '#'
-    assert_escapes_plain_string '\\#{}',  '#{}'
-    assert_escapes_plain_string '\\\\\\"','\\"'
-  end
-
-  def test_non_interpolated_strings_or_arrays_dont_get_compiled
-    ['abc', '\\{a}}', '{a}}', []].each do |obj|
-      Compiler.compile_if_an_interpolation(obj)
-      assert_equal false, obj.respond_to?(:i18n_interpolate)
-    end
-  end
-
-  def test_interpolated_string_gets_compiled
-    assert_equal '-A-', compile_and_interpolate('-%{a}-', :a => 'A')
-  end
-
-  def assert_handles_key(str, key)
-    assert_equal 'A', compile_and_interpolate(str, key => 'A')
-  end
-
-  def test_compiles_fancy_keys
-    assert_handles_key('%{\}',       :'\\'    )
-    assert_handles_key('%{#}',       :'#'     )
-    assert_handles_key('%{#{}',      :'#{'    )
-    assert_handles_key('%{#$SAFE}',  :'#$SAFE')
-    assert_handles_key('%{\000}',    :'\000'  )
-    assert_handles_key('%{\'}',      :'\''    )
-    assert_handles_key('%{\'\'}',    :'\'\''  )
-    assert_handles_key('%{a.b}',     :'a.b'   )
-    assert_handles_key('%{ }',       :' '     )
-    assert_handles_key('%{:}',       :':'     )
-    assert_handles_key("%{:''}",     :":''"   )
-    assert_handles_key('%{:"}',      :':"'    )
-  end
-
-  def test_str_containing_only_escaped_interpolation_is_handled_correctly
-    assert_equal 'abc %{x}', compile_and_interpolate('abc %%{x}')
-  end
-
-  def test_handles_weird_strings
-    assert_equal '#{} a',         compile_and_interpolate('#{} %{a}',         :a    => 'a')
-    assert_equal '"#{abc}"',      compile_and_interpolate('"#{ab%{a}c}"',     :a    => '' )
-    assert_equal 'a}',            compile_and_interpolate('%{{a}}',           :'{a' => 'a')
-    assert_equal '"',             compile_and_interpolate('"%{a}',            :a    => '' )
-    assert_equal 'a%{a}',         compile_and_interpolate('%{a}%%{a}',        :a    => 'a')
-    assert_equal '%%{a}',         compile_and_interpolate('%%%{a}')
-    assert_equal '\";eval("a")',  compile_and_interpolate('\";eval("%{a}")',  :a    => 'a')
-    assert_equal '\";eval("a")',  compile_and_interpolate('\";eval("a")%{a}', :a    => '' )
-    assert_equal "\na",           compile_and_interpolate("\n%{a}",           :a    => 'a')
-  end
-
-  def test_raises_exception_when_argument_is_missing
-    assert_raise(I18n::MissingInterpolationArgument) do
-      compile_and_interpolate('%{first} %{last}', :first => 'first')
-    end
-  end
-
-  def test_custom_missing_interpolation_argument_handler
-    old_handler = I18n.config.missing_interpolation_argument_handler
-    I18n.config.missing_interpolation_argument_handler = lambda do |key, values, string|
-      "missing key is #{key}, values are #{values.inspect}, given string is '#{string}'"
-    end
-    assert_equal %|first missing key is last, values are {:first=>"first"}, given string is '%{first} %{last}'|,
-        compile_and_interpolate('%{first} %{last}', :first => 'first')
-  ensure
-    I18n.config.missing_interpolation_argument_handler = old_handler
-  end
-end
-
-class I18nBackendInterpolationCompilerTest < I18n::TestCase
-  class Backend < I18n::Backend::Simple
-    include I18n::Backend::InterpolationCompiler
-  end
-
-  include I18n::Tests::Interpolation
-
-  def setup
-    I18n.backend = Backend.new
-    super
-  end
-
-  # pre-compile default strings to make sure we are testing I18n::Backend::InterpolationCompiler
-  def interpolate(*args)
-    options = args.last.kind_of?(Hash) ? args.last : {}
-    if default_str = options[:default]
-      I18n::Backend::InterpolationCompiler::Compiler.compile_if_an_interpolation(default_str)
-    end
-    super
-  end
-end

data/test/backend/key_value_test.rb

@@ -1,61 +0,0 @@
-require 'test_helper'
-
-class I18nBackendKeyValueTest < I18n::TestCase
-  def setup_backend!(subtree=true)
-    I18n.backend = I18n::Backend::KeyValue.new({}, subtree)
-    store_translations(:en, :foo => { :bar => 'bar', :baz => 'baz' })
-  end
-
-  def assert_flattens(expected, nested, escape=true, subtree=true)
-    assert_equal expected, I18n.backend.flatten_translations("en", nested, escape, subtree)
-  end
-
-  test "hash flattening works" do
-    setup_backend!
-    assert_flattens(
-      {:a=>'a', :b=>{:c=>'c', :d=>'d', :f=>{:x=>'x'}}, :"b.f" => {:x=>"x"}, :"b.c"=>"c", :"b.f.x"=>"x", :"b.d"=>"d"},
-      {:a=>'a', :b=>{:c=>'c', :d=>'d', :f=>{:x=>'x'}}}
-    )
-    assert_flattens({:a=>{:b =>['a', 'b']}, :"a.b"=>['a', 'b']}, {:a=>{:b =>['a', 'b']}})
-    assert_flattens({:"a\001b" => "c"}, {:"a.b" => "c"})
-    assert_flattens({:"a.b"=>['a', 'b']}, {:a=>{:b =>['a', 'b']}}, true, false)
-    assert_flattens({:"a.b" => "c"}, {:"a.b" => "c"}, false)
-  end
-
-  test "store_translations handle subtrees by default" do
-    setup_backend!
-    assert_equal({ :bar => 'bar', :baz => 'baz' }, I18n.t("foo"))
-  end
-
-  test "store_translations merge subtrees accordingly" do
-    setup_backend!
-    store_translations(:en, :foo => { :baz => "BAZ"})
-    assert_equal('BAZ', I18n.t("foo.baz"))
-    assert_equal({ :bar => 'bar', :baz => 'BAZ' }, I18n.t("foo"))
-  end
-
-  test "store_translations does not handle subtrees if desired" do
-    setup_backend!(false)
-    assert_raise I18n::MissingTranslationData do
-      I18n.t("foo", :raise => true)
-    end
-  end
-
-  test "subtrees enabled: given incomplete pluralization data it raises I18n::InvalidPluralizationData" do
-    setup_backend!
-    store_translations(:en, :bar => { :one => "One" })
-    assert_raise(I18n::InvalidPluralizationData) { I18n.t(:bar, :count => 2) }
-  end
-
-  test "subtrees disabled: given incomplete pluralization data it returns an error message" do
-    setup_backend!(false)
-    store_translations(:en, :bar => { :one => "One" })
-    assert_equal "translation missing: en.bar", I18n.t(:bar, :count => 2)
-  end
-
-  test "translate handles subtrees for pluralization" do
-    setup_backend!(false)
-    store_translations(:en, :bar => { :one => "One" })
-    assert_equal("One", I18n.t("bar", :count => 1))
-  end
-end if I18n::TestCase.key_value?

data/test/backend/memoize_test.rb

@@ -1,79 +0,0 @@
-require 'test_helper'
-# TODO: change back to "require 'backend/simple'" when dropping support to Ruby 1.8.7.
-require File.expand_path('../simple_test', __FILE__)
-
-class I18nBackendMemoizeTest < I18nBackendSimpleTest
-  module MemoizeSpy
-    attr_accessor :spy_calls
-
-    def available_locales
-      self.spy_calls = (self.spy_calls || 0) + 1
-      super
-    end
-  end
-
-  class MemoizeBackend < I18n::Backend::Simple
-    include MemoizeSpy
-    include I18n::Backend::Memoize
-  end
-
-  def setup
-    super
-    I18n.backend = MemoizeBackend.new
-  end
-
-  def test_memoizes_available_locales
-    I18n.backend.spy_calls = 0
-    assert_equal I18n.available_locales, I18n.available_locales
-    assert_equal 1, I18n.backend.spy_calls
-  end
-
-  def test_resets_available_locales_on_reload!
-    I18n.available_locales
-    I18n.backend.spy_calls = 0
-    I18n.reload!
-    assert_equal I18n.available_locales, I18n.available_locales
-    assert_equal 1, I18n.backend.spy_calls
-  end
-
-  def test_resets_available_locales_on_store_translations
-    I18n.available_locales
-    I18n.backend.spy_calls = 0
-    I18n.backend.store_translations(:copa, :ca => :bana)
-    assert_equal I18n.available_locales, I18n.available_locales
-    assert I18n.available_locales.include?(:copa)
-    assert_equal 1, I18n.backend.spy_calls
-  end
-
-  module TestLookup
-    def lookup(locale, key, scope = [], options = {})
-      keys = I18n.normalize_keys(locale, key, scope, options[:separator])
-      keys.inspect
-    end
-  end
-
-  def test_lookup_concurrent_consistency
-    backend_impl = Class.new(I18n::Backend::Simple) do
-      include TestLookup
-      include I18n::Backend::Memoize
-    end
-    backend = backend_impl.new
-
-    memoized_lookup = backend.send(:memoized_lookup)
-
-    assert_equal "[:foo, :scoped, :sample]", backend.translate('foo', scope = [:scoped, :sample])
-
-    results = []
-    30.times.inject([]) do |memo, i|
-      memo << Thread.new do
-        backend.translate('bar', scope); backend.translate(:baz, scope)
-      end
-    end.each(&:join)
-
-    memoized_lookup = backend.send(:memoized_lookup)
-    puts memoized_lookup.inspect if $VERBOSE
-    assert_equal 3, memoized_lookup.size, "NON-THREAD-SAFE lookup memoization backend: #{memoized_lookup.class}"
-    # if a plain Hash is used might eventually end up in a weird (inconsistent) state
-  end
-
-end