mirror of
https://github.com/boostorg/date_time.git
synced 2026-01-20 04:22:34 +00:00
1a95e81043
1. is_positive()
- Return boolean value to indicate whether or not time duration is
positive.
2. is_zero()
- Return boolean value to indicate whether or not time duration is
zero.
3. abs()
- Return a time_duration which is the absolute value of time
duration.
Added documentation for these helper functions and improved existing
documentation to indicate constness, return values or static
functions.
283 lines
11 KiB
C++
283 lines
11 KiB
C++
/* Copyright (c) 2002-2004 CrystalClear Software, Inc.
|
|
* Use, modification and distribution is subject to the
|
|
* Boost Software License, Version 1.0. (See accompanying
|
|
* file LICENSE_1_0.txt or http://www.boost.org/LICENSE_1_0.txt)
|
|
* Author: Jeff Garland, Bart Garst
|
|
* $Date$
|
|
*/
|
|
|
|
#include "boost/date_time/posix_time/posix_time_duration.hpp"
|
|
#include "boost/date_time/compiler_config.hpp"
|
|
#if defined(BOOST_DATE_TIME_INCLUDE_LIMITED_HEADERS)
|
|
#include "boost/date_time/posix_time/time_formatters_limited.hpp"
|
|
#else
|
|
#include "boost/date_time/posix_time/time_formatters.hpp"
|
|
#endif
|
|
#include "../testfrmwk.hpp"
|
|
|
|
|
|
int
|
|
main()
|
|
{
|
|
using namespace boost::posix_time;
|
|
|
|
|
|
// std::cout << "Default limits: SECOND " << std::endl;
|
|
{
|
|
time_duration td;
|
|
check("default construction -- 0 ticks", td.ticks() == 0);
|
|
// check("default construction -- 0 secs", td.seconds() == 0);
|
|
// check("default construction -- 0 min", td.minutes() == 0);
|
|
}
|
|
|
|
// construct from components
|
|
time_duration td1(1,25,0);
|
|
time_duration td3(td1.hours(),td1.minutes(),td1.seconds());
|
|
check("total up elements", td1 == td3);
|
|
td1 = -td1; // td1 == "-1:25:00"
|
|
check("invert_sign",td3 == td1.invert_sign());
|
|
check("invert_sign",td1 == td3.invert_sign());
|
|
check("abs",td3 == td1.abs());
|
|
check("abs",td3 == td3.abs());
|
|
check("is_positive",td3.is_positive());
|
|
check("is_positive",!td1.is_positive());
|
|
check("is_negative",td1.is_negative());
|
|
check("is_negative",!td3.is_negative());
|
|
check("is_zero",!td1.is_zero());
|
|
check("is_zero",(td1 - td1).is_zero());
|
|
td3 = time_duration(td1.hours(),td1.minutes(),td1.seconds());
|
|
check("total up elements-inverted sign", td1 == td3);
|
|
|
|
|
|
time_duration t_1(0,1,40);
|
|
time_duration t_2(0,1,41);
|
|
check("less test", !(t_2 < t_2));
|
|
check("equal test", t_1 == t_1);
|
|
check("greater equal - equal", t_1 >= t_1);
|
|
check("greater equal - greater", t_2 >= t_1);
|
|
check("less equal - equal ", t_2 <= t_2);
|
|
check("greater ", t_2 > t_1);
|
|
check("greater - not ", !(t_1 > t_2));
|
|
time_duration t_3(t_2);
|
|
check("copy constructor ", t_2 == t_3);
|
|
time_duration t_4 = t_3;
|
|
check("assignment operator ", t_2 == t_4);
|
|
|
|
time_duration t_5(1,30,20,10); // 1hr, 30min, 20sec, 10 frac sec
|
|
t_5 /= 2;
|
|
check("divide equal", (t_5.hours() == 0 &&
|
|
t_5.minutes() == 45 &&
|
|
t_5.seconds() == 10 &&
|
|
t_5.fractional_seconds() == 5));
|
|
t_5 = time_duration(3,15,8,0) / 2;
|
|
check("divide int", t_5 == time_duration(1,37,34,0));
|
|
{
|
|
time_duration td = hours(5);
|
|
td *= 5;
|
|
check("mult-equals int", time_duration(25,0,0,0) == td);
|
|
}
|
|
|
|
|
|
t_5 = t_2 + t_1;
|
|
//VC6 goes ambiguous on the next line...
|
|
#if (defined(BOOST_MSVC) && (_MSC_VER < 1300))
|
|
//sorry ticks() doesn't work on VC6
|
|
#else
|
|
std::cout << t_5.ticks() << std::endl;
|
|
#endif
|
|
check("add", t_5 == time_duration(0,3,21));
|
|
time_duration td_a(5,5,5,5);
|
|
time_duration td_b(4,4,4,4);
|
|
time_duration td_c(2,2,2,2);
|
|
td_a += td_b;
|
|
check("add equal", td_a == time_duration(9,9,9,9));
|
|
time_duration td_d = td_b - td_c;
|
|
check("subtract", td_d == time_duration(2,2,2,2));
|
|
td_d -= td_b;
|
|
check("subtract equal (neg result)", td_d == td_c - td_b);
|
|
|
|
time_duration utd(1,2,3,4);
|
|
time_duration utd2 = -utd;
|
|
//std::cout << td_d << '\n' << utd2 << std::endl;
|
|
check("unary-", ((utd2.hours() == -1) &&
|
|
(utd2.minutes() == -2) &&
|
|
(utd2.seconds() == -3) &&
|
|
(utd2.fractional_seconds() == -4)) );
|
|
utd2 = -hours(5);
|
|
check("unary-", utd2.hours() == -5);
|
|
utd2 = -utd2;
|
|
check("unary-", utd2.hours() == 5);
|
|
|
|
time_duration t_6(5,4,3); //05:04:03
|
|
check("h-m-s 5-4-3 hours", t_6.hours() == 5);
|
|
check("h-m-s 5-4-3 minutes", t_6.minutes() == 4);
|
|
check("h-m-s 5-4-3 seconds", t_6.seconds() == 3);
|
|
std::cout << t_6.total_seconds() << std::endl;
|
|
check("h-m-s 5-4-3 total_seconds", t_6.total_seconds() == 18243);
|
|
|
|
hours tenhours(10);
|
|
minutes fivemin(5);
|
|
time_duration t7 = time_duration(1,2,3) + tenhours + fivemin;
|
|
check("short hand durations add", t7 == time_duration(11,7,3));
|
|
time_duration t8 = tenhours + time_duration(1,2,3) + fivemin;
|
|
check("short hand durations add", t8 == time_duration(11,7,3));
|
|
|
|
if (time_duration::resolution() >= boost::date_time::micro) {
|
|
time_duration t_9(5,4,3,9876); //05:04:03.09876
|
|
check("h-m-s 5-4-3.21 hours", t_9.hours() == 5);
|
|
check("h-m-s 5-4-3.21 min ", t_9.minutes() == 4);
|
|
check("h-m-s 5-4-3.21 sec ", t_9.seconds() == 3);
|
|
check("h-m-s 5-4-3.21 fs ", t_9.fractional_seconds() == 9876);
|
|
check("h-m-s 5-4-3.21 total_seconds", t_9.total_seconds() == 18243);
|
|
// check("h-m-s 5-4-3.21 fs ", t_9.fs_as_double() == 0.9876);
|
|
//std::cout << t_9.fs_as_double() << std::endl;
|
|
std::cout << to_simple_string(t_9) << std::endl;
|
|
}
|
|
|
|
if (time_duration::resolution() >= boost::date_time::tenth) {
|
|
time_duration t_10(5,4,3,9); //05:04:03.00001
|
|
check("h-m-s 5-4-3.9 hours", t_10.hours() == 5);
|
|
check("h-m-s 5-4-3.9 min ", t_10.minutes() == 4);
|
|
check("h-m-s 5-4-3.9 sec ", t_10.seconds() == 3);
|
|
check("h-m-s 5-4-3.9 fs ", t_10.fractional_seconds() == 9);
|
|
check("h-m-s 5-4-3.9 total_seconds", t_10.total_seconds() == 18243);
|
|
std::cout << to_simple_string(t_10) << std::endl;
|
|
}
|
|
|
|
if (time_duration::resolution() >= boost::date_time::milli) {
|
|
millisec ms(9);
|
|
// time_duration t_10(0,0,0,); //00:00:00.009
|
|
std::cout << "time_resolution: " << time_duration::resolution() << std::endl;
|
|
#if (defined(BOOST_MSVC) && (_MSC_VER < 1300))
|
|
//sorry res_adjust() doesn't work on VC6
|
|
#else
|
|
std::cout << "res_adjust " << time_res_traits::res_adjust() << std::endl;
|
|
#endif
|
|
if (time_duration::resolution() == boost::date_time::nano) {
|
|
check("millisec", ms.fractional_seconds() == 9000000);
|
|
check("total_seconds - nofrac", ms.total_seconds() == 0);
|
|
check("total_millisec", ms.total_milliseconds() == 9);
|
|
check("ticks per second", time_duration::ticks_per_second() == 1000000000);
|
|
}
|
|
else {
|
|
check("millisec 9000", ms.fractional_seconds() == 9000);
|
|
check("total_seconds - nofrac", ms.total_seconds() == 0);
|
|
check("total_millisec", ms.total_milliseconds() == 9);
|
|
}
|
|
}
|
|
|
|
#ifdef BOOST_DATE_TIME_HAS_NANOSECONDS
|
|
if (time_duration::resolution() >= boost::date_time::nano) {
|
|
nanosec ns(9);
|
|
// time_duration t_10(0,0,0,); //00:00:00.00009
|
|
check("nanosec", ns.fractional_seconds() == 9);
|
|
check("total nanosec", ns.total_nanoseconds() == 9);
|
|
check("total microsec - truncated", ns.total_microseconds() == 0);
|
|
std::cout << to_simple_string(ns) << std::endl;
|
|
time_duration ns18 = ns + ns;
|
|
check("nanosec", ns18.fractional_seconds() == 18);
|
|
std::cout << to_simple_string(ns18) << std::endl;
|
|
nanosec ns2(1000000000); //one second
|
|
check("nano to second compare", ns2 == seconds(1));
|
|
check("check total seconds", ns2.total_seconds() == 1);
|
|
std::cout << to_simple_string(ns2) << std::endl;
|
|
check("division of nanoseconds", (nanosec(3)/2) == nanosec(1));
|
|
check("multiplication of nanosec", nanosec(3)*1000 == microsec(3));
|
|
}
|
|
#endif
|
|
|
|
// Test for overflows (ticket #3471)
|
|
{
|
|
ptime start(boost::gregorian::date(2000, 1, 1));
|
|
ptime end(boost::gregorian::date(2000, 5, 1));
|
|
time_duration td = end - start;
|
|
ptime end2 = start + microseconds(td.total_microseconds());
|
|
check("microseconds constructor overflow", end == end2);
|
|
}
|
|
|
|
time_duration t_11(3600,0,0);
|
|
check("3600 hours ", t_11.hours() == 3600);
|
|
check("total seconds 3600 hours", t_11.total_seconds() == 12960000);
|
|
|
|
time_duration td_12(1,2,3,10);
|
|
std::cout << td_12.total_seconds() << std::endl;
|
|
check("total seconds 3723 hours", td_12.total_seconds() == 3723);
|
|
|
|
// time_duration t_11a = t_11/time_duration(0,3,0);
|
|
|
|
check("division", (hours(2)/2) == hours(1));
|
|
check("division", (hours(3)/2) == time_duration(1,30,0));
|
|
check("division", (hours(3)/3) == hours(1));
|
|
check("multiplication", time_duration(3,0,0)*2 == hours(6));
|
|
check("multiplication", hours(360)*1000 == hours(360000));
|
|
|
|
// special_values operations
|
|
time_duration pi_dur(pos_infin), ni_dur(neg_infin), ndt_dur(not_a_date_time);
|
|
check("+infin + -infin", pi_dur + ni_dur == ndt_dur);
|
|
check("infin / int", pi_dur / 3 == pi_dur);
|
|
check("infin + duration", pi_dur + td_12 == pi_dur);
|
|
check("infin - duration", pi_dur - td_12 == pi_dur);
|
|
check("unary-", -pi_dur == ni_dur);
|
|
check("-infin less than +infin", ni_dur < pi_dur);
|
|
check("-infin less than duration", ni_dur < td_12);
|
|
check("+infin greater than duration", pi_dur > td_12);
|
|
std::string result(""), answer("+infinity");
|
|
result = to_simple_string(pi_dur);
|
|
check("to string +infin", result==answer);
|
|
result = to_simple_string(ni_dur);
|
|
answer = "-infinity";
|
|
check("to string +infin", result==answer);
|
|
result = to_simple_string(ndt_dur);
|
|
//answer = "not-a-number";
|
|
answer = "not-a-date-time";
|
|
check("to string +infin", result==answer);
|
|
|
|
using namespace boost::gregorian;
|
|
ptime t1(date(2001,7,14));
|
|
ptime t2(date(2002,7,14));
|
|
check("One year of hours: 365*24=8760", 365*24 == ((t2-t1).hours()));
|
|
check("Total seconds in a year", 365*24*3600 == ((t2-t1).total_seconds()));
|
|
|
|
std::cout << to_simple_string(time_duration(20000 * 24, 0, 0, 0)) << std::endl;
|
|
std::cout << to_simple_string(time_duration(24855 * 24, 0, 0, 0)) << std::endl;
|
|
std::cout << to_simple_string(time_duration(24856 * 24, 0, 0, 0)) << std::endl;
|
|
std::cout << to_simple_string(time_duration(25000 * 24, 0, 0, 0)) << std::endl;
|
|
time_duration tdl1(25000*24, 0, 0, 0);
|
|
check("600000 hours", tdl1.hours() == 600000);
|
|
time_duration tdl2(2000000, 0, 0, 0);
|
|
check("2000000 hours", tdl2.hours() == 2000000);
|
|
|
|
check("total milliseconds", seconds(1).total_milliseconds() == 1000);
|
|
check("total microseconds", seconds(1).total_microseconds() == 1000000);
|
|
check("total nanoseconds", seconds(1).total_nanoseconds() == 1000000000);
|
|
check("total milliseconds", hours(1).total_milliseconds() == 3600*1000);
|
|
boost::int64_t tms = static_cast<boost::int64_t>(3600)*1000000*1001; //ms per sec
|
|
check("total microseconds 1000 hours", hours(1001).total_microseconds() == tms);
|
|
tms = static_cast<boost::int64_t>(3600)*365*24*1000;
|
|
check("total milliseconds - one year", (t2-t1).total_milliseconds() == tms);
|
|
tms = 3600*365*24*static_cast<boost::int64_t>(1000000000);
|
|
check("total nanoseconds - one year", (t2-t1).total_nanoseconds() == tms);
|
|
#if (defined(BOOST_MSVC) && (_MSC_VER < 1300))
|
|
#else
|
|
std::cout << "tms: " << (t2-t1).total_milliseconds() << std::endl;
|
|
std::cout << "nano per year: " << (t2-t1).total_nanoseconds() << std::endl;
|
|
#endif
|
|
// make it into a double
|
|
double d1 = microseconds(25).ticks()/(double)time_duration::ticks_per_second();
|
|
std::cout << d1 << std::endl;
|
|
|
|
//Following causes errors on several compilers about value to large for
|
|
//type. So it is commented out for now. Strangely works on gcc 3.3
|
|
//eg: integer constant out of range
|
|
// long sec_in_200k_hours(7200000000);
|
|
// check("total sec in 2000000 hours",
|
|
// tdl2.total_seconds() == sec_in_200k_hours);
|
|
// std::cout << to_simple_string(time_duration(2000000, 0, 0, 0)) << std::endl;
|
|
|
|
|
|
return printTestStats();
|
|
|
|
}
|
|
|
|
|