]>
Commit | Line | Data |
---|---|---|
1 | /* Copyright (c) 2005 CrystalClear Software, Inc. | |
2 | * Use, modification and distribution is subject to the | |
3 | * Boost Software License, Version 1.0. (See accompanying | |
4 | * file LICENSE_1_0.txt or http://www.boost.org/LICENSE_1_0.txt) | |
5 | * Author: Jeff Garland, Bart Garst | |
6 | * $Date$ | |
7 | */ | |
8 | ||
9 | #include "boost/date_time/gregorian/gregorian.hpp" | |
10 | #include "../testfrmwk.hpp" | |
11 | #include <iostream> | |
12 | #include <sstream> | |
13 | #include <string> | |
14 | #include <vector> | |
15 | ||
16 | #ifndef USE_DATE_TIME_PRE_1_33_FACET_IO | |
17 | // for tests that are expected to fail and throw exceptions | |
18 | template<class temporal_type, class exception_type> | |
19 | bool failure_test(temporal_type component, | |
20 | const std::string& input, | |
21 | exception_type const& /*except*/, | |
22 | boost::gregorian::date_input_facet* facet) | |
23 | { | |
24 | using namespace boost::gregorian; | |
25 | bool result = false; | |
26 | std::istringstream iss(input); | |
27 | iss.exceptions(std::ios_base::failbit); // turn on exceptions | |
28 | iss.imbue(std::locale(std::locale::classic(), facet)); | |
29 | try { | |
30 | iss >> component; | |
31 | } | |
32 | catch(exception_type& e) { | |
33 | std::cout << "Expected exception caught: \"" | |
34 | << e.what() << "\"" << std::endl; | |
35 | result = iss.fail(); // failbit must be set to pass test | |
36 | } | |
37 | catch(...) { | |
38 | result = false; | |
39 | } | |
40 | ||
41 | return result; | |
42 | } | |
43 | ||
44 | // for tests that are expected to fail quietly | |
45 | template<class temporal_type> | |
46 | bool failure_test(temporal_type component, | |
47 | const std::string& input, | |
48 | boost::gregorian::date_input_facet* facet) | |
49 | { | |
50 | using namespace boost::gregorian; | |
51 | std::istringstream iss(input); | |
52 | /* leave exceptions turned off | |
53 | * iss.exceptions(std::ios_base::failbit); */ | |
54 | iss.imbue(std::locale(std::locale::classic(), facet)); | |
55 | try { | |
56 | iss >> component; | |
57 | } | |
58 | catch(...) { | |
59 | std::cout << "Caught unexpected exception" << std::endl; | |
60 | return false; | |
61 | } | |
62 | ||
63 | return iss.fail(); // failbit must be set to pass test | |
64 | } | |
65 | ||
66 | #endif | |
67 | ||
68 | ||
69 | ||
70 | int main(){ | |
71 | #ifndef USE_DATE_TIME_PRE_1_33_FACET_IO | |
72 | using namespace boost::gregorian; | |
73 | ||
74 | { | |
75 | // verify no extra character are consumed | |
76 | greg_month m(1); | |
77 | std::stringstream ss("Mar."); | |
78 | std::istreambuf_iterator<char> sitr(ss), str_end; | |
79 | ||
80 | date_input_facet f; | |
81 | f.get(sitr, str_end, ss, m); | |
82 | check("No extra characters consumed", m == greg_month(Mar) && *sitr == '.'); | |
83 | } | |
84 | ||
85 | // set up initial objects | |
86 | date d(not_a_date_time); | |
87 | days dd(not_a_date_time); | |
88 | greg_month m(1); | |
89 | greg_weekday gw(0); | |
90 | greg_day gd(1); | |
91 | greg_year gy(2000); | |
92 | // exceptions for failure_tests | |
93 | std::ios_base::failure e_failure("default"); | |
94 | bad_month e_bad_month; | |
95 | bad_year e_bad_year; | |
96 | bad_day_of_month e_bad_day_of_month; | |
97 | bad_weekday e_bad_weekday; | |
98 | bad_day_of_year e_bad_day_of_year; | |
99 | ||
100 | // default format tests: date, days, month, weekday, day, year | |
101 | std::istringstream iss("2005-Jan-15 21 Feb Tue 4 2002"); | |
102 | iss >> d; | |
103 | check_equal("Default format date", d, date(2005,Jan,15)); | |
104 | iss >> dd; | |
105 | check_equal("Default (only) format positive days", dd, days(21)); | |
106 | iss >> m; | |
107 | check_equal("Default format month", m, greg_month(2)); | |
108 | iss >> gw; | |
109 | check_equal("Default format weekday", gw, greg_weekday(2)); | |
110 | iss >> gd; | |
111 | check_equal("Default (only) format day of month", gd, greg_day(4)); | |
112 | iss >> gy; | |
113 | check_equal("Default format year", gy, greg_year(2002)); | |
114 | // failure tests | |
115 | check("Input Misspelled in year (date) w/exceptions", | |
116 | failure_test(d, "205-Jan-15", e_bad_year, new date_input_facet())); | |
117 | check("Input Misspelled in year (date) no-exceptions", | |
118 | failure_test(d, "205-Jan-15", new date_input_facet())); | |
119 | check("Input Misspelled in month (date) w/exceptions", | |
120 | failure_test(d, "2005-Jsn-15", e_bad_month, new date_input_facet())); | |
121 | check("Input Misspelled in month (date) no-exceptions", | |
122 | failure_test(d, "2005-Jsn-15", new date_input_facet())); | |
123 | check("Input Misspelled in day (date) w/exceptions", | |
124 | failure_test(d, "2005-Jan-51", e_bad_day_of_month, new date_input_facet())); | |
125 | check("Input Misspelled in day (date) no-exceptions", | |
126 | failure_test(d, "2005-Jan-51", new date_input_facet())); | |
127 | check("Input Misspelled greg_weekday w/exceptions", | |
128 | failure_test(gw, "San", e_bad_weekday, new date_input_facet())); | |
129 | check("Input Misspelled greg_weekday no-exceptions", | |
130 | failure_test(gw, "San", new date_input_facet())); | |
131 | check("Input Misspelled month w/exceptions", | |
132 | failure_test(m, "Jsn", e_bad_month, new date_input_facet())); | |
133 | check("Input Misspelled month no-exceptions", | |
134 | failure_test(m, "Jsn", new date_input_facet())); | |
135 | check("Bad Input greg_day w/exceptions", | |
136 | failure_test(gd, "Sun", e_bad_day_of_month, new date_input_facet())); | |
137 | check("Bad Input greg_day no-exceptions", | |
138 | failure_test(gd, "Sun", new date_input_facet())); | |
139 | check("Input Misspelled greg_year w/exceptions", | |
140 | failure_test(gy, "205", e_bad_year, new date_input_facet())); | |
141 | check("Input Misspelled greg_year no-exceptions", | |
142 | failure_test(gy, "205", new date_input_facet())); | |
143 | ||
144 | // change to full length names, iso date format, and 2 digit year | |
145 | date_input_facet* facet = new date_input_facet(); | |
146 | facet->set_iso_format(); | |
147 | facet->month_format("%B"); | |
148 | facet->weekday_format("%A"); | |
149 | facet->year_format("%y"); | |
150 | iss.str("20050115 -55 February Tuesday 02"); | |
151 | iss.imbue(std::locale(std::locale::classic(), facet)); | |
152 | ||
153 | iss >> d; | |
154 | check_equal("ISO format date", d, date(2005,Jan,15)); | |
155 | iss >> dd; | |
156 | check_equal("Default (only) format negative days", dd, days(-55)); | |
157 | iss >> m; | |
158 | check_equal("Full format month", m, greg_month(2)); | |
159 | iss >> gw; | |
160 | check_equal("Full format weekday", gw, greg_weekday(2)); | |
161 | iss >> gy; | |
162 | check_equal("2 digit format year", gy, greg_year(2002)); | |
163 | ||
164 | date_input_facet* f1 = new date_input_facet(); | |
165 | date_input_facet* f2 = new date_input_facet(); | |
166 | f1->set_iso_format(); | |
167 | f2->set_iso_format(); | |
168 | check("Missing digit(s) in ISO string", failure_test(d,"2005071", f1)); | |
169 | check("Missing digit(s) in ISO string", | |
170 | failure_test(d,"2005071", e_bad_day_of_month, f2)); | |
171 | ||
172 | { // literal % in format tests | |
173 | date dx(not_a_date_time); | |
174 | greg_month mx(1); | |
175 | greg_weekday gwx(0); | |
176 | greg_year y(1400); | |
177 | date_input_facet* f = new date_input_facet("%%d %Y-%b-%d"); | |
178 | std::stringstream ss; | |
179 | ss.imbue(std::locale(ss.getloc(), f)); | |
180 | ||
181 | ss.str("%d 2005-Jun-14"); | |
182 | ss >> dx; | |
183 | check_equal("Literal '%' in date format", dx, date(2005,Jun,14)); | |
184 | f->format("%%%d %Y-%b-%d"); | |
185 | ss.str("%14 2005-Jun-14"); | |
186 | ss >> dx; | |
187 | check_equal("Multiple literal '%'s in date format", dx, date(2005,Jun,14)); | |
188 | ||
189 | f->month_format("%%b %b"); | |
190 | ss.str("%b Jun"); | |
191 | ss >> mx; | |
192 | check_equal("Literal '%' in month format", mx, greg_month(6)); | |
193 | f->month_format("%%%b"); | |
194 | ss.str("%Jun"); | |
195 | ss >> mx; | |
196 | check_equal("Multiple literal '%'s in month format", mx, greg_month(6)); | |
197 | ||
198 | f->weekday_format("%%a %a"); | |
199 | ss.str("%a Tue"); | |
200 | ss >> gwx; | |
201 | check_equal("Literal '%' in weekday format", gwx, greg_weekday(2)); | |
202 | f->weekday_format("%%%a"); | |
203 | ss.str("%Tue"); | |
204 | ss >> gwx; | |
205 | check_equal("Multiple literal '%'s in weekday format", gwx, greg_weekday(2)); | |
206 | ||
207 | f->year_format("%%Y %Y"); | |
208 | ss.str("%Y 2005"); | |
209 | ss >> y; | |
210 | check_equal("Literal '%' in year format", y, greg_year(2005)); | |
211 | f->year_format("%%%Y"); | |
212 | ss.str("%2005"); | |
213 | ss >> y; | |
214 | check_equal("Multiple literal '%'s in year format", y, greg_year(2005)); | |
215 | ||
216 | f->year_format("%Y%"); | |
217 | ss.str("2005%"); | |
218 | ss >> y; | |
219 | check_equal("Trailing'%'s in year format", y, greg_year(2005)); | |
220 | } | |
221 | ||
222 | // All days, month, weekday, day, and year formats have been tested | |
223 | // begin testing other date formats | |
224 | facet->set_iso_extended_format(); | |
225 | iss.str("2005-01-15"); | |
226 | iss >> d; | |
227 | check_equal("ISO Extended format date", d, date(2005,Jan,15)); | |
228 | ||
229 | facet->format("%B %d, %Y"); | |
230 | iss.str("March 15, 2006"); | |
231 | iss >> d; | |
232 | check_equal("Custom date format: \"%B %d, %Y\" => 'March 15, 2006'", | |
233 | d, date(2006,Mar,15)); | |
234 | ||
235 | facet->format("%Y-%j"); // Ordinal format ISO8601(2000 sect 5.2.2.1 extended) | |
236 | iss.str("2006-074"); | |
237 | iss >> d; | |
238 | check_equal("Custom date format: \"%Y-%j\" => '2006-074'", | |
239 | d, date(2006,Mar,15)); | |
240 | check("Bad input Custom date format: \"%Y-%j\" => '2006-74' (w/exceptions)", | |
241 | failure_test(d, "2006-74", e_bad_day_of_year, facet)); | |
242 | check("Bad input Custom date format: \"%Y-%j\" => '2006-74' (no exceptions)", | |
243 | failure_test(d, "2006-74", facet)); | |
244 | ||
245 | // date_period tests | |
246 | ||
247 | // A date_period is constructed with an open range. So the periods | |
248 | // [2000-07--04/2000-07-25) <-- open range | |
249 | // And | |
250 | // [2000-07--04/2000-07-24] <-- closed range | |
251 | // Are equal | |
252 | date begin(2002, Jul, 4); | |
253 | days len(21); | |
254 | date_period dp(date(2000,Jan,1), days(1)); | |
255 | iss.str("[2002-07-04/2002-07-24]"); | |
256 | facet->set_iso_extended_format(); | |
257 | iss >> dp; | |
258 | check_equal("Default period (closed range)", dp, date_period(begin,len)); | |
259 | { | |
260 | std::stringstream ss; | |
261 | date dx(not_a_date_time); | |
262 | date d2 = day_clock::local_day(); | |
263 | date d3(neg_infin); | |
264 | date d4(pos_infin); | |
265 | date_period dpx(d2, dx); // date/nadt | |
266 | date_period dp2(dx, dx); // nadt/nadt | |
267 | date_period dp3(d3, d4); | |
268 | ss << dpx; | |
269 | ss >> dp2; | |
270 | check_equal("Special values period (reversibility test)", dpx, dp2); | |
271 | ss.str("[-infinity/+infinity]"); | |
272 | ss >> dp2; | |
273 | check_equal("Special values period (infinities)", dp3, dp2); | |
274 | } | |
275 | ||
276 | ||
277 | // open range | |
278 | period_parser pp(period_parser::AS_OPEN_RANGE); | |
279 | iss.str("[2002-07-04/2002-07-25)"); | |
280 | facet->period_parser(pp); | |
281 | iss >> dp; | |
282 | check_equal("Open range period", dp, date_period(begin,len)); | |
283 | // custom period delimiters | |
284 | pp.delimiter_strings(" to ", "from ", " exclusive", " inclusive"); | |
285 | iss.str("from 2002-07-04 to 2002-07-25 exclusive"); | |
286 | facet->period_parser(pp); | |
287 | iss >> dp; | |
288 | check_equal("Open range period - custom delimiters", dp, date_period(begin,len)); | |
289 | pp.range_option(period_parser::AS_CLOSED_RANGE); | |
290 | iss.str("from 2002-07-04 to 2002-07-24 inclusive"); | |
291 | facet->period_parser(pp); | |
292 | iss >> dp; | |
293 | check_equal("Closed range period - custom delimiters", dp, date_period(begin,len)); | |
294 | ||
295 | ||
296 | // date_generator tests | |
297 | ||
298 | // date_generators use formats contained in the | |
299 | // date_input_facet for weekdays and months | |
300 | // reset month & weekday formats to defaults | |
301 | facet->month_format("%b"); | |
302 | facet->weekday_format("%a"); | |
303 | ||
304 | partial_date pd(1,Jan); | |
305 | nth_kday_of_month nkd(nth_kday_of_month::first, Sunday, Jan); | |
306 | first_kday_of_month fkd(Sunday, Jan); | |
307 | last_kday_of_month lkd(Sunday, Jan); | |
308 | first_kday_before fkb(Sunday); | |
309 | first_kday_after fka(Sunday); | |
310 | // using default date_generator_parser "nth_strings" | |
311 | iss.str("29 Feb"); | |
312 | iss >> pd; | |
313 | // Feb-29 is a valid date_generator, get_date() will fail in a non-leap year | |
314 | check_equal("Default strings, partial_date", | |
315 | pd.get_date(2004), date(2004,Feb,29)); | |
316 | iss.str("second Mon of Mar"); | |
317 | iss >> nkd; | |
318 | check_equal("Default strings, nth_day_of_the_week_in_month", | |
319 | nkd.get_date(2004), date(2004,Mar,8)); | |
320 | iss.str("first Tue of Apr"); | |
321 | iss >> fkd; | |
322 | check_equal("Default strings, first_day_of_the_week_in_month", | |
323 | fkd.get_date(2004), date(2004,Apr,6)); | |
324 | iss.str("last Wed of May"); | |
325 | iss >> lkd; | |
326 | check_equal("Default strings, last_day_of_the_week_in_month", | |
327 | lkd.get_date(2004), date(2004,May,26)); | |
328 | iss.str("Thu before"); | |
329 | iss >> fkb; | |
330 | check_equal("Default strings, first_day_of_the_week_before", | |
331 | fkb.get_date(date(2004,Feb,8)), date(2004,Feb,5)); | |
332 | iss.str("Fri after"); | |
333 | iss >> fka; | |
334 | check_equal("Default strings, first_day_of_the_week_after", | |
335 | fka.get_date(date(2004,Feb,1)), date(2004,Feb,6)); | |
336 | // failure tests | |
337 | check("Incorrect elements (date_generator) w/exceptions", // after/before type mixup | |
338 | failure_test(fkb, "Fri after", e_failure, new date_input_facet())); | |
339 | check("Incorrect elements (date_generator) no exceptions", // after/before type mixup | |
340 | failure_test(fkb, "Fri after", new date_input_facet())); | |
341 | check("Incorrect elements (date_generator) w/exceptions", // first/last type mixup | |
342 | failure_test(lkd, "first Tue of Apr", e_failure, new date_input_facet())); | |
343 | check("Incorrect elements (date_generator) no exceptions", // first/last type mixup | |
344 | failure_test(lkd, "first Tue of Apr", new date_input_facet())); | |
345 | check("Incorrect elements (date_generator) w/exceptions", // 'in' is wrong | |
346 | failure_test(nkd, "second Mon in Mar", e_failure, new date_input_facet())); | |
347 | check("Incorrect elements (date_generator) no exceptions", // 'in' is wrong | |
348 | failure_test(nkd, "second Mon in Mar", new date_input_facet())); | |
349 | ||
350 | // date_generators - custom element strings | |
351 | facet->date_gen_element_strings("1st","2nd","3rd","4th","5th","final","prior to","past","in"); | |
352 | iss.str("3rd Sat in Jul"); | |
353 | iss >> nkd; | |
354 | check_equal("Custom strings, nth_day_of_the_week_in_month", | |
355 | nkd.get_date(2004), date(2004,Jul,17)); | |
356 | iss.str("1st Wed in May"); | |
357 | iss >> fkd; | |
358 | check_equal("Custom strings, first_day_of_the_week_in_month", | |
359 | fkd.get_date(2004), date(2004,May,5)); | |
360 | iss.str("final Tue in Apr"); | |
361 | iss >> lkd; | |
362 | check_equal("Custom strings, last_day_of_the_week_in_month", | |
363 | lkd.get_date(2004), date(2004,Apr,27)); | |
364 | iss.str("Fri prior to"); | |
365 | iss >> fkb; | |
366 | check_equal("Custom strings, first_day_of_the_week_before", | |
367 | fkb.get_date(date(2004,Feb,8)), date(2004,Feb,6)); | |
368 | iss.str("Thu past"); | |
369 | iss >> fka; | |
370 | check_equal("Custom strings, first_day_of_the_week_after", | |
371 | fka.get_date(date(2004,Feb,1)), date(2004,Feb,5)); | |
372 | ||
373 | // date_generators - special case with empty element string | |
374 | /* Doesn't work. Empty string returns -1 from string_parse_tree | |
375 | * because it attempts to match the next set of characters in the | |
376 | * stream to the wrong element. Ex. It attempts to match "Mar" to | |
377 | * the 'of' element in the test below. | |
378 | * | |
379 | facet->date_gen_element_strings("1st","2nd","3rd","4th","5th","final","prior to","past",""); // the 'of' string is an empty string | |
380 | iss.str("final Mon Mar"); | |
381 | iss >> lkd; | |
382 | check_equal("Special case, empty element string", | |
383 | lkd.get_date(2005), date(2005,Mar,28)); | |
384 | */ | |
385 | ||
386 | ||
387 | // special values tests (date and days only) | |
388 | iss.str("minimum-date-time +infinity"); | |
389 | iss >> d; | |
390 | iss >> dd; | |
391 | check_equal("Special values, default strings, min_date_time date", | |
392 | d, date(min_date_time)); | |
393 | check_equal("Special values, default strings, pos_infin days", | |
394 | dd, days(pos_infin)); | |
395 | iss.str("-infinity maximum-date-time"); | |
396 | iss >> d; | |
397 | iss >> dd; | |
398 | check_equal("Special values, default strings, neg_infin date", | |
399 | d, date(neg_infin)); | |
400 | check_equal("Special values, default strings, max_date_time days", | |
401 | dd, days(max_date_time)); | |
402 | iss.str("not-a-date-time"); | |
403 | iss >> d; | |
404 | check_equal("Special values, default strings, not_a_date_time date", | |
405 | d, date(not_a_date_time)); | |
406 | ||
407 | // in addition check that special_value_from_string also works correctly for other special values | |
408 | check_equal("Special values, default strings, not_special test", | |
409 | special_value_from_string("not_special"), not_special); | |
410 | check_equal("Special values, default strings, junk test", | |
411 | special_value_from_string("junk"), not_special); | |
412 | ||
413 | // special values custom, strings | |
414 | special_values_parser svp("NADT", "MINF", "INF", "MINDT", "MAXDT"); | |
415 | facet->special_values_parser(svp); | |
416 | iss.str("MINDT INF"); | |
417 | iss >> d; | |
418 | iss >> dd; | |
419 | check_equal("Special values, custom strings, min_date_time date", | |
420 | d, date(min_date_time)); | |
421 | check_equal("Special values, custom strings, pos_infin days", | |
422 | dd, days(pos_infin)); | |
423 | iss.str("MINF MAXDT"); | |
424 | iss >> d; | |
425 | iss >> dd; | |
426 | check_equal("Special values, custom strings, neg_infin date", | |
427 | d, date(neg_infin)); | |
428 | check_equal("Special values, custom strings, max_date_time days", | |
429 | dd, days(max_date_time)); | |
430 | iss.str("NADT"); | |
431 | iss >> dd; | |
432 | check_equal("Special values, custom strings, not_a_date_time days", | |
433 | dd, days(not_a_date_time)); | |
434 | // failure test | |
435 | check("Misspelled input, special_value date w/exceptions", | |
436 | failure_test(d, "NSDT", e_bad_year, new date_input_facet())); | |
437 | check("Misspelled input, special_value date no exceptions", | |
438 | failure_test(d, "NSDT", new date_input_facet())); | |
439 | check("Misspelled input, special_value days w/exceptions", | |
440 | failure_test(dd, "NSDT", e_failure, new date_input_facet())); | |
441 | check("Misspelled input, special_value days no exceptions", | |
442 | failure_test(dd, "NSDT", new date_input_facet())); | |
443 | ||
444 | { | |
445 | // German names. Please excuse any errors, I don't speak German and | |
446 | // had to rely on an on-line translation service. | |
447 | // These tests check one of each (at least) from all sets of custom strings | |
448 | ||
449 | // create a custom format_date_parser | |
450 | std::string m_a[] = {"Jan","Feb","Mar","Apr","Mai", | |
451 | "Jun","Jul","Aug","Sep","Okt","Nov","Dez"}; | |
452 | std::string m_f[] = {"Januar","Februar","Marz","April", | |
453 | "Mai","Juni","Juli","August", | |
454 | "September","Oktober","November","Dezember"}; | |
455 | std::string w_a[] = {"Son", "Mon", "Die","Mit", "Don", "Fre", "Sam"}; | |
456 | std::string w_f[] = {"Sonntag", "Montag", "Dienstag","Mittwoch", | |
457 | "Donnerstag", "Freitag", "Samstag"}; | |
458 | typedef boost::date_time::format_date_parser<date, char> date_parser; | |
459 | date_parser::input_collection_type months_abbrev; | |
460 | date_parser::input_collection_type months_full; | |
461 | date_parser::input_collection_type wkdays_abbrev; | |
462 | date_parser::input_collection_type wkdays_full; | |
463 | months_abbrev.assign(m_a, m_a+12); | |
464 | months_full.assign(m_f, m_f+12); | |
465 | wkdays_abbrev.assign(w_a, w_a+7); | |
466 | wkdays_full.assign(w_f, w_f+7); | |
467 | date_parser d_parser("%B %d %Y", | |
468 | months_abbrev, months_full, | |
469 | wkdays_abbrev, wkdays_full); | |
470 | ||
471 | // create a special_values parser | |
472 | special_values_parser sv_parser("NichtDatumzeit", | |
473 | "Negativ Unendlichkeit", | |
474 | "Positiv Unendlichkeit", | |
475 | "Wenigstes Datum", | |
476 | "Maximales Datum"); | |
477 | ||
478 | // create a period_parser | |
479 | period_parser p_parser; // default will do | |
480 | // create date_generator_parser | |
481 | typedef boost::date_time::date_generator_parser<date,char> date_gen_parser; | |
482 | date_gen_parser dg_parser("Zuerst","Zweitens","Dritt","Viert", | |
483 | "F\xC3\xBCnft","Letzt","Vor","Nach","Von"); | |
484 | ||
485 | // create the date_input_facet | |
486 | date_input_facet* de_facet = | |
487 | new date_input_facet("%B %d %Y", | |
488 | d_parser, | |
489 | sv_parser, | |
490 | p_parser, | |
491 | dg_parser); | |
492 | std::istringstream iss2; | |
493 | iss2.imbue(std::locale(std::locale::classic(), de_facet)); | |
494 | // June 06 2005, Dec, minimum date, Tues | |
495 | iss2.str("Juni 06 2005 Dez Wenigstes Datum Die"); | |
496 | iss2 >> d; | |
497 | iss2 >> m; | |
498 | check_equal("German names: date", d, date(2005, Jun, 6)); | |
499 | check_equal("German names: month", m, greg_month(Dec)); | |
500 | iss2 >> d; | |
501 | iss2 >> gw; | |
502 | check_equal("German names: special value date", d, date(min_date_time)); | |
503 | check_equal("German names: short weekday", gw, greg_weekday(Tuesday)); | |
504 | de_facet->weekday_format("%A"); // long weekday | |
505 | // Tuesday, Second Tuesday of Mar | |
506 | iss2.str("Dienstag Zweitens Dienstag von Mar"); | |
507 | iss2 >> gw; | |
508 | iss2 >> nkd; | |
509 | check_equal("German names: long weekday", gw, greg_weekday(Tuesday)); | |
510 | check_equal("German names, nth_day_of_the_week_in_month", | |
511 | nkd.get_date(2005), date(2005,Mar,8)); | |
512 | // Tuesday after | |
513 | iss2.str("Dienstag Nach"); | |
514 | iss2 >> fka; | |
515 | check_equal("German names, first_day_of_the_week_after", | |
516 | fka.get_date(date(2005,Apr,5)), date(2005,Apr,12)); | |
517 | } | |
518 | ||
519 | { | |
520 | // test name replacement functions | |
521 | ||
522 | // collections for adding to facet | |
523 | const char* const month_short_names[]={"*jan*","*feb*","*mar*", | |
524 | "*apr*","*may*","*jun*", | |
525 | "*jul*","*aug*","*sep*", | |
526 | "*oct*","*nov*","*dec*"}; | |
527 | const char* const month_long_names[]={"**January**","**February**","**March**", | |
528 | "**April**","**May**","**June**", | |
529 | "**July**","**August**","**September**", | |
530 | "**October**","**November**","**December**"}; | |
531 | const char* const weekday_short_names[]={"day1", "day2","day3","day4", | |
532 | "day5","day6","day7"}; | |
533 | const char* const weekday_long_names[]= {"Sun-0", "Mon-1", "Tue-2", | |
534 | "Wed-3", "Thu-4", | |
535 | "Fri-5", "Sat-6"}; | |
536 | ||
537 | std::vector<std::basic_string<char> > short_weekday_names; | |
538 | std::vector<std::basic_string<char> > long_weekday_names; | |
539 | std::vector<std::basic_string<char> > short_month_names; | |
540 | std::vector<std::basic_string<char> > long_month_names; | |
541 | ||
542 | std::copy(&weekday_short_names[0], | |
543 | &weekday_short_names[7], | |
544 | std::back_inserter(short_weekday_names)); | |
545 | std::copy(&weekday_long_names[0], | |
546 | &weekday_long_names[7], | |
547 | std::back_inserter(long_weekday_names)); | |
548 | std::copy(&month_short_names[0], | |
549 | &month_short_names[12], | |
550 | std::back_inserter(short_month_names)); | |
551 | std::copy(&month_long_names[0], | |
552 | &month_long_names[12], | |
553 | std::back_inserter(long_month_names)); | |
554 | ||
555 | date dx(not_a_date_time); | |
556 | date_input_facet* facetx = new date_input_facet(); | |
557 | std::stringstream ss; | |
558 | ss.imbue(std::locale(std::locale::classic(), facetx)); | |
559 | facetx->short_month_names(short_month_names); | |
560 | facetx->short_weekday_names(short_weekday_names); | |
561 | facetx->long_month_names(long_month_names); | |
562 | facetx->long_weekday_names(long_weekday_names); | |
563 | facetx->format("%a %b %d, %Y"); | |
564 | ss.str("day7 *apr* 23, 2005"); | |
565 | ss >> dx; | |
566 | check_equal("Short custom names, set via accessor function", dx.day_of_week(), greg_weekday(6)); | |
567 | check_equal("Short custom names, set via accessor function", dx.month(), greg_month(4)); | |
568 | ss.str(""); | |
569 | ss.str("Sun-0 **April** 24, 2005"); | |
570 | facetx->format("%A %B %d, %Y"); | |
571 | ss >> dx; | |
572 | check_equal("Long custom names, set via accessor function", dx.day_of_week(), greg_weekday(0)); | |
573 | check_equal("Long custom names, set via accessor function", dx.month(), greg_month(4)); | |
574 | ||
575 | } | |
576 | #else | |
577 | check("This test is a nop for platforms with USE_DATE_TIME_PRE_1_33_FACET_IO", | |
578 | true); | |
579 | #endif | |
580 | return printTestStats(); | |
581 | } | |
582 |