boost/date_time
2
0
Fork 0
mirror of https://github.com/boostorg/date_time.git synced 2026-01-19 04:12:07 +00:00
Code Issues Projects Releases Wiki Activity

trac-3606: fix remaining msvc /W4 complaints (msvc-10.0 and up)

Browse Source
This commit is contained in:
James E. King III
2017-12-27 10:05:59 -05:00
parent f280794280
commit f35bbbe906
27 changed files with 318 additions and 316 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2
.gitignore vendored
View File

@@ -1,2 +1,2 @@
**/time_duration_serialization.*
**/test_facet_file.out
**/time_duration_serialization.*

2
doc/build.jam
View File

@@ -4,8 +4,6 @@
# (See accompanying file LICENSE_1_0.txt or copy at
# http://www.boost.org/LICENSE_1_0.txt)
project libs/date_time/doc ;
###############################################################################
alias boostdoc
: ../xmldoc/date_time.xml

3
example/gregorian/find_last_day_of_months.cpp
View File

@@ -15,7 +15,8 @@ main()
// get a month and a year from the user
try {
int y, m;
greg_year::value_type y;
greg_month::value_type m;
std::cout << " Enter Year(ex: 2002): ";
std::cin >> y;
year = greg_year(y);

8
example/gregorian/print_holidays.cpp
View File

@@ -33,12 +33,12 @@ print_date(boost::gregorian::date d)
int
main() {
std::cout << "Enter Year: ";
int year;
std::cin >> year;
using namespace boost::gregorian;
std::cout << "Enter Year: ";
greg_year::value_type year;
std::cin >> year;
//define a collection of holidays fixed by month and day
std::vector<year_based_generator*> holidays;
holidays.push_back(new partial_date(1,Jan)); //Western New Year

8
example/gregorian/print_month.cpp
View File

@@ -19,16 +19,18 @@
int
main()
{
using namespace boost::gregorian;
std::cout << "Enter Year: ";
int year, month;
greg_year::value_type year;
greg_month::value_type month;
std::cin >> year;
std::cout << "Enter Month(1..12): ";
std::cin >> month;
using namespace boost::gregorian;
try {
//Use the calendar to get the last day of the month
int eom_day = gregorian_calendar::end_of_month_day(year,month);
greg_day::value_type eom_day = gregorian_calendar::end_of_month_day(year,month);
date endOfMonth(year,month,eom_day);
//construct an iterator starting with firt day of the month

6
test/gregorian/testdate.cpp
View File

@@ -21,9 +21,9 @@ main()
date def;
check("Default constructor", def == date(not_a_date_time));
#endif
date d(2000,1,1);
date d1(1900,1,1);
date d2 = d;
date d2 = date(2000,1,1);
date d3(d2);
check("Copy constructor", d3 == d2);
date d4(2000,12,31);
@@ -276,7 +276,7 @@ main()
}
//converts to date and back -- should get same result
check_equal("tm conversion functions 2000-1-1", date_from_tm(to_tm(d)), d);
check_equal("tm conversion functions 2000-1-1", date_from_tm(to_tm(d2)), d2);
check_equal("tm conversion functions 1900-1-1", date_from_tm(to_tm(d1)), d1);
check_equal("tm conversion functions min date 1400-1-1 ", date_from_tm(to_tm(d14)), d14);
check_equal("tm conversion functions max date 9999-12-31", date_from_tm(to_tm(d13)), d13);

8
test/gregorian/testdate_facet_new.cpp
View File

@@ -358,12 +358,12 @@ int main() {
// greg_month tests
{
for(int i = 0; i < 12; ++i) {
for(greg_month::value_type i = 0; i < 12; ++i) {
greg_month m(i+1); // month numbers 1-12
teststreaming("greg_month short", m, short_months[i], loc);
}
small_types_facet->month_format(L"%B"); // full name
for(int i = 0; i < 12; ++i) {
for(greg_month::value_type i = 0; i < 12; ++i) {
greg_month m(i+1); // month numbers 1-12
teststreaming("greg_month full", m, full_months[i], loc);
}
@@ -371,12 +371,12 @@ int main() {
// greg_weekday tests
{
for(int i = 0; i < 7; ++i) {
for(greg_weekday::value_type i = 0; i < 7; ++i) {
greg_weekday gw(i); // weekday numbers 0-6
teststreaming("greg_weekday short", gw, short_weekdays[i], loc);
}
small_types_facet->weekday_format(L"%A"); // full name
for(int i = 0; i < 7; ++i) {
for(greg_weekday::value_type i = 0; i < 7; ++i) {
greg_weekday gw(i); // weekday numbers 0-6
teststreaming("greg_weekday full", gw, full_weekdays[i], loc);
}

94
test/gregorian/testdate_input_facet.cpp
View File

@@ -170,39 +170,39 @@ int main(){
failure_test(d,"2005071", e_bad_day_of_month, f2));
{ // literal % in format tests
date d(not_a_date_time);
greg_month m(1);
greg_weekday gw(0);
date dx(not_a_date_time);
greg_month mx(1);
greg_weekday gwx(0);
greg_year y(1400);
date_input_facet* f = new date_input_facet("%%d %Y-%b-%d");
std::stringstream ss;
ss.imbue(std::locale(ss.getloc(), f));
ss.str("%d 2005-Jun-14");
ss >> d;
check_equal("Literal '%' in date format", d, date(2005,Jun,14));
ss >> dx;
check_equal("Literal '%' in date format", dx, date(2005,Jun,14));
f->format("%%%d %Y-%b-%d");
ss.str("%14 2005-Jun-14");
ss >> d;
check_equal("Multiple literal '%'s in date format", d, date(2005,Jun,14));
ss >> dx;
check_equal("Multiple literal '%'s in date format", dx, date(2005,Jun,14));
f->month_format("%%b %b");
ss.str("%b Jun");
ss >> m;
check_equal("Literal '%' in month format", m, greg_month(6));
ss >> mx;
check_equal("Literal '%' in month format", mx, greg_month(6));
f->month_format("%%%b");
ss.str("%Jun");
ss >> m;
check_equal("Multiple literal '%'s in month format", m, greg_month(6));
ss >> mx;
check_equal("Multiple literal '%'s in month format", mx, greg_month(6));
f->weekday_format("%%a %a");
ss.str("%a Tue");
ss >> gw;
check_equal("Literal '%' in weekday format", gw, greg_weekday(2));
ss >> gwx;
check_equal("Literal '%' in weekday format", gwx, greg_weekday(2));
f->weekday_format("%%%a");
ss.str("%Tue");
ss >> gw;
check_equal("Multiple literal '%'s in weekday format", gw, greg_weekday(2));
ss >> gwx;
check_equal("Multiple literal '%'s in weekday format", gwx, greg_weekday(2));
f->year_format("%%Y %Y");
ss.str("%Y 2005");
@@ -258,16 +258,16 @@ int main(){
check_equal("Default period (closed range)", dp, date_period(begin,len));
{
std::stringstream ss;
date d(not_a_date_time);
date dx(not_a_date_time);
date d2 = day_clock::local_day();
date d3(neg_infin);
date d4(pos_infin);
date_period dp(d2, d); // date/nadt
date_period dp2(d, d); // nadt/nadt
date_period dpx(d2, dx); // date/nadt
date_period dp2(dx, dx); // nadt/nadt
date_period dp3(d3, d4);
ss << dp;
ss << dpx;
ss >> dp2;
check_equal("Special values period (reversibility test)", dp, dp2);
check_equal("Special values period (reversibility test)", dpx, dp2);
ss.str("[-infinity/+infinity]");
ss >> dp2;
check_equal("Special values period (infinities)", dp3, dp2);
@@ -489,29 +489,29 @@ int main(){
sv_parser,
p_parser,
dg_parser);
std::istringstream iss;
iss.imbue(std::locale(std::locale::classic(), de_facet));
std::istringstream iss2;
iss2.imbue(std::locale(std::locale::classic(), de_facet));
// June 06 2005, Dec, minimum date, Tues
iss.str("Juni 06 2005 Dez Wenigstes Datum Die");
iss >> d;
iss >> m;
iss2.str("Juni 06 2005 Dez Wenigstes Datum Die");
iss2 >> d;
iss2 >> m;
check_equal("German names: date", d, date(2005, Jun, 6));
check_equal("German names: month", m, greg_month(Dec));
iss >> d;
iss >> gw;
iss2 >> d;
iss2 >> gw;
check_equal("German names: special value date", d, date(min_date_time));
check_equal("German names: short weekday", gw, greg_weekday(Tuesday));
de_facet->weekday_format("%A"); // long weekday
// Tuesday, Second Tuesday of Mar
iss.str("Dienstag Zweitens Dienstag von Mar");
iss >> gw;
iss >> nkd;
iss2.str("Dienstag Zweitens Dienstag von Mar");
iss2 >> gw;
iss2 >> nkd;
check_equal("German names: long weekday", gw, greg_weekday(Tuesday));
check_equal("German names, nth_day_of_the_week_in_month",
nkd.get_date(2005), date(2005,Mar,8));
// Tuesday after
iss.str("Dienstag Nach");
iss >> fka;
iss2.str("Dienstag Nach");
iss2 >> fka;
check_equal("German names, first_day_of_the_week_after",
fka.get_date(date(2005,Apr,5)), date(2005,Apr,12));
}
@@ -552,25 +552,25 @@ int main(){
&month_long_names[12],
std::back_inserter(long_month_names));
date d(not_a_date_time);
date_input_facet* facet = new date_input_facet();
date dx(not_a_date_time);
date_input_facet* facetx = new date_input_facet();
std::stringstream ss;
ss.imbue(std::locale(std::locale::classic(), facet));
facet->short_month_names(short_month_names);
facet->short_weekday_names(short_weekday_names);
facet->long_month_names(long_month_names);
facet->long_weekday_names(long_weekday_names);
facet->format("%a %b %d, %Y");
ss.imbue(std::locale(std::locale::classic(), facetx));
facetx->short_month_names(short_month_names);
facetx->short_weekday_names(short_weekday_names);
facetx->long_month_names(long_month_names);
facetx->long_weekday_names(long_weekday_names);
facetx->format("%a %b %d, %Y");
ss.str("day7 *apr* 23, 2005");
ss >> d;
check_equal("Short custom names, set via accessor function", d.day_of_week(), greg_weekday(6));
check_equal("Short custom names, set via accessor function", d.month(), greg_month(4));
ss >> dx;
check_equal("Short custom names, set via accessor function", dx.day_of_week(), greg_weekday(6));
check_equal("Short custom names, set via accessor function", dx.month(), greg_month(4));
ss.str("");
ss.str("Sun-0 **April** 24, 2005");
facet->format("%A %B %d, %Y");
ss >> d;
check_equal("Long custom names, set via accessor function", d.day_of_week(), greg_weekday(0));
check_equal("Long custom names, set via accessor function", d.month(), greg_month(4));
facetx->format("%A %B %d, %Y");
ss >> dx;
check_equal("Long custom names, set via accessor function", dx.day_of_week(), greg_weekday(0));
check_equal("Long custom names, set via accessor function", dx.month(), greg_month(4));
}
#else

14
test/gregorian/testfacet.cpp
View File

@@ -81,12 +81,12 @@ main()
ss.str() == std::string("Okt"));
ss.str(""); //reset string stream
greg_month m(Oct);
month_formatter::format_month(m, ss, gdnp);
greg_month mo(Oct);
month_formatter::format_month(mo, ss, gdnp);
check("check german short month: " + ss.str(),
ss.str() == std::string("Okt"));
ss.str(""); //reset string stream
// month_formatter::format_month(m, ss, gdnp);
// month_formatter::format_month(mo, ss, gdnp);
// check("check german long month: " + ss.str(),
// ss.str() == std::string("Oktober"));
@@ -277,7 +277,7 @@ main()
/*******************************************************************/
{
std::stringstream ss1("January");
std::stringstream ss2("dec"); // misspelled
std::stringstream ss2m("dec"); // misspelled
std::stringstream german("Okt");
german.imbue(global2);
greg_month m(3);
@@ -293,7 +293,7 @@ main()
german >> m;
check("Stream in German month", m == greg_month(Oct));
try{
ss2 >> m; // misspelled
ss2m >> m; // misspelled
check("Bad month exception NOT thrown (misspelled name)", false);
}catch(bad_month&){
check("Bad month exception caught (misspelled name)", true);
@@ -306,7 +306,7 @@ main()
/*******************************************************************/
{
std::stringstream ss1("Sun");
std::stringstream ss2("Wensday"); // misspelled
std::stringstream ss2w("Wensday"); // misspelled
std::stringstream german("Mittwoch"); // Wednesday
german.imbue(global2);
greg_weekday wd(Friday); //something not Sunday...
@@ -322,7 +322,7 @@ main()
german >> wd;
check("Stream in German weekday", wd == greg_weekday(Wednesday));
try{
ss2 >> wd;
ss2w >> wd;
check("Bad weekday exception NOT thrown (misspelled name)", false);
}catch(bad_weekday&){
check("Bad weekday exception caught (misspelled name)", true);

32
test/gregorian/testgreg_durations.cpp
View File

@@ -61,14 +61,14 @@ int main(){
d4 - months(-14) == date(2007,Jan,1));
}
{
months m1(5), m2(3), m3(10);
check("months & int multipliable", months(15) == m1 * 3);
m1 *= 3;
check("months & int multipliable", months(15) == m1);
//check("int * months", months(12) == 4 * m2);
check("months & int dividable", months(3) == m3 / 3);
m3 /= 3;
check("months & int dividable", months(3) == m3);
months m1x(5), m2x(3), m3x(10);
check("months & int multipliable", months(15) == m1x * 3);
m1x *= 3;
check("months & int multipliable", months(15) == m1x);
//check("int * months", months(12) == 4 * m2x);
check("months & int dividable", months(3) == m3x / 3);
m3x /= 3;
check("months & int dividable", months(3) == m3x);
}
{
months m(-5), m_pos(pos_infin), m_neg(neg_infin), m_nadt(not_a_date_time);
@@ -116,14 +116,14 @@ int main(){
y3 -= y2;
check("years & years subtractable", years(-1) == y3);
{
years y1(5), y2(3), y3(10);
check("years & int multipliable", years(15) == y1 * 3);
y1 *= 3;
check("years & int multipliable", years(15) == y1);
//check("int * years", years(12) == 4 * y2);
check("years & int dividable", years(3) == y3 / 3);
y3 /= 3;
check("years & int dividable", years(3) == y3);
years y1x(5), y2x(3), y3x(10);
check("years & int multipliable", years(15) == y1x * 3);
y1x *= 3;
check("years & int multipliable", years(15) == y1x);
//check("int * years", years(12) == 4 * y2x);
check("years & int dividable", years(3) == y3x / 3);
y3x /= 3;
check("years & int dividable", years(3) == y3x);
}
{
years m(15), y_pos(pos_infin), y_neg(neg_infin), y_nadt(not_a_date_time);

20
test/gregorian/testgreg_wstream.cpp
View File

@@ -45,9 +45,9 @@ int main(){
#ifndef BOOST_NO_STD_ITERATOR_TRAITS
{
res = L"2003-Aug-21";
std::wstringstream wss(L"2003-Aug-21");
std::wstringstream wss2(L"2003-Aug-21");
date testdate(not_a_date_time);
wss >> testdate;
wss2 >> testdate;
check("date operator>>", to_simple_wstring(testdate) == res);
}
#else
@@ -66,9 +66,9 @@ int main(){
res = L"August";
check("greg_month as_long_wstring", ws == res);
/*{
std::wstringstream wss(L"August");
std::wstringstream wss2(L"August");
greg_month testmonth(not_a_date_time);
wss >> testmonth;
wss2 >> testmonth;
check("greg_month operator>>", to_simple_wstring(testmonth) == res);
}*/
@@ -83,9 +83,9 @@ int main(){
res = L"Thursday";
check("greg_day_of_week as_long_wstring", ws == res);
/*{
std::wstringstream wss(L"Thu");
std::wstringstream wss2(L"Thu");
greg_day_of_week testday(not_a_date_time);
wss >> testday;
wss2 >> testday;
check("greg_day_of_week operator>>", to_simple_wstring(testday) == res);
}*/
@@ -100,12 +100,12 @@ int main(){
ws = to_iso_wstring(dp);
check("date_period to_iso_string", ws == res);
{
std::wstringstream wss(L"[2003-Aug-21/2004-May-27]");
std::wstringstream wss2(L"[2003-Aug-21/2004-May-27]");
res = L"[2003-Aug-21/2004-May-26]";
// following line gives an ambiguous overload of op>>
//date_period testperiod(date(not_a_date_time),date_duration(not_a_date_time));
date_period testperiod(date(2003,Aug,21), date(2004,May,27));
wss >> testperiod;
wss2 >> testperiod;
check("date_period operator>>", to_simple_wstring(testperiod) == res);
}
@@ -115,9 +115,9 @@ int main(){
check("date_duration", wss.str() == res);
wss.str(L"");
{
std::wstringstream wss(L"280");
std::wstringstream wss2(L"280");
date_duration testduration(not_a_date_time);
wss >> testduration;
wss2 >> testduration;
check("date_duration operator>>", testduration.days() == 280);
}

20
test/gregorian/testparse_date.cpp
View File

@@ -82,12 +82,12 @@ main()
date d8 = from_uk_string("29-Feb-2000");
check("date from day-month-year string", d8 == d);
{
std::string s("20050229"); // no Feb-29 in 2005
date d(not_a_date_time);
std::string sn("20050229"); // no Feb-29 in 2005
date dn(not_a_date_time);
try {
d = date_from_iso_string(s);
dn = date_from_iso_string(sn);
check("Expected exception not thrown: from ISO string (bad_day_of_month)", false);
std::cout << date_from_iso_string(s) << std::endl;
std::cout << date_from_iso_string(sn) << std::endl;
}
catch(bad_day_of_month&) {
check("Caught expected exception: bad_day_of_month ", true);
@@ -96,11 +96,11 @@ main()
check("Caught unexpected exception", false);
}
/* not currently passing due to a bug in boost::offset_separator (reported 2005-Aug-02)
s = "2005022"; // missing a digit
sn = "2005022"; // missing a digit
try {
d = date_from_iso_string(s);
d = date_from_iso_string(sn);
check("Expected exception not thrown: from ISO string (missing digit)", false);
std::cout << date_from_iso_string(s) << std::endl;
std::cout << date_from_iso_string(sn) << std::endl;
}
catch(bad_day_of_month& e) {
check("Caught expected exception: bad_day_of_month ", true);
@@ -109,9 +109,9 @@ main()
check("Caught unexpected exception", false);
}
*/
s = "20050228"; // now it's correct
d = date_from_iso_string(s);
check("from ISO string", date(2005,Feb,28) == d);
sn = "20050228"; // now it's correct
dn = date_from_iso_string(sn);
check("from ISO string", date(2005,Feb,28) == dn);
}
date d9 = from_us_string(__DATE__);

50
test/local_time/testlocal_time.cpp
View File

@@ -122,16 +122,16 @@ main()
std::cout << "\nChecking calc_options construction" << std::endl;
{ // invalid NADT
date d(2004, Apr, 4);
date dx(2004, Apr, 4);
time_duration td(2,30,0); // invalid local time in ny_tz
local_date_time calcop(d, td, ny_tz, local_date_time::NOT_DATE_TIME_ON_ERROR);
local_date_time calcop(dx, td, ny_tz, local_date_time::NOT_DATE_TIME_ON_ERROR);
check("is NADT", calcop.is_not_a_date_time());
}
{ // invalid exception
date d(2004, Apr, 4);
date dx(2004, Apr, 4);
time_duration td(2,30,0); // invalid local time in ny_tz
try{
local_date_time calcop(d, td, ny_tz, local_date_time::EXCEPTION_ON_ERROR);
local_date_time calcop(dx, td, ny_tz, local_date_time::EXCEPTION_ON_ERROR);
check("Did not catch expected exception", false);
}catch(time_label_invalid& /*i*/){
check("Caught expected exception", true);
@@ -140,16 +140,16 @@ main()
}
}
{ // ambig NADT
date d(2004, Oct, 31);
date dx(2004, Oct, 31);
time_duration td(1,30,0); // ambig local time in ny_tz
local_date_time calcop(d, td, ny_tz, local_date_time::NOT_DATE_TIME_ON_ERROR);
local_date_time calcop(dx, td, ny_tz, local_date_time::NOT_DATE_TIME_ON_ERROR);
check("is NADT", calcop.is_not_a_date_time());
}
{ // ambig exception
date d(2004, Oct, 31);
date dx(2004, Oct, 31);
time_duration td(1,30,0); // ambig local time in ny_tz
try{
local_date_time calcop(d, td, ny_tz, local_date_time::EXCEPTION_ON_ERROR);
local_date_time calcop(dx, td, ny_tz, local_date_time::EXCEPTION_ON_ERROR);
check("Did not catch expected exception", false);
}catch(ambiguous_result& /*a*/){
check("Caught expected exception", true);
@@ -199,10 +199,10 @@ main()
// thorough is_dst() tests, tests againts null_tz and non dst tz are
// done where those local times were tested
{
date d(2004,Apr,4);
date dx(2004,Apr,4);
time_duration td(1,15,0); // local
local_date_time lt1(d,td,ny_tz,false);
local_date_time lt2(ptime(d,time_duration(6,15,0)), ny_tz);
local_date_time lt1(dx,td,ny_tz,false);
local_date_time lt2(ptime(dx,time_duration(6,15,0)), ny_tz);
check("are local_times equal", lt1.utc_time() == lt2.utc_time());
check("is_dst - transition in 1", lt1.is_dst() == false);
check("is_dst - transition in 2", lt2.is_dst() == false);
@@ -212,17 +212,17 @@ main()
check("is_dst - transition in 2", lt2.is_dst() == true);
}
{
date d(2004,Oct,31);
date dx(2004,Oct,31);
time_duration td(1,15,0); // local
local_date_time lt1(d,td,ny_tz,true);
local_date_time lt1(dx,td,ny_tz,true);
/*try{
//local_date_time lt1(d,td,ny_tz,false);
local_date_time lt1(d,td,ny_tz,true);
//local_date_time lt1(dx,td,ny_tz,false);
local_date_time lt1(dx,td,ny_tz,true);
std::cout << "no exception thrown" << std::endl;
}catch(time_label_invalid& e){
std::cout << "caught: " << e.what() << std::endl;
}*/
local_date_time lt2(ptime(d,time_duration(5,15,0)), ny_tz);
local_date_time lt2(ptime(dx,time_duration(5,15,0)), ny_tz);
check("are local_times equal", lt1.utc_time() == lt2.utc_time());
check("is_dst - transition out 1", lt1.is_dst() == true);
check("is_dst - transition out 2", lt2.is_dst() == true);
@@ -232,17 +232,17 @@ main()
check("is_dst - transition out 2", lt2.is_dst() == false);
}
{ // southern hemisphere
date d(2004,Oct,31);
date dx(2004,Oct,31);
time_duration td(1,15,0); // local
local_date_time lt1(d,td,sydney,false);
local_date_time lt1(dx,td,sydney,false);
check("is_dst - transition in (sydney)", lt1.is_dst() == false);
lt1 += hours(1);
check("is_dst - transition in (sydney)", lt1.is_dst() == true);
}
{
date d(2004,Mar,28);
date dx(2004,Mar,28);
time_duration td(2,15,0); // local; sydney has a weird trans time
local_date_time lt1(d,td,sydney,true);
local_date_time lt1(dx,td,sydney,true);
check("is_dst - transition out (sydney)", lt1.is_dst() == true);
lt1 += hours(1);
check("is_dst - transition out (sydney)", lt1.is_dst() == false);
@@ -266,16 +266,16 @@ main()
{ // test comparisons & math operations
date d(2003, Aug, 28);
date dx(2003, Aug, 28);
ptime sv_pt(pos_infin);
local_date_time sv_lt(sv_pt, ny_tz);
ptime utc_pt(d, hours(12));
ptime utc_pt(dx, hours(12));
// all 4 of the following local times happen at the same instant
// so they are all equal
local_date_time utc_lt(utc_pt, null_tz); // noon in utc
local_date_time az_lt(d, hours(5), az_tz, false); // 5am local std
local_date_time ny_lt(d, hours(8), ny_tz, true); // 8am local dst
local_date_time au_lt(d, hours(22), sydney, false);// 10pm local std
local_date_time az_lt(dx, hours(5), az_tz, false); // 5am local std
local_date_time ny_lt(dx, hours(8), ny_tz, true); // 8am local dst
local_date_time au_lt(dx, hours(22), sydney, false);// 10pm local std
check("local_date_time to tm",
std::string("4 239 08/28/2003 05:00:00 STD") == tm_out(to_tm(az_lt)));

2
test/local_time/testlocal_time_facet.cpp
View File

@@ -34,7 +34,7 @@ teststreaming(std::string const& testname,
#endif
}
int main(int argc, char const* argv[]){
int main(int /* argc */, char const* argv[]){
/* use the tz_database for the time zones.
* Chicago, Denver, Los_Angeles, New_Tork, and Phoenix
* have all had full names added */

4
test/local_time/testlocal_time_input_facet.cpp
View File

@@ -184,8 +184,8 @@ int main() {
{
std::istringstream iss("2005-Aug-25 12:15:00 MST-07");
local_time_input_facet* f = new local_time_input_facet("%Y-%b-%d %H:%M:%S %z");
std::locale loc(std::locale::classic(), f);
iss.imbue(loc);
std::locale locx(std::locale::classic(), f);
iss.imbue(locx);
iss >> ldt1;
check("Wrong format flag makes UTC", ldt1.zone_as_posix_string() == std::string("UTC+00"));
check("Wrong format flag makes UTC", ldt1.utc_time() == ldt1.local_time());

2
test/local_time/testtz_database.cpp
View File

@@ -17,7 +17,7 @@
bool run_bad_field_count_test(char const* fn);
int main(int argc, char const* argv[]){
int main(int /* argc */, char const* argv[]){
using namespace boost::gregorian;
using namespace boost::posix_time;
using namespace boost::local_time;

13
test/posix_time/testlocal_adjustor.cpp
View File

@@ -121,12 +121,13 @@ main()
typedef boost::date_time::local_adjustor<ptime, -5, us_dst> us_eastern2;
ptime t7a(date(2002,May,31), hours(17));
ptime t7b = us_eastern2::local_to_utc(t7a);
ptime t7c = us_eastern2::utc_to_local(t7b);
//converted to local then back ot utc
check("check us_local_adjustor", t7c == t7a);
{
ptime t7a(date(2002,May,31), hours(17));
ptime t7b = us_eastern2::local_to_utc(t7a);
ptime t7c = us_eastern2::utc_to_local(t7b);
//converted to local then back ot utc
check("check us_local_adjustor", t7c == t7a);
}
typedef boost::date_time::us_dst_trait<date> us_dst_traits;
typedef boost::date_time::dst_calc_engine<date, time_duration, us_dst_traits>

54
test/posix_time/testparse_time.cpp
View File

@@ -104,10 +104,12 @@ main()
#ifdef BOOST_DATE_TIME_HAS_NANOSECONDS
std::string ts2("2002-12-31 00:00:00.999999999");
ptime t2 = time_from_string(ts2);
check("parse time: " + ts2,
t2 == ptime(date(2002,12,31),time_duration(0,0,0)+nanosec(999999999)));
{
std::string ts2("2002-12-31 00:00:00.999999999");
ptime t2 = time_from_string(ts2);
check("parse time: " + ts2,
t2 == ptime(date(2002,12,31),time_duration(0,0,0)+nanosec(999999999)));
}
{
std::string ts2("2002-12-31 00:00:00.");
ptime t2 = time_from_string(ts2);
@@ -128,13 +130,15 @@ main()
// std::cout << tod_1 << "|" << std::endl;
ptime t1 = time_from_string(ts1);
check("parse time: " + ts1,
t1 == ptime(date(2002,1,20),time_duration(23,59,59)));
{
std::string ts1("2002-01-20 23:59:59.");
ptime t1 = time_from_string(ts1);
check("parse time (decimal but no digits): " + ts1,
check("parse time: " + ts1,
t1 == ptime(date(2002,1,20),time_duration(23,59,59)));
}
{
std::string ts1x("2002-01-20 23:59:59.");
ptime t1 = time_from_string(ts1x);
check("parse time (decimal but no digits): " + ts1x,
t1 == ptime(date(2002,1,20),time_duration(23,59,59)));
}
@@ -148,21 +152,27 @@ main()
check("parse negative time duration: " + s6,
td6 == time_duration(-23,58,59));
std::string ts3("20020120T235859");
ptime t20 = from_iso_string(ts3);
check("parse iso time: " + ts3,
t20 == ptime(date(2002,1,20),time_duration(23,58,59)));
{
std::string ts3("20020120T235859");
ptime t20 = from_iso_string(ts3);
check("parse iso time: " + ts3,
t20 == ptime(date(2002,1,20),time_duration(23,58,59)));
}
std::string ts4("19001231T000000");
ptime t21 = from_iso_string(ts4);
check("parse iso time: " + ts4,
t21 == ptime(date(1900,12,31),time_duration(0,0,0)));
{
std::string ts4("19001231T000000");
ptime t21 = from_iso_string(ts4);
check("parse iso time: " + ts4,
t21 == ptime(date(1900,12,31),time_duration(0,0,0)));
}
{
std::string ts5("19001231T23");
ptime t22 = from_iso_string(ts5);
check("parse iso time: " + ts5,
t22 == ptime(date(1900,12,31),time_duration(23,0,0)));
}
std::string ts5("19001231T23");
ptime t22 = from_iso_string(ts5);
check("parse iso time: " + ts5,
t22 == ptime(date(1900,12,31),time_duration(23,0,0)));
{
#if defined(BOOST_DATE_TIME_POSIX_TIME_STD_CONFIG)
std::string ts3("20020120T235859.123456789");

18
test/posix_time/teststreams.cpp
View File

@@ -124,14 +124,14 @@ main()
}
{
date d1(2001,Aug,1), d2(2003,May,13);
date d1x(2001,Aug,1), d2x(2003,May,13);
#ifdef BOOST_DATE_TIME_HAS_NANOSECONDS
time_duration td1(15,32,18,20304000), td2(1,2,3);
time_duration td1x(15,32,18,20304000), td2x(1,2,3);
#else
time_duration td1(15,32,18,20304), td2(1,2,3);
time_duration td1x(15,32,18,20304), td2x(1,2,3);
#endif
time_period result(ptime(d1,td1), ptime(d2,td2));
time_period result(ptime(d1x,td1x), ptime(d2x,td2x));
std::istringstream iss("[2001-Aug-01 15:32:18.020304/2003-May-13 01:02:03]");
iss >> tp;
check("Stream in time_period", tp == result);
@@ -150,11 +150,11 @@ main()
std::wistringstream wiss3(L"[2004-Jan-01 02:03:04/2004-May-13 01:00:00]");
wiss3 >> tp;
date d1 = date(2004,Jan,1);
date d2 = date(2004,May,13);
time_duration td1 = time_duration(2,3,4);
time_duration td2 = time_duration(1,0,0);
time_period result = time_period(ptime(d1,td1), ptime(d2,td2));
date d1x = date(2004,Jan,1);
date d2x = date(2004,May,13);
time_duration td1x = time_duration(2,3,4);
time_duration td2x = time_duration(1,0,0);
time_period result = time_period(ptime(d1x,td1x), ptime(d2x,td2x));
check("Wide stream in time_period", tp == result);
}
#else

6
test/posix_time/testtime.cpp
View File

@@ -193,11 +193,11 @@ main()
std::cout << to_simple_string(td2) << std::endl;
check("add 2001-Dec-01 0:0:0 + 01:02:03", t9 == t10);
{
ptime t9(date(2001,Dec,1), time_duration(12,0,0)); //Dec 1 at Noon
ptime t9x(date(2001,Dec,1), time_duration(12,0,0)); //Dec 1 at Noon
time_duration td3(-4,0,0);
check("add 2001-Dec-01 12:00:00 + (-04:00:00)",
t9+td3 == ptime(date(2001,Dec,1), time_duration(8,0,0)) );
std::cout << to_simple_string(t9-td3) << std::endl;
t9x+td3 == ptime(date(2001,Dec,1), time_duration(8,0,0)) );
std::cout << to_simple_string(t9x-td3) << std::endl;
}
time_duration td3(24,0,0); // a day
check("add 2001-Dec-01 0:0:0 + 24:00:00", t8+td3 == ptime(date(2001,Dec,2)));

4
test/posix_time/testtime_facet.cpp
View File

@@ -220,8 +220,8 @@ int main() {
// not dereference end() iterator for the format string in do_put_tm.
{
boost::gregorian::date date(2009, 1, 1);
boost::posix_time::time_duration td(0, 0, 0, 0);
boost::posix_time::ptime boost_time(date, td);
boost::posix_time::time_duration tdx(0, 0, 0, 0);
boost::posix_time::ptime boost_time(date, tdx);
std::stringstream sstr;
boost::posix_time::time_facet* pFacet = new boost::posix_time::time_facet("");

82
test/posix_time/testtime_input_facet.cpp
View File

@@ -178,38 +178,38 @@ do_all_tests()
check_equal("Multiple literal '%'s in time_duration format", td, time_duration(15,15,0));
{ /****** iso format tests (and custom 'scrunched-together formats) ******/
time_input_facet *facet = new time_input_facet();
facet->set_iso_format();
facet->time_duration_format("%H""%M""%S""%F"); // iso format
time_input_facet *facet2 = new time_input_facet();
facet2->set_iso_format();
facet2->time_duration_format("%H""%M""%S""%F"); // iso format
std::stringstream ss;
ss.imbue(std::locale(std::locale::classic(), facet));
ptime pt(not_a_date_time);
time_duration td(not_a_date_time);
date d(2002,Oct,17);
ss.imbue(std::locale(std::locale::classic(), facet2));
ptime pt2(not_a_date_time);
time_duration tdx(not_a_date_time);
date dx(2002,Oct,17);
#if defined(BOOST_DATE_TIME_POSIX_TIME_STD_CONFIG)
time_duration td2(23,12,17,123450000);
#else
time_duration td2(23,12,17,123450);
#endif
ptime result(d, td2);
ptime result(dx, td2);
ss.str("20021017T231217.12345");
ss >> pt;
check_equal("iso_format ptime", pt, result);
ss >> pt2;
check_equal("iso_format ptime", pt2, result);
ss.str("");
facet->set_iso_extended_format();
facet2->set_iso_extended_format();
ss.str("2002-10-17 23:12:17.12345");
ss >> pt;
check_equal("iso_extended_format ptime", pt, result);
ss >> pt2;
check_equal("iso_extended_format ptime", pt2, result);
ss.str("");
ss.str("231217.12345");
ss >> td;
check_equal("iso_format time_duration", td, td2);
ss >> tdx;
check_equal("iso_format time_duration", tdx, td2);
ss.str("");
ss.str("-infinity");
ss >> td;
ss >> tdx;
check_equal("iso_format time_duration (special_value)",
td, time_duration(neg_infin));
tdx, time_duration(neg_infin));
ss.str("");
// the above tests prove correct parsing of time values in these formats.
// these tests show they also handle special_values & exceptions properly
@@ -217,35 +217,35 @@ do_all_tests()
ss.exceptions(std::ios_base::failbit); // we need exceptions turned on here
int count = 0;
try {
facet->time_duration_format("%H""%M""%S""%F");
facet2->time_duration_format("%H""%M""%S""%F");
ss.str("not-a-date-time");
++count;
ss >> td;
check_equal("special value w/ hours flag", td, nadt);
ss >> tdx;
check_equal("special value w/ hours flag", tdx, nadt);
ss.str("");
facet->time_duration_format("%M""%S""%F");
facet2->time_duration_format("%M""%S""%F");
ss.str("not-a-date-time");
++count;
ss >> td;
check_equal("special value w/ minutes flag", td, nadt);
ss >> tdx;
check_equal("special value w/ minutes flag", tdx, nadt);
ss.str("");
facet->time_duration_format("%S""%F");
facet2->time_duration_format("%S""%F");
ss.str("not-a-date-time");
++count;
ss >> td;
check_equal("special value w/ seconds flag", td, nadt);
ss >> tdx;
check_equal("special value w/ seconds flag", tdx, nadt);
ss.str("");
facet->time_duration_format("%s");
facet2->time_duration_format("%s");
ss.str("not-a-date-time");
++count;
ss >> td;
check_equal("special value w/ sec w/frac_sec (always) flag", td, nadt);
ss >> tdx;
check_equal("special value w/ sec w/frac_sec (always) flag", tdx, nadt);
ss.str("");
facet->time_duration_format("%f");
facet2->time_duration_format("%f");
ss.str("not-a-date-time");
++count;
ss >> td;
check_equal("special value w/ frac_sec (always) flag", td, nadt);
ss >> tdx;
check_equal("special value w/ frac_sec (always) flag", tdx, nadt);
ss.str("");
}
catch(...) {
@@ -332,16 +332,16 @@ do_all_tests()
(tp.end() == ptime(date(2005,12,31),time_duration(23,59,59,1))) );
{
std::stringstream ss;
ptime pt(not_a_date_time);
ptime ptx(not_a_date_time);
ptime pt2 = second_clock::local_time();
ptime pt3(neg_infin);
ptime pt4(pos_infin);
time_period tp(pt2, pt); // ptime/nadt
time_period tp2(pt, pt); // nadt/nadt
time_period tpx(pt2, ptx); // ptime/nadt
time_period tp2(ptx, ptx); // nadt/nadt
time_period tp3(pt3, pt4);
ss << tp;
ss << tpx;
ss >> tp2;
check_equal("Special values period (reversibility test)", tp, tp2);
check_equal("Special values period (reversibility test)", tpx, tp2);
ss.str("[-infinity/+infinity]");
ss >> tp2;
check_equal("Special values period (infinities)", tp3, tp2);
@@ -415,10 +415,10 @@ do_all_tests()
// trac 13194 (https://svn.boost.org/trac10/ticket/13194)
{
const std::string value = "December 07:27:10.435945 5 2017";
boost::posix_time::time_input_facet* facet = new boost::posix_time::time_input_facet("%B %H:%M:%s %e %Y");
boost::posix_time::ptime pt;
check("trac 13194 %e on \"5\" failbit set", !failure_test(pt, value, facet)); // proves failbit was not set
check_equal("trac 13194 %e on \" 5\" valid value", "2017-12-05T07:27:10.435945000", to_iso_extended_string(pt));
boost::posix_time::time_input_facet* facet4 = new boost::posix_time::time_input_facet("%B %H:%M:%s %e %Y");
boost::posix_time::ptime ptx;
check("trac 13194 %e on \"5\" failbit set", !failure_test(ptx, value, facet4)); // proves failbit was not set
check_equal("trac 13194 %e on \" 5\" valid value", "2017-12-05T07:27:10.435945000", to_iso_extended_string(ptx));
}
// trac 12910

4
test/testconstrained_value.cpp
View File

@@ -43,8 +43,8 @@ int main()
try {
constrained_value<one_to_ten_range_policy> cv2(11);
std::cout << "Not Reachable: " << cv2 << " ";
constrained_value<one_to_ten_range_policy> cv3(11);
std::cout << "Not Reachable: " << cv3 << " ";
check("got range exception max", false);
}
catch(range_error& e) {

160
test/testgeneric_period.cpp
View File

@@ -59,14 +59,6 @@ int main(){
check("End", p1.end() == 10);
check("Length", p1.length() == 9);
check("is_null (not)", !p1.is_null());
{
a_period p1(1, 10);
check("First", p1.begin() == 1);
check("Last", p1.last() == 9);
check("End", p1.end() == 10);
check("Length", p1.length() == 9);
check("is_null (not)", !p1.is_null());
}
a_period p2(5, 30);
check("First", p2.begin() == 5);
@@ -165,117 +157,117 @@ int main(){
{
std::cout << std::endl;
a_period p1(0, -2);
check("First", p1.begin() == 0);
check("Last", p1.last() == -3);
check("End", p1.end() == -2);
check("Length", p1.length() == -2);
check("is_null", p1.is_null());
a_period p1x(0, -2);
check("First", p1x.begin() == 0);
check("Last", p1x.last() == -3);
check("End", p1x.end() == -2);
check("Length", p1x.length() == -2);
check("is_null", p1x.is_null());
}
{
std::cout << std::endl;
a_period p1(0, -1);
check("First", p1.begin() == 0);
check("Last", p1.last() == -2);
check("End", p1.end() == -1);
check("Length", p1.length() == -1);
check("is_null", p1.is_null());
a_period p1x(0, -1);
check("First", p1x.begin() == 0);
check("Last", p1x.last() == -2);
check("End", p1x.end() == -1);
check("Length", p1x.length() == -1);
check("is_null", p1x.is_null());
}
{
std::cout << std::endl;
a_period p1(0, 0);
check("First", p1.begin() == 0);
check("Last", p1.last() == -1);
check("End", p1.end() == 0);
check("Length", p1.length() == 0);
check("is_null", p1.is_null());
a_period p1x(0, 0);
check("First", p1x.begin() == 0);
check("Last", p1x.last() == -1);
check("End", p1x.end() == 0);
check("Length", p1x.length() == 0);
check("is_null", p1x.is_null());
}
{
std::cout << std::endl;
a_period p1(0, 1);
check("First", p1.begin() == 0);
check("Last", p1.last() == 0);
check("End", p1.end() == 1);
check("Length", p1.length() == 1);
check("is_null", !p1.is_null());
a_period p1x(0, 1);
check("First", p1x.begin() == 0);
check("Last", p1x.last() == 0);
check("End", p1x.end() == 1);
check("Length", p1x.length() == 1);
check("is_null", !p1x.is_null());
}
{
std::cout << std::endl;
a_period p1(0, 2);
check("First", p1.begin() == 0);
check("Last", p1.last() == 1);
check("End", p1.end() == 2);
check("Length", p1.length() == 2);
check("is_null", !p1.is_null());
a_period p1x(0, 2);
check("First", p1x.begin() == 0);
check("Last", p1x.last() == 1);
check("End", p1x.end() == 2);
check("Length", p1x.length() == 2);
check("is_null", !p1x.is_null());
}
{
std::cout << std::endl;
a_period p1(0, duration_type<int>(-1));
check("First", p1.begin() == 0);
check("Last", p1.last() == -2);
check("End", p1.end() == -1);
check("Length", p1.length() == -1);
check("is_null", p1.is_null());
a_period p1x(0, duration_type<int>(-1));
check("First", p1x.begin() == 0);
check("Last", p1x.last() == -2);
check("End", p1x.end() == -1);
check("Length", p1x.length() == -1);
check("is_null", p1x.is_null());
}
{
std::cout << std::endl;
a_period p1(0, duration_type<int>(-2));
check("First", p1.begin() == 0);
check("Last", p1.last() == -3);
check("End", p1.end() == -2);
check("Length", p1.length() == -2);
check("is_null", p1.is_null());
a_period p1x(0, duration_type<int>(-2));
check("First", p1x.begin() == 0);
check("Last", p1x.last() == -3);
check("End", p1x.end() == -2);
check("Length", p1x.length() == -2);
check("is_null", p1x.is_null());
}
{
std::cout << std::endl;
a_period p1(0, duration_type<int>(0));
check("First", p1.begin() == 0);
check("Last", p1.last() == -1);
check("End", p1.end() == 0);
check("Length", p1.length() == 0);
check("is_null", p1.is_null());
a_period p1x(0, duration_type<int>(0));
check("First", p1x.begin() == 0);
check("Last", p1x.last() == -1);
check("End", p1x.end() == 0);
check("Length", p1x.length() == 0);
check("is_null", p1x.is_null());
}
{
std::cout << std::endl;
a_period p1(0, duration_type<int>(1));
check("First", p1.begin() == 0);
check("Last", p1.last() == 0);
check("End", p1.end() == 1);
check("Length", p1.length() == 1);
check("is_null", !p1.is_null());
a_period p1x(0, duration_type<int>(1));
check("First", p1x.begin() == 0);
check("Last", p1x.last() == 0);
check("End", p1x.end() == 1);
check("Length", p1x.length() == 1);
check("is_null", !p1x.is_null());
}
{
std::cout << std::endl;
a_period p1(0, duration_type<int>(2));
check("First", p1.begin() == 0);
check("Last", p1.last() == 1);
check("End", p1.end() == 2);
check("Length", p1.length() == 2);
check("is_null", !p1.is_null());
a_period p1x(0, duration_type<int>(2));
check("First", p1x.begin() == 0);
check("Last", p1x.last() == 1);
check("End", p1x.end() == 2);
check("Length", p1x.length() == 2);
check("is_null", !p1x.is_null());
}
{
std::cout << std::endl;
a_period p1(1,1); // length should be 0
a_period p2(1,2); // length should be 1
a_period p3(1,3); // length should be 2
check("Length p1", p1.length() == 0);
check("Length p2", p2.length() == 1);
check("Length p3", p3.length() == 2);
check("is_null p1 (not)", p1.is_null());
check("is_null p2 (not)", !p2.is_null());
a_period p1x(1,1); // length should be 0
a_period p2x(1,2); // length should be 1
a_period p3x(1,3); // length should be 2
check("Length p1", p1x.length() == 0);
check("Length p2", p2x.length() == 1);
check("Length p3", p3x.length() == 2);
check("is_null p1 (not)", p1x.is_null());
check("is_null p2 (not)", !p2x.is_null());
}
{
a_period p1(1,2); // length should be 1
p1.shift(duration_type<int>(1));
a_period p2(2,3); // shifted result
check("shift", p1 == p2);
a_period p1x(1,2); // length should be 1
p1x.shift(duration_type<int>(1));
a_period p2x(2,3); // shifted result
check("shift", p1x == p2x);
}
{
a_period p1(5,duration_type<int>(3));
a_period p2(3,10); // expanded result
p1.expand(duration_type<int>(2)); //from 2000-Jan-01--2000-Jan-04
check("expand", p1 == p2);
a_period p1x(5,duration_type<int>(3));
a_period p2x(3,10); // expanded result
p1x.expand(duration_type<int>(2)); //from 2000-Jan-01--2000-Jan-04
check("expand", p1x == p2x);
}
return printTestStats();
}

8
test/testint_adapter.cpp
View File

@@ -96,10 +96,10 @@ void test_int()
check("is special_value (pos_inf)", l.is_special());
check("add infinity" , l == int_type::pos_infinity());
{ // limiting the scope for these tests was easier than recalculating l
int_type l = i - int_type::pos_infinity();
check("value - +infinity", l == int_type::neg_infinity());
l = i + int_type::neg_infinity();
check("value + -infinity", l == int_type::neg_infinity());
int_type m = i - int_type::pos_infinity();
check("value - +infinity", m == int_type::neg_infinity());
m = i + int_type::neg_infinity();
check("value + -infinity", m == int_type::neg_infinity());
}
check("inf - inf = nan", (l - l) == int_type::not_a_number());
check("-inf + inf = nan", (j + l) == int_type::not_a_number());

8
test/testwrapping_int.cpp
View File

@@ -49,12 +49,12 @@ main()
check("signed int - value", wi3 == 0);
{ // subtracting negative values
wrapping_int<short, 10> wi3(5);
wrapping_int<short, 10> wi4(5);
check("subtract negative value to cause wrap",
(wi3.subtract(-8) == -1 && wi3 == 3));
check("reset", wi3.add(2) == 0 && wi3 ==5);
(wi4.subtract(-8) == -1 && wi4 == 3));
check("reset", wi4.add(2) == 0 && wi4 ==5);
check("add negative value to cause wrap",
(wi3.add(-8) == -1 && wi3 == 7));
(wi4.add(-8) == -1 && wi4 == 7));
}
wrapping_int2<short, 1, 5> wi4(1);

2
xmldoc/Jamfile.v2
View File

@@ -4,8 +4,6 @@
# file LICENSE_1_0.txt or http://www.boost.org/LICENSE_1_0.txt)
#
project libs/date_time/xmldoc ;
import set ;
using boostbook ;