tzinfo 0.2.2 → 0.3.0

data/test/tc_timezone_definition.rb

@@ -0,0 +1,115 @@
+$:.unshift File.join(File.dirname(__FILE__), "..", "lib")
+require 'test/unit'
+require 'tzinfo/timezone_definition'
+
+include TZInfo
+
+class TCTimezoneDefinition < Test::Unit::TestCase
+
+  module DataTest
+    include TimezoneDefinition
+    
+    timezone 'Test/Data/Zone' do |tz|
+      tz.offset :o0, -75, 0, :LMT
+      tz.offset :o1,   0, 0, :GMT
+      
+      tz.transition 1847, 12, :o1, 2760187969, 1152 
+    end
+  end
+  
+  module LinkedTest
+    include TimezoneDefinition
+    
+    linked_timezone 'Test/Linked/Zone', 'Test/Linked_To/Zone'
+  end
+  
+  module DoubleDataTest
+    include TimezoneDefinition
+    
+    timezone 'Test/Data/Zone1' do |tz|
+      tz.offset :o0, -75, 0, :LMT
+      tz.offset :o1,   0, 0, :GMT
+      
+      tz.transition 1847, 12, :o1, 2760187969, 1152 
+    end
+    
+    timezone 'Test/Data/Zone2' do |tz|
+      tz.offset :o0, 75, 0, :LMT
+      tz.offset :o1,  0, 0, :GMT
+      
+      tz.transition 1847, 12, :o1, 2760187969, 1152 
+    end
+  end
+  
+  module DoubleLinkedTest
+    include TimezoneDefinition
+    
+    linked_timezone 'Test/Linked/Zone1', 'Test/Linked_To/Zone1'
+    linked_timezone 'Test/Linked/Zone2', 'Test/Linked_To/Zone2'
+  end
+  
+  module DataLinkedTest
+    include TimezoneDefinition
+    
+    timezone 'Test/Data/Zone1' do |tz|
+      tz.offset :o0, -75, 0, :LMT
+      tz.offset :o1,   0, 0, :GMT
+      
+      tz.transition 1847, 12, :o1, 2760187969, 1152 
+    end 
+    
+    linked_timezone 'Test/Linked/Zone2', 'Test/Linked_To/Zone2'
+  end
+  
+  module LinkedDataTest
+    include TimezoneDefinition
+    
+    linked_timezone 'Test/Linked/Zone1', 'Test/Linked_To/Zone1'
+    
+    timezone 'Test/Data/Zone2' do |tz|
+      tz.offset :o0, -75, 0, :LMT
+      tz.offset :o1,   0, 0, :GMT
+      
+      tz.transition 1847, 12, :o1, 2760187969, 1152 
+    end    
+  end
+    
+  def test_data
+    assert_kind_of(DataTimezoneInfo, DataTest.get)
+    assert_equal('Test/Data/Zone', DataTest.get.identifier)
+    assert_equal(:LMT, DataTest.get.period_for_utc(DateTime.new(1847,12,1,0,1,14)).abbreviation)
+    assert_equal(:GMT, DataTest.get.period_for_utc(DateTime.new(1847,12,1,0,1,15)).abbreviation)
+  end
+  
+  def test_linked
+    assert_kind_of(LinkedTimezoneInfo, LinkedTest.get)
+    assert_equal('Test/Linked/Zone', LinkedTest.get.identifier)
+    assert_equal('Test/Linked_To/Zone', LinkedTest.get.link_to_identifier)    
+  end
+  
+  def test_double_data
+    assert_kind_of(DataTimezoneInfo, DoubleDataTest.get)
+    assert_equal('Test/Data/Zone2', DoubleDataTest.get.identifier)
+    assert_equal(:LMT, DoubleDataTest.get.period_for_utc(DateTime.new(1847,12,1,0,1,14)).abbreviation)
+    assert_equal(:GMT, DoubleDataTest.get.period_for_utc(DateTime.new(1847,12,1,0,1,15)).abbreviation)
+  end
+  
+  def test_double_linked
+    assert_kind_of(LinkedTimezoneInfo, DoubleLinkedTest.get)
+    assert_equal('Test/Linked/Zone2', DoubleLinkedTest.get.identifier)
+    assert_equal('Test/Linked_To/Zone2', DoubleLinkedTest.get.link_to_identifier)    
+  end
+  
+  def test_data_linked
+    assert_kind_of(LinkedTimezoneInfo, DataLinkedTest.get)
+    assert_equal('Test/Linked/Zone2', DataLinkedTest.get.identifier)
+    assert_equal('Test/Linked_To/Zone2', DataLinkedTest.get.link_to_identifier)    
+  end
+  
+  def test_linked_data
+    assert_kind_of(DataTimezoneInfo, LinkedDataTest.get)
+    assert_equal('Test/Data/Zone2', LinkedDataTest.get.identifier)
+    assert_equal(:LMT, LinkedDataTest.get.period_for_utc(DateTime.new(1847,12,1,0,1,14)).abbreviation)
+    assert_equal(:GMT, LinkedDataTest.get.period_for_utc(DateTime.new(1847,12,1,0,1,15)).abbreviation)
+  end  
+end

data/test/tc_timezone_index_definition.rb

@@ -0,0 +1,75 @@
+$:.unshift File.join(File.dirname(__FILE__), "..", "lib")
+require 'test/unit'
+require 'tzinfo/timezone_index_definition'
+
+include TZInfo
+
+class TCTimezoneIndexDefinition < Test::Unit::TestCase
+  
+  module TimezonesTest1
+    include TimezoneIndexDefinition
+    
+    timezone 'Test/One'
+    timezone 'Test/Two'
+    linked_timezone 'Test/Three'
+    timezone 'Another/Zone'
+    linked_timezone 'And/Yet/Another'
+  end
+  
+  module TimezonesTest2
+    include TimezoneIndexDefinition
+    
+    timezone 'Test/A/One'
+    timezone 'Test/A/Two'
+    timezone 'Test/A/Three'
+  end
+  
+  module TimezonesTest3
+    include TimezoneIndexDefinition
+    
+    linked_timezone 'Test/B/One'
+    linked_timezone 'Test/B/Two'
+    linked_timezone 'Test/B/Three'
+  end
+  
+  module TimezonesTest4
+    include TimezoneIndexDefinition
+    
+  end
+  
+  def test_timezones
+    assert_equal(['Test/One', 'Test/Two', 'Test/Three', 'Another/Zone', 'And/Yet/Another'], TimezonesTest1.timezones)            
+    assert_equal(['Test/A/One', 'Test/A/Two', 'Test/A/Three'], TimezonesTest2.timezones)
+    assert_equal(['Test/B/One', 'Test/B/Two', 'Test/B/Three'], TimezonesTest3.timezones)
+    assert_equal([], TimezonesTest4.timezones)
+      
+    assert_equal(true, TimezonesTest1.timezones.frozen?)
+    assert_equal(true, TimezonesTest2.timezones.frozen?)
+    assert_equal(true, TimezonesTest3.timezones.frozen?)
+    assert_equal(true, TimezonesTest4.timezones.frozen?)
+  end   
+  
+  def test_data_timezones
+    assert_equal(['Test/One', 'Test/Two', 'Another/Zone'], TimezonesTest1.data_timezones)
+    assert_equal(['Test/A/One', 'Test/A/Two', 'Test/A/Three'], TimezonesTest2.data_timezones)
+    assert_equal([], TimezonesTest3.data_timezones)
+    assert_equal([], TimezonesTest4.data_timezones)
+    
+    assert_equal(true, TimezonesTest1.data_timezones.frozen?)
+    assert_equal(true, TimezonesTest2.data_timezones.frozen?)
+    assert_equal(true, TimezonesTest3.data_timezones.frozen?)
+    assert_equal(true, TimezonesTest4.data_timezones.frozen?)
+  end
+  
+  def test_linked_timezones
+    assert_equal(['Test/Three', 'And/Yet/Another'], TimezonesTest1.linked_timezones)
+    assert_equal([], TimezonesTest2.linked_timezones)
+    assert_equal(['Test/B/One', 'Test/B/Two', 'Test/B/Three'], TimezonesTest3.linked_timezones)
+    assert_equal([], TimezonesTest4.linked_timezones)
+    
+    assert_equal(true, TimezonesTest1.linked_timezones.frozen?)
+    assert_equal(true, TimezonesTest2.linked_timezones.frozen?)
+    assert_equal(true, TimezonesTest3.linked_timezones.frozen?)
+    assert_equal(true, TimezonesTest4.linked_timezones.frozen?)
+  end  
+end

data/test/tc_timezone_info.rb

@@ -0,0 +1,13 @@
+$:.unshift File.join(File.dirname(__FILE__), "..", "lib")
+require 'test/unit'
+require 'tzinfo/timezone_info'
+
+include TZInfo
+
+class TCTimezoneInfo < Test::Unit::TestCase
+  
+  def test_identifier
+    ti = TimezoneInfo.new('Test/Zone')
+    assert_equal('Test/Zone', ti.identifier)
+  end
+end

data/test/tc_timezone_offset_info.rb

@@ -0,0 +1,116 @@
+$:.unshift File.join(File.dirname(__FILE__), "..", "lib")
+require 'test/unit'
+require 'tzinfo/timezone_offset_info'
+
+include TZInfo
+
+class TCTimezoneOffsetInfo < Test::Unit::TestCase
+  
+  def test_utc_offset
+    o1 = TimezoneOffsetInfo.new(18000, 0, :TEST)
+    o2 = TimezoneOffsetInfo.new(-3600, 3600, :TEST2)
+    
+    assert_equal(18000, o1.utc_offset)
+    assert_equal(-3600, o2.utc_offset)
+  end
+  
+  def test_std_offset
+    o1 = TimezoneOffsetInfo.new(18000, 0, :TEST)
+    o2 = TimezoneOffsetInfo.new(-3600, 3600, :TEST2)
+    
+    assert_equal(0, o1.std_offset)
+    assert_equal(3600, o2.std_offset)
+  end
+  
+  def test_utc_total_offset
+    o1 = TimezoneOffsetInfo.new(18000, 0, :TEST)
+    o2 = TimezoneOffsetInfo.new(-3600, 3600, :TEST2)
+    
+    assert_equal(18000, o1.utc_total_offset)
+    assert_equal(0, o2.utc_total_offset)
+  end
+  
+  def test_abbreviation
+    o1 = TimezoneOffsetInfo.new(18000, 0, :TEST)
+    o2 = TimezoneOffsetInfo.new(-3600, 3600, :TEST2)
+    
+    assert_equal(:TEST, o1.abbreviation)
+    assert_equal(:TEST2, o2.abbreviation)
+  end
+  
+  def test_dst
+    o1 = TimezoneOffsetInfo.new(18000, 0, :TEST)
+    o2 = TimezoneOffsetInfo.new(-3600, 3600, :TEST2)
+    
+    assert_equal(false, o1.dst?)
+    assert_equal(true, o2.dst?)
+  end
+  
+  def test_to_local
+    o1 = TimezoneOffsetInfo.new(18000, 0, :TEST)
+    o2 = TimezoneOffsetInfo.new(-3600, 3600, :TEST2)
+    
+    assert_equal(1148949080, o1.to_local(1148931080))
+    assert_equal(Time.utc(2006, 5, 30, 0, 31, 20), o1.to_local(Time.utc(2006, 5, 29, 19, 31, 20)))
+    assert_equal(DateTime.new(2006, 5, 30, 0, 31, 20), o1.to_local(DateTime.new(2006, 5, 29, 19, 31, 20)))
+    assert(TimeOrDateTime.new(1148949080).eql?(o1.to_local(TimeOrDateTime.new(1148931080))))
+    
+    assert_equal(1148931080, o2.to_local(1148931080))
+    assert_equal(Time.utc(2006, 5, 29, 19, 31, 20), o2.to_local(Time.utc(2006, 5, 29, 19, 31, 20)))
+    assert_equal(DateTime.new(2006, 5, 29, 19, 31, 20), o2.to_local(DateTime.new(2006, 5, 29, 19, 31, 20)))
+    assert(TimeOrDateTime.new(1148931080).eql?(o2.to_local(TimeOrDateTime.new(1148931080))))    
+  end
+  
+  def test_to_utc
+    o1 = TimezoneOffsetInfo.new(18000, 0, :TEST)
+    o2 = TimezoneOffsetInfo.new(-3600, 3600, :TEST2)
+    
+    assert_equal(1148913080, o1.to_utc(1148931080))
+    assert_equal(Time.utc(2006, 5, 29, 14, 31, 20), o1.to_utc(Time.utc(2006, 5, 29, 19, 31, 20)))
+    assert_equal(DateTime.new(2006, 5, 29, 14, 31, 20), o1.to_utc(DateTime.new(2006, 5, 29, 19, 31, 20)))
+    assert(TimeOrDateTime.new(1148913080).eql?(o1.to_utc(TimeOrDateTime.new(1148931080))))
+    
+    assert_equal(1148931080, o2.to_local(1148931080))
+    assert_equal(Time.utc(2006, 5, 29, 19, 31, 20), o2.to_local(Time.utc(2006, 5, 29, 19, 31, 20)))
+    assert_equal(DateTime.new(2006, 5, 29, 19, 31, 20), o2.to_local(DateTime.new(2006, 5, 29, 19, 31, 20)))
+    assert(TimeOrDateTime.new(1148931080).eql?(o2.to_local(TimeOrDateTime.new(1148931080))))    
+  end
+  
+  def test_equality
+    o1 = TimezoneOffsetInfo.new(18000, 0, :TEST)
+    o2 = TimezoneOffsetInfo.new(18000, 0, :TEST)
+    o3 = TimezoneOffsetInfo.new(18001, 0, :TEST)
+    o4 = TimezoneOffsetInfo.new(18000, 1, :TEST)
+    o5 = TimezoneOffsetInfo.new(18000, 0, :TEST2)
+    
+    assert_equal(true, o1 == o1)
+    assert_equal(true, o1 == o2)
+    assert_equal(false, o1 == o3)
+    assert_equal(false, o1 == o4)
+    assert_equal(false, o1 == o5)
+    assert_equal(false, o1 == Object.new)
+  end
+  
+  def test_eql
+    o1 = TimezoneOffsetInfo.new(18000, 0, :TEST)
+    o2 = TimezoneOffsetInfo.new(18000, 0, :TEST)
+    o3 = TimezoneOffsetInfo.new(18001, 0, :TEST)
+    o4 = TimezoneOffsetInfo.new(18000, 1, :TEST)
+    o5 = TimezoneOffsetInfo.new(18000, 0, :TEST2)
+    
+    assert_equal(true, o1.eql?(o1))
+    assert_equal(true, o1.eql?(o2))
+    assert_equal(false, o1.eql?(o3))
+    assert_equal(false, o1.eql?(o4))
+    assert_equal(false, o1.eql?(o5))
+    assert_equal(false, o1.eql?(Object.new))
+  end
+  
+  def test_hash
+    o1 = TimezoneOffsetInfo.new(18000, 0, :TEST)
+    o2 = TimezoneOffsetInfo.new(-3600, 3600, :TEST2)
+    
+    assert_equal(18000.hash ^ 0.hash ^ :TEST.hash, o1.hash)
+    assert_equal(-3600.hash ^ 3600.hash ^ :TEST2.hash, o2.hash)
+  end
+end

data/test/tc_timezone_period.rb

@@ -1,84 +1,138 @@
 $:.unshift File.join(File.dirname(__FILE__), "..", "lib")
 require 'test/unit'
 require 'tzinfo/timezone_period'
+require 'tzinfo/timezone_offset_info'
+require 'tzinfo/timezone_transition_info'
 
 include TZInfo
 
 class TCTimezonePeriod < Test::Unit::TestCase
-  def test_initialize_datetime
-    p = TimezonePeriod.new(DateTime.new(2005,1,1,0,0,0), DateTime.new(2005,1,2,0,0,0), -7200, 3600, :TEST)
-        
-    assert_equal(DateTime.new(2005,1,1,0,0,0), p.utc_start)
-    assert_equal(DateTime.new(2005,1,2,0,0,0), p.utc_end)
-    assert_equal(-7200, p.utc_offset)
-    assert_equal(3600, p.std_offset)
-    assert_equal(:TEST, p.zone_identifier)
-    assert_equal(:TEST, p.abbreviation)    
-    assert_equal(DateTime.new(2004,12,31,23,0,0), p.local_start)    
-    assert_equal(DateTime.new(2005,1,1,23,0,0), p.local_end)        
-  end
   
-  def test_initialize_time
-    p = TimezonePeriod.new(Time.utc(2005,1,1,0,0,0), Time.utc(2005,1,2,0,0,0), -7200, 3600, :TEST)
+  def test_initialize_start_end
+    std = TimezoneOffsetInfo.new(-7200, 0, :TEST)
+    dst = TimezoneOffsetInfo.new(-7200, 3600, :TEST)
+    start_t = TimezoneTransitionInfo.new(dst, std, 1136073600)
+    end_t = TimezoneTransitionInfo.new(std, dst, 1136160000)
+      
+    p = TimezonePeriod.new(start_t, end_t)
     
-    assert_equal(DateTime.new(2005,1,1,0,0,0), p.utc_start)
-    assert_equal(DateTime.new(2005,1,2,0,0,0), p.utc_end)
+    assert_equal(start_t, p.start_transition)
+    assert_equal(end_t, p.end_transition)
+    assert_equal(dst, p.offset)
+    assert_equal(DateTime.new(2006,1,1,0,0,0), p.utc_start)
+    assert_equal(DateTime.new(2006,1,2,0,0,0), p.utc_end)
     assert_equal(-7200, p.utc_offset)
     assert_equal(3600, p.std_offset)
+    assert_equal(-3600, p.utc_total_offset)
+    assert_equal(Rational(-3600, 86400), p.utc_total_offset_rational)
     assert_equal(:TEST, p.zone_identifier)
     assert_equal(:TEST, p.abbreviation)    
-    assert_equal(DateTime.new(2004,12,31,23,0,0), p.local_start)    
-    assert_equal(DateTime.new(2005,1,1,23,0,0), p.local_end)
+    assert_equal(DateTime.new(2005,12,31,23,0,0), p.local_start)    
+    assert_equal(DateTime.new(2006,1,1,23,0,0), p.local_end)
   end
   
-  def test_initialize_timestamp
-    p = TimezonePeriod.new(1104537600, 1104624000, -7200, 3600, :TEST)
+  def test_initialize_start_end_offset
+    std = TimezoneOffsetInfo.new(-7200, 0, :TEST)
+    dst = TimezoneOffsetInfo.new(-7200, 3600, :TEST)
+    special = TimezoneOffsetInfo.new(0, 0, :SPECIAL)
+    start_t = TimezoneTransitionInfo.new(dst, std, 1136073600)
+    end_t = TimezoneTransitionInfo.new(std, dst, 1136160000)
+      
+    assert_raise(ArgumentError) { TimezonePeriod.new(start_t, end_t, special) }
+  end
+  
+  def test_initialize_start
+    std = TimezoneOffsetInfo.new(-7200, 0, :TEST)
+    dst = TimezoneOffsetInfo.new(-7200, 3600, :TEST)
+    start_t = TimezoneTransitionInfo.new(dst, std, 1136073600)   
+      
+    p = TimezonePeriod.new(start_t, nil)
     
-    assert_equal(DateTime.new(2005,1,1,0,0,0), p.utc_start)
-    assert_equal(DateTime.new(2005,1,2,0,0,0), p.utc_end)
+    assert_equal(start_t, p.start_transition)
+    assert_nil(p.end_transition)
+    assert_equal(dst, p.offset)
+    assert_equal(DateTime.new(2006,1,1,0,0,0), p.utc_start)
+    assert_nil(p.utc_end)
     assert_equal(-7200, p.utc_offset)
     assert_equal(3600, p.std_offset)
+    assert_equal(-3600, p.utc_total_offset)
+    assert_equal(Rational(-3600, 86400), p.utc_total_offset_rational)
     assert_equal(:TEST, p.zone_identifier)
     assert_equal(:TEST, p.abbreviation)    
-    assert_equal(DateTime.new(2004,12,31,23,0,0), p.local_start)    
-    assert_equal(DateTime.new(2005,1,1,23,0,0), p.local_end)
+    assert_equal(DateTime.new(2005,12,31,23,0,0), p.local_start)    
+    assert_nil(p.local_end)
   end
   
-  def test_initialize_nil
-    p = TimezonePeriod.new(nil, nil, -7200, 3600, :TEST)
+  def test_initialize_start_offset
+    std = TimezoneOffsetInfo.new(-7200, 0, :TEST)
+    dst = TimezoneOffsetInfo.new(-7200, 3600, :TEST)
+    special = TimezoneOffsetInfo.new(0, 0, :SPECIAL)
+    start_t = TimezoneTransitionInfo.new(dst, std, 1136073600)   
+      
+    assert_raise(ArgumentError) { TimezonePeriod.new(start_t, nil, special) }
+  end
+  
+  def test_initialize_end
+    std = TimezoneOffsetInfo.new(-7200, 0, :TEST)
+    dst = TimezoneOffsetInfo.new(-7200, 3600, :TEST)    
+    end_t = TimezoneTransitionInfo.new(std, dst, 1136160000)
+      
+    p = TimezonePeriod.new(nil, end_t)
     
+    assert_nil(p.start_transition)
+    assert_equal(end_t, p.end_transition)
+    assert_equal(dst, p.offset)
     assert_nil(p.utc_start)
-    assert_nil(p.utc_end)
+    assert_equal(DateTime.new(2006,1,2,0,0,0), p.utc_end)
     assert_equal(-7200, p.utc_offset)
     assert_equal(3600, p.std_offset)
-    assert_equal(:TEST, p.zone_identifier)    
-    assert_equal(:TEST, p.abbreviation)
+    assert_equal(-3600, p.utc_total_offset)
+    assert_equal(Rational(-3600, 86400), p.utc_total_offset_rational)
+    assert_equal(:TEST, p.zone_identifier)
+    assert_equal(:TEST, p.abbreviation)    
     assert_nil(p.local_start)    
-    assert_nil(p.local_end)
+    assert_equal(DateTime.new(2006,1,1,23,0,0), p.local_end)
   end
   
-  def test_utc_total_offset
-    p1 = TimezonePeriod.new(DateTime.new(2005,1,1,0,0,0), DateTime.new(2005,1,2,0,0,0), -14400, 3600, :TEST)
-    p2 = TimezonePeriod.new(DateTime.new(2005,1,1,0,0,0), DateTime.new(2005,1,2,0,0,0), -14400, 0, :TEST)
-    p3 = TimezonePeriod.new(DateTime.new(2005,1,1,0,0,0), DateTime.new(2005,1,2,0,0,0), 7200, 3600, :TEST)
-    
-    assert_equal(-10800, p1.utc_total_offset)
-    assert_equal(-14400, p2.utc_total_offset)
-    assert_equal(10800, p3.utc_total_offset)
+  def test_initialize_end_offset
+    std = TimezoneOffsetInfo.new(-7200, 0, :TEST)
+    dst = TimezoneOffsetInfo.new(-7200, 3600, :TEST)    
+    special = TimezoneOffsetInfo.new(0, 0, :SPECIAL)
+    end_t = TimezoneTransitionInfo.new(std, dst, 1136160000)
+      
+    assert_raise(ArgumentError) { TimezonePeriod.new(nil, end_t, special) }    
   end
   
-  def test_utc_total_offset_rational
-    p = TimezonePeriod.new(DateTime.new(2005,1,1,0,0,0), DateTime.new(2005,1,2,0,0,0), -14400, 3600, :TEST)
+  def test_initialize
+    assert_raise(ArgumentError) { TimezonePeriod.new(nil, nil) }
+  end
+  
+  def test_initialize_offset
+    special = TimezoneOffsetInfo.new(0, 0, :SPECIAL)
+      
+    p = TimezonePeriod.new(nil, nil, special)
     
-    assert_equal(Rational(-10800, 24 * 60 * 60), p.utc_total_offset_rational)
+    assert_nil(p.start_transition)
+    assert_nil(p.end_transition)
+    assert_equal(special, p.offset)
+    assert_nil(p.utc_start)
+    assert_nil(p.utc_end)
+    assert_equal(0, p.utc_offset)
+    assert_equal(0, p.std_offset)
+    assert_equal(0, p.utc_total_offset)
+    assert_equal(Rational(0, 86400), p.utc_total_offset_rational)
+    assert_equal(:SPECIAL, p.zone_identifier)
+    assert_equal(:SPECIAL, p.abbreviation)    
+    assert_nil(p.local_start)    
+    assert_nil(p.local_end)  
   end
   
-  def test_dst
-    p1 = TimezonePeriod.new(DateTime.new(2005,1,1,0,0,0), DateTime.new(2005,1,2,0,0,0), -14400, 3600, :TEST)
-    p2 = TimezonePeriod.new(DateTime.new(2005,1,1,0,0,0), DateTime.new(2005,1,2,0,0,0), -14400, 0, :TEST)
-    p3 = TimezonePeriod.new(DateTime.new(2005,1,1,0,0,0), DateTime.new(2005,1,2,0,0,0), -14400, -3600, :TEST)
-    p4 = TimezonePeriod.new(DateTime.new(2005,1,1,0,0,0), DateTime.new(2005,1,2,0,0,0), -14400, 7200, :TEST)
-    p5 = TimezonePeriod.new(DateTime.new(2005,1,1,0,0,0), DateTime.new(2005,1,2,0,0,0), -14400, -7200, :TEST)
+  def test_dst    
+    p1 = TimezonePeriod.new(nil, nil, TimezoneOffsetInfo.new(-14400, 3600, :TEST))
+    p2 = TimezonePeriod.new(nil, nil, TimezoneOffsetInfo.new(-14400, 0, :TEST))
+    p3 = TimezonePeriod.new(nil, nil, TimezoneOffsetInfo.new(-14400, -3600, :TEST))
+    p4 = TimezonePeriod.new(nil, nil, TimezoneOffsetInfo.new(-14400, 7200, :TEST))
+    p5 = TimezonePeriod.new(nil, nil, TimezoneOffsetInfo.new(-14400, -7200, :TEST))
     
     assert_equal(true, p1.dst?)
     assert_equal(false, p2.dst?)
@@ -88,11 +142,17 @@ class TCTimezonePeriod < Test::Unit::TestCase
   end
   
   def test_valid_for_utc
-    p1 = TimezonePeriod.new(DateTime.new(2005,1,1,1,1,1), DateTime.new(2005,2,2,2,2,2), -7200, 3600, :TEST)
-    p2 = TimezonePeriod.new(nil, Time.utc(2005,2,2,2,2,2), -7200, 3600, :TEST)
-    p3 = TimezonePeriod.new(1104541261, nil, -7200, 3600, :TEST)
-    p4 = TimezonePeriod.new(nil, nil, -7200, 3600, :TEST)
-    p5 = TimezonePeriod.new(DateTime.new(1960,1,1,1,1,1), DateTime.new(1960,2,2,2,2,2), -7200, 3600, :TEST)
+    offset = TimezoneOffsetInfo.new(-7200, 3600, :TEST)
+    t1 = TimezoneTransitionInfo.new(offset, offset, 1104541261)
+    t2 = TimezoneTransitionInfo.new(offset, offset, 1107309722)
+    t3 = TimezoneTransitionInfo.new(offset, offset, 210551144461, 86400)
+    t4 = TimezoneTransitionInfo.new(offset, offset, 105276956461, 43200)
+    
+    p1 = TimezonePeriod.new(t1, t2)
+    p2 = TimezonePeriod.new(nil, t2)
+    p3 = TimezonePeriod.new(t1, nil)
+    p4 = TimezonePeriod.new(nil, nil, offset)
+    p5 = TimezonePeriod.new(t3, t4)
     
     assert_equal(true, p1.valid_for_utc?(DateTime.new(2005,1,1,1,1,1)))
     assert_equal(true, p1.valid_for_utc?(Time.utc(2005,2,2,2,2,1)))
@@ -135,9 +195,15 @@ class TCTimezonePeriod < Test::Unit::TestCase
   end
   
   def test_utc_after_start
-    p1 = TimezonePeriod.new(1104541261, DateTime.new(2005,2,2,2,2,2), -7200, 3600, :TEST)
-    p2 = TimezonePeriod.new(nil, Time.utc(2005,2,2,2,2,2), -7200, 3600, :TEST)
-    p3 = TimezonePeriod.new(DateTime.new(1945,1,1,1,1,1), DateTime.new(1945,2,2,2,2,2), -7200, 3600, :TEST)
+    offset = TimezoneOffsetInfo.new(-7200, 3600, :TEST)
+    t1 = TimezoneTransitionInfo.new(offset, offset, 1104541261)
+    t2 = TimezoneTransitionInfo.new(offset, offset, 1107309722)
+    t3 = TimezoneTransitionInfo.new(offset, offset, 210077845261, 86400)
+    t4 = TimezoneTransitionInfo.new(offset, offset, 105040306861, 43200)
+    
+    p1 = TimezonePeriod.new(t1, t2)
+    p2 = TimezonePeriod.new(nil, t2)
+    p3 = TimezonePeriod.new(t3, t4)
 
     assert_equal(true, p1.utc_after_start?(DateTime.new(2005,1,1,1,1,1)))    
     assert_equal(true, p1.utc_after_start?(Time.utc(2005,1,1,1,1,2)))
@@ -154,10 +220,16 @@ class TCTimezonePeriod < Test::Unit::TestCase
   end
   
   def test_utc_before_end
-    p1 = TimezonePeriod.new(Time.utc(2005,1,1,1,1,1), 1107309722, -7200, 3600, :TEST)    
-    p2 = TimezonePeriod.new(DateTime.new(2005,1,1,1,1,1), nil, -7200, 3600, :TEST) 
-    p3 = TimezonePeriod.new(DateTime.new(1945,1,1,1,1,1), DateTime.new(1945,2,2,2,2,2), -7200, 3600, :TEST)
-        
+    offset = TimezoneOffsetInfo.new(-7200, 3600, :TEST)
+    t1 = TimezoneTransitionInfo.new(offset, offset, 1104541261)
+    t2 = TimezoneTransitionInfo.new(offset, offset, 1107309722)
+    t3 = TimezoneTransitionInfo.new(offset, offset, 210077845261, 86400)
+    t4 = TimezoneTransitionInfo.new(offset, offset, 105040306861, 43200)
+    
+    p1 = TimezonePeriod.new(t1, t2)
+    p2 = TimezonePeriod.new(t1, nil)
+    p3 = TimezonePeriod.new(t3, t4)
+    
     assert_equal(true, p1.utc_before_end?(DateTime.new(2005,2,2,2,2,1)))    
     assert_equal(true, p1.utc_before_end?(Time.utc(2005,2,2,2,2,0)))   
     assert_equal(false, p1.utc_before_end?(1107309723))
@@ -173,11 +245,18 @@ class TCTimezonePeriod < Test::Unit::TestCase
   end
   
   def test_valid_for_local
-    p1 = TimezonePeriod.new(1104544861, DateTime.new(2005,2,2,3,2,2), -7200, 3600, :TEST)
-    p2 = TimezonePeriod.new(nil, Time.utc(2005,2,2,3,2,2), -7200, 3600, :TEST)
-    p3 = TimezonePeriod.new(DateTime.new(2005,1,1,2,1,1), nil, -7200, 3600, :TEST)
-    p4 = TimezonePeriod.new(nil, nil, -7200, 3600, :TEST)
-    p5 = TimezonePeriod.new(DateTime.new(1960,1,1,1,1,1), DateTime.new(1960,2,2,2,2,2), -7200, 3600, :TEST)
+    offset = TimezoneOffsetInfo.new(-7200, 3600, :TEST)
+    t1 = TimezoneTransitionInfo.new(offset, offset, 1104544861)
+    t2 = TimezoneTransitionInfo.new(offset, offset, 1107313322)
+    t3 = TimezoneTransitionInfo.new(offset, offset, 1104544861)
+    t4 = TimezoneTransitionInfo.new(offset, offset, 210551144461, 86400)
+    t5 = TimezoneTransitionInfo.new(offset, offset, 105276956461, 43200)
+    
+    p1 = TimezonePeriod.new(t1, t2)
+    p2 = TimezonePeriod.new(nil, t2)
+    p3 = TimezonePeriod.new(t3, nil)
+    p4 = TimezonePeriod.new(nil, nil, offset)
+    p5 = TimezonePeriod.new(t4, t5)
     
     assert_equal(true, p1.valid_for_local?(DateTime.new(2005,1,1,1,1,1)))
     assert_equal(true, p1.valid_for_local?(Time.utc(2005,2,2,2,2,1)))
@@ -220,9 +299,15 @@ class TCTimezonePeriod < Test::Unit::TestCase
   end
   
   def test_local_after_start
-    p1 = TimezonePeriod.new(DateTime.new(2005,1,1,2,1,1), Time.utc(2005,2,2,3,2,2), -7200, 3600, :TEST)
-    p2 = TimezonePeriod.new(nil, 1107313322, -7200, 3600, :TEST)
-    p3 = TimezonePeriod.new(DateTime.new(1945,1,1,1,1,1), DateTime.new(1945,2,2,2,2,2), -7200, 3600, :TEST)
+    offset = TimezoneOffsetInfo.new(-7200, 3600, :TEST)
+    t1 = TimezoneTransitionInfo.new(offset, offset, 1104544861)
+    t2 = TimezoneTransitionInfo.new(offset, offset, 1107313322)
+    t3 = TimezoneTransitionInfo.new(offset, offset, 210077845261, 86400)
+    t4 = TimezoneTransitionInfo.new(offset, offset, 105040306861, 43200)
+    
+    p1 = TimezonePeriod.new(t1, t2)
+    p2 = TimezonePeriod.new(nil, t2)
+    p3 = TimezonePeriod.new(t3, t4)
 
     assert_equal(true, p1.local_after_start?(DateTime.new(2005,1,1,1,1,1)))    
     assert_equal(true, p1.local_after_start?(Time.utc(2005,1,1,1,1,2)))
@@ -239,9 +324,15 @@ class TCTimezonePeriod < Test::Unit::TestCase
   end
   
   def test_local_before_end
-    p1 = TimezonePeriod.new(Time.utc(2005,1,1,2,1,1), 1107313322, -7200, 3600, :TEST)    
-    p2 = TimezonePeriod.new(DateTime.new(2005,1,1,2,1,1), nil, -7200, 3600, :TEST)
-    p3 = TimezonePeriod.new(DateTime.new(1945,1,1,1,1,1), DateTime.new(1945,2,2,2,2,2), -7200, 3600, :TEST)    
+    offset = TimezoneOffsetInfo.new(-7200, 3600, :TEST)
+    t1 = TimezoneTransitionInfo.new(offset, offset, 1104544861)
+    t2 = TimezoneTransitionInfo.new(offset, offset, 1107313322)
+    t3 = TimezoneTransitionInfo.new(offset, offset, 210077845261, 86400)
+    t4 = TimezoneTransitionInfo.new(offset, offset, 105040306861, 43200)
+    
+    p1 = TimezonePeriod.new(t1, t2)    
+    p2 = TimezonePeriod.new(t1, nil)
+    p3 = TimezonePeriod.new(t3, t4)    
         
     assert_equal(true, p1.local_before_end?(DateTime.new(2005,2,2,2,2,1)))    
     assert_equal(true, p1.local_before_end?(Time.utc(2005,2,2,2,2,0)))   
@@ -258,9 +349,9 @@ class TCTimezonePeriod < Test::Unit::TestCase
   end
   
   def test_to_local
-    p1 = TimezonePeriod.new(DateTime.new(2005,1,1,0,0,0), DateTime.new(2005,2,2,0,0,0), -14400, 3600, :TEST)
-    p2 = TimezonePeriod.new(DateTime.new(2005,1,1,0,0,0), DateTime.new(2005,2,2,0,0,0), -14400, 0, :TEST)
-    p3 = TimezonePeriod.new(DateTime.new(2005,1,1,0,0,0), DateTime.new(2005,2,2,0,0,0), 7200, 3600, :TEST)
+    p1 = TimezonePeriod.new(nil, nil, TimezoneOffsetInfo.new(-14400, 3600, :TEST))
+    p2 = TimezonePeriod.new(nil, nil, TimezoneOffsetInfo.new(-14400, 0, :TEST))
+    p3 = TimezonePeriod.new(nil, nil, TimezoneOffsetInfo.new(7200, 3600, :TEST))
         
     assert_equal(DateTime.new(2005,1,19,22,0,0), p1.to_local(DateTime.new(2005,1,20,1,0,0)))
     assert_equal(Time.utc(2005,1,19,21,0,0), p2.to_local(Time.utc(2005,1,20,1,0,0)))
@@ -268,9 +359,9 @@ class TCTimezonePeriod < Test::Unit::TestCase
   end
   
   def test_to_utc
-    p1 = TimezonePeriod.new(DateTime.new(2005,1,1,0,0,0), DateTime.new(2005,2,2,0,0,0), -14400, 3600, :TEST)
-    p2 = TimezonePeriod.new(DateTime.new(2005,1,1,0,0,0), DateTime.new(2005,2,2,0,0,0), -14400, 0, :TEST)
-    p3 = TimezonePeriod.new(DateTime.new(2005,1,1,0,0,0), DateTime.new(2005,2,2,0,0,0), 7200, 3600, :TEST)
+    p1 = TimezonePeriod.new(nil, nil, TimezoneOffsetInfo.new(-14400, 3600, :TEST))
+    p2 = TimezonePeriod.new(nil, nil, TimezoneOffsetInfo.new(-14400, 0, :TEST))
+    p3 = TimezonePeriod.new(nil, nil, TimezoneOffsetInfo.new(7200, 3600, :TEST))
         
     assert_equal(DateTime.new(2005,1,20,4,0,0), p1.to_utc(DateTime.new(2005,1,20,1,0,0)))
     assert_equal(Time.utc(2005,1,20,5,0,0), p2.to_utc(Time.utc(2005,1,20,1,0,0)))
@@ -278,14 +369,143 @@ class TCTimezonePeriod < Test::Unit::TestCase
   end
   
   def test_time_boundary_start
-    p1 = TimezonePeriod.new(Time.utc(1970,1,1,0,0,0), nil, -3600, 0, :TEST)
+    o1 = TimezoneOffsetInfo.new(-3600, 0, :TEST)
+    o2 = TimezoneOffsetInfo.new(-3600, 3600, :TEST)
+    t1 = TimezoneTransitionInfo.new(o1, o2, 0)
+    
+    p1 = TimezonePeriod.new(t1, nil)
     
     assert_equal(DateTime.new(1969,12,31,23,0,0), p1.local_start)    
   end
   
   def test_time_boundary_end
-    p1 = TimezonePeriod.new(nil, Time.utc(2038,1,19,3,0,0), 0, 3600, :TEST)
+    o1 = TimezoneOffsetInfo.new(0, 3600, :TEST)
+    o2 = TimezoneOffsetInfo.new(0, 0, :TEST)
+    t1 = TimezoneTransitionInfo.new(o2, o1, 2147482800)
+    
+    p1 = TimezonePeriod.new(nil, t1)
     
     assert_equal(DateTime.new(2038,1,19,4,0,0), p1.local_end)
   end
+  
+  def test_equality
+    o1 = TimezoneOffsetInfo.new(0, 3600, :TEST)
+    o2 = TimezoneOffsetInfo.new(0, 0, :TEST)
+    t1 = TimezoneTransitionInfo.new(o1, o2, 1149368400)    
+    t2 = TimezoneTransitionInfo.new(o1, o2, 19631123, 8)
+    t3 = TimezoneTransitionInfo.new(o1, o2, 1149454800)
+    t4 = TimezoneTransitionInfo.new(o1, o2, 1149541200)
+    
+    p1 = TimezonePeriod.new(t1, t3)
+    p2 = TimezonePeriod.new(t1, t3)
+    p3 = TimezonePeriod.new(t2, t3)
+    p4 = TimezonePeriod.new(t3, nil)
+    p5 = TimezonePeriod.new(t3, nil)
+    p6 = TimezonePeriod.new(t4, nil)
+    p7 = TimezonePeriod.new(nil, t3)
+    p8 = TimezonePeriod.new(nil, t3)
+    p9 = TimezonePeriod.new(nil, t4)
+    p10 = TimezonePeriod.new(nil, nil, o1)
+    p11 = TimezonePeriod.new(nil, nil, o1)
+    p12 = TimezonePeriod.new(nil, nil, o2)
+    
+    assert_equal(true, p1 == p1)
+    assert_equal(true, p1 == p2)
+    assert_equal(true, p1 == p3)
+    assert_equal(false, p1 == p4)
+    assert_equal(false, p1 == p5)
+    assert_equal(false, p1 == p6)
+    assert_equal(false, p1 == p7)
+    assert_equal(false, p1 == p8)
+    assert_equal(false, p1 == p9)
+    assert_equal(false, p1 == p10)
+    assert_equal(false, p1 == p11)
+    assert_equal(false, p1 == p12)
+    assert_equal(false, p1 == Object.new)
+    
+    assert_equal(true, p4 == p4)
+    assert_equal(true, p4 == p5)
+    assert_equal(false, p4 == p6)
+    assert_equal(false, p4 == Object.new)
+    
+    assert_equal(true, p7 == p7)
+    assert_equal(true, p7 == p8)
+    assert_equal(false, p7 == p9)
+    assert_equal(false, p7 == Object.new)
+    
+    assert_equal(true, p10 == p10)
+    assert_equal(true, p10 == p11)
+    assert_equal(false, p10 == p12)
+    assert_equal(false, p10 == Object.new)
+  end
+  
+  def test_eql
+    o1 = TimezoneOffsetInfo.new(0, 3600, :TEST)
+    o2 = TimezoneOffsetInfo.new(0, 0, :TEST)
+    t1 = TimezoneTransitionInfo.new(o1, o2, 1149368400)    
+    t2 = TimezoneTransitionInfo.new(o1, o2, 19631123, 8)
+    t3 = TimezoneTransitionInfo.new(o1, o2, 1149454800)
+    t4 = TimezoneTransitionInfo.new(o1, o2, 1149541200)
+    
+    p1 = TimezonePeriod.new(t1, t3)
+    p2 = TimezonePeriod.new(t1, t3)
+    p3 = TimezonePeriod.new(t2, t3)
+    p4 = TimezonePeriod.new(t3, nil)
+    p5 = TimezonePeriod.new(t3, nil)
+    p6 = TimezonePeriod.new(t4, nil)
+    p7 = TimezonePeriod.new(nil, t3)
+    p8 = TimezonePeriod.new(nil, t3)
+    p9 = TimezonePeriod.new(nil, t4)
+    p10 = TimezonePeriod.new(nil, nil, o1)
+    p11 = TimezonePeriod.new(nil, nil, o1)
+    p12 = TimezonePeriod.new(nil, nil, o2)
+    
+    assert_equal(true, p1.eql?(p1))
+    assert_equal(true, p1.eql?(p2))
+    assert_equal(false, p1.eql?(p3))
+    assert_equal(false, p1.eql?(p4))
+    assert_equal(false, p1.eql?(p5))
+    assert_equal(false, p1.eql?(p6))
+    assert_equal(false, p1.eql?(p7))
+    assert_equal(false, p1.eql?(p8))
+    assert_equal(false, p1.eql?(p9))
+    assert_equal(false, p1.eql?(p10))
+    assert_equal(false, p1.eql?(p11))
+    assert_equal(false, p1.eql?(p12))
+    assert_equal(false, p1.eql?(Object.new))
+    
+    assert_equal(true, p4.eql?(p4))
+    assert_equal(true, p4.eql?(p5))
+    assert_equal(false, p4.eql?(p6))
+    assert_equal(false, p4.eql?(Object.new))
+    
+    assert_equal(true, p7.eql?(p7))
+    assert_equal(true, p7.eql?(p8))
+    assert_equal(false, p7.eql?(p9))
+    assert_equal(false, p7.eql?(Object.new))
+    
+    assert_equal(true, p10.eql?(p10))
+    assert_equal(true, p10.eql?(p11))
+    assert_equal(false, p10.eql?(p12))
+    assert_equal(false, p10.eql?(Object.new))
+  end
+  
+  def test_hash
+    o1 = TimezoneOffsetInfo.new(0, 3600, :TEST)
+    o2 = TimezoneOffsetInfo.new(0, 0, :TEST)
+    t1 = TimezoneTransitionInfo.new(o1, o2, 1149368400)    
+    t2 = TimezoneTransitionInfo.new(o1, o2, 19631123, 8)
+    t3 = TimezoneTransitionInfo.new(o1, o2, 1149454800)
+    t4 = TimezoneTransitionInfo.new(o1, o2, 1149541200)
+    
+    p1 = TimezonePeriod.new(t1, t3)    
+    p2 = TimezonePeriod.new(t3, nil)
+    p3 = TimezonePeriod.new(nil, t3)
+    p4 = TimezonePeriod.new(nil, nil, o1)
+
+    assert_equal(t1.hash ^ t3.hash, p1.hash)
+    assert_equal(t3.hash ^ nil.hash, p2.hash)
+    assert_equal(nil.hash ^ t3.hash, p3.hash)
+    assert_equal(nil.hash ^ nil.hash ^ o1.hash, p4.hash)    
+  end
 end