I do not know Ada, but you raise a good point. Thanks for sharing that.

On a side note, this bug can actually be exploited in certain cases.

package Standard is
[...]
type Duration is delta implementation-defined range implementation-defined;
end Standard;

(Duration is a fixed-point type representing seconds with absolute accuracy, as opposed to a floating-point type that has relative accuracy).

package Ada.Calendar is
type Time is private;
subtype Year_Number is Integer range 1901 .. 2399;
subtype Month_Number is Integer range 1 .. 12;
subtype Day_Number is Integer range 1 .. 31;
subtype Day_Duration is Duration range 0.0 .. 86_400.0;
function Clock return Time;
function Year (Date : Time) return Year_Number;
function Month (Date : Time) return Month_Number;
function Day (Date : Time) return Day_Number;
function Seconds(Date : Time) return Day_Duration;
procedure Split (Date : in Time;
Year : out Year_Number;
Month : out Month_Number;
Day : out Day_Number;
Seconds : out Day_Duration);
function Time_Of(Year : Year_Number;
Month : Month_Number;
Day : Day_Number;
Seconds : Day_Duration := 0.0)
return Time;
function “+” (Left : Time; Right : Duration) return Time;
function “+” (Left : Duration; Right : Time) return Time;
function “-” (Left : Time; Right : Duration) return Time;
function “-” (Left : Time; Right : Time) return Duration;
function “<" (Left, Right : Time) return Boolean;
function "” (Left, Right : Time) return Boolean;
function “>=”(Left, Right : Time) return Boolean;
Time_Error : exception;
private
… — not specified by the language
end Ada.Calendar;

Ada programmers consequently spend comparatively very little time debugging their software.

@Nov
@steven
@DD605
@Michal R.

Yep that is a solution one could use. If one of the participants in the operations is a long, the result would have to be a long.

@knalli
@Fabricio Tuosto

Yep I agree that a calendar could be used here to provide a better solution.

When I said bug, I meant it was a bug from the method and developer’s perspective. This component is supposed to return the expiry time but it does the opposite sometimes

The developer assumes that
long future = 3600 * 24 * days * 1000;

will compute as long, but that is not true. Because every component of “3600 * 24 * days * 1000″ is int – the result is int, too. The type of “future” does not matter (because it is irrelevant for the computing part).

If you want a calculating “on long level” at least one component must be long. If this is not so, you must at least one of them. Option 1 use no “int days” but “long days” or option 2 cast one of the factors, like “3600L”.

The issue, other story:
float d = 1/2

The result is not 0.5 because int/int has no decimals.

Anyway, the usage of calendar and “real” 40 days would be better. The next 40 days can be 3456000001 seconds, too.

Yes, you are not using Joda Time http://joda-time.sourceforge.net/ for your date and time calculations