tzinfo 0.0.4 → 0.1.0

data/test/tc_timezone.rb

@@ -4,6 +4,9 @@ require 'tzinfo/timezone'
 
 include TZInfo
 
+class TCTimezoneBlockCalled < StandardError
+end
+
 class TCTimezone < Test::Unit::TestCase
   def test_get_valid_1
     tz = Timezone.get('Europe/London')
@@ -67,8 +70,9 @@ class TCTimezone < Test::Unit::TestCase
   end
   
   def test_get_case    
+    Timezone.get('Europe/Prague')
     assert_raise(InvalidTimezoneIdentifier) {
-      Timezone.get('Europe/london')
+      Timezone.get('Europe/prague')
     }
   end
   
@@ -195,6 +199,129 @@ class TCTimezone < Test::Unit::TestCase
     assert_equal('UTC', Timezone.get('UTC').to_s)
   end    
   
+  def test_period_for_utc
+    dt = DateTime.new(2005,2,18,16,24,23)
+    t = Time.utc(2005,2,18,16,24,23)
+        
+    dt_period = Timezone.get('Europe/London').period_for_utc(dt)
+    t_period = Timezone.get('Europe/London').period_for_utc(t)
+    
+    assert_equal(DateTime.new(2004,10,31,1,0,0), dt_period.utc_start)
+    assert_equal(DateTime.new(2005,3,27,1,0,0), dt_period.utc_end)
+    
+    assert_equal(DateTime.new(2004,10,31,1,0,0), t_period.utc_start)
+    assert_equal(DateTime.new(2005,3,27,1,0,0), t_period.utc_end)
+  end
+  
+  def test_period_for_local
+    dt = DateTime.new(2005,2,18,16,24,23)
+    t = Time.utc(2005,2,18,16,24,23)
+    
+    dt_period = Timezone.get('Europe/London').period_for_local(dt)
+    t_period = Timezone.get('Europe/London').period_for_local(t)
+    
+    assert_equal(DateTime.new(2004,10,31,1,0,0), dt_period.utc_start)
+    assert_equal(DateTime.new(2005,3,27,1,0,0), dt_period.utc_end)
+    
+    assert_equal(DateTime.new(2004,10,31,1,0,0), t_period.utc_start)
+    assert_equal(DateTime.new(2005,3,27,1,0,0), t_period.utc_end)
+  end
+  
+  def test_period_for_local_invalid
+    assert_raise(PeriodNotFound) {
+      Timezone.get('America/New_York').period_for_local(DateTime.new(2004,4,4,2,30,0))
+    }
+  end
+  
+  def test_period_for_local_ambiguous
+    assert_raise(AmbiguousTime) {
+      Timezone.get('America/New_York').period_for_local(DateTime.new(2004,10,31,1,30,0))
+    }
+  end
+  
+  def test_period_for_local_dst_flag_resolved
+    dt = DateTime.new(2004,10,31,1,30,0)
+    tz = Timezone.get('America/New_York')
+    
+    assert_period_for(DateTime.new(2004,4,4,7,0,0), DateTime.new(2004,10,31,6,0,0), true, tz.period_for_local(dt, true))
+    assert_period_for(DateTime.new(2004,10,31,6,0,0), DateTime.new(2005,4,3,7,0,0), false, tz.period_for_local(dt, false))
+    assert_period_for(DateTime.new(2004,4,4,7,0,0), DateTime.new(2004,10,31,6,0,0), true, tz.period_for_local(dt, true) {|periods| raise TCTimezoneBlockCalled, 'should not be called' })
+    assert_period_for(DateTime.new(2004,10,31,6,0,0), DateTime.new(2005,4,3,7,0,0), false, tz.period_for_local(dt, false) {|periods| raise TCTimezoneBlockCalled, 'should not be called' })
+  end
+  
+  def test_period_for_local_dst_block_called
+    dt = DateTime.new(2004,10,31,1,30,0)
+    tz = Timezone.get('America/New_York')
+    
+    assert_raise(TCTimezoneBlockCalled) {
+      tz.period_for_local(dt) {|periods|
+        assert_equal(2, periods.size)
+        assert_period_for(DateTime.new(2004,4,4,7,0,0), DateTime.new(2004,10,31,6,0,0), true, periods[0])
+        assert_period_for(DateTime.new(2004,10,31,6,0,0), DateTime.new(2005,4,3,7,0,0), false, periods[1])
+        
+        # raise exception to test that the block was called
+        raise TCTimezoneBlockCalled, 'should be raised'
+      }
+    }
+    
+    assert_period_for(DateTime.new(2004,4,4,7,0,0), DateTime.new(2004,10,31,6,0,0), true, tz.period_for_local(dt) {|periods| periods.first})
+    assert_period_for(DateTime.new(2004,10,31,6,0,0), DateTime.new(2005,4,3,7,0,0), false,  tz.period_for_local(dt) {|periods| periods.last})
+    assert_period_for(DateTime.new(2004,4,4,7,0,0), DateTime.new(2004,10,31,6,0,0), true, tz.period_for_local(dt) {|periods| [periods.first]})
+    assert_period_for(DateTime.new(2004,10,31,6,0,0), DateTime.new(2005,4,3,7,0,0), false,  tz.period_for_local(dt) {|periods| [periods.last]})
+  end
+  
+  def test_period_for_local_dst_cannot_resolve
+    # At midnight local time on Aug 5 1915 in Warsaw, the clocks were put back
+    # 24 minutes and both periods were non-DST. Hence the block should be
+    # called regardless of the value of the Boolean dst parameter.
+    
+    dt = DateTime.new(1915,8,4,23,40,0)
+    tz = Timezone.get('Europe/Warsaw')
+    
+    assert_raise(TCTimezoneBlockCalled) {
+      tz.period_for_local(dt, true) {|periods|
+        assert_equal(2, periods.size)
+        assert_equal(DateTime.new(1915,8,4,22,36,0), periods[0].utc_end)        
+        assert_equal(false, periods[0].dst?)        
+        assert_period_for(DateTime.new(1915,8,4,22,36,0), DateTime.new(1916,4,30,22,0,0), false, periods[1])
+        
+        raise TCTimezoneBlockCalled, 'should be raised'
+      }
+    }
+    
+    assert_raise(TCTimezoneBlockCalled) {
+      tz.period_for_local(dt, false) {|periods|
+        assert_equal(2, periods.size)
+        assert_equal(DateTime.new(1915,8,4,22,36,0), periods[0].utc_end)        
+        assert_equal(false, periods[0].dst?)        
+        assert_period_for(DateTime.new(1915,8,4,22,36,0), DateTime.new(1916,4,30,22,0,0), false, periods[1])
+        
+        raise TCTimezoneBlockCalled, 'should be raised'
+      }
+    }    
+  end
+  
+  def test_period_for_local_block_ambiguous
+    dt = DateTime.new(2004,10,31,1,30,0)
+    tz = Timezone.get('America/New_York')
+    
+    assert_raise(AmbiguousTime) {
+      tz.period_for_local(dt) {|periods| nil}
+    }
+    
+    assert_raise(AmbiguousTime) {
+      tz.period_for_local(dt) {|periods| periods}
+    }
+    
+    assert_raise(AmbiguousTime) {
+      tz.period_for_local(dt) {|periods| []}
+    }
+    
+    assert_raise(AmbiguousTime) {
+      tz.period_for_local(dt) {|periods| raise AmbiguousTime, 'Ambiguous time'}
+    }
+  end
+   
   def test_utc_to_local
     dt = DateTime.new(2005,2,18,16,24,23)
     t = Time.utc(2005,2,18,16,24,23)
@@ -215,6 +342,102 @@ class TCTimezone < Test::Unit::TestCase
     assert_not_equal(dt, Timezone.get('Europe/London').local_to_utc(t))
   end
   
+  def test_local_to_utc_invalid
+    assert_raise(PeriodNotFound) {
+      Timezone.get('America/New_York').local_to_utc(DateTime.new(2004,4,4,2,30,0))
+    }
+  end
+  
+  def test_local_to_utc_ambiguous
+    assert_raise(AmbiguousTime) {
+      Timezone.get('America/New_York').local_to_utc(DateTime.new(2004,10,31,1,30,0))
+    }
+  end
+  
+  def test_local_to_utc_dst_flag_resolved
+    dt = DateTime.new(2004,10,31,1,30,0)
+    tz = Timezone.get('America/New_York')
+    
+    assert_equal(DateTime.new(2004,10,31,5,30,0), tz.local_to_utc(dt, true))
+    assert_equal(DateTime.new(2004,10,31,6,30,0), tz.local_to_utc(dt, false))
+    assert_equal(DateTime.new(2004,10,31,5,30,0), tz.local_to_utc(dt, true) {|periods| raise TCTimezoneBlockCalled, 'should not be called' })
+    assert_equal(DateTime.new(2004,10,31,6,30,0), tz.local_to_utc(dt, false) {|periods| raise TCTimezoneBlockCalled, 'should not be called' })
+  end
+  
+  def test_local_to_utc_dst_block_called
+    dt = DateTime.new(2004,10,31,1,30,0)
+    tz = Timezone.get('America/New_York')
+    
+    assert_raise(TCTimezoneBlockCalled) {
+      tz.local_to_utc(dt) {|periods|
+        assert_equal(2, periods.size)
+        assert_period_for(DateTime.new(2004,4,4,7,0,0), DateTime.new(2004,10,31,6,0,0), true, periods[0])
+        assert_period_for(DateTime.new(2004,10,31,6,0,0), DateTime.new(2005,4,3,7,0,0), false, periods[1])        
+        
+        # raise exception to test that the block was called
+        raise TCTimezoneBlockCalled, 'should be raised'
+      }
+    }
+    
+    assert_equal(DateTime.new(2004,10,31,5,30,0), tz.local_to_utc(dt) {|periods| periods.first})
+    assert_equal(DateTime.new(2004,10,31,6,30,0), tz.local_to_utc(dt) {|periods| periods.last})
+  end
+  
+  def test_local_to_utc_dst_cannot_resolve
+    # At midnight local time on Aug 5 1915 in Warsaw, the clocks were put back
+    # 24 minutes and both periods were non-DST. Hence the block should be
+    # called regardless of the value of the Boolean dst parameter.
+    
+    dt = DateTime.new(1915,8,4,23,40,0)
+    tz = Timezone.get('Europe/Warsaw')
+    
+    assert_raise(TCTimezoneBlockCalled) {
+      tz.local_to_utc(dt, true) {|periods|
+        assert_equal(2, periods.size)
+        assert_equal(DateTime.new(1915,8,4,22,36,0), periods[0].utc_end)        
+        assert_equal(false, periods[0].dst?)        
+        assert_period_for(DateTime.new(1915,8,4,22,36,0), DateTime.new(1916,4,30,22,0,0), false, periods[1])
+        
+        raise TCTimezoneBlockCalled, 'should be raised'
+      }
+    }
+    
+    assert_raise(TCTimezoneBlockCalled) {
+      tz.local_to_utc(dt, false) {|periods|
+        assert_equal(2, periods.size)
+        assert_equal(DateTime.new(1915,8,4,22,36,0), periods[0].utc_end)        
+        assert_equal(false, periods[0].dst?)        
+        assert_period_for(DateTime.new(1915,8,4,22,36,0), DateTime.new(1916,4,30,22,0,0), false, periods[1])
+        
+        raise TCTimezoneBlockCalled, 'should be raised'
+      }
+    }
+    
+    assert_equal(DateTime.new(1915,8,4,22,16,0), tz.local_to_utc(dt) {|periods| periods.first})
+    assert_equal(DateTime.new(1915,8,4,22,40,0), tz.local_to_utc(dt) {|periods| periods.last})
+  end
+  
+  def test_local_to_utc_block_ambiguous
+    dt = DateTime.new(2004,10,31,1,30,0)
+    tz = Timezone.get('America/New_York')
+    
+    assert_raise(AmbiguousTime) {
+      tz.local_to_utc(dt) {|periods| nil}
+    }
+    
+    assert_raise(AmbiguousTime) {
+      tz.local_to_utc(dt) {|periods| periods}
+    } 
+    
+    assert_raise(AmbiguousTime) {
+      tz.local_to_utc(dt) {|periods| []}
+    }
+    
+    assert_raise(AmbiguousTime) {
+      tz.local_to_utc(dt) {|periods| raise AmbiguousTime, 'Ambiguous time'}
+    }
+  end
+  
   def test_now
     assert_kind_of(Time, Timezone.get('Europe/London').now)
   end
@@ -259,4 +482,11 @@ class TCTimezone < Test::Unit::TestCase
     assert((Timezone.get('America/New_York') <=> Timezone.get('Europe/Paris')) < 0)
     assert((Timezone.get('Europe/Paris') <=> Timezone.get('America/New_York')) > 0)
   end
+  
+  private
+    def assert_period_for(utc_start, utc_end, dst, period)
+      assert_equal(utc_start, period.utc_start)
+      assert_equal(utc_end, period.utc_end)
+      assert_equal(dst, period.dst?)
+    end
 end

data/test/tc_timezone_london.rb

@@ -19,10 +19,13 @@ class TCTimezoneLondon < Test::Unit::TestCase
     
     assert_equal(DateTime.new(2004,3,28,0,59,59), tz.local_to_utc(DateTime.new(2004,3,28,0,59,59)))
     assert_equal(DateTime.new(2004,3,28,1,0,0), tz.local_to_utc(DateTime.new(2004,3,28,2,0,0)))
-    assert_equal(DateTime.new(2004,10,31,0,59,59), tz.local_to_utc(DateTime.new(2004,10,31,1,59,59)))
-    assert_equal(DateTime.new(2004,10,31,0,0,0), tz.local_to_utc(DateTime.new(2004,10,31,1,0,0))) # returns first possible utc time
+    assert_equal(DateTime.new(2004,10,31,0,59,59), tz.local_to_utc(DateTime.new(2004,10,31,1,59,59), true))
+    assert_equal(DateTime.new(2004,10,31,1,59,59), tz.local_to_utc(DateTime.new(2004,10,31,1,59,59), false))
+    assert_equal(DateTime.new(2004,10,31,0,0,0), tz.local_to_utc(DateTime.new(2004,10,31,1,0,0), true))
+    assert_equal(DateTime.new(2004,10,31,1,0,0), tz.local_to_utc(DateTime.new(2004,10,31,1,0,0), false))
     
     assert_raise(PeriodNotFound) { tz.local_to_utc(DateTime.new(2004,3,28,1,0,0)) }
+    assert_raise(AmbiguousTime) { tz.local_to_utc(DateTime.new(2004,10,31,1,0,0)) }
     
     assert_equal(:GMT, tz.period_for_utc(DateTime.new(2004,3,28,0,59,59)).zone_identifier)
     assert_equal(:BST, tz.period_for_utc(DateTime.new(2004,3,28,1,0,0)).zone_identifier)
@@ -31,8 +34,10 @@ class TCTimezoneLondon < Test::Unit::TestCase
     
     assert_equal(:GMT, tz.period_for_local(DateTime.new(2004,3,28,0,59,59)).zone_identifier)
     assert_equal(:BST, tz.period_for_local(DateTime.new(2004,3,28,2,0,0)).zone_identifier)
-    assert_equal(:BST, tz.period_for_local(DateTime.new(2004,10,31,1,59,59)).zone_identifier)
-    assert_equal(:BST, tz.period_for_local(DateTime.new(2004,10,31,1,0,0)).zone_identifier)
+    assert_equal(:BST, tz.period_for_local(DateTime.new(2004,10,31,1,59,59), true).zone_identifier)
+    assert_equal(:GMT, tz.period_for_local(DateTime.new(2004,10,31,1,59,59), false).zone_identifier)
+    assert_equal(:BST, tz.period_for_local(DateTime.new(2004,10,31,1,0,0), true).zone_identifier)
+    assert_equal(:GMT, tz.period_for_local(DateTime.new(2004,10,31,1,0,0), false).zone_identifier)
     
     assert_equal(0, tz.period_for_utc(DateTime.new(2004,3,28,0,59,59)).utc_total_offset)
     assert_equal(3600, tz.period_for_utc(DateTime.new(2004,3,28,1,0,0)).utc_total_offset)
@@ -41,7 +46,9 @@ class TCTimezoneLondon < Test::Unit::TestCase
     
     assert_equal(0, tz.period_for_local(DateTime.new(2004,3,28,0,59,59)).utc_total_offset)
     assert_equal(3600, tz.period_for_local(DateTime.new(2004,3,28,2,0,0)).utc_total_offset)
-    assert_equal(3600, tz.period_for_local(DateTime.new(2004,10,31,1,59,59)).utc_total_offset)
-    assert_equal(3600, tz.period_for_local(DateTime.new(2004,10,31,1,0,0)).utc_total_offset)
+    assert_equal(3600, tz.period_for_local(DateTime.new(2004,10,31,1,59,59), true).utc_total_offset)
+    assert_equal(0, tz.period_for_local(DateTime.new(2004,10,31,1,59,59), false).utc_total_offset)
+    assert_equal(3600, tz.period_for_local(DateTime.new(2004,10,31,1,0,0), true).utc_total_offset)
+    assert_equal(0, tz.period_for_local(DateTime.new(2004,10,31,1,0,0), false).utc_total_offset)
   end    
 end

data/test/tc_timezone_melbourne.rb

@@ -17,20 +17,25 @@ class TCTimezoneMelbourne < Test::Unit::TestCase
     assert_equal(DateTime.new(2004,10,31,1,59,59), tz.utc_to_local(DateTime.new(2004,10,30,15,59,59)))
     assert_equal(DateTime.new(2004,10,31,3,0,0), tz.utc_to_local(DateTime.new(2004,10,30,16,0,0)))
     
-    assert_equal(DateTime.new(2004,3,27,15,59,59), tz.local_to_utc(DateTime.new(2004,3,28,2,59,59)))
-    assert_equal(DateTime.new(2004,3,27,15,0,0), tz.local_to_utc(DateTime.new(2004,3,28,2,0,0))) # returns first possible utc time
+    assert_equal(DateTime.new(2004,3,27,15,59,59), tz.local_to_utc(DateTime.new(2004,3,28,2,59,59), true))
+    assert_equal(DateTime.new(2004,3,27,16,59,59), tz.local_to_utc(DateTime.new(2004,3,28,2,59,59), false))
+    assert_equal(DateTime.new(2004,3,27,15,0,0), tz.local_to_utc(DateTime.new(2004,3,28,2,0,0), true))
+    assert_equal(DateTime.new(2004,3,27,16,0,0), tz.local_to_utc(DateTime.new(2004,3,28,2,0,0), false))   
     assert_equal(DateTime.new(2004,10,30,15,59,59), tz.local_to_utc(DateTime.new(2004,10,31,1,59,59)))
     assert_equal(DateTime.new(2004,10,30,16,0,0), tz.local_to_utc(DateTime.new(2004,10,31,3,0,0)))
     
     assert_raise(PeriodNotFound) { tz.local_to_utc(DateTime.new(2004,10,31,2,0,0)) }
+    assert_raise(AmbiguousTime) { tz.local_to_utc(DateTime.new(2004,3,28,2,0,0)) }
     
     assert_equal(:EST, tz.period_for_utc(DateTime.new(2004,3,27,15,59,59)).zone_identifier)
     assert_equal(:EST, tz.period_for_utc(DateTime.new(2004,3,27,16,0,0)).zone_identifier)
     assert_equal(:EST, tz.period_for_utc(DateTime.new(2004,10,30,15,59,59)).zone_identifier)
     assert_equal(:EST, tz.period_for_utc(DateTime.new(2004,10,30,16,0,0)).zone_identifier)
     
-    assert_equal(:EST, tz.period_for_local(DateTime.new(2004,3,28,2,59,59)).zone_identifier)
-    assert_equal(:EST, tz.period_for_local(DateTime.new(2004,3,28,2,0,0)).zone_identifier)
+    assert_equal(:EST, tz.period_for_local(DateTime.new(2004,3,28,2,59,59), true).zone_identifier)
+    assert_equal(:EST, tz.period_for_local(DateTime.new(2004,3,28,2,59,59), false).zone_identifier)
+    assert_equal(:EST, tz.period_for_local(DateTime.new(2004,3,28,2,0,0), true).zone_identifier)
+    assert_equal(:EST, tz.period_for_local(DateTime.new(2004,3,28,2,0,0), false).zone_identifier)
     assert_equal(:EST, tz.period_for_local(DateTime.new(2004,10,31,1,59,59)).zone_identifier)
     assert_equal(:EST, tz.period_for_local(DateTime.new(2004,10,31,3,0,0)).zone_identifier)
     
@@ -39,8 +44,10 @@ class TCTimezoneMelbourne < Test::Unit::TestCase
     assert_equal(36000, tz.period_for_utc(DateTime.new(2004,10,30,15,59,59)).utc_total_offset)
     assert_equal(39600, tz.period_for_utc(DateTime.new(2004,10,30,16,0,0)).utc_total_offset)
     
-    assert_equal(39600, tz.period_for_local(DateTime.new(2004,3,28,2,59,59)).utc_total_offset)
-    assert_equal(39600, tz.period_for_local(DateTime.new(2004,3,28,2,0,0)).utc_total_offset)
+    assert_equal(39600, tz.period_for_local(DateTime.new(2004,3,28,2,59,59), true).utc_total_offset)
+    assert_equal(36000, tz.period_for_local(DateTime.new(2004,3,28,2,59,59), false).utc_total_offset)
+    assert_equal(39600, tz.period_for_local(DateTime.new(2004,3,28,2,0,0), true).utc_total_offset)
+    assert_equal(36000, tz.period_for_local(DateTime.new(2004,3,28,2,0,0), false).utc_total_offset)
     assert_equal(36000, tz.period_for_local(DateTime.new(2004,10,31,1,59,59)).utc_total_offset)
     assert_equal(39600, tz.period_for_local(DateTime.new(2004,10,31,3,0,0)).utc_total_offset)
   end    

data/test/tc_timezone_new_york.rb

@@ -19,10 +19,13 @@ class TCTimezoneNewYork < Test::Unit::TestCase
     
     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)))
-    assert_equal(DateTime.new(2004,10,31,5,0,0), tz.local_to_utc(DateTime.new(2004,10,31,1,0,0))) # returns first possible utc time
+    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_raise(PeriodNotFound) { tz.local_to_utc(DateTime.new(2004,4,4,2,0,0)) }
+    assert_raise(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)
@@ -31,8 +34,10 @@ class TCTimezoneNewYork < Test::Unit::TestCase
     
     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)).zone_identifier)
-    assert_equal(:EDT, tz.period_for_local(DateTime.new(2004,10,31,1,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)
@@ -41,7 +46,9 @@ class TCTimezoneNewYork < Test::Unit::TestCase
     
     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)).utc_total_offset)
-    assert_equal(-14400, tz.period_for_local(DateTime.new(2004,10,31,1,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)
   end    
 end

data/test/tc_timezone_period.rb

@@ -1,6 +1,6 @@
 $:.unshift File.join(File.dirname(__FILE__), "..", "lib")
 require 'test/unit'
-require 'tzinfo/timezone'
+require 'tzinfo/timezone_period'
 
 include TZInfo
 

data/test/tc_timezone_period_list.rb

@@ -0,0 +1,288 @@
+$:.unshift File.join(File.dirname(__FILE__), "..", "lib")
+require 'test/unit'
+require 'tzinfo/timezone_period_list'
+
+include TZInfo
+
+class TCTimezonePeriod < Test::Unit::TestCase
+  def test_add
+    # Just a test for no exception
+    
+    list = TimezonePeriodList.new
+    list.add(2005, 1) { TimezonePeriod.new(DateTime.new(2005,1,1,1,0,0), DateTime.new(2005,3,1,1,0,0), 0, 0, :TEST) }
+    list.add(2005, 3) { TimezonePeriod.new(DateTime.new(2005,3,1,1,0,0), DateTime.new(2005,5,1,1,0,0), 0, 0, :TEST) }
+    list.add(2005, 5) { TimezonePeriod.new(DateTime.new(2005,5,1,1,0,0), DateTime.new(2005,5,2,1,0,0), 0, 0, :TEST) }
+    list.add(2005, 5) { TimezonePeriod.new(DateTime.new(2005,5,2,1,0,0), DateTime.new(2005,7,1,1,0,0), 0, 0, :TEST) }
+  end
+  
+  def test_add_incorrect_order
+    list = TimezonePeriodList.new
+    list.add(2005, 1) { TimezonePeriod.new(DateTime.new(2005,1,1,1,0,0), DateTime.new(2005,2,1,1,0,0), 0, 0, :TEST) }
+    list.add(2005, 3) { TimezonePeriod.new(DateTime.new(2005,3,1,1,0,0), DateTime.new(2005,5,1,1,0,0), 0, 0, :TEST) }
+      
+    assert_raise(ArgumentError) {      
+      list.add(2005, 2) { TimezonePeriod.new(DateTime.new(2005,2,1,1,0,0), DateTime.new(2005,3,1,1,0,0), 0, 0, :TEST) }      
+    }
+    
+    assert_raise(ArgumentError) {      
+      list.add(2004, 12) { TimezonePeriod.new(DateTime.new(2004,12,1,1,0,0), DateTime.new(2005,1,1,1,0,0), 0, 0, :TEST) }      
+    }
+    
+    assert_raise(ArgumentError) {
+      list.add_unbounded_start { TimezonePeriod.new(nil, DateTime.new(2005,1,1,1,0,0), 0, 0, :TEST) }
+    }
+  end
+  
+  def test_add_incorrect_order_unbounded
+    list = TimezonePeriodList.new    
+    list.add_unbounded_start { TimezonePeriod.new(nil, DateTime.new(2005,1,1,1,0,0), 0, 0, :TEST) }
+    
+    assert_raise(ArgumentError) {
+      list.add_unbounded_start { TimezonePeriod.new(nil, DateTime.new(2005,1,1,1,0,0), 0, 0, :TEST) }
+    }
+  end
+  
+  def test_period_for_utc
+    list = TimezonePeriodList.new
+    list.add(2000, 4)  { TimezonePeriod.new(DateTime.new(2000,4,1,1,0,0),DateTime.new(2000,10,1,1,0,0),-18000,3600,:'TESTD') }
+    list.add(2000, 10) { TimezonePeriod.new(DateTime.new(2000,10,1,1,0,0),DateTime.new(2001,3,1,1,0,0),-18000,0,:'TESTS') }    
+    list.add(2001, 3)  { TimezonePeriod.new(DateTime.new(2001,3,1,1,0,0),DateTime.new(2001,4,1,1,0,0),-18000,3600,:'TESTD') }
+    list.add(2001, 4)  { TimezonePeriod.new(DateTime.new(2001,4,1,1,0,0),DateTime.new(2001,10,1,1,0,0),-21600,3600,:'TESTD') }
+    list.add(2001, 10)  { TimezonePeriod.new(DateTime.new(2001,10,1,1,0,0),DateTime.new(2002,10,1,1,0,0),-18000,0,:'TESTS') }
+    list.add(2002, 10)  { TimezonePeriod.new(DateTime.new(2002,10,1,1,0,0),DateTime.new(2003,2,1,1,0,0),-18000,0,:'TESTS') }
+    
+    # TimezonePeriodList expands out blocks and caches the results
+    # run twice to ensure this is being done correctly
+    2.times {|i|    
+      assert_raise(PeriodNotFound) {
+        list.period_for_utc(DateTime.new(1999,12,1,0,0,0))
+      }
+      assert_raise(PeriodNotFound) {
+        list.period_for_utc(DateTime.new(2000,4,1,0,59,59))
+      }      
+      assert_period_equal(TimezonePeriod.new(DateTime.new(2000,4,1,1,0,0),DateTime.new(2000,10,1,1,0,0),-18000,3600,:'TESTD'),
+        list.period_for_utc(DateTime.new(2000,4,1,1,0,0)))
+      assert_period_equal(TimezonePeriod.new(DateTime.new(2000,4,1,1,0,0),DateTime.new(2000,10,1,1,0,0),-18000,3600,:'TESTD'),
+        list.period_for_utc(DateTime.new(2000,10,1,0,59,59)))
+      assert_period_equal(TimezonePeriod.new(DateTime.new(2000,10,1,1,0,0),DateTime.new(2001,3,1,1,0,0),-18000,0,:'TESTS'),
+        list.period_for_utc(DateTime.new(2000,10,1,1,0,0)))
+      assert_period_equal(TimezonePeriod.new(DateTime.new(2000,10,1,1,0,0),DateTime.new(2001,3,1,1,0,0),-18000,0,:'TESTS'),
+        list.period_for_utc(DateTime.new(2001,3,1,0,59,59)))
+      assert_period_equal(TimezonePeriod.new(DateTime.new(2001,3,1,1,0,0),DateTime.new(2001,4,1,1,0,0),-18000,3600,:'TESTD'),
+        list.period_for_utc(DateTime.new(2001,3,1,1,0,0)))
+      assert_period_equal(TimezonePeriod.new(DateTime.new(2001,3,1,1,0,0),DateTime.new(2001,4,1,1,0,0),-18000,3600,:'TESTD'),
+        list.period_for_utc(DateTime.new(2001,4,1,0,59,59)))
+      assert_period_equal(TimezonePeriod.new(DateTime.new(2001,4,1,1,0,0),DateTime.new(2001,10,1,1,0,0),-21600,3600,:'TESTD'),
+        list.period_for_utc(DateTime.new(2001,4,1,1,0,0)))
+      assert_period_equal(TimezonePeriod.new(DateTime.new(2001,4,1,1,0,0),DateTime.new(2001,10,1,1,0,0),-21600,3600,:'TESTD'),
+        list.period_for_utc(DateTime.new(2001,10,1,0,59,59)))
+      assert_period_equal(TimezonePeriod.new(DateTime.new(2001,10,1,1,0,0),DateTime.new(2002,10,1,1,0,0),-18000,0,:'TESTS'),
+        list.period_for_utc(DateTime.new(2001,10,1,1,0,0)))
+      assert_period_equal(TimezonePeriod.new(DateTime.new(2001,10,1,1,0,0),DateTime.new(2002,10,1,1,0,0),-18000,0,:'TESTS'),
+        list.period_for_utc(DateTime.new(2002,2,1,1,0,0)))
+      assert_period_equal(TimezonePeriod.new(DateTime.new(2001,10,1,1,0,0),DateTime.new(2002,10,1,1,0,0),-18000,0,:'TESTS'),
+        list.period_for_utc(DateTime.new(2002,10,1,0,59,59)))
+      assert_period_equal(TimezonePeriod.new(DateTime.new(2002,10,1,1,0,0),DateTime.new(2003,2,1,1,0,0),-18000,0,:'TESTS'),
+        list.period_for_utc(DateTime.new(2002,10,1,1,0,0)))
+      assert_period_equal(TimezonePeriod.new(DateTime.new(2002,10,1,1,0,0),DateTime.new(2003,2,1,1,0,0),-18000,0,:'TESTS'),
+        list.period_for_utc(DateTime.new(2003,2,1,0,59,59)))
+      
+      assert_raise(PeriodNotFound) {
+        list.period_for_utc(DateTime.new(2003,2,1,1,0,0))
+      }
+      assert_raise(PeriodNotFound) {
+        list.period_for_utc(DateTime.new(2004,1,1,1,0,0))
+      }
+    }
+  end
+  
+  def test_period_for_utc_unbounded
+    list = TimezonePeriodList.new
+    list.add_unbounded_start  { TimezonePeriod.new(nil,DateTime.new(2000,10,1,1,0,0),-18000,3600,:'TESTD') }
+    list.add(2000, 10) { TimezonePeriod.new(DateTime.new(2000,10,1,1,0,0),DateTime.new(2001,3,1,1,0,0),-18000,0,:'TESTS') }    
+    list.add(2001, 3)  { TimezonePeriod.new(DateTime.new(2001,3,1,1,0,0),nil,-18000,3600,:'TESTD') }
+        
+    assert_period_equal(TimezonePeriod.new(nil,DateTime.new(2000,10,1,1,0,0),-18000,3600,:'TESTD'),
+      list.period_for_utc(DateTime.new(1999,12,1,1,0,0)))
+    assert_period_equal(TimezonePeriod.new(nil,DateTime.new(2000,10,1,1,0,0),-18000,3600,:'TESTD'),
+      list.period_for_utc(DateTime.new(2000,10,1,0,59,59)))
+    assert_period_equal(TimezonePeriod.new(DateTime.new(2000,10,1,1,0,0),DateTime.new(2001,3,1,1,0,0),-18000,0,:'TESTS'),
+      list.period_for_utc(DateTime.new(2000,10,1,1,0,0)))
+    assert_period_equal(TimezonePeriod.new(DateTime.new(2000,10,1,1,0,0),DateTime.new(2001,3,1,1,0,0),-18000,0,:'TESTS'),
+      list.period_for_utc(DateTime.new(2001,3,1,0,59,59)))
+    assert_period_equal(TimezonePeriod.new(DateTime.new(2001,3,1,1,0,0),nil,-18000,3600,:'TESTD'),
+      list.period_for_utc(DateTime.new(2001,3,1,1,0,0)))
+    assert_period_equal(TimezonePeriod.new(DateTime.new(2001,3,1,1,0,0),nil,-18000,3600,:'TESTD'),
+      list.period_for_utc(DateTime.new(2002,1,1,1,0,0)))
+  end
+  
+  def test_period_for_utc_gap
+    list = TimezonePeriodList.new
+    list.add(2000, 4)  { TimezonePeriod.new(DateTime.new(2000,4,1,1,0,0),DateTime.new(2000,5,1,1,0,0),-18000,3600,:'TESTD') }
+    list.add(2000, 10) { TimezonePeriod.new(DateTime.new(2000,10,1,1,0,0),DateTime.new(2001,3,1,1,0,0),-18000,0,:'TESTS') }
+    
+    assert_raise(PeriodNotFound) {
+      list.period_for_utc(DateTime.new(2005,5,1,1,0,0))
+    }
+    
+    assert_raise(PeriodNotFound) {
+      list.period_for_utc(DateTime.new(2005,10,1,0,59,59))
+    }
+  end
+  
+  def test_period_for_utc_empty
+    list = TimezonePeriodList.new
+    assert_raise(PeriodNotFound) {
+      list.period_for_utc(DateTime.new(2005,1,1,0,0,0))
+    }
+  end
+  
+  def test_periods_for_local
+    list = TimezonePeriodList.new
+    list.add(2000, 4)  { TimezonePeriod.new(DateTime.new(2000,4,2,1,0,0),DateTime.new(2000,10,2,1,0,0),-18000,3600,:'TESTD') }
+    list.add(2000, 10) { TimezonePeriod.new(DateTime.new(2000,10,2,1,0,0),DateTime.new(2001,3,2,1,0,0),-18000,0,:'TESTS') }    
+    list.add(2001, 3)  { TimezonePeriod.new(DateTime.new(2001,3,2,1,0,0),DateTime.new(2001,4,2,1,0,0),-18000,3600,:'TESTD') }
+    list.add(2001, 4)  { TimezonePeriod.new(DateTime.new(2001,4,2,1,0,0),DateTime.new(2001,10,2,1,0,0),-21600,3600,:'TESTD') }
+    list.add(2001, 10)  { TimezonePeriod.new(DateTime.new(2001,10,2,1,0,0),DateTime.new(2002,10,2,1,0,0),-18000,0,:'TESTS') }
+    list.add(2002, 10)  { TimezonePeriod.new(DateTime.new(2002,10,2,1,0,0),DateTime.new(2003,2,2,1,0,0),-18000,0,:'TESTS') }
+    
+    # TimezonePeriodList expands out blocks and caches the results
+    # run twice to ensure this is being done correctly
+    2.times {|i|
+      assert_raise(PeriodNotFound) {
+        list.periods_for_local(DateTime.new(1999,12,1,0,0,0))
+      }
+      assert_raise(PeriodNotFound) {
+        list.periods_for_local(DateTime.new(2000,4,1,20,59,59))
+      }
+      
+      assert_periods_equal([TimezonePeriod.new(DateTime.new(2000,4,2,1,0,0),DateTime.new(2000,10,2,1,0,0),-18000,3600,:'TESTD')],
+        list.periods_for_local(DateTime.new(2000,4,1,21,0,0)))
+      assert_periods_equal([TimezonePeriod.new(DateTime.new(2000,4,2,1,0,0),DateTime.new(2000,10,2,1,0,0),-18000,3600,:'TESTD')],
+        list.periods_for_local(DateTime.new(2000,10,1,19,59,59)))
+      assert_periods_equal([TimezonePeriod.new(DateTime.new(2000,4,2,1,0,0),DateTime.new(2000,10,2,1,0,0),-18000,3600,:'TESTD'),
+        TimezonePeriod.new(DateTime.new(2000,10,2,1,0,0),DateTime.new(2001,3,2,1,0,0),-18000,0,:'TESTS')],
+        list.periods_for_local(DateTime.new(2000,10,1,20,0,0)))
+      assert_periods_equal([TimezonePeriod.new(DateTime.new(2000,4,2,1,0,0),DateTime.new(2000,10,2,1,0,0),-18000,3600,:'TESTD'),
+        TimezonePeriod.new(DateTime.new(2000,10,2,1,0,0),DateTime.new(2001,3,2,1,0,0),-18000,0,:'TESTS')],
+        list.periods_for_local(DateTime.new(2000,10,1,20,59,59)))
+      assert_periods_equal([TimezonePeriod.new(DateTime.new(2000,10,2,1,0,0),DateTime.new(2001,3,2,1,0,0),-18000,0,:'TESTS')],
+        list.periods_for_local(DateTime.new(2000,10,1,21,0,0)))
+      assert_periods_equal([TimezonePeriod.new(DateTime.new(2000,10,2,1,0,0),DateTime.new(2001,3,2,1,0,0),-18000,0,:'TESTS')],
+        list.periods_for_local(DateTime.new(2001,3,1,19,59,59)))
+        
+      assert_raise(PeriodNotFound) {
+        list.periods_for_local(DateTime.new(2001,3,1,20,0,0))
+      }
+      assert_raise(PeriodNotFound) {
+        list.periods_for_local(DateTime.new(2001,3,1,20,59,59))
+      }
+      
+      assert_periods_equal([TimezonePeriod.new(DateTime.new(2001,3,2,1,0,0),DateTime.new(2001,4,2,1,0,0),-18000,3600,:'TESTD')],
+        list.periods_for_local(DateTime.new(2001,3,1,21,0,0)))
+      assert_periods_equal([TimezonePeriod.new(DateTime.new(2001,3,2,1,0,0),DateTime.new(2001,4,2,1,0,0),-18000,3600,:'TESTD')],
+        list.periods_for_local(DateTime.new(2001,4,1,19,59,59)))
+      assert_periods_equal([TimezonePeriod.new(DateTime.new(2001,3,2,1,0,0),DateTime.new(2001,4,2,1,0,0),-18000,3600,:'TESTD'),
+        TimezonePeriod.new(DateTime.new(2001,4,2,1,0,0),DateTime.new(2001,10,2,1,0,0),-21600,3600,:'TESTD')],
+        list.periods_for_local(DateTime.new(2001,4,1,20,0,0)))
+      assert_periods_equal([TimezonePeriod.new(DateTime.new(2001,3,2,1,0,0),DateTime.new(2001,4,2,1,0,0),-18000,3600,:'TESTD'),
+        TimezonePeriod.new(DateTime.new(2001,4,2,1,0,0),DateTime.new(2001,10,2,1,0,0),-21600,3600,:'TESTD')],
+        list.periods_for_local(DateTime.new(2001,4,1,20,59,59)))
+      assert_periods_equal([TimezonePeriod.new(DateTime.new(2001,4,2,1,0,0),DateTime.new(2001,10,2,1,0,0),-21600,3600,:'TESTD')],
+        list.periods_for_local(DateTime.new(2001,4,1,21,0,0)))
+      assert_periods_equal([TimezonePeriod.new(DateTime.new(2001,4,2,1,0,0),DateTime.new(2001,10,2,1,0,0),-21600,3600,:'TESTD')],
+        list.periods_for_local(DateTime.new(2001,10,1,19,59,59)))
+      assert_periods_equal([TimezonePeriod.new(DateTime.new(2001,10,2,1,0,0),DateTime.new(2002,10,2,1,0,0),-18000,0,:'TESTS')],
+        list.periods_for_local(DateTime.new(2001,10,1,20,0,0)))
+      assert_periods_equal([TimezonePeriod.new(DateTime.new(2001,10,2,1,0,0),DateTime.new(2002,10,2,1,0,0),-18000,0,:'TESTS')],
+        list.periods_for_local(DateTime.new(2002,2,1,20,0,0)))
+      assert_periods_equal([TimezonePeriod.new(DateTime.new(2001,10,2,1,0,0),DateTime.new(2002,10,2,1,0,0),-18000,0,:'TESTS')],
+        list.periods_for_local(DateTime.new(2002,10,1,19,59,59)))
+      assert_periods_equal([TimezonePeriod.new(DateTime.new(2002,10,2,1,0,0),DateTime.new(2003,2,2,1,0,0),-18000,0,:'TESTS')],
+        list.periods_for_local(DateTime.new(2002,10,1,20,0,0)))
+      assert_periods_equal([TimezonePeriod.new(DateTime.new(2002,10,2,1,0,0),DateTime.new(2003,2,2,1,0,0),-18000,0,:'TESTS')],
+        list.periods_for_local(DateTime.new(2003,2,1,19,59,59)))
+        
+      assert_raise(PeriodNotFound) {
+        list.periods_for_local(DateTime.new(2003,2,1,20,0,0))
+      }
+      assert_raise(PeriodNotFound) {
+        list.periods_for_local(DateTime.new(2004,1,1,20,0,0))
+      }  
+    }
+  end
+  
+  def test_period_for_local_unbounded
+    list = TimezonePeriodList.new
+    list.add_unbounded_start  { TimezonePeriod.new(nil,DateTime.new(2000,10,2,1,0,0),-18000,3600,:'TESTD') }
+    list.add(2000, 10) { TimezonePeriod.new(DateTime.new(2000,10,2,1,0,0),DateTime.new(2001,3,2,1,0,0),-18000,0,:'TESTS') }    
+    list.add(2001, 3)  { TimezonePeriod.new(DateTime.new(2001,3,2,1,0,0),nil,-18000,3600,:'TESTD') }
+        
+    assert_periods_equal([TimezonePeriod.new(nil,DateTime.new(2000,10,2,1,0,0),-18000,3600,:'TESTD')],
+      list.periods_for_local(DateTime.new(1999,12,1,1,0,0)))
+    assert_periods_equal([TimezonePeriod.new(nil,DateTime.new(2000,10,2,1,0,0),-18000,3600,:'TESTD')],
+      list.periods_for_local(DateTime.new(2000,10,1,20,59,59)))
+    assert_periods_equal([TimezonePeriod.new(nil,DateTime.new(2000,10,2,1,0,0),-18000,3600,:'TESTD')],
+      list.periods_for_local(DateTime.new(2000,10,1,19,59,59)))
+    assert_periods_equal([TimezonePeriod.new(nil,DateTime.new(2000,10,2,1,0,0),-18000,3600,:'TESTD'),
+      TimezonePeriod.new(DateTime.new(2000,10,2,1,0,0),DateTime.new(2001,3,2,1,0,0),-18000,0,:'TESTS')],
+      list.periods_for_local(DateTime.new(2000,10,1,20,0,0)))
+    assert_periods_equal([TimezonePeriod.new(nil,DateTime.new(2000,10,2,1,0,0),-18000,3600,:'TESTD'),
+      TimezonePeriod.new(DateTime.new(2000,10,2,1,0,0),DateTime.new(2001,3,2,1,0,0),-18000,0,:'TESTS')],
+      list.periods_for_local(DateTime.new(2000,10,1,20,59,59)))       
+    assert_periods_equal([TimezonePeriod.new(DateTime.new(2000,10,2,1,0,0),DateTime.new(2001,3,2,1,0,0),-18000,0,:'TESTS')],
+      list.periods_for_local(DateTime.new(2000,10,1,21,0,0)))
+    assert_periods_equal([TimezonePeriod.new(DateTime.new(2000,10,2,1,0,0),DateTime.new(2001,3,2,1,0,0),-18000,0,:'TESTS')],
+      list.periods_for_local(DateTime.new(2001,3,1,19,59,59)))
+    assert_periods_equal([TimezonePeriod.new(DateTime.new(2000,10,2,1,0,0),DateTime.new(2001,3,2,1,0,0),-18000,0,:'TESTS')],
+      list.periods_for_local(DateTime.new(2001,3,1,19,59,59)))
+      
+    assert_raise(PeriodNotFound) {
+      list.periods_for_local(DateTime.new(2001,3,1,20,0,0))
+    }
+    assert_raise(PeriodNotFound) {
+      list.periods_for_local(DateTime.new(2001,3,1,20,59,59))
+    }
+    
+    assert_periods_equal([TimezonePeriod.new(DateTime.new(2001,3,2,1,0,0),nil,-18000,3600,:'TESTD')],
+      list.periods_for_local(DateTime.new(2001,3,1,21,0,0)))
+    assert_periods_equal([TimezonePeriod.new(DateTime.new(2001,3,2,1,0,0),nil,-18000,3600,:'TESTD')],
+      list.periods_for_local(DateTime.new(2002,1,1,21,0,0)))
+  end
+  
+  def test_period_for_local_unbounded
+    list = TimezonePeriodList.new
+    list.add_unbounded_start  { TimezonePeriod.new(nil,DateTime.new(2000,7,1,0,0,0),-3600,0,:'TESTD') }
+    list.add(2000, 7) { TimezonePeriod.new(DateTime.new(2000,7,1,0,0,0),nil,-3600,0,:'TESTS') }    
+    
+    # 2000-07-01 00:00:00 UTC is 2000-06-30 23:00:00 UTC-1
+    # hence to find periods for local times between 2000-06-30 23:00:00
+    # and 2000-07-01 00:00:00 a search has to be carried out in the next half
+    # year to the one containing the date we are looking for
+    
+    assert_periods_equal([TimezonePeriod.new(nil,DateTime.new(2000,7,1,0,0,0),-3600,0,:'TESTD')],
+      list.periods_for_local(DateTime.new(2000,6,30,22,59,59)))
+    assert_periods_equal([TimezonePeriod.new(DateTime.new(2000,7,1,0,0,0),nil,-3600,0,:'TESTS')],
+      list.periods_for_local(DateTime.new(2000,6,30,23,0,0)))
+    assert_periods_equal([TimezonePeriod.new(DateTime.new(2000,7,1,0,0,0),nil,-3600,0,:'TESTS')],
+      list.periods_for_local(DateTime.new(2000,7,1,0,0,0)))
+  end
+  
+  private
+    def assert_period_equal(expected, actual)
+      assert_equal(expected.utc_start, actual.utc_start)
+      assert_equal(expected.utc_end, actual.utc_end)
+      assert_equal(expected.utc_offset, actual.utc_offset)
+      assert_equal(expected.std_offset, actual.std_offset)
+      assert_equal(expected.zone_identifier, actual.zone_identifier)    
+      assert_equal(expected.local_start, actual.local_start)    
+      assert_equal(expected.local_end, actual.local_end)
+    end
+    
+    def assert_periods_equal(expected, actual)     
+      assert_equal(expected.length, actual.length)
+      (0..expected.length - 1).each {|i|
+        assert_period_equal(expected[i], actual[i])
+      }
+    end
+end