tzinfo 0.0.3 → 0.0.4

data/CHANGES

@@ -0,0 +1,58 @@
+Version 0.0.4 (tzdata v2005m) - 18-Sep-2005
+-------------------------------------------
+
+* Removed debug output accidently included in the previous release.
+* Fixed a bug in the generation of friendly zone identifiers (was inserting
+  apostrophes into UTC, GMT, etc).
+* Fixed Country <=> operator (was comparing non-existant attribute)
+* Fixed Timezone.period_for_local error when period not found.
+* Added testcases for Timezone, TimezoneProxy, TimezonePeriod, Country and
+  some selected timezones.
+
+Version 0.0.3 (tzdata v2005m) - 17-Sep-2005
+-------------------------------------------
+
+* Reduced visibility of some methods added in Timezone#setup and Country#setup.
+* Added name method to Timezone (returns the identifier).
+* Added friendly_identifier method to Timezone. Returns a more friendly version
+  of the identifier.
+* Added to_s method to Timezone. Returns the friendly identifier.
+* Added == and <=> operators to Timezone (compares identifiers).
+* Timezone now includes Comparable.
+* Added to_s method to Country.
+* Added == and <=> operators to Country (compares ISO 3166 country codes).
+* Country now includes Comparable.
+* New TimezoneProxy class that behaves the same as a Timezone but doesn't
+  actually load in its definition until it is actually required.
+* Modified Timezone and Country methods that return Timezones to return
+  TimezoneProxy instances instead. This makes these methods much quicker.
+  
+  In Ruby on Rails, you can now show a drop-down list of all timezones using the
+  Rails time_zone_select helper method:
+  
+  <%= time_zone_select 'user', 'time_zone', TZInfo::Timezone.all.sort, :model => TZInfo::Timezone %>
+
+
+Version 0.0.2 (tzdata v2005m) - 13-Sep-2005 
+-------------------------------------------
+
+* Country and Timezone data is now loaded into class rather than instance 
+  variables. This makes Timezone links more efficient and saves memory if
+  creating specific Timezone and Country classes directly.
+* TimezonePeriod zone_identifier is now defined as a symbol to save memory
+  (was previously a string).
+* TimezonePeriod zone_identifiers that were previously '' are now :Unknown.
+* Timezones and Countries can now be returned using Timezone.new(identifier)
+  and Country.new(identifier). When passed an identifier, the new method
+  calls get to return an instance of the specified timezone or country.
+* Added new class methods to Timezone to return sets of zones and identifiers.
+
+Thanks to Scott Barron of Lunchbox Software for the suggestions in his
+article about using TZInfo with Rails 
+(http://lunchroom.lunchboxsoftware.com/pages/tzinfo_rails)
+
+
+Version 0.0.1 (tzdata v2005m) - 29-Aug-2005 
+-------------------------------------------
+
+* First release.

data/README

@@ -64,7 +64,7 @@ Documentation can be found at
 
 The preferred method of installing TZInfo is through its GEM file (RubyGems[http://docs.rubygems.org/] required):
 
-  % gem install tzinfo-0.0.3.gem
+  % gem install tzinfo-0.0.4.gem
   
 or to automatically download and install:
 
@@ -76,11 +76,6 @@ or to automatically download and install:
 TZInfo is released under the MIT[http://opensource.org/licenses/mit-license.html] license.
 
 
-== Issues
-
-* It currently takes an extremely long time to generate all the Ruby Timezone classes from the tz data. This process could do with some optimization.
-* Test cases need to be written.
-
 == Support
 
 Please contact Philip Ross (phil.ross@gmail.com) if you require assistance or have

data/lib/tzinfo/country.rb

@@ -1,6 +1,10 @@
 require 'tzinfo/timezone'
 
 module TZInfo
+  # Thrown by Country#get if the code given is not valid.
+  class InvalidCountryCode < StandardError
+  end
+  
   # An ISO 3166 country. Can be used to get a list of Timezones for a country.
   # For example:
   #
@@ -13,9 +17,13 @@ module TZInfo
     # Gets a Country by its ISO 3166 code. Raising an exception if it couldn't
     # be found.
     def self.get(identifier)
-      raise 'Invalid identifier' if identifier !~ /^[A-Z]{2}$/
-      require "tzinfo/countries/#{identifier}"
-      Countries.const_get(identifier).instance      
+      raise InvalidCountryCode.new, 'Invalid identifier' if identifier !~ /^[A-Z]{2}$/
+      begin
+        require "tzinfo/countries/#{identifier}"
+        Countries.const_get(identifier).instance
+      rescue LoadError, NameError => e
+        raise InvalidCountryCode, e
+      end
     end
     
     # If identifier is nil calls super(), else calls get(identifier).
@@ -38,12 +46,7 @@ module TZInfo
       all_codes.collect {|code|
         get(code)
       }
-    end
-    
-    # Initializes the Country.
-    def initialize
-            
-    end
+    end       
     
     # The ISO 3166 country code.
     def code
@@ -87,7 +90,7 @@ module TZInfo
     # Compare two Countries based on their code. Returns -1 if tz is less
     # than self, 0 if tz is equal to self and +1 if tz is greater than self.
     def <=>(tz)
-      identifier <=> tz.identifier
+      code <=> tz.code
     end
             
     protected

data/lib/tzinfo/timezone.rb

@@ -1,9 +1,14 @@
 require 'tzinfo/country'
 
 module TZInfo
+  # Thrown to indicate that no TimezonePeriod matching a given time could be found.
   class PeriodNotFound < StandardError
   end
   
+  # Thrown by Timezone#get if the identifier given is not valid.
+  class InvalidTimezoneIdentifier < StandardError
+  end
+  
   # Timezone is the base class of all timezones. It provides a factory method
   # get to access timezones by identifier. Once a specific Timezone has been
   # retrieved, DateTimes and Times can be converted between the UTC and the
@@ -23,21 +28,25 @@ module TZInfo
     #
     # Raises an exception of the timezone couldn't be found.
     def self.get(identifier)
-      raise 'Invalid identifier' if identifier !~ /^[A-z0-9\+\-_]+(\/[A-z0-9\+\-_]+)*$/
+      raise InvalidTimezoneIdentifier, 'Invalid identifier' if identifier !~ /^[A-z0-9\+\-_]+(\/[A-z0-9\+\-_]+)*$/
       identifier = identifier.gsub(/-/, '__m__').gsub(/\+/, '__p__')
-      require "tzinfo/definitions/#{identifier}"
-      
-      m = Definitions
-      identifier.split(/\//).each {|part|
-        m = m.const_get(part)
-      }
-      m.instance      
+      begin
+        require "tzinfo/definitions/#{identifier}"
+        
+        m = Definitions
+        identifier.split(/\//).each {|part|
+          m = m.const_get(part)
+        }
+        m.instance
+      rescue LoadError, NameError => e
+        raise InvalidTimezoneIdentifier, e
+      end
     end
     
-    # If identifier is nil calls super(), else calls get(identifier).
+    # If identifier is nil calls super(), else calls get(identifier). An
+    # identfier should always be passed in when called externally.
     def self.new(identifier = nil)
-      if identifier
-        puts 'getting'
+      if identifier        
         get(identifier)
       else
         super()
@@ -131,13 +140,15 @@ module TZInfo
         parts[1, parts.length - 1].reverse_each {|part|
           part.gsub!(/_/, ' ')
           
-          # Missing a space if a lower case followed by an upper case and the
-          # name isn't McXxxx.
-          part.gsub!(/[^M]([a-z])([A-Z])/, '\1 \2')
-          part.gsub!(/[M]([a-bd-z])([A-Z])/, '\1 \2')
-          
-          # Missing an apostrophe if two consecutive upper case characters.
-          part.gsub!(/([A-Z])([A-Z])/, '\1\'\2')
+          if part.index(/[a-z]/)
+            # Missing a space if a lower case followed by an upper case and the
+            # name isn't McXxxx.
+            part.gsub!(/([^M][a-z])([A-Z])/, '\1 \2')
+            part.gsub!(/([M][a-bd-z])([A-Z])/, '\1 \2')
+            
+            # Missing an apostrophe if two consecutive upper case characters.
+            part.gsub!(/([A-Z])([A-Z])/, '\1\'\2')
+          end
           
           result << part
           result << ', '
@@ -208,11 +219,11 @@ module TZInfo
             if first.local_before_end?(local)
               first
             else
-              raise PeriodNotFound, "No time period found for #{utc}. This could be because a change to daylight savings time caused an hour to be skipped."
+              raise PeriodNotFound, "No time period found for #{local}. This could be because a change to daylight savings time caused an hour to be skipped."
             end
           end
         else
-          raise PeriodNotFound, "No time period found for #{utc}. This could be because a change to daylight savings time caused an hour to be skipped."
+          raise PeriodNotFound, "No time period found for #{local}. This could be because a change to daylight savings time caused an hour to be skipped."
         end
       }
     end
@@ -252,12 +263,14 @@ module TZInfo
       period_for_utc(Time.now.utc)
     end
     
-    # Returns the current time and TimezonePeriod as an array.
+    # Returns the current Time and TimezonePeriod as an array.
     def current_period_and_time
       utc = Time.now.utc
       [utc_to_local(utc), period_for_utc(utc)]
     end
     
+    alias :current_time_and_period :current_period_and_time
+    
     # Two Timezones are considered to be equal if their identifiers are the same.
     def ==(tz)
       identifier == tz.identifier
@@ -408,12 +421,12 @@ CODE
       utc_after_start?(utc) && utc_before_end?(utc) 
     end
     
-    # true if the given utc DateTime is after the start of the period; otherwise false.
+    # true if the given utc DateTime is after the start of the period (inclusive); otherwise false.
     def utc_after_start?(utc)
       @utc_start.nil? || @utc_start <= utc
     end
     
-    # true if the given utc DateTime is before the end of the period; otherwise false.
+    # true if the given utc DateTime is before the end of the period (exclusive); otherwise false.
     def utc_before_end?(utc)
       @utc_end.nil? || @utc_end > utc
     end
@@ -423,12 +436,12 @@ CODE
       local_after_start?(local) && local_before_end?(local) 
     end
     
-    # true if the given local DateTime is after the start of the period; otherwise false.
+    # true if the given local DateTime is after the start of the period (inclusive); otherwise false.
     def local_after_start?(local)
       @local_start.nil? || @local_start <= local
     end
     
-    # true if the given local DateTime is before the end of the period; otherwise false.
+    # true if the given local DateTime is before the end of the period (exclusive); otherwise false.
     def local_before_end?(local)
       @local_end.nil? || @local_end > local
     end

data/test/tc_country.rb

@@ -0,0 +1,127 @@
+$:.unshift File.join(File.dirname(__FILE__), "..", "lib")
+require 'test/unit'
+require 'tzinfo/country'
+
+include TZInfo
+
+class TCCountry < Test::Unit::TestCase
+  def test_get_valid
+    c = Country.get('GB')
+    
+    assert_not_nil(c)
+    require 'tzinfo/countries/GB'
+    assert_same(Countries::GB.instance, c)
+    assert_equal('GB', c.code)
+  end
+    
+  def test_get_not_exist
+    assert_raise(InvalidCountryCode) {
+      Country.get('ZZ')
+    }
+  end
+  
+  def test_get_invalid
+    assert_raise(InvalidCountryCode) {
+      Country.get('../Countries/GB')
+    }
+  end
+  
+  def test_get_nil
+    assert_raise(InvalidCountryCode) {
+      Country.get(nil)
+    }
+  end
+  
+  def test_get_case    
+    assert_raise(InvalidCountryCode) {
+      Country.get('gb')
+    }
+  end
+  
+  def test_new_no_args
+    c = Country.new
+    
+    assert_equal('Unknown', c.code)    
+  end
+  
+  def test_new_nil
+    c = Country.new(nil)
+    
+    assert_equal('Unknown', c.code)    
+  end
+  
+  def test_new_arg
+    c = Country.new('GB')
+    assert_same(Country.get('GB'), c)    
+  end
+  
+  def test_new_arg_not_exist    
+    assert_raise(InvalidCountryCode) {
+      Country.new('ZZ')
+    }
+  end 
+  
+  def test_all_codes
+    all_codes = Country.all_codes
+    assert_kind_of(Array, all_codes)
+  end
+  
+  def test_all
+    all = Country.all    
+    assert_equal(Country.all_codes, all.collect {|c| c.code})
+  end
+  
+  def test_code
+    assert_equal('Unknown', Country.new.code)
+    assert_equal('US', Country.get('US').code)
+  end
+  
+  def test_name
+    assert_kind_of(String, Country.get('US').name)
+  end
+  
+  def test_to_s
+    assert_equal(Country.get('US').name, Country.get('US').to_s)
+    assert_equal(Country.get('GB').name, Country.get('GB').to_s)
+  end
+  
+  def test_zone_names
+    zone_names = Country.get('US').zone_names
+    assert_kind_of(Array, zone_names)
+    assert(zone_names.frozen?)
+  end
+  
+  def test_zone_identifiers
+    assert_equal(Country.get('US').zone_names, Country.get('US').zone_identifiers)
+  end
+  
+  def test_zones
+    zones = Country.get('US').zones
+    assert_equal(Country.get('US').zone_names, zones.collect {|z| z.identifier})
+    
+    zones.each {|z|
+      assert_kind_of(TimezoneProxy, z)
+    }
+  end
+  
+  def test_equals
+    require 'tzinfo/countries/GB'
+    assert(Countries::GB.new == Countries::GB.new)
+    assert(Countries::GB.new == Country.get('GB'))
+    assert(Country.get('GB') == Countries::GB.new)    
+  end
+  
+  def test_compare
+    require 'tzinfo/countries/GB'
+    require 'tzinfo/countries/FR'
+    require 'tzinfo/countries/US'    
+    assert_equal(0, Countries::GB.new <=> Countries::GB.new)
+    assert_equal(0, Country.get('GB') <=> Countries::GB.new)
+    assert_equal(0, Countries::GB.new <=> Country.get('GB'))
+    assert_equal(0, Country.get('GB') <=> Country.get('GB'))
+    assert((Country.get('GB') <=> Country.get('US')) < 0)
+    assert((Country.get('US') <=> Country.get('GB')) > 0)
+    assert((Country.get('FR') <=> Country.get('US')) < 0)
+    assert((Country.get('US') <=> Country.get('FR')) > 0)
+  end
+end

data/test/tc_timezone.rb

@@ -0,0 +1,262 @@
+$:.unshift File.join(File.dirname(__FILE__), "..", "lib")
+require 'test/unit'
+require 'tzinfo/timezone'
+
+include TZInfo
+
+class TCTimezone < Test::Unit::TestCase
+  def test_get_valid_1
+    tz = Timezone.get('Europe/London')
+    
+    assert_not_nil(tz)
+    require 'tzinfo/definitions/Europe/London'
+    assert_same(Definitions::Europe::London.instance, tz)
+    assert_equal('Europe/London', tz.identifier)
+  end
+  
+  def test_get_valid_2
+    tz = Timezone.get('UTC')
+    
+    assert_not_nil(tz)
+    require 'tzinfo/definitions/UTC'
+    assert_same(Definitions::UTC.instance, tz)    
+    assert_equal('UTC', tz.identifier)
+  end
+  
+  def test_get_valid_3
+    tz = Timezone.get('America/Argentina/Buenos_Aires')
+    
+    assert_not_nil(tz)
+    assert_same(Definitions::America::Argentina::Buenos_Aires.instance, tz)
+    require 'tzinfo/definitions/America/Argentina/Buenos_Aires'
+    assert_equal('America/Argentina/Buenos_Aires', tz.identifier)
+  end
+  
+  def test_get_not_exist
+    assert_raise(InvalidTimezoneIdentifier) {
+      Timezone.get('Nowhere/Special')
+    }
+  end
+  
+  def test_get_invalid
+    assert_raise(InvalidTimezoneIdentifier) {
+      Timezone.get('../Definitions/UTC')
+    }
+  end
+  
+  def test_get_nil
+    assert_raise(InvalidTimezoneIdentifier) {
+      Timezone.get(nil)
+    }
+  end
+  
+  def test_get_plus
+    tz = Timezone.get('Etc/GMT+1')
+    
+    assert_not_nil(tz)
+    assert_same(Definitions::Etc::GMT__p__1.instance, tz)
+    assert_equal('Etc/GMT+1', tz.identifier)
+  end
+  
+  def test_get_minus
+    tz = Timezone.get('Etc/GMT-1')
+    
+    assert_not_nil(tz)
+    assert_same(Definitions::Etc::GMT__m__1.instance, tz)
+    assert_equal('Etc/GMT-1', tz.identifier)
+  end
+  
+  def test_get_case    
+    assert_raise(InvalidTimezoneIdentifier) {
+      Timezone.get('Europe/london')
+    }
+  end
+  
+  def test_new_no_args
+    tz = Timezone.new
+    
+    assert_equal('Unknown', tz.identifier)    
+  end
+  
+  def test_new_nil
+    tz = Timezone.new(nil)
+    
+    assert_equal('Unknown', tz.identifier)    
+  end
+  
+  def test_new_arg
+    tz = Timezone.new('Europe/London')
+    assert_same(Timezone.get('Europe/London'), tz)    
+  end
+  
+  def test_new_arg_not_exist    
+    assert_raise(InvalidTimezoneIdentifier) {
+      Timezone.new('Nowhere/Special')
+    }
+  end 
+  
+  def test_all
+    assert_equal(Timezone.all_country_zones, Timezone.all)
+  end
+  
+  def test_all_identifiers
+    assert_equal(Timezone.all_country_zone_identifiers, Timezone.all_identifiers)
+  end
+  
+  def test_all_country_zones
+    # Probably should relax this test - just need all the zones, don't care
+    # about order.
+    expected = Country.all.inject([]) {|expected,country|
+      expected += country.zones
+    }
+    expected.uniq!
+    
+    all_country_zones = Timezone.all_country_zones
+    assert_equal(expected, all_country_zones)
+    
+    all_country_zone_identifiers = Timezone.all_country_zone_identifiers
+    assert_equal(all_country_zone_identifiers.length, all_country_zones.length)
+    
+    all_country_zones.each {|zone|
+      assert_kind_of(TimezoneProxy, zone)
+      assert(all_country_zone_identifiers.include?(zone.identifier))
+    }            
+  end
+  
+  def test_all_country_zone_identifiers
+    # Probably should relax this test - just need all the zones, don't care
+    # about order.
+    expected = Country.all.inject([]) {|expected,country|
+      expected += country.zone_identifiers
+    }
+    expected.uniq!
+        
+    assert_equal(expected, Timezone.all_country_zone_identifiers)
+  end
+  
+  def test_us_zones   
+    # Probably should relax this test - just need all the zones, don't care
+    # about order.
+    us_zones = Timezone.us_zones
+    assert_equal(Country.get('US').zones.uniq, us_zones)
+    
+    us_zone_identifiers = Timezone.us_zone_identifiers
+    assert_equal(us_zone_identifiers.length, us_zones.length)
+    
+    us_zones.each {|zone|
+      assert_kind_of(TimezoneProxy, zone)
+      assert(us_zone_identifiers.include?(zone.identifier))
+    }
+  end
+  
+  def test_us_zone_identifiers
+    # Probably should relax this test - just need all the zones, don't care
+    # about order.        
+    assert_equal(Country.get('US').zone_identifiers.uniq, Timezone.us_zone_identifiers)
+  end
+  
+  def test_identifier
+    assert_equal('Unknown', Timezone.new.identifier)
+    assert_equal('Europe/Paris', Timezone.get('Europe/Paris').identifier)    
+  end
+  
+  def test_name
+    assert_equal('Unknown', Timezone.new.name)
+    assert_equal('Europe/Paris', Timezone.get('Europe/Paris').name)    
+  end
+  
+  def test_friendly_identifier
+    assert_equal('Paris', Timezone.get('Europe/Paris').friendly_identifier(true))
+    assert_equal('Europe - Paris', Timezone.get('Europe/Paris').friendly_identifier(false))
+    assert_equal('Europe - Paris', Timezone.get('Europe/Paris').friendly_identifier)
+    assert_equal('Knox, Indiana', Timezone.get('America/Indiana/Knox').friendly_identifier(true))
+    assert_equal('America - Knox, Indiana', Timezone.get('America/Indiana/Knox').friendly_identifier(false))
+    assert_equal('America - Knox, Indiana', Timezone.get('America/Indiana/Knox').friendly_identifier)
+    assert_equal('Dumont D\'Urville', Timezone.get('Antarctica/DumontDUrville').friendly_identifier(true))
+    assert_equal('Antarctica - Dumont D\'Urville', Timezone.get('Antarctica/DumontDUrville').friendly_identifier(false))
+    assert_equal('Antarctica - Dumont D\'Urville', Timezone.get('Antarctica/DumontDUrville').friendly_identifier)
+    assert_equal('McMurdo', Timezone.get('Antarctica/McMurdo').friendly_identifier(true))
+    assert_equal('Antarctica - McMurdo', Timezone.get('Antarctica/McMurdo').friendly_identifier(false))
+    assert_equal('Antarctica - McMurdo', Timezone.get('Antarctica/McMurdo').friendly_identifier)
+    assert_equal('GMT+1', Timezone.get('Etc/GMT+1').friendly_identifier(true))
+    assert_equal('Etc - GMT+1', Timezone.get('Etc/GMT+1').friendly_identifier(false))
+    assert_equal('Etc - GMT+1', Timezone.get('Etc/GMT+1').friendly_identifier)
+    assert_equal('UTC', Timezone.get('UTC').friendly_identifier(true))
+    assert_equal('UTC', Timezone.get('UTC').friendly_identifier(false))
+    assert_equal('UTC', Timezone.get('UTC').friendly_identifier)
+  end
+  
+  def test_to_s
+    assert_equal('Europe - Paris', Timezone.get('Europe/Paris').to_s)
+    assert_equal('America - Knox, Indiana', Timezone.get('America/Indiana/Knox').to_s)
+    assert_equal('Antarctica - Dumont D\'Urville', Timezone.get('Antarctica/DumontDUrville').to_s)
+    assert_equal('Antarctica - McMurdo', Timezone.get('Antarctica/McMurdo').to_s)
+    assert_equal('Etc - GMT+1', Timezone.get('Etc/GMT+1').to_s)
+    assert_equal('UTC', Timezone.get('UTC').to_s)
+  end    
+  
+  def test_utc_to_local
+    dt = DateTime.new(2005,2,18,16,24,23)
+    t = Time.utc(2005,2,18,16,24,23)
+        
+    assert_equal(dt, Timezone.get('Europe/London').utc_to_local(dt))
+    assert_not_equal(t, Timezone.get('Europe/London').utc_to_local(dt))
+    assert_equal(t, Timezone.get('Europe/London').utc_to_local(t))
+    assert_not_equal(dt, Timezone.get('Europe/London').utc_to_local(t))
+  end    
+  
+  def test_local_to_utc
+    dt = DateTime.new(2005,2,18,16,24,23)
+    t = Time.utc(2005,2,18,16,24,23)
+        
+    assert_equal(dt, Timezone.get('Europe/London').local_to_utc(dt))
+    assert_not_equal(t, Timezone.get('Europe/London').local_to_utc(dt))
+    assert_equal(t, Timezone.get('Europe/London').local_to_utc(t))
+    assert_not_equal(dt, Timezone.get('Europe/London').local_to_utc(t))
+  end
+  
+  def test_now
+    assert_kind_of(Time, Timezone.get('Europe/London').now)
+  end
+  
+  def test_current_period
+    assert_kind_of(TimezonePeriod, Timezone.get('Europe/London').current_period)
+  end
+  
+  def test_current_period_and_time
+    current = Timezone.get('Europe/London').current_period_and_time
+    assert_equal(2, current.length)
+    assert_kind_of(Time, current[0])
+    assert_kind_of(TimezonePeriod, current[1])
+  end
+  
+  def test_current_time_and_period
+    current = Timezone.get('Europe/London').current_time_and_period
+    assert_equal(2, current.length)
+    assert_kind_of(Time, current[0])
+    assert_kind_of(TimezonePeriod, current[1])
+  end
+  
+  def test_equals
+    require 'tzinfo/definitions/Europe/London'
+    assert(Definitions::Europe::London.new == Definitions::Europe::London.new)
+    assert(Definitions::Europe::London.new == Timezone.get('Europe/London'))
+    assert(Timezone.get('Europe/London') == Definitions::Europe::London.new)
+    assert(Timezone.get('Europe/London') == TimezoneProxy.new('Europe/London'))
+    assert(TimezoneProxy.new('Europe/London') == Timezone.get('Europe/London'))
+  end
+  
+  def test_compare
+    require 'tzinfo/definitions/Europe/London'
+    require 'tzinfo/definitions/Europe/Paris'
+    require 'tzinfo/definitions/America/New_York'
+    assert_equal(0, Definitions::Europe::London.new <=> Definitions::Europe::London.new)
+    assert_equal(0, Timezone.get('Europe/London') <=> Definitions::Europe::London.new)
+    assert_equal(0, Definitions::Europe::London.new <=> Timezone.get('Europe/London'))
+    assert_equal(0, Timezone.get('Europe/London') <=> Timezone.get('Europe/London'))
+    assert((Timezone.get('Europe/London') <=> Timezone.get('Europe/Paris')) < 0)
+    assert((Timezone.get('Europe/Paris') <=> Timezone.get('Europe/London')) > 0)
+    assert((Timezone.get('America/New_York') <=> Timezone.get('Europe/Paris')) < 0)
+    assert((Timezone.get('Europe/Paris') <=> Timezone.get('America/New_York')) > 0)
+  end
+end

data/test/tc_timezone_london.rb

@@ -0,0 +1,47 @@
+$:.unshift File.join(File.dirname(__FILE__), "..", "lib")
+require 'test/unit'
+require 'tzinfo/timezone'
+
+include TZInfo
+
+class TCTimezoneLondon < Test::Unit::TestCase
+  def test_2004
+    #Europe/London  Sun Mar 28 00:59:59 2004 UTC = Sun Mar 28 00:59:59 2004 GMT isdst=0 gmtoff=0
+    #Europe/London  Sun Mar 28 01:00:00 2004 UTC = Sun Mar 28 02:00:00 2004 BST isdst=1 gmtoff=3600
+    #Europe/London  Sun Oct 31 00:59:59 2004 UTC = Sun Oct 31 01:59:59 2004 BST isdst=1 gmtoff=3600
+    #Europe/London  Sun Oct 31 01:00:00 2004 UTC = Sun Oct 31 01:00:00 2004 GMT isdst=0 gmtoff=0
+    
+    tz = Timezone.get('Europe/London')
+    assert_equal(DateTime.new(2004,3,28,0,59,59), tz.utc_to_local(DateTime.new(2004,3,28,0,59,59)))
+    assert_equal(DateTime.new(2004,3,28,2,0,0), tz.utc_to_local(DateTime.new(2004,3,28,1,0,0)))    
+    assert_equal(DateTime.new(2004,10,31,1,59,59), tz.utc_to_local(DateTime.new(2004,10,31,0,59,59)))
+    assert_equal(DateTime.new(2004,10,31,1,0,0), tz.utc_to_local(DateTime.new(2004,10,31,1,0,0)))
+    
+    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_raise(PeriodNotFound) { tz.local_to_utc(DateTime.new(2004,3,28,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)
+    assert_equal(:BST, tz.period_for_utc(DateTime.new(2004,10,31,0,59,59)).zone_identifier)
+    assert_equal(:GMT, tz.period_for_utc(DateTime.new(2004,10,31,1,0,0)).zone_identifier)
+    
+    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(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)
+    assert_equal(3600, tz.period_for_utc(DateTime.new(2004,10,31,0,59,59)).utc_total_offset)
+    assert_equal(0, tz.period_for_utc(DateTime.new(2004,10,31,1,0,0)).utc_total_offset)
+    
+    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)
+  end    
+end

data/test/tc_timezone_melbourne.rb

@@ -0,0 +1,47 @@
+$:.unshift File.join(File.dirname(__FILE__), "..", "lib")
+require 'test/unit'
+require 'tzinfo/timezone'
+
+include TZInfo
+
+class TCTimezoneMelbourne < Test::Unit::TestCase
+  def test_2004
+    #Australia/Melbourne  Sat Mar 27 15:59:59 2004 UTC = Sun Mar 28 02:59:59 2004 EST isdst=1 gmtoff=39600
+    #Australia/Melbourne  Sat Mar 27 16:00:00 2004 UTC = Sun Mar 28 02:00:00 2004 EST isdst=0 gmtoff=36000
+    #Australia/Melbourne  Sat Oct 30 15:59:59 2004 UTC = Sun Oct 31 01:59:59 2004 EST isdst=0 gmtoff=36000
+    #Australia/Melbourne  Sat Oct 30 16:00:00 2004 UTC = Sun Oct 31 03:00:00 2004 EST isdst=1 gmtoff=39600
+    
+    tz = Timezone.get('Australia/Melbourne')
+    assert_equal(DateTime.new(2004,3,28,2,59,59), tz.utc_to_local(DateTime.new(2004,3,27,15,59,59)))
+    assert_equal(DateTime.new(2004,3,28,2,0,0), tz.utc_to_local(DateTime.new(2004,3,27,16,0,0)))    
+    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,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_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,10,31,1,59,59)).zone_identifier)
+    assert_equal(:EST, tz.period_for_local(DateTime.new(2004,10,31,3,0,0)).zone_identifier)
+    
+    assert_equal(39600, tz.period_for_utc(DateTime.new(2004,3,27,15,59,59)).utc_total_offset)
+    assert_equal(36000, tz.period_for_utc(DateTime.new(2004,3,27,16,0,0)).utc_total_offset)
+    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(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    
+end

data/test/tc_timezone_new_york.rb

@@ -0,0 +1,47 @@
+$:.unshift File.join(File.dirname(__FILE__), "..", "lib")
+require 'test/unit'
+require 'tzinfo/timezone'
+
+include TZInfo
+
+class TCTimezoneNewYork < Test::Unit::TestCase
+  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)))
+    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_raise(PeriodNotFound) { tz.local_to_utc(DateTime.new(2004,4,4,2,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)).zone_identifier)
+    assert_equal(:EDT, tz.period_for_local(DateTime.new(2004,10,31,1,0,0)).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)).utc_total_offset)
+    assert_equal(-14400, tz.period_for_local(DateTime.new(2004,10,31,1,0,0)).utc_total_offset)
+  end    
+end

data/test/tc_timezone_period.rb

@@ -0,0 +1,200 @@
+$:.unshift File.join(File.dirname(__FILE__), "..", "lib")
+require 'test/unit'
+require 'tzinfo/timezone'
+
+include TZInfo
+
+class TCTimezonePeriod < Test::Unit::TestCase
+  def test_initialize
+    p1 = TimezonePeriod.new(DateTime.new(2005,1,1,0,0,0), DateTime.new(2005,1,2,0,0,0), -7200, 3600, :TEST)
+    p2 = TimezonePeriod.new(nil, nil, -7200, 3600, :TEST)
+    
+    assert_equal(DateTime.new(2005,1,1,0,0,0), p1.utc_start)
+    assert_equal(DateTime.new(2005,1,2,0,0,0), p1.utc_end)
+    assert_equal(-7200, p1.utc_offset)
+    assert_equal(3600, p1.std_offset)
+    assert_equal(:TEST, p1.zone_identifier)    
+    assert_equal(DateTime.new(2004,12,31,23,0,0), p1.local_start)    
+    assert_equal(DateTime.new(2005,1,1,23,0,0), p1.local_end)
+    
+    assert_nil(p2.utc_start)
+    assert_nil(p2.utc_end)
+    assert_equal(-7200, p2.utc_offset)
+    assert_equal(3600, p2.std_offset)
+    assert_equal(:TEST, p2.zone_identifier)    
+    assert_nil(p2.local_start)    
+    assert_nil(p2.local_end)
+  end
+  
+  def test_utc_total_offset
+    p1 = TimezonePeriod.new(DateTime.new(2005,1,1,0,0,0), DateTime.new(2005,1,2,0,0,0), -14400, 3600, :TEST)
+    p2 = TimezonePeriod.new(DateTime.new(2005,1,1,0,0,0), DateTime.new(2005,1,2,0,0,0), -14400, 0, :TEST)
+    p3 = TimezonePeriod.new(DateTime.new(2005,1,1,0,0,0), DateTime.new(2005,1,2,0,0,0), 7200, 3600, :TEST)
+    
+    assert_equal(-10800, p1.utc_total_offset)
+    assert_equal(-14400, p2.utc_total_offset)
+    assert_equal(10800, p3.utc_total_offset)
+  end
+  
+  def test_utc_total_offset_rational
+    p = TimezonePeriod.new(DateTime.new(2005,1,1,0,0,0), DateTime.new(2005,1,2,0,0,0), -14400, 3600, :TEST)
+    
+    assert_equal(Rational(-10800, 24 * 60 * 60), p.utc_total_offset_rational)
+  end
+  
+  def test_dst
+    p1 = TimezonePeriod.new(DateTime.new(2005,1,1,0,0,0), DateTime.new(2005,1,2,0,0,0), -14400, 3600, :TEST)
+    p2 = TimezonePeriod.new(DateTime.new(2005,1,1,0,0,0), DateTime.new(2005,1,2,0,0,0), -14400, 0, :TEST)
+    p3 = TimezonePeriod.new(DateTime.new(2005,1,1,0,0,0), DateTime.new(2005,1,2,0,0,0), -14400, -3600, :TEST)
+    p4 = TimezonePeriod.new(DateTime.new(2005,1,1,0,0,0), DateTime.new(2005,1,2,0,0,0), -14400, 7200, :TEST)
+    p5 = TimezonePeriod.new(DateTime.new(2005,1,1,0,0,0), DateTime.new(2005,1,2,0,0,0), -14400, -7200, :TEST)
+    
+    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
+    p1 = TimezonePeriod.new(DateTime.new(2005,1,1,1,1,1), DateTime.new(2005,2,2,2,2,2), -7200, 3600, :TEST)
+    p2 = TimezonePeriod.new(nil, DateTime.new(2005,2,2,2,2,2), -7200, 3600, :TEST)
+    p3 = TimezonePeriod.new(DateTime.new(2005,1,1,1,1,1), nil, -7200, 3600, :TEST)
+    p4 = TimezonePeriod.new(nil, nil, -7200, 3600, :TEST)
+    
+    assert_equal(true, p1.valid_for_utc?(DateTime.new(2005,1,1,1,1,1)))
+    assert_equal(true, p1.valid_for_utc?(DateTime.new(2005,2,2,2,2,1)))
+    assert_equal(true, p1.valid_for_utc?(DateTime.new(2005,1,1,1,1,2)))
+    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(true, p2.valid_for_utc?(DateTime.new(2005,1,1,1,1,1)))
+    assert_equal(true, p2.valid_for_utc?(DateTime.new(2005,2,2,2,2,1)))
+    assert_equal(true, p2.valid_for_utc?(DateTime.new(2005,1,1,1,1,2)))
+    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, p3.valid_for_utc?(DateTime.new(2005,1,1,1,1,1)))
+    assert_equal(true, p3.valid_for_utc?(DateTime.new(2005,2,2,2,2,1)))
+    assert_equal(true, p3.valid_for_utc?(DateTime.new(2005,1,1,1,1,2)))
+    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(true, p4.valid_for_utc?(DateTime.new(2005,1,1,1,1,1)))
+    assert_equal(true, p4.valid_for_utc?(DateTime.new(2005,2,2,2,2,1)))
+    assert_equal(true, p4.valid_for_utc?(DateTime.new(2005,1,1,1,1,2)))
+    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)))
+  end
+  
+  def test_utc_after_start
+    p1 = TimezonePeriod.new(DateTime.new(2005,1,1,1,1,1), DateTime.new(2005,2,2,2,2,2), -7200, 3600, :TEST)
+    p2 = TimezonePeriod.new(nil, DateTime.new(2005,2,2,2,2,2), -7200, 3600, :TEST)
+
+    assert_equal(true, p1.utc_after_start?(DateTime.new(2005,1,1,1,1,1)))    
+    assert_equal(true, p1.utc_after_start?(DateTime.new(2005,1,1,1,1,2)))
+    assert_equal(false, p1.utc_after_start?(DateTime.new(2005,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?(DateTime.new(2005,1,1,1,1,2)))
+    assert_equal(true, p2.utc_after_start?(DateTime.new(2005,1,1,1,1,0)))    
+  end
+  
+  def test_utc_before_end
+    p1 = TimezonePeriod.new(DateTime.new(2005,1,1,1,1,1), DateTime.new(2005,2,2,2,2,2), -7200, 3600, :TEST)    
+    p2 = TimezonePeriod.new(DateTime.new(2005,1,1,1,1,1), nil, -7200, 3600, :TEST)    
+        
+    assert_equal(true, p1.utc_before_end?(DateTime.new(2005,2,2,2,2,1)))    
+    assert_equal(true, p1.utc_before_end?(DateTime.new(2005,2,2,2,2,0)))   
+    assert_equal(false, p1.utc_before_end?(DateTime.new(2005,2,2,2,2,3)))
+    
+    assert_equal(true, p2.utc_before_end?(DateTime.new(2005,2,2,2,2,1)))    
+    assert_equal(true, p2.utc_before_end?(DateTime.new(2005,2,2,2,2,0)))   
+    assert_equal(true, p2.utc_before_end?(DateTime.new(2005,2,2,2,2,3)))
+  end
+  
+  def test_valid_for_local
+    p1 = TimezonePeriod.new(DateTime.new(2005,1,1,2,1,1), DateTime.new(2005,2,2,3,2,2), -7200, 3600, :TEST)
+    p2 = TimezonePeriod.new(nil, DateTime.new(2005,2,2,3,2,2), -7200, 3600, :TEST)
+    p3 = TimezonePeriod.new(DateTime.new(2005,1,1,2,1,1), nil, -7200, 3600, :TEST)
+    p4 = TimezonePeriod.new(nil, nil, -7200, 3600, :TEST)
+    
+    assert_equal(true, p1.valid_for_local?(DateTime.new(2005,1,1,1,1,1)))
+    assert_equal(true, p1.valid_for_local?(DateTime.new(2005,2,2,2,2,1)))
+    assert_equal(true, p1.valid_for_local?(DateTime.new(2005,1,1,1,1,2)))
+    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(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?(DateTime.new(2005,1,1,1,1,2)))
+    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, 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?(DateTime.new(2005,1,1,1,1,2)))
+    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(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?(DateTime.new(2005,1,1,1,1,2)))
+    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)))
+  end
+  
+  def test_local_after_start
+    p1 = TimezonePeriod.new(DateTime.new(2005,1,1,2,1,1), DateTime.new(2005,2,2,3,2,2), -7200, 3600, :TEST)
+    p2 = TimezonePeriod.new(nil, DateTime.new(2005,2,2,3,2,2), -7200, 3600, :TEST)
+
+    assert_equal(true, p1.local_after_start?(DateTime.new(2005,1,1,1,1,1)))    
+    assert_equal(true, p1.local_after_start?(DateTime.new(2005,1,1,1,1,2)))
+    assert_equal(false, p1.local_after_start?(DateTime.new(2005,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?(DateTime.new(2005,1,1,1,1,2)))
+    assert_equal(true, p2.local_after_start?(DateTime.new(2005,1,1,1,1,0)))    
+  end
+  
+  def test_local_before_end
+    p1 = TimezonePeriod.new(DateTime.new(2005,1,1,2,1,1), DateTime.new(2005,2,2,3,2,2), -7200, 3600, :TEST)    
+    p2 = TimezonePeriod.new(DateTime.new(2005,1,1,2,1,1), nil, -7200, 3600, :TEST)    
+        
+    assert_equal(true, p1.local_before_end?(DateTime.new(2005,2,2,2,2,1)))    
+    assert_equal(true, p1.local_before_end?(DateTime.new(2005,2,2,2,2,0)))   
+    assert_equal(false, p1.local_before_end?(DateTime.new(2005,2,2,2,2,3)))
+    
+    assert_equal(true, p2.local_before_end?(DateTime.new(2005,2,2,2,2,1)))    
+    assert_equal(true, p2.local_before_end?(DateTime.new(2005,2,2,2,2,0)))   
+    assert_equal(true, p2.local_before_end?(DateTime.new(2005,2,2,2,2,3)))
+  end
+  
+  def test_to_local
+    p1 = TimezonePeriod.new(DateTime.new(2005,1,1,0,0,0), DateTime.new(2005,2,2,0,0,0), -14400, 3600, :TEST)
+    p2 = TimezonePeriod.new(DateTime.new(2005,1,1,0,0,0), DateTime.new(2005,2,2,0,0,0), -14400, 0, :TEST)
+    p3 = TimezonePeriod.new(DateTime.new(2005,1,1,0,0,0), DateTime.new(2005,2,2,0,0,0), 7200, 3600, :TEST)
+        
+    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,21,0,0), p2.to_local(DateTime.new(2005,1,20,1,0,0)))
+    assert_equal(DateTime.new(2005,1,20,4,0,0), p3.to_local(DateTime.new(2005,1,20,1,0,0)))
+  end
+  
+  def test_to_utc
+    p1 = TimezonePeriod.new(DateTime.new(2005,1,1,0,0,0), DateTime.new(2005,2,2,0,0,0), -14400, 3600, :TEST)
+    p2 = TimezonePeriod.new(DateTime.new(2005,1,1,0,0,0), DateTime.new(2005,2,2,0,0,0), -14400, 0, :TEST)
+    p3 = TimezonePeriod.new(DateTime.new(2005,1,1,0,0,0), DateTime.new(2005,2,2,0,0,0), 7200, 3600, :TEST)
+        
+    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,5,0,0), p2.to_utc(DateTime.new(2005,1,20,1,0,0)))
+    assert_equal(DateTime.new(2005,1,19,22,0,0), p3.to_utc(DateTime.new(2005,1,20,1,0,0)))
+  end
+end

data/test/tc_timezone_proxy.rb

@@ -0,0 +1,76 @@
+$:.unshift File.join(File.dirname(__FILE__), "..", "lib")
+require 'test/unit'
+require 'tzinfo/timezone'
+
+include TZInfo
+
+class TCTimezoneProxy < Test::Unit::TestCase
+  def test_not_exist
+    proxy = TimezoneProxy.new('Nothing/Special')
+    assert_equal('Nothing/Special', proxy.identifier)
+    assert_raise(InvalidTimezoneIdentifier) { proxy.now }
+    assert_raise(InvalidTimezoneIdentifier) { proxy.current_period }
+    assert_raise(InvalidTimezoneIdentifier) { proxy.current_period_and_time }
+    assert_raise(InvalidTimezoneIdentifier) { proxy.current_time_and_period }
+    assert_raise(InvalidTimezoneIdentifier) { proxy.utc_to_local(DateTime.new(2006,1,1,0,0,0)) }
+    assert_raise(InvalidTimezoneIdentifier) { proxy.local_to_utc(DateTime.new(2006,1,1,0,0,0)) }
+    assert_raise(InvalidTimezoneIdentifier) { proxy.period_for_utc(DateTime.new(2006,1,1,0,0,0)) }
+    assert_raise(InvalidTimezoneIdentifier) { proxy.period_for_local(DateTime.new(2006,1,1,0,0,0)) }
+  end
+  
+  def test_valid
+    proxy = TimezoneProxy.new('Europe/London')
+    assert_equal('Europe/London', proxy.identifier)
+    
+    assert_nothing_raised { proxy.now }
+    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('Europe/London', proxy.identifier)
+    
+    assert(real == proxy)
+    assert(proxy == real)
+    assert_equal(0, real <=> proxy)
+    assert_equal(0, proxy <=> real)
+  end
+  
+  def test_equals
+    assert(TimezoneProxy.new('Europe/London') == TimezoneProxy.new('Europe/London'))
+  end
+  
+  def test_compare
+    assert_equal(0, TimezoneProxy.new('Europe/London') <=> TimezoneProxy.new('Europe/London'))
+    assert_equal(0, Timezone.get('Europe/London') <=> TimezoneProxy.new('Europe/London'))
+    assert_equal(0, TimezoneProxy.new('Europe/London') <=> Timezone.get('Europe/London'))
+    assert((TimezoneProxy.new('Europe/London') <=> TimezoneProxy.new('Europe/Paris')) < 0)
+    assert((Timezone.get('Europe/London') <=> TimezoneProxy.new('Europe/Paris')) < 0)
+    assert((TimezoneProxy.new('Europe/London') <=> Timezone.get('Europe/Paris')) < 0)
+    assert((TimezoneProxy.new('Europe/Paris') <=> TimezoneProxy.new('Europe/London')) > 0)
+    assert((Timezone.get('Europe/Paris') <=> TimezoneProxy.new('Europe/London')) > 0)
+    assert((TimezoneProxy.new('Europe/Paris') <=> Timezone.get('Europe/London')) > 0)
+    assert((TimezoneProxy.new('America/New_York') <=> TimezoneProxy.new('Europe/Paris')) < 0)
+    assert((Timezone.get('America/New_York') <=> TimezoneProxy.new('Europe/Paris')) < 0)
+    assert((TimezoneProxy.new('America/New_York') <=> Timezone.get('Europe/Paris')) < 0)
+    assert((TimezoneProxy.new('Europe/Paris') <=> TimezoneProxy.new('America/New_York')) > 0)
+    assert((Timezone.get('Europe/Paris') <=> TimezoneProxy.new('America/New_York')) > 0)
+    assert((TimezoneProxy.new('Europe/Paris') <=> Timezone.get('America/New_York')) > 0)
+  end
+  
+  def test_kind
+    assert_kind_of(Timezone, TimezoneProxy.new('America/New_York'))
+  end
+end

data/test/ts_all.rb

@@ -0,0 +1,2 @@
+require 'test/unit'
+Dir['tc_*.rb'].each {|t| require t}

metadata

@@ -3,8 +3,8 @@ rubygems_version: 0.8.10
 specification_version: 1
 name: tzinfo
 version: !ruby/object:Gem::Version 
-  version: 0.0.3
-date: 2005-09-17
+  version: 0.0.4
+date: 2005-09-18
 summary: Daylight-savings aware timezone library
 require_paths: 
   - lib
@@ -850,11 +850,21 @@ files:
   - lib/tzinfo/definitions/US/Pacific.rb
   - lib/tzinfo/definitions/US/Pacific__m__New.rb
   - lib/tzinfo/definitions/US/Samoa.rb
+  - test/tc_country.rb
+  - test/tc_timezone.rb
+  - test/tc_timezone_london.rb
+  - test/tc_timezone_melbourne.rb
+  - test/tc_timezone_new_york.rb
+  - test/tc_timezone_period.rb
+  - test/tc_timezone_proxy.rb
+  - test/ts_all.rb
   - README
+  - CHANGES
 test_files: []
 rdoc_options: []
 extra_rdoc_files: 
   - README
+  - CHANGES
 executables: []
 extensions: []
 requirements: []