ruby-cldr 0.0.1

data/test/data/plurals_test.rb

@@ -0,0 +1,132 @@
+require File.dirname(__FILE__) + '/../test_helper.rb'
+
+class TestCldrDataPluralParser < Test::Unit::TestCase
+  def cldr_data
+    File.read(File.dirname(__FILE__) + '/../../vendor/cldr/common/supplemental/plurals.xml')
+  end
+  
+  def cldr_rules
+    Cldr::Data::Plurals::Rules.parse(cldr_data)
+  end
+  
+  def test_compiles_to_valid_ruby_code
+    assert_nothing_raised { eval(cldr_rules.to_ruby) }
+  end
+  
+  def test_evals_to_a_hash_containing_plural_rule_and_keys_per_locale
+    data = eval(cldr_rules.to_ruby)
+    assert Hash === data
+    assert Proc === data[:de][:i18n][:plural][:rule]
+    assert_equal [:one, :other], data[:de][:i18n][:plural][:keys]
+  end
+  
+  def test_lookup_rule_by_locale
+    assert_equal "lambda { |n| n == 1 ? :one : :other }", cldr_rules.rule(:de).to_ruby
+  end
+
+  def test_parses_n
+    assert Cldr::Data::Plurals::Rule.parse('n').is_a?(Cldr::Data::Plurals::Expression)
+  end
+
+  def test_parses_n_is_1
+    rule = Cldr::Data::Plurals::Rule.parse('n is 1')
+    assert_equal [:is, '1'], [rule.operator, rule.operand]
+  end
+
+  def test_parses_n_mod_1_is_1
+    rule = Cldr::Data::Plurals::Rule.parse('n mod 1 is 1')
+    assert_equal [:is, '1', '1'], [rule.operator, rule.operand, rule.mod]
+  end
+
+  def test_parses_n_is_not_1
+    rule = Cldr::Data::Plurals::Rule.parse('n is not 1')
+    assert_equal [:is, '1', true], [rule.operator, rule.operand, rule.negate]
+  end
+
+  def test_parses_n_mod_1_is_not_1
+    rule = Cldr::Data::Plurals::Rule.parse('n mod 1 is not 1')
+    assert_equal [:is, '1', true, '1'], [rule.operator, rule.operand, rule.negate, rule.mod]
+  end
+
+  def test_parses_n_in_1_2
+    rule = Cldr::Data::Plurals::Rule.parse('n in 1..2')
+    assert_equal [:in, '[1, 2]'], [rule.operator, rule.operand]
+  end
+
+  def test_parses_n_mod_1_in_1_2
+    rule = Cldr::Data::Plurals::Rule.parse('n mod 1 in 1..2')
+    assert_equal [:in, '[1, 2]', '1'], [rule.operator, rule.operand, rule.mod]
+  end
+
+  def test_parses_n_not_in_1_2
+    rule = Cldr::Data::Plurals::Rule.parse('n not in 1..2')
+    assert_equal [:in, '[1, 2]', true], [rule.operator, rule.operand, rule.negate]
+  end
+
+  def test_parses_n_mod_1_not_in_1_2
+    rule = Cldr::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]
+  end
+
+  def test_parses_or_condition
+    rule = Cldr::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]
+  end
+
+  def test_parses_and_condition
+    rule = Cldr::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]
+  end
+
+  def test_compiles_n
+    assert_equal 'n', Cldr::Data::Plurals::Rule.parse('n').to_ruby
+  end
+
+  def test_compiles_n_is_2
+    assert_equal 'n == 2', Cldr::Data::Plurals::Rule.parse('n is 2').to_ruby
+  end
+
+  def test_compiles_n_mod_1_is_2
+    assert_equal 'n % 1 == 2', Cldr::Data::Plurals::Rule.parse('n mod 1 is 2').to_ruby
+  end
+
+  def test_compiles_n_is_not_2
+    assert_equal 'n != 2', Cldr::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::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::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::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::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::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::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::Data::Plurals::Rule.parse('n mod 1 is not 2 and n mod 2 in 3..4').to_ruby
+  end
+
+  def test_compiles_n_mod_100_in_3_99
+    assert_equal '[3, 4, 5, 6].include?(n % 100)', Cldr::Data::Plurals::Rule.parse('n mod 100 in 3..6').to_ruby
+  end
+end

data/test/data/territories_test.rb

@@ -0,0 +1,51 @@
+# encoding: utf-8
+
+require File.dirname(__FILE__) + '/../test_helper.rb'
+
+class TestCldrDataTerritories < Test::Unit::TestCase
+  define_method '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]
+
+    territories = Cldr::Data::Territories.new(:de)[:territories]
+    assert (territories.keys - codes).empty? && (codes - territories.keys).empty?
+    assert_equal('Deutschland', territories[:DE])
+  end
+
+  # Cldr::Data.locales.each do |locale|
+  #   define_method "test: extract territories for #{locale}" do
+  #     assert_nothing_raised do
+  #       Cldr::Data::Territories.new(locale)
+  #     end
+  #   end
+  # end
+end
+
+
+
+
+
+
+

data/test/data/timezones_test.rb

@@ -0,0 +1,56 @@
+# encoding: utf-8
+
+require File.dirname(__FILE__) + '/../test_helper.rb'
+
+class TestCldrDataTimezones < Test::Unit::TestCase
+  define_method '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",
+             :"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",
+             :"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"]
+  
+    timezones = Cldr::Data::Timezones.new(:de)[:timezones]
+    assert (timezones.keys - codes).empty? && (codes - timezones.keys).empty?
+    assert_equal({ :city => 'Wien' }, timezones[:"Europe/Vienna"])
+  end
+
+  # Cldr::Data.locales.each do |locale|
+  #   define_method "test: extract timezones for #{locale}" do
+  #     assert_nothing_raised do
+  #       Cldr::Data::Timezones.new(locale)
+  #     end
+  #   end
+  # end
+end
+
+
+
+
+
+

data/test/data/units_test.rb

@@ -0,0 +1,36 @@
+# encoding: utf-8
+
+require File.dirname(__FILE__) + '/../test_helper.rb'
+
+class TestCldrDataUnits < Test::Unit::TestCase
+  define_method 'test: units' do
+    units = {
+      :day    => { :one => "{0} Tag",   :other => "{0} Tage" },
+      :week   => { :one => "{0} Woche", :other => "{0} Wochen" },
+      :month  => { :one => "{0} Monat", :other => "{0} Monate" },
+      :year   => { :one => "{0} Jahr",  :other => "{0} Jahre" },
+      :hour   => { :one => "{0} Std.",  :other => "{0} Std." },
+      :minute => { :one => "{0} Min.",  :other => "{0} Min." },
+      :second => { :one => "{0} Sek.",  :other => "{0} Sek." }
+    }
+    keys = %w(day week month year hour minute second).sort
+    data = Cldr::Data::Units.new('de')[:units]
+
+    assert_equal keys, data.keys.map { |key| key.to_s }.sort
+    assert_equal units[:day],    data[:day]
+    assert_equal units[:week],   data[:week]
+    assert_equal units[:month],  data[:month]
+    assert_equal units[:year],   data[:year]
+    assert_equal units[:hour],   data[:hour]
+    assert_equal units[:minute], data[:minute]
+    assert_equal units[:second], data[:second]
+  end
+
+  # Cldr::Data.locales.each do |locale|
+  #   define_method "test: extract units for #{locale}" do
+  #     assert_nothing_raised do
+  #       Cldr::Data::Units.new(locale)
+  #     end
+  #   end
+  # end
+end

data/test/export_test.rb

@@ -0,0 +1,57 @@
+# encoding: utf-8
+
+require File.dirname(__FILE__) + '/test_helper.rb'
+require 'yaml'
+require 'fileutils'
+
+class TestExtract < Test::Unit::TestCase
+  def setup
+    Cldr::Export.base_path = tmp_dir
+    FileUtils.mkdir_p(tmp_dir) rescue nil
+  end
+
+  def teardown
+    FileUtils.rm_r(tmp_dir)
+  end
+
+  def tmp_dir
+    File.expand_path(File.dirname(__FILE__) + '/tmp')
+  end
+
+  define_method 'test: passing the merge option generates and merge data for all fallback locales' do
+    data = Cldr::Export.data('numbers', 'de-AT')
+    assert !data[:numbers][:formats][:nan]
+
+    data = Cldr::Export.data('numbers', 'de-AT', :merge => true)
+    assert_equal 'NaN', data[:numbers][:symbols][:nan]
+  end
+
+  define_method "test: exports data to files" do
+    Cldr::Export.export(:locales => %w(de), :components => %w(calendars))
+    assert File.exists?(Cldr::Export.path('de', 'calendars', 'yml'))
+  end
+
+  define_method "test: exported data starts with the locale at top level" do
+    Cldr::Export.export(:locales => %w(de), :components => %w(calendars))
+    data = YAML.load(File.open(Cldr::Export.path('de', 'calendars', 'yml')))
+    assert data['de']
+  end
+
+  define_method "test: writes dot-separated symbols to yaml" do
+    data = { :format  => { :narrow => :"calendars.gregorian.months.stand-alone.narrow" } }
+    yaml = %(\nformat: \n  narrow: :"calendars.gregorian.months.stand-alone.narrow")
+
+    assert_equal yaml, Cldr::Export::Yaml.new.emit(data.deep_stringify_keys)
+  end
+
+  # Cldr::Data.locales.each do |locale|
+  #   Cldr::Data.components.each do |component|
+  #     define_method "test: exported yaml file yaml for #{locale}/#{component} readable" do
+  #       Cldr::Export.export(:locales => [locale], :components => [component])
+  #       assert_nothing_raised do
+  #         YAML.load(File.open(Cldr::Data::Export.path(locale, component))) rescue Errno::ENOENT
+  #       end
+  #     end
+  #   end
+  # end
+end

data/test/formats/all.rb

@@ -0,0 +1,3 @@
+Dir["#{File.dirname(__FILE__)}/**/*_test.rb"].each do |filename|
+  require filename
+end

data/test/formats/datetime/all.rb

@@ -0,0 +1,3 @@
+Dir["#{File.dirname(__FILE__)}/**/*_test.rb"].each do |filename|
+  require filename
+end

data/test/formats/datetime/date_test.rb

@@ -0,0 +1,31 @@
+# encoding: utf-8
+
+require File.dirname(__FILE__) + '/../../test_helper'
+require 'date'
+
+class TestCldrDateFormat < Test::Unit::TestCase
+  def setup
+    @locale = :de
+    @calendar = Cldr::Data::Calendars.new(@locale)[:calendars][:gregorian]
+  end
+
+  def format(object, pattern)
+    Cldr::Format::Date.new(pattern, @calendar).apply(object)
+  end
+  
+  define_method "test: full date pattern :de" do
+    assert_equal 'Montag, 11. Januar 2010', format(Date.new(2010, 1, 11), 'EEEE, d. MMMM y')
+  end
+
+  define_method "test: long date pattern :de" do
+    assert_equal '11. Januar 2010', format(Date.new(2010, 1, 11), 'd. MMMM y')
+  end
+
+  define_method "test: medium date pattern :de" do
+    assert_equal '11.01.2010', format(Date.new(2010, 1, 11), 'dd.MM.yyyy')
+  end
+
+  define_method "test: short date pattern :de" do
+    assert_equal '11.01.10', format(Date.new(2010, 1, 11), 'dd.MM.yy')
+  end
+end

data/test/formats/datetime/datetime_test.rb

@@ -0,0 +1,18 @@
+# encoding: utf-8
+
+require File.dirname(__FILE__) + '/../../test_helper'
+require 'date'
+
+class TestCldrDatetimeFormat < Test::Unit::TestCase
+  def setup
+    @locale = :de
+    @calendar = Cldr::Data::Calendars.new(@locale)[:calendars][:gregorian]
+  end
+  
+  define_method "test: datetime pattern :de" do
+    date   = Cldr::Format::Date.new('dd.MM.yyyy', @calendar)
+    time   = Cldr::Format::Time.new('HH:mm', @calendar)
+    result = Cldr::Format::Datetime.new('{1} {0}', date, time).apply(DateTime.new(2010, 1, 10, 13, 12, 11))
+    assert_equal '10.01.2010 13:12', result
+  end
+end

data/test/formats/datetime/day_test.rb

@@ -0,0 +1,41 @@
+# encoding: utf-8
+
+require File.dirname(__FILE__) + '/../../test_helper'
+require 'date'
+
+class TestCldrDateDayFormat < Test::Unit::TestCase
+  def setup
+    @locale = :de
+    @calendar = Cldr::Data::Calendars.new(@locale)[:calendars][:gregorian]
+  end
+
+  def format(object, pattern)
+    Cldr::Format::Date.new(pattern, @calendar).apply(object)
+  end
+
+  # DAY
+
+  define_method "test: pattern d" do
+    assert_equal  '1', format(Date.new(2010, 1,  1), 'd')
+    assert_equal '10', format(Date.new(2010, 1, 10), 'd')
+  end
+
+  define_method "test: pattern dd" do
+    assert_equal '01', format(Date.new(2010, 1,  1), 'dd')
+    assert_equal '10', format(Date.new(2010, 1, 10), 'dd')
+  end
+
+  define_method "test: pattern E, EE, EEE" do
+    assert_equal 'Fr.', format(Date.new(2010, 1, 1), 'E')
+    assert_equal 'Fr.', format(Date.new(2010, 1, 1), 'EE')
+    assert_equal 'Fr.', format(Date.new(2010, 1, 1), 'EEE')
+  end
+
+  define_method "test: pattern EEEE" do
+    assert_equal 'Freitag', format(Date.new(2010, 1, 1), 'EEEE')
+  end
+
+  define_method "test: pattern EEEEE" do
+    assert_equal 'F', format(Date.new(2010, 1, 1), 'EEEEE')
+  end
+end

data/test/formats/datetime/hour_test.rb

@@ -0,0 +1,79 @@
+# encoding: utf-8
+
+require File.dirname(__FILE__) + '/../../test_helper'
+require 'date'
+
+class TestCldrDateHourFormat < Test::Unit::TestCase
+  def setup
+    @locale = :de
+    @calendar = Cldr::Data::Calendars.new(@locale)[:calendars][:gregorian]
+  end
+
+  def format(object, pattern)
+    Cldr::Format::Time.new(pattern, @calendar).apply(object)
+  end
+
+  define_method "test: h" do
+    assert_equal '12', format(Time.local(2000, 1, 1,  0, 1, 1), 'h')
+    assert_equal  '1', format(Time.local(2000, 1, 1,  1, 1, 1), 'h')
+    assert_equal '11', format(Time.local(2000, 1, 1, 11, 1, 1), 'h')
+    assert_equal '12', format(Time.local(2000, 1, 1, 12, 1, 1), 'h')
+    assert_equal '11', format(Time.local(2000, 1, 1, 23, 1, 1), 'h')
+  end
+
+  define_method "test: hh" do
+    assert_equal '12', format(Time.local(2000, 1, 1,  0, 1, 1), 'hh')
+    assert_equal '01', format(Time.local(2000, 1, 1,  1, 1, 1), 'hh')
+    assert_equal '11', format(Time.local(2000, 1, 1, 11, 1, 1), 'hh')
+    assert_equal '12', format(Time.local(2000, 1, 1, 12, 1, 1), 'hh')
+    assert_equal '11', format(Time.local(2000, 1, 1, 23, 1, 1), 'hh')
+  end
+
+  define_method "test: H" do
+    assert_equal  '0', format(Time.local(2000, 1, 1,  0, 1, 1), 'H')
+    assert_equal  '1', format(Time.local(2000, 1, 1,  1, 1, 1), 'H')
+    assert_equal '11', format(Time.local(2000, 1, 1, 11, 1, 1), 'H')
+    assert_equal '12', format(Time.local(2000, 1, 1, 12, 1, 1), 'H')
+    assert_equal '23', format(Time.local(2000, 1, 1, 23, 1, 1), 'H')
+  end
+
+  define_method "test: HH" do
+    assert_equal '00', format(Time.local(2000, 1, 1,  0, 1, 1), 'HH')
+    assert_equal '01', format(Time.local(2000, 1, 1,  1, 1, 1), 'HH')
+    assert_equal '11', format(Time.local(2000, 1, 1, 11, 1, 1), 'HH')
+    assert_equal '12', format(Time.local(2000, 1, 1, 12, 1, 1), 'HH')
+    assert_equal '23', format(Time.local(2000, 1, 1, 23, 1, 1), 'HH')
+  end
+
+  define_method "test: K" do
+    assert_equal  '0', format(Time.local(2000, 1, 1,  0, 1, 1), 'K')
+    assert_equal  '1', format(Time.local(2000, 1, 1,  1, 1, 1), 'K')
+    assert_equal '11', format(Time.local(2000, 1, 1, 11, 1, 1), 'K')
+    assert_equal  '0', format(Time.local(2000, 1, 1, 12, 1, 1), 'K')
+    assert_equal '11', format(Time.local(2000, 1, 1, 23, 1, 1), 'K')
+  end
+
+  define_method "test: KK" do
+    assert_equal '00', format(Time.local(2000, 1, 1,  0, 1, 1), 'KK')
+    assert_equal '01', format(Time.local(2000, 1, 1,  1, 1, 1), 'KK')
+    assert_equal '11', format(Time.local(2000, 1, 1, 11, 1, 1), 'KK')
+    assert_equal '00', format(Time.local(2000, 1, 1, 12, 1, 1), 'KK')
+    assert_equal '11', format(Time.local(2000, 1, 1, 23, 1, 1), 'KK')
+  end
+
+  define_method "test: k" do
+    assert_equal '24', format(Time.local(2000, 1, 1,  0, 1, 1), 'k')
+    assert_equal  '1', format(Time.local(2000, 1, 1,  1, 1, 1), 'k')
+    assert_equal '11', format(Time.local(2000, 1, 1, 11, 1, 1), 'k')
+    assert_equal '12', format(Time.local(2000, 1, 1, 12, 1, 1), 'k')
+    assert_equal '23', format(Time.local(2000, 1, 1, 23, 1, 1), 'k')
+  end
+
+  define_method "test: kk" do
+    assert_equal '24', format(Time.local(2000, 1, 1,  0, 1, 1), 'kk')
+    assert_equal '01', format(Time.local(2000, 1, 1,  1, 1, 1), 'kk')
+    assert_equal '11', format(Time.local(2000, 1, 1, 11, 1, 1), 'kk')
+    assert_equal '12', format(Time.local(2000, 1, 1, 12, 1, 1), 'kk')
+    assert_equal '23', format(Time.local(2000, 1, 1, 23, 1, 1), 'kk')
+  end
+end

data/test/formats/datetime/minute_test.rb

@@ -0,0 +1,25 @@
+# encoding: utf-8
+
+require File.dirname(__FILE__) + '/../../test_helper'
+require 'date'
+
+class TestCldrDateMinuteFormat < Test::Unit::TestCase
+  def setup
+    @locale = :de
+    @calendar = Cldr::Data::Calendars.new(@locale)[:calendars][:gregorian]
+  end
+
+  def format(object, pattern)
+    Cldr::Format::Time.new(pattern, @calendar).apply(object)
+  end
+
+  define_method "test: m" do
+    assert_equal  '1', format(Time.local(2000, 1, 1, 1,  1, 1), 'm')
+    assert_equal '11', format(Time.local(2000, 1, 1, 1, 11, 1), 'm')
+  end
+
+  define_method "test: mm" do
+    assert_equal '01', format(Time.local(2000, 1, 1, 1,  1, 1), 'mm')
+    assert_equal '11', format(Time.local(2000, 1, 1, 1, 11, 1), 'mm')
+  end
+end

data/test/formats/datetime/month_test.rb

@@ -0,0 +1,76 @@
+# encoding: utf-8
+
+require File.dirname(__FILE__) + '/../../test_helper'
+require 'date'
+
+class TestCldrDateMonthFormat < Test::Unit::TestCase
+  def setup
+    @locale = :de
+    @calendar = Cldr::Data::Calendars.new(@locale)[:calendars][:gregorian]
+  end
+
+  def format(object, pattern)
+    Cldr::Format::Date.new(pattern, @calendar).apply(object)
+  end
+
+  # MONTH
+
+  define_method "test: pattern M" do
+    assert_equal   '1', format(Date.new(2010,  1, 1), 'M')
+    assert_equal  '10', format(Date.new(2010, 10, 1), 'M')
+  end
+
+  define_method "test: pattern MM" do
+    assert_equal '01', format(Date.new(2010,  1, 1), 'MM')
+    assert_equal '10', format(Date.new(2010, 10, 1), 'MM')
+  end
+
+  define_method "test: pattern MMM" do
+    assert_equal 'Jan', format(Date.new(2010,  1, 1), 'MMM')
+    assert_equal 'Okt', format(Date.new(2010, 10, 1), 'MMM')
+  end
+
+  define_method "test: pattern MMMM" do
+    assert_equal 'Januar',  format(Date.new(2010,  1, 1), 'MMMM')
+    assert_equal 'Oktober', format(Date.new(2010, 10, 1), 'MMMM')
+  end
+
+  # requires cldr's "multiple inheritance"
+  #
+  # define_method "test: pattern MMMMM" do
+  #   assert_equal 'J', format(Date.new(2010,  1, 1), 'MMMMM')
+  #   assert_equal 'O', format(Date.new(2010, 10, 1), 'MMMMM')
+  # end
+
+  define_method "test: pattern L" do
+    assert_equal   '1', format(Date.new(2010,  1, 1), 'L')
+    assert_equal  '10', format(Date.new(2010, 10, 1), 'L')
+  end
+
+  define_method "test: pattern LL" do
+    assert_equal '01', format(Date.new(2010,  1, 1), 'LL')
+    assert_equal '10', format(Date.new(2010, 10, 1), 'LL')
+  end
+
+  # requires cldr's "multiple inheritance"
+  #
+  # define_method "test: pattern LLL" do
+  #   assert_equal 'Jan', format(Date.new(2010,  1, 1), 'LLL')
+  #   assert_equal 'Okt', format(Date.new(2010, 10, 1), 'LLL')
+  # end
+  #
+  # define_method "test: pattern LLLL" do
+  #   assert_equal 'Januar',  format(Date.new(2010,  1, 1), 'LLLL')
+  #   assert_equal 'Oktober', format(Date.new(2010, 10, 1), 'LLLL')
+  # end
+  #
+  # define_method "test: pattern LLLLL" do
+  #   assert_equal 'J', format(Date.new(2010,  1, 1), 'LLLLL')
+  #   assert_equal 'O', format(Date.new(2010, 10, 1), 'LLLLL')
+  # end
+
+  define_method "test: pattern LLLLL" do
+    assert_equal 'J', format(Date.new(2010,  1, 1), 'LLLLL')
+    assert_equal 'O', format(Date.new(2010, 10, 1), 'LLLLL')
+  end
+end

data/test/formats/datetime/period_test.rb

@@ -0,0 +1,20 @@
+# encoding: utf-8
+
+require File.dirname(__FILE__) + '/../../test_helper'
+require 'date'
+
+class TestCldrDatePeriodFormat < Test::Unit::TestCase
+  def setup
+    @locale = :de
+    @calendar = Cldr::Data::Calendars.new(@locale)[:calendars][:gregorian]
+  end
+
+  def format(object, pattern)
+    Cldr::Format::Time.new(pattern, @calendar).apply(object)
+  end
+
+  define_method "test: a" do
+    assert_equal 'vorm.', format(Time.local(2000, 1, 1, 1, 1, 1), 'a')
+    assert_equal 'nachm.', format(Time.local(2000, 1, 1, 15, 1, 1), 'a')
+  end
+end