tzinfo 1.2.5 → 1.2.9

data/test/tc_timezone.rb

@@ -2,6 +2,10 @@ require File.join(File.expand_path(File.dirname(__FILE__)), 'test_utils')
 
 include TZInfo
 
+# Use send as a workaround for erroneous 'wrong number of arguments' errors with
+# JRuby 9.0.5.0 when calling methods with Java implementations. See #114.
+send(:using, TaintExt) if Module.const_defined?(:TaintExt)
+
 class TCTimezone < Minitest::Test
 
   class BlockCalled < StandardError
@@ -242,7 +246,7 @@ class TCTimezone < Minitest::Test
   def test_get_tainted_loaded
     Timezone.get('Europe/Andorra')
   
-    safe_test do
+    safe_test(:unavailable => :skip) do
       identifier = 'Europe/Andorra'.dup.taint
       assert(identifier.tainted?)
       tz = Timezone.get(identifier)
@@ -261,7 +265,9 @@ class TCTimezone < Minitest::Test
   end
   
   def test_get_tainted_not_previously_loaded
-    safe_test do
+    skip_if_has_bug_14060
+
+    safe_test(:unavailable => :skip) do
       identifier = 'Europe/Andorra'.dup.taint
       assert(identifier.tainted?)
       tz = Timezone.get(identifier)
@@ -271,6 +277,8 @@ class TCTimezone < Minitest::Test
   end
   
   def test_get_tainted_and_frozen_not_previously_loaded
+    skip_if_has_bug_14060
+
     safe_test do
       tz = Timezone.get('Europe/Amsterdam'.dup.taint.freeze)
       assert_equal('Europe/Amsterdam', tz.identifier)
@@ -1260,6 +1268,7 @@ class TCTimezone < Minitest::Test
     assert_equal('BST BST', tz.strftime('%Z %Z', dt))
     assert_equal('BST %Z %BST %%Z %%BST', tz.strftime('%Z %%Z %%%Z %%%%Z %%%%%Z', dt))
     assert_equal('+0100 +01:00 +01:00:00 +01 %::::z', tz.strftime('%z %:z %::z %:::z %::::z', dt))
+    assert_equal('1153001522 %s %1153001522', tz.strftime('%s %%s %%%s', dt))
   end
   
   def test_strftime_time
@@ -1271,6 +1280,7 @@ class TCTimezone < Minitest::Test
     assert_equal('BST BST', tz.strftime('%Z %Z', t))
     assert_equal('BST %Z %BST %%Z %%BST', tz.strftime('%Z %%Z %%%Z %%%%Z %%%%%Z', t))
     assert_equal('+0100 +01:00 +01:00:00 +01 %::::z', tz.strftime('%z %:z %::z %:::z %::::z', t))
+    assert_equal('1153001522 %s %1153001522', tz.strftime('%s %%s %%%s', t))
   end
   
   def test_strftime_int
@@ -1282,6 +1292,7 @@ class TCTimezone < Minitest::Test
     assert_equal('BST BST', tz.strftime('%Z %Z', i))
     assert_equal('BST %Z %BST %%Z %%BST', tz.strftime('%Z %%Z %%%Z %%%%Z %%%%%Z', i))
     assert_equal('+0100 +01:00 +01:00:00 +01 %::::z', tz.strftime('%z %:z %::z %:::z %::::z', i))
+    assert_equal('1153001522 %s %1153001522', tz.strftime('%s %%s %%%s', i))
   end
   
   def test_get_missing_data_source

data/test/tc_transition_data_timezone_info.rb

@@ -359,7 +359,17 @@ class TCTransitionDataTimezoneInfo < Minitest::Test
     assert_equal([t1,t2,t3,t4,t5], dti.transitions_up_to(DateTime.new(2011,10,1,1,0,Rational(DATETIME_RESOLUTION,1000000))))
     assert_equal([t1,t2,t3,t4,t5], dti.transitions_up_to(DateTime.new(2011,10,1,1,0,1), DateTime.new(2010,4,1,1,0,0)))
     assert_equal([t2,t3,t4,t5], dti.transitions_up_to(DateTime.new(2011,10,1,1,0,1), DateTime.new(2010,4,1,1,0,1)))
-    assert_equal([t2,t3,t4,t5], dti.transitions_up_to(DateTime.new(2011,10,1,1,0,1), DateTime.new(2010,4,1,1,0,Rational(DATETIME_RESOLUTION,1000000))))
+
+    # Ruby 1.8.7 (built with GCC 8.3.0 on Ubuntu 19.04) fails to perform
+    # DateTime comparisons correctly when sub-seconds are used.
+    to = DateTime.new(2011,10,1,1,0,1)
+    from = DateTime.new(2010,4,1,1,0,Rational(DATETIME_RESOLUTION,1000000))
+    if to > from
+      assert_equal([t2,t3,t4,t5], dti.transitions_up_to(to, from))
+    else
+      puts "This platform does not consider the DateTime #{to.strftime('%Y-%m-%d %H:%m:%S.%N')} to be later than the DateTime #{from.strftime('%Y-%m-%d %H:%m:%S.%N')}"
+    end
+
     assert_equal([t5], dti.transitions_up_to(DateTime.new(2015,1,1,0,0,0), DateTime.new(2011,10,1,1,0,0)))
     assert_equal([], dti.transitions_up_to(DateTime.new(2015,1,1,0,0,0), DateTime.new(2011,10,1,1,0,1)))
   end

data/test/tc_transition_rule.rb

@@ -0,0 +1,663 @@
+require File.join(File.expand_path(File.dirname(__FILE__)), 'test_utils')
+
+include TZInfo
+
+class TCTransitionRule < Minitest::Test
+  [-1, 0, 1].each do |transition_at|
+    define_method "test_transition_at_#{transition_at}" do
+      rule = TestTransitionRule.new(transition_at)
+      assert_equal(transition_at, rule.transition_at)
+    end
+  end
+
+  [
+    [-1, 19, 23, 59, 59],
+    [0, 20, 0, 0, 0],
+    [1, 20, 0, 0, 1],
+    [60, 20, 0, 1, 0],
+    [86399, 20, 23, 59, 59],
+    [86400, 21, 0, 0, 0]
+  ].each do |(transition_at, expected_day, expected_hour, expected_minute, expected_second)|
+    define_method "test_at_with_transition_at_#{transition_at}" do
+      offset = TimezoneOffset.new(0, 0, 'TEST')
+      rule = TestTransitionRule.new(transition_at) do |y|
+        assert_equal(2020, y)
+        TimeOrDateTime.wrap(Time.utc(2020, 3, 20))
+      end
+
+      result = rule.at(offset, 2020)
+
+      assert_kind_of(TimeOrDateTime, result)
+      assert_equal(Time.utc(2020, 3, expected_day, expected_hour, expected_minute, expected_second), result.to_time)
+    end
+  end
+
+  [-7200, 0, 7200].each do |offset_seconds|
+    define_method "test_at_with_offset_#{offset_seconds}" do
+      offset = TimezoneOffset.new(offset_seconds, 0, 'TEST')
+      rule = TestTransitionRule.new(3600) do |y|
+        assert_equal(2020, y)
+        TimeOrDateTime.wrap(Time.utc(2020, 3, 20))
+      end
+
+      result = rule.at(offset, 2020)
+
+      assert_kind_of(TimeOrDateTime, result)
+      assert_equal(Time.utc(2020, 3, 20, 1, 0, 0) - offset_seconds, result.to_time)
+    end
+  end
+
+  [2020, 2021].each do |year|
+    define_method "test_at_with_year_#{year}" do
+      offset = TimezoneOffset.new(0, 0, 'TEST')
+      rule = TestTransitionRule.new(3600) do |y|
+        assert_equal(year, y)
+        TimeOrDateTime.wrap(Time.utc(year, 3, 20))
+      end
+
+      result = rule.at(offset, year)
+
+      assert_kind_of(TimeOrDateTime, result)
+      assert_equal(Time.utc(year, 3, 20, 1, 0, 0), result.to_time)
+    end
+  end
+
+  def test_at_crosses_64_bit_boundary
+    offset = TimezoneOffset.new(0, 0, 'TEST')
+    rule = TestTransitionRule.new(11648) do |y|
+      assert_equal(2038, y)
+      TimeOrDateTime.wrap(Time.utc(2038, 1, 19))
+    end
+
+    result = rule.at(offset, 2038)
+
+    assert_kind_of(TimeOrDateTime, result)
+    if RubyCoreSupport.time_supports_64bit
+      assert_kind_of(Time, result.to_orig)
+    else
+      assert_kind_of(DateTime, result.to_orig)
+    end
+    assert_equal(DateTime.new(2038, 1, 19, 3, 14, 8), result.to_datetime)
+  end
+
+  def test_at_crosses_negative_boundary
+    offset = TimezoneOffset.new(0, 0, 'TEST')
+    rule = TestTransitionRule.new(-1) do |y|
+      assert_equal(1970, y)
+      TimeOrDateTime.wrap(Time.utc(1970, 1, 1))
+    end
+
+    result = rule.at(offset, 1970)
+
+    assert_kind_of(TimeOrDateTime, result)
+    if RubyCoreSupport.time_supports_negative
+      assert_kind_of(Time, result.to_orig)
+    else
+      assert_kind_of(DateTime, result.to_orig)
+    end
+    assert_equal(DateTime.new(1969, 12, 31, 23, 59, 59), result.to_datetime)
+  end
+
+  NEGATIVE_DATES = [[1969, 12, 31]]
+  B32_DATES = [[1970, 1, 1], [2038, 1, 19]]
+  B64_DATES = [[2038, 1, 20], [2038, 2, 1], [2039, 1, 1]]
+
+  B32_DATES.concat(RubyCoreSupport.time_supports_negative ? NEGATIVE_DATES : []).concat(RubyCoreSupport.time_supports_64bit ? B64_DATES : []).each do |(year, month, day)|
+    define_method "test_new_time_or_datetime_returns_time_based_instance_for_#{year}_#{month}_#{day}" do
+      result = TestTransitionRule.new(0).new_time_or_datetime!(year, month, day)
+      assert_kind_of(TimeOrDateTime, result)
+      assert_kind_of(Time, result.to_orig)
+      assert_equal(Time.utc(year, month, day), result.to_orig)
+    end
+  end
+
+  (RubyCoreSupport.time_supports_negative ? [] : NEGATIVE_DATES).concat(RubyCoreSupport.time_supports_64bit ? [] : B64_DATES).each do |(year, month, day)|
+    define_method "test_new_time_or_datetime_returns_datetime_based_instance_for_#{year}_#{month}_#{day}" do
+      result = TestTransitionRule.new(0).new_time_or_datetime!(year, month, day)
+      assert_kind_of(TimeOrDateTime, result)
+      assert_kind_of(DateTime, result.to_orig)
+      assert_equal(DateTime.new(year, month, day), result.to_orig)
+    end
+  end
+
+  [1900, 2021, 2039].each do |year|
+    define_method "test_new_time_or_datetime_returns_march_1_for_feb_29_on_non_leap_year_#{year}" do
+      result = TestTransitionRule.new(0).new_time_or_datetime!(year, 2, 29)
+      assert_kind_of(TimeOrDateTime, result)
+      assert_equal(DateTime.new(year, 3, 1), result.to_datetime)
+    end
+  end
+
+  [1968, 2000, 2040].each do |year|
+    define_method "test_new_time_or_datetime_returns_feb_29_on_leap_year_#{year}" do
+      result = TestTransitionRule.new(0).new_time_or_datetime!(year, 2, 29)
+      assert_kind_of(TimeOrDateTime, result)
+      assert_equal(DateTime.new(year, 2, 29), result.to_datetime)
+    end
+  end
+
+  class TestTransitionRule < TransitionRule
+    def initialize(transition_at, &block)
+      super(transition_at)
+      @get_day = block
+    end
+
+    alias new_time_or_datetime! new_time_or_datetime
+    public :new_time_or_datetime!
+
+    protected
+
+    def get_day(year)
+      @get_day.call(year)
+    end
+  end
+end
+
+module BaseTransitionRuleTestHelper
+  def test_invalid_transition_at
+    error = assert_raises(ArgumentError) { create_with_transition_at('0') }
+    assert_match(/\btransition_at(\b.*)?/, error.message)
+  end
+
+  [:==, :eql?].each do |method|
+    define_method "test_not_equal_by_transition_at_with_#{method}" do
+      rule1 = create_with_transition_at(0)
+      rule2 = create_with_transition_at(1)
+      assert_equal(false, rule1.send(method, rule2))
+      assert_equal(false, rule2.send(method, rule1))
+    end
+
+    define_method "test_not_equal_to_other_with_#{method}" do
+      rule = create_with_transition_at(0)
+      assert_equal(false, rule.send(method, Object.new))
+    end
+  end
+end
+
+class TCAbsoluteDayOfYearTransitionRule < Minitest::Test
+  include BaseTransitionRuleTestHelper
+
+  [-1, 366, '0'].each do |value|
+    define_method "test_invalid_day_#{value}" do
+      error = assert_raises(ArgumentError) { AbsoluteDayOfYearTransitionRule.new(value) }
+      assert_match(/\bday\b/, error.message)
+    end
+  end
+
+  [
+    [2020, 0, 1, 1],
+    [2020, 58, 2, 28],
+    [2020, 59, 2, 29],
+    [2020, 365, 12, 31],
+    [2021, 59, 3, 1],
+    [2021, 365, 13, 1],
+    [2100, 59, 3, 1],
+    [2100, 365, 13, 1],
+    [2000, 59, 2, 29],
+    [2000, 365, 12, 31]
+  ].each do |(year, day, expected_month, expected_day)|
+    define_method "test_day_#{day}_of_year_#{year}" do
+      rule = AbsoluteDayOfYearTransitionRule.new(day, 3600)
+      offset = TimezoneOffset.new(0, 0, 'TEST')
+
+      result = rule.at(offset, year)
+
+      expected_year = year
+      if expected_month == 13
+        expected_year += 1
+        expected_month = 1
+      end
+
+      assert_kind_of(TimeOrDateTime, result)
+      assert_equal(DateTime.new(expected_year, expected_month, expected_day, 1, 0, 0), result.to_datetime)
+    end
+  end
+
+  def test_crosses_64_bit_boundary
+    # Internally the calculation starts with Jan 1 and adds days. Jan 20 2038
+    # will require a DateTime on 32-bit only systems.
+
+    rule = AbsoluteDayOfYearTransitionRule.new(19, 3600)
+    offset = TimezoneOffset.new(0, 0, 'TEST')
+
+    result = rule.at(offset, 2038)
+
+    assert_kind_of(TimeOrDateTime, result)
+    if RubyCoreSupport.time_supports_64bit
+      assert_kind_of(Time, result.to_orig)
+    else
+      assert_kind_of(DateTime, result.to_orig)
+    end
+    assert_equal(DateTime.new(2038, 1, 20, 1, 0, 0), result.to_datetime)
+  end
+
+  def test_day_0_is_always_first_day_of_year
+    rule = AbsoluteDayOfYearTransitionRule.new(0)
+    assert_equal(true, rule.is_always_first_day_of_year?)
+  end
+
+  [1, 365].each do |day|
+    define_method "test_day_#{day}_is_not_always_first_day_of_year" do
+      rule = AbsoluteDayOfYearTransitionRule.new(day)
+      assert_equal(false, rule.is_always_first_day_of_year?)
+    end
+
+    define_method "test_day_#{day}_is_not_always_last_day_of_year" do
+      rule = AbsoluteDayOfYearTransitionRule.new(day)
+      assert_equal(false, rule.is_always_last_day_of_year?)
+    end
+  end
+
+  [:==, :eql?].each do |method|
+    [
+      [0, 0],
+      [0, 3600],
+      [365, 0]
+    ].each do |(day, transition_at)|
+      define_method "test_equal_for_day_#{day}_and_transition_at_#{transition_at}_with_#{method}" do
+        rule1 = AbsoluteDayOfYearTransitionRule.new(day, transition_at)
+        rule2 = AbsoluteDayOfYearTransitionRule.new(day, transition_at)
+        assert_equal(true, rule1.send(method, rule2))
+        assert_equal(true, rule2.send(method, rule1))
+      end
+    end
+
+    define_method "test_not_equal_by_day_with_#{method}" do
+      rule1 = AbsoluteDayOfYearTransitionRule.new(0, 3600)
+      rule2 = AbsoluteDayOfYearTransitionRule.new(1, 3600)
+      assert_equal(false, rule1.send(method, rule2))
+      assert_equal(false, rule2.send(method, rule1))
+    end
+
+    define_method "test_not_equal_to_julian_with_#{method}" do
+      rule1 = AbsoluteDayOfYearTransitionRule.new(1, 0)
+      rule2 = JulianDayOfYearTransitionRule.new(1, 0)
+      assert_equal(false, rule1.send(method, rule2))
+      assert_equal(false, rule2.send(method, rule1))
+    end
+  end
+
+  [
+    [0, 0],
+    [0, 3600],
+    [365, 0]
+  ].each do |(day, transition_at)|
+    define_method "test_hash_for_day_#{day}_and_transition_at_#{transition_at}" do
+      rule = AbsoluteDayOfYearTransitionRule.new(day, transition_at)
+      expected = [AbsoluteDayOfYearTransitionRule, day * 86400, transition_at].hash
+      assert_equal(expected, rule.hash)
+    end
+  end
+
+  protected
+
+  def create_with_transition_at(transition_at)
+    AbsoluteDayOfYearTransitionRule.new(1, transition_at)
+  end
+end
+
+class TCJulianDayOfYearTransitionRule < Minitest::Test
+  include BaseTransitionRuleTestHelper
+
+  [0, 366, '1'].each do |value|
+    define_method "test_invalid_day_#{value}" do
+      error = assert_raises(ArgumentError) { JulianDayOfYearTransitionRule.new(value) }
+      assert_match(/\bday\b/, error.message)
+    end
+  end
+
+  [2020, 2021, 2100, 2000].each do |year|
+    [
+      [1, 1, 1],
+      [59, 2, 28],
+      [60, 3, 1],
+      [365, 12, 31]
+    ].each do |(day, expected_month, expected_day)|
+      define_method "test_day_#{day}_of_year_#{year}" do
+        rule = JulianDayOfYearTransitionRule.new(day, 3600)
+        offset = TimezoneOffset.new(0, 0, 'TEST')
+
+        result = rule.at(offset, year)
+
+        assert_kind_of(TimeOrDateTime, result)
+        assert_equal(DateTime.new(year, expected_month, expected_day, 1, 0, 0), result.to_datetime)
+      end
+    end
+  end
+
+  def test_day_1_is_always_first_day_of_year
+    rule = JulianDayOfYearTransitionRule.new(1)
+    assert_equal(true, rule.is_always_first_day_of_year?)
+  end
+
+  [2, 365].each do |day|
+    define_method "test_day_#{day}_is_not_always_first_day_of_year" do
+      rule = JulianDayOfYearTransitionRule.new(day)
+      assert_equal(false, rule.is_always_first_day_of_year?)
+    end
+  end
+
+  def test_day_365_is_always_last_day_of_year
+    rule = JulianDayOfYearTransitionRule.new(365)
+    assert_equal(true, rule.is_always_last_day_of_year?)
+  end
+
+  [1, 364].each do |day|
+    define_method "test_day_#{day}_is_not_always_last_day_of_year" do
+      rule = JulianDayOfYearTransitionRule.new(day)
+      assert_equal(false, rule.is_always_last_day_of_year?)
+    end
+  end
+
+  [:==, :eql?].each do |method|
+    [
+      [1, 0],
+      [1, 3600],
+      [365, 0]
+    ].each do |(day, transition_at)|
+      define_method "test_equal_for_day_#{day}_and_transition_at_#{transition_at}_with_#{method}" do
+        rule1 = JulianDayOfYearTransitionRule.new(day, transition_at)
+        rule2 = JulianDayOfYearTransitionRule.new(day, transition_at)
+        assert_equal(true, rule1.send(method, rule2))
+        assert_equal(true, rule2.send(method, rule1))
+      end
+    end
+
+    define_method "test_not_equal_by_day_with_#{method}" do
+      rule1 = JulianDayOfYearTransitionRule.new(1, 0)
+      rule2 = JulianDayOfYearTransitionRule.new(2, 0)
+      assert_equal(false, rule1.send(method, rule2))
+      assert_equal(false, rule2.send(method, rule1))
+    end
+
+    define_method "test_not_equal_to_absolute_with_#{method}" do
+      rule1 = JulianDayOfYearTransitionRule.new(1, 0)
+      rule2 = AbsoluteDayOfYearTransitionRule.new(1, 0)
+      assert_equal(false, rule1.send(method, rule2))
+      assert_equal(false, rule2.send(method, rule1))
+    end
+  end
+
+  [
+    [1, 0],
+    [1, 3600],
+    [365, 0]
+  ].each do |(day, transition_at)|
+    define_method "test_hash_for_day_#{day}_and_transition_at_#{transition_at}" do
+      rule = JulianDayOfYearTransitionRule.new(day, transition_at)
+      expected = [JulianDayOfYearTransitionRule, day * 86400, transition_at].hash
+      assert_equal(expected, rule.hash)
+    end
+  end
+
+  protected
+
+  def create_with_transition_at(transition_at)
+    JulianDayOfYearTransitionRule.new(1, transition_at)
+  end
+end
+
+module DayOfWeekTransitionRuleTestHelper
+  [-1, 0, 13, '1'].each do |month|
+    define_method "test_invalid_month_#{month}" do
+      error = assert_raises(ArgumentError) { create_with_month_and_day_of_week(month, 0) }
+      assert_match(/\bmonth\b/, error.message)
+    end
+  end
+
+  [-1, 7, '0'].each do |day_of_week|
+    define_method "test_invalid_day_of_week_#{day_of_week}" do
+      error = assert_raises(ArgumentError) { create_with_month_and_day_of_week(1, day_of_week) }
+      assert_match(/\bday_of_week\b/, error.message)
+    end
+  end
+
+  def test_is_not_always_first_day_of_year
+    rule = create_with_month_and_day_of_week(1, 0)
+    assert_equal(false, rule.is_always_first_day_of_year?)
+  end
+
+  def test_is_not_always_last_day_of_year
+    rule = create_with_month_and_day_of_week(12, 6)
+    assert_equal(false, rule.is_always_last_day_of_year?)
+  end
+
+  [:==, :eql?].each do |method|
+    define_method "test_not_equal_by_month_with_#{method}" do
+      rule1 = create_with_month_and_day_of_week(1, 0)
+      rule2 = create_with_month_and_day_of_week(2, 0)
+      assert_equal(false, rule1.send(method, rule2))
+      assert_equal(false, rule2.send(method, rule1))
+    end
+
+    define_method "test_not_equal_by_day_of_week_with_#{method}" do
+      rule1 = create_with_month_and_day_of_week(1, 0)
+      rule2 = create_with_month_and_day_of_week(1, 1)
+      assert_equal(false, rule1.send(method, rule2))
+      assert_equal(false, rule2.send(method, rule1))
+    end
+  end
+end
+
+class TCDayOfMonthTransitionRule < Minitest::Test
+  include BaseTransitionRuleTestHelper
+  include DayOfWeekTransitionRuleTestHelper
+
+  [-1, 0, 5, '1'].each do |week|
+    define_method "test_invalid_week_#{week}" do
+      error = assert_raises(ArgumentError) { DayOfMonthTransitionRule.new(1, week, 0) }
+      assert_match(/\bweek\b/, error.message)
+    end
+  end
+
+  [
+    # All possible first week start days.
+    [2020, 3, [1, 2, 3, 4, 5, 6, 7]],
+    [2021, 3, [7, 1, 2, 3, 4, 5, 6]],
+    [2022, 3, [6, 7, 1, 2, 3, 4, 5]],
+    [2023, 3, [5, 6, 7, 1, 2, 3, 4]],
+    [2018, 3, [4, 5, 6, 7, 1, 2, 3]],
+    [2024, 3, [3, 4, 5, 6, 7, 1, 2]],
+    [2025, 3, [2, 3, 4, 5, 6, 7, 1]],
+
+    # All possible months.
+    [2019, 1, [6]],
+    [2019, 2, [3]],
+    [2019, 3, [3]],
+    [2019, 4, [7]],
+    [2019, 5, [5]],
+    [2019, 6, [2]],
+    [2019, 7, [7]],
+    [2019, 8, [4]],
+    [2019, 9, [1]],
+    [2019, 10, [6]],
+    [2019, 11, [3]],
+    [2019, 12, [1]]
+  ].each do |(year, month, days)|
+    days.each_with_index do |expected_day, day_of_week|
+      (1..4).each do |week|
+        define_method "test_month_#{month}_week_#{week}_and_day_of_week_#{day_of_week}_year_#{year}" do
+          rule = DayOfMonthTransitionRule.new(month, week, day_of_week, 3600)
+          offset = TimezoneOffset.new(0, 0, 'TEST')
+
+          result = rule.at(offset, year)
+
+          assert_kind_of(TimeOrDateTime, result)
+          assert_equal(Time.utc(year, month, expected_day + (week - 1) * 7, 1, 0, 0), result.to_time)
+        end
+      end
+    end
+  end
+
+  [[3, 3, 20], [4, 6, 23]].each do |(week, day_of_week, expected_day)|
+    define_method "test_crosses_64_bit_boundary_for_day_of_week_#{day_of_week}" do
+      rule = DayOfMonthTransitionRule.new(1, week, day_of_week, 3600)
+      offset = TimezoneOffset.new(0, 0, 'TEST')
+
+      result = rule.at(offset, 2038)
+
+      assert_kind_of(TimeOrDateTime, result)
+      if RubyCoreSupport.time_supports_64bit
+        assert_kind_of(Time, result.to_orig)
+      else
+        assert_kind_of(DateTime, result.to_orig)
+      end
+      assert_equal(DateTime.new(2038, 1, expected_day, 1, 0, 0), result.to_datetime)
+    end
+  end
+
+  [:==, :eql?].each do |method|
+    [
+      [1, 1, 0, 0],
+      [1, 1, 0, 1],
+      [1, 1, 1, 0],
+      [1, 2, 0, 0],
+      [2, 1, 0, 0]
+    ].each do |(month, week, day_of_week, transition_at)|
+      define_method "test_equal_for_month_#{month}_week_#{week}_day_of_week_#{day_of_week}_and_transition_at_#{transition_at}_with_#{method}" do
+        rule1 = DayOfMonthTransitionRule.new(month, week, day_of_week, transition_at)
+        rule2 = DayOfMonthTransitionRule.new(month, week, day_of_week, transition_at)
+        assert_equal(true, rule1.send(method, rule2))
+        assert_equal(true, rule2.send(method, rule1))
+      end
+    end
+
+    define_method "test_not_equal_by_week_with_#{method}" do
+      rule1 = DayOfMonthTransitionRule.new(1, 1, 0, 0)
+      rule2 = DayOfMonthTransitionRule.new(1, 2, 0, 0)
+      assert_equal(false, rule1.send(method, rule2))
+      assert_equal(false, rule2.send(method, rule1))
+    end
+
+    define_method "test_not_equal_to_last_day_of_month_with_#{method}" do
+      rule1 = DayOfMonthTransitionRule.new(1, 1, 0, 0)
+      rule2 = LastDayOfMonthTransitionRule.new(1, 0, 0)
+      assert_equal(false, rule1.send(method, rule2))
+      assert_equal(false, rule2.send(method, rule1))
+    end
+  end
+
+  [
+    [1, 1, 0, 0],
+    [1, 1, 0, 1],
+    [1, 1, 1, 0],
+    [1, 2, 0, 0],
+    [2, 1, 0, 0]
+  ].each do |(month, week, day_of_week, transition_at)|
+    define_method "test_hash_for_month_#{month}_week_#{week}_day_of_week_#{day_of_week}_and_transition_at_#{transition_at}" do
+      rule = DayOfMonthTransitionRule.new(month, week, day_of_week, transition_at)
+      expected = [(week - 1) * 7 + 1, month, day_of_week, transition_at].hash
+      assert_equal(expected, rule.hash)
+    end
+  end
+
+  protected
+
+  def create_with_transition_at(transition_at)
+    DayOfMonthTransitionRule.new(1, 1, 0, transition_at)
+  end
+
+  def create_with_month_and_day_of_week(month, day_of_week)
+    DayOfMonthTransitionRule.new(month, 1, day_of_week)
+  end
+end
+
+class TCLastDayOfMonthTransitionRule < Minitest::Test
+  include BaseTransitionRuleTestHelper
+  include DayOfWeekTransitionRuleTestHelper
+
+  [
+    # All possible last days.
+    [2021, 10, [31, 25, 26, 27, 28, 29, 30]],
+    [2022, 10, [30, 31, 25, 26, 27, 28, 29]],
+    [2023, 10, [29, 30, 31, 25, 26, 27, 28]],
+    [2018, 10, [28, 29, 30, 31, 25, 26, 27]],
+    [2024, 10, [27, 28, 29, 30, 31, 25, 26]],
+    [2025, 10, [26, 27, 28, 29, 30, 31, 25]],
+    [2026, 10, [25, 26, 27, 28, 29, 30, 31]],
+
+    # All possible months.
+    [2020, 1, [26]],
+    [2020, 2, [23]],
+    [2020, 3, [29]],
+    [2020, 4, [26]],
+    [2020, 5, [31]],
+    [2020, 6, [28]],
+    [2020, 7, [26]],
+    [2020, 8, [30]],
+    [2020, 9, [27]],
+    [2020, 10, [25]],
+    [2020, 11, [29]],
+    [2020, 12, [27]]
+  ].each do |(year, month, days)|
+    days.each_with_index do |expected_day, day_of_week|
+      define_method "test_month_#{month}_day_of_week_#{day_of_week}_year_#{year}" do
+        rule = LastDayOfMonthTransitionRule.new(month, day_of_week, 7200)
+        offset = TimezoneOffset.new(0, 0, 'TEST')
+
+        result = rule.at(offset, year)
+
+        assert_kind_of(TimeOrDateTime, result)
+        assert_equal(Time.utc(year, month, expected_day, 2, 0, 0), result.to_time)
+      end
+    end
+  end
+
+  [[2020, 6, 29], [2021, 0, 28], [2000, 2, 29], [2100, 0, 28]].each do |(year, day_of_week, expected_day)|
+    define_method "test_#{expected_day == 29 ? '' : 'non_'}leap_year_#{year}" do
+      rule = LastDayOfMonthTransitionRule.new(2, day_of_week, 7200)
+      offset = TimezoneOffset.new(0, 0, 'TEST')
+
+      result = rule.at(offset, year)
+
+      assert_kind_of(TimeOrDateTime, result)
+      assert_equal(DateTime.new(year, 2, expected_day, 2, 0, 0), result.to_datetime)
+    end
+  end
+
+  [:==, :eql?].each do |method|
+    [
+      [1, 0, 0],
+      [1, 0, 1],
+      [1, 1, 0],
+      [2, 0, 0]
+    ].each do |(month, day_of_week, transition_at)|
+      define_method "test_equal_for_month_#{month}_day_of_week_#{day_of_week}_and_transition_at_#{transition_at}_with_#{method}" do
+        rule1 = LastDayOfMonthTransitionRule.new(month, day_of_week, transition_at)
+        rule2 = LastDayOfMonthTransitionRule.new(month, day_of_week, transition_at)
+        assert_equal(true, rule1.send(method, rule2))
+        assert_equal(true, rule2.send(method, rule1))
+      end
+    end
+
+    define_method "test_not_equal_to_day_of_month_with_#{method}" do
+      rule1 = LastDayOfMonthTransitionRule.new(1, 0, 0)
+      rule2 = DayOfMonthTransitionRule.new(1, 1, 0, 0)
+      assert_equal(false, rule1.send(method, rule2))
+      assert_equal(false, rule2.send(method, rule1))
+    end
+  end
+
+  [
+    [1, 0, 0],
+    [1, 0, 1],
+    [1, 1, 0],
+    [2, 0, 0]
+  ].each do |(month, day_of_week, transition_at)|
+    define_method "test_hash_for_month_#{month}_day_of_week_#{day_of_week}_and_transition_at_#{transition_at}" do
+      rule = LastDayOfMonthTransitionRule.new(month, day_of_week, transition_at)
+      expected = [month, day_of_week, transition_at].hash
+      assert_equal(expected, rule.hash)
+    end
+  end
+
+  protected
+
+  def create_with_transition_at(transition_at)
+    LastDayOfMonthTransitionRule.new(1, 0, transition_at)
+  end
+
+  def create_with_month_and_day_of_week(month, day_of_week)
+    LastDayOfMonthTransitionRule.new(month, day_of_week)
+  end
+end