townforge/date_time
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity
cc
date_time/test/gregorian/testdate_input_facet.cpp
Jeff Garland e26fd2ed98
pull develop to master for boost 1.72 (#117) 
* Synchronize each miscrosec test to the next second (#109)

* Synchronize each miscrosec test to the next second

The aim is to avoid false positives in test_microsec when the seconds,
minutes or hours change during time read between the second_clock and
the microsec_clock.

* Improved readability of the microcec_time_clock test

* Improve performance of adding and subtracting time durations from a ptime. (#99)

Modifying ptime objects by adding and subtracting time durations was
inefficient because it extracted the date and time of day and then
re-constructed a ptime using the date and modified time of day.

This can be avoided by using the existing time_system utilities which
perform the operation by adjusting the number of ticks.

Performance is improved by a factor of 48 on my system.

* Update CI Scripts

* Add time_duration helper functions: (#113)

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.

* Cease dependence on MPL (#115)
2019-12-03 17:06:28 -07:00

583 lines
22 KiB
C++
Raw Permalink Blame History

/* Copyright (c) 2005 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/gregorian/gregorian.hpp"
#include "../testfrmwk.hpp"
#include <iostream>
#include <sstream>
#include <string>
#include <vector>
#ifndef USE_DATE_TIME_PRE_1_33_FACET_IO
// for tests that are expected to fail and throw exceptions
template<class temporal_type, class exception_type>
bool failure_test(temporal_type component,
const std::string& input,
exception_type const& /*except*/,
boost::gregorian::date_input_facet* facet)
{
using namespace boost::gregorian;
bool result = false;
std::istringstream iss(input);
iss.exceptions(std::ios_base::failbit); // turn on exceptions
iss.imbue(std::locale(std::locale::classic(), facet));
try {
iss >> component;
}
catch(exception_type& e) {
std::cout << "Expected exception caught: \""
<< e.what() << "\"" << std::endl;
result = iss.fail(); // failbit must be set to pass test
}
catch(...) {
result = false;
}
return result;
}
// for tests that are expected to fail quietly
template<class temporal_type>
bool failure_test(temporal_type component,
const std::string& input,
boost::gregorian::date_input_facet* facet)
{
using namespace boost::gregorian;
std::istringstream iss(input);
/* leave exceptions turned off
* iss.exceptions(std::ios_base::failbit); */
iss.imbue(std::locale(std::locale::classic(), facet));
try {
iss >> component;
}
catch(...) {
std::cout << "Caught unexpected exception" << std::endl;
return false;
}
return iss.fail(); // failbit must be set to pass test
}
#endif
int main(){
#ifndef USE_DATE_TIME_PRE_1_33_FACET_IO
using namespace boost::gregorian;
{
// verify no extra character are consumed
greg_month m(1);
std::stringstream ss("Mar.");
std::istreambuf_iterator<char> sitr(ss), str_end;
date_input_facet f;
f.get(sitr, str_end, ss, m);
check("No extra characters consumed", m == greg_month(Mar) && *sitr == '.');
}
// set up initial objects
date d(not_a_date_time);
days dd(not_a_date_time);
greg_month m(1);
greg_weekday gw(0);
greg_day gd(1);
greg_year gy(2000);
// exceptions for failure_tests
std::ios_base::failure e_failure("default");
bad_month e_bad_month;
bad_year e_bad_year;
bad_day_of_month e_bad_day_of_month;
bad_weekday e_bad_weekday;
bad_day_of_year e_bad_day_of_year;
// default format tests: date, days, month, weekday, day, year
std::istringstream iss("2005-Jan-15 21 Feb Tue 4 2002");
iss >> d;
check_equal("Default format date", d, date(2005,Jan,15));
iss >> dd;
check_equal("Default (only) format positive days", dd, days(21));
iss >> m;
check_equal("Default format month", m, greg_month(2));
iss >> gw;
check_equal("Default format weekday", gw, greg_weekday(2));
iss >> gd;
check_equal("Default (only) format day of month", gd, greg_day(4));
iss >> gy;
check_equal("Default format year", gy, greg_year(2002));
// failure tests
check("Input Misspelled in year (date) w/exceptions",
failure_test(d, "205-Jan-15", e_bad_year, new date_input_facet()));
check("Input Misspelled in year (date) no-exceptions",
failure_test(d, "205-Jan-15", new date_input_facet()));
check("Input Misspelled in month (date) w/exceptions",
failure_test(d, "2005-Jsn-15", e_bad_month, new date_input_facet()));
check("Input Misspelled in month (date) no-exceptions",
failure_test(d, "2005-Jsn-15", new date_input_facet()));
check("Input Misspelled in day (date) w/exceptions",
failure_test(d, "2005-Jan-51", e_bad_day_of_month, new date_input_facet()));
check("Input Misspelled in day (date) no-exceptions",
failure_test(d, "2005-Jan-51", new date_input_facet()));
check("Input Misspelled greg_weekday w/exceptions",
failure_test(gw, "San", e_bad_weekday, new date_input_facet()));
check("Input Misspelled greg_weekday no-exceptions",
failure_test(gw, "San", new date_input_facet()));
check("Input Misspelled month w/exceptions",
failure_test(m, "Jsn", e_bad_month, new date_input_facet()));
check("Input Misspelled month no-exceptions",
failure_test(m, "Jsn", new date_input_facet()));
check("Bad Input greg_day w/exceptions",
failure_test(gd, "Sun", e_bad_day_of_month, new date_input_facet()));
check("Bad Input greg_day no-exceptions",
failure_test(gd, "Sun", new date_input_facet()));
check("Input Misspelled greg_year w/exceptions",
failure_test(gy, "205", e_bad_year, new date_input_facet()));
check("Input Misspelled greg_year no-exceptions",
failure_test(gy, "205", new date_input_facet()));
// change to full length names, iso date format, and 2 digit year
date_input_facet* facet = new date_input_facet();
facet->set_iso_format();
facet->month_format("%B");
facet->weekday_format("%A");
facet->year_format("%y");
iss.str("20050115 -55 February Tuesday 02");
iss.imbue(std::locale(std::locale::classic(), facet));
iss >> d;
check_equal("ISO format date", d, date(2005,Jan,15));
iss >> dd;
check_equal("Default (only) format negative days", dd, days(-55));
iss >> m;
check_equal("Full format month", m, greg_month(2));
iss >> gw;
check_equal("Full format weekday", gw, greg_weekday(2));
iss >> gy;
check_equal("2 digit format year", gy, greg_year(2002));
date_input_facet* f1 = new date_input_facet();
date_input_facet* f2 = new date_input_facet();
f1->set_iso_format();
f2->set_iso_format();
check("Missing digit(s) in ISO string", failure_test(d,"2005071", f1));
check("Missing digit(s) in ISO string",
failure_test(d,"2005071", e_bad_day_of_month, f2));
{ // literal % in format tests
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 >> 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 >> dx;
check_equal("Multiple literal '%'s in date format", dx, date(2005,Jun,14));
f->month_format("%%b %b");
ss.str("%b Jun");
ss >> mx;
check_equal("Literal '%' in month format", mx, greg_month(6));
f->month_format("%%%b");
ss.str("%Jun");
ss >> mx;
check_equal("Multiple literal '%'s in month format", mx, greg_month(6));
f->weekday_format("%%a %a");
ss.str("%a Tue");
ss >> gwx;
check_equal("Literal '%' in weekday format", gwx, greg_weekday(2));
f->weekday_format("%%%a");
ss.str("%Tue");
ss >> gwx;
check_equal("Multiple literal '%'s in weekday format", gwx, greg_weekday(2));
f->year_format("%%Y %Y");
ss.str("%Y 2005");
ss >> y;
check_equal("Literal '%' in year format", y, greg_year(2005));
f->year_format("%%%Y");
ss.str("%2005");
ss >> y;
check_equal("Multiple literal '%'s in year format", y, greg_year(2005));
f->year_format("%Y%");
ss.str("2005%");
ss >> y;
check_equal("Trailing'%'s in year format", y, greg_year(2005));
}
// All days, month, weekday, day, and year formats have been tested
// begin testing other date formats
facet->set_iso_extended_format();
iss.str("2005-01-15");
iss >> d;
check_equal("ISO Extended format date", d, date(2005,Jan,15));
facet->format("%B %d, %Y");
iss.str("March 15, 2006");
iss >> d;
check_equal("Custom date format: \"%B %d, %Y\" => 'March 15, 2006'",
d, date(2006,Mar,15));
facet->format("%Y-%j"); // Ordinal format ISO8601(2000 sect 5.2.2.1 extended)
iss.str("2006-074");
iss >> d;
check_equal("Custom date format: \"%Y-%j\" => '2006-074'",
d, date(2006,Mar,15));
check("Bad input Custom date format: \"%Y-%j\" => '2006-74' (w/exceptions)",
failure_test(d, "2006-74", e_bad_day_of_year, facet));
check("Bad input Custom date format: \"%Y-%j\" => '2006-74' (no exceptions)",
failure_test(d, "2006-74", facet));
// date_period tests
// A date_period is constructed with an open range. So the periods
// [2000-07--04/2000-07-25) <-- open range
// And
// [2000-07--04/2000-07-24] <-- closed range
// Are equal
date begin(2002, Jul, 4);
days len(21);
date_period dp(date(2000,Jan,1), days(1));
iss.str("[2002-07-04/2002-07-24]");
facet->set_iso_extended_format();
iss >> dp;
check_equal("Default period (closed range)", dp, date_period(begin,len));
{
std::stringstream ss;
date dx(not_a_date_time);
date d2 = day_clock::local_day();
date d3(neg_infin);
date d4(pos_infin);
date_period dpx(d2, dx); // date/nadt
date_period dp2(dx, dx); // nadt/nadt
date_period dp3(d3, d4);
ss << dpx;
ss >> dp2;
check_equal("Special values period (reversibility test)", dpx, dp2);
ss.str("[-infinity/+infinity]");
ss >> dp2;
check_equal("Special values period (infinities)", dp3, dp2);
}
// open range
period_parser pp(period_parser::AS_OPEN_RANGE);
iss.str("[2002-07-04/2002-07-25)");
facet->period_parser(pp);
iss >> dp;
check_equal("Open range period", dp, date_period(begin,len));
// custom period delimiters
pp.delimiter_strings(" to ", "from ", " exclusive", " inclusive");
iss.str("from 2002-07-04 to 2002-07-25 exclusive");
facet->period_parser(pp);
iss >> dp;
check_equal("Open range period - custom delimiters", dp, date_period(begin,len));
pp.range_option(period_parser::AS_CLOSED_RANGE);
iss.str("from 2002-07-04 to 2002-07-24 inclusive");
facet->period_parser(pp);
iss >> dp;
check_equal("Closed range period - custom delimiters", dp, date_period(begin,len));
// date_generator tests
// date_generators use formats contained in the
// date_input_facet for weekdays and months
// reset month & weekday formats to defaults
facet->month_format("%b");
facet->weekday_format("%a");
partial_date pd(1,Jan);
nth_kday_of_month nkd(nth_kday_of_month::first, Sunday, Jan);
first_kday_of_month fkd(Sunday, Jan);
last_kday_of_month lkd(Sunday, Jan);
first_kday_before fkb(Sunday);
first_kday_after fka(Sunday);
// using default date_generator_parser "nth_strings"
iss.str("29 Feb");
iss >> pd;
// Feb-29 is a valid date_generator, get_date() will fail in a non-leap year
check_equal("Default strings, partial_date",
pd.get_date(2004), date(2004,Feb,29));
iss.str("second Mon of Mar");
iss >> nkd;
check_equal("Default strings, nth_day_of_the_week_in_month",
nkd.get_date(2004), date(2004,Mar,8));
iss.str("first Tue of Apr");
iss >> fkd;
check_equal("Default strings, first_day_of_the_week_in_month",
fkd.get_date(2004), date(2004,Apr,6));
iss.str("last Wed of May");
iss >> lkd;
check_equal("Default strings, last_day_of_the_week_in_month",
lkd.get_date(2004), date(2004,May,26));
iss.str("Thu before");
iss >> fkb;
check_equal("Default strings, first_day_of_the_week_before",
fkb.get_date(date(2004,Feb,8)), date(2004,Feb,5));
iss.str("Fri after");
iss >> fka;
check_equal("Default strings, first_day_of_the_week_after",
fka.get_date(date(2004,Feb,1)), date(2004,Feb,6));
// failure tests
check("Incorrect elements (date_generator) w/exceptions", // after/before type mixup
failure_test(fkb, "Fri after", e_failure, new date_input_facet()));
check("Incorrect elements (date_generator) no exceptions", // after/before type mixup
failure_test(fkb, "Fri after", new date_input_facet()));
check("Incorrect elements (date_generator) w/exceptions", // first/last type mixup
failure_test(lkd, "first Tue of Apr", e_failure, new date_input_facet()));
check("Incorrect elements (date_generator) no exceptions", // first/last type mixup
failure_test(lkd, "first Tue of Apr", new date_input_facet()));
check("Incorrect elements (date_generator) w/exceptions", // 'in' is wrong
failure_test(nkd, "second Mon in Mar", e_failure, new date_input_facet()));
check("Incorrect elements (date_generator) no exceptions", // 'in' is wrong
failure_test(nkd, "second Mon in Mar", new date_input_facet()));
// date_generators - custom element strings
facet->date_gen_element_strings("1st","2nd","3rd","4th","5th","final","prior to","past","in");
iss.str("3rd Sat in Jul");
iss >> nkd;
check_equal("Custom strings, nth_day_of_the_week_in_month",
nkd.get_date(2004), date(2004,Jul,17));
iss.str("1st Wed in May");
iss >> fkd;
check_equal("Custom strings, first_day_of_the_week_in_month",
fkd.get_date(2004), date(2004,May,5));
iss.str("final Tue in Apr");
iss >> lkd;
check_equal("Custom strings, last_day_of_the_week_in_month",
lkd.get_date(2004), date(2004,Apr,27));
iss.str("Fri prior to");
iss >> fkb;
check_equal("Custom strings, first_day_of_the_week_before",
fkb.get_date(date(2004,Feb,8)), date(2004,Feb,6));
iss.str("Thu past");
iss >> fka;
check_equal("Custom strings, first_day_of_the_week_after",
fka.get_date(date(2004,Feb,1)), date(2004,Feb,5));
// date_generators - special case with empty element string
/* Doesn't work. Empty string returns -1 from string_parse_tree
* because it attempts to match the next set of characters in the
* stream to the wrong element. Ex. It attempts to match "Mar" to
* the 'of' element in the test below.
*
facet->date_gen_element_strings("1st","2nd","3rd","4th","5th","final","prior to","past",""); // the 'of' string is an empty string
iss.str("final Mon Mar");
iss >> lkd;
check_equal("Special case, empty element string",
lkd.get_date(2005), date(2005,Mar,28));
*/
// special values tests (date and days only)
iss.str("minimum-date-time +infinity");
iss >> d;
iss >> dd;
check_equal("Special values, default strings, min_date_time date",
d, date(min_date_time));
check_equal("Special values, default strings, pos_infin days",
dd, days(pos_infin));
iss.str("-infinity maximum-date-time");
iss >> d;
iss >> dd;
check_equal("Special values, default strings, neg_infin date",
d, date(neg_infin));
check_equal("Special values, default strings, max_date_time days",
dd, days(max_date_time));
iss.str("not-a-date-time");
iss >> d;
check_equal("Special values, default strings, not_a_date_time date",
d, date(not_a_date_time));
// in addition check that special_value_from_string also works correctly for other special values
check_equal("Special values, default strings, not_special test",
special_value_from_string("not_special"), not_special);
check_equal("Special values, default strings, junk test",
special_value_from_string("junk"), not_special);
// special values custom, strings
special_values_parser svp("NADT", "MINF", "INF", "MINDT", "MAXDT");
facet->special_values_parser(svp);
iss.str("MINDT INF");
iss >> d;
iss >> dd;
check_equal("Special values, custom strings, min_date_time date",
d, date(min_date_time));
check_equal("Special values, custom strings, pos_infin days",
dd, days(pos_infin));
iss.str("MINF MAXDT");
iss >> d;
iss >> dd;
check_equal("Special values, custom strings, neg_infin date",
d, date(neg_infin));
check_equal("Special values, custom strings, max_date_time days",
dd, days(max_date_time));
iss.str("NADT");
iss >> dd;
check_equal("Special values, custom strings, not_a_date_time days",
dd, days(not_a_date_time));
// failure test
check("Misspelled input, special_value date w/exceptions",
failure_test(d, "NSDT", e_bad_year, new date_input_facet()));
check("Misspelled input, special_value date no exceptions",
failure_test(d, "NSDT", new date_input_facet()));
check("Misspelled input, special_value days w/exceptions",
failure_test(dd, "NSDT", e_failure, new date_input_facet()));
check("Misspelled input, special_value days no exceptions",
failure_test(dd, "NSDT", new date_input_facet()));
{
// German names. Please excuse any errors, I don't speak German and
// had to rely on an on-line translation service.
// These tests check one of each (at least) from all sets of custom strings
// create a custom format_date_parser
std::string m_a[] = {"Jan","Feb","Mar","Apr","Mai",
"Jun","Jul","Aug","Sep","Okt","Nov","Dez"};
std::string m_f[] = {"Januar","Februar","Marz","April",
"Mai","Juni","Juli","August",
"September","Oktober","November","Dezember"};
std::string w_a[] = {"Son", "Mon", "Die","Mit", "Don", "Fre", "Sam"};
std::string w_f[] = {"Sonntag", "Montag", "Dienstag","Mittwoch",
"Donnerstag", "Freitag", "Samstag"};
typedef boost::date_time::format_date_parser<date, char> date_parser;
date_parser::input_collection_type months_abbrev;
date_parser::input_collection_type months_full;
date_parser::input_collection_type wkdays_abbrev;
date_parser::input_collection_type wkdays_full;
months_abbrev.assign(m_a, m_a+12);
months_full.assign(m_f, m_f+12);
wkdays_abbrev.assign(w_a, w_a+7);
wkdays_full.assign(w_f, w_f+7);
date_parser d_parser("%B %d %Y",
months_abbrev, months_full,
wkdays_abbrev, wkdays_full);
// create a special_values parser
special_values_parser sv_parser("NichtDatumzeit",
"Negativ Unendlichkeit",
"Positiv Unendlichkeit",
"Wenigstes Datum",
"Maximales Datum");
// create a period_parser
period_parser p_parser; // default will do
// create date_generator_parser
typedef boost::date_time::date_generator_parser<date,char> date_gen_parser;
date_gen_parser dg_parser("Zuerst","Zweitens","Dritt","Viert",
"F\xC3\xBCnft","Letzt","Vor","Nach","Von");
// create the date_input_facet
date_input_facet* de_facet =
new date_input_facet("%B %d %Y",
d_parser,
sv_parser,
p_parser,
dg_parser);
std::istringstream iss2;
iss2.imbue(std::locale(std::locale::classic(), de_facet));
// June 06 2005, Dec, minimum date, Tues
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));
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
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
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));
}
{
// test name replacement functions
// collections for adding to facet
const char* const month_short_names[]={"*jan*","*feb*","*mar*",
"*apr*","*may*","*jun*",
"*jul*","*aug*","*sep*",
"*oct*","*nov*","*dec*"};
const char* const month_long_names[]={"**January**","**February**","**March**",
"**April**","**May**","**June**",
"**July**","**August**","**September**",
"**October**","**November**","**December**"};
const char* const weekday_short_names[]={"day1", "day2","day3","day4",
"day5","day6","day7"};
const char* const weekday_long_names[]= {"Sun-0", "Mon-1", "Tue-2",
"Wed-3", "Thu-4",
"Fri-5", "Sat-6"};
std::vector<std::basic_string<char> > short_weekday_names;
std::vector<std::basic_string<char> > long_weekday_names;
std::vector<std::basic_string<char> > short_month_names;
std::vector<std::basic_string<char> > long_month_names;
std::copy(&weekday_short_names[0],
&weekday_short_names[7],
std::back_inserter(short_weekday_names));
std::copy(&weekday_long_names[0],
&weekday_long_names[7],
std::back_inserter(long_weekday_names));
std::copy(&month_short_names[0],
&month_short_names[12],
std::back_inserter(short_month_names));
std::copy(&month_long_names[0],
&month_long_names[12],
std::back_inserter(long_month_names));
date dx(not_a_date_time);
date_input_facet* facetx = new date_input_facet();
std::stringstream ss;
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 >> 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");
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
check("This test is a nop for platforms with USE_DATE_TIME_PRE_1_33_FACET_IO",
true);
#endif
return printTestStats();
}
Reference in New Issue View Git Blame Copy Permalink