when_exe 0.3.7 → 0.3.8

data/test/test/region/jewish.rb

@@ -56,6 +56,8 @@ module MiniTest
       assert_equal("BCE3761(-3760).10.07",
                    (When.era('BCE')[0] ^ When.Calendar('Jewish').domain[''].first).to_s)
 
+      date = When.when?('4861-06-21^^Jewish')
+      assert_equal('4862-06*21', (date + When::P1Y).to_s)
     end
   end
 end

data/test/test/region/m17n.rb

@@ -179,6 +179,15 @@ module MiniTest
           end
         end
       end
+
+      assert_equal({:Frame=>"http://hosi.org/When/CalendarTypes/Gregorian",
+                    :Precision=>0,
+                    :Sdn=>2456388,
+                    :Calendar=>["http://hosi.org/When/CalendarTypes/Gregorian"],
+                    :Notes=>[[{:Note=>"Month", :Value=>"April"}],
+                             [{:Note=>"Week", :Value=>"Friday(4)"}]],
+                    :CalDate=>[2013, 4, 5]},
+                    When.when?('2013-4-5').to_h(:method=>:to_m17n, :locale=>'en', :camel=>true))
     end
   end
 end

data/test/test/region/reforms.rb

@@ -0,0 +1,121 @@
+# -*- coding: utf-8 -*-
+=begin
+  Copyright (C) 2014 Takashi SUGA
+
+  You may use and/or modify this file according to the license
+  described in the LICENSE.txt file included in this archive.
+=end
+
+module MiniTest
+
+  class World < MiniTest::TestCase
+    def test_world
+      date = When.when? '2001.1.1'
+      400.times do
+        assert_equal(date.cal_date, (When::World ^ date).cal_date)
+        date += When::P1Y
+      end
+    end
+  end
+
+  class Positivist < MiniTest::TestCase
+    def test_positivist
+      date = When.when? '2001.1.1'
+      400.times do |i|
+        assert_equal([2001+i-1788,1,1], (When::Positivist ^ date).cal_date)
+        date += When::P1Y
+      end
+    end
+  end
+
+  class InternationalFixed < MiniTest::TestCase
+    def test_international_fixed
+      date = When.when? '2001.1.1'
+      400.times do |i|
+        assert_equal([2001+i,1,1], (When::InternationalFixed ^ date).cal_date)
+        date += When::P1Y
+      end
+    end
+  end
+
+  class Tranquility < MiniTest::TestCase
+    def test_tranquility
+      date = When.when? '1969.7.21'
+      400.times do |i|
+        assert_equal([1+i,1,1], (When::Tranquility ^ date).cal_date)
+        date += When::P1Y
+      end
+    end
+  end
+
+  class WorldSeason < MiniTest::TestCase
+    def test_world_season
+      date = When.when? '2000.12.21'
+      400.times do |i|
+        assert_equal([2001+i,1,1], (When::WorldSeason ^ date).cal_date)
+        date += When::P1Y
+      end
+    end
+  end
+
+  class Pax < MiniTest::TestCase
+    def test_pax
+
+      samples = [
+        %w(2014-01-01 2013-12-29),
+        %w(2015-01-01 2014-12-28),
+        %w(2016-01-01 2015-12-27),
+        %w(2017-01-01 2016-12-25),
+        %w(2018-01-01 2017-12-24),
+        %w(2019-01-01 2018-12-30),
+        %w(2020-01-01 2019-12-29),
+        %w(2021-01-01 2020-12-27),
+        %w(2022-01-01 2021-12-26),
+        %w(2023-01-01 2022-12-25),
+
+        %w(2018-02-01 2018-01-21),
+        %w(2018-03-01 2018-02-18),
+        %w(2018-04-01 2018-03-18),
+        %w(2018-05-01 2018-04-15),
+        %w(2018-06-01 2018-05-13),
+        %w(2018-07-01 2018-06-10),
+        %w(2018-08-01 2018-07-08),
+        %w(2018-09-01 2018-08-05),
+        %w(2018-10-01 2018-09-02),
+        %w(2018-11-01 2018-09-30),
+        %w(2018-12-01 2018-10-28),
+        %w(2018-12=01 2018-11-25),
+        %w(2018-13-01 2018-12-02)]
+
+      date = When.when? '2014.1.1^^Pax'
+      10.times do
+        assert_equal(samples.shift, [date.to_s, (When::Gregorian ^ date).to_s])
+        date += When::P1Y
+      end
+
+      date = When.when? '2018.1.1^^Pax'
+      13.times do
+        date += When::P1M
+        assert_equal(samples.shift, [date.to_s, (When::Gregorian ^ date).to_s])
+      end
+    end
+  end
+
+  class HankeHenry < MiniTest::TestCase
+    def test_hanke_henry
+      assert_equal(When.when?('2012.1.1').to_i, When.when?('2012.1.1^^HankeHenry').to_i)
+      count = 0
+      (2000...2400).each do |year|
+        first = When.tm_pos(year, 1, 1)
+        last  = When.tm_pos(year,12,31)
+        if (first.to_i % 7) == 3 || (last.to_i % 7) == 3
+          assert_equal(371, When.tm_pos(year, :frame=>When::HankeHenry).length(When::YEAR))
+          count += 1
+        else
+          assert_equal(364, When.tm_pos(year, :frame=>When::HankeHenry).length(When::YEAR))
+        end
+      end
+      assert_equal(71, count)
+    end
+  end
+end

data/test/test/region/residue.rb

@@ -92,6 +92,7 @@ module MiniTest
     def test__epoch_in_CE
       cals  = [
         'Gregorian',
+        'Gregorian?border=1959-2-23',
         'Dee',
         'DeeCecil',
         'Coptic?Epoch=284Y',
@@ -105,6 +106,7 @@ module MiniTest
         'IndianNationalSolar',
         'Nanakshahi',
         'RevisedBengali',
+        'Fasli',
         'HinduSolar?type=SBV',
         'HinduSolar?type=SBVZ',
         'HinduSolar?type=SBS',
@@ -113,14 +115,14 @@ module MiniTest
         'HinduSolar?type=SBBZ',
         'HinduSolar?type=SBH',
         'HinduSolar?type=SBHZ',
-     #  'HinduLuniSolar?type=SBVA',
-     #  'HinduLuniSolar?type=SBVZA',
-     #  'HinduLuniSolar?type=SBSA',
-     #  'HinduLuniSolar?type=SBSZA',
-     #  'HinduLuniSolar?type=SBB',
-     #  'HinduLuniSolar?type=SBBZ',
-     #  'HinduLuniSolar?type=SBH',
-     #  'HinduLuniSolar?type=SBHZ',
+        'HinduLuniSolar?type=SBVA',
+      # 'HinduLuniSolar?type=SBVZA',
+      # 'HinduLuniSolar?type=SBSA',
+      # 'HinduLuniSolar?type=SBSZA',
+      # 'HinduLuniSolar?type=SBBA',
+      # 'HinduLuniSolar?type=SBBZA',
+      # 'HinduLuniSolar?type=SBHA',
+      # 'HinduLuniSolar?type=SBHZA',
         'FrenchRepublican',
         'Jalali',
         'SolarHijri',
@@ -128,17 +130,21 @@ module MiniTest
         'Borji',
         'Jewish',
         'Thai',
-      # 'ThaiC',
+        'ThaiT',
         'Tibetan',
+        'Discordian',
+        'Positivist',
+        'InternationalFixed',
+        'VanishingLeprechaun'
       ]
       eto   = When.Resource('_co:Common::干支').to('year')
-      today = When.when?('2012-06-16')
+      today = When.when?('2012-06-15')
       assert_equal([[28, 246778, 246778]],
         cals.map { |list|
           cal, shift = list
           shift    ||= 0
           date = When.Calendar(cal) ^ today
-          [date % eto - shift, ((eto & date).to_i/10).to_i + 37*shift, ((date & eto).to_i/10).to_i + 37*shift]
+          [+(date % eto - shift), ((eto & date).to_i/10).to_i + 37*shift, ((date & eto).to_i/10).to_i + 37*shift]
         }.uniq
       )
     end

data/test/test/region/shire.rb

@@ -0,0 +1,58 @@
+# -*- coding: utf-8 -*-
+=begin
+  Copyright (C) 2014 Takashi SUGA
+
+  You may use and/or modify this file according to the license
+  described in the LICENSE.txt file included in this archive.
+=end
+
+module MiniTest
+
+  class Shire < MiniTest::TestCase
+    def test_shire
+      date = When.when? '2001.1.1^^Shire?time_basis=+09:00'
+      [["2001-01-01", 2451901],
+       ["2002-01-01", 2452266],
+       ["2003-01-01", 2452632],
+       ["2004-01-01", 2452997],
+       ["2005-01-01", 2453362],
+       ["2006-01-01", 2453727],
+       ["2007-01-01", 2454093],
+       ["2008-01-01", 2454458],
+       ["2009-01-01", 2454823],
+       ["2010-01-01", 2455188],
+       ["2011-01-01", 2455554],
+       ["2012-01-01", 2455919],
+       ["2013-01-01", 2456284],
+       ["2014-01-01", 2456649],
+       ["2015-01-01", 2457015],
+       ["2016-01-01", 2457380],
+       ["2017-01-01", 2457745],
+       ["2018-01-01", 2458110],
+       ["2019-01-01", 2458476],
+       ["2020-01-01", 2458841],
+       ["2021-01-01", 2459206],
+       ["2022-01-01", 2459571],
+       ["2023-01-01", 2459936],
+       ["2024-01-01", 2460302],
+       ["2025-01-01", 2460667],
+       ["2026-01-01", 2461032],
+       ["2027-01-01", 2461397],
+       ["2028-01-01", 2461763],
+       ["2029-01-01", 2462128],
+       ["2030-01-01", 2462493],
+       ["2031-01-01", 2462858],
+       ["2032-01-01", 2463224],
+       ["2033-01-01", 2463589]].each do |sample|
+        assert_equal(sample, [date.to_s, date.to_i])
+        date += When::P1Y
+      end
+
+      date = When.when? '2001.1.1'
+      400.times do
+        assert_equal([1,9], (When.Calendar('Shire') ^ date).cal_date[1..2])
+        date += When::P1Y
+      end
+    end
+  end
+end

data/test/test/region/swedish.rb

@@ -0,0 +1,45 @@
+# -*- coding: utf-8 -*-
+=begin
+  Copyright (C) 2014 Takashi SUGA
+
+  You may use and/or modify this file according to the license
+  described in the LICENSE.txt file included in this archive.
+=end
+
+module MiniTest
+
+  class Swedish < MiniTest::TestCase
+    def test__swedish_date
+
+      dates = []
+      jdns  = []
+      [2342042, 2346424].each do |base|
+        (-3..+3).each do |diff|
+          jdn    = base + diff
+          jdate  = When::Julian  ^ jdn
+          s1date = When::Swedish ^ jdn
+          s2date = When.tm_pos(*(s1date.cal_date + [{:frame=>When::Swedish}]))
+          dates << s1date.to_s
+          jdns  << [s1date.to_s == s2date.to_s, s1date.to_i == jdn, s2date.to_i == jdn].uniq
+        end
+      end
+
+      assert_equal(%w(1700-02-26 1700-02-27 1700-02-28 1700-03-01 1700-03-02 1700-03-03 1700-03-04
+                      1712-02-26 1712-02-27 1712-02-28 1712-02-29 1712-02-30 1712-03-01 1712-03-02), dates)
+      assert_equal([[true]], jdns.uniq)
+    end
+
+    def test__swedish_easter
+
+      dates = []
+      civil = When.Calendar('Civil?old=Swedish&reform_date=1753-03-01')
+      ((1700..1711).to_a + (1740..1752).to_a+[1802,1805,1818]).each do |year|
+         dates << When.tm_pos(year, {:frame=>civil}).easter.to_s
+      end
+      assert_equal(%w(1700-04-01 1701-04-21 1702-04-06 1703-03-29 1704-04-17 1705-04-02 1706-03-25
+                      1707-04-14 1708-04-05 1709-04-18 1710-04-10 1711-03-26 1740-04-06 1741-03-22
+                      1742-03-14 1743-04-03 1744-03-18 1745-04-07 1746-03-30 1747-03-22 1748-04-03
+                      1749-03-26 1750-03-18 1751-03-31 1752-03-22 1802-04-25 1805-04-21 1818-03-29), dates)
+    end
+  end
+end

data/test/test/region/zoroastrian.rb

@@ -0,0 +1,58 @@
+# -*- coding: utf-8 -*-
+=begin
+  Copyright (C) 2014 Takashi SUGA
+
+  You may use and/or modify this file according to the license
+  described in the LICENSE.txt file included in this archive.
+=end
+
+module MiniTest
+
+  class Zoroastrian < MiniTest::TestCase
+    def test_fasli
+      date = When.when? '1366.1.1^^Fasli?location=(_co:Iranian::Tehran)'
+      [["1366-01-01", "1996-03-20", 2450163],
+       ["1367-01-01", "1997-03-20", 2450528],
+       ["1368-01-01", "1998-03-21", 2450894],
+       ["1369-01-01", "1999-03-21", 2451259],
+       ["1370-01-01", "2000-03-20", 2451624],
+       ["1371-01-01", "2001-03-20", 2451989],
+       ["1372-01-01", "2002-03-21", 2452355],
+       ["1373-01-01", "2003-03-21", 2452720],
+       ["1374-01-01", "2004-03-20", 2453085],
+       ["1375-01-01", "2005-03-20", 2453450],
+       ["1376-01-01", "2006-03-21", 2453816],
+       ["1377-01-01", "2007-03-21", 2454181],
+       ["1378-01-01", "2008-03-20", 2454546],
+       ["1379-01-01", "2009-03-20", 2454911],
+       ["1380-01-01", "2010-03-21", 2455277],
+       ["1381-01-01", "2011-03-21", 2455642],
+       ["1382-01-01", "2012-03-20", 2456007],
+       ["1383-01-01", "2013-03-20", 2456372],
+       ["1384-01-01", "2014-03-21", 2456738],
+       ["1385-01-01", "2015-03-21", 2457103],
+       ["1386-01-01", "2016-03-20", 2457468],
+       ["1387-01-01", "2017-03-20", 2457833],
+       ["1388-01-01", "2018-03-21", 2458199],
+       ["1389-01-01", "2019-03-21", 2458564],
+       ["1390-01-01", "2020-03-20", 2458929],
+       ["1391-01-01", "2021-03-20", 2459294],
+       ["1392-01-01", "2022-03-21", 2459660],
+       ["1393-01-01", "2023-03-21", 2460025],
+       ["1394-01-01", "2024-03-20", 2460390],
+       ["1395-01-01", "2025-03-20", 2460755],
+       ["1396-01-01", "2026-03-20", 2461120],
+       ["1397-01-01", "2027-03-21", 2461486],
+       ["1398-01-01", "2028-03-20", 2461851]].each do |sample|
+        assert_equal(sample, [date.to_s, (When::Gregorian ^ date).to_s, date.to_i])
+        date += When::P1Y
+      end
+
+      date = When.when? '2001.3.21'
+      400.times do
+        assert_equal([1,1], (When.Calendar('Fasli') ^ date).cal_date[-2..-1])
+        date += When::P1Y
+      end
+    end
+  end
+end

data/test/test/tmobjects.rb

@@ -310,6 +310,60 @@ module MiniTest::TM
          assert_equal(sample[1], period[sample[0]])
       end
     end
+
+    def test__period_duration_diff
+      date1 = When.when?('2012-07-01')
+      date2 = When.when?('2012-07-02')
+      duration = date2 - date1
+      assert_equal('P1D', duration.to_s)
+      assert_equal(When::TM::PeriodDuration, duration.class)
+
+      if Object.const_defined?(:TZInfo)
+        time = When.when?('2013-03-10T01:00:00', :tz=>'America/New_York')
+        assert_equal('2013-03-10T02:30:00-04:00', (time + When.Duration('PT1.5H')).to_s) # ��ʂ�1.5����
+      else
+        puts
+        puts "Tests for TZInfo have been skipped at line #{__LINE__} of #{__FILE__.split(/\//)[-1]}."
+      end
+
+      vcal = When.Resource("examples/USA-DST.ics?C=New_York&Z=E&D=04&DZ=06&S=05&SZ=07")
+      time = When.when?('2013-03-10T01:00:00', :clock=>vcal['America/New_York'])
+      assert_equal('2013-03-10T02:30:00-04:00', (time + When.Duration('PT1.5H')).to_s) # ��ʂ�1.5����
+    end
+
+    Sample10 = %w(2013-01-31 2013-02-28 2013-03-31 2013-04-30 2013-05-31
+                  2013-06-30 2013-07-31 2013-08-31 2013-09-30 2013-10-31)
+
+    Sample12 = %w(2013-01-31 2013-02-28 2013-03-31 2013-04-30 2013-05-31 2013-06-30
+                  2013-07-31 2013-08-31 2013-09-30 2013-10-31 2013-11-30 2013-12-31)
+
+    def test__duration_each
+      sample = Sample10.dup
+      When::P1M.enum_for(When.when?('2013-01-31'), :forward, 10).each do |date|
+        assert_equal(sample.shift, date.to_s)
+      end
+
+      count = 0
+      (When.when?('2013-01-31') ^ When::P1M).each({:count_limit=>0}) do |date|
+        count += 1
+      end
+      assert_equal(0, count)
+
+      sample = Sample10.dup
+      (When.when?('2013-01-31') ^ When::P1M).each({:count_limit=>10}) do |date|
+        assert_equal(sample.shift, date.to_s)
+      end
+
+      sample = Sample12.dup
+      (When.when?('2013-01-31') ^ When::P1M).each({:until=>When.when?('2013-12-31')}) do |date|
+        assert_equal(sample.shift, date.to_s)
+      end
+
+      sample = Sample12.reverse
+      (When.when?('2013-12-31') ^ -When::P1M).each({:until=>When.when?('2013-01-31')}) do |date|
+        assert_equal(sample.shift, date.to_s)
+      end
+    end
   end
 
   class IntervalLength < MiniTest::TestCase
@@ -324,5 +378,25 @@ module MiniTest::TM
         assert_equal(sample[1..5], [interval.value, interval.factor, interval.radix, interval.unit, interval.to_s])
       end
     end
+
+    def test__interval_length_diff
+      time1 = When.when?('2012-07-01T01:23:45+09:00')
+      time2 = When.when?('2012-07-02T01:23:45+09:00')
+      duration = time2 - time1
+      assert_equal('86401.0s', duration.to_s)
+      assert_equal(When::TM::IntervalLength, duration.class)
+
+      if Object.const_defined?(:TZInfo)
+        time = When.when?('2013-03-10T01:00:00', :tz=>'America/New_York')
+        assert_equal('2013-03-10T03:30:00-04:00', (time + When.Duration('1.5h')).to_s)   # �����I��1.5����
+      else
+        puts
+        puts "Tests for TZInfo have been skipped at line #{__LINE__} of #{__FILE__.split(/\//)[-1]}."
+      end
+
+      vcal = When.Resource("examples/USA-DST.ics?C=New_York&Z=E&D=04&DZ=06&S=05&SZ=07")
+      time = When.when?('2013-03-10T01:00:00', :clock=>vcal['America/New_York'])
+      assert_equal('2013-03-10T03:30:00-04:00', (time + When.Duration('1.5h')).to_s)   # �����I��1.5����
+    end
   end
 end