tzinfo 1.2.5 → 1.2.9

data/test/tc_annual_rules.rb

@@ -0,0 +1,95 @@
+require File.join(File.expand_path(File.dirname(__FILE__)), 'test_utils')
+
+include TZInfo
+
+class TCAnnualRules < Minitest::Test
+
+  def test_initialize
+    std_offset = TimezoneOffset.new(0, 0, 'GMT')
+    dst_offset = TimezoneOffset.new(0, 3600, 'BST')
+    dst_start_rule = FakeAlwaysDateAdjustmentRule.new(3, 1)
+    dst_end_rule = FakeAlwaysDateAdjustmentRule.new(10, 1)
+
+    rules = AnnualRules.new(std_offset, dst_offset, dst_start_rule, dst_end_rule)
+    assert_same(std_offset, rules.std_offset)
+    assert_same(dst_offset, rules.dst_offset)
+    assert_same(dst_start_rule, rules.dst_start_rule)
+    assert_same(dst_end_rule, rules.dst_end_rule)
+  end
+
+  [2020, 2021].each do |year|
+    define_method "test_transitions_for_dst_mid_year_#{year}" do
+      std_offset = TimezoneOffset.new(3600, 0, 'TEST')
+      dst_offset = TimezoneOffset.new(3600, 3600, 'TESTS')
+
+      rules = AnnualRules.new(
+        std_offset,
+        dst_offset,
+        FakeAlwaysDateAdjustmentRule.new(3, 21),
+        FakeAlwaysDateAdjustmentRule.new(10, 22)
+      )
+
+      result = rules.transitions(year)
+
+      expected = [
+        AnnualRules::Transition.new(dst_offset, std_offset, TimeOrDateTime.wrap(Time.utc(year,  3, 21, 0, 0, 0) - 3600)),
+        AnnualRules::Transition.new(std_offset, dst_offset, TimeOrDateTime.wrap(Time.utc(year, 10, 22, 0, 0, 0) - 7200))
+      ]
+
+      assert_equal(expected, result)
+    end
+
+    define_method "test_transitions_for_dst_start_and_end_of_year_#{year}" do
+      std_offset = TimezoneOffset.new(3600, 0, 'TEST')
+      dst_offset = TimezoneOffset.new(3600, 3600, 'TESTS')
+
+      rules = AnnualRules.new(
+        std_offset,
+        dst_offset,
+        FakeAlwaysDateAdjustmentRule.new(10, 22),
+        FakeAlwaysDateAdjustmentRule.new(3, 21)
+      )
+
+      result = rules.transitions(year)
+
+      expected = [
+        AnnualRules::Transition.new(std_offset, dst_offset, TimeOrDateTime.wrap(Time.utc(year,  3, 21, 0, 0, 0) - 7200)),
+        AnnualRules::Transition.new(dst_offset, std_offset, TimeOrDateTime.wrap(Time.utc(year, 10, 22, 0, 0, 0) - 3600))
+      ]
+
+      assert_equal(expected, result)
+    end
+
+    define_method "test_transitions_for_negative_dst_start_and_end_of_year_#{year}" do
+      std_offset = TimezoneOffset.new(7200, 0, 'TEST')
+      dst_offset = TimezoneOffset.new(7200, -3600, 'TESTW')
+
+      rules = AnnualRules.new(
+        std_offset,
+        dst_offset,
+        FakeAlwaysDateAdjustmentRule.new(10, 22),
+        FakeAlwaysDateAdjustmentRule.new(3, 21)
+      )
+
+      result = rules.transitions(year)
+
+      expected = [
+        AnnualRules::Transition.new(std_offset, dst_offset, TimeOrDateTime.wrap(Time.utc(year,  3, 21, 0, 0, 0) - 3600)),
+        AnnualRules::Transition.new(dst_offset, std_offset, TimeOrDateTime.wrap(Time.utc(year, 10, 22, 0, 0, 0) - 7200))
+      ]
+
+      assert_equal(expected, result)
+    end
+  end
+
+  class FakeAlwaysDateAdjustmentRule
+    def initialize(month, day)
+      @month = month
+      @day = day
+    end
+
+    def at(offset, year)
+      TimeOrDateTime.wrap(Time.utc(year, @month, @day, 0, 0, 0) - offset.utc_total_offset)
+    end
+  end
+end

data/test/tc_country.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 TCCountry < Minitest::Test
   def setup
     @orig_data_source = DataSource.get
@@ -46,7 +50,7 @@ class TCCountry < Minitest::Test
   def test_get_tainted_loaded
     Country.get('GB')
   
-    safe_test do
+    safe_test(:unavailable => :skip) do
       code = 'GB'.dup.taint
       assert(code.tainted?)
       country = Country.get(code)
@@ -65,7 +69,7 @@ class TCCountry < Minitest::Test
   end
   
   def test_get_tainted_not_previously_loaded
-    safe_test do
+    safe_test(:unavailable => :skip) do
       code = 'GB'.dup.taint
       assert(code.tainted?)
       country = Country.get(code)

data/test/tc_posix_time_zone_parser.rb

@@ -0,0 +1,261 @@
+require File.join(File.expand_path(File.dirname(__FILE__)), 'test_utils')
+
+include TZInfo
+
+class TCPosixTimeZoneParser < Minitest::Test
+  HOUR = 3600
+  MINUTE = 60
+
+  class << self
+    private
+
+    def append_time_to_rule(day_rule, time)
+      time ? "#{day_rule}/#{time}" : day_rule
+    end
+
+    def define_invalid_dst_rule_tests(type, rule)
+      define_method "test_#{type}_dst_start_rule_for_invalid_#{rule}" do
+        tz_string = "STD-1DST,#{rule},300"
+        assert_raises(InvalidPosixTimeZone) { @parser.parse(tz_string) }
+      end
+
+      define_method "test_#{type}_dst_end_rule_for_invalid_#{rule}" do
+        tz_string = "STD-1DST,60,#{rule}"
+        assert_raises(InvalidPosixTimeZone) { @parser.parse(tz_string) }
+      end
+    end
+  end
+
+  def setup
+    @parser = PosixTimeZoneParser.new
+  end
+
+  def test_empty_rule_returns_nil
+    result = @parser.parse('')
+    assert_nil(result)
+  end
+
+  ABBREVIATIONS_WITH_OFFSETS = [
+    ['UTC0', :UTC, 0],
+    ['U0', :U, 0],
+    ['West1', :West, -HOUR],
+    ['East-1', :East, HOUR],
+    ['<-05>5', :'-05', -5 * HOUR],
+    ['<+12>-12', :'+12', 12 * HOUR],
+    ['HMM2:30', :HMM, -(2 * HOUR + 30 * MINUTE)],
+    ['HHMM02:30', :HHMM, -(2 * HOUR + 30 * MINUTE)],
+    ['HHMM+02:30', :HHMM, -(2 * HOUR + 30 * MINUTE)],
+    ['HHMSS-12:5:50', :HHMSS, 12 * HOUR + 5 * MINUTE + 50],
+    ['HHMMSS-12:05:50', :HHMMSS, 12 * HOUR + 5 * MINUTE + 50],
+    ['HHMMS-12:05:7', :HHMMS, 12 * HOUR + 5 * MINUTE + 7]
+  ]
+
+  ABBREVIATIONS_WITH_OFFSETS.each do |(tz_string, expected_abbrev, expected_base_offset)|
+    define_method "test_std_only_returns_std_offset_#{tz_string}" do
+      result = @parser.parse(tz_string)
+      expected = TimezoneOffset.new(expected_base_offset, 0, expected_abbrev)
+      assert_equal(expected, result)
+    end
+  end
+
+  ABBREVIATIONS_WITH_OFFSETS.each do |(abbrev_and_offset, expected_abbrev, expected_base_offset)|
+    define_method "test_std_offset_#{abbrev_and_offset}" do
+      result = @parser.parse(abbrev_and_offset + 'DST,60,300')
+      expected_std_offset = TimezoneOffset.new(expected_base_offset, 0, expected_abbrev)
+      assert_equal(expected_std_offset, result.std_offset)
+    end
+  end
+
+  [
+    ['Zero0One-1', :One, 0, HOUR],
+    ['Zero0One', :One, 0, HOUR],
+    ['Z0O', :O, 0, HOUR],
+    ['West1WestS0', :WestS, -HOUR, HOUR],
+    ['West1WestS', :WestS, -HOUR, HOUR],
+    ['East-1EastS-2', :EastS, HOUR, HOUR],
+    ['East-1EastS', :EastS, HOUR, HOUR],
+    ['Neg2NegS3', :NegS, -2 * HOUR, -HOUR],
+    ['<-05>5<-04>4', :'-04', -5 * HOUR, HOUR],
+    ['STD5<-04>4', :'-04', -5 * HOUR, HOUR],
+    ['<+12>-12<+13>-13', :'+13', 12 * HOUR, HOUR],
+    ['STD-12<+13>-13', :'+13', 12 * HOUR, HOUR],
+    ['HMM2:30SHMM1:15', :SHMM, -(2 * HOUR + 30 * MINUTE), HOUR + 15 * MINUTE],
+    ['HHMM02:30SHHMM01:15', :SHHMM, -(2 * HOUR + 30 * MINUTE), HOUR + 15 * MINUTE],
+    ['HHMM+02:30SHHMM+01:15', :SHHMM, -(2 * HOUR + 30 * MINUTE), HOUR + 15 * MINUTE],
+    ['HHMSS-12:5:50SHHMSS-13:4:30', :SHHMSS, 12 * HOUR + 5 * MINUTE + 50, 58 * MINUTE + 40],
+    ['HHMMSS-12:05:50SHHMMSS-13:04:30', :SHHMMSS, 12 * HOUR + 5 * MINUTE + 50, 58 * MINUTE + 40],
+    ['HHMMS-12:05:7SHHMMSS-13:06:8', :SHHMMSS, 12 * HOUR + 5 * MINUTE + 7, HOUR + MINUTE + 1],
+  ].each do |(abbrevs_and_offsets, expected_abbrev, expected_base_offset, expected_std_offset)|
+    define_method "test_dst_offset_#{abbrevs_and_offsets}" do
+      result = @parser.parse(abbrevs_and_offsets + ',60,300')
+      expected_dst_offset = TimezoneOffset.new(expected_base_offset, expected_std_offset, expected_abbrev)
+      assert_equal(expected_dst_offset, result.dst_offset)
+    end
+  end
+
+  ['<M-1>01:-1', '<M60>01:60', '<S-1>01:00:-1', '<S60>01:00:60'].each do |abbrev_and_offset|
+    ['', 'DST,60,300'].each do |dst_suffix|
+      tz_string = abbrev_and_offset + dst_suffix
+      define_method "test_std_offset_invalid_#{tz_string}" do
+        assert_raises(InvalidPosixTimeZone) { @parser.parse(tz_string) }
+      end
+    end
+
+    tz_string = "STD1#{abbrev_and_offset},60,300"
+    define_method "test_dst_offset_invalid_#{tz_string}" do
+      assert_raises(InvalidPosixTimeZone) { @parser.parse(tz_string) }
+    end
+  end
+
+  [
+    [nil, 2 * HOUR],
+    ['2', 2 * HOUR],
+    ['+2', 2 * HOUR],
+    ['-2', -2 * HOUR],
+    ['2:3:4', 2 * HOUR + 3 * MINUTE + 4],
+    ['02:03:04', 2 * HOUR + 3 * MINUTE + 4],
+    ['-2:3:4', -2 * HOUR + 3 * MINUTE + 4], # 22:03:04 on the day prior to the one specified
+    ['-02:03:04', -2 * HOUR + 3 * MINUTE + 4],
+    ['167', 167 * HOUR],
+    ['-167', -167 * HOUR]
+  ].each do |(time, expected_offset_from_midnight)|
+    [
+      ['J1', 1],
+      ['J365', 365]
+    ].each do |(julian_day_rule, expected_julian_day)|
+      rule = append_time_to_rule(julian_day_rule, time)
+
+      define_method "test_julian_day_dst_start_rule_for_#{rule}" do
+        result = @parser.parse("STD-1DST,#{rule},300")
+        expected_dst_start_rule = JulianDayOfYearTransitionRule.new(expected_julian_day, expected_offset_from_midnight)
+        assert_equal(expected_dst_start_rule, result.dst_start_rule)
+      end
+
+      define_method "test_julian_day_dst_end_rule_for_#{rule}" do
+        result = @parser.parse("STD-1DST,60,#{rule}")
+        expected_dst_end_rule = JulianDayOfYearTransitionRule.new(expected_julian_day, expected_offset_from_midnight)
+        assert_equal(expected_dst_end_rule, result.dst_end_rule)
+      end
+    end
+
+    [
+      ['0', 0],
+      ['365', 365]
+    ].each do |(absolute_day_rule, expected_day)|
+      rule = append_time_to_rule(absolute_day_rule, time)
+
+      define_method "test_absolute_day_dst_start_rule_for_#{rule}" do
+        result = @parser.parse("STD-1DST,#{rule},J300")
+        expected_dst_start_rule = AbsoluteDayOfYearTransitionRule.new(expected_day, expected_offset_from_midnight)
+        assert_equal(expected_dst_start_rule, result.dst_start_rule)
+      end
+
+      define_method "test_absolute_day_dst_end_rule_for_#{rule}" do
+        result = @parser.parse("STD-1DST,J60,#{rule}")
+        expected_dst_end_rule = AbsoluteDayOfYearTransitionRule.new(expected_day, expected_offset_from_midnight)
+        assert_equal(expected_dst_end_rule, result.dst_end_rule)
+      end
+    end
+
+    [
+      ['M1.1.0', 1, 1, 0],
+      ['M12.4.6', 12, 4, 6]
+    ].each do |(day_of_month_rule, expected_month, expected_week, expected_day_of_week)|
+      rule = append_time_to_rule(day_of_month_rule, time)
+
+      define_method "test_day_of_month_dst_start_rule_for_#{rule}" do
+        result = @parser.parse("STD-1DST,#{rule},300")
+        expected_dst_start_rule = DayOfMonthTransitionRule.new(expected_month, expected_week, expected_day_of_week, expected_offset_from_midnight)
+        assert_equal(expected_dst_start_rule, result.dst_start_rule)
+      end
+
+      define_method "test_day_of_month_dst_end_rule_for_#{rule}" do
+        result = @parser.parse("STD-1DST,60,#{rule}")
+        expected_dst_end_rule = DayOfMonthTransitionRule.new(expected_month, expected_week, expected_day_of_week, expected_offset_from_midnight)
+        assert_equal(expected_dst_end_rule, result.dst_end_rule)
+      end
+    end
+
+    [
+      ['M1.5.0', 1, 0],
+      ['M12.5.6', 12, 6]
+    ].each do |(last_day_of_month_rule, expected_month, expected_day_of_week)|
+      rule = append_time_to_rule(last_day_of_month_rule, time)
+
+      define_method "test_last_day_of_month_dst_start_rule_for_#{rule}" do
+        result = @parser.parse("STD-1DST,#{rule},300")
+        expected_dst_start_rule = LastDayOfMonthTransitionRule.new(expected_month, expected_day_of_week, expected_offset_from_midnight)
+        assert_equal(expected_dst_start_rule, result.dst_start_rule)
+      end
+
+      define_method "test_last_day_of_month_dst_end_rule_for_#{rule}" do
+        result = @parser.parse("STD-1DST,60,#{rule}")
+        expected_dst_end_rule = LastDayOfMonthTransitionRule.new(expected_month, expected_day_of_week, expected_offset_from_midnight)
+        assert_equal(expected_dst_end_rule, result.dst_end_rule)
+      end
+    end
+  end
+
+  ['J0', 'J366'].each do |julian_day_rule|
+    define_invalid_dst_rule_tests('julian_day', julian_day_rule)
+  end
+
+  ['-1', '366'].each do |absolute_day_rule|
+    define_invalid_dst_rule_tests('absolute_day', absolute_day_rule)
+  end
+
+  ['M0,1,0', 'M13,1,0', 'M6,0,0', 'M6,6,0', 'M6,1,-1', 'M6,1,7'].each do |day_of_month_rule|
+    define_invalid_dst_rule_tests('day_of_month', day_of_month_rule)
+  end
+
+  ['M0,5,0', 'M13,5,0', 'M6,5,-1', 'M6,5,7'].each do |last_day_of_month_rule|
+    define_invalid_dst_rule_tests('last_day_of_month', last_day_of_month_rule)
+  end
+
+  def test_invalid_dst_start_rule
+    assert_raises(InvalidPosixTimeZone) { @parser.parse('STD1DST,X60,300') }
+  end
+
+  def test_invalid_dst_end_rule
+    assert_raises(InvalidPosixTimeZone) { @parser.parse('STD1DST,60,X300') }
+  end
+
+  [
+    ['STD5DST,0/0,J365/25', :DST, -5 * HOUR, HOUR],
+    ['STD-5DST,0/0,J365/25', :DST, 5 * HOUR, HOUR],
+    ['STD5DST3,0/0,J365/26', :DST, -5 * HOUR, 2 * HOUR],
+    ['STD5DST6,0/0,J365/23', :DST, -5 * HOUR, -HOUR],
+    ['STD5DST,J1/0,J365/25', :DST, -5 * HOUR, HOUR],
+    ['Winter5Summer,0/0,J365/25', :Summer, -5 * HOUR, HOUR],
+    ['<-05>5<-06>,0/0,J365/25', :'-06', -5 * HOUR, HOUR]
+  ].each do |(tz_string, expected_abbrev, expected_base_offset, expected_std_offset)|
+    define_method "test_dst_only_returns_continuous_offset_for_#{tz_string}" do
+      result = @parser.parse(tz_string)
+      expected = TimezoneOffset.new(expected_base_offset, expected_std_offset, expected_abbrev)
+      assert_equal(expected, result)
+    end
+  end
+
+  def test_parses_tainted_string_in_safe_mode_and_returns_untainted_abbreviations
+    safe_test(:unavailable => :skip) do
+      result = @parser.parse('STD1DST,60,300'.dup.taint)
+
+      assert_equal(:STD, result.std_offset.abbreviation)
+      assert_equal(:DST, result.dst_offset.abbreviation)
+    end
+  end
+
+  ['STD1', 'STD1DST,60,300'].each do |tz_string|
+    tz_string += "-"
+    define_method "test_content_after_end_for_#{tz_string}" do
+      error = assert_raises(InvalidPosixTimeZone) { @parser.parse(tz_string) }
+      assert_equal("Expected the end of a POSIX-style time zone string but found '-'.", error.message)
+    end
+  end
+
+  ['X', 0].each do |invalid_tz_string|
+    define_method "test_invalid_tz_string_#{invalid_tz_string}" do
+      assert_raises(InvalidPosixTimeZone) { @parser.parse(invalid_tz_string) }
+    end
+  end
+end

data/test/tc_ruby_data_source.rb

@@ -2,11 +2,31 @@ 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 TCRubyDataSource < Minitest::Test
   def setup
     @data_source = RubyDataSource.new
   end
   
+  def test_initialize_not_found
+    # A failure to load tzinfo/data in initialize will not cause an exception.
+    # Attempts to load data files will subsequently fail.
+    code = <<-EOF
+      begin
+        ds = TZInfo::RubyDataSource.new
+        puts 'Initialized'
+        ds.load_timezone_info('Europe/London')
+      rescue Exception => e
+        puts e.class
+      end
+    EOF
+
+    assert_sub_process_returns(['Initialized', 'TZInfo::InvalidTimezoneIdentifier'], code)
+  end
+
   def test_load_timezone_info_data
     info = @data_source.load_timezone_info('Europe/London')
     assert_kind_of(DataTimezoneInfo, info)
@@ -55,7 +75,9 @@ class TCRubyDataSource < Minitest::Test
   end
 
   def test_load_timezone_info_tainted
-    safe_test do
+    skip_if_has_bug_14060
+
+    safe_test(:unavailable => :skip) do
       identifier = 'Europe/Amsterdam'.dup.taint
       assert(identifier.tainted?)
       info = @data_source.load_timezone_info(identifier)
@@ -65,6 +87,8 @@ class TCRubyDataSource < Minitest::Test
   end
   
   def test_load_timezone_info_tainted_and_frozen
+    skip_if_has_bug_14060
+
     safe_test do
       info = @data_source.load_timezone_info('Europe/Amsterdam'.dup.taint.freeze)
       assert_equal('Europe/Amsterdam', info.identifier)
@@ -119,7 +143,7 @@ class TCRubyDataSource < Minitest::Test
   end
   
   def test_load_country_info_tainted
-    safe_test do
+    safe_test(:unavailable => :skip) do
       code = 'NL'.dup.taint
       assert(code.tainted?)
       info = @data_source.load_country_info(code)

data/test/tc_time_or_datetime.rb

@@ -4,6 +4,12 @@ require 'rational' unless defined?(Rational)
 include TZInfo
 
 class TCTimeOrDateTime < Minitest::Test
+  # Ruby 1.8.7 (built with GCC 8.3.0 on Ubuntu 19.04) fails to perform DateTime
+  # arithmetic operations correctly when sub-seconds are used. Detect this and
+  # disable the affected tests.
+  DATETIME_SUBSECOND_ARITHMETIC_IS_BROKEN = (DateTime.new(2019, 12, 22, 15, 0, Rational(1, 1000)) + Rational(1, 86400)).strftime('%Q') != '1577026801001'
+  puts "DateTime sub-second arithmetic is broken on this platform" if DATETIME_SUBSECOND_ARITHMETIC_IS_BROKEN
+
   def test_initialize_time
     assert_nothing_raised do
       TimeOrDateTime.new(Time.utc(2006, 3, 24, 15, 32, 3, 721000))
@@ -243,6 +249,20 @@ class TCTimeOrDateTime < Minitest::Test
     assert_equal(24, TimeOrDateTime.new(DateTime.new(2006, 3, 24, 15, 32, 3)).day)
     assert_equal(24, TimeOrDateTime.new(1143214323).day)
   end
+
+  19.upto(25).each_with_index do |mday,i|
+    define_method "test_wday_time_#{i}" do
+      assert_equal(i, TimeOrDateTime.new(Time.utc(2006, 3, mday)).wday)
+    end
+
+    define_method "test_wday_datetime_#{i}" do
+      assert_equal(i, TimeOrDateTime.new(DateTime.new(2006, 3, mday)).wday)
+    end
+
+    define_method "test_wday_timestamp_#{i}" do
+      assert_equal(i, TimeOrDateTime.new(Time.utc(2006, 3, mday).to_i).wday)
+    end
+  end
   
   def test_hour
     assert_equal(15, TimeOrDateTime.new(Time.utc(2006, 3, 24, 15, 32, 3)).hour)
@@ -500,12 +520,12 @@ class TCTimeOrDateTime < Minitest::Test
     assert_equal(Time.utc(2006, 3, 24, 15, 32, 4), (TimeOrDateTime.new(Time.utc(2006, 3, 24, 15, 32, 3)) + 1).to_orig)
     assert_equal(Time.utc(2006, 3, 24, 15, 32, 4, 721000), (TimeOrDateTime.new(Time.utc(2006, 3, 24, 15, 32, 3, 721000)) + 1).to_orig)
     assert_equal(DateTime.new(2006, 3, 24, 15, 32, 4), (TimeOrDateTime.new(DateTime.new(2006, 3, 24, 15, 32, 3)) + 1).to_orig)
-    assert_equal(DateTime.new(2006, 3, 24, 15, 32, 4 + Rational(721, 1000)), (TimeOrDateTime.new(DateTime.new(2006, 3, 24, 15, 32, 3 + Rational(721, 1000))) + 1).to_orig)
+    assert_equal(DateTime.new(2006, 3, 24, 15, 32, 4 + Rational(721, 1000)), (TimeOrDateTime.new(DateTime.new(2006, 3, 24, 15, 32, 3 + Rational(721, 1000))) + 1).to_orig) unless DATETIME_SUBSECOND_ARITHMETIC_IS_BROKEN
     assert_equal(1143214324, (TimeOrDateTime.new(1143214323) + 1).to_orig)
     assert_equal(Time.utc(2006, 3, 24, 15, 32, 2), (TimeOrDateTime.new(Time.utc(2006, 3, 24, 15, 32, 3)) + (-1)).to_orig)
     assert_equal(Time.utc(2006, 3, 24, 15, 32, 2, 721000), (TimeOrDateTime.new(Time.utc(2006, 3, 24, 15, 32, 3, 721000)) + (-1)).to_orig)
     assert_equal(DateTime.new(2006, 3, 24, 15, 32, 2), (TimeOrDateTime.new(DateTime.new(2006, 3, 24, 15, 32, 3)) + (-1)).to_orig)
-    assert_equal(DateTime.new(2006, 3, 24, 15, 32, 2 + Rational(721, 1000)), (TimeOrDateTime.new(DateTime.new(2006, 3, 24, 15, 32, 3 + Rational(721, 1000))) + (-1)).to_orig)
+    assert_equal(DateTime.new(2006, 3, 24, 15, 32, 2 + Rational(721, 1000)), (TimeOrDateTime.new(DateTime.new(2006, 3, 24, 15, 32, 3 + Rational(721, 1000))) + (-1)).to_orig) unless DATETIME_SUBSECOND_ARITHMETIC_IS_BROKEN
     assert_equal(1143214322, (TimeOrDateTime.new(1143214323) + (-1)).to_orig)
   end
   
@@ -518,12 +538,12 @@ class TCTimeOrDateTime < Minitest::Test
     assert_equal(Time.utc(2006, 3, 24, 15, 32, 2), (TimeOrDateTime.new(Time.utc(2006, 3, 24, 15, 32, 3)) - 1).to_orig)
     assert_equal(Time.utc(2006, 3, 24, 15, 32, 2, 721000), (TimeOrDateTime.new(Time.utc(2006, 3, 24, 15, 32, 3, 721000)) - 1).to_orig)
     assert_equal(DateTime.new(2006, 3, 24, 15, 32, 2), (TimeOrDateTime.new(DateTime.new(2006, 3, 24, 15, 32, 3)) - 1).to_orig)
-    assert_equal(DateTime.new(2006, 3, 24, 15, 32, 2 + Rational(721, 1000)), (TimeOrDateTime.new(DateTime.new(2006, 3, 24, 15, 32, 3 + Rational(721, 1000))) - 1).to_orig)
+    assert_equal(DateTime.new(2006, 3, 24, 15, 32, 2 + Rational(721, 1000)), (TimeOrDateTime.new(DateTime.new(2006, 3, 24, 15, 32, 3 + Rational(721, 1000))) - 1).to_orig) unless DATETIME_SUBSECOND_ARITHMETIC_IS_BROKEN
     assert_equal(1143214322, (TimeOrDateTime.new(1143214323) - 1).to_orig)
     assert_equal(Time.utc(2006, 3, 24, 15, 32, 4), (TimeOrDateTime.new(Time.utc(2006, 3, 24, 15, 32, 3)) - (-1)).to_orig)
     assert_equal(Time.utc(2006, 3, 24, 15, 32, 4, 721000), (TimeOrDateTime.new(Time.utc(2006, 3, 24, 15, 32, 3, 721000)) - (-1)).to_orig)
     assert_equal(DateTime.new(2006, 3, 24, 15, 32, 4), (TimeOrDateTime.new(DateTime.new(2006, 3, 24, 15, 32, 3)) - (-1)).to_orig)
-    assert_equal(DateTime.new(2006, 3, 24, 15, 32, 4 + Rational(721, 1000)), (TimeOrDateTime.new(DateTime.new(2006, 3, 24, 15, 32, 3 + Rational(721, 1000))) - (-1)).to_orig)
+    assert_equal(DateTime.new(2006, 3, 24, 15, 32, 4 + Rational(721, 1000)), (TimeOrDateTime.new(DateTime.new(2006, 3, 24, 15, 32, 3 + Rational(721, 1000))) - (-1)).to_orig) unless DATETIME_SUBSECOND_ARITHMETIC_IS_BROKEN
     assert_equal(1143214324, (TimeOrDateTime.new(1143214323) - (-1)).to_orig)
   end
   
@@ -536,12 +556,12 @@ class TCTimeOrDateTime < Minitest::Test
     assert_equal(Time.utc(2006, 3, 24, 15, 32, 4), TimeOrDateTime.new(Time.utc(2006, 3, 24, 15, 32, 3)).add_with_convert(1).to_orig)
     assert_equal(Time.utc(2006, 3, 24, 15, 32, 4, 721000), TimeOrDateTime.new(Time.utc(2006, 3, 24, 15, 32, 3, 721000)).add_with_convert(1).to_orig)
     assert_equal(DateTime.new(2006, 3, 24, 15, 32, 4), TimeOrDateTime.new(DateTime.new(2006, 3, 24, 15, 32, 3)).add_with_convert(1).to_orig)
-    assert_equal(DateTime.new(2006, 3, 24, 15, 32, 4 + Rational(721, 1000)), TimeOrDateTime.new(DateTime.new(2006, 3, 24, 15, 32, 3 + Rational(721, 1000))).add_with_convert(1).to_orig)
+    assert_equal(DateTime.new(2006, 3, 24, 15, 32, 4 + Rational(721, 1000)), TimeOrDateTime.new(DateTime.new(2006, 3, 24, 15, 32, 3 + Rational(721, 1000))).add_with_convert(1).to_orig) unless DATETIME_SUBSECOND_ARITHMETIC_IS_BROKEN
     assert_equal(1143214324, TimeOrDateTime.new(1143214323).add_with_convert(1).to_orig)
     assert_equal(Time.utc(2006, 3, 24, 15, 32, 2), TimeOrDateTime.new(Time.utc(2006, 3, 24, 15, 32, 3)).add_with_convert(-1).to_orig)
     assert_equal(Time.utc(2006, 3, 24, 15, 32, 2, 721000), TimeOrDateTime.new(Time.utc(2006, 3, 24, 15, 32, 3, 721000)).add_with_convert(-1).to_orig)
     assert_equal(DateTime.new(2006, 3, 24, 15, 32, 2), TimeOrDateTime.new(DateTime.new(2006, 3, 24, 15, 32, 3)).add_with_convert(-1).to_orig)
-    assert_equal(DateTime.new(2006, 3, 24, 15, 32, 2 + Rational(721, 1000)), TimeOrDateTime.new(DateTime.new(2006, 3, 24, 15, 32, 3 + Rational(721, 1000))).add_with_convert(-1).to_orig)
+    assert_equal(DateTime.new(2006, 3, 24, 15, 32, 2 + Rational(721, 1000)), TimeOrDateTime.new(DateTime.new(2006, 3, 24, 15, 32, 3 + Rational(721, 1000))).add_with_convert(-1).to_orig) unless DATETIME_SUBSECOND_ARITHMETIC_IS_BROKEN
     assert_equal(1143214322, TimeOrDateTime.new(1143214323).add_with_convert(-1).to_orig)
     
     if RubyCoreSupport.time_supports_negative