timecop 0.9.6 → 0.9.9

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: c86a01ea95f5019cb15a6a66c5668e68e7f1e293ca14b910a10cbe1cdd70d668
-  data.tar.gz: e5c6987d3a452fa9ead841021f93bf4ea6bac713c1f6cea38cfc1c1d49baf6ee
+  metadata.gz: 5ffc3899071434ff0ae8eb0a9e4a6ea4c2d8794547113c272bdc24a384d2eb45
+  data.tar.gz: e9333e4c2cf362558c432d7b954a724ff588e66c4dcce8d3af4a327dd6dcb894
 SHA512:
-  metadata.gz: 4abbcd2d37b9fdf6dfb1ed1f63f945a882cd62a47ae2ae237da003ccac0bc660572be0800933ea484fb1632707bdc2de457b96f9aad8a62b1dfd96d766220692
-  data.tar.gz: a19cc9026478a29161a832454edebf76105d56d3841575af71e9dbaa305a40a68af285d17b7473369ae913e463cadd7b67ab2e099d13d3162b713d2c3cd87d05
+  metadata.gz: 692759ecf208cccb83f72d2cd2a3632d6fb6477e9ac1dbf1ca19d8c23a0b864093abdfdc1d51ee98078858dc2dd3eab50f1bd8b469cc84f0619c99bed242169f
+  data.tar.gz: 85fc3b65a8f415601a047d4189ff497a73f49d4d48647881a6579d82dc6f12ab9e6a088da0ca2b3c2a25693f220ce3c8f31b5f2847f6a5d4784c63ace77136ff

data/README.markdown

@@ -5,7 +5,7 @@
 
 ## DESCRIPTION
 
-A gem providing "time travel" and "time freezing" capabilities, making it dead simple to test time-dependent code.  It provides a unified method to mock Time.now, Date.today, and DateTime.now in a single call.
+A gem providing "time travel" and "time freezing" capabilities, making it dead simple to test time-dependent code. It provides a unified method to mock `Time.now`, `Date.today`, `DateTime.now`, and `Process.clock_gettime` in a single call.
 
 ## INSTALL
 
@@ -17,13 +17,13 @@ A gem providing "time travel" and "time freezing" capabilities, making it dead s
 - Travel back to a specific point in time, but allow time to continue moving forward from there.
 - Scale time by a given scaling factor that will cause time to move at an accelerated pace.
 - No dependencies, can be used with _any_ ruby project
-- Timecop api allows arguments to be passed into #freeze and #travel as one of the following:
+- Timecop api allows arguments to be passed into `#freeze` and `#travel` as one of the following:
   - Time instance
   - DateTime instance
   - Date instance
   - individual arguments (year, month, day, hour, minute, second)
-  - a single integer argument that is interpreted as an offset in seconds from Time.now
-- Nested calls to Timecop#travel and Timecop#freeze are supported -- each block will maintain its interpretation of now.
+  - a single integer argument that is interpreted as an offset in seconds from `Time.now`
+- Nested calls to `Timecop#travel` and `Timecop#freeze` are supported -- each block will maintain its interpretation of now.
 - Works with regular Ruby projects, and Ruby on Rails projects
 
 ## USAGE
@@ -62,7 +62,7 @@ helpful if your whole application is time-sensitive.  It allows you to build
 your test data at a single point in time, and to move in/out of that time as
 appropriate (within your tests)
 
-in config/environments/test.rb
+in `config/environments/test.rb`
 
 ```ruby
 config.after_initialize do
@@ -74,10 +74,10 @@ end
 
 ### The difference between Timecop.freeze and Timecop.travel
 
-freeze is used to statically mock the concept of now. As your program executes,
-Time.now will not change unless you make subsequent calls into the Timecop API.
-travel, on the other hand, computes an offset between what we currently think
-Time.now is (recall that we support nested traveling) and the time passed in.
+`freeze` is used to statically mock the concept of now. As your program executes,
+`Time.now` will not change unless you make subsequent calls into the Timecop API.
+`travel`, on the other hand, computes an offset between what we currently think
+`Time.now` is (recall that we support nested traveling) and the time passed in.
 It uses this offset to simulate the passage of time.  To demonstrate, consider
 the following code snippets:
 

data/lib/timecop/time_extensions.rb

@@ -50,21 +50,28 @@ class Date #:nodoc:
 
       d = Date._strptime(str, fmt)
       now = Time.now.to_date
-      year = d[:year] || now.year
+      year = d[:year] || d[:cwyear] || now.year
       mon = d[:mon] || now.mon
       if d.keys == [:year]
         Date.new(year, 1, 1, start)
       elsif d[:mday]
         Date.new(year, mon, d[:mday], start)
-      elsif d[:wday]
-        Date.new(year, mon, now.mday, start) + (d[:wday] - now.wday)
       elsif d[:yday]
         Date.new(year, 1, 1, start).next_day(d[:yday] - 1)
-      elsif d[:cwyear] && d[:cweek]
-        if d[:cwday]
-          Date.commercial(d[:cwyear], d[:cweek], d[:cwday], start)
-        else
-          Date.commercial(d[:cwyear], d[:cweek], 1, start)
+      elsif d[:cwyear] || d[:cweek] || d[:wnum0] || d[:wnum1] || d[:wday] || d[:cwday]
+        week = d[:cweek] || d[:wnum1] || d[:wnum0] || now.strftime('%W').to_i
+        if d[:wnum0] #Week of year where week starts on sunday
+          if d[:cwday] #monday based day of week
+            Date.strptime_without_mock_date("#{year} #{week} #{d[:cwday]}", '%Y %U %u', start)
+          else
+            Date.strptime_without_mock_date("#{year} #{week} #{d[:wday] || 0}", '%Y %U %w', start)
+          end
+        else #Week of year where week starts on monday
+          if d[:wday] #sunday based day of week
+            Date.strptime_without_mock_date("#{year} #{week} #{d[:wday]}", '%Y %W %w', start)
+          else
+            Date.strptime_without_mock_date("#{year} #{week} #{d[:cwday] || 1}", '%Y %W %u', start)
+          end
         end
       elsif d[:seconds]
         Time.at(d[:seconds]).to_date
@@ -125,7 +132,6 @@ class DateTime #:nodoc:
     alias_method :now, :now_with_mock_time
 
     def parse_with_mock_date(*args)
-      date_hash = Date._parse(*args)
       parsed_date = parse_without_mock_date(*args)
       return parsed_date unless mocked_time_stack_item
       date_hash = DateTime._parse(*args)
@@ -137,8 +143,17 @@ class DateTime #:nodoc:
         DateTime.new(mocked_time_stack_item.year, date_hash[:mon], date_hash[:mday])
       when date_hash[:mday]
         DateTime.new(mocked_time_stack_item.year, mocked_time_stack_item.month, date_hash[:mday])
+      when date_hash[:wday] && date_hash[:hour] && date_hash[:min]
+        closest_date = Date.closest_wday(date_hash[:wday]).to_datetime
+
+        DateTime.new(
+          closest_date.year, closest_date.month, closest_date.day,
+          date_hash[:hour], date_hash[:min]
+        )
       when date_hash[:wday]
         Date.closest_wday(date_hash[:wday]).to_datetime
+      when date_hash[:hour] && date_hash[:min] && date_hash[:sec]
+        DateTime.new(mocked_time_stack_item.year, mocked_time_stack_item.month, mocked_time_stack_item.day, date_hash[:hour], date_hash[:min], date_hash[:sec])
       else
         parsed_date + mocked_time_stack_item.travel_offset_days
       end
@@ -152,3 +167,59 @@ class DateTime #:nodoc:
     end
   end
 end
+
+if RUBY_VERSION >= '2.1.0'
+  module Process #:nodoc:
+    class << self
+      alias_method :clock_gettime_without_mock, :clock_gettime
+
+      def clock_gettime_mock_time(clock_id, unit = :float_second)
+        mock_time = case clock_id
+                    when Process::CLOCK_MONOTONIC
+                      mock_time_monotonic
+                    when Process::CLOCK_REALTIME
+                      mock_time_realtime
+                    end
+
+        return clock_gettime_without_mock(clock_id, unit) unless mock_time
+
+        divisor = case unit
+                  when :float_second
+                    1_000_000_000.0
+                  when :second
+                    1_000_000_000
+                  when :float_millisecond
+                    1_000_000.0
+                  when :millisecond
+                    1_000_000
+                  when :float_microsecond
+                    1000.0
+                  when :microsecond
+                    1000
+                  when :nanosecond
+                    1
+                  end
+
+        (mock_time / divisor)
+      end
+
+      alias_method :clock_gettime, :clock_gettime_mock_time
+
+      private
+
+      def mock_time_monotonic
+        mocked_time_stack_item = Timecop.top_stack_item
+        mocked_time_stack_item.nil? ? nil : mocked_time_stack_item.monotonic
+      end
+
+      def mock_time_realtime
+        mocked_time_stack_item = Timecop.top_stack_item
+
+        return nil if mocked_time_stack_item.nil?
+
+        t = mocked_time_stack_item.time
+        t.to_i * 1_000_000_000 + t.nsec
+      end
+    end
+  end
+end

data/lib/timecop/time_stack_item.rb

@@ -9,6 +9,7 @@ class Timecop
       @travel_offset  = @scaling_factor = nil
       @scaling_factor = args.shift if mock_type == :scale
       @mock_type      = mock_type
+      @monotonic      = parse_monotonic_time(*args) if RUBY_VERSION >= '2.1.0'
       @time           = parse_time(*args)
       @time_was       = Time.now_without_mock_time
       @travel_offset  = compute_travel_offset
@@ -54,6 +55,26 @@ class Timecop
       @scaling_factor
     end
 
+    if RUBY_VERSION >= '2.1.0'
+      def monotonic
+        if travel_offset.nil?
+          @monotonic
+        elsif scaling_factor.nil?
+          current_monotonic + travel_offset * (10 ** 9)
+        else
+          (@monotonic + (current_monotonic - @monotonic) * scaling_factor).to_i
+        end
+      end
+
+      def current_monotonic
+        Process.clock_gettime_without_mock(Process::CLOCK_MONOTONIC, :nanosecond)
+      end
+
+      def current_monotonic_with_mock
+        Process.clock_gettime_mock_time(Process::CLOCK_MONOTONIC, :nanosecond)
+      end
+    end
+
     def time(time_klass = Time) #:nodoc:
       if @time.respond_to?(:in_time_zone)
         time = time_klass.at(@time.dup.localtime)
@@ -97,6 +118,16 @@ class Timecop
       Rational(utc_offset, 24 * 60 * 60)
     end
 
+    def parse_monotonic_time(*args)
+      arg = args.shift
+      offset_in_nanoseconds = if args.empty? && (arg.kind_of?(Integer) || arg.kind_of?(Float))
+        arg * 1_000_000_000
+      else
+        0
+      end
+      current_monotonic_with_mock + offset_in_nanoseconds
+    end
+
     def parse_time(*args)
       arg = args.shift
       if arg.is_a?(Time)

data/lib/timecop/timecop.rb

@@ -38,6 +38,12 @@ class Timecop
     # previous values after the block has finished executing.  This allows us to nest multiple
     # calls to Timecop.travel and have each block maintain it's concept of "now."
     #
+    # The Process.clock_gettime call mocks both CLOCK::MONOTIC and CLOCK::REALTIME
+    #
+    # CLOCK::MONOTONIC works slightly differently than other clocks. This clock cannot move to a
+    # particular date/time. So the only option that changes this clock is #4 which will move the
+    # clock the requested offset. Otherwise the clock is frozen to the current tick.
+    #
     # * Note: Timecop.freeze will actually freeze time.  This can cause unanticipated problems if
     #   benchmark or other timing calls are executed, which implicitly expect Time to actually move
     #   forward.
@@ -121,9 +127,19 @@ class Timecop
       instance.thread_safe
     end
 
-    # Returns whether or not Timecop is currently frozen/travelled
+    # Returns whether or not Timecop is currently frozen
     def frozen?
-      !instance.stack.empty?
+      !instance.stack.empty? && instance.stack.last.mock_type == :freeze
+    end
+
+    # Returns whether or not Timecop is currently travelled
+    def travelled?
+      !instance.stack.empty? && instance.stack.last.mock_type == :travel
+    end
+
+    # Returns whether or not Timecop is currently scaled
+    def scaled?
+      !instance.stack.empty? && instance.stack.last.mock_type == :scale
     end
 
     private

data/lib/timecop/version.rb

@@ -1,3 +1,3 @@
 class Timecop
-  VERSION = "0.9.6"
+  VERSION = "0.9.9"
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: timecop
 version: !ruby/object:Gem::Version
-  version: 0.9.6
+  version: 0.9.9
 platform: ruby
 authors:
 - Travis Jeffery
@@ -9,7 +9,7 @@ authors:
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2022-11-29 00:00:00.000000000 Z
+date: 2024-06-01 00:00:00.000000000 Z
 dependencies: []
 description: A gem providing "time travel" and "time freezing" capabilities, making
   it dead simple to test time-dependent code.  It provides a unified method to mock
@@ -29,11 +29,6 @@ files:
 - lib/timecop/time_stack_item.rb
 - lib/timecop/timecop.rb
 - lib/timecop/version.rb
-- test/test_helper.rb
-- test/time_stack_item_test.rb
-- test/timecop_test.rb
-- test/timecop_without_date_but_with_time_test.rb
-- test/timecop_without_date_test.rb
 homepage: https://github.com/travisjeffery/timecop
 licenses:
 - MIT
@@ -56,13 +51,8 @@ required_rubygems_version: !ruby/object:Gem::Requirement
 requirements: []
 rubygems_version: 3.2.15
 signing_key:
-specification_version: 3
+specification_version: 4
 summary: A gem providing "time travel" and "time freezing" capabilities, making it
   dead simple to test time-dependent code.  It provides a unified method to mock Time.now,
   Date.today, and DateTime.now in a single call.
-test_files:
-- test/test_helper.rb
-- test/time_stack_item_test.rb
-- test/timecop_test.rb
-- test/timecop_without_date_test.rb
-- test/timecop_without_date_but_with_time_test.rb
+test_files: []

data/test/test_helper.rb

@@ -1,59 +0,0 @@
-require 'bundler/setup'
-require 'minitest/autorun'
-require 'minitest/rg'
-require 'pry'
-
-$VERBOSE = true # enable ruby warnings
-
-require 'mocha/minitest'
-
-class Minitest::Test
-  private
-    # Tests to see that two times are within the given distance,
-    # in seconds, from each other.
-    def times_effectively_equal(time1, time2, seconds_interval = 1)
-      (time1 - time2).abs <= seconds_interval
-    end
-
-    def assert_times_effectively_equal(time1, time2, seconds_interval = 1, msg = nil)
-      assert times_effectively_equal(time1, time2, seconds_interval), "#{msg}: time1 = #{time1.to_s}, time2 = #{time2.to_s}"
-    end
-
-    def assert_times_effectively_not_equal(time1, time2, seconds_interval = 1, msg = nil)
-      assert !times_effectively_equal(time1, time2, seconds_interval), "#{msg}: time1 = #{time1.to_s}, time2 = #{time2.to_s}"
-    end
-
-    # Gets the local offset (supplied by ENV['TZ'] or your computer's clock)
-    # At the given timestamp, or Time.now if not time is given.
-    def local_offset(time = Time.now)
-      Time.at(time.to_i).to_datetime.offset
-    end
-
-    TIMEZONES = ["Pacific/Midway", "Europe/Paris", "UTC", "America/Chicago"]
-
-    def each_timezone
-      old_tz = ENV["TZ"]
-
-      begin
-        TIMEZONES.each do |timezone|
-          ENV["TZ"] = timezone
-          yield
-        end
-      ensure
-        ENV["TZ"] = old_tz
-      end
-    end
-
-    def a_time_stack_item
-      Timecop::TimeStackItem.new(:freeze, 2008, 1, 1, 0, 0, 0)
-    end
-
-    def assert_date_times_equal(dt1, dt2)
-      assert_in_delta dt1.to_time.to_f, dt2.to_time.to_f, 0.01, "Failed for timezone: #{ENV['TZ']}: #{dt1.to_s} not equal to #{dt2.to_s}"
-    end
-
-    def jruby?
-      RUBY_PLATFORM == "java"
-    end
-
-end

data/test/time_stack_item_test.rb

@@ -1,299 +0,0 @@
-require 'date'
-require_relative "test_helper"
-require 'timecop'
-
-require 'active_support/all'
-
-class TestTimeStackItem < Minitest::Test
-  def teardown
-    Timecop.return
-    Time.zone = nil
-  end
-
-  def test_new_with_time
-    t = Time.now
-    y, m, d, h, min, s = t.year, t.month, t.day, t.hour, t.min, t.sec
-    stack_item = Timecop::TimeStackItem.new(:freeze, t)
-
-    assert_equal y,   stack_item.year
-    assert_equal m,   stack_item.month
-    assert_equal d,   stack_item.day
-    assert_equal h,   stack_item.hour
-    assert_equal min, stack_item.min
-    assert_equal s,   stack_item.sec
-  end
-
-  def test_new_with_time_and_arguments
-    t = Time.new(2012, 7, 28, 20, 0)
-    y, m, d, h, min, s = t.year, t.month, t.day, t.hour, t.min, t.sec
-    stack_item = Timecop::TimeStackItem.new(:freeze, t)
-
-    assert_equal y,   stack_item.year
-    assert_equal m,   stack_item.month
-    assert_equal d,   stack_item.day
-    assert_equal h,   stack_item.hour
-    assert_equal min, stack_item.min
-    assert_equal s,   stack_item.sec
-  end
-
-  def test_new_with_datetime_now
-    t = DateTime.now
-    y, m, d, h, min, s = t.year, t.month, t.day, t.hour, t.min, t.sec
-    stack_item = Timecop::TimeStackItem.new(:freeze, t)
-
-    assert_equal y,   stack_item.year
-    assert_equal m,   stack_item.month
-    assert_equal d,   stack_item.day
-    assert_equal h,   stack_item.hour
-    assert_equal min, stack_item.min
-    assert_equal s,   stack_item.sec
-  end
-
-  def test_new_with_datetime_in_different_timezone
-    each_timezone do
-      t = DateTime.parse("2009-10-11 00:38:00 +0200")
-      stack_item = Timecop::TimeStackItem.new(:freeze, t)
-
-      assert_date_times_equal(t, stack_item.datetime)
-    end
-  end
-
-  def test_new_with_date
-    date = Date.today
-    y, m, d, h, min, s = date.year, date.month, date.day, 0, 0, 0
-    stack_item = Timecop::TimeStackItem.new(:freeze, date)
-
-    assert_equal y,   stack_item.year
-    assert_equal m,   stack_item.month
-    assert_equal d,   stack_item.day
-    assert_equal h,   stack_item.hour
-    assert_equal min, stack_item.min
-    assert_equal s,   stack_item.sec
-  end
-
-  # Due to the nature of this test (calling Time.now once in this test and
-  # once in #new), this test may fail when two subsequent calls
-  # to Time.now return a different second.
-  def test_new_with_integer
-    t = Time.now
-    y, m, d, h, min, s = t.year, t.month, t.day, t.hour, t.min, t.sec
-    stack_item = Timecop::TimeStackItem.new(:freeze, 0)
-
-    assert_equal y,   stack_item.year
-    assert_equal m,   stack_item.month
-    assert_equal d,   stack_item.day
-    assert_equal h,   stack_item.hour
-    assert_equal min, stack_item.min
-    assert_equal s,   stack_item.sec
-  end
-
-  def test_new_with_float
-    t = Time.now
-    y, m, d, h, min, s = t.year, t.month, t.day, t.hour, t.min, t.sec
-    stack_item = Timecop::TimeStackItem.new(:freeze, 0.0)
-
-    assert_equal y,   stack_item.year
-    assert_equal m,   stack_item.month
-    assert_equal d,   stack_item.day
-    assert_equal h,   stack_item.hour
-    assert_equal min, stack_item.min
-    assert_equal s,   stack_item.sec
-  end
-
-  def test_new_with_individual_arguments
-    y, m, d, h, min, s = 2008, 10, 10, 10, 10, 10
-    stack_item = Timecop::TimeStackItem.new(:freeze, y, m, d, h, min, s)
-
-    assert_equal y,   stack_item.year
-    assert_equal m,   stack_item.month
-    assert_equal d,   stack_item.day
-    assert_equal h,   stack_item.hour
-    assert_equal min, stack_item.min
-    assert_equal s,   stack_item.sec
-  end
-
-  def test_rational_to_utc_offset
-    assert_equal -14400, a_time_stack_item.send(:rational_to_utc_offset, Rational(-1, 6))
-    assert_equal -18000, a_time_stack_item.send(:rational_to_utc_offset, Rational(-5, 24))
-    assert_equal 0,      a_time_stack_item.send(:rational_to_utc_offset, Rational(0, 1))
-    assert_equal 3600,   a_time_stack_item.send(:rational_to_utc_offset, Rational(1, 24))
-  end
-
-  def test_utc_offset_to_rational
-    assert_equal Rational(-1, 6),  a_time_stack_item.send(:utc_offset_to_rational, -14400)
-    assert_equal Rational(-5, 24), a_time_stack_item.send(:utc_offset_to_rational, -18000)
-    assert_equal Rational(0, 1),   a_time_stack_item.send(:utc_offset_to_rational, 0)
-    assert_equal Rational(1, 24),  a_time_stack_item.send(:utc_offset_to_rational, 3600)
-  end
-
-  def test_datetime_in_presence_of_activesupport_timezone
-    skip('requires ActiveSupport') unless Time.respond_to? :zone
-    backed_up_zone, backed_up_tzvar = Time.zone, ENV['TZ']
-
-    Time.zone = ENV['TZ'] = 'America/Los_Angeles'
-    t = DateTime.new(2001, 2, 28, 23, 59, 59.5)
-    tsi = Timecop::TimeStackItem.new(:freeze, t)
-
-    assert_date_times_equal t, tsi.datetime
-  ensure
-    Time.zone, ENV['TZ'] = backed_up_zone, backed_up_tzvar
-  end
-
-  # Ensure DateTimes handle changing DST properly
-  def test_datetime_for_dst_to_non_dst
-    Timecop.freeze(DateTime.parse("2009-12-1 00:38:00 -0500"))
-    t = DateTime.parse("2009-10-11 00:00:00 -0400")
-    tsi = Timecop::TimeStackItem.new(:freeze, t)
-
-    assert_date_times_equal t, tsi.datetime
-  end
-
-  # Ensure DateTimes handle changing DST properly when changing from DateTime to Time
-  def test_datetime_for_dst_to_time_for_non_dst
-    Timecop.freeze(DateTime.parse("2009-12-1 00:38:00 -0500"))
-    t = DateTime.parse("2009-10-11 00:00:00 -0400")
-    tsi = Timecop::TimeStackItem.new(:freeze, t)
-
-    assert_date_times_equal t.to_time, tsi.time
-  end
-
-  def test_datetime_for_non_dst_to_dst
-    Timecop.freeze(DateTime.parse("2009-10-11 00:00:00 -0400"))
-    t = DateTime.parse("2009-11-30 23:38:00 -0500")
-    tsi = Timecop::TimeStackItem.new(:freeze, t)
-    return if !tsi.time.dst?
-
-    assert_date_times_equal t, tsi.datetime
-    assert_equal Date.new(2009, 12, 1), tsi.date
-  end
-
-  def test_set_travel_offset_for_travel
-    t_now = Time.now
-    t = Time.local(2009, 10, 1, 0, 0, 30)
-    expected_offset = t - t_now
-    tsi = Timecop::TimeStackItem.new(:travel, t)
-
-    assert_times_effectively_equal expected_offset, tsi.send(:travel_offset), 1, "Offset not calculated correctly"
-  end
-
-  def test_set_travel_offset_for_freeze
-    Timecop.freeze(2009, 10, 1, 0, 0, 0)
-    t = Time.local(2009, 10, 1, 0, 0, 30)
-    tsi = Timecop::TimeStackItem.new(:freeze, t)
-
-    assert_nil tsi.send(:travel_offset)
-  end
-
-  def test_timezones
-    Time.zone = "Europe/Zurich"
-    time = Time.zone.parse("2012-12-27T12:12:12+08:00")
-    Timecop.freeze(time) do |frozen_time|
-      assert_equal time, frozen_time
-    end
-  end
-
-  def test_timezones_with_parsed_string
-    Time.zone = "Europe/Zurich"
-    time_string = "2012-12-27 12:12"
-    expected_time = Time.zone.parse(time_string)
-    Timecop.freeze(time_string) do |frozen_time|
-      assert_equal expected_time, frozen_time
-    end
-  end
-
-  def test_timezones_apply_dates
-    Time.zone = "Central Time (US & Canada)"
-    time = Time.zone.local(2013,1,3)
-
-    Timecop.freeze(time) do
-      assert_equal time.to_date, Time.zone.now.to_date
-    end
-  end
-
-  def test_set_scaling_factor_for_scale
-    t_now = Time.now
-    t = Time.local(2009, 10, 1, 0, 0, 30)
-    expected_offset = t - t_now
-    tsi = Timecop::TimeStackItem.new(:scale, 4, t)
-
-    assert_times_effectively_equal expected_offset, tsi.send(:travel_offset), 1, "Offset not calculated correctly"
-    assert_equal tsi.send(:scaling_factor), 4, "Scaling factor not set"
-  end
-
-  def test_parse_only_string_with_active_support
-    Time.expects(:parse).never
-    Timecop.freeze(2011, 01, 02, hour=0, minute=0, second=0)
-  end
-
-  def test_parse_date
-    Timecop.freeze(Date.new(2012, 6, 9))
-  end
-
-  def test_time_zone_returns_nil
-    Time.zone = nil
-    Timecop.freeze
-  end
-
-  def test_nsecs_are_set
-    time = Time.now
-    Timecop.freeze time
-    assert_equal time, Time.now
-    assert_equal time.nsec, Time.now.nsec if (Time.now.respond_to?(:nsec))
-  end
-
-  def test_time_with_different_timezone_keeps_nsec
-    Time.zone = "Tokyo"
-    t = Time.now
-    Timecop.freeze(t) do
-      assert_equal t, Time.now
-      assert_equal t.nsec, Time.now.nsec if (Time.now.respond_to?(:nsec))
-    end
-  end
-
-  def test_time_now_always_returns_local_time
-    Time.zone = "Tokyo"
-    t = Time.utc(2000, 1, 1)
-    Timecop.freeze(t) do
-      assert_equal t.getlocal.zone, Time.now.zone
-    end
-  end
-
-  def test_time_zone_now_returns_time_in_that_zone
-    Time.zone = "Hawaii"
-    t = Time.utc(2000, 1, 1)
-    Timecop.freeze(t) do
-      assert_equal t, Time.zone.now
-      assert_equal 'HST', Time.zone.now.zone
-    end
-  end
-
-  def test_freezing_a_time_leaves_timezone_intact
-    Time.zone = "Tokyo"
-    t = Time.now
-    t_dup = t.dup
-    Timecop.freeze(t) {}
-    assert_equal t_dup.zone, t.zone
-  end
-
-  def test_freezing_a_time_with_zone_returns_proper_zones
-    Time.zone = "Hawaii"
-    t = ActiveSupport::TimeWithZone.new(Time.utc(2000, 1, 1), ActiveSupport::TimeZone['Tokyo'])
-    Timecop.freeze(t) do
-      local_now = Time.now
-      assert_equal t, local_now
-      assert_equal t.getlocal.zone, local_now.zone
-
-      zoned_now = Time.zone.now
-      assert_equal t, zoned_now
-      assert_equal 'HST', zoned_now.zone
-    end
-  end
-
-  def test_datetime_timezones
-    dt = DateTime.new(2011,1,3,15,25,0,"-6")
-    Timecop.freeze(dt) do
-      now = DateTime.now
-      assert_equal dt, now, "#{dt.to_f}, #{now.to_f}"
-    end
-  end
-end