1 // The MIT License (MIT)
2 //
3 // Copyright (c) 2016 Howard Hinnant
4 //
5 // Permission is hereby granted, free of charge, to any person obtaining a copy
6 // of this software and associated documentation files (the "Software"), to deal
7 // in the Software without restriction, including without limitation the rights
8 // to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
9 // copies of the Software, and to permit persons to whom the Software is
10 // furnished to do so, subject to the following conditions:
11 //
12 // The above copyright notice and this permission notice shall be included in all
13 // copies or substantial portions of the Software.
14 //
15 // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
16 // IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
17 // FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
18 // AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
19 // LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
20 // OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
21 // SOFTWARE.
22
23 // This test is meant to maintain a record of the sizeof each type.
24
25 #include "date.h"
26 #include <cassert>
27 #include <sstream>
28
29 void
test_a()30 test_a()
31 {
32 using namespace date;
33 {
34 // correct abbreviation
35 std::istringstream in{"Sun 2016-12-11"};
36 sys_days tp;
37 in >> parse("%a %F", tp);
38 assert(!in.fail());
39 assert(!in.bad());
40 assert(!in.eof());
41 assert(tp == 2016_y/12/11);
42 }
43 {
44 // correct abbreviation
45 std::istringstream in{"Sun 2016-12-11"};
46 sys_days tp;
47 in >> parse("%A %F", tp);
48 // this may fail with libstdc++, see https://github.com/HowardHinnant/date/issues/388
49 // possible workaround: compile date.h with -DONLY_C_LOCALE=1
50 assert(!in.fail());
51 assert(!in.bad());
52 assert(!in.eof());
53 assert(tp == 2016_y/12/11);
54 }
55 {
56 // correct full name
57 std::istringstream in{"Sunday 2016-12-11"};
58 sys_days tp;
59 in >> parse("%a %F", tp);
60 assert(!in.fail());
61 assert(!in.bad());
62 assert(!in.eof());
63 assert(tp == 2016_y/12/11);
64 }
65 {
66 // correct full name
67 std::istringstream in{"Sunday 2016-12-11"};
68 sys_days tp;
69 in >> parse("%A %F", tp);
70 assert(!in.fail());
71 assert(!in.bad());
72 assert(!in.eof());
73 assert(tp == 2016_y/12/11);
74 }
75 {
76 // not a valid name
77 std::istringstream in{"Dec 2016-12-11"};
78 sys_days tp;
79 in >> parse("%a %F", tp);
80 assert( in.fail());
81 assert(!in.bad());
82 assert(!in.eof());
83 assert(tp == 1970_y/1/1);
84 }
85 {
86 // wrong name
87 std::istringstream in{"Sat 2016-12-11"};
88 sys_days tp;
89 in >> parse("%a %F", tp);
90 assert( in.fail());
91 assert(!in.bad());
92 assert(!in.eof());
93 assert(tp == 1970_y/1/1);
94 }
95 {
96 // extra ws in input
97 std::istringstream in{"Sun 2016-12-11"};
98 sys_days tp;
99 in >> parse("%a %F", tp);
100 assert(!in.fail());
101 assert(!in.bad());
102 assert(!in.eof());
103 assert(tp == 2016_y/12/11);
104 }
105 {
106 // extra ws in format
107 std::istringstream in{"Sun 2016-12-11"};
108 sys_days tp;
109 in >> parse("%a %F", tp);
110 assert(!in.fail());
111 assert(!in.bad());
112 assert(!in.eof());
113 assert(tp == 2016_y/12/11);
114 }
115 }
116
117 void
test_b()118 test_b()
119 {
120 using namespace date;
121 {
122 // correct abbreviation
123 std::istringstream in{"Dec 11 2016"};
124 sys_days tp;
125 in >> parse("%b %d %Y", tp);
126 assert(!in.fail());
127 assert(!in.bad());
128 assert(!in.eof());
129 assert(tp == 2016_y/12/11);
130 }
131 {
132 // correct abbreviation
133 std::istringstream in{"Dec 11 2016"};
134 sys_days tp;
135 in >> parse("%B %d %Y", tp);
136 assert(!in.fail());
137 assert(!in.bad());
138 assert(!in.eof());
139 assert(tp == 2016_y/12/11);
140 }
141 {
142 // correct abbreviation
143 std::istringstream in{"Dec 11 2016"};
144 sys_days tp;
145 in >> parse("%h %d %Y", tp);
146 assert(!in.fail());
147 assert(!in.bad());
148 assert(!in.eof());
149 assert(tp == 2016_y/12/11);
150 }
151 {
152 // correct full name
153 std::istringstream in{"December 11 2016"};
154 sys_days tp;
155 in >> parse("%b %d %Y", tp);
156 assert(!in.fail());
157 assert(!in.bad());
158 assert(!in.eof());
159 assert(tp == 2016_y/12/11);
160 }
161 {
162 // correct full name
163 std::istringstream in{"December 11 2016"};
164 sys_days tp;
165 in >> parse("%B %d %Y", tp);
166 assert(!in.fail());
167 assert(!in.bad());
168 assert(!in.eof());
169 assert(tp == 2016_y/12/11);
170 }
171 {
172 // correct full name
173 std::istringstream in{"December 11 2016"};
174 sys_days tp;
175 in >> parse("%h %d %Y", tp);
176 assert(!in.fail());
177 assert(!in.bad());
178 assert(!in.eof());
179 assert(tp == 2016_y/12/11);
180 }
181 {
182 // incorrect abbreviation
183 std::istringstream in{"Dece 11 2016"};
184 sys_days tp;
185 in >> parse("%b %d %Y", tp);
186 assert( in.fail());
187 assert(!in.bad());
188 assert(!in.eof());
189 assert(tp == 1970_y/1/1);
190 }
191 }
192
193 void
test_c()194 test_c()
195 {
196 using namespace date;
197 using namespace std::chrono;
198 {
199 // correct abbreviation
200 std::istringstream in{"Sun Dec 11 14:02:43 2016"};
201 sys_seconds tp;
202 in >> parse("%c", tp);
203 assert(!in.fail());
204 assert(!in.bad());
205 assert(tp == sys_days{2016_y/12/11} + hours{14} + minutes{2} + seconds{43});
206 }
207 }
208
209 void
test_x()210 test_x()
211 {
212 using namespace date;
213 using namespace std::chrono;
214 {
215 // correct abbreviation
216 std::istringstream in{"12/11/16"};
217 sys_seconds tp;
218 in >> parse("%x", tp);
219 assert(!in.fail());
220 assert(!in.bad());
221 assert(tp == sys_days{2016_y/12/11});
222 }
223 }
224
225 void
test_X()226 test_X()
227 {
228 using namespace date;
229 using namespace std::chrono;
230 {
231 // correct abbreviation
232 std::istringstream in{"2016-12-11 14:02:43"};
233 sys_seconds tp;
234 in >> parse("%F %X", tp);
235 assert(!in.fail());
236 assert(!in.bad());
237 assert(tp == sys_days{2016_y/12/11} + hours{14} + minutes{2} + seconds{43});
238 }
239 }
240
241 void
test_C()242 test_C()
243 {
244 using namespace date;
245 using namespace std::chrono;
246 {
247 std::istringstream in{"20 16 12 11"};
248 sys_days tp;
249 in >> parse("%C %y %m %d", tp);
250 assert(!in.fail());
251 assert(!in.bad());
252 assert(tp == 2016_y/12/11);
253 }
254 {
255 std::istringstream in{"-2 1 12 11"};
256 sys_days tp;
257 in >> parse("%C %y %m %d", tp);
258 assert(!in.fail());
259 assert(!in.bad());
260 assert(tp == -101_y/12/11);
261 }
262 {
263 std::istringstream in{"-1 0 12 11"};
264 sys_days tp;
265 in >> parse("%C %y %m %d", tp);
266 assert(!in.fail());
267 assert(!in.bad());
268 assert(tp == -100_y/12/11);
269 }
270 {
271 std::istringstream in{"-1 99 12 11"};
272 sys_days tp;
273 in >> parse("%C %y %m %d", tp);
274 assert(!in.fail());
275 assert(!in.bad());
276 assert(tp == -99_y/12/11);
277 }
278 {
279 std::istringstream in{"-1 1 12 11"};
280 sys_days tp;
281 in >> parse("%C %y %m %d", tp);
282 assert(!in.fail());
283 assert(!in.bad());
284 assert(tp == -1_y/12/11);
285 }
286 {
287 std::istringstream in{"0 0 12 11"};
288 sys_days tp;
289 in >> parse("%C %y %m %d", tp);
290 assert(!in.fail());
291 assert(!in.bad());
292 assert(tp == 0_y/12/11);
293 }
294 {
295 std::istringstream in{"0 1 12 11"};
296 sys_days tp;
297 in >> parse("%C %y %m %d", tp);
298 assert(!in.fail());
299 assert(!in.bad());
300 assert(tp == 1_y/12/11);
301 }
302 {
303 std::istringstream in{"0 99 12 11"};
304 sys_days tp;
305 in >> parse("%C %y %m %d", tp);
306 assert(!in.fail());
307 assert(!in.bad());
308 assert(tp == 99_y/12/11);
309 }
310 {
311 std::istringstream in{"1 0 12 11"};
312 sys_days tp;
313 in >> parse("%C %y %m %d", tp);
314 assert(!in.fail());
315 assert(!in.bad());
316 assert(tp == 100_y/12/11);
317 }
318 {
319 std::istringstream in{"1 1 12 11"};
320 sys_days tp;
321 in >> parse("%C %y %m %d", tp);
322 assert(!in.fail());
323 assert(!in.bad());
324 assert(tp == 101_y/12/11);
325 }
326 }
327
328 void
test_d()329 test_d()
330 {
331 using namespace date;
332 using namespace std::chrono;
333 {
334 std::istringstream in{"2016 09 12"};
335 sys_days tp;
336 in >> parse("%Y %d %m", tp);
337 assert(!in.fail());
338 assert(!in.bad());
339 assert(tp == 2016_y/12/9);
340 }
341 {
342 std::istringstream in{"2016 09 12"};
343 sys_days tp;
344 in >> parse("%Y %e %m", tp);
345 assert(!in.fail());
346 assert(!in.bad());
347 assert(tp == 2016_y/12/9);
348 }
349 {
350 std::istringstream in{"2016 9 12"};
351 sys_days tp;
352 in >> parse("%Y %d %m", tp);
353 assert(!in.fail());
354 assert(!in.bad());
355 assert(tp == 2016_y/12/9);
356 }
357 {
358 std::istringstream in{"2016 9 12"};
359 sys_days tp;
360 in >> parse("%Y %e %m", tp);
361 assert(!in.fail());
362 assert(!in.bad());
363 assert(tp == 2016_y/12/9);
364 }
365 {
366 std::istringstream in{"2016 31 11"};
367 sys_days tp;
368 in >> parse("%Y %e %m", tp);
369 assert(in.fail());
370 }
371 }
372
373 void
test_D()374 test_D()
375 {
376 using namespace date;
377 using namespace std::chrono;
378 {
379 std::istringstream in{"12/11/16"};
380 sys_days tp;
381 in >> parse("%D", tp);
382 assert(!in.fail());
383 assert(!in.bad());
384 assert(tp == 2016_y/12/11);
385 }
386 }
387
388 void
test_F()389 test_F()
390 {
391 using namespace date;
392 using namespace std::chrono;
393 {
394 std::istringstream in{"2016-12-13"};
395 sys_days tp;
396 in >> parse("%F", tp);
397 assert(!in.fail());
398 assert(!in.bad());
399 assert(tp == 2016_y/12/13);
400 }
401 {
402 std::istringstream in{"2016-12-13"};
403 year_month_day tp;
404 in >> parse("%F", tp);
405 assert(!in.fail());
406 assert(!in.bad());
407 assert(tp == 2016_y/12/13);
408 }
409 }
410
411 void
test_H()412 test_H()
413 {
414 using namespace date;
415 using namespace std::chrono;
416 {
417 std::istringstream in{"2016-12-11 15"};
418 sys_time<hours> tp;
419 in >> parse("%F %H", tp);
420 assert(!in.fail());
421 assert(!in.bad());
422 assert(tp == sys_days{2016_y/12/11} + hours{15});
423 }
424 {
425 std::istringstream in{"2016-12-11 24"};
426 sys_time<hours> tp;
427 in >> parse("%F %H", tp);
428 assert(in.fail());
429 }
430 }
431
432 void
test_Ip()433 test_Ip()
434 {
435 using namespace date;
436 using namespace std::chrono;
437 {
438 std::istringstream in{"2016-12-11 1 pm"};
439 sys_time<hours> tp;
440 in >> parse("%F %I %p", tp);
441 assert(!in.fail());
442 assert(!in.bad());
443 assert(tp == sys_days{2016_y/12/11} + hours{13});
444 }
445 {
446 std::istringstream in{"2016-12-11 1 am"};
447 sys_time<hours> tp;
448 in >> parse("%F %I %p", tp);
449 assert(!in.fail());
450 assert(!in.bad());
451 assert(tp == sys_days{2016_y/12/11} + hours{1});
452 }
453 {
454 std::istringstream in{"2016-12-11 13 am"};
455 sys_time<hours> tp;
456 in >> parse("%F %I %p", tp);
457 assert(in.fail());
458 }
459 }
460
461 void
test_j()462 test_j()
463 {
464 using namespace date;
465 using namespace std::chrono;
466 {
467 std::istringstream in{"2016 361"};
468 sys_days tp;
469 in >> parse("%Y %j", tp);
470 assert(!in.fail());
471 assert(!in.bad());
472 assert(tp == sys_days{2016_y/12/26});
473 }
474 }
475
476 void
test_m()477 test_m()
478 {
479 using namespace date;
480 using namespace std::chrono;
481 {
482 std::istringstream in{"2016 12 09"};
483 sys_days tp;
484 in >> parse("%Y %d %m", tp);
485 assert(!in.fail());
486 assert(!in.bad());
487 assert(tp == 2016_y/9/12);
488 }
489 {
490 std::istringstream in{"2016 12 9"};
491 sys_days tp;
492 in >> parse("%Y %d %m", tp);
493 assert(!in.fail());
494 assert(!in.bad());
495 assert(tp == 2016_y/9/12);
496 }
497 {
498 std::istringstream in{"2016 12 13"};
499 sys_days tp;
500 in >> parse("%Y %d %m", tp);
501 assert(in.fail());
502 }
503 }
504
505 void
test_M()506 test_M()
507 {
508 using namespace date;
509 using namespace std::chrono;
510 {
511 std::istringstream in{"2016-12-11 15"};
512 sys_time<minutes> tp;
513 in >> parse("%F %M", tp);
514 assert(!in.fail());
515 assert(!in.bad());
516 assert(tp == sys_days{2016_y/12/11} + minutes{15});
517 }
518 {
519 std::istringstream in{"2016-12-11 65"};
520 sys_time<minutes> tp;
521 in >> parse("%F %M", tp);
522 assert(in.fail());
523 }
524 }
525
526 void
test_S()527 test_S()
528 {
529 using namespace date;
530 using namespace std::chrono;
531 {
532 std::istringstream in{"2016-12-11 15"};
533 sys_seconds tp;
534 in >> parse("%F %S", tp);
535 assert(!in.fail());
536 assert(!in.bad());
537 assert(tp == sys_days{2016_y/12/11} + seconds{15});
538 }
539 {
540 std::istringstream in{"2016-12-11 15.001"};
541 sys_time<milliseconds> tp;
542 in >> parse("%F %S", tp);
543 assert(!in.fail());
544 assert(!in.bad());
545 assert(tp == sys_days{2016_y/12/11} + seconds{15} + milliseconds{1});
546 }
547 {
548 std::istringstream in{"2016-12-11 60"};
549 sys_seconds tp;
550 in >> parse("%F %S", tp);
551 assert(in.fail());
552 }
553 }
554
555 void
test_T()556 test_T()
557 {
558 using namespace date;
559 using namespace std::chrono;
560 {
561 std::istringstream in{"2016-12-11 15:43:22"};
562 sys_seconds tp;
563 in >> parse("%F %T", tp);
564 assert(!in.fail());
565 assert(!in.bad());
566 assert(tp == sys_days{2016_y/12/11} + hours{15} + minutes{43} + seconds{22});
567 }
568 {
569 std::istringstream in{"2016-12-11 15:43:22.001"};
570 sys_time<milliseconds> tp;
571 in >> parse("%F %T", tp);
572 assert(!in.fail());
573 assert(!in.bad());
574 assert(tp == sys_days{2016_y/12/11} + hours{15} + minutes{43} + seconds{22} +
575 milliseconds{1});
576 }
577 {
578 std::istringstream in{"2016-12-11 15:43:22"};
579 sys_time<milliseconds> tp;
580 in >> parse("%F %T", tp);
581 assert(!in.fail());
582 assert(!in.bad());
583 assert(tp == sys_days{2016_y/12/11} + hours{15} + minutes{43} + seconds{22});
584 }
585 {
586 std::istringstream in{"15:43:22.001"};
587 milliseconds d;
588 in >> parse("%T", d);
589 assert(!in.fail());
590 assert(!in.bad());
591 assert(d == hours{15} + minutes{43} + seconds{22} + milliseconds{1});
592 }
593 {
594 std::istringstream in{"2016-12-11 24:43:22"};
595 sys_seconds tp;
596 in >> parse("%F %T", tp);
597 assert(in.fail());
598 }
599 {
600 std::istringstream in{"2016-12-11 15:60:22"};
601 sys_seconds tp;
602 in >> parse("%F %T", tp);
603 assert(in.fail());
604 }
605 {
606 std::istringstream in{"2016-12-11 15:43:60"};
607 sys_seconds tp;
608 in >> parse("%F %T", tp);
609 assert(in.fail());
610 }
611 }
612
613 void
test_p()614 test_p()
615 {
616 using namespace date;
617 using namespace std::chrono;
618 {
619 std::istringstream in{"2016-12-11 11pm"};
620 sys_time<hours> tp;
621 in >> parse("%F %I%p", tp);
622 assert(!in.fail());
623 assert(!in.bad());
624 assert(tp == sys_days{2016_y/12/11} + hours{23});
625 }
626 }
627
628 void
test_r()629 test_r()
630 {
631 using namespace date;
632 using namespace std::chrono;
633 {
634 std::istringstream in{"2016-12-26 1:36:57 pm"};
635 sys_seconds tp;
636 in >> parse("%F %r", tp);
637 assert(!in.fail());
638 assert(!in.bad());
639 assert(tp == sys_days{2016_y/12/26} + hours{13} + minutes{36} + seconds{57});
640 }
641 }
642
643 void
test_R()644 test_R()
645 {
646 using namespace date;
647 using namespace std::chrono;
648 {
649 std::istringstream in{"2016-12-26 13:36"};
650 sys_seconds tp;
651 in >> parse("%F %R", tp);
652 assert(!in.fail());
653 assert(!in.bad());
654 assert(tp == sys_days{2016_y/12/26} + hours{13} + minutes{36});
655 }
656 }
657
658 void
test_U()659 test_U()
660 {
661 using namespace date;
662 using namespace std::chrono;
663 {
664 std::istringstream in{"2016-52-1"};
665 sys_days tp;
666 in >> parse("%Y-%U-%w", tp);
667 assert(!in.fail());
668 assert(!in.bad());
669 assert(tp == sys_days{2016_y/12/26});
670 }
671 }
672
673 void
test_W()674 test_W()
675 {
676 using namespace date;
677 using namespace std::chrono;
678 {
679 std::istringstream in{"2016-52-1"};
680 sys_days tp;
681 in >> parse("%Y-%W-%w", tp);
682 assert(!in.fail());
683 assert(!in.bad());
684 assert(tp == sys_days{2016_y/12/26});
685 }
686 }
687
688 void
test_GV()689 test_GV()
690 {
691 using namespace date;
692 using namespace std::chrono;
693 {
694 std::istringstream in{"2016-52-1"};
695 sys_days tp;
696 in >> parse("%G-%V-%w", tp);
697 assert(!in.fail());
698 assert(!in.bad());
699 assert(tp == sys_days{2016_y/12/26});
700 }
701 {
702 std::istringstream in{"2016-52-1"};
703 sys_days tp;
704 in >> parse("%G-%V-%w", tp);
705 assert(!in.fail());
706 assert(!in.bad());
707 assert(tp == sys_days{2016_y/12/26});
708 }
709 {
710 std::istringstream in{"20 16-52-1"};
711 sys_days tp;
712 in >> parse("%C %g-%V-%w", tp);
713 assert(!in.fail());
714 assert(!in.bad());
715 assert(tp == sys_days{2016_y/12/26});
716 }
717 {
718 std::istringstream in{"20 16-52-1"};
719 sys_days tp;
720 in >> parse("%C %g-%V-%u", tp);
721 assert(!in.fail());
722 assert(!in.bad());
723 assert(tp == sys_days{2016_y/12/26});
724 }
725 }
726
727 void
test_z()728 test_z()
729 {
730 using namespace date;
731 using namespace std::chrono;
732 {
733 std::istringstream in{"2016-12-26 15:53:22 -0500"};
734 sys_seconds tp;
735 in >> parse("%F %T %z", tp);
736 assert(!in.fail());
737 assert(!in.bad());
738 assert(tp == sys_days{2016_y/12/26} + hours{20} + minutes{53} + seconds{22});
739 }
740 {
741 std::istringstream in{"2016-12-26 15:53:22 -0500"};
742 local_seconds tp;
743 in >> parse("%F %T %z", tp);
744 assert(!in.fail());
745 assert(!in.bad());
746 assert(tp == local_days{2016_y/12/26} + hours{15} + minutes{53} + seconds{22});
747 }
748 {
749 std::istringstream in{"2016-12-26 15:53:22 -05:00"};
750 sys_seconds tp;
751 in >> parse("%F %T %Ez", tp);
752 assert(!in.fail());
753 assert(!in.bad());
754 assert(tp == sys_days{2016_y/12/26} + hours{20} + minutes{53} + seconds{22});
755 }
756 }
757
758 void
test_Z()759 test_Z()
760 {
761 using namespace date;
762 using namespace std::chrono;
763 {
764 std::string a;
765 std::istringstream in{"2016-12-26 15:53:22 word"};
766 local_seconds tp;
767 in >> parse("%F %T %Z", tp, a);
768 assert(!in.fail());
769 assert(!in.bad());
770 assert(tp == local_days{2016_y/12/26} + hours{15} + minutes{53} + seconds{22});
771 assert(a == "word");
772 }
773 }
774
775 void
test_trailing_Z()776 test_trailing_Z()
777 {
778 std::string format = "%FT%TZ";
779 std::string datetime = "2017-2-15T13:13:13";
780 std::istringstream input(datetime);
781 date::sys_seconds tp;
782 input >> date::parse(format, tp);
783 assert(input.fail());
784 assert(input.eof());
785 }
786
787 void
test_leading_ws()788 test_leading_ws()
789 {
790 using namespace std;
791 using namespace date;
792 istringstream in{"05/04/17 5/4/17"};
793 year_month_day d1, d2;
794 in >> parse("%D", d1) >> parse("%n%D", d2);
795 assert(d1 == may/4/2017);
796 assert(d2 == may/4/2017);
797 }
798
799 void
test_space()800 test_space()
801 {
802 using namespace std;
803 using namespace date;
804 {
805 istringstream in{"05/04/17"};
806 year_month_day d1;
807 in >> parse(" %D", d1);
808 assert(d1 == may/4/2017);
809 }
810 {
811 istringstream in{" 05/04/17"};
812 year_month_day d1;
813 in >> parse(" %D", d1);
814 assert(d1 == may/4/2017);
815 }
816 {
817 istringstream in{" 05/04/17"};
818 year_month_day d1;
819 in >> parse(" %D", d1);
820 assert(d1 == may/4/2017);
821 }
822 }
823
824 void
test_n()825 test_n()
826 {
827 using namespace std;
828 using namespace date;
829 {
830 istringstream in{"05/04/17"};
831 year_month_day d1;
832 in >> parse("%n%D", d1);
833 assert(in.fail());
834 }
835 {
836 istringstream in{" 05/04/17"};
837 year_month_day d1;
838 in >> parse("%n%D", d1);
839 assert(d1 == may/4/2017);
840 }
841 {
842 istringstream in{" 05/04/17"};
843 year_month_day d1;
844 in >> parse("%n%D", d1);
845 assert(in.fail());
846 }
847 }
848
849 void
test_t()850 test_t()
851 {
852 using namespace std;
853 using namespace date;
854 {
855 istringstream in{"05/04/17"};
856 year_month_day d1;
857 in >> parse("%t%D", d1);
858 assert(d1 == may/4/2017);
859 }
860 {
861 istringstream in{" 05/04/17"};
862 year_month_day d1;
863 in >> parse("%t%D", d1);
864 assert(d1 == may/4/2017);
865 }
866 {
867 istringstream in{" 05/04/17"};
868 year_month_day d1;
869 in >> parse("%t%D", d1);
870 assert(in.fail());
871 }
872 }
873
874 int
main()875 main()
876 {
877 test_a();
878 test_b();
879 test_c();
880 test_C();
881 test_d();
882 test_D();
883 test_F();
884 test_H();
885 test_Ip();
886 test_j();
887 test_m();
888 test_M();
889 test_p();
890 test_r();
891 test_R();
892 test_S();
893 test_T();
894 test_U();
895 test_W();
896 test_GV();
897 test_x();
898 test_X();
899 test_z();
900 test_Z();
901 test_trailing_Z();
902 test_leading_ws();
903 test_space();
904 test_n();
905 test_t();
906 }
907