ruby-cldr 0.0.2 → 0.1.0

data/test/export/data/metazones_test.rb

@@ -0,0 +1,17 @@
+# encoding: utf-8
+
+require File.expand_path(File.join(File.dirname(__FILE__) + '/../../test_helper'))
+require 'date'
+
+class TestCldrDataMetazones < Test::Unit::TestCase
+  test 'metazone timezones' do
+    timezones = Cldr::Export::Data::Metazones.new[:timezones]
+    assert_equal({ 'from' => DateTime.parse('1990-05-05T21:00:00+00:00'), 'metazone' => 'Europe_Eastern' }, timezones[:'Europe/Chisinau'].last)
+  end
+
+  test 'metazone primaryzones' do
+    primaryzones = Cldr::Export::Data::Metazones.new[:primaryzones]
+    assert_equal('Europe/Berlin', primaryzones[:'DE'])
+  end
+
+end

data/test/export/data/numbers_test.rb

@@ -14,9 +14,8 @@ class TestCldrDataNumbers < Test::Unit::TestCase
       :percent_sign      => "%",
       :list              => ";",
       :per_mille         => "‰",
-      :native_zero_digit => "0",
       :infinity          => "∞",
-      :pattern_digit     => "#"
+      :superscripting_exponent => "·"
     }
     assert_equal expected, Cldr::Export::Data::Numbers.new('de')[:numbers][:symbols]
   end
@@ -24,21 +23,53 @@ class TestCldrDataNumbers < Test::Unit::TestCase
   test "number formats :de" do
     expected = {
       :decimal => {
+        :number_system => "latn",
         :patterns => {
-          :default => "#,##0.###"
+          :default => "#,##0.###",
+          "long" => {
+            "1000" => "0 Tausend",
+            "10000" => "00 Tausend",
+            "100000" => "000 Tausend",
+            "1000000" => "0 Millionen",
+            "10000000" => "00 Millionen",
+            "100000000" => "000 Millionen",
+            "1000000000" => "0 Milliarden",
+            "10000000000" => "00 Milliarden",
+            "100000000000" => "000 Milliarden",
+            "1000000000000" => "0 Billionen",
+            "10000000000000" => "00 Billionen",
+            "100000000000000" => "000 Billionen"
+          },
+          "short" => {
+            "1000" => "0 Tsd",
+            "10000" => "00 Tsd",
+            "100000" => "000 Tsd",
+            "1000000" => "0 Mio",
+            "10000000" => "00 Mio",
+            "100000000" => "000 Mio",
+            "1000000000" => "0 Mrd",
+            "10000000000" => "00 Mrd",
+            "100000000000" => "000 Mrd",
+            "1000000000000" => "0 Bio",
+            "10000000000000" => "00 Bio",
+            "100000000000000" => "000 Bio"
+          }
         }
       },
       :scientific => {
+        :number_system => "latn",
         :patterns => {
           :default => "#E0"
         }
       },
       :percent => {
+        :number_system => "latn",
         :patterns => {
           :default => "#,##0 %"     # includes a non-breaking space (\302\240)
         }
       },
       :currency => {
+        :number_system => "latn",
         :patterns => {
           :default => "#,##0.00 ¤", # includes a non-breaking space (\302\240)
         },

data/test/export/data/plurals_test.rb

@@ -21,121 +21,222 @@ class TestCldrDataPluralParser < Test::Unit::TestCase
   end
   
   def test_lookup_rule_by_locale
-    assert_equal "lambda { |n| n == 1 ? :one : :other }", cldr_rules.rule(:de).to_ruby
+    assert_equal 'lambda { |n| n = n.respond_to?(:abs) ? n.abs : ((m = n.to_s)[0] == "-" ? m[1,m.length] : m); (n.to_i == 1 && ((v = n.to_s.split(".")[1]) ? v.length : 0) == 0) ? :one : :other }', cldr_rules.rule(:de).to_ruby
   end
 
-  def test_parses_n
-    assert Cldr::Export::Data::Plurals::Rule.parse('n').is_a?(Cldr::Export::Data::Plurals::Expression)
+  def test_parses_empty
+    assert Cldr::Export::Data::Plurals::Rule.parse('').is_a?(Cldr::Export::Data::Plurals::Expression)
+    assert Cldr::Export::Data::Plurals::Rule.parse(' ').is_a?(Cldr::Export::Data::Plurals::Expression)
+    assert Cldr::Export::Data::Plurals::Rule.parse(' @integer').is_a?(Cldr::Export::Data::Plurals::Expression)
+    assert Cldr::Export::Data::Plurals::Rule.parse('@decimal').is_a?(Cldr::Export::Data::Plurals::Expression)
   end
 
   def test_parses_n_is_1
     rule = Cldr::Export::Data::Plurals::Rule.parse('n is 1')
-    assert_equal [:is, '1'], [rule.operator, rule.operand]
+    assert_equal [:is, 1], [rule.operator, rule.operand]
   end
 
   def test_parses_n_mod_1_is_1
     rule = Cldr::Export::Data::Plurals::Rule.parse('n mod 1 is 1')
-    assert_equal [:is, '1', '1'], [rule.operator, rule.operand, rule.mod]
+    assert_equal [:is, 1, '1', 'n'], [rule.operator, rule.operand, rule.mod, rule.type]
   end
 
   def test_parses_n_is_not_1
     rule = Cldr::Export::Data::Plurals::Rule.parse('n is not 1')
-    assert_equal [:is, '1', true], [rule.operator, rule.operand, rule.negate]
+    assert_equal [:is, 1, true, 'n'], [rule.operator, rule.operand, rule.negate, rule.type]
   end
 
   def test_parses_n_mod_1_is_not_1
     rule = Cldr::Export::Data::Plurals::Rule.parse('n mod 1 is not 1')
-    assert_equal [:is, '1', true, '1'], [rule.operator, rule.operand, rule.negate, rule.mod]
+    assert_equal [:is, 1, true, '1', 'n'], [rule.operator, rule.operand, rule.negate, rule.mod, rule.type]
   end
 
   def test_parses_n_in_1_2
     rule = Cldr::Export::Data::Plurals::Rule.parse('n in 1..2')
-    assert_equal [:in, '[1, 2]'], [rule.operator, rule.operand]
+    assert_equal [:in, [[],[1..2]], 'n'], [rule.operator, rule.operand, rule.type]
   end
 
   def test_parses_n_mod_1_in_1_2
     rule = Cldr::Export::Data::Plurals::Rule.parse('n mod 1 in 1..2')
-    assert_equal [:in, '[1, 2]', '1'], [rule.operator, rule.operand, rule.mod]
+    assert_equal [:in, [[],[1..2]], '1', 'n'], [rule.operator, rule.operand, rule.mod, rule.type]
   end
 
   def test_parses_n_not_in_1_2
     rule = Cldr::Export::Data::Plurals::Rule.parse('n not in 1..2')
-    assert_equal [:in, '[1, 2]', true], [rule.operator, rule.operand, rule.negate]
+    assert_equal [:in, [[],[1..2]], true, 'n'], [rule.operator, rule.operand, rule.negate, rule.type]
   end
 
   def test_parses_n_mod_1_not_in_1_2
     rule = Cldr::Export::Data::Plurals::Rule.parse('n mod 1 not in 1..2')
-    assert_equal [:in, '[1, 2]', true, '1'], [rule.operator, rule.operand, rule.negate, rule.mod]
+    assert_equal [:in, [[],[1..2]], true, '1', 'n'], [rule.operator, rule.operand, rule.negate, rule.mod, rule.type]
   end
 
   def test_parses_n_within_0_2
     expression = Cldr::Export::Data::Plurals::Rule.parse('n within 0..2')
-    assert_equal [:within, %w{0 2}], [expression.operator, expression.operand]
+    assert_equal [:within, 0..2, 'n'], [expression.operator, expression.operand, expression.type]
+  end
+
+  def test_parses_n_list_range
+    expression = Cldr::Export::Data::Plurals::Rule.parse('n % 100 != 10..19,30,34,39,90..99')
+    assert_equal [:in, [[30, 34, 39],[10..19, 90..99]], true, '100', 'n'], [expression.operator, expression.operand, expression.negate, expression.mod, expression.type]
   end
 
   def test_parses_or_condition
     rule = Cldr::Export::Data::Plurals::Rule.parse('n mod 1 is not 2 or n mod 2 in 3..4')
     assert_equal 2, rule.size
-    assert_equal [:is, '2', true, '1'], [rule[0].operator, rule[0].operand, rule[0].negate, rule[0].mod]
-    assert_equal [:in, '[3, 4]', false, '2'], [rule[1].operator, rule[1].operand, rule[1].negate, rule[1].mod]
+    assert_equal [:is, 2, true, '1', 'n'], [rule[0].operator, rule[0].operand, rule[0].negate, rule[0].mod, rule[0].type]
+    assert_equal [:in, [[],[3..4]], false, '2', 'n'], [rule[1].operator, rule[1].operand, rule[1].negate, rule[1].mod, rule[1].type]
   end
 
   def test_parses_and_condition
     rule = Cldr::Export::Data::Plurals::Rule.parse('n mod 1 is not 2 and n mod 2 in 3..4')
     assert_equal 2, rule.size
-    assert_equal [:is, '2', true, '1'], [rule[0].operator, rule[0].operand, rule[0].negate, rule[0].mod]
-    assert_equal [:in, '[3, 4]', false, '2'], [rule[1].operator, rule[1].operand, rule[1].negate, rule[1].mod]
+    assert_equal [:is, 2, true, '1', 'n'], [rule[0].operator, rule[0].operand, rule[0].negate, rule[0].mod, rule[0].type]
+    assert_equal [:in, [[],[3..4]], false, '2', 'n'], [rule[1].operator, rule[1].operand, rule[1].negate, rule[1].mod, rule[1].type]
+  end
+
+  def test_parses_and_priority
+    rule = Cldr::Export::Data::Plurals::Rule.parse('i = 0 or v != 1 and f % 2 = 3..4')
+    assert_equal 2, rule.size
+    assert_equal 2, rule[1].size
+    assert_equal [:is, 0, 'i'], [rule[0].operator, rule[0].operand, rule[0].type]
+    assert_equal [:is, 1, true, 'v'], [rule[1][0].operator, rule[1][0].operand, rule[1][0].negate, rule[1][0].type]
+    assert_equal [:in, [[],[3..4]], '2', 'f'], [rule[1][1].operator, rule[1][1].operand, rule[1][1].mod, rule[1][1].type]
   end
 
-  def test_compiles_n
-    assert_equal 'n', Cldr::Export::Data::Plurals::Rule.parse('n').to_ruby
+  def test_compiles_empty
+    assert_equal nil, Cldr::Export::Data::Plurals::Rule.parse('').to_ruby
+    assert_equal nil, Cldr::Export::Data::Plurals::Rule.parse(' ').to_ruby
+    assert_equal nil, Cldr::Export::Data::Plurals::Rule.parse(' @integer').to_ruby
+    assert_equal nil, Cldr::Export::Data::Plurals::Rule.parse('@decimal').to_ruby
   end
 
   def test_compiles_n_is_2
-    assert_equal 'n == 2', Cldr::Export::Data::Plurals::Rule.parse('n is 2').to_ruby
+    assert_equal 'n.to_f == 2', Cldr::Export::Data::Plurals::Rule.parse('n is 2').to_ruby
   end
 
   def test_compiles_n_mod_1_is_2
-    assert_equal 'n % 1 == 2', Cldr::Export::Data::Plurals::Rule.parse('n mod 1 is 2').to_ruby
+    assert_equal 'n.to_f % 1 == 2', Cldr::Export::Data::Plurals::Rule.parse('n mod 1 is 2').to_ruby
   end
 
   def test_compiles_n_is_not_2
-    assert_equal 'n != 2', Cldr::Export::Data::Plurals::Rule.parse('n is not 2').to_ruby
+    assert_equal 'n.to_f != 2', Cldr::Export::Data::Plurals::Rule.parse('n is not 2').to_ruby
   end
 
   def test_compiles_n_mod_1_is_not_2
-    assert_equal 'n % 1 != 2', Cldr::Export::Data::Plurals::Rule.parse('n mod 1 is not 2').to_ruby
+    assert_equal 'n.to_f % 1 != 2', Cldr::Export::Data::Plurals::Rule.parse('n mod 1 is not 2').to_ruby
   end
 
   def test_compiles_n_in_1_2
-    assert_equal '[1, 2].include?(n)', Cldr::Export::Data::Plurals::Rule.parse('n in 1..2').to_ruby
+    assert_equal '((n.to_f % 1).zero? && (1..2).include?(n.to_f))', Cldr::Export::Data::Plurals::Rule.parse('n in 1..2').to_ruby
   end
 
   def test_compiles_n_mod_1_in_1_2
-    assert_equal '[1, 2].include?(n % 1)', Cldr::Export::Data::Plurals::Rule.parse('n mod 1 in 1..2').to_ruby
+    assert_equal '(((n.to_f % 1) % 1).zero? && (1..2).include?(n.to_f % 1))', Cldr::Export::Data::Plurals::Rule.parse('n mod 1 in 1..2').to_ruby
   end
 
   def test_compiles_n_not_in_1_2
-    assert_equal '![1, 2].include?(n)', Cldr::Export::Data::Plurals::Rule.parse('n not in 1..2').to_ruby
+    assert_equal '((n.to_f % 1).zero? && !(1..2).include?(n.to_f))', Cldr::Export::Data::Plurals::Rule.parse('n not in 1..2').to_ruby
   end
 
   def test_compiles_n_mod_1_not_in_1_2
-    assert_equal '![1, 2].include?(n % 1)', Cldr::Export::Data::Plurals::Rule.parse('n mod 1 not in 1..2').to_ruby
+    assert_equal '(((n.to_f % 1) % 1).zero? && !(1..2).include?(n.to_f % 1))', Cldr::Export::Data::Plurals::Rule.parse('n mod 1 not in 1..2').to_ruby
   end
 
   def test_compiles_or_condition
-    assert_equal 'n % 1 != 2 || [3, 4].include?(n % 2)', Cldr::Export::Data::Plurals::Rule.parse('n mod 1 is not 2 or n mod 2 in 3..4').to_ruby
+    assert_equal '(n.to_f % 1 != 2 || (((n.to_f % 2) % 1).zero? && (3..4).include?(n.to_f % 2)))', Cldr::Export::Data::Plurals::Rule.parse('n mod 1 is not 2 or n mod 2 in 3..4').to_ruby
   end
 
   def test_compiles_and_condition
-    assert_equal 'n % 1 != 2 && [3, 4].include?(n % 2)', Cldr::Export::Data::Plurals::Rule.parse('n mod 1 is not 2 and n mod 2 in 3..4').to_ruby
+    assert_equal '(n.to_f % 1 != 2 && (((n.to_f % 2) % 1).zero? && (3..4).include?(n.to_f % 2)))', Cldr::Export::Data::Plurals::Rule.parse('n mod 1 is not 2 and n mod 2 in 3..4').to_ruby
+  end
+
+  def test_compiles_and_priority
+    assert_equal '(n.to_i == 0 || (((v = n.to_s.split(".")[1]) ? v.length : 0) != 1 && (3..4).include?(((t = n.to_s.split(".")[1]) ? t.gsub(/0+$/, "").to_i : 0) % 2)))', Cldr::Export::Data::Plurals::Rule.parse('i = 0 or v != 1 and t mod 2 = 3..4').to_ruby
   end
 
   def test_compiles_n_mod_100_in_3_99
-    assert_equal '[3, 4, 5, 6].include?(n % 100)', Cldr::Export::Data::Plurals::Rule.parse('n mod 100 in 3..6').to_ruby
+    assert_equal '(((n.to_f % 100) % 1).zero? && (3..6).include?(n.to_f % 100))', Cldr::Export::Data::Plurals::Rule.parse('n mod 100 in 3..6').to_ruby
   end
 
   def test_compiles_n_within_0_2
-    assert_equal 'n.between?(0, 2)', Cldr::Export::Data::Plurals::Rule.parse('n within 0..2').to_ruby
-  end
-end
+    assert_equal 'n.to_f.between?(0, 2)', Cldr::Export::Data::Plurals::Rule.parse('n within 0..2').to_ruby
+  end
+
+  def test_compiles_n_list_range
+    assert_equal '(![30, 34, 39].include?(n.to_f % 100) || (((n.to_f % 100) % 1).zero? && (!(10..19).include?(n.to_f % 100) || !(90..99).include?(n.to_f % 100))))', Cldr::Export::Data::Plurals::Rule.parse('n % 100 != 10..19,30,34,39,90..99').to_ruby
+  end
+
+  def test_compiles_n_list_range2
+    assert_equal '((n.to_f % 100) != 100 || (((n.to_f % 100) % 1).zero? && (!(10..19).include?(n.to_f % 100) || !(90..99).include?(n.to_f % 100))))', Cldr::Export::Data::Plurals::Rule.parse('n % 100 != 10..19,90..99,100').to_ruby
+  end
+
+  def test_eval_n_in
+    n = 3.3
+    assert_equal false, eval(Cldr::Export::Data::Plurals::Rule.parse('n mod 100 in 3..6').to_ruby, binding)
+  end
+
+  def test_n_negative
+    # one: i = 1 and v = 0 @integer 1
+    # other: @integer 0, 2~16, 100, 1000, 10000, 100000, 1000000, … @decimal 0.0~1.5, 10.0, 100.0, 1000.0, 10000.0, 100000.0, 1000000.0, …
+    fn = eval(cldr_rules.rule(:de).to_ruby)
+    assert_equal :one, fn.call(-1)
+    assert_equal :one, fn.call("-1")
+    assert_equal :one, fn.call(1)
+    assert_equal :other, fn.call("1.0")
+    assert_equal :other, fn.call("-1.0")
+    assert_equal :other, fn.call(-5)
+  end
+
+  def test_n_digit
+    # one: n = 0..1 or n = 11..99 @integer 0, 1, 11~24 @decimal 0.0, 1.0, 11.0, 12.0, 13.0, 14.0, 15.0, 16.0, 17.0, 18.0, 19.0, 20.0, 21.0, 22.0, 23.0, 24.0
+    # other: @integer 2~10, 100~106, 1000, 10000, 100000, 1000000, … @decimal 0.1~0.9, 1.1~1.7, 10.0, 100.0, 1000.0, 10000.0, 100000.0, 1000000.0, …
+    fn = eval(cldr_rules.rule(:tzm).to_ruby)
+    assert_equal :one, fn.call(0)
+    assert_equal :one, fn.call(1)
+    assert_equal :one, fn.call(11)
+    assert_equal :one, fn.call(25.0)
+    assert_equal :one, fn.call("-62.00")
+    assert_equal :other, fn.call(2)
+    assert_equal :other, fn.call(10)
+    assert_equal :other, fn.call(25.1)
+    assert_equal :other, fn.call(111)
+  end
+
+  def test_n_string
+    # one: i = 1 and v = 0 or i = 0 and t = 1 @integer 1 @decimal 0.1, 0.01, 0.10, 0.001, 0.010, 0.100, 0.0001, 0.0010, 0.0100, 0.1000
+    # other: @integer 0, 2~16, 100, 1000, 10000, 100000, 1000000, … @decimal 0.0, 0.2~1.6, 10.0, 100.0, 1000.0, 10000.0, 100000.0, 1000000.0, …
+    fn = eval(cldr_rules.rule(:pt).to_ruby)
+    assert_equal :one, fn.call("1")
+    assert_equal :one, fn.call("0.00100")
+    assert_equal :one, fn.call("-0.01")
+    assert_equal :other, fn.call("0")
+    assert_equal :other, fn.call("1.1")
+    assert_equal :other, fn.call("0.21")
+  end
+
+  def test_n_mod
+    # one: v = 0 and i % 10 = 1 and i % 100 != 11 or f % 10 = 1 and f % 100 != 11 @integer 1, 21, 31, 41, 51, 61, 71, 81, 101, 1001, … @decimal 0.1, 1.1, 2.1, 3.1, 4.1, 5.1, 6.1, 7.1, 10.1, 100.1, 1000.1, …
+    # few: v = 0 and i % 10 = 2..4 and i % 100 != 12..14 or f % 10 = 2..4 and f % 100 != 12..14 @integer 2~4, 22~24, 32~34, 42~44, 52~54, 62, 102, 1002, … @decimal 0.2~0.4, 1.2~1.4, 2.2~2.4, 3.2~3.4, 4.2~4.4, 5.2, 10.2, 100.2, 1000.2, …
+    # other: @integer 0, 5~19, 100, 1000, 10000, 100000, 1000000, … @decimal 0.0, 0.5~1.0, 1.5~2.0, 2.5~2.7, 10.0, 100.0, 1000.0, 10000.0, 100000.0, 1000000.0, …
+    fn = eval(cldr_rules.rule(:hr).to_ruby)
+    assert_equal :one, fn.call(1)
+    assert_equal :one, fn.call("21")
+    assert_equal :one, fn.call("131")
+    assert_equal :one, fn.call(11.321)
+    assert_equal :one, fn.call("25.01")
+    assert_equal :few, fn.call(24)
+    assert_equal :few, fn.call("252")
+    assert_equal :few, fn.call(2.04)
+    assert_equal :few, fn.call("113.0022")
+    assert_equal :other, fn.call("10")
+    assert_equal :other, fn.call("11")
+    assert_equal :other, fn.call(311)
+    assert_equal :other, fn.call("13")
+    assert_equal :other, fn.call(1212)
+    assert_equal :other, fn.call("0.10")
+    assert_equal :other, fn.call(0.11)
+    assert_equal :other, fn.call("0.220")
+    assert_equal :other, fn.call("41.0")
+  end
+end

data/test/export/data/territories_test.rb

@@ -6,28 +6,28 @@ class TestCldrDataTerritories < Test::Unit::TestCase
   test 'territories :de' do
     codes = [:"001", :"002", :"003", :"005", :"009", :"011", :"013", :"014",
              :"015", :"017", :"018", :"019", :"021", :"029", :"030", :"034",
-             :"035", :"039", :"053", :"054", :"057", :"061", :"062", :"142",
-             :"143", :"145", :"150", :"151", :"154", :"155", :"172", :"419",
-             :"830", :AD, :AE, :AF, :AG, :AI, :AL, :AM, :AN, :AO, :AQ, :AR,
-             :AS, :AT, :AU, :AW, :AX, :AZ, :BA, :BB, :BD, :BE, :BF, :BG, :BH,
-             :BI, :BJ, :BL, :BM, :BN, :BO, :BR, :BS, :BT, :BV, :BW, :BY, :BZ,
-             :CA, :CC, :CD, :CF, :CG, :CH, :CI, :CK, :CL, :CM, :CN, :CO, :CR,
-             :CS, :CU, :CV, :CX, :CY, :CZ, :DE, :DJ, :DK, :DM, :DO, :DZ, :EC,
-             :EE, :EG, :EH, :ER, :ES, :ET, :FI, :FJ, :FK, :FM, :FO, :FR, :GA,
-             :GB, :GD, :GE, :GF, :GG, :GH, :GI, :GL, :GM, :GN, :GP, :GQ, :GR,
-             :GS, :GT, :GU, :GW, :GY, :HK, :HM, :HN, :HR, :HT, :HU, :ID, :IE,
-             :IL, :IM, :IN, :IO, :IQ, :IR, :IS, :IT, :JE, :JM, :JO, :JP, :KE,
-             :KG, :KH, :KI, :KM, :KN, :KP, :KR, :KW, :KY, :KZ, :LA, :LB, :LC,
-             :LI, :LK, :LR, :LS, :LT, :LU, :LV, :LY, :MA, :MC, :MD, :ME, :MF,
-             :MG, :MH, :MK, :ML, :MM, :MN, :MO, :MP, :MQ, :MR, :MS, :MT, :MU,
-             :MV, :MW, :MX, :MY, :MZ, :NA, :NC, :NE, :NF, :NG, :NI, :NL, :NO,
-             :NP, :NR, :NU, :NZ, :OM, :PA, :PE, :PF, :PG, :PH, :PK, :PL, :PM,
-             :PN, :PR, :PS, :PT, :PW, :PY, :QA, :QO, :QU, :RE, :RO, :RS, :RU,
-             :RW, :SA, :SB, :SC, :SD, :SE, :SG, :SH, :SI, :SJ, :SK, :SL, :SM,
-             :SN, :SO, :SR, :ST, :SV, :SY, :SZ, :TC, :TD, :TF, :TG, :TH, :TJ,
-             :TK, :TL, :TM, :TN, :TO, :TR, :TT, :TV, :TW, :TZ, :UA, :UG, :UM,
-             :US, :UY, :UZ, :VA, :VC, :VE, :VG, :VI, :VN, :VU, :WF, :WS, :YE,
-             :YT, :ZA, :ZM, :ZW, :ZZ]
+             :"035", :"039", :"053", :"054", :"057", :"061", :"142", :"143",
+             :"145", :"150", :"151", :"154", :"155", :"419", :AC, :AD, :AE,
+             :AF, :AG, :AI, :AL, :AM, :AN, :AO, :AQ, :AR, :AS, :AT, :AU, :AW,
+             :AX, :AZ, :BA, :BB, :BD, :BE, :BF, :BG, :BH, :BI, :BJ, :BL, :BM,
+             :BN, :BO, :BQ, :BR, :BS, :BT, :BV, :BW, :BY, :BZ, :CA, :CC, :CD,
+             :CF, :CG, :CH, :CI, :CK, :CL, :CM, :CN, :CO, :CP, :CR, :CU, :CV,
+             :CW, :CX, :CY, :CZ, :DE, :DG, :DJ, :DK, :DM, :DO, :DZ, :EA, :EC,
+             :EE, :EG, :EH, :ER, :ES, :ET, :EU, :FI, :FJ, :FK, :FM, :FO, :FR,
+             :GA, :GB, :GD, :GE, :GF, :GG, :GH, :GI, :GL, :GM, :GN, :GP, :GQ,
+             :GR, :GS, :GT, :GU, :GW, :GY, :HK, :HM, :HN, :HR, :HT, :HU, :IC,
+             :ID, :IE, :IL, :IM, :IN, :IO, :IQ, :IR, :IS, :IT, :JE, :JM, :JO,
+             :JP, :KE, :KG, :KH, :KI, :KM, :KN, :KP, :KR, :KW, :KY, :KZ, :LA,
+             :LB, :LC, :LI, :LK, :LR, :LS, :LT, :LU, :LV, :LY, :MA, :MC, :MD,
+             :ME, :MF, :MG, :MH, :MK, :ML, :MM, :MN, :MO, :MP, :MQ, :MR, :MS,
+             :MT, :MU, :MV, :MW, :MX, :MY, :MZ, :NA, :NC, :NE, :NF, :NG, :NI,
+             :NL, :NO, :NP, :NR, :NU, :NZ, :OM, :PA, :PE, :PF, :PG, :PH, :PK,
+             :PL, :PM, :PN, :PR, :PS, :PT, :PW, :PY, :QA, :QO, :RE, :RO, :RS,
+             :RU, :RW, :SA, :SB, :SC, :SD, :SE, :SG, :SH, :SI, :SJ, :SK, :SL,
+             :SM, :SN, :SO, :SR, :SS, :ST, :SV, :SX, :SY, :SZ, :TA, :TC, :TD,
+             :TF, :TG, :TH, :TJ, :TK, :TL, :TM, :TN, :TO, :TR, :TT, :TV, :TW,
+             :TZ, :UA, :UG, :UM, :US, :UY, :UZ, :VA, :VC, :VE, :VG, :VI, :VN,
+             :VU, :WF, :WS, :XK, :YE, :YT, :ZA, :ZM, :ZW, :ZZ]
 
     territories = Cldr::Export::Data::Territories.new(:de)[:territories]
     assert (territories.keys - codes).empty? && (codes - territories.keys).empty?

data/test/export/data/timezones_test.rb

@@ -5,41 +5,64 @@ require File.expand_path(File.join(File.dirname(__FILE__) + '/../../test_helper'
 class TestCldrDataTimezones < Test::Unit::TestCase
   test 'timezones :de' do
     codes = [:"Etc/Unknown", :"Europe/Tirane", :"Asia/Yerevan",
-             :"America/Curacao", :"Antarctica/South_Pole",
-             :"Antarctica/Vostok", :"Antarctica/DumontDUrville",
-             :"Europe/Vienna", :"Europe/Brussels", :"Africa/Ouagadougou",
-             :"Atlantic/Bermuda", :"Europe/Zurich", :"Pacific/Easter",
-             :"America/Havana", :"Atlantic/Cape_Verde", :"Indian/Christmas",
-             :"Asia/Nicosia", :"Africa/Djibouti", :"Europe/Copenhagen",
-             :"Africa/Algiers", :"Africa/Cairo", :"Africa/El_Aaiun",
+             :"Antarctica/South_Pole", :"Antarctica/Vostok",
+             :"Antarctica/DumontDUrville", :"Europe/Vienna", :"Europe/Brussels",
+             :"Africa/Ouagadougou", :"Africa/Porto-Novo", :"America/St_Barthelemy",
+             :"Atlantic/Bermuda", :"America/Sao_Paulo", :"America/Coral_Harbour",
+             :"America/St_Johns", :"Europe/Zurich", :"Pacific/Easter",
+             :"Asia/Kashgar", :"America/Bogota", :"America/Havana",
+             :"Atlantic/Cape_Verde", :"America/Curacao", :"Indian/Christmas",
+             :"Asia/Nicosia", :"Europe/Prague", :"Europe/Busingen",
+             :"Africa/Djibouti", :"Europe/Copenhagen", :"Africa/Algiers",
+             :"Africa/Cairo", :"Africa/El_Aaiun", :"Africa/Asmera",
              :"Atlantic/Canary", :"Africa/Addis_Ababa", :"Pacific/Fiji",
-             :"Atlantic/Faeroe", :"Asia/Tbilisi", :"Africa/Accra",
-             :"Europe/Athens", :"Atlantic/South_Georgia", :"Asia/Hong_Kong",
-             :"Asia/Baghdad", :"Asia/Tehran", :"Europe/Rome",
-             :"America/Jamaica", :"Asia/Tokyo", :"Asia/Bishkek",
-             :"Indian/Comoro", :"America/St_Kitts", :"Asia/Pyongyang",
-             :"America/Cayman", :"Asia/Aqtobe", :"America/St_Lucia",
-             :"Europe/Vilnius", :"Europe/Luxembourg", :"Africa/Tripoli",
-             :"Europe/Chisinau", :"Asia/Macau", :"Indian/Maldives",
-             :"America/Mexico_City", :"Africa/Niamey", :"Asia/Muscat",
-             :"Europe/Warsaw", :"Atlantic/Azores", :"Europe/Lisbon",
-             :"America/Asuncion", :"Asia/Qatar", :"Indian/Reunion",
-             :"Europe/Bucharest", :"Europe/Moscow", :"Asia/Yekaterinburg",
-             :"Asia/Novosibirsk", :"Asia/Krasnoyarsk", :"Asia/Yakutsk",
+             :"Pacific/Truk", :"Pacific/Ponape", :"Atlantic/Faeroe",
+             :"Europe/London", :"Asia/Tbilisi", :"Africa/Accra", :"America/Godthab",
+             :"America/Scoresbysund", :"Europe/Athens", :"Atlantic/South_Georgia",
+             :"Asia/Hong_Kong", :"Asia/Jayapura", :"Europe/Dublin", :"Asia/Calcutta",
+             :"Asia/Baghdad", :"Asia/Tehran", :"Atlantic/Reykjavik", :"Europe/Rome",
+             :"America/Jamaica", :"Asia/Tokyo", :"Asia/Bishkek", :"Indian/Comoro",
+             :"America/St_Kitts", :"Asia/Pyongyang", :"America/Cayman",
+             :"Asia/Aqtobe", :"America/St_Lucia", :"Europe/Vilnius",
+             :"Europe/Luxembourg", :"Africa/Tripoli", :"Europe/Chisinau",
+             :"Asia/Macau", :"Indian/Maldives", :"America/Mexico_City",
+             :"Asia/Katmandu", :"Asia/Muscat", :"Europe/Warsaw", :"Atlantic/Azores",
+             :"Europe/Lisbon", :"America/Asuncion", :"Asia/Qatar", :"Indian/Reunion",
+             :"Europe/Bucharest", :"Europe/Belgrade", :"Europe/Moscow",
+             :"Europe/Volgograd", :"Asia/Yekaterinburg", :"Asia/Novosibirsk",
+             :"Asia/Novokuznetsk", :"Asia/Krasnoyarsk", :"Asia/Yakutsk",
              :"Asia/Vladivostok", :"Asia/Sakhalin", :"Asia/Kamchatka",
              :"Asia/Riyadh", :"Africa/Khartoum", :"Asia/Singapore",
              :"Atlantic/St_Helena", :"Africa/Mogadishu", :"Africa/Sao_Tome",
-             :"America/El_Salvador", :"Asia/Damascus", :"Asia/Dushanbe",
-             :"America/Port_of_Spain", :"Asia/Taipei", :"Africa/Dar_es_Salaam",
-             :"Europe/Uzhgorod", :"Europe/Kiev", :"Europe/Zaporozhye",
-             :"America/Indiana/Knox", :"Asia/Tashkent", :"America/St_Vincent",
-             :"America/St_Thomas"]
-  
+             :"America/El_Salvador", :"America/Lower_Princes", :"Asia/Damascus",
+             :"Africa/Lome", :"Asia/Dushanbe", :"America/Port_of_Spain",
+             :"Asia/Taipei", :"Africa/Dar_es_Salaam", :"Europe/Uzhgorod",
+             :"Europe/Kiev", :"Europe/Zaporozhye", :"America/North_Dakota/Beulah",
+             :"America/North_Dakota/New_Salem", :"America/North_Dakota/Center",
+             :"America/Indiana/Vincennes", :"America/Indiana/Petersburg",
+             :"America/Indiana/Tell_City", :"America/Indiana/Knox",
+             :"America/Indiana/Winamac", :"America/Indiana/Marengo",
+             :"America/Indiana/Vevay", :"America/Kentucky/Monticello",
+             :"Asia/Tashkent", :"Europe/Vatican", :"America/St_Vincent",
+             :"America/St_Thomas", :"Asia/Saigon"]
+
     timezones = Cldr::Export::Data::Timezones.new(:de)[:timezones]
     assert (timezones.keys - codes).empty? && (codes - timezones.keys).empty?
     assert_equal({ :city => 'Wien' }, timezones[:"Europe/Vienna"])
   end
 
+  test 'timezone daylight' do
+    london = Cldr::Export::Data::Timezones.new(:de)[:timezones][:'Europe/London']
+    assert_equal({ :long => { :daylight => 'Britische Sommerzeit'} }, london)
+  end
+
+  test 'metazone :de Europe_Western' do
+    europe_western = Cldr::Export::Data::Timezones.new(:de)[:metazones][:Europe_Western]
+    long = { :generic => 'Westeuropäische Zeit', :standard => 'Westeuropäische Normalzeit', :daylight => 'Westeuropäische Sommerzeit' }
+    short = { :generic => 'WEZ', :standard => 'WEZ', :daylight => 'WESZ' }
+    assert_equal({ :long => long, :short => short }, europe_western)
+  end
+
   # Cldr::Export::Data.locales.each do |locale|
   #   test "extract timezones for #{locale}" do
   #     assert_nothing_raised do