tzinfo 1.2.5

data/test/tc_timezone_new_york.rb

@@ -0,0 +1,142 @@
+require File.join(File.expand_path(File.dirname(__FILE__)), 'test_utils')
+
+include TZInfo
+
+class TCTimezoneNewYork < Minitest::Test
+  def test_2004
+    #America/New_York  Sun Apr  4 06:59:59 2004 UTC = Sun Apr  4 01:59:59 2004 EST isdst=0 gmtoff=-18000
+    #America/New_York  Sun Apr  4 07:00:00 2004 UTC = Sun Apr  4 03:00:00 2004 EDT isdst=1 gmtoff=-14400
+    #America/New_York  Sun Oct 31 05:59:59 2004 UTC = Sun Oct 31 01:59:59 2004 EDT isdst=1 gmtoff=-14400
+    #America/New_York  Sun Oct 31 06:00:00 2004 UTC = Sun Oct 31 01:00:00 2004 EST isdst=0 gmtoff=-18000
+    
+    tz = Timezone.get('America/New_York')
+    assert_equal(DateTime.new(2004,4,4,1,59,59), tz.utc_to_local(DateTime.new(2004,4,4,6,59,59)))
+    assert_equal(DateTime.new(2004,4,4,3,0,0), tz.utc_to_local(DateTime.new(2004,4,4,7,0,0)))    
+    assert_equal(DateTime.new(2004,10,31,1,59,59), tz.utc_to_local(DateTime.new(2004,10,31,5,59,59)))
+    assert_equal(DateTime.new(2004,10,31,1,0,0), tz.utc_to_local(DateTime.new(2004,10,31,6,0,0)))
+    
+    assert_equal(DateTime.new(2004,4,4,6,59,59), tz.local_to_utc(DateTime.new(2004,4,4,1,59,59)))
+    assert_equal(DateTime.new(2004,4,4,7,0,0), tz.local_to_utc(DateTime.new(2004,4,4,3,0,0)))
+    assert_equal(DateTime.new(2004,10,31,5,59,59), tz.local_to_utc(DateTime.new(2004,10,31,1,59,59), true))
+    assert_equal(DateTime.new(2004,10,31,6,59,59), tz.local_to_utc(DateTime.new(2004,10,31,1,59,59), false))
+    assert_equal(DateTime.new(2004,10,31,5,0,0), tz.local_to_utc(DateTime.new(2004,10,31,1,0,0), true))
+    assert_equal(DateTime.new(2004,10,31,6,0,0), tz.local_to_utc(DateTime.new(2004,10,31,1,0,0), false))
+    
+    assert_raises(PeriodNotFound) { tz.local_to_utc(DateTime.new(2004,4,4,2,0,0)) }
+    assert_raises(AmbiguousTime) { tz.local_to_utc(DateTime.new(2004,10,31,1,0,0)) }
+    
+    assert_equal(:EST, tz.period_for_utc(DateTime.new(2004,4,4,6,59,59)).zone_identifier)
+    assert_equal(:EDT, tz.period_for_utc(DateTime.new(2004,4,4,7,0,0)).zone_identifier)
+    assert_equal(:EDT, tz.period_for_utc(DateTime.new(2004,10,31,5,59,59)).zone_identifier)
+    assert_equal(:EST, tz.period_for_utc(DateTime.new(2004,10,31,6,0,0)).zone_identifier)
+    
+    assert_equal(:EST, tz.period_for_local(DateTime.new(2004,4,4,1,59,59)).zone_identifier)
+    assert_equal(:EDT, tz.period_for_local(DateTime.new(2004,4,4,3,0,0)).zone_identifier)
+    assert_equal(:EDT, tz.period_for_local(DateTime.new(2004,10,31,1,59,59), true).zone_identifier)
+    assert_equal(:EST, tz.period_for_local(DateTime.new(2004,10,31,1,59,59), false).zone_identifier)
+    assert_equal(:EDT, tz.period_for_local(DateTime.new(2004,10,31,1,0,0), true).zone_identifier)
+    assert_equal(:EST, tz.period_for_local(DateTime.new(2004,10,31,1,0,0), false).zone_identifier)
+    
+    assert_equal(-18000, tz.period_for_utc(DateTime.new(2004,4,4,6,59,59)).utc_total_offset)
+    assert_equal(-14400, tz.period_for_utc(DateTime.new(2004,4,4,7,0,0)).utc_total_offset)
+    assert_equal(-14400, tz.period_for_utc(DateTime.new(2004,10,31,5,59,59)).utc_total_offset)
+    assert_equal(-18000, tz.period_for_utc(DateTime.new(2004,10,31,6,0,0)).utc_total_offset)
+    
+    assert_equal(-18000, tz.period_for_local(DateTime.new(2004,4,4,1,59,59)).utc_total_offset)
+    assert_equal(-14400, tz.period_for_local(DateTime.new(2004,4,4,3,0,0)).utc_total_offset)
+    assert_equal(-14400, tz.period_for_local(DateTime.new(2004,10,31,1,59,59), true).utc_total_offset)
+    assert_equal(-18000, tz.period_for_local(DateTime.new(2004,10,31,1,59,59), false).utc_total_offset)
+    assert_equal(-14400, tz.period_for_local(DateTime.new(2004,10,31,1,0,0), true).utc_total_offset)
+    assert_equal(-18000, tz.period_for_local(DateTime.new(2004,10,31,1,0,0), false).utc_total_offset)
+    
+    transitions = tz.transitions_up_to(DateTime.new(2005,1,1,0,0,0), DateTime.new(2004,1,1,0,0,0))
+    assert_equal(2, transitions.length)
+    assert_equal(TimeOrDateTime.new(DateTime.new(2004,4,4,7,0,0)), transitions[0].at)
+    assert_equal(TimezoneOffset.new(-18000, 0, :EST), transitions[0].previous_offset)
+    assert_equal(TimezoneOffset.new(-18000, 3600, :EDT), transitions[0].offset)
+    assert_equal(TimeOrDateTime.new(DateTime.new(2004,10,31,6,0,0)), transitions[1].at)
+    assert_equal(TimezoneOffset.new(-18000, 3600, :EDT), transitions[1].previous_offset)
+    assert_equal(TimezoneOffset.new(-18000, 0, :EST), transitions[1].offset)
+    
+    offsets = tz.offsets_up_to(DateTime.new(2005,1,1,0,0,0), DateTime.new(2004,1,1,0,0,0))
+    assert_array_same_items([TimezoneOffset.new(-18000, 0, :EST), TimezoneOffset.new(-18000, 3600, :EDT)], offsets)
+  end     
+
+  def test_1957
+    # This test cannot be run when using ZoneinfoDataSource on platforms
+    # that don't support Times before the epoch (i.e. Ruby < 1.9 on Windows) 
+    # because it relates to the year 1957.
+    
+    if !DataSource.get.kind_of?(ZoneinfoDataSource) || RubyCoreSupport.time_supports_negative
+      #America/New_York  Sun Apr 28 06:59:59 1957 UTC = Sun Apr 28 01:59:59 1957 EST isdst=0 gmtoff=-18000
+      #America/New_York  Sun Apr 28 07:00:00 1957 UTC = Sun Apr 28 03:00:00 1957 EDT isdst=1 gmtoff=-14400
+      #America/New_York  Sun Oct 27 05:59:59 1957 UTC = Sun Oct 27 01:59:59 1957 EDT isdst=1 gmtoff=-14400
+      #America/New_York  Sun Oct 27 06:00:00 1957 UTC = Sun Oct 27 01:00:00 1957 EST isdst=0 gmtoff=-18000
+      
+      tz = Timezone.get('America/New_York')
+      assert_equal(DateTime.new(1957,4,28,1,59,59), tz.utc_to_local(DateTime.new(1957,4,28,6,59,59)))
+      assert_equal(DateTime.new(1957,4,28,3,0,0), tz.utc_to_local(DateTime.new(1957,4,28,7,0,0)))    
+      assert_equal(DateTime.new(1957,10,27,1,59,59), tz.utc_to_local(DateTime.new(1957,10,27,5,59,59)))
+      assert_equal(DateTime.new(1957,10,27,1,0,0), tz.utc_to_local(DateTime.new(1957,10,27,6,0,0)))
+      
+      assert_equal(DateTime.new(1957,4,28,6,59,59), tz.local_to_utc(DateTime.new(1957,4,28,1,59,59)))
+      assert_equal(DateTime.new(1957,4,28,7,0,0), tz.local_to_utc(DateTime.new(1957,4,28,3,0,0)))
+      assert_equal(DateTime.new(1957,10,27,5,59,59), tz.local_to_utc(DateTime.new(1957,10,27,1,59,59), true))
+      assert_equal(DateTime.new(1957,10,27,6,59,59), tz.local_to_utc(DateTime.new(1957,10,27,1,59,59), false))
+      assert_equal(DateTime.new(1957,10,27,5,0,0), tz.local_to_utc(DateTime.new(1957,10,27,1,0,0), true))
+      assert_equal(DateTime.new(1957,10,27,6,0,0), tz.local_to_utc(DateTime.new(1957,10,27,1,0,0), false))
+      
+      assert_raises(PeriodNotFound) { tz.local_to_utc(DateTime.new(1957,4,28,2,0,0)) }
+      assert_raises(AmbiguousTime) { tz.local_to_utc(DateTime.new(1957,10,27,1,0,0)) }
+      
+      assert_equal(:EST, tz.period_for_utc(DateTime.new(1957,4,28,6,59,59)).zone_identifier)
+      assert_equal(:EDT, tz.period_for_utc(DateTime.new(1957,4,28,7,0,0)).zone_identifier)
+      assert_equal(:EDT, tz.period_for_utc(DateTime.new(1957,10,27,5,59,59)).zone_identifier)
+      assert_equal(:EST, tz.period_for_utc(DateTime.new(1957,10,27,6,0,0)).zone_identifier)
+      
+      assert_equal(:EST, tz.period_for_local(DateTime.new(1957,4,28,1,59,59)).zone_identifier)
+      assert_equal(:EDT, tz.period_for_local(DateTime.new(1957,4,28,3,0,0)).zone_identifier)
+      assert_equal(:EDT, tz.period_for_local(DateTime.new(1957,10,27,1,59,59), true).zone_identifier)
+      assert_equal(:EST, tz.period_for_local(DateTime.new(1957,10,27,1,59,59), false).zone_identifier)
+      assert_equal(:EDT, tz.period_for_local(DateTime.new(1957,10,27,1,0,0), true).zone_identifier)
+      assert_equal(:EST, tz.period_for_local(DateTime.new(1957,10,27,1,0,0), false).zone_identifier)
+      
+      assert_equal(-18000, tz.period_for_utc(DateTime.new(1957,4,28,6,59,59)).utc_total_offset)
+      assert_equal(-14400, tz.period_for_utc(DateTime.new(1957,4,28,7,0,0)).utc_total_offset)
+      assert_equal(-14400, tz.period_for_utc(DateTime.new(1957,10,27,5,59,59)).utc_total_offset)
+      assert_equal(-18000, tz.period_for_utc(DateTime.new(1957,10,27,6,0,0)).utc_total_offset)
+      
+      assert_equal(-18000, tz.period_for_local(DateTime.new(1957,4,28,1,59,59)).utc_total_offset)
+      assert_equal(-14400, tz.period_for_local(DateTime.new(1957,4,28,3,0,0)).utc_total_offset)
+      assert_equal(-14400, tz.period_for_local(DateTime.new(1957,10,27,1,59,59), true).utc_total_offset)
+      assert_equal(-18000, tz.period_for_local(DateTime.new(1957,10,27,1,59,59), false).utc_total_offset)
+      assert_equal(-14400, tz.period_for_local(DateTime.new(1957,10,27,1,0,0), true).utc_total_offset)
+      assert_equal(-18000, tz.period_for_local(DateTime.new(1957,10,27,1,0,0), false).utc_total_offset)
+      
+      transitions = tz.transitions_up_to(DateTime.new(1958,1,1,0,0,0), DateTime.new(1957,1,1,0,0,0))
+      assert_equal(2, transitions.length)
+      assert_equal(TimeOrDateTime.new(DateTime.new(1957,4,28,7,0,0)), transitions[0].at)
+      assert_equal(TimezoneOffset.new(-18000, 0, :EST), transitions[0].previous_offset)
+      assert_equal(TimezoneOffset.new(-18000, 3600, :EDT), transitions[0].offset)
+      assert_equal(TimeOrDateTime.new(DateTime.new(1957,10,27,6,0,0)), transitions[1].at)
+      assert_equal(TimezoneOffset.new(-18000, 3600, :EDT), transitions[1].previous_offset)
+      assert_equal(TimezoneOffset.new(-18000, 0, :EST), transitions[1].offset)
+      
+      offsets = tz.offsets_up_to(DateTime.new(1958,1,1,0,0,0), DateTime.new(1957,1,1,0,0,0))
+      assert_array_same_items([TimezoneOffset.new(-18000, 0, :EST), TimezoneOffset.new(-18000, 3600, :EDT)], offsets)
+    end
+  end
+  
+  def test_time_boundary
+    #America/New_York  Sun Oct 26 06:00:00 1969 UTC = Sun Oct 26 01:00:00 1969 EST isdst=0 gmtoff=-18000
+    #America/New_York  Sun Apr 26 06:59:59 1970 UTC = Sun Apr 26 01:59:59 1970 EST isdst=0 gmtoff=-18000
+    
+    tz = Timezone.get('America/New_York')    
+    assert_equal(DateTime.new(1970,1,1,0,0,0), tz.utc_to_local(DateTime.new(1970,1,1,5,0,0)))
+    assert_equal(DateTime.new(1970,1,1,5,0,0), tz.local_to_utc(DateTime.new(1970,1,1,0,0,0)))
+    assert_equal(Time.utc(1970,1,1,0,0,0), tz.utc_to_local(Time.utc(1970,1,1,5,0,0)))
+    assert_equal(Time.utc(1970,1,1,5,0,0), tz.local_to_utc(Time.utc(1970,1,1,0,0,0)))
+    assert_equal(0, tz.utc_to_local(18000))
+    assert_equal(18000, tz.local_to_utc(0))
+  end
+end

data/test/tc_timezone_offset.rb

@@ -0,0 +1,126 @@
+require File.join(File.expand_path(File.dirname(__FILE__)), 'test_utils')
+
+include TZInfo
+
+class TCTimezoneOffset < Minitest::Test
+  
+  def test_utc_offset
+    o1 = TimezoneOffset.new(18000, 0, :TEST)
+    o2 = TimezoneOffset.new(-3600, 3600, :TEST2)
+    
+    assert_equal(18000, o1.utc_offset)
+    assert_equal(-3600, o2.utc_offset)
+  end
+  
+  def test_std_offset
+    o1 = TimezoneOffset.new(18000, 0, :TEST)
+    o2 = TimezoneOffset.new(-3600, 3600, :TEST2)
+    
+    assert_equal(0, o1.std_offset)
+    assert_equal(3600, o2.std_offset)
+  end
+  
+  def test_utc_total_offset
+    o1 = TimezoneOffset.new(18000, 0, :TEST)
+    o2 = TimezoneOffset.new(-3600, 3600, :TEST2)
+    
+    assert_equal(18000, o1.utc_total_offset)
+    assert_equal(0, o2.utc_total_offset)
+  end
+  
+  def test_abbreviation
+    o1 = TimezoneOffset.new(18000, 0, :TEST)
+    o2 = TimezoneOffset.new(-3600, 3600, :TEST2)
+    
+    assert_equal(:TEST, o1.abbreviation)
+    assert_equal(:TEST2, o2.abbreviation)
+  end
+  
+  def test_dst
+    o1 = TimezoneOffset.new(18000, 0, :TEST)
+    o2 = TimezoneOffset.new(-3600, 3600, :TEST2)
+    
+    assert_equal(false, o1.dst?)
+    assert_equal(true, o2.dst?)
+  end
+  
+  def test_to_local
+    o1 = TimezoneOffset.new(18000, 0, :TEST)
+    o2 = TimezoneOffset.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(Time.utc(2006, 5, 30, 0, 31, 20, 782000), o1.to_local(Time.utc(2006, 5, 29, 19, 31, 20, 782000)))
+    assert_equal(DateTime.new(2006, 5, 30, 0, 31, 20), o1.to_local(DateTime.new(2006, 5, 29, 19, 31, 20)))
+    assert_equal(DateTime.new(2006, 5, 30, 0, 31, 20 + Rational(782, 1000)), o1.to_local(DateTime.new(2006, 5, 29, 19, 31, 20 + Rational(782, 1000))))
+    assert_equal(1148949080, o1.to_local(1148931080))
+    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(Time.utc(2006, 5, 29, 19, 31, 20, 123000), o2.to_local(Time.utc(2006, 5, 29, 19, 31, 20, 123000)))
+    assert_equal(DateTime.new(2006, 5, 29, 19, 31, 20), o2.to_local(DateTime.new(2006, 5, 29, 19, 31, 20)))
+    assert_equal(DateTime.new(2006, 5, 29, 19, 31, 20 + Rational(123, 1000)), o2.to_local(DateTime.new(2006, 5, 29, 19, 31, 20 + Rational(123, 1000))))
+    assert_equal(1148931080, o2.to_local(1148931080))
+    assert(TimeOrDateTime.new(1148931080).eql?(o2.to_local(TimeOrDateTime.new(1148931080))))
+  end
+  
+  def test_to_utc
+    o1 = TimezoneOffset.new(18000, 0, :TEST)
+    o2 = TimezoneOffset.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(Time.utc(2006, 5, 29, 14, 31, 20, 913000), o1.to_utc(Time.utc(2006, 5, 29, 19, 31, 20, 913000)))
+    assert_equal(DateTime.new(2006, 5, 29, 14, 31, 20), o1.to_utc(DateTime.new(2006, 5, 29, 19, 31, 20)))
+    assert_equal(DateTime.new(2006, 5, 29, 14, 31, 20 + Rational(913,1000)), o1.to_utc(DateTime.new(2006, 5, 29, 19, 31, 20 + Rational(913,1000))))
+    assert_equal(1148913080, o1.to_utc(1148931080))
+    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(Time.utc(2006, 5, 29, 19, 31, 20, 323000), o2.to_local(Time.utc(2006, 5, 29, 19, 31, 20, 323000)))
+    assert_equal(DateTime.new(2006, 5, 29, 19, 31, 20), o2.to_local(DateTime.new(2006, 5, 29, 19, 31, 20)))
+    assert_equal(DateTime.new(2006, 5, 29, 19, 31, 20 + Rational(323, 1000)), o2.to_local(DateTime.new(2006, 5, 29, 19, 31, 20 + Rational(323, 1000))))
+    assert_equal(1148931080, o2.to_utc(1148931080))
+    assert(TimeOrDateTime.new(1148931080).eql?(o2.to_local(TimeOrDateTime.new(1148931080))))    
+  end
+  
+  def test_equality
+    o1 = TimezoneOffset.new(18000, 0, :TEST)
+    o2 = TimezoneOffset.new(18000, 0, :TEST)
+    o3 = TimezoneOffset.new(18001, 0, :TEST)
+    o4 = TimezoneOffset.new(18000, 1, :TEST)
+    o5 = TimezoneOffset.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 = TimezoneOffset.new(18000, 0, :TEST)
+    o2 = TimezoneOffset.new(18000, 0, :TEST)
+    o3 = TimezoneOffset.new(18001, 0, :TEST)
+    o4 = TimezoneOffset.new(18000, 1, :TEST)
+    o5 = TimezoneOffset.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 = TimezoneOffset.new(18000, 0, :TEST)
+    o2 = TimezoneOffset.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

@@ -0,0 +1,555 @@
+require File.join(File.expand_path(File.dirname(__FILE__)), 'test_utils')
+
+include TZInfo
+
+class TCTimezonePeriod < Minitest::Test
+  
+  class TestTimezoneTransition < TimezoneTransition
+    def initialize(offset, previous_offset, at)
+      super(offset, previous_offset)
+      @at = TimeOrDateTime.wrap(at)
+    end
+    
+    def at
+      @at
+    end
+  end
+  
+  def test_initialize_start_end
+    std = TimezoneOffset.new(-7200, 0, :TEST)
+    dst = TimezoneOffset.new(-7200, 3600, :TEST)
+    start_t = TestTimezoneTransition.new(dst, std, 1136073600)
+    end_t = TestTimezoneTransition.new(std, dst, 1136160000)
+      
+    p = TimezonePeriod.new(start_t, end_t)
+    
+    assert_same(start_t, p.start_transition)
+    assert_same(end_t, p.end_transition)
+    assert_same(dst, p.offset)
+    assert_equal(DateTime.new(2006,1,1,0,0,0), p.utc_start)
+    assert_equal(Time.utc(2006,1,1,0,0,0), p.utc_start_time)
+    assert_equal(DateTime.new(2006,1,2,0,0,0), p.utc_end)
+    assert_equal(Time.utc(2006,1,2,0,0,0), p.utc_end_time)
+    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(2005,12,31,23,0,0), p.local_start)
+    assert_equal(Time.utc(2005,12,31,23,0,0), p.local_start_time)
+    assert_equal(DateTime.new(2006,1,1,23,0,0), p.local_end)
+    assert_equal(Time.utc(2006,1,1,23,0,0), p.local_end_time)
+  end
+  
+  def test_initialize_start_end_offset
+    std = TimezoneOffset.new(-7200, 0, :TEST)
+    dst = TimezoneOffset.new(-7200, 3600, :TEST)
+    special = TimezoneOffset.new(0, 0, :SPECIAL)
+    start_t = TestTimezoneTransition.new(dst, std, 1136073600)
+    end_t = TestTimezoneTransition.new(std, dst, 1136160000)
+      
+    assert_raises(ArgumentError) { TimezonePeriod.new(start_t, end_t, special) }
+  end
+  
+  def test_initialize_start
+    std = TimezoneOffset.new(-7200, 0, :TEST)
+    dst = TimezoneOffset.new(-7200, 3600, :TEST)
+    start_t = TestTimezoneTransition.new(dst, std, 1136073600)
+      
+    p = TimezonePeriod.new(start_t, nil)
+    
+    assert_same(start_t, p.start_transition)
+    assert_nil(p.end_transition)
+    assert_same(dst, p.offset)
+    assert_equal(DateTime.new(2006,1,1,0,0,0), p.utc_start)
+    assert_equal(Time.utc(2006,1,1,0,0,0), p.utc_start_time)
+    assert_nil(p.utc_end)
+    assert_nil(p.utc_end_time)
+    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(2005,12,31,23,0,0), p.local_start)
+    assert_equal(Time.utc(2005,12,31,23,0,0), p.local_start_time)
+    assert_nil(p.local_end)
+    assert_nil(p.local_end_time)
+  end
+  
+  def test_initialize_start_offset
+    std = TimezoneOffset.new(-7200, 0, :TEST)
+    dst = TimezoneOffset.new(-7200, 3600, :TEST)
+    special = TimezoneOffset.new(0, 0, :SPECIAL)
+    start_t = TestTimezoneTransition.new(dst, std, 1136073600)
+      
+    assert_raises(ArgumentError) { TimezonePeriod.new(start_t, nil, special) }
+  end
+  
+  def test_initialize_end
+    std = TimezoneOffset.new(-7200, 0, :TEST)
+    dst = TimezoneOffset.new(-7200, 3600, :TEST)    
+    end_t = TestTimezoneTransition.new(std, dst, 1136160000)
+      
+    p = TimezonePeriod.new(nil, end_t)
+    
+    assert_nil(p.start_transition)
+    assert_same(end_t, p.end_transition)
+    assert_same(dst, p.offset)
+    assert_nil(p.utc_start)
+    assert_nil(p.utc_start_time)
+    assert_equal(DateTime.new(2006,1,2,0,0,0), p.utc_end)
+    assert_equal(Time.utc(2006,1,2,0,0,0), p.utc_end_time)
+    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_nil(p.local_start)
+    assert_nil(p.local_start_time)
+    assert_equal(DateTime.new(2006,1,1,23,0,0), p.local_end)
+    assert_equal(Time.utc(2006,1,1,23,0,0), p.local_end_time)
+  end
+  
+  def test_initialize_end_offset
+    std = TimezoneOffset.new(-7200, 0, :TEST)
+    dst = TimezoneOffset.new(-7200, 3600, :TEST)    
+    special = TimezoneOffset.new(0, 0, :SPECIAL)
+    end_t = TestTimezoneTransition.new(std, dst, 1136160000)
+      
+    assert_raises(ArgumentError) { TimezonePeriod.new(nil, end_t, special) }    
+  end
+  
+  def test_initialize
+    assert_raises(ArgumentError) { TimezonePeriod.new(nil, nil) }
+  end
+  
+  def test_initialize_offset
+    special = TimezoneOffset.new(0, 0, :SPECIAL)
+      
+    p = TimezonePeriod.new(nil, nil, special)
+    
+    assert_nil(p.start_transition)
+    assert_nil(p.end_transition)
+    assert_same(special, p.offset)
+    assert_nil(p.utc_start)
+    assert_nil(p.utc_start_time)
+    assert_nil(p.utc_end)
+    assert_nil(p.utc_end_time)
+    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_start_time)
+    assert_nil(p.local_end)
+    assert_nil(p.local_end_time)
+  end
+
+  def test_utc_total_offset_rational_after_freeze
+    o = TimezoneOffset.new(3600, 0, :TEST)
+    p = TimezonePeriod.new(nil, nil, o)
+    p.freeze
+    assert_equal(Rational(1, 24), p.utc_total_offset_rational)
+  end
+  
+  def test_dst    
+    p1 = TimezonePeriod.new(nil, nil, TimezoneOffset.new(-14400, 3600, :TEST))
+    p2 = TimezonePeriod.new(nil, nil, TimezoneOffset.new(-14400, 0, :TEST))
+    p3 = TimezonePeriod.new(nil, nil, TimezoneOffset.new(-14400, -3600, :TEST))
+    p4 = TimezonePeriod.new(nil, nil, TimezoneOffset.new(-14400, 7200, :TEST))
+    p5 = TimezonePeriod.new(nil, nil, TimezoneOffset.new(-14400, -7200, :TEST))
+    
+    assert_equal(true, p1.dst?)
+    assert_equal(false, p2.dst?)
+    assert_equal(true, p3.dst?)
+    assert_equal(true, p4.dst?)
+    assert_equal(true, p5.dst?)
+  end
+  
+  def test_valid_for_utc
+    offset = TimezoneOffset.new(-7200, 3600, :TEST)
+    t1 = TestTimezoneTransition.new(offset, offset, 1104541261)
+    t2 = TestTimezoneTransition.new(offset, offset, 1107309722)
+    t3 = TestTimezoneTransition.new(offset, offset, DateTime.new(1960, 1, 1, 1, 1, 1))
+    t4 = TestTimezoneTransition.new(offset, offset, DateTime.new(1960, 2, 2, 2, 2, 2))
+    
+    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)))
+    assert_equal(true, p1.valid_for_utc?(1104541262))
+    assert_equal(true, p1.valid_for_utc?(DateTime.new(2005,2,2,2,2,0)))
+    assert_equal(false, p1.valid_for_utc?(DateTime.new(2005,1,1,1,1,0)))
+    assert_equal(false, p1.valid_for_utc?(DateTime.new(2005,2,2,2,2,3)))
+    assert_equal(false, p1.valid_for_utc?(DateTime.new(1960,1,1,1,1,0)))
+    assert_equal(false, p1.valid_for_utc?(DateTime.new(2040,1,1,1,1,0)))
+    
+    assert_equal(true, p2.valid_for_utc?(DateTime.new(2005,1,1,1,1,1)))
+    assert_equal(true, p2.valid_for_utc?(Time.utc(2005,2,2,2,2,1)))
+    assert_equal(true, p2.valid_for_utc?(1104541262))
+    assert_equal(true, p2.valid_for_utc?(DateTime.new(2005,2,2,2,2,0)))
+    assert_equal(true, p2.valid_for_utc?(DateTime.new(2005,1,1,1,1,0)))    
+    assert_equal(false, p2.valid_for_utc?(DateTime.new(2005,2,2,2,2,3)))
+    assert_equal(true, p2.valid_for_utc?(DateTime.new(1960,1,1,1,1,0)))
+    assert_equal(false, p2.valid_for_utc?(DateTime.new(2040,1,1,1,1,0)))
+    
+    assert_equal(true, p3.valid_for_utc?(DateTime.new(2005,1,1,1,1,1)))
+    assert_equal(true, p3.valid_for_utc?(Time.utc(2005,2,2,2,2,1)))
+    assert_equal(true, p3.valid_for_utc?(1104541262))
+    assert_equal(true, p3.valid_for_utc?(DateTime.new(2005,2,2,2,2,0)))
+    assert_equal(false, p3.valid_for_utc?(DateTime.new(2005,1,1,1,1,0)))
+    assert_equal(true, p3.valid_for_utc?(DateTime.new(2005,2,2,2,2,3)))
+    assert_equal(false, p3.valid_for_utc?(DateTime.new(1960,1,1,1,1,0)))
+    assert_equal(true, p3.valid_for_utc?(DateTime.new(2040,1,1,1,1,0)))
+    
+    assert_equal(true, p4.valid_for_utc?(DateTime.new(2005,1,1,1,1,1)))
+    assert_equal(true, p4.valid_for_utc?(Time.utc(2005,2,2,2,2,1)))
+    assert_equal(true, p4.valid_for_utc?(1104541262))
+    assert_equal(true, p4.valid_for_utc?(DateTime.new(2005,2,2,2,2,0)))
+    assert_equal(true, p4.valid_for_utc?(DateTime.new(2005,1,1,1,1,0)))
+    assert_equal(true, p4.valid_for_utc?(DateTime.new(2005,2,2,2,2,3)))
+    assert_equal(true, p4.valid_for_utc?(DateTime.new(1960,1,1,1,1,0)))
+    assert_equal(true, p4.valid_for_utc?(DateTime.new(2040,1,1,1,1,0)))
+    
+    assert_equal(false, p5.valid_for_utc?(Time.utc(2005,1,1,1,1,1)))
+    assert_equal(false, p5.valid_for_utc?(1104541262))
+  end
+  
+  def test_utc_after_start
+    offset = TimezoneOffset.new(-7200, 3600, :TEST)
+    t1 = TestTimezoneTransition.new(offset, offset, 1104541261)
+    t2 = TestTimezoneTransition.new(offset, offset, 1107309722)
+    t3 = TestTimezoneTransition.new(offset, offset, DateTime.new(1945, 1, 1, 1, 1, 1))
+    t4 = TestTimezoneTransition.new(offset, offset, DateTime.new(1945, 2, 2, 2, 2, 2))
+    
+    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)))
+    assert_equal(false, p1.utc_after_start?(1104541260))
+    assert_equal(true, p1.utc_after_start?(DateTime.new(2045,1,1,1,1,0)))
+    assert_equal(false, p1.utc_after_start?(DateTime.new(1955,1,1,1,1,0)))
+
+    assert_equal(true, p2.utc_after_start?(DateTime.new(2005,1,1,1,1,1)))    
+    assert_equal(true, p2.utc_after_start?(Time.utc(2005,1,1,1,1,2)))
+    assert_equal(true, p2.utc_after_start?(1104541260)) 
+    
+    assert_equal(true, p3.utc_after_start?(Time.utc(2005,1,2,1,1,1)))
+    assert_equal(true, p3.utc_after_start?(1104627661))
+  end
+  
+  def test_utc_before_end
+    offset = TimezoneOffset.new(-7200, 3600, :TEST)
+    t1 = TestTimezoneTransition.new(offset, offset, 1104541261)
+    t2 = TestTimezoneTransition.new(offset, offset, 1107309722)
+    t3 = TestTimezoneTransition.new(offset, offset, DateTime.new(1945, 1, 1, 1, 1, 1))
+    t4 = TestTimezoneTransition.new(offset, offset, DateTime.new(1945, 2, 2, 2, 2, 2))
+    
+    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))
+    assert_equal(false, p1.utc_before_end?(DateTime.new(2045,1,1,1,1,0)))
+    assert_equal(true, p1.utc_before_end?(DateTime.new(1955,1,1,1,1,0)))
+    
+    assert_equal(true, p2.utc_before_end?(DateTime.new(2005,2,2,2,2,1)))    
+    assert_equal(true, p2.utc_before_end?(Time.utc(2005,2,2,2,2,0)))   
+    assert_equal(true, p2.utc_before_end?(1107309723))
+    
+    assert_equal(false, p3.utc_before_end?(Time.utc(2005,1,2,1,1,1)))
+    assert_equal(false, p3.utc_before_end?(1104627661))
+  end
+  
+  def test_valid_for_local
+    offset = TimezoneOffset.new(-7200, 3600, :TEST)
+    t1 = TestTimezoneTransition.new(offset, offset, 1104544861)
+    t2 = TestTimezoneTransition.new(offset, offset, 1107313322)
+    t3 = TestTimezoneTransition.new(offset, offset, 1104544861)
+    t4 = TestTimezoneTransition.new(offset, offset, DateTime.new(1960, 1, 1, 1, 1, 1))
+    t5 = TestTimezoneTransition.new(offset, offset, DateTime.new(1960, 2, 2, 2, 2, 2))
+    
+    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)))
+    assert_equal(true, p1.valid_for_local?(1104541262))
+    assert_equal(true, p1.valid_for_local?(DateTime.new(2005,2,2,2,2,0)))
+    assert_equal(false, p1.valid_for_local?(DateTime.new(2005,1,1,1,1,0)))
+    assert_equal(false, p1.valid_for_local?(DateTime.new(2005,2,2,2,2,3)))
+    assert_equal(false, p1.valid_for_local?(DateTime.new(1960,1,1,1,1,0)))
+    assert_equal(false, p1.valid_for_local?(DateTime.new(2040,1,1,1,1,0)))
+    
+    assert_equal(true, p2.valid_for_local?(DateTime.new(2005,1,1,1,1,1)))
+    assert_equal(true, p2.valid_for_local?(DateTime.new(2005,2,2,2,2,1)))
+    assert_equal(true, p2.valid_for_local?(1104541262))
+    assert_equal(true, p2.valid_for_local?(DateTime.new(2005,2,2,2,2,0)))
+    assert_equal(true, p2.valid_for_local?(DateTime.new(2005,1,1,1,1,0)))
+    assert_equal(false, p2.valid_for_local?(DateTime.new(2005,2,2,2,2,3)))
+    assert_equal(true, p2.valid_for_local?(DateTime.new(1960,1,1,1,1,0)))
+    assert_equal(false, p2.valid_for_local?(DateTime.new(2040,1,1,1,1,0)))
+    
+    assert_equal(true, p3.valid_for_local?(DateTime.new(2005,1,1,1,1,1)))
+    assert_equal(true, p3.valid_for_local?(DateTime.new(2005,2,2,2,2,1)))
+    assert_equal(true, p3.valid_for_local?(1104541262))
+    assert_equal(true, p3.valid_for_local?(DateTime.new(2005,2,2,2,2,0)))
+    assert_equal(false, p3.valid_for_local?(DateTime.new(2005,1,1,1,1,0)))
+    assert_equal(true, p3.valid_for_local?(DateTime.new(2005,2,2,2,2,3)))
+    assert_equal(false, p3.valid_for_local?(DateTime.new(1960,1,1,1,1,0)))
+    assert_equal(true, p3.valid_for_local?(DateTime.new(2040,1,1,1,1,0)))
+    
+    assert_equal(true, p4.valid_for_local?(DateTime.new(2005,1,1,1,1,1)))
+    assert_equal(true, p4.valid_for_local?(DateTime.new(2005,2,2,2,2,1)))
+    assert_equal(true, p4.valid_for_local?(1104541262))
+    assert_equal(true, p4.valid_for_local?(DateTime.new(2005,2,2,2,2,0)))
+    assert_equal(true, p4.valid_for_local?(DateTime.new(2005,1,1,1,1,0)))
+    assert_equal(true, p4.valid_for_local?(DateTime.new(2005,2,2,2,2,3)))
+    assert_equal(true, p4.valid_for_local?(DateTime.new(1960,1,1,1,1,0)))
+    assert_equal(true, p4.valid_for_local?(DateTime.new(2040,1,1,1,1,0)))
+    
+    assert_equal(false, p5.valid_for_utc?(Time.utc(2005,1,1,1,1,1)))
+    assert_equal(false, p5.valid_for_utc?(1104541262))
+  end
+  
+  def test_local_after_start
+    offset = TimezoneOffset.new(-7200, 3600, :TEST)
+    t1 = TestTimezoneTransition.new(offset, offset, 1104544861)
+    t2 = TestTimezoneTransition.new(offset, offset, 1107313322)
+    t3 = TestTimezoneTransition.new(offset, offset, DateTime.new(1945, 1, 1, 1, 1, 1))
+    t4 = TestTimezoneTransition.new(offset, offset, DateTime.new(1945, 2, 2, 2, 2, 2))
+    
+    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)))
+    assert_equal(false, p1.local_after_start?(1104541260))
+    assert_equal(true, p1.local_after_start?(DateTime.new(2045,1,1,1,1,0)))
+    assert_equal(false, p1.local_after_start?(DateTime.new(1955,1,1,1,1,0)))
+
+    assert_equal(true, p2.local_after_start?(DateTime.new(2005,1,1,1,1,1)))    
+    assert_equal(true, p2.local_after_start?(Time.utc(2005,1,1,1,1,2)))
+    assert_equal(true, p2.local_after_start?(1104541260))    
+    
+    assert_equal(true, p3.local_after_start?(Time.utc(2005,1,2,1,1,1)))
+    assert_equal(true, p3.local_after_start?(1104627661))
+  end
+  
+  def test_local_before_end
+    offset = TimezoneOffset.new(-7200, 3600, :TEST)
+    t1 = TestTimezoneTransition.new(offset, offset, 1104544861)
+    t2 = TestTimezoneTransition.new(offset, offset, 1107313322)
+    t3 = TestTimezoneTransition.new(offset, offset, DateTime.new(1945, 1, 1, 1, 1, 1))
+    t4 = TestTimezoneTransition.new(offset, offset, DateTime.new(1945, 2, 2, 2, 2, 2))
+    
+    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)))   
+    assert_equal(false, p1.local_before_end?(1107309723))
+    assert_equal(false, p1.local_before_end?(DateTime.new(2045,1,1,1,1,0)))
+    assert_equal(true, p1.local_before_end?(DateTime.new(1955,1,1,1,1,0)))
+    
+    assert_equal(true, p2.local_before_end?(DateTime.new(2005,2,2,2,2,1)))    
+    assert_equal(true, p2.local_before_end?(Time.utc(2005,2,2,2,2,0)))   
+    assert_equal(true, p2.local_before_end?(1107309723))
+    
+    assert_equal(false, p3.local_before_end?(Time.utc(2005,1,2,1,1,1)))
+    assert_equal(false, p3.local_before_end?(1104627661))
+  end
+  
+  def test_to_local
+    p1 = TimezonePeriod.new(nil, nil, TimezoneOffset.new(-14400, 3600, :TEST))
+    p2 = TimezonePeriod.new(nil, nil, TimezoneOffset.new(-14400, 0, :TEST))
+    p3 = TimezonePeriod.new(nil, nil, TimezoneOffset.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(DateTime.new(2005,1,19,22,0,0 + Rational(512,1000)), p1.to_local(DateTime.new(2005,1,20,1,0,0 + Rational(512,1000))))
+    assert_equal(Time.utc(2005,1,19,21,0,0), p2.to_local(Time.utc(2005,1,20,1,0,0)))
+    assert_equal(Time.utc(2005,1,19,21,0,0,512000), p2.to_local(Time.utc(2005,1,20,1,0,0,512000)))
+    assert_equal(1106193600, p3.to_local(1106182800))
+  end
+  
+  def test_to_utc
+    p1 = TimezonePeriod.new(nil, nil, TimezoneOffset.new(-14400, 3600, :TEST))
+    p2 = TimezonePeriod.new(nil, nil, TimezoneOffset.new(-14400, 0, :TEST))
+    p3 = TimezonePeriod.new(nil, nil, TimezoneOffset.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(DateTime.new(2005,1,20,4,0,0 + Rational(571,1000)), p1.to_utc(DateTime.new(2005,1,20,1,0,0 + Rational(571,1000))))
+    assert_equal(Time.utc(2005,1,20,5,0,0), p2.to_utc(Time.utc(2005,1,20,1,0,0)))
+    assert_equal(Time.utc(2005,1,20,5,0,0,571000), p2.to_utc(Time.utc(2005,1,20,1,0,0,571000)))
+    assert_equal(1106172000, p3.to_utc(1106182800))
+  end
+  
+  def test_time_boundary_start
+    o1 = TimezoneOffset.new(-3600, 0, :TEST)
+    o2 = TimezoneOffset.new(-3600, 3600, :TEST)
+    t1 = TestTimezoneTransition.new(o1, o2, 0)
+    
+    p1 = TimezonePeriod.new(t1, nil)
+    
+    assert_equal(DateTime.new(1969,12,31,23,0,0), p1.local_start)
+    
+    # Conversion to Time will fail on systems that don't support negative times.
+    if RubyCoreSupport.time_supports_negative
+      assert_equal(Time.utc(1969,12,31,23,0,0), p1.local_start_time)
+    end
+  end
+  
+  def test_time_boundary_end
+    o1 = TimezoneOffset.new(0, 3600, :TEST)
+    o2 = TimezoneOffset.new(0, 0, :TEST)
+    t1 = TestTimezoneTransition.new(o2, o1, 2147482800)
+    
+    p1 = TimezonePeriod.new(nil, t1)
+    
+    assert_equal(DateTime.new(2038,1,19,4,0,0), p1.local_end)
+    
+    # Conversion to Time will fail on systems that don't support 64-bit times
+    if RubyCoreSupport.time_supports_64bit
+      assert_equal(Time.utc(2038,1,19,4,0,0), p1.local_end_time)
+    end
+  end
+  
+  def test_equality
+    o1 = TimezoneOffset.new(0, 3600, :TEST)
+    o2 = TimezoneOffset.new(0, 0, :TEST)
+    t1 = TestTimezoneTransition.new(o1, o2, 1149368400)
+    t2 = TestTimezoneTransition.new(o1, o2, DateTime.new(2006, 6, 3, 21, 0, 0))
+    t3 = TestTimezoneTransition.new(o1, o2, 1149454800)
+    t4 = TestTimezoneTransition.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 = TimezoneOffset.new(0, 3600, :TEST)
+    o2 = TimezoneOffset.new(0, 0, :TEST)
+    t1 = TestTimezoneTransition.new(o1, o2, 1149368400)
+    t2 = TestTimezoneTransition.new(o1, o2, DateTime.new(2006, 6, 3, 21, 0, 0))
+    t3 = TestTimezoneTransition.new(o1, o2, 1149454800)
+    t4 = TestTimezoneTransition.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 = TimezoneOffset.new(0, 3600, :TEST)
+    o2 = TimezoneOffset.new(0, 0, :TEST)
+    t1 = TestTimezoneTransition.new(o1, o2, 1149368400)
+    t2 = TestTimezoneTransition.new(o1, o2, DateTime.new(2006, 6, 3, 21, 0, 0))
+    t3 = TestTimezoneTransition.new(o1, o2, 1149454800)
+    t4 = TestTimezoneTransition.new(o1, o2, 1149541200)
+    
+    p1 = TimezonePeriod.new(t1, t3)    
+    p2 = TimezonePeriod.new(t2, nil)
+    p3 = TimezonePeriod.new(nil, t4)
+    p4 = TimezonePeriod.new(nil, nil, o1)
+
+    assert_equal(t1.hash ^ t3.hash, p1.hash)
+    assert_equal(t2.hash ^ nil.hash, p2.hash)
+    assert_equal(nil.hash ^ t4.hash, p3.hash)
+    assert_equal(nil.hash ^ nil.hash ^ o1.hash, p4.hash)    
+  end
+end