monero_wallet_gen 0.1.0

data/vendor/bundle/ruby/2.3.0/gems/i18n-1.0.1/test/api/pluralization_test.rb

@@ -0,0 +1,30 @@
+require 'test_helper'
+
+class I18nPluralizationApiTest < I18n::TestCase
+  class Backend < I18n::Backend::Simple
+    include I18n::Backend::Pluralization
+  end
+
+  def setup
+    I18n.backend = Backend.new
+    super
+  end
+
+  include I18n::Tests::Basics
+  include I18n::Tests::Defaults
+  include I18n::Tests::Interpolation
+  include I18n::Tests::Link
+  include I18n::Tests::Lookup
+  include I18n::Tests::Pluralization
+  include I18n::Tests::Procs
+  include I18n::Tests::Localization::Date
+  include I18n::Tests::Localization::DateTime
+  include I18n::Tests::Localization::Time
+  include I18n::Tests::Localization::Procs
+
+  test "make sure we use a backend with Pluralization included" do
+    assert_equal Backend, I18n.backend.class
+  end
+
+  # links: test that keys stored on one backend can link to keys stored on another backend
+end

data/vendor/bundle/ruby/2.3.0/gems/i18n-1.0.1/test/api/simple_test.rb

@@ -0,0 +1,28 @@
+require 'test_helper'
+
+class I18nSimpleBackendApiTest < I18n::TestCase
+  class Backend < I18n::Backend::Simple
+    include I18n::Backend::Pluralization
+  end
+
+  def setup
+    I18n.backend = I18n::Backend::Simple.new
+    super
+  end
+
+  include I18n::Tests::Basics
+  include I18n::Tests::Defaults
+  include I18n::Tests::Interpolation
+  include I18n::Tests::Link
+  include I18n::Tests::Lookup
+  include I18n::Tests::Pluralization
+  include I18n::Tests::Procs
+  include I18n::Tests::Localization::Date
+  include I18n::Tests::Localization::DateTime
+  include I18n::Tests::Localization::Time
+  include I18n::Tests::Localization::Procs
+
+  test "make sure we use the Simple backend" do
+    assert_equal I18n::Backend::Simple, I18n.backend.class
+  end
+end

data/vendor/bundle/ruby/2.3.0/gems/i18n-1.0.1/test/backend/cache_test.rb

@@ -0,0 +1,109 @@
+require 'test_helper'
+require 'digest/md5'
+
+begin
+  require 'active_support'
+rescue LoadError
+  $stderr.puts "Skipping cache tests using ActiveSupport"
+else
+
+class I18nBackendCacheTest < I18n::TestCase
+  class Backend < I18n::Backend::Simple
+    include I18n::Backend::Cache
+  end
+
+  def setup
+    I18n.backend = Backend.new
+    super
+    I18n.cache_store = ActiveSupport::Cache.lookup_store(:memory_store)
+    I18n.cache_key_digest = nil
+  end
+
+  def teardown
+    super
+    I18n.cache_store = nil
+  end
+
+  test "it uses the cache" do
+    assert I18n.cache_store.is_a?(ActiveSupport::Cache::MemoryStore)
+  end
+
+  test "translate hits the backend and caches the response" do
+    I18n.backend.expects(:lookup).returns('Foo')
+    assert_equal 'Foo', I18n.t(:foo)
+
+    I18n.backend.expects(:lookup).never
+    assert_equal 'Foo', I18n.t(:foo)
+
+    I18n.backend.expects(:lookup).returns('Bar')
+    assert_equal 'Bar', I18n.t(:bar)
+  end
+
+  test "translate returns a cached false response" do
+    I18n.backend.expects(:lookup).never
+    I18n.cache_store.expects(:read).returns(false)
+    assert_equal false, I18n.t(:foo)
+  end
+
+  test "still raises MissingTranslationData but also caches it" do
+    assert_raise(I18n::MissingTranslationData) { I18n.t(:missing, :raise => true) }
+    assert_raise(I18n::MissingTranslationData) { I18n.t(:missing, :raise => true) }
+    assert_equal 1, I18n.cache_store.instance_variable_get(:@data).size
+
+    # I18n.backend.expects(:lookup).returns(nil)
+    # assert_raise(I18n::MissingTranslationData) { I18n.t(:missing, :raise => true) }
+    # I18n.backend.expects(:lookup).never
+    # assert_raise(I18n::MissingTranslationData) { I18n.t(:missing, :raise => true) }
+  end
+
+  test "uses 'i18n' as a cache key namespace by default" do
+    assert_equal 0, I18n.backend.send(:cache_key, :en, :foo, {}).index('i18n')
+  end
+
+  test "adds a custom cache key namespace" do
+    with_cache_namespace('bar') do
+      assert_equal 0, I18n.backend.send(:cache_key, :en, :foo, {}).index('i18n/bar/')
+    end
+  end
+
+  test "adds locale and hash of key and hash of options" do
+    options = { :bar=>1 }
+    options_hash = RUBY_VERSION <= "1.9" ? options.inspect.hash : options.hash
+    assert_equal "i18n//en/#{:foo.hash}/#{options_hash}", I18n.backend.send(:cache_key, :en, :foo, options)
+  end
+
+  test "cache_key uses configured digest method" do
+    md5 = Digest::MD5.new
+    options = { :bar=>1 }
+    options_hash = options.inspect
+    with_cache_key_digest(md5) do
+      assert_equal "i18n//en/#{md5.hexdigest(:foo.to_s)}/#{md5.hexdigest(options_hash)}", I18n.backend.send(:cache_key, :en, :foo, options)
+    end
+  end
+
+  test "keys should not be equal" do
+    interpolation_values1 = { :foo => 1, :bar => 2 }
+    interpolation_values2 = { :foo => 2, :bar => 1 }
+
+    key1 = I18n.backend.send(:cache_key, :en, :some_key, interpolation_values1)
+    key2 = I18n.backend.send(:cache_key, :en, :some_key, interpolation_values2)
+
+    assert key1 != key2
+  end
+
+  protected
+
+    def with_cache_namespace(namespace)
+      I18n.cache_namespace = namespace
+      yield
+      I18n.cache_namespace = nil
+    end
+
+    def with_cache_key_digest(digest)
+      I18n.cache_key_digest = digest
+      yield
+      I18n.cache_key_digest = nil
+    end
+end
+
+end # AS cache check

data/vendor/bundle/ruby/2.3.0/gems/i18n-1.0.1/test/backend/cascade_test.rb

@@ -0,0 +1,86 @@
+require 'test_helper'
+
+class I18nBackendCascadeTest < I18n::TestCase
+  class Backend < I18n::Backend::Simple
+    include I18n::Backend::Cascade
+  end
+
+  def setup
+    super
+    I18n.backend = Backend.new
+    store_translations(:en, :foo => 'foo', :bar => { :baz => 'baz' })
+    @cascade_options = { :step => 1, :offset => 1, :skip_root => false }
+  end
+
+  def lookup(key, options = {})
+    I18n.t(key, options.merge(:cascade => @cascade_options))
+  end
+
+  test "still returns an existing translation as usual" do
+    assert_equal 'foo', lookup(:foo)
+    assert_equal 'baz', lookup(:'bar.baz')
+  end
+
+  test "falls back by cutting keys off the end of the scope" do
+    assert_equal 'foo', lookup(:foo, :scope => :'missing')
+    assert_equal 'foo', lookup(:foo, :scope => :'missing.missing')
+    assert_equal 'baz', lookup(:baz, :scope => :'bar.missing')
+    assert_equal 'baz', lookup(:baz, :scope => :'bar.missing.missing')
+  end
+
+  test "raises I18n::MissingTranslationData exception when no translation was found" do
+    assert_raise(I18n::MissingTranslationData) { lookup(:'foo.missing', :raise => true) }
+    assert_raise(I18n::MissingTranslationData) { lookup(:'bar.baz.missing', :raise => true) }
+    assert_raise(I18n::MissingTranslationData) { lookup(:'missing.bar.baz', :raise => true) }
+  end
+
+  test "cascades before evaluating the default" do
+    assert_equal 'foo', lookup(:foo, :scope => :missing, :default => 'default')
+  end
+
+  test "cascades defaults, too" do
+    assert_equal 'foo', lookup(nil, :default => [:'missing.missing', :'missing.foo'])
+  end
+
+  test "works with :offset => 2 and a single key" do
+    @cascade_options[:offset] = 2
+    lookup(:foo)
+  end
+
+  test "assemble required fallbacks for ActiveRecord validation messages" do
+    store_translations(:en,
+      :errors => {
+        :odd => 'errors.odd',
+        :reply => { :title => { :blank => 'errors.reply.title.blank'   }, :taken  => 'errors.reply.taken'  },
+        :topic => { :title => { :format => 'errors.topic.title.format' }, :length => 'errors.topic.length' }
+      }
+    )
+    assert_equal 'errors.reply.title.blank',  lookup(:'errors.reply.title.blank',  :default => :'errors.topic.title.blank')
+    assert_equal 'errors.reply.taken',        lookup(:'errors.reply.title.taken',  :default => :'errors.topic.title.taken')
+    assert_equal 'errors.topic.title.format', lookup(:'errors.reply.title.format', :default => :'errors.topic.title.format')
+    assert_equal 'errors.topic.length',       lookup(:'errors.reply.title.length', :default => :'errors.topic.title.length')
+    assert_equal 'errors.odd',                lookup(:'errors.reply.title.odd',    :default => :'errors.topic.title.odd')
+  end
+
+  test "assemble action view translation helper lookup cascade" do
+    @cascade_options[:offset] = 2
+
+    store_translations(:en,
+      :menu => { :show => 'menu.show' },
+      :namespace => {
+        :menu => { :new => 'namespace.menu.new' },
+        :controller => {
+          :menu => { :edit => 'namespace.controller.menu.edit' },
+          :action => {
+            :menu => { :destroy => 'namespace.controller.action.menu.destroy' }
+          }
+        }
+      }
+    )
+
+    assert_equal 'menu.show',                                lookup(:'namespace.controller.action.menu.show')
+    assert_equal 'namespace.menu.new',                       lookup(:'namespace.controller.action.menu.new')
+    assert_equal 'namespace.controller.menu.edit',           lookup(:'namespace.controller.action.menu.edit')
+    assert_equal 'namespace.controller.action.menu.destroy', lookup(:'namespace.controller.action.menu.destroy')
+  end
+end

data/vendor/bundle/ruby/2.3.0/gems/i18n-1.0.1/test/backend/chain_test.rb

@@ -0,0 +1,122 @@
+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/vendor/bundle/ruby/2.3.0/gems/i18n-1.0.1/test/backend/exceptions_test.rb

@@ -0,0 +1,36 @@
+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/vendor/bundle/ruby/2.3.0/gems/i18n-1.0.1/test/backend/fallbacks_test.rb

@@ -0,0 +1,219 @@
+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