when_exe 0.4.2 → 0.5.0

data/test/test/region/zoroastrian.rb

@@ -1,58 +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
+# -*- 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/timestandard.rb

@@ -1,81 +1,81 @@
-# -*- coding: utf-8 -*-
-=begin
-  Copyright (C) 2011-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::TimeStandard
-
-  class UniversalTime < MiniTest::TestCase
-    def view(time)
-      return time unless time.instance_of?(When::Coordinates::LeapSeconds)
-      return [time.trunk, time.branch, time.second]
-    end
-
-    def test__delta_t
-      date  = When.when?('2009-01-01T00:00:00Z')
-      assert_equal("2008-12-31T23:59:01Z", (date - When::TM::IntervalLength.new(60, 'second')).to_s)
-      assert_equal("2008-12-31T23:59:00Z", (date - When::Duration('PT60S')).to_s)
-
-      date  = When::TM::JulianDate.dynamical_time((2500000-(When::TM::JulianDate::JD19700101-0.5))*675)
-      assert_equal(2500000.0, +date)
-      assert_equal(true, +date > date.to_f)
-
-      date  = When::TM::JulianDate.universal_time((2500000-(When::TM::JulianDate::JD19700101-0.5))*675)
-      assert_equal(2500000.0, date.to_f)
-      assert_equal(true, +date > date.to_f)
-
-      assert_equal((40 + 377.0/2048), When::TimeStandard.delta_t(When.when?('1970-01-01T').to_f))
-
-      date  = When.when?('2008-10-31T23:59:60Z')
-      assert_equal([[2008, 11, 1], [0, 0, 0, 0]], [date.cal_date, date.clk_time.clk_time])
-
-      pair  = When::Coordinates::Pair.new(1,1)
-      assert_equal([-1, -1, 1], [0.9, 1, 1.1].map {|v| v<=>pair})
-
-      time  = When.Resource('_t:UniversalTime')
-      date0 = When.when?('2008-12-31T23:59:58Z') ^ When.Duration('1s') # Duration('PT1S')
-      [
-        "2008-12-31T23:59:58Z",
-        "2008-12-31T23:59:59Z",
-        "2008-12-31T23:59:60Z",
-        "2009-01-01T00:00:00Z",
-        "2009-01-01T00:00:01Z"
-      ].each do |sample|
-        date = date0.next
-        assert_equal([sample, true], [date.to_s, date.universal_time == time.from_dynamical_time(date.dynamical_time)])
-      end
-
-      it = When::V::Event.new({
-          'rrule'   => 'FREQ=MINUTELY;BYSECOND=59,60',
-          'dtstart' => '2008-12-31T23:58:59Z'
-      }).each
-
-      [
-        "2008-12-31T23:58:59Z",
-        "2008-12-31T23:59:59Z",
-        "2009-01-01T00:00:59Z",
-        "2009-01-01T00:01:59Z"
-      ].each do |sample|
-        assert_equal(sample, it.next.to_s)
-      end
-
-      it = When::V::Event.new({
-          'rrule'   => 'FREQ=1s', #;BYSECOND=59,60',
-          'dtstart' => '2008-12-31T23:59:58Z'
-      }).each
-
-      [
-        "2008-12-31T23:59:58Z",
-        "2008-12-31T23:59:59Z",
-        "2008-12-31T23:59:60Z",
-        "2009-01-01T00:00:00Z",
-        "2009-01-01T00:00:01Z"
-      ].each do |sample|
-        assert_equal(sample, it.next.to_s)
-      end
-    end
-  end
-end
+# -*- coding: utf-8 -*-
+=begin
+  Copyright (C) 2011-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::TimeStandard
+
+  class UniversalTime < MiniTest::TestCase
+    def view(time)
+      return time unless time.instance_of?(When::Coordinates::LeapSeconds)
+      return [time.trunk, time.branch, time.second]
+    end
+
+    def test__delta_t
+      date  = When.when?('2009-01-01T00:00:00Z')
+      assert_equal("2008-12-31T23:59:01Z", (date - When::TM::IntervalLength.new(60, 'second')).to_s)
+      assert_equal("2008-12-31T23:59:00Z", (date - When::Duration('PT60S')).to_s)
+
+      date  = When::TM::JulianDate.dynamical_time((2500000-(When::TM::JulianDate::JD19700101-0.5))*675)
+      assert_equal(2500000.0, +date)
+      assert_equal(true, +date > date.to_f)
+
+      date  = When::TM::JulianDate.universal_time((2500000-(When::TM::JulianDate::JD19700101-0.5))*675)
+      assert_equal(2500000.0, date.to_f)
+      assert_equal(true, +date > date.to_f)
+
+      assert_equal((40 + 377.0/2048), When::TimeStandard.delta_t(When.when?('1970-01-01T').to_f))
+
+      date  = When.when?('2008-10-31T23:59:60Z')
+      assert_equal([[2008, 11, 1], [0, 0, 0, 0]], [date.cal_date, date.clk_time.clk_time])
+
+      pair  = When::Coordinates::Pair.new(1,1)
+      assert_equal([-1, -1, 1], [0.9, 1, 1.1].map {|v| v<=>pair})
+
+      time  = When.Resource('_t:UniversalTime')
+      date0 = When.when?('2008-12-31T23:59:58Z') ^ When.Duration('1s') # Duration('PT1S')
+      [
+        "2008-12-31T23:59:58Z",
+        "2008-12-31T23:59:59Z",
+        "2008-12-31T23:59:60Z",
+        "2009-01-01T00:00:00Z",
+        "2009-01-01T00:00:01Z"
+      ].each do |sample|
+        date = date0.next
+        assert_equal([sample, true], [date.to_s, date.universal_time == time.from_dynamical_time(date.dynamical_time)])
+      end
+
+      it = When::V::Event.new({
+          'rrule'   => 'FREQ=MINUTELY;BYSECOND=59,60',
+          'dtstart' => '2008-12-31T23:58:59Z'
+      }).each
+
+      [
+        "2008-12-31T23:58:59Z",
+        "2008-12-31T23:59:59Z",
+        "2009-01-01T00:00:59Z",
+        "2009-01-01T00:01:59Z"
+      ].each do |sample|
+        assert_equal(sample, it.next.to_s)
+      end
+
+      it = When::V::Event.new({
+          'rrule'   => 'FREQ=1s', #;BYSECOND=59,60',
+          'dtstart' => '2008-12-31T23:59:58Z'
+      }).each
+
+      [
+        "2008-12-31T23:59:58Z",
+        "2008-12-31T23:59:59Z",
+        "2008-12-31T23:59:60Z",
+        "2009-01-01T00:00:00Z",
+        "2009-01-01T00:00:01Z"
+      ].each do |sample|
+        assert_equal(sample, it.next.to_s)
+      end
+    end
+  end
+end

data/test/test/tmobjects.rb

@@ -1,402 +1,402 @@
-# -*- 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 MiniTest::TM
-
-#
-# (5.2) Temporal Objects Package
-#
-#
-
-  class Separation < MiniTest::TestCase
-    def test_nothing
-    end
-  end
-
-  class Order < MiniTest::TestCase
-    def test_nothing
-    end
-  end
-
-  class RelativePosition < MiniTest::TestCase
-    def test_nothing
-    end
-  end
-
-  class Object < MiniTest::TestCase
-    def test_nothing
-    end
-  end
-
-  class Complex < MiniTest::TestCase
-    def test_nothing
-    end
-  end
-
-  class TopologicalComplex < MiniTest::TestCase
-    def test_nothing
-    end
-  end
-
-  class Primitive < MiniTest::TestCase
-    def test_nothing
-    end
-  end
-
-  class GeometricPrimitive < MiniTest::TestCase
-    def test_nothing
-    end
-  end
-
-  class Instant < MiniTest::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 < MiniTest::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])
-
-      extent_0201_0202 = When::EX::Extent.new(period_0201_0202)
-      extent_0202_0203 = When::EX::Extent.new(period_0202_0203)
-      extent_0203_0204 = When::EX::Extent.new(period_0203_0204)
-      extent_0204_0205 = When::EX::Extent.new(period_0204_0205)
-      extent_0205_0206 = When::EX::Extent.new(period_0205_0206)
-
-      extent_0202_0204 = When::EX::Extent.new(period_0202_0204)
-      extent_0204_0206 = When::EX::Extent.new(period_0204_0206)
-      extent_0203_0206 = When::EX::Extent.new(period_0203_0206)
-      extent_0201_0206 = When::EX::Extent.new(period_0201_0206)
-
-      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
-
-      sample = ['P1D', 'P0D', 'P0D', 'P0D', 'P1D', 'P2D']
-      instant.each do |i|
-        assert_equal(sample.shift, extent_0202_0204.distance(i).to_s)
-      end
-
-      [['P2D', extent_0201_0202, extent_0204_0206],
-       ['P0D', extent_0201_0202, extent_0202_0204],
-       ['P0D', extent_0202_0203, extent_0202_0204],
-       ['P0D', extent_0203_0204, extent_0202_0204],
-       ['P0D', extent_0204_0205, extent_0202_0204],
-       ['P0D', extent_0203_0206, extent_0202_0204],
-       ['P1D', extent_0205_0206, extent_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 < MiniTest::TestCase
-    def test_nothing
-    end
-  end
-
-  class Node < MiniTest::TestCase
-    def test_nothing
-    end
-  end
-
-  class Edge < MiniTest::TestCase
-    def test_nothing
-    end
-  end
-
-  class Duration < MiniTest::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.25)
-       stop  = start + duration
-       assert_equal((RUBY_VERSION.to_f<1.9 ? 93784.25 : 93784), stop-start)
-       assert_raises(TypeError) {
-         ::Date.today + duration
-       }
-       require 'when_exe/core/duration'
-       stop  = start + duration
-       assert_equal(93784.25, stop-start)
-
-       now_date = DateTime.now
-       duration = When::TM::Duration.hour(8)
-       assert_equal(Rational(1,128), (now_date + duration * 3 / 128   ) - now_date)
-       assert_equal(Rational(1,3),   (now_date + duration    ) - now_date)
-       assert_equal(Rational(1,1),   (now_date + duration * 3) - now_date)
-
-       stop  = start + When.Duration('P1DT2H3M4S')
-       assert_equal(93784, stop-start)
-
-       assert_raises(TypeError) {
-         stop  = start + When.Duration('P2M1DT2H3M4S')
-       }
-    end
-  end
-
-  class PeriodDuration < MiniTest::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__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
-    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__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
+# -*- 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 MiniTest::TM
+
+#
+# (5.2) Temporal Objects Package
+#
+#
+
+  class Separation < MiniTest::TestCase
+    def test_nothing
+    end
+  end
+
+  class Order < MiniTest::TestCase
+    def test_nothing
+    end
+  end
+
+  class RelativePosition < MiniTest::TestCase
+    def test_nothing
+    end
+  end
+
+  class Object < MiniTest::TestCase
+    def test_nothing
+    end
+  end
+
+  class Complex < MiniTest::TestCase
+    def test_nothing
+    end
+  end
+
+  class TopologicalComplex < MiniTest::TestCase
+    def test_nothing
+    end
+  end
+
+  class Primitive < MiniTest::TestCase
+    def test_nothing
+    end
+  end
+
+  class GeometricPrimitive < MiniTest::TestCase
+    def test_nothing
+    end
+  end
+
+  class Instant < MiniTest::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 < MiniTest::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])
+
+      extent_0201_0202 = When::EX::Extent.new(period_0201_0202)
+      extent_0202_0203 = When::EX::Extent.new(period_0202_0203)
+      extent_0203_0204 = When::EX::Extent.new(period_0203_0204)
+      extent_0204_0205 = When::EX::Extent.new(period_0204_0205)
+      extent_0205_0206 = When::EX::Extent.new(period_0205_0206)
+
+      extent_0202_0204 = When::EX::Extent.new(period_0202_0204)
+      extent_0204_0206 = When::EX::Extent.new(period_0204_0206)
+      extent_0203_0206 = When::EX::Extent.new(period_0203_0206)
+      extent_0201_0206 = When::EX::Extent.new(period_0201_0206)
+
+      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
+
+      sample = ['P1D', 'P0D', 'P0D', 'P0D', 'P1D', 'P2D']
+      instant.each do |i|
+        assert_equal(sample.shift, extent_0202_0204.distance(i).to_s)
+      end
+
+      [['P2D', extent_0201_0202, extent_0204_0206],
+       ['P0D', extent_0201_0202, extent_0202_0204],
+       ['P0D', extent_0202_0203, extent_0202_0204],
+       ['P0D', extent_0203_0204, extent_0202_0204],
+       ['P0D', extent_0204_0205, extent_0202_0204],
+       ['P0D', extent_0203_0206, extent_0202_0204],
+       ['P1D', extent_0205_0206, extent_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 < MiniTest::TestCase
+    def test_nothing
+    end
+  end
+
+  class Node < MiniTest::TestCase
+    def test_nothing
+    end
+  end
+
+  class Edge < MiniTest::TestCase
+    def test_nothing
+    end
+  end
+
+  class Duration < MiniTest::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.25)
+       stop  = start + duration
+       assert_equal((RUBY_VERSION.to_f<1.9 ? 93784.25 : 93784), stop-start)
+       assert_raises(TypeError) {
+         ::Date.today + duration
+       }
+       require 'when_exe/core/duration'
+       stop  = start + duration
+       assert_equal(93784.25, stop-start)
+
+       now_date = DateTime.now
+       duration = When::TM::Duration.hour(8)
+       assert_equal(Rational(1,128), (now_date + duration * 3 / 128   ) - now_date)
+       assert_equal(Rational(1,3),   (now_date + duration    ) - now_date)
+       assert_equal(Rational(1,1),   (now_date + duration * 3) - now_date)
+
+       stop  = start + When.Duration('P1DT2H3M4S')
+       assert_equal(93784, stop-start)
+
+       assert_raises(TypeError) {
+         stop  = start + When.Duration('P2M1DT2H3M4S')
+       }
+    end
+  end
+
+  class PeriodDuration < MiniTest::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__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
+    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__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