tzinfo 1.2.2 → 1.2.3

data/test/tc_country.rb

@@ -47,7 +47,7 @@ class TCCountry < Minitest::Test
     Country.get('GB')
   
     safe_test do
-      code = 'GB'.taint
+      code = 'GB'.dup.taint
       assert(code.tainted?)
       country = Country.get(code)
       assert_equal('GB', country.code)
@@ -59,14 +59,14 @@ class TCCountry < Minitest::Test
     Country.get('GB')
   
     safe_test do
-      country = Country.get('GB'.taint.freeze)
+      country = Country.get('GB'.dup.taint.freeze)
       assert_equal('GB', country.code)
     end
   end
   
   def test_get_tainted_not_previously_loaded
     safe_test do
-      code = 'GB'.taint
+      code = 'GB'.dup.taint
       assert(code.tainted?)
       country = Country.get(code)
       assert_equal('GB', country.code)
@@ -76,7 +76,7 @@ class TCCountry < Minitest::Test
   
   def test_get_tainted_and_frozen_not_previously_loaded
     safe_test do
-      country = Country.get('GB'.taint.freeze)
+      country = Country.get('GB'.dup.taint.freeze)
       assert_equal('GB', country.code)
     end
   end

data/test/tc_ruby_data_source.rb

@@ -56,7 +56,7 @@ class TCRubyDataSource < Minitest::Test
 
   def test_load_timezone_info_tainted
     safe_test do
-      identifier = 'Europe/Amsterdam'.taint
+      identifier = 'Europe/Amsterdam'.dup.taint
       assert(identifier.tainted?)
       info = @data_source.load_timezone_info(identifier)
       assert_equal('Europe/Amsterdam', info.identifier)
@@ -66,7 +66,7 @@ class TCRubyDataSource < Minitest::Test
   
   def test_load_timezone_info_tainted_and_frozen
     safe_test do
-      info = @data_source.load_timezone_info('Europe/Amsterdam'.taint.freeze)
+      info = @data_source.load_timezone_info('Europe/Amsterdam'.dup.taint.freeze)
       assert_equal('Europe/Amsterdam', info.identifier)
     end
   end
@@ -120,7 +120,7 @@ class TCRubyDataSource < Minitest::Test
   
   def test_load_country_info_tainted
     safe_test do
-      code = 'NL'.taint
+      code = 'NL'.dup.taint
       assert(code.tainted?)
       info = @data_source.load_country_info(code)
       assert_equal('NL', info.code)
@@ -130,7 +130,7 @@ class TCRubyDataSource < Minitest::Test
   
   def test_load_country_info_tainted_and_frozen
     safe_test do
-      info = @data_source.load_country_info('NL'.taint.freeze)
+      info = @data_source.load_country_info('NL'.dup.taint.freeze)
       assert_equal('NL', info.code)
     end
   end

data/test/tc_timezone.rb

@@ -243,7 +243,7 @@ class TCTimezone < Minitest::Test
     Timezone.get('Europe/Andorra')
   
     safe_test do
-      identifier = 'Europe/Andorra'.taint
+      identifier = 'Europe/Andorra'.dup.taint
       assert(identifier.tainted?)
       tz = Timezone.get(identifier)
       assert_equal('Europe/Andorra', tz.identifier)
@@ -255,14 +255,14 @@ class TCTimezone < Minitest::Test
     Timezone.get('Europe/Andorra')
   
     safe_test do
-      tz = Timezone.get('Europe/Andorra'.taint.freeze)
+      tz = Timezone.get('Europe/Andorra'.dup.taint.freeze)
       assert_equal('Europe/Andorra', tz.identifier)
     end
   end
   
   def test_get_tainted_not_previously_loaded
     safe_test do
-      identifier = 'Europe/Andorra'.taint
+      identifier = 'Europe/Andorra'.dup.taint
       assert(identifier.tainted?)
       tz = Timezone.get(identifier)
       assert_equal('Europe/Andorra', tz.identifier)
@@ -272,7 +272,7 @@ class TCTimezone < Minitest::Test
   
   def test_get_tainted_and_frozen_not_previously_loaded
     safe_test do
-      tz = Timezone.get('Europe/Amsterdam'.taint.freeze)
+      tz = Timezone.get('Europe/Amsterdam'.dup.taint.freeze)
       assert_equal('Europe/Amsterdam', tz.identifier)
     end
   end
@@ -436,6 +436,13 @@ class TCTimezone < Minitest::Test
     assert_equal('UTC', TestTimezone.new('UTC').friendly_identifier)
   end
   
+  if defined?(Encoding)
+    def test_friendly_identifier_non_binary_encoding
+      refute_equal(Encoding::ASCII_8BIT, TestTimezone.new('Europe/Paris').friendly_identifier(true).encoding)
+      refute_equal(Encoding::ASCII_8BIT, TestTimezone.new('Europe/Paris').friendly_identifier(false).encoding)
+    end
+  end
+
   def test_to_s
     assert_equal('Europe - Paris', TestTimezone.new('Europe/Paris').to_s)
     assert_equal('America - Knox, Indiana', TestTimezone.new('America/Indiana/Knox').to_s)
@@ -1246,26 +1253,35 @@ class TCTimezone < Minitest::Test
   
   def test_strftime_datetime
     tz = Timezone.get('Europe/London')
-    assert_equal('23:12:02 BST', tz.strftime('%H:%M:%S %Z', DateTime.new(2006, 7, 15, 22, 12, 2)))
-    assert_equal('BST', tz.strftime('%Z', DateTime.new(2006, 7, 15, 22, 12, 2)))
-    assert_equal('%ZBST', tz.strftime('%%Z%Z', DateTime.new(2006, 7, 15, 22, 12, 2)))
-    assert_equal('BST BST', tz.strftime('%Z %Z', DateTime.new(2006, 7, 15, 22, 12, 2)))
+    dt = DateTime.new(2006, 7, 15, 22, 12, 2)
+    assert_equal('23:12:02 BST', tz.strftime('%H:%M:%S %Z', dt))
+    assert_equal('BST', tz.strftime('%Z', dt))
+    assert_equal('%ZBST', tz.strftime('%%Z%Z', dt))
+    assert_equal('BST BST', tz.strftime('%Z %Z', dt))
+    assert_equal('BST %Z %BST %%Z %%BST', tz.strftime('%Z %%Z %%%Z %%%%Z %%%%%Z', dt))
+    assert_equal('+0100 +01:00 +01:00:00 +01 %::::z', tz.strftime('%z %:z %::z %:::z %::::z', dt))
   end
   
   def test_strftime_time
     tz = Timezone.get('Europe/London')
-    assert_equal('23:12:02 BST', tz.strftime('%H:%M:%S %Z', Time.utc(2006, 7, 15, 22, 12, 2)))
-    assert_equal('BST', tz.strftime('%Z', Time.utc(2006, 7, 15, 22, 12, 2)))
-    assert_equal('%ZBST', tz.strftime('%%Z%Z', Time.utc(2006, 7, 15, 22, 12, 2)))
-    assert_equal('BST BST', tz.strftime('%Z %Z', Time.utc(2006, 7, 15, 22, 12, 2)))
+    t = Time.utc(2006, 7, 15, 22, 12, 2)
+    assert_equal('23:12:02 BST', tz.strftime('%H:%M:%S %Z', t))
+    assert_equal('BST', tz.strftime('%Z', t))
+    assert_equal('%ZBST', tz.strftime('%%Z%Z', t))
+    assert_equal('BST BST', tz.strftime('%Z %Z', t))
+    assert_equal('BST %Z %BST %%Z %%BST', tz.strftime('%Z %%Z %%%Z %%%%Z %%%%%Z', t))
+    assert_equal('+0100 +01:00 +01:00:00 +01 %::::z', tz.strftime('%z %:z %::z %:::z %::::z', t))
   end
   
   def test_strftime_int
     tz = Timezone.get('Europe/London')
-    assert_equal('23:12:02 BST', tz.strftime('%H:%M:%S %Z', Time.utc(2006, 7, 15, 22, 12, 2).to_i))
-    assert_equal('BST', tz.strftime('%Z', Time.utc(2006, 7, 15, 22, 12, 2).to_i))
-    assert_equal('%ZBST', tz.strftime('%%Z%Z', Time.utc(2006, 7, 15, 22, 12, 2).to_i))
-    assert_equal('BST BST', tz.strftime('%Z %Z', Time.utc(2006, 7, 15, 22, 12, 2).to_i))
+    i = Time.utc(2006, 7, 15, 22, 12, 2).to_i
+    assert_equal('23:12:02 BST', tz.strftime('%H:%M:%S %Z', i))
+    assert_equal('BST', tz.strftime('%Z', i))
+    assert_equal('%ZBST', tz.strftime('%%Z%Z', i))
+    assert_equal('BST BST', tz.strftime('%Z %Z', i))
+    assert_equal('BST %Z %BST %%Z %%BST', tz.strftime('%Z %%Z %%%Z %%%%Z %%%%%Z', i))
+    assert_equal('+0100 +01:00 +01:00:00 +01 %::::z', tz.strftime('%z %:z %::z %:::z %::::z', i))
   end
   
   def test_get_missing_data_source

data/test/tc_timezone_proxy.rb

@@ -5,45 +5,59 @@ include TZInfo
 class TCTimezoneProxy < Minitest::Test
   def test_not_exist
     proxy = TimezoneProxy.new('Nothing/Special')
+    t = Time.utc(2006,1,1,0,0,0)
     assert_equal('Nothing/Special', proxy.identifier)
-    assert_raises(InvalidTimezoneIdentifier) { proxy.now }
+    assert_equal('Nothing/Special', proxy.name)
+    assert_equal('Nothing - Special', proxy.friendly_identifier)
+    assert_equal('Nothing - Special', proxy.to_s)
+
+    assert_raises(InvalidTimezoneIdentifier) { proxy.canonical_identifier }
+    assert_raises(InvalidTimezoneIdentifier) { proxy.canonical_zone }
     assert_raises(InvalidTimezoneIdentifier) { proxy.current_period }
     assert_raises(InvalidTimezoneIdentifier) { proxy.current_period_and_time }
     assert_raises(InvalidTimezoneIdentifier) { proxy.current_time_and_period }
-    assert_raises(InvalidTimezoneIdentifier) { proxy.utc_to_local(DateTime.new(2006,1,1,0,0,0)) }
-    assert_raises(InvalidTimezoneIdentifier) { proxy.local_to_utc(DateTime.new(2006,1,1,0,0,0)) }
-    assert_raises(InvalidTimezoneIdentifier) { proxy.period_for_utc(DateTime.new(2006,1,1,0,0,0)) }
-    assert_raises(InvalidTimezoneIdentifier) { proxy.period_for_local(DateTime.new(2006,1,1,0,0,0)) }
-    assert_raises(InvalidTimezoneIdentifier) { proxy.canonical_identifier }
-    assert_raises(InvalidTimezoneIdentifier) { proxy.canonical_zone }
+    assert_raises(InvalidTimezoneIdentifier) { proxy.local_to_utc(t) }
+    assert_raises(InvalidTimezoneIdentifier) { proxy.now }
+    assert_raises(InvalidTimezoneIdentifier) { proxy.offsets_up_to(t) }
+    assert_raises(InvalidTimezoneIdentifier) { proxy.period_for_local(t) }
+    assert_raises(InvalidTimezoneIdentifier) { proxy.period_for_utc(t) }
+    assert_raises(InvalidTimezoneIdentifier) { proxy.periods_for_local(t) }
+    assert_raises(InvalidTimezoneIdentifier) { proxy.strftime('%Z', t) }
+    assert_raises(InvalidTimezoneIdentifier) { proxy.transitions_up_to(t) }
+    assert_raises(InvalidTimezoneIdentifier) { proxy.utc_to_local(t) }
   end
   
   def test_valid
     proxy = TimezoneProxy.new('Europe/London')
-    assert_equal('Europe/London', proxy.identifier)
-    
-    assert_nothing_raised { proxy.now }
+    real = Timezone.get('Europe/London')
+
+    t1 = Time.utc(2005,8,1,0,0,0)
+    t2 = Time.utc(2004,8,1,0,0,0)
+
+    assert_equal(real.canonical_identifier, proxy.canonical_identifier)
+    assert_same(real.canonical_zone, proxy.canonical_zone)
     assert_nothing_raised { proxy.current_period }
     assert_nothing_raised { proxy.current_period_and_time }
     assert_nothing_raised { proxy.current_time_and_period }
-    
-    real = Timezone.get('Europe/London')
-    
-    assert_equal(real.utc_to_local(DateTime.new(2005,8,1,0,0,0)), proxy.utc_to_local(DateTime.new(2005,8,1,0,0,0)))
-    assert_equal(real.local_to_utc(DateTime.new(2005,8,1,0,0,0)), proxy.local_to_utc(DateTime.new(2005,8,1,0,0,0)))
-    assert_equal(real.period_for_utc(DateTime.new(2005,8,1,0,0,0)), proxy.period_for_utc(DateTime.new(2005,8,1,0,0,0)))
-    assert_equal(real.period_for_local(DateTime.new(2005,8,1,0,0,0)), proxy.period_for_local(DateTime.new(2005,8,1,0,0,0)))
-    assert_equal(real.identifier, proxy.identifier)
-    assert_equal(real.name, proxy.name)
-    assert_equal(real.to_s, proxy.to_s)
     assert_equal(real.friendly_identifier(true), proxy.friendly_identifier(true))
     assert_equal(real.friendly_identifier(false), proxy.friendly_identifier(false))
     assert_equal(real.friendly_identifier, proxy.friendly_identifier)
-    assert_equal(real.canonical_identifier, proxy.canonical_identifier)
-    assert_same(real.canonical_zone, proxy.canonical_zone)
-    
-    assert_equal('Europe/London', proxy.identifier)
-    
+    assert_equal(real.identifier, proxy.identifier)
+    assert_equal(real.local_to_utc(t1), proxy.local_to_utc(t1))
+    assert_equal(real.name, proxy.name)
+    assert_nothing_raised { proxy.now }
+    assert_equal(real.offsets_up_to(t1), proxy.offsets_up_to(t1))
+    assert_equal(real.offsets_up_to(t1, t2), proxy.offsets_up_to(t1, t2))
+    assert_equal(real.period_for_local(t1), proxy.period_for_local(t1))
+    assert_equal(real.period_for_utc(t1), proxy.period_for_utc(t1))
+    assert_equal(real.periods_for_local(t1), proxy.periods_for_local(t1))
+    assert_equal(real.strftime('%Z', t1), proxy.strftime('%Z', t1))
+    assert_equal(real.to_s, proxy.to_s)
+    assert_equal(real.transitions_up_to(t1), proxy.transitions_up_to(t1))
+    assert_equal(real.transitions_up_to(t1, t2), proxy.transitions_up_to(t1, t2))
+    assert_equal(real.utc_to_local(t1), proxy.utc_to_local(t1))
+
+
     assert(real == proxy)
     assert(proxy == real)
     assert_equal(0, real <=> proxy)

data/test/tc_zoneinfo_data_source.rb

@@ -395,6 +395,41 @@ class TCZoneinfoDataSource < Minitest::Test
     end
   end
   
+  def test_load_timezone_info_ignored_timeconfig_symlink
+    # Slackware includes a symlink named timeconfig that points at /usr/sbin/timeconfig.
+
+    Dir.mktmpdir('tzinfo_test_target') do |target_dir|
+      target_path = File.join(target_dir, 'timeconfig')
+
+      File.open(target_path, 'w') do |f|
+        f.write("#!/bin/sh\n")
+        f.write("#\n")
+        f.write('# timeconfig         Slackware Linux timezone configuration utility.\n')
+      end
+
+      Dir.mktmpdir('tzinfo_test') do |dir|
+        FileUtils.touch(File.join(dir, 'zone.tab'))
+        FileUtils.touch(File.join(dir, 'iso3166.tab'))
+        FileUtils.cp(File.join(@data_source.zoneinfo_dir, 'EST'), File.join(dir, 'EST'))
+
+        symlink_path = File.join(dir, 'timeconfig')
+        begin
+          FileUtils.ln_s(target_path, symlink_path)
+        rescue NotImplementedError, Errno::EACCES
+          # Symlinks not supported on this platform, or permission denied
+          # (administrative rights are required on Windows). Copy instead.
+          FileUtils.cp(target_path, symlink_path)
+        end
+
+        data_source = ZoneinfoDataSource.new(dir)
+
+        assert_raises(InvalidTimezoneIdentifier) do
+          data_source.load_timezone_info('timeconfig')
+        end
+      end
+    end
+  end
+
   def test_load_timezone_info_nil
     assert_raises(InvalidTimezoneIdentifier) do
       @data_source.load_timezone_info(nil)
@@ -453,8 +488,9 @@ class TCZoneinfoDataSource < Minitest::Test
         
         begin
           FileUtils.ln_s(outside_file, file)
-        rescue NotImplementedError
-          # Symlinks not supported on this platform - skip test
+        rescue NotImplementedError, Errno::EACCES
+          # Symlinks not supported on this platform, or permission denied
+          # (administrative rights are required on Windows). Skip test.
           return
         end
         
@@ -478,8 +514,9 @@ class TCZoneinfoDataSource < Minitest::Test
       
       begin  
         FileUtils.ln_s(File.join(File.expand_path(dir), 'EST'), link)      
-      rescue NotImplementedError
-        # Symlinks not supported on this platform - skip test
+      rescue NotImplementedError, Errno::EACCES
+        # Symlinks not supported on this platform, or permission denied
+        # (administrative rights are required on Windows). Skip test.
         return
       end
       
@@ -505,8 +542,9 @@ class TCZoneinfoDataSource < Minitest::Test
       
       begin
         FileUtils.ln_s('../outside', link)
-      rescue NotImplementedError
-        # Symlinks not supported on this platform - skip test
+      rescue NotImplementedError, Errno::EACCES
+        # Symlinks not supported on this platform, or permission denied
+        # (administrative rights are required on Windows). Skip test.
         return
       end
       
@@ -541,8 +579,9 @@ class TCZoneinfoDataSource < Minitest::Test
       subdir_link = File.join(subdir, 'Link')
       begin
         FileUtils.ln_s('../Subdir/EST', subdir_link)
-      rescue NotImplementedError
-        # Symlinks not supported on this platform - skip test
+      rescue NotImplementedError, Errno::EACCES
+        # Symlinks not supported on this platform, or permission denied
+        # (administrative rights are required on Windows). Skip test.
         return
       end
       
@@ -613,7 +652,7 @@ class TCZoneinfoDataSource < Minitest::Test
 
   def test_load_timezone_info_tainted
     safe_test do
-      identifier = 'Europe/Amsterdam'.taint
+      identifier = 'Europe/Amsterdam'.dup.taint
       assert(identifier.tainted?)
       info = @data_source.load_timezone_info(identifier)
       assert_equal('Europe/Amsterdam', info.identifier)
@@ -623,7 +662,7 @@ class TCZoneinfoDataSource < Minitest::Test
   
   def test_load_timezone_info_tainted_and_frozen
     safe_test do
-      info = @data_source.load_timezone_info('Europe/Amsterdam'.taint.freeze)
+      info = @data_source.load_timezone_info('Europe/Amsterdam'.dup.taint.freeze)
       assert_equal('Europe/Amsterdam', info.identifier)
     end
   end
@@ -653,11 +692,11 @@ class TCZoneinfoDataSource < Minitest::Test
        
     entries = entries.collect {|file| file[directory.length + File::SEPARATOR.length, file.length - directory.length - File::SEPARATOR.length]}
 
-    # Exclude right (with leapseconds) and posix (copy) directories; .tab files; localtime, posixrules and Factory zones
+    # Exclude right (with leapseconds) and posix (copy) directories; .tab files; localtime and posixrules files.
     entries = entries.select do |file| 
       file !~ /\A(posix|right)\// &&
         file !~ /\.tab\z/ &&
-        !%w(localtime posixrules Factory).include?(file)
+        !%w(localtime posixrules).include?(file)
     end
     
     entries.sort
@@ -714,6 +753,38 @@ class TCZoneinfoDataSource < Minitest::Test
     end
   end
   
+  def test_timezone_identifiers_ignored_timeconfig_symlink
+    # Slackware includes a symlink named timeconfig that points at /usr/sbin/timeconfig.
+
+    Dir.mktmpdir('tzinfo_test_target') do |target_dir|
+      target_path = File.join(target_dir, 'timeconfig')
+
+      File.open(target_path, 'w') do |f|
+        f.write("#!/bin/sh\n")
+        f.write("#\n")
+        f.write('# timeconfig         Slackware Linux timezone configuration utility.\n')
+      end
+
+      Dir.mktmpdir('tzinfo_test') do |dir|
+        FileUtils.touch(File.join(dir, 'zone.tab'))
+        FileUtils.touch(File.join(dir, 'iso3166.tab'))
+        FileUtils.cp(File.join(@data_source.zoneinfo_dir, 'EST'), File.join(dir, 'EST'))
+
+        symlink_path = File.join(dir, 'timeconfig')
+        begin
+          FileUtils.ln_s(target_path, symlink_path)
+        rescue NotImplementedError, Errno::EACCES
+          # Symlinks not supported on this platform, or permission denied
+          # (administrative rights are required on Windows). Copy instead.
+          FileUtils.cp(target_path, symlink_path)
+        end
+
+        data_source = ZoneinfoDataSource.new(dir)
+        assert_array_same_items(['EST'], data_source.timezone_identifiers)
+      end
+    end
+  end
+
   def test_timezone_identifiers_ignored_src_directory
     # Solaris includes a src directory containing the source timezone data files
     # from the tzdata distribution. These should be ignored.
@@ -768,7 +839,7 @@ class TCZoneinfoDataSource < Minitest::Test
   
   def test_load_country_info_tainted
     safe_test do
-      code = 'NL'.taint
+      code = 'NL'.dup.taint
       assert(code.tainted?)
       info = @data_source.load_country_info(code)
       assert_equal('NL', info.code)
@@ -778,7 +849,7 @@ class TCZoneinfoDataSource < Minitest::Test
   
   def test_load_country_info_tainted_and_frozen
     safe_test do
-      info = @data_source.load_country_info('NL'.taint.freeze)
+      info = @data_source.load_country_info('NL'.dup.taint.freeze)
       assert_equal('NL', info.code)
     end
   end

data/test/tc_zoneinfo_timezone_info.rb

@@ -286,6 +286,17 @@ class TCZoneinfoTimezoneInfo < Minitest::Test
     end
   end
   
+  def test_load_no_offsets
+    offsets = []
+    transitions = [{:at => Time.utc(2000, 12, 31), :offset_index => 0}]
+
+    tzif_test(offsets, transitions) do |path, format|
+      assert_raises(InvalidZoneinfoFile) do
+        ZoneinfoTimezoneInfo.new('Zone', path)
+      end
+    end
+  end
+
   def test_load_invalid_offset_index
     offsets = [{:gmtoff => -0, :isdst => false, :abbrev => 'LMT'}]
     transitions = [{:at => Time.utc(2000, 12, 31), :offset_index => 2}]
@@ -707,27 +718,39 @@ class TCZoneinfoTimezoneInfo < Minitest::Test
     end
   end
     
-  def test_load_starts_all_same_dst_offset
+  def test_load_starts_only_dst_transition_with_lmt
     # The zoneinfo files don't include the offset from standard time, so this
     # has to be derived by looking at changes in the total UTC offset.
-    #
-    # If there are no changes in the UTC offset (ignoring the first offset, 
-    # which is usually local mean time), then a value of 1 hour is used as the
-    # standard time offset.
-  
+
     offsets = [
       {:gmtoff => 3542, :isdst => false, :abbrev => 'LMT'},
-      {:gmtoff => 7200, :isdst => true,  :abbrev => 'XDDT'}]
-      
-    transitions = [
-      {:at => Time.utc(2000, 1, 1), :offset_index => 1}]
-  
-    tzif_test(offsets, transitions) do |path, format|     
-      info = ZoneinfoTimezoneInfo.new('Zone/DoubleDaylight', path)
-      assert_equal('Zone/DoubleDaylight', info.identifier)
-  
-      assert_period(:LMT,  3542,    0, false,                  nil, Time.utc(2000, 1, 1), info)
-      assert_period(:XDDT, 3600, 3600,  true, Time.utc(2000, 1, 1),                  nil, info)
+      {:gmtoff => 7200, :isdst => true,  :abbrev => 'XDT'}]
+
+    transitions = [{:at => Time.utc(2000, 1, 1), :offset_index => 1}]
+
+    tzif_test(offsets, transitions) do |path, format|
+      info = ZoneinfoTimezoneInfo.new('Zone/OnlyDST', path)
+      assert_equal('Zone/OnlyDST', info.identifier)
+
+      assert_period(:LMT, 3542,    0, false,                  nil, Time.utc(2000, 1, 1), info)
+      assert_period(:XDT, 3542, 3658,  true, Time.utc(2000, 1, 1),                  nil, info)
+    end
+  end
+
+  def test_load_starts_only_dst_transition_without_lmt
+    # The zoneinfo files don't include the offset from standard time, so this
+    # has to be derived by looking at changes in the total UTC offset.
+
+    offsets = [{:gmtoff => 7200, :isdst => true,  :abbrev => 'XDT'}]
+
+    transitions = [{:at => Time.utc(2000, 1, 1), :offset_index => 0}]
+
+    tzif_test(offsets, transitions) do |path, format|
+      info = ZoneinfoTimezoneInfo.new('Zone/OnlyDST', path)
+      assert_equal('Zone/OnlyDST', info.identifier)
+
+      assert_period(:XDT, 3600, 3600, true,                  nil, Time.utc(2000, 1, 1), info)
+      assert_period(:XDT, 3600, 3600, true, Time.utc(2000, 1, 1),                  nil, info)
     end
   end
   
@@ -756,6 +779,297 @@ class TCZoneinfoTimezoneInfo < Minitest::Test
       assert_period(:XDT,     0, 3600,  true, Time.utc(2000, 2, 1), nil, info)
     end
   end
+
+  def test_load_apia_international_dateline_change
+    # The zoneinfo files don't include the offset from standard time, so this
+    # has to be derived by looking at changes in the total UTC offset.
+
+    # Pacific/Apia moved across the International Date Line whilst observing
+    # daylight savings time.
+
+    offsets = [
+      {:gmtoff =>  45184, :isdst => false, :abbrev => 'LMT'},
+      {:gmtoff => -39600, :isdst => false, :abbrev => '-11'},
+      {:gmtoff => -36000, :isdst => true,  :abbrev => '-10'},
+      {:gmtoff =>  50400, :isdst => true,  :abbrev => '+14'},
+      {:gmtoff =>  46800, :isdst => false, :abbrev => '+13'}]
+
+    transitions = [
+      {:at => Time.utc(2011,  4,  2, 14, 0, 0), :offset_index => 1},
+      {:at => Time.utc(2011,  9, 24, 14, 0, 0), :offset_index => 2},
+      {:at => Time.utc(2011, 12, 30, 10, 0, 0), :offset_index => 3},
+      {:at => Time.utc(2012,  3, 31, 14, 0, 0), :offset_index => 4}]
+
+    tzif_test(offsets, transitions) do |path, format|
+      info = ZoneinfoTimezoneInfo.new('Test/Pacific/Apia', path)
+      assert_equal('Test/Pacific/Apia', info.identifier)
+
+      assert_period(  :LMT,  45184,    0, false,                              nil, Time.utc(2011,  4,  2, 14, 0, 0), info)
+      assert_period(:'-11', -39600,    0, false, Time.utc(2011,  4,  2, 14, 0, 0), Time.utc(2011,  9, 24, 14, 0, 0), info)
+      assert_period(:'-10', -39600, 3600,  true, Time.utc(2011,  9, 24, 14, 0, 0), Time.utc(2011, 12, 30, 10, 0, 0), info)
+      assert_period(:'+14',  46800, 3600,  true, Time.utc(2011, 12, 30, 10, 0, 0), Time.utc(2012,  3, 31, 14, 0, 0), info)
+      assert_period(:'+13',  46800,    0, false, Time.utc(2012,  3, 31, 14, 0, 0),                              nil, info)
+    end
+  end
+
+  def test_load_offset_split_for_different_utc_offset
+    # The zoneinfo files don't include the offset from standard time, so this
+    # has to be derived by looking at changes in the total UTC offset.
+
+    offsets = [
+      {:gmtoff =>  3542, :isdst => false, :abbrev => 'LMT'},
+      {:gmtoff =>  3600, :isdst => false, :abbrev => 'XST1'},
+      {:gmtoff =>  7200, :isdst => false, :abbrev => 'XST2'},
+      {:gmtoff => 10800, :isdst => true,  :abbrev => 'XDT'}]
+
+    transitions = [
+      {:at => Time.utc(2000,  1, 1), :offset_index => 1},
+      {:at => Time.utc(2000,  2, 1), :offset_index => 3},
+      {:at => Time.utc(2000,  3, 1), :offset_index => 1},
+      {:at => Time.utc(2000,  4, 1), :offset_index => 2},
+      {:at => Time.utc(2000,  5, 1), :offset_index => 3},
+      {:at => Time.utc(2000,  6, 1), :offset_index => 2},
+      {:at => Time.utc(2000,  7, 1), :offset_index => 1},
+      {:at => Time.utc(2000,  8, 1), :offset_index => 3},
+      {:at => Time.utc(2000,  9, 1), :offset_index => 1},
+      {:at => Time.utc(2000, 10, 1), :offset_index => 2},
+      {:at => Time.utc(2000, 11, 1), :offset_index => 3},
+      {:at => Time.utc(2000, 12, 1), :offset_index => 2}]
+
+    # XDT will be split and defined according to its surrounding standard time
+    # offsets.
+
+    tzif_test(offsets, transitions) do |path, format|
+      info = ZoneinfoTimezoneInfo.new('Zone/SplitUtcOffset', path)
+      assert_equal('Zone/SplitUtcOffset', info.identifier)
+
+      assert_period( :LMT, 3542,    0, false,                   nil, Time.utc(2000,  1, 1), info)
+      assert_period(:XST1, 3600,    0, false, Time.utc(2000,  1, 1), Time.utc(2000,  2, 1), info)
+      assert_period( :XDT, 3600, 7200,  true, Time.utc(2000,  2, 1), Time.utc(2000,  3, 1), info)
+      assert_period(:XST1, 3600,    0, false, Time.utc(2000,  3, 1), Time.utc(2000,  4, 1), info)
+      assert_period(:XST2, 7200,    0, false, Time.utc(2000,  4, 1), Time.utc(2000,  5, 1), info)
+      assert_period( :XDT, 7200, 3600,  true, Time.utc(2000,  5, 1), Time.utc(2000,  6, 1), info)
+      assert_period(:XST2, 7200,    0, false, Time.utc(2000,  6, 1), Time.utc(2000,  7, 1), info)
+      assert_period(:XST1, 3600,    0, false, Time.utc(2000,  7, 1), Time.utc(2000,  8, 1), info)
+      assert_period( :XDT, 3600, 7200,  true, Time.utc(2000,  8, 1), Time.utc(2000,  9, 1), info)
+      assert_period(:XST1, 3600,    0, false, Time.utc(2000,  9, 1), Time.utc(2000, 10, 1), info)
+      assert_period(:XST2, 7200,    0, false, Time.utc(2000, 10, 1), Time.utc(2000, 11, 1), info)
+      assert_period( :XDT, 7200, 3600,  true, Time.utc(2000, 11, 1), Time.utc(2000, 12, 1), info)
+      assert_period(:XST2, 7200,    0, false, Time.utc(2000, 12, 1),                   nil, info)
+
+      1.upto(6) do |i|
+        assert_same(info.period_for_utc(Time.utc(2000, i, 1)).offset, info.period_for_utc(Time.utc(2000, i + 6, 1)).offset)
+      end
+    end
+  end
+
+  def test_load_offset_utc_offset_taken_from_minimum_difference_minimum_after
+    # The zoneinfo files don't include the offset from standard time, so this
+    # has to be derived by looking at changes in the total UTC offset.
+
+    offsets = [
+      {:gmtoff =>  3542, :isdst => false, :abbrev => 'LMT'},
+      {:gmtoff =>  3600, :isdst => false, :abbrev => 'XST1'},
+      {:gmtoff =>  7200, :isdst => false, :abbrev => 'XST2'},
+      {:gmtoff => 10800, :isdst => true,  :abbrev => 'XDT'}]
+
+    transitions = [
+      {:at => Time.utc(2000,  1, 1), :offset_index => 1},
+      {:at => Time.utc(2000,  2, 1), :offset_index => 3},
+      {:at => Time.utc(2000,  3, 1), :offset_index => 2}]
+
+    # XDT should use the closest utc_offset (7200) (and not an equivalent
+    # utc_offset of 3600 and std_offset of 7200).
+
+    tzif_test(offsets, transitions) do |path, format|
+      info = ZoneinfoTimezoneInfo.new('Zone/MinimumUtcOffset', path)
+      assert_equal('Zone/MinimumUtcOffset', info.identifier)
+
+      assert_period( :LMT, 3542,    0, false,                   nil, Time.utc(2000,  1, 1), info)
+      assert_period(:XST1, 3600,    0, false, Time.utc(2000,  1, 1), Time.utc(2000,  2, 1), info)
+      assert_period( :XDT, 7200, 3600,  true, Time.utc(2000,  2, 1), Time.utc(2000,  3, 1), info)
+      assert_period(:XST2, 7200,    0, false, Time.utc(2000,  3, 1),                   nil, info)
+    end
+  end
+
+  def test_load_offset_utc_offset_taken_from_minimum_difference_minimum_before
+    # The zoneinfo files don't include the offset from standard time, so this
+    # has to be derived by looking at changes in the total UTC offset.
+
+    offsets = [
+      {:gmtoff =>  3542, :isdst => false, :abbrev => 'LMT'},
+      {:gmtoff =>  3600, :isdst => false, :abbrev => 'XST1'},
+      {:gmtoff =>  7200, :isdst => false, :abbrev => 'XST2'},
+      {:gmtoff => 10800, :isdst => true,  :abbrev => 'XDT'}]
+
+    transitions = [
+      {:at => Time.utc(2000,  1, 1), :offset_index => 2},
+      {:at => Time.utc(2000,  2, 1), :offset_index => 3},
+      {:at => Time.utc(2000,  3, 1), :offset_index => 1}]
+
+    # XDT should use the closest utc_offset (7200) (and not an equivalent
+    # utc_offset of 3600 and std_offset of 7200).
+
+    tzif_test(offsets, transitions) do |path, format|
+      info = ZoneinfoTimezoneInfo.new('Zone/MinimumUtcOffset', path)
+      assert_equal('Zone/MinimumUtcOffset', info.identifier)
+
+      assert_period( :LMT, 3542,    0, false,                   nil, Time.utc(2000,  1, 1), info)
+      assert_period(:XST2, 7200,    0, false, Time.utc(2000,  1, 1), Time.utc(2000,  2, 1), info)
+      assert_period( :XDT, 7200, 3600,  true, Time.utc(2000,  2, 1), Time.utc(2000,  3, 1), info)
+      assert_period(:XST1, 3600,    0, false, Time.utc(2000,  3, 1),                   nil, info)
+    end
+  end
+
+  def test_load_offset_does_not_use_equal_utc_total_offset_equal_after
+    # The zoneinfo files don't include the offset from standard time, so this
+    # has to be derived by looking at changes in the total UTC offset.
+
+    offsets = [
+      {:gmtoff => 3542, :isdst => false, :abbrev => 'LMT'},
+      {:gmtoff => 3600, :isdst => false, :abbrev => 'XST1'},
+      {:gmtoff => 7200, :isdst => false, :abbrev => 'XST2'},
+      {:gmtoff => 7200, :isdst => true,  :abbrev => 'XDT'}]
+
+    transitions = [
+      {:at => Time.utc(2000,  1, 1), :offset_index => 1},
+      {:at => Time.utc(2000,  2, 1), :offset_index => 3},
+      {:at => Time.utc(2000,  3, 1), :offset_index => 2}]
+
+    # XDT will be based on the utc_offset of XST1 even though XST2 has an
+    # equivalent (or greater) utc_total_offset.
+
+    tzif_test(offsets, transitions) do |path, format|
+      info = ZoneinfoTimezoneInfo.new('Zone/UtcOffsetEqual', path)
+      assert_equal('Zone/UtcOffsetEqual', info.identifier)
+
+      assert_period( :LMT, 3542,    0, false,                   nil, Time.utc(2000,  1, 1), info)
+      assert_period(:XST1, 3600,    0, false, Time.utc(2000,  1, 1), Time.utc(2000,  2, 1), info)
+      assert_period( :XDT, 3600, 3600,  true, Time.utc(2000,  2, 1), Time.utc(2000,  3, 1), info)
+      assert_period(:XST2, 7200,    0, false, Time.utc(2000,  3, 1),                   nil, info)
+    end
+  end
+
+  def test_load_offset_does_not_use_equal_utc_total_offset_equal_before
+    # The zoneinfo files don't include the offset from standard time, so this
+    # has to be derived by looking at changes in the total UTC offset.
+
+    offsets = [
+      {:gmtoff => 3542, :isdst => false, :abbrev => 'LMT'},
+      {:gmtoff => 3600, :isdst => false, :abbrev => 'XST1'},
+      {:gmtoff => 7200, :isdst => false, :abbrev => 'XST2'},
+      {:gmtoff => 7200, :isdst => true,  :abbrev => 'XDT'}]
+
+    transitions = [
+      {:at => Time.utc(2000,  1, 1), :offset_index => 2},
+      {:at => Time.utc(2000,  2, 1), :offset_index => 3},
+      {:at => Time.utc(2000,  3, 1), :offset_index => 1}]
+
+    # XDT will be based on the utc_offset of XST1 even though XST2 has an
+    # equivalent (or greater) utc_total_offset.
+
+    tzif_test(offsets, transitions) do |path, format|
+      info = ZoneinfoTimezoneInfo.new('Zone/UtcOffsetEqual', path)
+      assert_equal('Zone/UtcOffsetEqual', info.identifier)
+
+      assert_period( :LMT, 3542,    0, false,                   nil, Time.utc(2000,  1, 1), info)
+      assert_period(:XST2, 7200,    0, false, Time.utc(2000,  1, 1), Time.utc(2000,  2, 1), info)
+      assert_period( :XDT, 3600, 3600,  true, Time.utc(2000,  2, 1), Time.utc(2000,  3, 1), info)
+      assert_period(:XST1, 3600,    0, false, Time.utc(2000,  3, 1),                   nil, info)
+    end
+  end
+
+  def test_load_offset_both_adjacent_non_dst_equal_utc_total_offset
+    # The zoneinfo files don't include the offset from standard time, so this
+    # has to be derived by looking at changes in the total UTC offset.
+
+    offsets = [
+      {:gmtoff => 7142, :isdst => false, :abbrev => 'LMT'},
+      {:gmtoff => 7200, :isdst => false, :abbrev => 'XST'},
+      {:gmtoff => 7200, :isdst => true,  :abbrev => 'XDT'}]
+
+    transitions = [
+      {:at => Time.utc(2000,  1, 1), :offset_index => 1},
+      {:at => Time.utc(2000,  2, 1), :offset_index => 2},
+      {:at => Time.utc(2000,  3, 1), :offset_index => 1}]
+
+    # XDT will just assume an std_offset of +1 hour and calculate the utc_offset
+    # from utc_total_offset - std_offset.
+
+    tzif_test(offsets, transitions) do |path, format|
+      info = ZoneinfoTimezoneInfo.new('Zone/AdjacentEqual', path)
+      assert_equal('Zone/AdjacentEqual', info.identifier)
+
+      assert_period(:LMT, 7142,    0, false,                   nil, Time.utc(2000,  1, 1), info)
+      assert_period(:XST, 7200,    0, false, Time.utc(2000,  1, 1), Time.utc(2000,  2, 1), info)
+      assert_period(:XDT, 3600, 3600,  true, Time.utc(2000,  2, 1), Time.utc(2000,  3, 1), info)
+      assert_period(:XST, 7200,    0, false, Time.utc(2000,  3, 1),                   nil, info)
+    end
+  end
+
+  def test_load_offset_utc_offset_preserved_from_next
+    # The zoneinfo files don't include the offset from standard time, so this
+    # has to be derived by looking at changes in the total UTC offset.
+
+    offsets = [
+      {:gmtoff =>  3542, :isdst => false, :abbrev => 'LMT'},
+      {:gmtoff =>  3600, :isdst => false, :abbrev => 'XST1'},
+      {:gmtoff =>  7200, :isdst => false, :abbrev => 'XST2'},
+      {:gmtoff => 10800, :isdst => true,  :abbrev => 'XDT1'},
+      {:gmtoff => 10800, :isdst => true,  :abbrev => 'XDT2'}]
+
+    transitions = [
+      {:at => Time.utc(2000,  1, 1), :offset_index => 1},
+      {:at => Time.utc(2000,  2, 1), :offset_index => 3},
+      {:at => Time.utc(2000,  3, 1), :offset_index => 4},
+      {:at => Time.utc(2000,  4, 1), :offset_index => 2}]
+
+    # Both XDT1 and XDT2 should both use the closest utc_offset (7200) (and not
+    # an equivalent utc_offset of 3600 and std_offset of 7200).
+
+    tzif_test(offsets, transitions) do |path, format|
+      info = ZoneinfoTimezoneInfo.new('Zone/UtcOffsetPreserved', path)
+      assert_equal('Zone/UtcOffsetPreserved', info.identifier)
+
+      assert_period( :LMT, 3542,    0, false,                   nil, Time.utc(2000,  1, 1), info)
+      assert_period(:XST1, 3600,    0, false, Time.utc(2000,  1, 1), Time.utc(2000,  2, 1), info)
+      assert_period(:XDT1, 7200, 3600,  true, Time.utc(2000,  2, 1), Time.utc(2000,  3, 1), info)
+      assert_period(:XDT2, 7200, 3600,  true, Time.utc(2000,  3, 1), Time.utc(2000,  4, 1), info)
+      assert_period(:XST2, 7200,    0, false, Time.utc(2000,  4, 1),                   nil, info)
+    end
+  end
+
+  def test_load_offset_utc_offset_preserved_from_previous
+    # The zoneinfo files don't include the offset from standard time, so this
+    # has to be derived by looking at changes in the total UTC offset.
+
+    offsets = [
+      {:gmtoff =>  3542, :isdst => false, :abbrev => 'LMT'},
+      {:gmtoff =>  3600, :isdst => false, :abbrev => 'XST1'},
+      {:gmtoff =>  7200, :isdst => false, :abbrev => 'XST2'},
+      {:gmtoff => 10800, :isdst => true,  :abbrev => 'XDT1'},
+      {:gmtoff => 10800, :isdst => true,  :abbrev => 'XDT2'}]
+
+    transitions = [
+      {:at => Time.utc(2000,  1, 1), :offset_index => 2},
+      {:at => Time.utc(2000,  2, 1), :offset_index => 3},
+      {:at => Time.utc(2000,  3, 1), :offset_index => 4},
+      {:at => Time.utc(2000,  4, 1), :offset_index => 1}]
+
+    # Both XDT1 and XDT2 should both use the closest utc_offset (7200) (and not
+    # an equivalent utc_offset of 3600 and std_offset of 7200).
+
+    tzif_test(offsets, transitions) do |path, format|
+      info = ZoneinfoTimezoneInfo.new('Zone/UtcOffsetPreserved', path)
+      assert_equal('Zone/UtcOffsetPreserved', info.identifier)
+
+      assert_period( :LMT, 3542,    0, false,                   nil, Time.utc(2000,  1, 1), info)
+      assert_period(:XST2, 7200,    0, false, Time.utc(2000,  1, 1), Time.utc(2000,  2, 1), info)
+      assert_period(:XDT1, 7200, 3600,  true, Time.utc(2000,  2, 1), Time.utc(2000,  3, 1), info)
+      assert_period(:XDT2, 7200, 3600,  true, Time.utc(2000,  3, 1), Time.utc(2000,  4, 1), info)
+      assert_period(:XST1, 3600,    0, false, Time.utc(2000,  4, 1),                   nil, info)
+    end
+  end
   
   def test_load_in_safe_mode
     offsets = [{:gmtoff => -12094, :isdst => false, :abbrev => 'LT'}]