timecop 0.9.5 → 0.9.7

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 681f52d846b808b06ff833f3fbfc21e3c7c4c1bf426baa03f101c0a2c3b79ce8
-  data.tar.gz: b95b6d4a3c357e7f11f046d82dad3badd81d4903c96ef2b8e77762f241eeb66e
+  metadata.gz: 016ae208ea8ac5c5713b042c7ea1f030bd2d3ff312e95b349e3d31264fc0f0d4
+  data.tar.gz: ed69f4b76ca2a02af2c10f4ad486140bbfefae3d1f3ac13f2d0e7a9176ba09d8
 SHA512:
-  metadata.gz: e62e48939fb924a78d59199222688ae7692a2f6649c16daac296375ac1e537fa1c85e6a34d1a5cbd64b209e643ffa08d180ce3d933905f91284ce4c819873c1e
-  data.tar.gz: f6f5ef32ee1bfadfd43a5a8899bb521873d61eafd2f242942df6e80a3ed11f80a170d074ada23a61eb3b92009eeaf3a1046b126c802dc9a1c014c77d32acb3ab
+  metadata.gz: f47a6e763afa59b037e5e00250b63a623cf3e605135962ecca5bd7eba9e7e36db669c8c261dcefc52ee6c852f1a1507977d5266ad1c63bd007d1edc50414ea1e
+  data.tar.gz: b4a3bff764722b9d1c95d0e7f01dbdad3953503d87e4587c02ad12c0fc5ebe47598177cafdd4d81b9dfaee6ef76447a2e15f5382403cad224fbe08221886fc90

data/README.markdown

@@ -5,11 +5,11 @@
 
 ## 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`, and `DateTime.now` in a single call.
 
 ## INSTALL
 
-`gem install timecop`
+`bundle add timecop`
 
 ## FEATURES
 
@@ -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

@@ -45,36 +45,31 @@ class Date #:nodoc:
     alias_method :strptime_without_mock_date, :strptime
 
     def strptime_with_mock_date(str = '-4712-01-01', fmt = '%F', start = Date::ITALY)
-      unless start == Date::ITALY
-        raise ArgumentError, "Timecop's #{self}::#{__method__} only " +
-          "supports Date::ITALY for the start argument."
-      end
-
       #If date is not valid the following line raises
-      Date.strptime_without_mock_date(str, fmt)
+      Date.strptime_without_mock_date(str, fmt, start)
 
       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)
+        Date.new(year, 1, 1, start)
       elsif d[:mday]
-        Date.new(year, mon, d[:mday])
-      elsif d[:wday]
-        Date.new(year, mon, now.mday) + (d[:wday] - now.wday)
+        Date.new(year, mon, d[:mday], start)
       elsif d[:yday]
-        Date.new(year).next_day(d[:yday] - 1)
-      elsif d[:cwyear] && d[:cweek]
-        if d[:cwday]
-          Date.commercial(d[:cwyear], d[:cweek], d[:cwday])
-        else
-          Date.commercial(d[:cwyear], d[:cweek])
-        end
+        Date.new(year, 1, 1, start).next_day(d[:yday] - 1)
+      elsif d[:cwyear] || d[:cweek] || d[:wnum1] || d[:wday] || d[:cwday]
+        day_of_week_from_monday = if d[:wday]
+                                    (d[:wday] + 6)%7 + 1
+                                  else
+                                    d[:cwday] || 1
+                                  end
+        week = d[:cweek] || d[:wnum1] || now.strftime('%W').to_i
+        Date.commercial(year, week, day_of_week_from_monday, start)
       elsif d[:seconds]
         Time.at(d[:seconds]).to_date
       else
-        Date.new(year, mon)
+        Date.new(year, mon, 1, start)
       end
     end
 
@@ -130,7 +125,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)

data/lib/timecop/time_stack_item.rb

@@ -56,7 +56,7 @@ class Timecop
 
     def time(time_klass = Time) #:nodoc:
       if @time.respond_to?(:in_time_zone)
-        time = time_klass.at(@time.dup.localtime)
+        time = time_klass.at(@time.localtime)
       else
         time = time_klass.at(@time)
       end

data/lib/timecop/timecop.rb

@@ -121,9 +121,9 @@ 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
 
     private

data/lib/timecop/version.rb

@@ -1,3 +1,3 @@
 class Timecop
-  VERSION = "0.9.5"
+  VERSION = "0.9.7"
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: timecop
 version: !ruby/object:Gem::Version
-  version: 0.9.5
+  version: 0.9.7
 platform: ruby
 authors:
 - Travis Jeffery
@@ -9,7 +9,7 @@ authors:
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2022-03-07 00:00:00.000000000 Z
+date: 2023-08-12 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
@@ -54,15 +49,10 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.2.22
+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

data/test/timecop_test.rb

@@ -1,622 +0,0 @@
-require_relative "test_helper"
-require 'timecop'
-
-class TestTimecop < Minitest::Test
-  def teardown
-    Timecop.return
-  end
-
-  def test_freeze_changes_and_resets_time
-    outer_freeze_time = Time.local(2001, 01, 01)
-    inner_freeze_block = Time.local(2002, 02, 02)
-    inner_freeze_one = Time.local(2003, 03, 03)
-    inner_freeze_two = Time.local(2004, 04, 04)
-
-    Timecop.freeze(outer_freeze_time) do
-      assert_times_effectively_equal outer_freeze_time, Time.now
-      Timecop.freeze(inner_freeze_block) do
-        assert_times_effectively_equal inner_freeze_block, Time.now
-        Timecop.freeze(inner_freeze_one)
-        assert_times_effectively_equal inner_freeze_one, Time.now
-        Timecop.freeze(inner_freeze_two)
-        assert_times_effectively_equal inner_freeze_two, Time.now
-      end
-      assert_times_effectively_equal outer_freeze_time, Time.now
-    end
-  end
-
-  def test_freeze_yields_mocked_time
-    Timecop.freeze(2008, 10, 10, 10, 10, 10) do |frozen_time|
-      assert_equal frozen_time, Time.now
-    end
-  end
-
-  def test_freeze_then_return_unsets_mock_time
-    Timecop.freeze(1)
-    Timecop.return
-    assert_nil Time.send(:mock_time)
-  end
-
-  def test_freeze_then_unfreeze_unsets_mock_time
-    Timecop.freeze(1)
-    Timecop.unfreeze
-    assert_nil Time.send(:mock_time)
-  end
-
-  def test_travel_then_return_unsets_mock_time
-    Timecop.travel(1)
-    Timecop.return
-    assert_nil Time.send(:mock_time)
-  end
-
-  def test_freeze_with_block_unsets_mock_time
-    assert_nil Time.send(:mock_time), "test is invalid"
-    Timecop.freeze(1) do; end
-    assert_nil Time.send(:mock_time)
-  end
-
-  def test_travel_with_block_unsets_mock_time
-    assert_nil Time.send(:mock_time), "test is invalid"
-    Timecop.travel(1) do; end
-    assert_nil Time.send(:mock_time)
-  end
-
-  def test_travel_does_not_reduce_precision_of_datetime
-    # requires to_r on Float (>= 1.9)
-    if Float.method_defined?(:to_r)
-      Timecop.travel(Time.new(2014, 1, 1, 0, 0, 0))
-      assert DateTime.now != DateTime.now
-
-      Timecop.travel(Time.new(2014, 1, 1, 0, 0, 59))
-      assert DateTime.now != DateTime.now
-    end
-  end
-
-  def test_freeze_in_time_subclass_returns_mocked_subclass
-    t = Time.local(2008, 10, 10, 10, 10, 10)
-    custom_timeklass = Class.new(Time) do
-      def custom_format_method() strftime('%F') end
-    end
-
-    Timecop.freeze(2008, 10, 10, 10, 10, 10) do
-      assert custom_timeklass.now.is_a? custom_timeklass
-      assert Time.now.eql? custom_timeklass.now
-      assert custom_timeklass.now.respond_to? :custom_format_method
-    end
-  end
-
-  def test_freeze_in_date_subclass_returns_mocked_subclass
-    t = Time.local(2008, 10, 10, 10, 10, 10)
-    custom_dateklass = Class.new(Date) do
-      def custom_format_method() strftime('%F') end
-    end
-
-    Timecop.freeze(2008, 10, 10, 10, 10, 10) do
-      assert custom_dateklass.today.is_a? custom_dateklass
-      assert Date.today.eql? custom_dateklass.today
-      assert custom_dateklass.today.respond_to? :custom_format_method
-    end
-  end
-
-  def test_freeze_in_datetime_subclass_returns_mocked_subclass
-    t = Time.local(2008, 10, 10, 10, 10, 10)
-    custom_datetimeklass = Class.new(DateTime) do
-      def custom_format_method() strftime('%F') end
-    end
-
-    Timecop.freeze(2008, 10, 10, 10, 10, 10) do
-      assert custom_datetimeklass.now.is_a? custom_datetimeklass
-      assert DateTime.now.eql? custom_datetimeklass.now
-      assert custom_datetimeklass.now.respond_to? :custom_format_method
-    end
-  end
-
-  def test_recursive_freeze
-    t = Time.local(2008, 10, 10, 10, 10, 10)
-    Timecop.freeze(2008, 10, 10, 10, 10, 10) do
-      assert_equal t, Time.now
-      t2 = Time.local(2008, 9, 9, 9, 9, 9)
-      Timecop.freeze(2008, 9, 9, 9, 9, 9) do
-        assert_equal t2, Time.now
-      end
-      assert_equal t, Time.now
-    end
-    assert t != Time.now
-  end
-
-  def test_freeze_with_time_instance_works_as_expected
-    t = Time.local(2008, 10, 10, 10, 10, 10)
-    Timecop.freeze(t) do
-      assert_equal t, Time.now
-      assert_date_times_equal DateTime.new(2008, 10, 10, 10, 10, 10, local_offset), DateTime.now
-      assert_equal Date.new(2008, 10, 10), Date.today
-    end
-
-    assert t != Time.now
-    assert DateTime.new(2008, 10, 10, 10, 10, 10, local_offset) != DateTime.now
-    assert Date.new(2008, 10, 10) != Date.today
-  end
-
-  def test_freeze_with_datetime_on_specific_timezone_during_dst
-    each_timezone do
-      # Start from a time that is subject to DST
-      Timecop.freeze(2009, 9, 1)
-      # Travel to a DateTime that is also in DST
-      t = DateTime.parse("2009-10-11 00:38:00 +0200")
-      Timecop.freeze(t) do
-        assert_date_times_equal t, DateTime.now
-      end
-      Timecop.return
-    end
-  end
-
-  def test_freeze_with_datetime_on_specific_timezone_not_during_dst
-    each_timezone do
-      # Start from a time that is not subject to DST
-      Timecop.freeze(2009, 12, 1)
-      # Travel to a time that is also not in DST
-      t = DateTime.parse("2009-12-11 00:38:00 +0100")
-      Timecop.freeze(t) do
-        assert_date_times_equal t, DateTime.now
-      end
-    end
-  end
-
-  def test_freeze_with_datetime_from_a_non_dst_time_to_a_dst_time
-    each_timezone do
-      # Start from a time that is not subject to DST
-      Timecop.freeze(DateTime.parse("2009-12-1 00:00:00 +0100"))
-      # Travel back to a time in DST
-      t = DateTime.parse("2009-10-11 00:38:00 +0200")
-      Timecop.freeze(t) do
-        assert_date_times_equal t, DateTime.now
-      end
-    end
-  end
-
-  def test_freeze_with_datetime_from_a_dst_time_to_a_non_dst_time
-    each_timezone do
-      # Start from a time that is not subject to DST
-      Timecop.freeze(DateTime.parse("2009-10-11 00:00:00 +0200"))
-      # Travel back to a time in DST
-      t = DateTime.parse("2009-12-1 00:38:00 +0100")
-      Timecop.freeze(t) do
-        assert_date_times_equal t, DateTime.now
-      end
-    end
-  end
-
-  def test_freeze_with_date_instance_works_as_expected
-    d = Date.new(2008, 10, 10)
-    Timecop.freeze(d) do
-      assert_equal d, Date.today
-      assert_equal Time.local(2008, 10, 10, 0, 0, 0), Time.now
-      assert_date_times_equal DateTime.new(2008, 10, 10, 0, 0, 0, local_offset), DateTime.now
-    end
-    assert d != Date.today
-    assert Time.local(2008, 10, 10, 0, 0, 0) != Time.now
-    assert DateTime.new(2008, 10, 10, 0, 0, 0, local_offset) != DateTime.now
-  end
-
-  def test_freeze_with_integer_instance_works_as_expected
-    t = Time.local(2008, 10, 10, 10, 10, 10)
-    Timecop.freeze(t) do
-      assert_equal t, Time.now
-      assert_date_times_equal DateTime.new(2008, 10, 10, 10, 10, 10, local_offset), DateTime.now
-      assert_equal Date.new(2008, 10, 10), Date.today
-      Timecop.freeze(10) do
-        assert_equal t + 10, Time.now
-        assert_equal Time.local(2008, 10, 10, 10, 10, 20), Time.now
-        assert_equal Date.new(2008, 10, 10), Date.today
-      end
-    end
-    assert t != Time.now
-    assert DateTime.new(2008, 10, 10, 10, 10, 10) != DateTime.now
-    assert Date.new(2008, 10, 10) != Date.today
-  end
-
-  def test_exception_thrown_in_freeze_block_properly_resets_time
-    t = Time.local(2008, 10, 10, 10, 10, 10)
-    begin
-      Timecop.freeze(t) do
-        assert_equal t, Time.now
-        raise "blah exception"
-      end
-    rescue
-      assert t != Time.now
-      assert_nil Time.send(:mock_time)
-    end
-  end
-
-  def test_exception_thrown_in_return_block_restores_previous_time
-    t = Time.local(2008, 10, 10, 10, 10, 10)
-    Timecop.freeze(t) do
-      Timecop.return { raise 'foobar' } rescue nil
-      assert_equal t, Time.now
-    end
-  end
-
-  def test_freeze_freezes_time
-    t = Time.local(2008, 10, 10, 10, 10, 10)
-    now = Time.now
-    Timecop.freeze(t) do
-      #assert Time.now < now, "If we had failed to freeze, time would have proceeded, which is what appears to have happened."
-      new_t, new_d, new_dt = Time.now, Date.today, DateTime.now
-      assert_equal t, new_t, "Failed to freeze time." # 2 seconds
-      #sleep(10)
-      assert_equal new_t, Time.now
-      assert_equal new_d, Date.today
-      assert_equal new_dt, DateTime.now
-    end
-  end
-
-  def test_travel_keeps_time_moving
-    t = Time.local(2008, 10, 10, 10, 10, 10)
-    now = Time.now
-    Timecop.travel(t) do
-      new_now = Time.now
-      assert_times_effectively_equal(new_now, t, 1, "Looks like we failed to actually travel time")
-      sleep(0.25)
-      assert_times_effectively_not_equal new_now, Time.now, 0.24, "Looks like time is not moving"
-    end
-  end
-
-  def test_mocked_date_time_now_is_local
-    each_timezone do
-      t = DateTime.parse("2009-10-11 00:38:00 +0200")
-      Timecop.freeze(t) do
-        if ENV['TZ'] == 'UTC'
-          assert_equal(local_offset, 0, "Local offset not be zero for #{ENV['TZ']}")
-        else
-          assert(local_offset, 0 != "Local offset should not be zero for #{ENV['TZ']}")
-        end
-        assert_equal local_offset, DateTime.now.offset, "Failed for timezone: #{ENV['TZ']}"
-      end
-    end
-  end
-
-  def test_scaling_keeps_time_moving_at_an_accelerated_rate
-    t = Time.local(2008, 10, 10, 10, 10, 10)
-    Timecop.scale(4, t) do
-      start = Time.now
-      assert_times_effectively_equal start, t, 1, "Looks like we failed to actually travel time"
-      sleep(0.25)
-      assert_times_effectively_equal Time.at((start + 4*0.25).to_f), Time.now, 0.25, "Looks like time is not moving at 4x"
-    end
-  end
-
-  def test_scaling_returns_now_if_no_block_given
-    t = Time.local(2008, 10, 10, 10, 10, 10)
-    assert_times_effectively_equal t, Timecop.scale(4, t)
-  end
-  
-  def test_scaling_returns_now_if_nil_supplied
-    assert_times_effectively_equal Time.now, Timecop.scale(nil)
-  end
-
-  def test_scaling_raises_when_empty_string_supplied
-    err = assert_raises(TypeError) do
-      Timecop.scale("")
-    end
-    assert_match /String can't be coerced into Float/, err.message
-  end
-
-  def test_freeze_with_utc_time
-    each_timezone do
-      t = Time.utc(2008, 10, 10, 10, 10, 10)
-      local = t.getlocal
-      Timecop.freeze(t) do
-        assert_equal local, Time.now, "Failed for timezone: #{ENV['TZ']}"
-      end
-    end
-  end
-
-  def test_freeze_without_arguments_instance_works_as_expected
-    t = Time.local(2008, 10, 10, 10, 10, 10)
-    Timecop.freeze(t) do
-      assert_equal t, Time.now
-      Timecop.freeze do
-        assert_equal t, Time.now
-        assert_equal Time.local(2008, 10, 10, 10, 10, 10), Time.now
-        assert_equal Date.new(2008, 10, 10), Date.today
-      end
-    end
-    assert t != Time.now
-  end
-
-  def test_destructive_methods_on_frozen_time
-    # Use any time zone other than UTC.
-    ENV['TZ'] = 'EST'
-
-    t = Time.local(2008, 10, 10, 10, 10, 10)
-    Timecop.freeze(t) do
-      assert !Time.now.utc?, "Time#local failed to return a time in the local time zone."
-
-      # #utc, #gmt, and #localtime are destructive methods.
-      Time.now.utc
-
-      assert !Time.now.utc?, "Failed to thwart destructive methods."
-    end
-  end
-
-  def test_recursive_travel_maintains_each_context
-    t = Time.local(2008, 10, 10, 10, 10, 10)
-    Timecop.travel(2008, 10, 10, 10, 10, 10) do
-      assert((t - Time.now).abs < 50, "Failed to travel time.")
-      t2 = Time.local(2008, 9, 9, 9, 9, 9)
-      Timecop.travel(2008, 9, 9, 9, 9, 9) do
-        assert_times_effectively_equal(t2, Time.now, 1, "Failed to travel time.")
-        assert_times_effectively_not_equal(t, Time.now, 1000, "Failed to travel time.")
-      end
-      assert_times_effectively_equal(t, Time.now, 2, "Failed to restore previously-traveled time.")
-    end
-    assert_nil Time.send(:mock_time)
-  end
-
-  def test_recursive_travel_yields_correct_time
-    Timecop.travel(2008, 10, 10, 10, 10, 10) do
-      Timecop.travel(2008, 9, 9, 9, 9, 9) do |inner_freeze|
-        assert_times_effectively_equal inner_freeze, Time.now, 1, "Failed to yield current time back to block"
-      end
-    end
-  end
-
-  def test_recursive_travel_then_freeze
-    t = Time.local(2008, 10, 10, 10, 10, 10)
-    Timecop.travel(2008, 10, 10, 10, 10, 10) do
-      assert((t - Time.now).abs < 50, "Failed to travel time.")
-      t2 = Time.local(2008, 9, 9, 9, 9, 9)
-      Timecop.freeze(2008, 9, 9, 9, 9, 9) do
-        assert_equal t2, Time.now
-      end
-      assert_times_effectively_equal(t, Time.now, 2, "Failed to restore previously-traveled time.")
-    end
-    assert_nil Time.send(:mock_time)
-  end
-
-  def test_recursive_freeze_then_travel
-    t = Time.local(2008, 10, 10, 10, 10, 10)
-    Timecop.freeze(t) do
-      assert_equal t, Time.now
-      t2 = Time.local(2008, 9, 9, 9, 9, 9)
-      Timecop.travel(t2) do
-        assert_times_effectively_equal(t2, Time.now, 1, "Failed to travel time.")
-        assert_times_effectively_not_equal(t, Time.now, 1000, "Failed to travel time.")
-      end
-      assert_equal t, Time.now
-    end
-    assert_nil Time.send(:mock_time)
-  end
-
-  def test_travel_time_returns_now_if_no_block_given
-    t_future = Time.local(2030, 10, 10, 10, 10, 10)
-    assert_times_effectively_equal t_future, Timecop.travel(t_future)
-  end
-
-  def test_return_temporarily_returns_to_current_time_in_given_block
-    time_after_travel = Time.local(1990, 7, 16)
-    now = Time.now
-
-    Timecop.travel(time_after_travel)
-
-    assert_times_effectively_equal(time_after_travel, Time.now)
-    Timecop.return do
-      assert_times_effectively_equal(now, Time.now)
-    end
-    assert_times_effectively_equal(time_after_travel, Time.now)
-  end
-  
-  def test_travel_returns_now_if_nil_supplied
-    assert_times_effectively_equal Time.now, Timecop.travel(nil)
-  end
-
-  def test_travel_time_with_block_returns_the_value_of_the_block
-    t_future = Time.local(2030, 10, 10, 10, 10, 10)
-    expected = :foo
-    actual = Timecop.travel(t_future) { expected }
-
-    assert_equal expected, actual
-  end
-  
-  def test_travel_raises_when_empty_string_supplied
-    err = assert_raises(ArgumentError) do
-      Timecop.travel("")
-    end
-    assert_match /no time information in \"\"/, err.message
-  end
-
-  def test_freeze_time_returns_now_if_no_block_given
-    t_future = Time.local(2030, 10, 10, 10, 10, 10)
-    assert_times_effectively_equal t_future, Timecop.freeze(t_future)
-  end
-
-  def test_freeze_time_with_block_returns_the_value_of_the_block
-    t_future = Time.local(2030, 10, 10, 10, 10, 10)
-    expected = :foo
-    actual = Timecop.freeze(t_future) { expected }
-
-    assert_equal expected, actual
-  end
-
-  def test_return_returns_nil
-    assert_nil Timecop.return
-  end
-
-  def test_freeze_without_params
-    Timecop.freeze 1 do
-      current_time = Time.now
-      Timecop.freeze do
-        assert_equal Time.now, current_time
-      end
-    end
-  end
-  
-   def test_freeze_returns_now_if_nil_supplied
-    assert_times_effectively_equal Time.now, Timecop.freeze(nil)
-  end
-
-  def test_freeze_raises_when_empty_string_supplied
-    err = assert_raises(ArgumentError) do
-      Timecop.freeze("")
-    end
-     assert_match /no time information in \"\"/, err.message
-  end
-
-  def test_freeze_with_new_date
-    date = Date.new(2012, 6, 9)
-    Timecop.freeze(Date.new(2012, 6, 9)) do
-      assert_equal date, Time.now.__send__(:to_date)
-    end
-  end
-
-  def test_return_to_baseline_without_a_baseline_set_returns_to_current_time
-    time_before_travel = Time.now
-    Timecop.travel Time.now - 60
-    Timecop.return_to_baseline
-    assert times_effectively_equal(time_before_travel, Time.now)
-  end
-
-  def test_return_to_baseline_with_a_baseline_set_returns_to_baseline
-    baseline = Time.local(1945, 10, 10, 10, 10, 10)
-    Timecop.baseline = baseline
-    Timecop.travel Time.now - 60
-    time_now = Timecop.return_to_baseline
-    assert times_effectively_equal(baseline, time_now),
-      "expected to return to #{baseline}, but returned to #{time_now}"
-  end
-
-  def test_return_eliminates_baseline
-    time_before_travel = Time.now
-    Timecop.baseline = Time.local(1937, 9, 9, 9, 9, 9)
-    Timecop.return
-    assert times_effectively_equal(time_before_travel, Time.now)
-
-    Timecop.travel(Time.now - 100)
-    Timecop.return_to_baseline
-    assert times_effectively_equal(time_before_travel, Time.now)
-  end
-
-  def test_mock_time_new_same_as_now
-    date = Time.local(2011, 01, 02)
-    Timecop.freeze date
-    assert_equal date, Time.now
-    assert_equal date, Time.new
-  end
-
-  def test_not_callable_send_travel
-    assert_raises NoMethodError do
-      Timecop.send_travel(:travel, Time.now - 100)
-    end
-  end
-
-  def test_datetime_to_time_for_dst_to_non_dst
-    # Start at a time subject to DST
-    Timecop.travel(2009, 4, 1, 0, 0, 0, -4*60*60) do
-
-      # Then freeze, via DateTime, at a time not subject to DST
-      t = DateTime.new(2009,01,01,0,0,0, "-0500")
-      Timecop.freeze(t) do
-
-        # Check the current time via DateTime.now--should be what we asked for
-        assert_date_times_equal t, DateTime.now
-
-        # Then check the current time via Time.now (not DateTime.now)
-        assert_times_effectively_equal Time.new(2009, 1, 1, 0, 0, 0, -5*60*60), Time.now
-      end
-    end
-  end
-
-  def test_raises_when_safe_mode_and_no_block
-    with_safe_mode do
-      assert_raises Timecop::SafeModeException do
-        Timecop.freeze
-      end
-    end
-  end
-
-  def test_raises_when_safe_mode_and_no_block_though_previously_block_given
-    Timecop.freeze do
-      Timecop.freeze
-    end
-
-    with_safe_mode do
-      assert_raises Timecop::SafeModeException do
-        Timecop.freeze
-      end
-    end
-  end
-
-  def test_no_raise_when_safe_mode_and_block_used
-    with_safe_mode do
-      Timecop.freeze {}
-    end
-  end
-
-  def test_no_raise_when_not_safe_mode_and_no_block
-    with_safe_mode(false) do
-      Timecop.freeze
-    end
-  end
-
-  def test_no_raise_when_safe_mode_and_no_block_and_in_block_context
-    with_safe_mode do
-      Timecop.freeze do
-        Timecop.freeze
-      end
-    end
-  end
-
-  def test_frozen_after_freeze
-    Timecop.freeze
-    assert Timecop.frozen?
-  end
-
-  def test_frozen_inside_freeze
-    Timecop.freeze do
-      assert Timecop.frozen?
-    end
-  end
-
-  def test_not_frozen_after_return
-    Timecop.freeze
-    Timecop.return
-    assert !Timecop.frozen?
-  end
-
-  def test_thread_safe_timecop_in_parallel
-    Timecop.thread_safe = true
-    date = Time.local(2011, 01, 02)
-    thread = Thread.new do
-      Timecop.freeze(date) do
-        sleep 1 #give main thread time to run
-        assert_equal date, Time.now
-      end
-    end
-
-    sleep 0.25
-    assert Time.now != date
-    thread.join
-  ensure
-    Timecop.thread_safe = false
-  end
-
-  def test_thread_safe_timecop_returns_after_block
-    Timecop.thread_safe = true
-    date = Time.local(2017, 10, 8)
-
-    Timecop.freeze(date) { }
-    assert Time.now != date
-  ensure
-    Timecop.thread_safe = false
-  end
-
-  private
-
-  def with_safe_mode(enabled=true)
-    mode = Timecop.safe_mode?
-    Timecop.safe_mode = enabled
-    yield
-  ensure
-    Timecop.safe_mode = mode
-  end
-end

data/test/timecop_without_date_but_with_time_test.rb

@@ -1,8 +0,0 @@
-require_relative "test_helper"
-require "time"
-
-class TestTimecopWithoutDateButWithTime < Minitest::Test
-  def test_loads_properly_when_time_is_required_instead_of_date
-    require 'timecop'
-  end
-end

data/test/timecop_without_date_test.rb

@@ -1,118 +0,0 @@
-require_relative "test_helper"
-require 'timecop'
-
-class TestTimecopWithoutDate < Minitest::Test
-
-  def setup
-    Object.send(:remove_const, :Date) if Object.const_defined?(:Date)
-    Object.send(:remove_const, :DateTime) if Object.const_defined?(:DateTime)
-  end
-
-  # just in case...let's really make sure that Timecop is disabled between tests...
-  def teardown
-    Timecop.return
-  end
-
-  def test_freeze_changes_and_resets_time
-    # depending on how we're invoked (individually or via the rake test suite)
-    assert !Time.respond_to?(:zone) || Time.zone.nil?
-
-    t = Time.local(2008, 10, 10, 10, 10, 10)
-    assert t != Time.now
-    Timecop.freeze(2008, 10, 10, 10, 10, 10) do
-      assert_equal t, Time.now
-    end
-    assert t != Time.now
-  end
-
-  def test_recursive_freeze
-    t = Time.local(2008, 10, 10, 10, 10, 10)
-    Timecop.freeze(2008, 10, 10, 10, 10, 10) do
-      assert_equal t, Time.now
-      t2 = Time.local(2008, 9, 9, 9, 9, 9)
-      Timecop.freeze(2008, 9, 9, 9, 9, 9) do
-        assert_equal t2, Time.now
-      end
-      assert_equal t, Time.now
-    end
-    assert_nil Time.send(:mock_time)
-  end
-
-  def test_exception_thrown_in_freeze_block_properly_resets_time
-    t = Time.local(2008, 10, 10, 10, 10, 10)
-    begin
-      Timecop.freeze(t) do
-        assert_equal t, Time.now
-        raise "blah exception"
-      end
-    rescue
-      assert t != Time.now
-      assert_nil Time.send(:mock_time)
-    end
-  end
-
-  def test_freeze_freezes_time
-    t = Time.local(2008, 10, 10, 10, 10, 10)
-    now = Time.now
-    Timecop.freeze(t) do
-      sleep(0.25)
-      assert Time.now < now, "If we had failed to freeze, time would have proceeded, which is what appears to have happened."
-      new_t = Time.now
-      assert_equal t, new_t, "Failed to change move time." # 2 seconds
-      assert_equal new_t, Time.now
-    end
-  end
-
-  def test_travel_keeps_time_moving
-    t = Time.local(2008, 10, 10, 10, 10, 10)
-    now = Time.now
-    Timecop.travel(t) do
-      new_now = Time.now
-      assert_times_effectively_equal new_now, t, 1, "Looks like we failed to actually travel time" # 0.1 seconds
-      sleep(0.25)
-      assert_times_effectively_not_equal new_now, Time.now, 0.24, "Looks like time is not moving"
-    end
-  end
-
-  def test_recursive_travel_maintains_each_context
-    t = Time.local(2008, 10, 10, 10, 10, 10)
-    Timecop.travel(2008, 10, 10, 10, 10, 10) do
-      assert((t - Time.now).abs < 50, "Failed to travel time.")
-      t2 = Time.local(2008, 9, 9, 9, 9, 9)
-      Timecop.travel(2008, 9, 9, 9, 9, 9) do
-        assert_times_effectively_equal(t2, Time.now, 1, "Failed to travel time.")
-        assert_times_effectively_not_equal(t, Time.now, 1000, "Failed to travel time.")
-      end
-      assert_times_effectively_equal(t, Time.now, 2, "Failed to restore previously-traveled time.")
-    end
-    assert_nil Time.send(:mock_time)
-  end
-
-  def test_recursive_travel_then_freeze
-    t = Time.local(2008, 10, 10, 10, 10, 10)
-    Timecop.travel(2008, 10, 10, 10, 10, 10) do
-      assert((t - Time.now).abs < 50, "Failed to travel time.")
-      t2 = Time.local(2008, 9, 9, 9, 9, 9)
-      Timecop.freeze(2008, 9, 9, 9, 9, 9) do
-        assert_equal t2, Time.now
-      end
-      assert_times_effectively_equal(t, Time.now, 2, "Failed to restore previously-traveled time.")
-    end
-    assert_nil Time.send(:mock_time)
-  end
-
-  def test_recursive_freeze_then_travel
-    t = Time.local(2008, 10, 10, 10, 10, 10)
-    Timecop.freeze(t) do
-      assert_equal t, Time.now
-      t2 = Time.local(2008, 9, 9, 9, 9, 9)
-      Timecop.travel(t2) do
-        assert_times_effectively_equal(t2, Time.now, 1, "Failed to travel time.")
-        assert_times_effectively_not_equal(t, Time.now, 1000, "Failed to travel time.")
-      end
-      assert_equal t, Time.now
-    end
-    assert_nil Time.send(:mock_time)
-  end
-
-end