when_exe 0.2.100 → 0.3.1

data/test/test/region/tibetan.rb

@@ -0,0 +1,30 @@
+# -*- coding: utf-8 -*-
+=begin
+  Copyright (C) 2011 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 Test
+
+  class Tibetan < Test::Unit::TestCase
+    Sample = [
+      "1991-05-01-", "1991-05-02-", "1991-05-03-", "1991-05-04-", "1991-05-05%", "1991-05-07-", "1991-05-08-", "1991-05-09-",
+      "1991-05-10-", "1991-05-11-", "1991-05-12-", "1991-05-13-", "1991-05-14-", "1991-05-15-", "1991-05-15=", "1991-05-16-",
+      "1991-05-17-", "1991-05-18-", "1991-05-19-", "1991-05-20-", "1991-05-21-", "1991-05-22-", "1991-05-23-", "1991-05-24-",
+      "1991-05-25-", "1991-05-26-", "1991-05-27-", "1991-05-28%", "1991-05-30-"
+    ]
+
+    def test_tibetan_date
+      cc     = When.Resource('_c:Tibetan')
+      date   = When.when?('1991-05-01', {:frame=>cc})
+      start  = 2448421
+      Sample.size.times do |i|
+        assert_equal([Sample[i], start+i], [date.to_s, date.to_i])
+        date += When.Duration('P1D')
+      end
+    end
+  end
+end
+

data/test/test/tmobjects.rb

@@ -1,57 +1,356 @@
-# -*- coding: utf-8 -*-
-=begin
-  Copyright (C) 2011-2013 Takashi SUGA
-
-  You may use and/or modify this file according to the license
-  described in the COPYING file included in this archive.
-=end
-
-module Test::TM
-  class Duration < Test::Unit::TestCase
-    def test__duration_constructors
-       assert_equal(    1,       When::TM::Duration.new(1).duration)
-       assert_equal(    1.0/128, When::TM::Duration.second(1).duration)
-       assert_equal(   60.0/128, When::TM::Duration.minute(1).duration)
-       assert_equal( 3600.0/128, When::TM::Duration.hour(1).duration)
-       assert_equal(86400.0/128, When::TM::Duration.day(1).duration)
-       assert_equal(93784.0/128, When::TM::Duration.dhms(1,2,3,4).duration)
-    end
-
-    def test__duration_values
-       assert_equal(1, When::TM::Duration.new(1).system)
-       assert_equal(2, When::TM::Duration.second(2).second)
-       assert_equal(3, When::TM::Duration.minute(3).minute)
-       assert_equal(4, When::TM::Duration.hour(4).hour)
-       assert_equal(5, When::TM::Duration.day(5).day)
-       assert_equal([1,2,3,4], When::TM::Duration.dhms(1,2,3,4).to_dhms)
-       assert_equal([-2,21,56,56], (-When::TM::Duration.dhms(1,2,3,4)).to_dhms)
-    end
-
-    def test__duration_elements
-       duration = When::TM::Duration.dhms(1,2,3,4.5)
-       assert_equal(1,   duration[0])
-       assert_equal(2,   duration[1])
-       assert_equal(3,   duration[2])
-       assert_equal(4.5, duration[3])
-    end
-
-    def test__duration_arithmetics
-       assert_equal(When::TM::Duration.dhms(-2,21,56,56), -When::TM::Duration.dhms(1,2,3,4))
-       assert_equal(When::TM::Duration.dhms(2,3,4,5), When::TM::Duration.dhms(1,2,3,4) + When::TM::Duration.dhms(1,1,1,1))
-       assert_equal(When::TM::Duration.dhms(0,1,2,3), When::TM::Duration.dhms(1,2,3,4) - When::TM::Duration.dhms(1,1,1,1))
-       assert_equal(When::TM::Duration.dhms(2,4,6,8), When::TM::Duration.dhms(1,2,3,4) * 2)
-       assert_equal(When::TM::Duration.dhms(1,2,3,4), When::TM::Duration.dhms(2,4,6,8) / 2)
-       assert_equal(2, When::TM::Duration.dhms(2,4,6,8) / When::TM::Duration.dhms(1,2,3,4))
-    end
-
-    def test__duration_and_time
-       start    = Time.now
-       duration = When::TM::Duration.dhms(1,2,3,4.4)
-       stop  = start + duration
-       assert_equal((RUBY_VERSION.to_f<1.9 ? 93784.4 : 93784), stop-start)
-       require 'when_exe/core/duration'
-       stop  = start + duration
-       assert_equal(93784.4, stop-start)
-    end
-  end
-end
+# -*- coding: utf-8 -*-
+=begin
+  Copyright (C) 2011-2013 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 Test::TM
+
+#
+# (5.2) Temporal Objects Package
+#
+#
+
+  class Separation < Test::Unit::TestCase
+    def test_nothing
+    end
+  end
+
+  class Order < Test::Unit::TestCase
+    def test_nothing
+    end
+  end
+
+  class RelativePosition < Test::Unit::TestCase
+    def test_nothing
+    end
+  end
+
+  class Object < Test::Unit::TestCase
+    def test_nothing
+    end
+  end
+
+  class Complex < Test::Unit::TestCase
+    def test_nothing
+    end
+  end
+
+  class TopologicalComplex < Test::Unit::TestCase
+    def test_nothing
+    end
+  end
+
+  class Primitive < Test::Unit::TestCase
+    def test_nothing
+    end
+  end
+
+  class GeometricPrimitive < Test::Unit::TestCase
+    def test_nothing
+    end
+  end
+
+  class Instant < Test::Unit::TestCase
+
+    include When::TM::RelativePosition
+
+    def test__distance
+      position = []
+      instant  = []
+      When.when?('20110201/06').each do |sample|
+        position << When.when?(sample)
+        instant  << When::TM::Instant.new(position[-1])
+      end
+      period_0202_0204 = When::TM::Period.new(instant[1], instant[3])
+
+      sample = ['P2D', 'P1D', 'P0D', 'P1D', 'P2D', 'P3D']
+      instant.each do |i|
+        assert_equal(sample.shift, i.distance(instant[2]).to_s)
+      end
+
+      sample = ['P1D', 'P0D', 'P0D', 'P0D', 'P1D', 'P2D']
+      instant.each do |i|
+        assert_equal(sample.shift, i.distance(period_0202_0204).to_s)
+      end
+    end
+
+    def test__relative_position
+      position = []
+      instant  = []
+      When.when?('20110201/06').each do |sample|
+        position << When.when?(sample)
+        instant  << When::TM::Instant.new(position[-1])
+      end
+      period_0202_0204 = When::TM::Period.new(instant[1], instant[3])
+
+      sample = [Before, Before, Equals, After, After, After]
+      instant.each do |i|
+        assert_equal(sample.shift, i.relative_position(instant[2]))
+      end
+
+      sample = [Before, Begins, During,  Ends,   After, After]
+      instant.each do |i|
+        assert_equal(sample.shift, i.relative_position(period_0202_0204))
+      end
+    end
+  end
+
+  class Period < Test::Unit::TestCase
+
+    include When::TM::RelativePosition
+
+    def test__distance
+      position = []
+      instant  = []
+      When.when?('20110201/06').each do |sample|
+        position << When.when?(sample)
+        instant  << When::TM::Instant.new(position[-1])
+      end
+      assert_equal(["2011-02-01", "2011-02-02", "2011-02-03",
+                    "2011-02-04", "2011-02-05", "2011-02-06"],
+                    position.map {|v| v.to_s})
+
+      period_0201_0202 = When::TM::Period.new(instant[0], instant[1])
+      period_0202_0203 = When::TM::Period.new(instant[1], instant[2])
+      period_0203_0204 = When::TM::Period.new(instant[2], instant[3])
+      period_0204_0205 = When::TM::Period.new(instant[3], instant[4])
+      period_0205_0206 = When::TM::Period.new(instant[4], instant[5])
+
+      period_0202_0204 = When::TM::Period.new(instant[1], instant[3])
+      period_0204_0206 = When::TM::Period.new(instant[3], instant[5])
+      period_0203_0206 = When::TM::Period.new(instant[2], instant[5])
+      period_0201_0206 = When::TM::Period.new(instant[0], instant[5])
+
+      sample = ['P1D', 'P0D', 'P0D', 'P0D', 'P1D', 'P2D']
+      instant.each do |i|
+        assert_equal(sample.shift, period_0202_0204.distance(i).to_s)
+      end
+
+      [['P2D', period_0201_0202, period_0204_0206],
+       ['P0D', period_0201_0202, period_0202_0204],
+       ['P0D', period_0202_0203, period_0202_0204],
+       ['P0D', period_0203_0204, period_0202_0204],
+       ['P0D', period_0204_0205, period_0202_0204],
+       ['P0D', period_0203_0206, period_0202_0204],
+       ['P1D', period_0205_0206, period_0202_0204]].each do |sample|
+        assert_equal(sample[0], sample[1].distance(sample[2]).to_s)
+        assert_equal(sample[0], sample[2].distance(sample[1]).to_s)
+      end
+    end
+
+    def test__relative_position
+      position = []
+      instant  = []
+      When.when?('20110201/06').each do |sample|
+        position << When.when?(sample)
+        instant  << When::TM::Instant.new(position[-1])
+      end
+      period_0201_0202 = When::TM::Period.new(instant[0], instant[1])
+      period_0202_0203 = When::TM::Period.new(instant[1], instant[2])
+      period_0203_0204 = When::TM::Period.new(instant[2], instant[3])
+      period_0204_0205 = When::TM::Period.new(instant[3], instant[4])
+      period_0205_0206 = When::TM::Period.new(instant[4], instant[5])
+
+      period_0202_0204 = When::TM::Period.new(instant[1], instant[3])
+      period_0203_0206 = When::TM::Period.new(instant[2], instant[5])
+      period_0204_0206 = When::TM::Period.new(instant[3], instant[5])
+      period_0201_0206 = When::TM::Period.new(instant[0], instant[5])
+
+      sample = [After, BegunBy, Contains, EndedBy, Before, Before]
+      instant.each do |i|
+        assert_equal(sample.shift, period_0202_0204.relative_position(i))
+      end
+
+      [[Before,       period_0201_0202, period_0204_0206],
+       [Meets,        period_0201_0202, period_0202_0204],
+       [Overlaps,     period_0202_0204, period_0203_0206],
+       [Begins,       period_0202_0203, period_0202_0204],
+       [BegunBy,      period_0202_0204, period_0202_0203],
+
+       [During,       period_0202_0204, period_0201_0206],
+       [Contains,     period_0201_0206, period_0202_0204],
+       [Equals,       period_0202_0204, period_0202_0204],
+
+       [OverlappedBy, period_0203_0206, period_0202_0204],
+       [Ends,         period_0203_0204, period_0202_0204],
+       [EndedBy,      period_0202_0204, period_0203_0204],
+       [MetBy,        period_0204_0205, period_0202_0204],
+       [After,        period_0205_0206, period_0202_0204]].each do |sample|
+        assert_equal(sample[0], sample[1].relative_position(sample[2]))
+      end
+
+    end
+  end
+
+  class TopologicalPrimitive < Test::Unit::TestCase
+    def test_nothing
+    end
+  end
+
+  class Node < Test::Unit::TestCase
+    def test_nothing
+    end
+  end
+
+  class Edge < Test::Unit::TestCase
+    def test_nothing
+    end
+  end
+
+  class Duration < Test::Unit::TestCase
+    def test__duration_constructors
+       assert_equal(    1,       When::TM::Duration.new(1).duration)
+       assert_equal(    1.0/128, When::TM::Duration.second(1).duration)
+       assert_equal(   60.0/128, When::TM::Duration.minute(1).duration)
+       assert_equal( 3600.0/128, When::TM::Duration.hour(1).duration)
+       assert_equal(86400.0/128, When::TM::Duration.day(1).duration)
+       assert_equal(93784.0/128, When::TM::Duration.dhms(1,2,3,4).duration)
+    end
+
+    def test__duration_values
+       assert_equal(1, When::TM::Duration.new(1).system)
+       assert_equal(2, When::TM::Duration.second(2).second)
+       assert_equal(3, When::TM::Duration.minute(3).minute)
+       assert_equal(4, When::TM::Duration.hour(4).hour)
+       assert_equal(5, When::TM::Duration.day(5).day)
+       assert_equal([1,2,3,4], When::TM::Duration.dhms(1,2,3,4).to_dhms)
+       assert_equal([-2,21,56,56], (-When::TM::Duration.dhms(1,2,3,4)).to_dhms)
+    end
+
+    def test__duration_elements
+       duration = When::TM::Duration.dhms(1,2,3,4.5)
+       assert_equal(1,   duration[0])
+       assert_equal(2,   duration[1])
+       assert_equal(3,   duration[2])
+       assert_equal(4.5, duration[3])
+    end
+
+    def test__duration_arithmetics
+       assert_equal(When::TM::Duration.dhms(-2,21,56,56), -When::TM::Duration.dhms(1,2,3,4))
+       assert_equal(When::TM::Duration.dhms(2,3,4,5), When::TM::Duration.dhms(1,2,3,4) + When::TM::Duration.dhms(1,1,1,1))
+       assert_equal(When::TM::Duration.dhms(0,1,2,3), When::TM::Duration.dhms(1,2,3,4) - When::TM::Duration.dhms(1,1,1,1))
+       assert_equal(When::TM::Duration.dhms(2,4,6,8), When::TM::Duration.dhms(1,2,3,4) * 2)
+       assert_equal(When::TM::Duration.dhms(1,2,3,4), When::TM::Duration.dhms(2,4,6,8) / 2)
+       assert_equal(2, When::TM::Duration.dhms(2,4,6,8) / When::TM::Duration.dhms(1,2,3,4))
+    end
+
+    def test__duration_and_time
+       start    = Time.now
+       duration = When::TM::Duration.dhms(1,2,3,4.4)
+       stop  = start + duration
+       assert_equal((RUBY_VERSION.to_f<1.9 ? 93784.4 : 93784), stop-start)
+       require 'when_exe/core/duration'
+       stop  = start + duration
+       assert_equal(93784.4, stop-start)
+
+       stop  = start + When.Duration('P1DT2H3M4S')
+       assert_equal(93784, stop-start)
+
+       assert_raise(TypeError) {
+         stop  = start + When.Duration('P2M1DT2H3M4S')
+       }
+    end
+  end
+
+  class PeriodDuration < Test::Unit::TestCase
+    def test__period_duration
+      period = When.Duration('P2Y3M4D')
+      [[-2, 2], [-1, 3], [0, 4]].each do |sample|
+         assert_equal(sample[1], period[sample[0]])
+      end
+      period = When.Duration('PT5H6M7S')
+      [[1, 5], [2, 6], [3, 7]].each do |sample|
+         assert_equal(sample[1], period[sample[0]])
+      end
+      period = When.Duration('P2Y3M4DT5H6M7S')
+      [[-2, 2], [-1, 3], [0, 4], [1, 5], [2, 6], [3, 7]].each do |sample|
+         assert_equal(sample[1], period[sample[0]])
+      end
+      period = When.Duration('P8W9D')
+      [[-0.5, 8], [0, 8*7+9]].each do |sample|
+         assert_equal(sample[1], period[sample[0]])
+      end
+    end
+
+    def test__julian_gregorian_change
+      epoch = When.when?('CE1582.10.3') ^ When.Duration('P1D')
+      sample = [
+        "CE1582.10.03",
+        "CE1582.10.04",
+        "CE1582.10.15",
+        "CE1582.10.16"
+      ]
+      4.times do
+        assert_equal(sample.shift, epoch.next.to_s)
+      end
+
+      sample = [
+        "CE1582.10.16",
+        "CE1582.10.15",
+        "CE1582.10.04",
+        "CE1582.10.03"
+      ]
+      epoch = When.when?('CE1582.10.16') ^ -When.Duration('P1D')
+      4.times do
+        assert_equal(sample.shift, epoch.next.to_s)
+      end
+
+     assert_equal(
+       [["October 1582",
+        ["-", 1, 2, 3, 4, 15, 16],
+        [17, 18, 19, 20, 21, 22, 23],
+        [24, 25, 26, 27, 28, 29, 30],
+        [31, "-", "-", "-", "-", "-", "-"]]],
+       When.when?('CE1582.10').month_included('SU') {|date, type|
+         case type
+         when When::YEAR,
+              When::MONTH ; date.strftime("%B %Y")
+         when When::WEEK  ; nil
+         when When::DAY   ; date[0]
+         else             ; '-'
+         end
+       })
+    end
+  end
+
+  class IntervalLength < Test::Unit::TestCase
+    def test__interval_length
+      [
+       ['7E-3s',      7,  3, 10, 'second', '7E-3s'      ],
+       ['8X-2m',      8,  2, 60, 'minute', '8X-2m'      ],
+       ['6(12)7D',    6, -7, 12, 'day',    '6(12)+7D'   ],
+       ['1(16)4*10S', 1, -4, 16, '10',     '1(16)+4*10S']
+      ].each do |sample|
+        interval = When.Duration(sample[0])
+        assert_equal(sample[1..5], [interval.value, interval.factor, interval.radix, interval.unit, interval.to_s])
+      end
+    end
+
+    def test__julian_gregorian_change
+      epoch = When.when?('CE1582.10.03') ^ When.Duration('1D')
+      sample = [
+        "CE1582.10.03",
+        "CE1582.10.04",
+        "CE1582.10.15",
+        "CE1582.10.16"
+      ]
+      4.times do
+        assert_equal(sample.shift, epoch.next.to_s)
+      end
+
+      sample = [
+        "CE1582.10.16",
+        "CE1582.10.15",
+        "CE1582.10.04",
+        "CE1582.10.03"
+      ]
+      epoch = When.when?('CE1582.10.16') ^ -When.Duration('1D')
+      4.times do
+        assert_equal(sample.shift, epoch.next.to_s)
+      end
+    end
+  end
+end

data/test/test/tmposition.rb

@@ -0,0 +1,237 @@
+# -*- coding: utf-8 -*-
+=begin
+  Copyright (C) 2011-2012 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 Test::TM
+
+#
+# (5.4) Temporal Position Package
+#
+#
+
+  class IndeterminateValue < Test::Unit::TestCase
+    def test_nothing
+    end
+  end
+
+  class Position < Test::Unit::TestCase
+    def test_nothing
+    end
+  end
+
+  class TemporalPosition < Test::Unit::TestCase
+    def test__instance
+      [["19800203T234512.33+0900",       "1980-02-03T23:45:12.33+09:00"],
+       ["19800203T234512.33Z",           "1980-02-03T23:45:12.33Z"],
+       ["19800203T234512",               "1980-02-03T23:45:12Z"],
+       ["19800203T2345",                 "1980-02-03T23:45Z"],
+       ["19800203T23",                   "1980-02-03T23Z"],
+       ["19800203T",                     "1980-02-03TZ"],
+       ["19800203",                      "1980-02-03"],
+       ["1980-02",                       "1980-02"],
+       ["S33.07.31",                     "S33(1958).07.31"],
+       ["S33.07.31/",                    "S33(1958).07.31"],
+       ["1980T-0700",                    "1980T-07:00"],
+       ["T234512-0700",                  "T23:45:12-07:00"],
+       ["H2(1990)-05-11T23:45:12-07:00", "H02(1990).05.11T23:45:12-07:00"],
+       ["T3(1914)=05-11T23:45:12-07:00", "T03(1914)=05.11T23:45:12-07:00"], # TODO
+       ["S64.01.07",                     "S64(1989).01.07"],
+       ["2001-08-02/After",              "2001-08-02"],
+       ["Before/2001-09-10",             "2001-09-10"]].each do |sample|
+         assert_equal(sample[1], When.when?(sample[0]).to_s)
+      end
+      assert_equal(["1980-02-03","1980-02-05","1980-02-06","1980-02-09"], When.when?(<<LIST).map {|date| date.to_s})
+19800203
+19800205
+19800206
+19800209
+LIST
+      assert_equal("2001-08-02..2001-09-10", When.when?("2001-08-02/09-10").to_s)
+      assert_equal("1980-02-01", When.when?("800201", {:abbr=>1970}).to_s)
+      # assert_equal(nil, When.TemporalPosition(2011,2,29))
+      assert_equal('2011-03-01', When.TemporalPosition(2011,2,29).to_s)
+      assert_equal(nil, When.TemporalPosition(2011,2,29, {:invalid=>:check}))
+      assert_raises(ArgumentError) { When.TemporalPosition(2011,2,29, {:invalid=>:raise}) }
+    end
+
+    def test__to_date
+      if ::Object.const_defined?(:Date) && Date.respond_to?(:civil)
+        assert(/^Tue Jun  7 00:00:00 (\+00:00|Z) 2011$/ =~  When.when?("2011-06-07").to_date.strftime('%+'))
+      end
+    end
+
+    def test__to_date_time
+      if ::Object.const_defined?(:Date) && Date.respond_to?(:civil)
+        assert(/Tue Jun  7 16:17:36 \+09:?00 2011$/ =~ When.when?("2011-06-07T16:17:36+09:00").to_date_time.strftime('%+'))
+      end
+    end
+  end
+
+  class Coordinate < Test::Unit::TestCase
+    def test_nothing
+    end
+  end
+
+  class JulianDate < Test::Unit::TestCase
+    def test_nothing
+    end
+  end
+
+  class OrdinalPosition < Test::Unit::TestCase
+    def test_nothing
+    end
+  end
+
+  class ClockTime < Test::Unit::TestCase
+    def test_nothing
+    end
+  end
+
+  class CalDate < Test::Unit::TestCase
+    def test__floor
+      date4 = When.when?("19820606^^Julian")
+      [[-2, "1982"],
+       [-1, "1982-06"],
+       [ 0, "1982-06-06"]].each do |sample|
+        assert_equal(sample[1], date4.floor(sample[0]).to_s)
+      end
+    end
+
+    def test__week
+      date = When.when?('20110517')
+      assert_equal("2011-05-16...2011-05-23", date.week_included.to_s)
+      [
+        ['MO', "2011-05-16...2011-05-23"],
+        ['TU', "2011-05-17...2011-05-24"],
+        ['WE', "2011-05-11...2011-05-18"],
+        ['TH', "2011-05-12...2011-05-19"],
+        ['FR', "2011-05-13...2011-05-20"],
+        ['SA', "2011-05-14...2011-05-21"],
+        ['SU', "2011-05-15...2011-05-22"]
+      ].each do |sample|
+        assert_equal(sample[1], date.week_included(sample[0]).to_s)
+      end
+      [
+        [-1, "2011-05-09...2011-05-16"],
+        [ 0, "2011-05-16...2011-05-23"],
+        [+1, "2011-05-23...2011-05-30"],
+      ].each do |sample|
+        assert_equal(sample[1], date.week_included(sample[0]).to_s)
+      end
+    end
+  end
+
+  class DateAndTime < Test::Unit::TestCase
+    def test__caret
+      week = When.Resource("_co:Residue?divisor=7")
+      date = When.TemporalPosition(2010,11,30, 6, 30)
+      assert_equal("2010-11-30T06:30Z", date.to_s)
+      it   = date ^ week
+      assert_equal("2010-12-06T06:30Z", it.next.to_s)
+      assert_equal("2010-12-13T06:30Z", it.next.to_s)
+      assert_equal("2010-12-20T06:30Z", it.next.to_s)
+      it   = date ^ When.Duration(2 * When::TM::Duration::DAY)
+      assert_equal("2010-11-30T06:30Z", it.next.to_s)
+      assert_equal("2010-12-02T06:30Z", it.next.to_s)
+      assert_equal("2010-12-04T06:30Z", it.next.to_s)
+    end
+
+    def test__modulo
+      week = When.Resource("_co:Residue?divisor=7")
+      weekName = ['Mon', 'Tue', 'Wed', 'Thu', 'Fri', 'Sat', 'Sun']
+      obj1 = When.when?("20100928T234512.33+0900^^Gregorian")
+      assert_equal("Tue", weekName[obj1 % week])
+      obj2 = When.when?("20100928T234512.33-0600^^Gregorian")
+      assert_equal("Tue", weekName[obj2 % week])
+    end
+
+    def test__minus
+      obj1 = When.when?("20100928T234512.33+0900^^Gregorian")
+      obj2 = When.when?("20100928T234512.33-0600^^Gregorian")
+      assert_equal("2010-08-28T23:45:12.33+09:00", (obj1 - When::Duration("P1M")).to_s)
+      assert_equal(0.625 * When::TM::Duration::DAY, (obj2 - obj1).duration)
+      assert_equal("2010-09-13T23:45:12.33-06:00", (obj2 - 15).to_s)
+    end
+
+    def test__plus
+      obj1 = When.when?("20100928T234512.33+0900^^Gregorian")
+      [["P3D",  "2010-10-01T23:45:12.33+09:00"],
+       ["P1Y",  "2011-09-28T23:45:12.33+09:00"],
+       ["P1M",  "2010-10-28T23:45:12.33+09:00"],
+       ["PT3H", "2010-09-29T02:45:12.33+09:00"],
+       ["P3W",  "2010-10-19T23:45:12.33+09:00"]].each do |sample|
+        assert_equal(sample[1], (obj1 + When::Duration(sample[0])).to_s)
+      end
+
+      obj2 = When.when?("19820606T1234^^Julian")
+      [["PT2H15M", "1982-06-06T14:49Z"],
+       ["PT3H",    "1982-06-06T15:34Z"]].each do |sample|
+        assert_equal(sample[1], (obj2 + When::Duration(sample[0])).to_s)
+      end
+
+      ic  = When.Resource("examples/NewYork.ics")
+      tz1 = When::V::Timezone["America/New_York"]
+
+      [tz1].each do |tz|
+        When::TM::Clock.local_time = tz
+        obj3 = When.when?("1997-04-06T00:00:00", {:clock=>tz})
+        [["PT1H", "1997-04-06T01:00:00-05:00"],
+         ["PT2H", "1997-04-06T02:00:00-04:00"],
+         ["PT3H", "1997-04-06T03:00:00-04:00"],
+         [1 * When::TM::Duration::HOUR, "1997-04-06T01:00:00-05:00"],
+         [2 * When::TM::Duration::HOUR, "1997-04-06T03:00:00-04:00"],
+         [3 * When::TM::Duration::HOUR, "1997-04-06T04:00:00-04:00"]].each do |sample|
+          assert_equal(sample[1], (obj3 + When::Duration(sample[0])).to_s)
+        end
+
+        obj4 = When.when?("1997-10-26T00:00:00", {:clock=>tz})
+        [["PT1H", "1997-10-26T01:00:00-04:00"],
+         ["PT2H", "1997-10-26T02:00:00-04:00"],
+         ["PT3H", "1997-10-26T03:00:00-05:00"],
+         [1 * When::TM::Duration::HOUR, "1997-10-26T01:00:00-04:00"],
+         [2 * When::TM::Duration::HOUR, "1997-10-26T02:00:00-04:00"],
+         [3 * When::TM::Duration::HOUR, "1997-10-26T02:00:00-05:00"]].each do |sample|
+          assert_equal(sample[1], (obj4 + When::Duration(sample[0])).to_s)
+        end
+      end
+    end
+
+    if Object.const_defined?(:TZInfo)
+      def test__plus_tzinfo
+        obj4 = When.when?("1997-10-26T00:00:00", {:clock=>When::Parts::Timezone["America/New_York"]})
+        [["PT59M","1997-10-26T00:59:00-04:00"],
+         ["PT1H", "1997-10-26T01:00:00-04:00"],
+         ["PT2H", "1997-10-26T02:00:00-05:00"], #  "1997-10-26T02:00:00-04:00" - TODO !!
+         ["PT3H", "1997-10-26T03:00:00-05:00"],
+         [1 * When::TM::Duration::HOUR, "1997-10-26T01:00:00-04:00"],
+         [2 * When::TM::Duration::HOUR, "1997-10-26T02:00:00-04:00"],
+         [3 * When::TM::Duration::HOUR, "1997-10-26T02:00:00-05:00"]].each do |sample|
+          assert_equal(sample[1], (obj4 + When::Duration(sample[0])).to_s)
+        end
+      end
+    else
+      puts "Tests for TZInfo have been skipped at line #{__LINE__} of #{__FILE__.split(/\//)[-1]}."
+    end
+
+    def test__floor_date_and_time
+      date5 = When.when?("1982-06-06T12:34:56.78^^Julian")
+      sample = [
+       "1982TZ",
+       "1982-06TZ",
+       "1982-06-06TZ",
+       "1982-06-06T12Z",
+       "1982-06-06T12:34Z",
+       "1982-06-06T12:34:56Z",
+       "1982-06-06T12:34:56.7Z",
+       "1982-06-06T12:34:56.78Z"
+      ]
+      (-2..5).each do |i|
+        assert_equal(sample.shift, date5.floor(i).to_s)
+      end
+    end
+  end
+end