lazy_record 0.2.1 → 0.2.2

data/vendor/bundle/gems/i18n-0.8.1/test/api/pluralization_test.rb

@@ -1,30 +0,0 @@
-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/gems/i18n-0.8.1/test/api/simple_test.rb

@@ -1,28 +0,0 @@
-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/gems/i18n-0.8.1/test/backend/cache_test.rb

@@ -1,108 +0,0 @@
-require 'test_helper'
-
-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/gems/i18n-0.8.1/test/backend/cascade_test.rb

@@ -1,86 +0,0 @@
-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/gems/i18n-0.8.1/test/backend/chain_test.rb

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

data/vendor/bundle/gems/i18n-0.8.1/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/vendor/bundle/gems/i18n-0.8.1/test/backend/fallbacks_test.rb

@@ -1,206 +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')
-    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 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-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