Make float and date of ITime not overflow

Author: ph-kev

src/ITime.jl

@@ -101,12 +101,30 @@ end
 """
     date(t::ITime)
 
-Return the date associated with `t`. If the time is fractional round it to millisecond.
+Return the date associated with `t`. If the time is fractional, round it to
+millisecond.
 
-For this to work, `t` has to have a `epoch`
+For this to work, `t` has to have a `epoch`.
 """
 function date(t::ITime)
-    return epoch(t) + counter(t) * period(t)
+    current_date = epoch(t)
+    elapsed_period = counter(t) * period(t)
+
+    # We only check if `elapsed_period` overflows.
+    # It is reasonable to assume that the date will not overflow since the
+    # maximum value for the date is 292277025-08-17T07:12:55.807
+    # which is computed by
+    # `DateTime(Dates.UTInstant(Millisecond(typemax(Int64))))`.
+    # Meanwhile, it is possible for `elapsed_period` to overflow if the period
+    # is extremely small (e.g. nanosecond) and Int64 is used for the counter.
+    # Although, this will not happen for the nanosecond and Int64 case for ~294
+    # years
+    period_is_zero = period(t) == zero(period(t))
+    no_overflow = period_is_zero || elapsed_period / period(t) == counter(t)
+    no_overflow && return current_date + elapsed_period
+    error(
+        "Overflow with counter(t) * period(t) in computing the date; try to use a bigger value for the period if possible",
+    )
 end
 
 """
@@ -159,7 +177,7 @@ function Base.show(io::IO, time::ITime)
     # them because they cannot be nicely converted to Periods, instead of
     # reconstruct the string from the type name and the value (obtained my
     # multiplying the counter and the number of units in the period)
-    value = counter(time) * period(time).value
+    value = counter(time) * float(period(time).value)
     plural_s = abs(value) != 1 ? "s" : ""
     unit = lowercase(string(nameof(typeof(period(time))))) * plural_s
 
@@ -348,7 +366,7 @@ Convert an `ITime` to a floating-point number representing the time in seconds.
 """
 function Base.float(t::T) where {T <: ITime}
     if VERSION >= v"1.11"
-        return float(Dates.seconds(t.period) * t.counter)
+        return float(Dates.seconds(t.period)) * t.counter
     else
         return Dates.tons(t.period) / 1_000_000_000 * t.counter
     end

test/itime.jl

@@ -143,19 +143,20 @@ using Test, Dates
 
     @testset "Show method" begin
         t1 = ITime(10)
-        @test sprint(show, t1) == "10 seconds [counter = 10, period = 1 second]"
+        @test sprint(show, t1) ==
+              "10.0 seconds [counter = 10, period = 1 second]"
 
         t2 = ITime(10, epoch = Dates.DateTime(2024, 1, 1))
         @test sprint(show, t2) ==
-              "10 seconds (2024-01-01T00:00:10) [counter = 10, period = 1 second, epoch = 2024-01-01T00:00:00]"
+              "10.0 seconds (2024-01-01T00:00:10) [counter = 10, period = 1 second, epoch = 2024-01-01T00:00:00]"
 
         t3 = ITime(
             10,
             period = Dates.Hour(1),
             epoch = Dates.DateTime(2024, 1, 1),
         )
         @test sprint(show, t3) ==
-              "10 hours (2024-01-01T10:00:00) [counter = 10, period = 1 hour, epoch = 2024-01-01T00:00:00]"
+              "10.0 hours (2024-01-01T10:00:00) [counter = 10, period = 1 hour, epoch = 2024-01-01T00:00:00]"
     end
 
     @testset "Find common epoch" begin
@@ -290,4 +291,38 @@ using Test, Dates
         @test typeof(zero(t1).counter) == Int32
         @test typeof(mod(t3, t2).counter) == Int32
     end
+
+    @testset "Overflow test" begin
+        t1 = ITime(typemax(Int64), period = Second(2))
+        # Dates.seconds(t.period) returns an integer if t.period is in seconds
+        # Multiplying this by t.counter, an integer, results in an integer that
+        # could overflow
+        @test isapprox(float(t1), float(typemax(Int64)) * 2.0)
+
+        # The computation epoch(t) + counter(t) * period(t) could overflow since
+        # counter(t) * period(t) could overflow. In this case, the maximum value
+        # of period(t) is 2^63 - 1 nanoseconds. Multiplying 2 nanoseconds by the
+        # counter overflow and give -2 nanoseconds. Here, we decide to throw an
+        # error instead of circumventing the overflow. One way to circumvent the
+        # overflow is to add counter(t) * oneunit(period(t)) n times, where n is
+        # the value of period.
+        t2 = ITime(
+            typemax(Int64),
+            period = Nanosecond(2),
+            epoch = Dates.DateTime(2010),
+        )
+        @test_throws ErrorException date(t2)
+
+        # Same tests as above, but with Int32
+        t3 = ITime(typemax(Int32), period = Second(2))
+        @test isapprox(float(t3), float(typemax(Int32)) * 2.0)
+
+        t4 = ITime(
+            typemax(Int32),
+            period = Nanosecond(2),
+            epoch = Dates.DateTime(2010),
+        )
+        # We do not overflow because Period uses Int64 internally
+        @test date(t4) == Dates.DateTime(2010) + typemax(Int32) * Nanosecond(2)
+    end
 end