Ne.app NeANT
The Ne.app NeANT User module of the NeANT distribution.
22.locale.num.get.cpp
Go to the documentation of this file.
1
29// Usage:
30// #define NO_GET_${T}, where ${T} is the name of the arithmetic
31// type the num_get<charT>::get(..., ${T}&) overload, to disable
32// the corresponding test
33//
34// #define NO_GET_INTEGER to disable tests of all integer types
35// #define NO_GET_FLOATING to disable testst of all floating types
36// #define NO_GET_ERRNO to disable errno tests
37
38
39#ifdef NO_GET_INTEGER
40# define NO_GET_BOOL
41// no NO_GET_USHRT
42# define NO_GET_SHRT
43// no NO_GET_UINT
44# define NO_GET_INT
45# define NO_GET_ULONG
46# define NO_GET_LONG
47# define NO_GET_ULLONG
48# define NO_GET_LLONG
49#endif // NO_GET_INTEGER
50
51#ifdef NO_GET_FLOATING
52# define NO_GET_FLT
53# define NO_GET_DBL
54# define NO_GET_LDBL
55#endif // NO_GET_FLOATING
56
57
59#include <cstddef> // for std::size_t, std::ptrdiff_t
60#include <cfloat> // FLT_MAX, FLT_MIN, etc.
61#include <climits> // INT_MAX, INT_MIN, etc.
62#include <clocale> // for localeconv(), setlocale()
63#include <cstdio> // for sprintf(), sscanf()
64#include <cstring> // for memset(), strerror(), strlen()
65#include <cerrno> // for ERANGE, errno
66
67#include <ios>
68#include <limits>
69#include <locale>
70
71#include <rw_alg_test.h> // for InputIter
72#include <rw_any.h> // for rw_any_t
73#include <rw_cmdopt.h> // for rw_enabled()
74#include <rw_driver.h> // for rw_test(), ...
75#include <rw_char.h> // for rw_widen()
76#include <rw_locale.h> // for rw_locales()
77#include <rw_valcmp.h> // for rw_equal()
78
79
81// set by the command line option handler in response to:
82static int rw_opt_no_errno = 0; // --no-errno
83static int rw_opt_no_grouping = 0; // --no-grouping
84static int rw_opt_no_widen = 0; // --no-widen
85static int rw_opt_no_uflow = 0; // --no-underflow
86
87
89// replacement ctype facet
90
91template <class charT>
92struct Ctype: std::ctype<charT>
93{
94 typedef std::ctype<charT> Base;
95
96 typedef typename Base::char_type char_type;
97
98 static int n_widen_;
99
100 Ctype (): Base (0, 0, 1) { }
101
102 virtual char_type do_widen (char c) const {
103 ++n_widen_;
104
105 switch (c) {
106 case '0': c = '9'; break;
107 case '1': c = '8'; break;
108 case '2': c = '7'; break;
109 case '3': c = '6'; break;
110 case '4': c = '5'; break;
111 case '5': c = '4'; break;
112 case '6': c = '3'; break;
113 case '7': c = '2'; break;
114 case '8': c = '1'; break;
115 case '9': c = '0'; break;
116 default: break;
117 }
118
119 return char_type (c);
120 }
121
122 virtual const char_type*
123 do_widen (const char *lo, const char *hi, char_type *dst) const {
124 return Base::do_widen (lo, hi, dst);
125 }
126};
127
128template <class charT>
129int Ctype<charT>::n_widen_;
130
131
132
134struct PunctData
135{
136 static char decimal_point_;
137 static char thousands_sep_;
138 static const char* grouping_;
139 static const char* falsename_;
140 static const char* truename_;
141
142 // number of facet objects in existence
143 static int n_objs_;
144
145 // number of calls to do_thousands_sep()
146 static int n_thousands_sep_;
147
148 static void set_names (const char *fname, const char *tname) {
149 falsename_ = fname;
150 truename_ = tname;
151 }
152};
153
154char PunctData::decimal_point_ = '.';
155char PunctData::thousands_sep_ = ',';
156const char* PunctData::grouping_ = "";
157const char* PunctData::falsename_ = 0;
158const char* PunctData::truename_ = 0;
159
160int PunctData::n_thousands_sep_;
161int PunctData::n_objs_;
162
163
164// replacement numpunct facet
165template <class charT>
166struct Punct: PunctData, std::numpunct<charT>
167{
168 typedef unsigned char UChar;
169 typedef typename std::numpunct<charT>::char_type char_type;
170 typedef typename std::numpunct<charT>::string_type string_type;
171
172 Punct (std::size_t ref = 0)
173 : std::numpunct<charT>(ref) {
174 ++n_objs_;
175 }
176
177 ~Punct () {
178 --n_objs_;
179 }
180
181 virtual char_type do_decimal_point () const {
182 return char_type (UChar (decimal_point_));
183 }
184
185 virtual std::string do_grouping () const {
186 return grouping_;
187 }
188
189 virtual char_type do_thousands_sep () const {
190 ++n_thousands_sep_;
191 return char_type (UChar (thousands_sep_));
192 }
193
194 virtual string_type do_truename () const {
195 char_type name [40];
196 return rw_widen (name, truename_, sizeof name / sizeof *name - 1);
197 }
198
199 virtual string_type do_falsename () const {
200 char_type name [40];
201 return rw_widen (name, falsename_, sizeof name / sizeof *name - 1);
202 }
203};
204
205
207template <class charT, class Traits>
208struct Ios: std::basic_ios<charT, Traits>
209{
210 Ios () { this->init (0); }
211};
212
213template <class charT, class Traits>
214struct Streambuf: std::basic_streambuf<charT, Traits>
215{
216 typedef std::basic_streambuf<charT, Traits> Base;
217
218 Streambuf (const charT *gbeg, const charT *gend)
219 : Base () {
220 this->setg (_RWSTD_CONST_CAST (charT*, gbeg),
221 _RWSTD_CONST_CAST (charT*, gbeg),
222 _RWSTD_CONST_CAST (charT*, gend));
223 }
224
225 std::ptrdiff_t gptr_off () const {
226 return this->gptr () - this->eback ();
227 }
228};
229
230template <class charT, class InputIterator>
231struct NumGet: std::num_get<charT, InputIterator>
232{
233 NumGet () { /* working around a bug in older versions of EDG eccp */ }
234};
235
236
238// if non-zero expected to point to a maximum valid value
239// of type T that's being tested below (used for floating
240// point ranges)
241// on function return, the pointed to value is overwritten
242// with the actual extracted value
243void *pmax = 0;
244
245
246enum IterType { iter_pointer, iter_istreambuf, iter_input };
247
248template <class charT, class nativeT>
249int do_test (int lineno, // line number
250 charT* /* dummy */,
251 const char *cname, // name of character type
252 IterType itype, // type of input iterator
253 const char *iname, // name of input iterator
254 nativeT val, // value expected to be extracted
255 const char *str, // input sequence
256 int eat_expect = -1, // number of consumed characters
257 int flags = 0, // initial set of flags
258 int err_expect = -1, // expected iostate
259 const char *grouping = "") // optional grouping string
260{
261 typedef std::char_traits<charT> Traits;
262
263 static const char* const tname = rw_any_t (nativeT ()).type_name ();
264
265 if (!rw_enabled (lineno /*, cname, tname */)) {
266 rw_note (0, __FILE__, __LINE__, "test on line %d disabled", lineno);
267 return 0;
268 }
269
270 if (*grouping && '%' != *grouping && rw_opt_no_grouping) {
271 // if grouping is not empty (and doesn't start with '%')
272 // check the state of the --no-grouping command line
273 // option before proceeding with the test case
274 rw_note (0, __FILE__, __LINE__,
275 "grouping test on line %d disabled", lineno);
276 return 0;
277 }
278
279 // create a distinct punctuation facet for each iteration to make sure
280 // any data cached in between successive calls to the facet's public
281 // member functions are flushed
282 const Punct<charT> pun (1);
283
284 Ios<charT, Traits> io;
285 std::ios_base &iob = io;
286
287 io.imbue (std::locale (io.getloc (),
288 (const std::numpunct<charT>*)&pun));
289
290 io.flags (std::ios_base::fmtflags (flags));
291 pun.grouping_ = grouping;
292
293 // initialize x to a value other than the expected one except when
294 // get() is expected to fail (in which case the value isn't supposed
295 // to be modified, except when the failure is caused by an invalid
296 // grouping)
297 // doing so exercises the requirement that the get() functions not
298 // modify their argument on failure (except when the failure is due
299 // to bad grouping)
300 nativeT x =
301 err_expect & std::ios::failbit || *grouping ? val : nativeT (!val);
302
303 // large buffer to widen `str' to
304 static charT wstr_buf [32767];
305
306 const charT *pnext; // iterator to the next character where to parse
307
308 // narrow character buffer
309 static char nbuf [sizeof wstr_buf / sizeof *wstr_buf];
310
311 // if the string `str' starts with a '%', treat it as a printf()
312 // format specifier and take the string produced by sprintf()
313 // below as the expected result, otherwise treat it literally
314 // as the expected result
315 if ('%' == *str && 0 < std::sprintf (nbuf, str, val))
316 str = nbuf;
317
318 pnext = rw_widen (wstr_buf, str);
319
320 std::ios_base::iostate err = std::ios_base::goodbit;
321
322 const charT *plast = pnext + std::char_traits<charT>::length (pnext);
323
324 std::ptrdiff_t consumed;
325
326 switch (itype) {
327 case iter_pointer: {
328 NumGet<charT, const charT*> ng;
329 plast = ng.get (pnext, plast, iob, err, x);
330 consumed = plast - pnext;
331 break;
332 }
333
334 case iter_istreambuf: {
335 typedef std::istreambuf_iterator<charT, Traits> IStreambufIter;
336
337 Streambuf<charT, Traits> sb (pnext, plast);
338
339 IStreambufIter sbitnext (&sb);
340 IStreambufIter sbitlast;
341
342 NumGet<charT, IStreambufIter> ng;
343 sbitlast = ng.get (sbitnext, sbitlast, iob, err, x);
344 consumed = sb.gptr_off ();
345 break;
346 }
347
348 case iter_input: {
349 typedef InputIter<charT> UserIter;
350
351 UserIter uitnext (pnext, pnext, plast);
352 UserIter uitlast (plast, pnext, plast);
353
354 NumGet<charT, UserIter> ng;
355 uitlast = ng.get (uitnext, uitlast, iob, err, x);
356 consumed = uitlast.cur_ - uitnext.cur_;
357 break;
358 }
359
360 }
361
362 // do not test the number of extracted characters
363 // if (eat_expect == -1) holds
364 int success = -1 == eat_expect || consumed == eat_expect;
365
366 int nfailures = !success;
367
368 rw_assert (success, 0, lineno,
369 "line %d: num_get<%s, %s>::get (%#s, ..., %s&); "
370 "fmtflags = %{If}; "
371 "%{?}grouping = %#s; %{;}"
372 "ate %td, expected %d",
373 __LINE__, cname, iname, str, tname,
374 flags,
375 *grouping && '%' != *grouping, grouping,
376 consumed, eat_expect);
377
378 const nativeT val_max = pmax ? *(nativeT*)pmax : val;
379 // if pmax is non-zero it points to the upper bound of the range
380 // that the extracted value can be in
381 success =
382 err == err_expect
383 && (rw_equal (x, val) || (val <= x && x <= val_max));
384
385 nfailures += !success;
386
387 rw_assert (success, 0, lineno,
388 "line %d: num_get<%s, %s>::get (%{*Ac}, ..., %s&); "
389 "fmtflags = %{If}; "
390 "%{?}grouping = %#s; %{;}"
391 "got %s (%{Is}); "
392 "expected %s%{?} <= %s %{;} "
393 "(%{Is})",
394 __LINE__, cname, iname, int (sizeof *str), str, tname,
395 flags,
396 *grouping && '%' != *grouping, grouping,
397 TOSTR (x), err,
398 TOSTR (val), 0 != pmax, TOSTR (val_max),
399 err_expect);
400
401 if (pmax) {
402 // store the extracted value into the pointed to location
403 *(nativeT*)pmax = x;
404 }
405
406 if (*grouping && '%' == *grouping) {
407
408 // if the `grouping' string starts with a '%', treat it as
409 // a scanf() format specifier and use sscanf() to parse the
410 // tested string `str'; then compare for equality the number
411 // parsed with sscanf() with that parsed with num_get::get()
412 const char* const scanspec = grouping;
413
414 nativeT y = nativeT ();
415
416 const int n = std::sscanf (str, scanspec, &y);
417
418 success =
419 !( (err & std::ios::failbit && n > 0)
420 || (!(err & std::ios::failbit) && 1 != n)
421 || !rw_equal (x, y));
422
423 nfailures += !success;
424
425 rw_assert (success, 0, lineno,
426 "line %d: num_get<%s, %s>::get (%#s, ..., %s&); "
427 "got %s, but scanf (..., \"%s\", ...) extracted %s "
428 "and returned %d; fmtflags = %{If}, iostate = %{Is}",
429 __LINE__, cname, iname, str, tname,
430 TOSTR (x), scanspec, TOSTR (y),
431 n, flags, err);
432 }
433
434 return nfailures;
435}
436
437
439enum CharType { narrow_char, wide_char, user_char };
440
441template <class nativeT>
442int do_test (int lineno, // line number
443 CharType ctype, // character type
444 const char *cname, // name of character type
445 IterType itype, // iterator type
446 const char *iname, // name of iterator type
447 nativeT val, // value expected to be extracted
448 const char *str, // input sequence
449 int eat_expect = -1, // number of consumed characters
450 int flags = 0, // initial set of flags
451 int err_expect = -1, // expected iostate
452 const char *grouping = "") // optional grouping string
453{
454 switch (ctype) {
455 case narrow_char:
456 return do_test (lineno, (char*)0, cname, itype, iname,
457 val, str, eat_expect, flags, err_expect, grouping);
458 case wide_char:
459 return do_test (lineno, (wchar_t*)0, cname, itype, iname,
460 val, str, eat_expect, flags, err_expect, grouping);
461 case user_char:
462 break;
463#if 0 // disabled
464 return do_test (lineno, (UserChar*)0, cname, itype, iname,
465 val, str, eat_expect, flags, err_expect, grouping);
466#endif // disabled
467 }
468
469 return 1;
470}
471
472
474// for convenience
475#define boolalpha std::ios_base::boolalpha
476#define dec std::ios_base::dec
477#define fixed std::ios_base::fixed
478#define hex std::ios_base::hex
479#define internal std::ios_base::internal
480#define left std::ios_base::left
481#define oct std::ios_base::oct
482#define right std::ios_base::right
483#define scientific std::ios_base::scientific
484#define showbase std::ios_base::showbase
485#define showpoint std::ios_base::showpoint
486#define showpos std::ios_base::showpos
487#define skipws std::ios_base::skipws
488#define unitbuf std::ios_base::unitbuf
489#define uppercase std::ios_base::uppercase
490#define bin std::ios_base::bin
491#define adjustfield std::ios_base::adjustfield
492#define basefield std::ios_base::basefield
493#define floatfield std::ios_base::floatfield
494#define nolock std::ios_base::nolock
495#define nolockbuf std::ios_base::nolockbuf
496
497#define Bad std::ios_base::badbit
498#define Eof std::ios_base::eofbit
499#define Fail std::ios_base::failbit
500#define Good std::ios_base::goodbit
501
502
504#define TEST do_test
505#define T __LINE__, ctype, cname, itype, iname
506
507
508template <class numT>
509void test_errno (CharType ctype, const char *cname,
510 IterType itype, const char *iname, numT)
511{
512 // verify that errno doesn't change after, or affects
513 // a successful extraction
514
515 const char* const tname = rw_any_t (numT ()).type_name ();
516
517 rw_info (0, 0, 0, "std::num_get<%s, %s>::get (..., %s&) and errno",
518 cname, iname, tname);
519
520 const int errnos[] = {
521 ERANGE, -4, -3, -2, -1, 0, 1, 2, 3, 4,
522 Bad, Eof, Fail, Bad | Eof, Bad | Fail, Eof | Fail, Bad | Eof | Fail
523 };
524
525 int i;
526
527#define TEST_ERRNO(val) \
528 for (i = 0; i != sizeof errnos / sizeof *errnos; ++i) { \
529 errno = errnos [i]; \
530 TEST (T, numT (val), _RWSTD_STR (val), \
531 int (sizeof (_RWSTD_STR (val))) -1, 0, Eof); \
532 rw_assert (errnos [i] == errno, 0, __LINE__, \
533 "%d. errno unexpectedly changed from %d to %d", \
534 i, errnos [i], errno); \
535 } (void)0
536
537 // prevent warnings when numT is unsigned
538 numT zero = numT ();
539 numT minus_one = numT (~0);
540
541 TEST_ERRNO (0);
542 TEST_ERRNO (1);
543 TEST_ERRNO (12);
544 TEST_ERRNO (123);
545 TEST_ERRNO (1234);
546 TEST_ERRNO (12345);
547 TEST_ERRNO (12346);
548 TEST_ERRNO (12347);
549 TEST_ERRNO (12348);
550 TEST_ERRNO (12349);
551
552 if (minus_one > zero)
553 return;
554
555 TEST_ERRNO (-1);
556 TEST_ERRNO (-12);
557 TEST_ERRNO (-123);
558 TEST_ERRNO (-1234);
559 TEST_ERRNO (-12345);
560 TEST_ERRNO (-12346);
561 TEST_ERRNO (-12347);
562 TEST_ERRNO (-12348);
563 TEST_ERRNO (-12349);
564}
565
566
568static void
569test_bool (CharType ctype, const char *cname,
570 IterType itype, const char *iname)
571{
572#ifndef NO_GET_BOOL
573
574 const char* const tname = "bool";
575
576 rw_info (0, 0, 0, "std::num_get<%s, %s>::get (..., %s&)",
577 cname, iname, tname);
578
579 PunctData::decimal_point_ = '.';
580 PunctData::thousands_sep_ = ',';
581 PunctData::set_names ("false", "true");
582
583 // lwg issue 17: special treatment for bool:
584
585 // The in iterator is always left pointing one position beyond
586 // the last character successfully matched. If val is set, then
587 // err is set to str.good; or to str.eof if, when seeking
588 // another character to match, it is found that (in==end). If
589 // val is not set, then err is set to str.fail; or to
590 // (str.fail|str.eof) if the reason for the failure was
591 // that (in==end). [Example: for targets true:"a" and false:"abb",
592 // the input sequence "a" yields val==true and err==str.eof;
593 // the input sequence "abc" yields err=str.fail, with in ending
594 // at the 'c' element. For targets true:"1" and false:"0", the
595 // input sequence "1" yields val==true and err=str.good. For
596 // empty targets (""), any input sequence yields err==str.fail.
597 // --end example]
598
599 // arguments are passed in the following order:
600 //
601 // [v] (out) N/A expected value
602 // [s] (in) N/A character string to parse or a printf
603 // specifier to format [v] with
604 // [n] (out) -1 number of characters consumed
605 // [f] (in) 0 iosflags
606 // [e] (in|out) -1 expected iostate after parsing
607 // [g] (in) "" grouping string, or a scanf
608 // specifier to parse [s] with
609
610 // bool, numeric parsing
611 TEST (T, false, "0", 1, 0, Eof);
612 TEST (T, true, "1", 1, 0, Eof);
613 TEST (T, false, "2", 1, 0, Fail | Eof);
614
615 TEST (T, false, "0x0", 3, 0, Eof);
616 TEST (T, true, "0x1", 3, 0, Eof);
617 TEST (T, true, "0x01", 4, 0, Eof);
618 TEST (T, false, "0x20", 4, 0, Fail | Eof);
619 TEST (T, false, "", 0, 0, Fail | Eof);
620
621 TEST (T, false, "0+", 1, 0, Good);
622 TEST (T, true, "1+", 1, 0, Good);
623 TEST (T, false, "2+", 1, 0, Fail);
624
625 TEST (T, false, "0-", 1, 0, Good);
626 TEST (T, true, "1-", 1, 0, Good);
627 TEST (T, false, "2-", 1, 0, Fail);
628
629 TEST (T, false, "00", 2, 0, Eof);
630 TEST (T, true, "01", 2, 0, Eof);
631 TEST (T, false, "02", 2, 0, Fail | Eof);
632 TEST (T, false, "012", 3, 0, Fail | Eof);
633
634 TEST (T, false, "+0 ", 2, 0, Good);
635 TEST (T, true, "+1 ", 2, 0, Good);
636 TEST (T, false, "+2 ", 2, 0, Fail);
637 TEST (T, false, "-0 ", 2, 0, Good);
638 TEST (T, false, "-1 ", 2, 0, Fail);
639 TEST (T, false, "-2 ", 2, 0, Fail);
640 TEST (T, false, "++1", 1, 0, Fail);
641 TEST (T, false, "+-1", 1, 0, Fail);
642 TEST (T, false, "-+1", 1, 0, Fail);
643 TEST (T, false, "--1", 1, 0, Fail);
644
645 TEST (T, false, "+000+", 4, 0, Good);
646 TEST (T, false, "+000-", 4, 0, Good);
647 TEST (T, true, "+001-", 4, 0, Good);
648 TEST (T, false, "+002", 4, 0, Eof | Fail);
649 TEST (T, false, "-000-", 4, 0, Good);
650 TEST (T, false, "-000+", 4, 0, Good);
651 TEST (T, false, "-001- ", 4, 0, Fail);
652 TEST (T, false, "-002- ", 4, 0, Fail);
653 TEST (T, false, "-012- ", 4, 0, Fail);
654
655 TEST (T, false, "0.0", 1, 0, Good);
656 TEST (T, true, "1.1", 1, 0, Good);
657
658 TEST (T, false, "-0.00 ", 2, 0, Good);
659 TEST (T, false, "+00.01", 3, 0, Good);
660 TEST (T, true, "+1.12.", 2, 0, Good);
661
662 // bool, numeric parsing with grouping
663
664 PunctData::thousands_sep_ = ';';
665
666 TEST (T, false, "0;0", 3, 0, Eof, "\1");
667 TEST (T, false, "+0;0", 4, 0, Eof, "\1");
668 TEST (T, false, "-0;0", 4, 0, Eof, "\1");
669 TEST (T, false, "0;0;0", 5, 0, Eof, "\1");
670 TEST (T, false, "0;0;0;0", 7, 0, Eof, "\1");
671 TEST (T, true, "01", 2, 0, Eof, "\2");
672 TEST (T, true, "0;01", 4, 0, Eof, "\2");
673 TEST (T, true, "00;01", 5, 0, Eof, "\2");
674 TEST (T, true, "0;01", 4, 0, Eof, "\2");
675 TEST (T, false, "00;0", 4, 0, Eof, "\1\2");
676 TEST (T, false, "0;00;0", 6, 0, Eof, "\1\2\3");
677 TEST (T, false, "000;00;0", 8, 0, Eof, "\1\2\3");
678 TEST (T, false, "0;000;00;0", 10, 0, Eof, "\1\2\3");
679 TEST (T, true, "00;1", 4, 0, Eof, "\1\2");
680 TEST (T, true, "0;00;1", 6, 0, Eof, "\1\2\3");
681 TEST (T, true, "000;00;1", 8, 0, Eof, "\1\2\3");
682 TEST (T, true, "0;000;00;1", 10, 0, Eof, "\1\2\3");
683 TEST (T, true, "+0;000;00;1", 11, 0, Eof, "\1\2\3");
684
685 // bad groups, invalid input: do not store value, set failbit
686 // the format of integers in 22.2.3.1, p2 is:
687 //
688 // integer ::= [sign] units
689 // sign ::= plusminus [whitespace]
690 // plusminus ::= '+' | '-'
691 // units ::= digits [thousands-sep units]
692 // digits ::= digit [digits]
693 //
694 // i.e., thousands-sep may only appear at most one at a time and
695 // only when enclosed within a sequence of digits and not first
696 // or last
697
698 TEST (T, false, ";0", 0, 0, Fail, "\1");
699 TEST (T, false, "0;", 2, 0, Eof | Fail, "\1");
700 TEST (T, false, "0;;", 2, 0, Fail, "\1");
701 TEST (T, false, ";0;0", 0, 0, Fail, "\1");
702 TEST (T, false, ";01", 0, 0, Fail, "\2");
703 TEST (T, false, "01;", 3, 0, Eof | Fail, "\2");
704 TEST (T, false, "01;;", 3, 0, Fail, "\2");
705 TEST (T, false, ";;0;01", 0, 0, Fail, "\2");
706 TEST (T, false, "00;;01", 3, 0, Fail, "\2");
707 TEST (T, false, "00;;;01", 3, 0, Fail, "\2");
708 TEST (T, false, ";;11", 0, 0, Fail, "\3");
709 TEST (T, false, "+;;12", 1, 0, Fail, "\3");
710 TEST (T, false, "-;;13", 1, 0, Fail, "\3");
711 TEST (T, false, "01;;4", 3, 0, Fail, "\3");
712
713 // bad groups, valid input: store value and set failbit
714 // this is different from the above in that the integer grammar
715 // is satisifed but the positions of the thousands_sep characters
716 // in otherwise valid input do not match the specified grouping
717
718 TEST (T, true, "00;0;1", 6, 0, Eof | Fail, "\1");
719
720 // bool, boolalpha parsing
721 TEST (T, false, "false", 5, boolalpha, Good);
722 TEST (T, true, "true", 4, boolalpha, Good);
723
724 TEST (T, false, "falsee", 5, boolalpha, Good);
725 TEST (T, true, "truee", 4, boolalpha, Good);
726
727 TEST (T, false, "False", 0, boolalpha, Fail);
728 TEST (T, false, "True", 0, boolalpha, Fail);
729
730 TEST (T, false, "falsE", 4, boolalpha, Fail);
731 TEST (T, false, "truE", 3, boolalpha, Fail);
732
733 TEST (T, false, "fals", 4, boolalpha, Eof | Fail);
734 TEST (T, false, "tru", 3, boolalpha, Eof | Fail);
735
736 TEST (T, false, "fal", 3, boolalpha, Eof | Fail);
737 TEST (T, false, "tr", 2, boolalpha, Eof | Fail);
738
739 TEST (T, false, "fa", 2, boolalpha, Eof | Fail);
740 TEST (T, false, "t", 1, boolalpha, Eof | Fail);
741
742 TEST (T, false, "f", 1, boolalpha, Eof | Fail);
743 TEST (T, false, "", 0, boolalpha, Eof | Fail);
744
745 PunctData::set_names ("bool:-", "bool:+");
746
747 TEST (T, false, "false", 0, boolalpha, Fail);
748 TEST (T, false, "true", 0, boolalpha, Fail);
749
750 TEST (T, false, "bool:-", 6, boolalpha, Good);
751 TEST (T, true, "bool:+", 6, boolalpha, Good);
752
753 TEST (T, false, "bool: ", 5, boolalpha, Fail);
754 TEST (T, false, "bool: ", 5, boolalpha, Fail);
755
756 PunctData::set_names ("Bool", "Boolean");
757
758 TEST (T, false, "false", 0, boolalpha, Fail);
759 TEST (T, false, "true", 0, boolalpha, Fail);
760
761 TEST (T, false, "Bool", 4, boolalpha, Eof);
762 TEST (T, true, "Boolean", 7, boolalpha, Good);
763
764 TEST (T, false, "Boole", 5, boolalpha, Eof | Fail);
765 TEST (T, false, "Boolea", 6, boolalpha, Eof | Fail);
766
767 PunctData::set_names ("BOOLEAN", "BOOL");
768
769 TEST (T, false, "false", 0, boolalpha, Fail);
770 TEST (T, false, "true", 0, boolalpha, Fail);
771
772 TEST (T, false, "BOOLEAN", 7, boolalpha, Good);
773 TEST (T, true, "BOOL", 4, boolalpha, Eof);
774 TEST (T, true, "BOOL ", 4, boolalpha, Good);
775
776 // the parsing algorithm is greedy, partial matches fail even
777 // if one keyword is a subset of the other and the shorter one
778 // is a subset of the characters matched so far
779 TEST (T, false, "BOOLEA", 6, boolalpha, Eof | Fail);
780 TEST (T, false, "BOOLE", 5, boolalpha, Eof | Fail);
781
782 PunctData::set_names ("1", "0");
783
784 TEST (T, false, "false", 0, boolalpha, Fail);
785 TEST (T, false, "true", 0, boolalpha, Fail);
786
787 TEST (T, false, "1", 1, boolalpha, Good);
788 TEST (T, true, "0", 1, boolalpha, Good);
789
790 // numeric parsing with "0" and "1" as keywords
791 TEST (T, false, "0", 1, 0, Eof);
792 TEST (T, true, "1", 1, 0, Eof);
793
794 TEST (T, false, "11", 1, boolalpha, Good);
795 TEST (T, true, "00", 1, boolalpha, Good);
796
797 TEST (T, false, "+1", 0, boolalpha, Fail);
798 TEST (T, false, "+0", 0, boolalpha, Fail);
799
800#else // if defined (NO_GET_BOOL)
801
802 _RWSTD_UNUSED (t);
803
804#endif // NO_GET_BOOL
805
806}
807
808
810static void
811test_shrt (CharType ctype, const char *cname,
812 IterType itype, const char *iname)
813{
814#ifndef _RWSTD_NO_EXT_NUM_GET
815# ifndef NO_GET_SHRT
816
817 const char* const tname = "short";
818
819 rw_info (0, 0, 0, "extension: std::num_get<%s, %s>::get (..., %s&)",
820 cname, iname, tname);
821
822 // short parsing of 0, no base specified
823 TEST (T, short (0), "%hi", 1, 0, Eof, "%hi");
824 TEST (T, short (0), "%ho", 1, 0, Eof, "%hi");
825 TEST (T, short (0), "%hx", 1, 0, Eof, "%hi");
826 TEST (T, short (0), "%#hx", 1, 0, Eof, "%hi");
827
828 TEST (T, short (1), "%hi", 1, 0, Eof, "%hi");
829 TEST (T, short (SHRT_MAX), "%hi", -1, 0, Eof, "%hi");
830 TEST (T, short (SHRT_MIN), "%hi", -1, 0, Eof, "%hi");
831
832 rw_info (0, 0, 0, "extension: base 1 (Roman)");
833
834#define BASE(n) ((n) << _RWSTD_IOS_BASEOFF)
835
836 TEST (T, short ( 0), "0", 1, BASE (1), Eof);
837 TEST (T, short ( 1), "i", 1, BASE (1), Eof);
838 TEST (T, short ( 2), "ii", 2, BASE (1), Eof);
839 TEST (T, short ( 3), "iii", 3, BASE (1), Eof);
840 TEST (T, short ( 4), "iiii", 4, BASE (1), Eof);
841 TEST (T, short ( 4), "iv", 2, BASE (1), Eof);
842 TEST (T, short ( 5), "v", 1, BASE (1), Eof);
843 TEST (T, short ( 6), "vi", 2, BASE (1), Eof);
844 TEST (T, short ( 7), "vii", 3, BASE (1), Eof);
845 TEST (T, short ( 8), "viii", 4, BASE (1), Eof);
846 TEST (T, short ( 9), "viiii", 5, BASE (1), Eof);
847 TEST (T, short ( 9), "ix", 2, BASE (1), Eof);
848 TEST (T, short (10), "x", 1, BASE (1), Eof);
849
850 TEST (T, short ( 12), "XII", 3, BASE (1), Eof);
851 TEST (T, short ( 123), "CXXIII", 6, BASE (1), Eof);
852 TEST (T, short (1234), "MCCXXXIV", 8, BASE (1), Eof);
853 TEST (T, short (2345), "MMCCCXLV", 8, BASE (1), Eof);
854 TEST (T, short (3456), "MMMCDLVI", 8, BASE (1), Eof);
855 TEST (T, short (4567), "MMMMDLXVII", 10, BASE (1), Eof);
856 TEST (T, short (4999), "MMMMCMXCIX", 10, BASE (1), Eof);
857 TEST (T, short (5000), "5000", 4, BASE (1), Eof);
858 TEST (T, short (5678), "5678", 4, BASE (1), Eof);
859
860 TEST (T, short (5001), "5001i", 4, BASE (1), Good);
861 TEST (T, short (5002), "5002v", 4, BASE (1), Good);
862 TEST (T, short (5003), "5003x", 4, BASE (1), Good);
863 TEST (T, short (5004), "5004l", 4, BASE (1), Good);
864 TEST (T, short (5005), "5005d", 4, BASE (1), Good);
865 TEST (T, short (5006), "5006m", 4, BASE (1), Good);
866
867 rw_info (0, 0, 0, "extension: base 2 (ios_base::bin, binary)");
868
869 TEST (T, short ( 0), "0", 1, BASE (2), Eof);
870 TEST (T, short ( 1), "1", 1, BASE (2), Eof);
871 TEST (T, short ( 2), "10", 2, BASE (2), Eof);
872 TEST (T, short ( 3), "11", 2, BASE (2), Eof);
873 TEST (T, short ( 4), "100", 3, BASE (2), Eof);
874 TEST (T, short ( 5), "101", 3, BASE (2), Eof);
875 TEST (T, short ( 6), "110", 3, BASE (2), Eof);
876 TEST (T, short ( 7), "111", 3, BASE (2), Eof);
877 TEST (T, short ( 8), "1000", 4, BASE (2), Eof);
878 TEST (T, short ( 9), "1001", 4, BASE (2), Eof);
879 TEST (T, short ( 10), "1010", 4, BASE (2), Eof);
880 TEST (T, short ( 11), "1011", 4, BASE (2), Eof);
881 TEST (T, short ( 12), "1100", 4, BASE (2), Eof);
882 TEST (T, short ( 13), "1101", 4, BASE (2), Eof);
883 TEST (T, short ( 14), "1110", 4, BASE (2), Eof);
884 TEST (T, short ( 15), "1111", 4, BASE (2), Eof);
885 TEST (T, short ( 16), "10000", 5, BASE (2), Eof);
886 TEST (T, short ( 17), "+10001", 6, BASE (2), Eof);
887 TEST (T, short (-18), "-10010", 6, BASE (2), Eof);
888
889 TEST (T, short (17), "100012", 5, BASE (2), Good);
890 TEST (T, short (18), "100103", 5, BASE (2), Good);
891 TEST (T, short (19), "100114", 5, BASE (2), Good);
892
893 rw_info (0, 0, 0, "extension: base 3");
894
895 TEST (T, short ( 0), "0", 1, BASE (3), Eof);
896 TEST (T, short ( 1), "1", 1, BASE (3), Eof);
897 TEST (T, short ( 2), "2", 1, BASE (3), Eof);
898 TEST (T, short ( 3), "10", 2, BASE (3), Eof);
899 TEST (T, short ( 4), "11", 2, BASE (3), Eof);
900 TEST (T, short ( 5), "12", 2, BASE (3), Eof);
901 TEST (T, short ( 6), "20", 2, BASE (3), Eof);
902 TEST (T, short ( 7), "21", 2, BASE (3), Eof);
903 TEST (T, short ( 8), "22", 2, BASE (3), Eof);
904
905 TEST (T, short ( 8), "223", 2, BASE (3), Good);
906
907 if (rw_opt_no_errno) {
908 rw_note (0, 0, 0, "errno test disabled");
909 }
910 else {
911 test_errno (ctype, cname, itype, iname, short ());
912 }
913
914# else // if defined (NO_GET_SHRT)
915
916 _RWSTD_UNUSED (t);
917
918# endif // NO_GET_SHRT
919#endif // _RWSTD_NO_EXT_NUM_GET
920
921}
922
923
925static void
926test_int (CharType ctype, const char *cname,
927 IterType itype, const char *iname)
928{
929#ifndef _RWSTD_NO_EXT_NUM_GET
930# ifndef NO_GET_INT
931
932 const char* const tname = "int";
933
934 rw_info (0, 0, 0, "extension: std::num_get<%s, %s>::get (..., %s&)",
935 cname, iname, tname);
936
937 TEST (T, 0, "%i", 1, 0, Eof, "%i");
938 TEST (T, 0, "%o", 1, 0, Eof, "%i");
939 TEST (T, 0, "%x", 1, 0, Eof, "%i");
940 TEST (T, 0, "%#x", 1, 0, Eof, "%i");
941
942 if (rw_opt_no_errno) {
943 rw_note (0, 0, 0, "errno test disabled");
944 }
945 else {
946 test_errno (ctype, cname, itype, iname, int ());
947 }
948
949# else // if defined (NO_GET_INT)
950
951 _RWSTD_UNUSED (t);
952
953# endif // NO_GET_INT
954#endif // _RWSTD_NO_EXT_NUM_GET
955
956}
957
958
960static void
961test_long (CharType ctype, const char *cname,
962 IterType itype, const char *iname)
963{
964#ifndef NO_GET_LONG
965
966 const char* const tname = "long";
967
968 rw_info (0, 0, 0, "std::num_get<%s, %s>::get (..., %s&)",
969 cname, iname, tname);
970
971 // 22.2.3.1, p2 -- integer grammar:
972 //
973 // integer ::= [sign] units
974 // sign ::= plusminus [whitespace]
975 // plusminus ::= '+' | '-'
976 // units ::= digits [thousands-sep units]
977 // digits ::= digit [digits]
978 // digit ::= '0' | '1' | '2' | '3' | '4' | '5' | '6' | '7'
979 // | '8' | '9' | 'A' | 'B' | 'C' | 'D' | 'E' | 'F'
980 // | 'a' | 'b' | 'c' | 'd' | 'e' | 'f'
981
982
983 // long parsing of 0, no base specified
984 TEST (T, 0L, "%li", 1, 0, Eof, "%li");
985 TEST (T, 0L, "%lo", 1, 0, Eof, "%li");
986 TEST (T, 0L, "%lx", 1, 0, Eof, "%li");
987 TEST (T, 0L, "%#lx", 1, 0, Eof, "%li");
988
989 TEST (T, 0L, "", 0, 0, Eof | Fail);
990 TEST (T, 0L, "+", 1, 0, Eof | Fail);
991 TEST (T, 0L, "-", 1, 0, Eof | Fail);
992 TEST (T, 0L, "0", 1, 0, Eof);
993 TEST (T, 0L, "00", 2, 0, Eof);
994 TEST (T, 0L, "+0", 2, 0, Eof);
995 TEST (T, 0L, "-0", 2, 0, Eof);
996 TEST (T, 0L, "0x0", 3, 0, Eof);
997 TEST (T, 0L, "0X0", 3, 0, Eof);
998 TEST (T, 0L, "+0x0", 4, 0, Eof);
999 TEST (T, 0L, "-0x0", 4, 0, Eof);
1000 TEST (T, 0L, "0x0x", 3, 0, Good);
1001 TEST (T, 0L, "00000000", 8, 0, Eof);
1002 TEST (T, 0L, "0x00000000", 10, 0, Eof);
1003 TEST (T, 0L, "0-", 1, 0, Good);
1004 TEST (T, 0L, "0+", 1, 0, Good);
1005 TEST (T, 0L, "0.", 1, 0, Good);
1006
1007 // long parsing of 0, base 10
1008 TEST (T, 0L, "0", 1, dec, Eof);
1009 TEST (T, 0L, "00", 2, dec, Eof);
1010 TEST (T, 0L, "+0", 2, dec, Eof);
1011 TEST (T, 0L, "-0", 2, dec, Eof);
1012 TEST (T, 0L, "0x0", 1, dec, Good);
1013 TEST (T, 0L, "+0x0", 2, dec, Good);
1014 TEST (T, 0L, "-0x0", 2, dec, Good);
1015 TEST (T, 0L, "00000000", 8, dec, Eof);
1016 TEST (T, 0L, "0x00000000", 1, dec, Good);
1017 TEST (T, 0L, "0-", 1, dec, Good);
1018 TEST (T, 0L, "0+", 1, dec, Good);
1019 TEST (T, 0L, "0.", 1, dec, Good);
1020
1021 // long parsing of 0, base 8
1022 TEST (T, 0L, "0", 1, oct, Eof);
1023 TEST (T, 0L, "00", 2, oct, Eof);
1024 TEST (T, 0L, "+0", 2, oct, Eof);
1025 TEST (T, 0L, "-0", 2, oct, Eof);
1026 TEST (T, 0L, "0x0", 1, oct, Good);
1027 TEST (T, 0L, "+0x0", 2, oct, Good);
1028 TEST (T, 0L, "-0x0", 2, oct, Good);
1029 TEST (T, 0L, "00000000", 8, oct, Eof);
1030 TEST (T, 0L, "0x00000000", 1, oct, Good);
1031 TEST (T, 0L, "0-", 1, oct, Good);
1032 TEST (T, 0L, "0+", 1, oct, Good);
1033 TEST (T, 0L, "0.", 1, oct, Good);
1034
1035 // long parsing of 0, base 16
1036 TEST (T, 0L, "0", 1, hex, Eof);
1037 TEST (T, 0L, "00", 2, hex, Eof);
1038 TEST (T, 0L, "+0", 2, hex, Eof);
1039 TEST (T, 0L, "-0", 2, hex, Eof);
1040 TEST (T, 0L, "0x0", 3, hex, Eof);
1041 TEST (T, 0L, "0X00", 4, hex, Eof);
1042 TEST (T, 0L, "+0x0", 4, hex, Eof);
1043 TEST (T, 0L, "-0x0", 4, hex, Eof);
1044 TEST (T, 0L, "00000000", 8, hex, Eof);
1045 TEST (T, 0L, "0x00000000", 10, hex, Eof);
1046 TEST (T, 0L, "0-", 1, hex, Good);
1047 TEST (T, 0L, "0+", 1, hex, Good);
1048 TEST (T, 0L, "0.", 1, hex, Good);
1049
1050 // long parsing, no base specified
1051 // assumes sizeof(long) >= 4
1052
1053 _RWSTD_ASSERT (sizeof (long) >= 4);
1054
1055 TEST (T, 1L, "1", 1, 0, Eof, "%li");
1056 TEST (T, 12L, "12", 2, 0, Eof, "%li");
1057 TEST (T, 123L, "123", 3, 0, Eof, "%li");
1058 TEST (T, 1234L, "1234", 4, 0, Eof, "%li");
1059 TEST (T, 12345L, "12345", 5, 0, Eof, "%li");
1060 TEST (T, 123456L, "123456", 6, 0, Eof, "%li");
1061 TEST (T, 1234567L, "1234567", 7, 0, Eof, "%li");
1062 TEST (T, 12345678L, "12345678", 8, 0, Eof, "%li");
1063 TEST (T, 134217728L, "134217728", 9, 0, Eof, "%li");
1064 TEST (T, 134217728L, "%li", 9, 0, Eof, "%li");
1065 TEST (T, ~0L, "%li", -1, 0, Eof, "%li");
1066 TEST (T, 10L, "%li", -1, 0, Eof, "%li");
1067
1068 // autodetection of oct and hex format
1069 TEST (T, 01234567L, "01234567", 8, 0, Eof, "%li");
1070 TEST (T, 0x1234567L, "0x1234567", 9, 0, Eof, "%li");
1071 TEST (T, 0X79aBcDeFL, "0X79aBcDeF", 10, 0, Eof, "%li");
1072
1073 TEST (T, 01234567L, "+01234567", 9, 0, Eof, "%li");
1074 TEST (T, 0x1234567L, "+0x1234567", 10, 0, Eof, "%li");
1075 TEST (T, -01234567L, "-01234567", 9, 0, Eof, "%li");
1076 TEST (T, -0x1234567L, "-0x1234567", 10, 0, Eof, "%li");
1077
1078 TEST (T, 0xaL, "0x00000000000000a", 17, 0, Eof, "%li");
1079 TEST (T, 0xabL, "0x000000000000ab", 16, 0, Eof, "%li");
1080 TEST (T, 0xabcL, "0x0000000000abc", 15, 0, Eof, "%li");
1081 TEST (T, 0xabcdL, "0x00000000abcd", 14, 0, Eof, "%li");
1082 TEST (T, 0xabcdeL, "0x000000abcde", 13, 0, Eof, "%li");
1083 TEST (T, 0xabcdefL, "0x0000abcdef", 12, 0, Eof, "%li");
1084 TEST (T, 0xabcdef0L, "0x00abcdef0", 11, 0, Eof, "%li");
1085 TEST (T, 0xabcdef1L, "0xabcdef1", 9, 0, Eof, "%li");
1086
1087 TEST (T, 0L, "00x", 2, 0, Good, "%li");
1088 TEST (T, 1L, "01x", 2, 0, Good, "%li");
1089 TEST (T, 0L, "0x", 2, 0, Eof | Fail);
1090 TEST (T, 0L, "x", 0, 0, Fail, "%li");
1091
1092 // long parsing, dec base
1093 TEST (T, 2L, "2", 1, dec, Eof, "%ld");
1094 TEST (T, 23L, "23", 2, dec, Eof, "%ld");
1095 TEST (T, 234L, "234", 3, dec, Eof, "%ld");
1096 TEST (T, 2345L, "2345", 4, dec, Eof, "%ld");
1097 TEST (T, 23456L, "23456", 5, dec, Eof, "%ld");
1098 TEST (T, 234567L, "234567", 6, dec, Eof, "%ld");
1099 TEST (T, 2345678L, "2345678", 7, dec, Eof, "%ld");
1100 TEST (T, 23456789L, "23456789", 8, dec, Eof, "%ld");
1101 TEST (T, 134217728L, "134217728", 9, dec, Eof, "%ld");
1102 TEST (T, 134217728L, "%ld", 9, dec, Eof, "%ld");
1103 TEST (T, ~0L, "%ld", -1, dec, Eof, "%ld");
1104 TEST (T, LONG_MAX, "%ld", -1, dec, Eof, "%ld");
1105 TEST (T, LONG_MIN, "%ld", -1, dec, Eof, "%ld");
1106 TEST (T, -3L, "%ld", 2, dec, Eof, "%ld");
1107 TEST (T, -34L, "%ld", 3, dec, Eof, "%ld");
1108 TEST (T, -345L, "%ld", 4, dec, Eof, "%ld");
1109 TEST (T, -3456L, "-3456", 5, dec, Eof, "%ld");
1110 TEST (T, -34567L, "-34567", 6, dec, Eof, "%ld");
1111 TEST (T, -345678L, "-00345678", 9, dec, Eof, "%ld");
1112 TEST (T, 3456789L, "+03456789", 9, dec, Eof, "%ld");
1113 TEST (T, 4567890L, "4567890.1", 7, dec, Good, "%ld");
1114 TEST (T, 567890L, "567890e+1", 6, dec, Good, "%ld");
1115
1116 PunctData::thousands_sep_ = ';';
1117
1118 // long parsing, dec base, with grouping (which is optional, empty
1119 // grouping, "", causes extraction to terminate at the first occurrence
1120 // of the thousands_sep character)
1121 TEST (T, 2147483647L, "2147483647;", 10, dec, Good, "\0");
1122 TEST (T, 214748364L, "214748364;7", 9, dec, Good, "\0");
1123 TEST (T, 21474836L, "21474836;47", 8, dec, Good, "\0");
1124 TEST (T, 2147483L, "2147483;647", 7, dec, Good, "\0");
1125 TEST (T, 214748L, "214748;3647", 6, dec, Good, "\0");
1126 TEST (T, 21474L, "21474;83647", 5, dec, Good, "\0");
1127 TEST (T, 2147L, "2147;483647", 4, dec, Good, "\0");
1128 TEST (T, 214L, "214;7483647", 3, dec, Good, "\0");
1129 TEST (T, 21L, "21;47483647", 2, dec, Good, "\0");
1130 TEST (T, 2L, "2;147483647", 1, dec, Good, "\0");
1131 TEST (T, 0L, ";2147483647", 0, dec, Fail, "\0");
1132
1133 TEST (T, 2147483647L, "2147483647", 10, dec, Eof, "\1");
1134 TEST (T, 2147483647L, "2;1;4;7;4;8;3;6;4;7", 19, dec, Eof, "\1");
1135 TEST (T, 2147483646L, "21;47;48;36;46", 14, dec, Eof, "\2");
1136 TEST (T, 2147483645L, "2;147;483;645", 13, dec, Eof, "\3");
1137 TEST (T, 2147483644L, "21;4748;3644", 12, dec, Eof, "\4");
1138 TEST (T, 2147483643L, "21474;83643", 11, dec, Eof, "\5");
1139 TEST (T, 2147483642L, "2147;483642", 11, dec, Eof, "\6");
1140 TEST (T, 2147483641L, "214;7483641", 11, dec, Eof, "\7");
1141 TEST (T, 2147483640L, "21;47483640", 11, dec, Eof, "\10");
1142 TEST (T, 2147483639L, "2;147483639", 11, dec, Eof, "\11");
1143 TEST (T, 2147483638L, "2147483638", 10, dec, Eof, "\12");
1144
1145 TEST (T, 2147483637L, "2;14;74;83;63;7", 15, dec, Eof, "\1\2");
1146 TEST (T, 2147483636L, "214;748;363;6", 13, dec, Eof, "\1\3");
1147 TEST (T, 2147483635L, "2;1474;8363;5", 13, dec, Eof, "\1\4");
1148 TEST (T, 2147483634L, "2147;48363;4", 12, dec, Eof, "\1\5");
1149 TEST (T, 2147483633L, "214;748363;3", 12, dec, Eof, "\1\6");
1150 TEST (T, 2147483632L, "21;4748363;2", 12, dec, Eof, "\1\7");
1151 TEST (T, 2147483631L, "2;14748363;1", 12, dec, Eof, "\1\10");
1152 TEST (T, 2147483630L, "214748363;0", 11, dec, Eof, "\1\11");
1153
1154 TEST (T, 2147483629L, "2;147;483;62;9", 14, dec, Eof, "\1\2\3");
1155 TEST (T, 2147483628L, "2;1;4;7;4;83;628", 16, dec, Eof, "\3\2\1");
1156 TEST (T, 2147483627L, "2;147;483;627", 13, dec, Eof, "\3\3\3");
1157 TEST (T, 2147483626L, "+2147;483;626", 13, dec, Eof, "\3\3\4");
1158
1159 for (int i = 256; i >= 0; i -= 32) {
1160
1161 // exercise parsing of input with excessively many groups
1162 static const char many_groups[] = {
1163 // each row below consists of 32 thousands_sep's (numbered 0-31)
1164 // and 32 zeros for a total of 64 characters
1165 // . . . . : . . . . 1 . . . . : . . . . 2 . . . . : . . . . 3 .
1166 "0;0;0;0;0;0;0;0;0;0;0;0;0;0;0;0;0;0;0;0;0;0;0;0;0;0;0;0;0;0;0;0;"
1167 "0;0;0;0;0;0;0;0;0;0;0;0;0;0;0;0;0;0;0;0;0;0;0;0;0;0;0;0;0;0;0;0;"
1168 "0;0;0;0;0;0;0;0;0;0;0;0;0;0;0;0;0;0;0;0;0;0;0;0;0;0;0;0;0;0;0;0;"
1169 "0;0;0;0;0;0;0;0;0;0;0;0;0;0;0;0;0;0;0;0;0;0;0;0;0;0;0;0;0;0;0;0;"
1170 "0;0;0;0;0;0;0;0;0;0;0;0;0;0;0;0;0;0;0;0;0;0;0;0;0;0;0;0;0;0;0;0;"
1171 "0;0;0;0;0;0;0;0;0;0;0;0;0;0;0;0;0;0;0;0;0;0;0;0;0;0;0;0;0;0;0;0;"
1172 "0;0;0;0;0;0;0;0;0;0;0;0;0;0;0;0;0;0;0;0;0;0;0;0;0;0;0;0;0;0;0;0;"
1173 "0;0;0;0;0;0;0;0;0;0;0;0;0;0;0;0;0;0;0;0;0;0;0;0;0;0;0;0;0;0;0;0;"
1174 "1"
1175 };
1176
1177 static const int NC = int (sizeof many_groups - 1);
1178
1179 const int nfail = TEST (T, 1L, many_groups + i, NC - i, dec, Eof, "\1");
1180
1181 // increase input length and break out after the first failure
1182 if (nfail)
1183 break;
1184 }
1185
1186 // long parsing, hex base, with grouping
1187 TEST (T, 0x0L, "0", 1, hex, Eof, "\1");
1188 TEST (T, 0x0L, "00", 2, hex, Eof, "\1");
1189 TEST (T, 0x0L, "000", 3, hex, Eof, "\1");
1190 TEST (T, 0x0L, "0;0;0", 5, hex, Eof, "\1");
1191 TEST (T, 0x0L, "0x0;0;0", 7, hex, Eof, "\1");
1192 TEST (T, 0x0L, "0X0;0;0", 7, hex, Eof, "\1");
1193 TEST (T, 0x0L, "+0;0;0", 6, hex, Eof, "\1");
1194 TEST (T, 0x0L, "-0;0;0", 6, hex, Eof, "\1");
1195 TEST (T, 0x0L, "+0x0;0;0", 8, hex, Eof, "\1");
1196 TEST (T, 0x0L, "+0X0;0;0", 8, hex, Eof, "\1");
1197 TEST (T, 0x0L, "-0x0;0;0", 8, hex, Eof, "\1");
1198 TEST (T, 0x0L, "-0X0;0;0", 8, hex, Eof, "\1");
1199
1200 TEST (T, 0xAL, "A", 1, hex, Eof, "\1");
1201 TEST (T, 0xABL, "AB", 2, hex, Eof, "\1");
1202 TEST (T, 0xABL, "A;B", 3, hex, Eof, "\1");
1203 TEST (T, 0xABL, "A;b", 3, hex, Eof, "\1");
1204 TEST (T, 0xABL, "a;B", 3, hex, Eof, "\1");
1205 TEST (T, 0xABCL, "ABC", 3, hex, Eof, "\1");
1206 TEST (T, 0xABCL, "A;B;C", 5, hex, Eof, "\1");
1207 TEST (T, 0xABCDL, "ABCD", 4, hex, Eof, "\1");
1208 TEST (T, 0xABCDL, "A;B;C;D", 7, hex, Eof, "\1");
1209 TEST (T, 0xABCDEL, "ABCDE", 5, hex, Eof, "\1");
1210 TEST (T, 0xABCDEL, "A;B;C;D;E", 9, hex, Eof, "\1");
1211 TEST (T, 0xABCDEFL, "ABCDEF", 6, hex, Eof, "\1");
1212 TEST (T, 0xABCDEFL, "A;B;C;D;E;F", 11, hex, Eof, "\1");
1213 TEST (T, 0xABCDEFL, "a;B;c;D;e;F", 11, hex, Eof, "\1");
1214 TEST (T, 0xABCDEFL, "+A;B;C;D;E;F", 12, hex, Eof, "\1");
1215 TEST (T, -0xABCDEFL, "-A;B;C;D;E;F", 12, hex, Eof, "\1");
1216 TEST (T, 0xABCDEFL, "0xA;B;C;D;E;F", 13, hex, Eof, "\1");
1217 TEST (T, 0xABCDEFL, "+0xA;B;C;D;E;F", 14, hex, Eof, "\1");
1218 TEST (T, -0xABCDEFL, "-0xA;B;C;D;E;F", 14, hex, Eof, "\1");
1219
1220 // long parsing, dec base, with bad groups: store value, set failbit
1221 TEST (T, 2147483624L, "21;474;83624; ", 13, dec, Fail, "\5\3");
1222 TEST (T, 2147483623L, "21;47;483623 ", 12, dec, Fail, "\6\3");
1223 TEST (T, 2147483622L, "21;47483622 ", 11, dec, Fail, "\7\3");
1224 TEST (T, 2147483621L, "214;748362;1 ", 12, dec, Fail, "\7\3");
1225 TEST (T, 2147483619L, "2;147;483;619 ", 13, dec, Fail, "\1");
1226 TEST (T, 2147483618L, "2147;48;36;18 ", 13, dec, Fail, "\2");
1227 TEST (T, 2147483617L, "2147;483;617 ", 12, dec, Fail, "\3");
1228 TEST (T, 2147483616L, "21;47483616 ", 11, dec, Fail, "\4");
1229 TEST (T, 2147483615L, "21;47;4836;15 ", 13, dec, Fail, "\2\2");
1230 TEST (T, 2147483614L, "21474;836;14 ", 12, dec, Fail, "\2\3");
1231
1232 // thousands_sep at illegal positions, do not store value, set failbit
1233 TEST (T, 2147483625L, ";214;748;3625 ", 0, dec, Fail, "\4\3");
1234 TEST (T, 2147483620L, "+214;;7483620 ", 5, dec, Fail, "\7\4");
1235
1236 // unusual thousands_sep
1237 PunctData::thousands_sep_ = '.';
1238 TEST (T, 2147483618L, "214.74836.18", 12, dec, Eof, "\2\5");
1239
1240 PunctData::thousands_sep_ = 'A';
1241 TEST (T, 2147483617L, "2A14A7483A617", 13, dec, Eof, "\3\4\2");
1242
1243 // Stage 2 parsing algorithm in 22.2.2.1.2, p8 removes thousands_sep
1244 // from the sequence before checking for sign and other valid chars
1245 // but since, according to the grammar, a well-formed thousands_sep
1246 // may not appear first, when the leading thousands_sep matches
1247 // the sign character it is taken as the sign
1248 // (these are totally anal-retentive tests)
1249 PunctData::thousands_sep_ = '-';
1250 TEST (T, 2147483617L, "21-47-4-83-617", 14, dec, Eof, "\3\2\1\2");
1251 TEST (T, -2147483616L, "-214-748-3616 ", 13, dec, Good, "\4\3\3");
1252
1253 PunctData::thousands_sep_ = '+';
1254 TEST (T, 2147483615L, "2+147+48+3+615", 14, dec, Eof, "\3\1\2\3");
1255
1256 // leading '+' taken as the plus sign and not a thousands_sep
1257 TEST (T, 2147483614L, "+21+4748361+4 ", 13, dec, Good, "\1\7\2");
1258
1259 // a digit as a thousands_sep is removed from the input sequence
1260 PunctData::thousands_sep_ = '0';
1261 TEST (T, 2147483613L, "21047048306013", 14, dec, Eof, "\2\1\3\2");
1262
1263 PunctData::thousands_sep_ = '1';
1264 TEST (T, 24748362L, "2147483612", 10, dec, Eof, "\1\6");
1265
1266 // exercise lwg issue 338 (whitespace after sign not allowed)
1267 TEST (T, 0L, "+ 1", 1, 0, Fail);
1268 TEST (T, 0L, "- 2", 1, 0, Fail);
1269
1270
1271 // exercise signed integer overflow
1272#if LONG_MAX == 0x7fffL
1273 const char lmin[] = "-32768";
1274 const char lmin_minus_1[] = "-32769";
1275 const char lmin_minus_2[] = "-32770";
1276 const char lmin_minus_3[] = "-32771";
1277
1278 const char lmax[] = "32767";
1279 const char lmax_plus_1[] = "32768";
1280 const char lmax_plus_2[] = "32769";
1281 const char lmax_plus_3[] = "32770";
1282 const char lmax_x_f[] = "0x7ffff";
1283
1284 const char vflow_1[] = "";
1285#elif LONG_MAX == 0x7fffffffL
1286 const char lmin[] = "-2147483648";
1287 const char lmin_minus_1[] = "-2147483649";
1288 const char lmin_minus_2[] = "-2147483650";
1289 const char lmin_minus_3[] = "-2147483651";
1290
1291 const char lmax[] = "2147483647"; // 0x7fffffffL
1292 const char lmax_plus_1[] = "2147483648"; // 0x7fffffffL + 1
1293 const char lmax_plus_2[] = "2147483649"; // 0x7fffffffL + 2
1294 const char lmax_plus_3[] = "2147483650"; // 0x7fffffffL + 3
1295 const char lmax_x_f[] = "0x7ffffffff"; // extra 'f' (times 0xf)
1296 const char vflow_1[] = "";
1297#elif LONG_MAX > 0x7fffffffL
1298 const char lmin[] = "-9223372036854775808";
1299 const char lmin_minus_1[] = "-9223372036854775809";
1300 const char lmin_minus_2[] = "-9223372036854775810";
1301 const char lmin_minus_3[] = "-9223372036854775811";
1302
1303 const char lmax[] = "9223372036854775807";
1304 const char lmax_plus_1[] = "9223372036854775808";
1305 const char lmax_plus_2[] = "9223372036854775809";
1306 const char lmax_plus_3[] = "9223372036854775810";
1307 const char lmax_x_f[] = "0x7ffffffffffffffff";
1308 const char vflow_1[] = "";
1309#else
1310 // working around a SunPro bug (PR #28279)
1311
1312 const char lmin[] = "-999999999999999999990";
1313 const char lmin_minus_1[] = "-999999999999999999991";
1314 const char lmin_minus_2[] = "-999999999999999999992";
1315 const char lmin_minus_3[] = "-999999999999999999993";
1316
1317 const char lmax[] = "0";
1318 const char lmax_plus_1[] = "999999999999999999997";
1319 const char lmax_plus_2[] = "999999999999999999998";
1320 const char lmax_plus_3[] = "999999999999999999999";
1321 const char lmax_x_f[] = "0xfffffffffffffffff";
1322 const char vflow_1[] = "999999999999999999990";
1323#endif
1324
1325#define INTSIZE(x) _RWSTD_STATIC_CAST(int, sizeof (x))
1326
1327 TEST (T, LONG_MIN, lmin, INTSIZE (lmin - 1), 0, Eof);
1328 TEST (T, LONG_MIN, lmin_minus_1, INTSIZE (lmin_minus_1 - 1), 0, Eof | Fail);
1329 TEST (T, LONG_MIN, lmin_minus_2, INTSIZE (lmin_minus_2 - 1), 0, Eof | Fail);
1330 TEST (T, LONG_MIN, lmin_minus_3, INTSIZE (lmin_minus_3 - 1), 0, Eof | Fail);
1331
1332 TEST (T, LONG_MAX, lmax, INTSIZE (lmax - 1), 0, Eof);
1333 TEST (T, LONG_MAX, lmax_plus_1, INTSIZE (lmax_plus_1 - 1), 0, Eof | Fail);
1334 TEST (T, LONG_MAX, lmax_plus_2, INTSIZE (lmax_plus_2 - 1), 0, Eof | Fail);
1335 TEST (T, LONG_MAX, lmax_plus_3, INTSIZE (lmax_plus_3 - 1), 0, Eof | Fail);
1336 TEST (T, LONG_MAX, lmax_x_f, INTSIZE (lmax_x_f - 1), 0, Eof | Fail);
1337
1338 TEST (T, LONG_MAX, vflow_1, INTSIZE (vflow_1 - 1), 0, Eof | Fail);
1339
1340
1341 // verify that the combination of ERANGE and LONG_MAX
1342 // doesn't trip the facet up if it uses strtol()
1343 errno = ERANGE;
1344 TEST (T, _RWSTD_LONG_MAX, _RWSTD_STRSTR (_RWSTD_LONG_MAX), -1, 0, Good);
1345
1346 rw_assert (ERANGE == errno, 0, __LINE__,
1347 "errno unexpectedly changed from %d (%{#*m}) to %d (%{#m})",
1348 ERANGE, ERANGE, errno);
1349
1350 rw_info (0, 0, 0, "extension: base 1 (Roman)");
1351
1352#define BASE(n) ((n) << _RWSTD_IOS_BASEOFF)
1353
1354 TEST (T, 0L, "0", 1, BASE (1), Eof);
1355 TEST (T, 1L, "i", 1, BASE (1), Eof);
1356 TEST (T, 2L, "ii", 2, BASE (1), Eof);
1357 TEST (T, 3L, "iii", 3, BASE (1), Eof);
1358 TEST (T, 4L, "iiii", 4, BASE (1), Eof);
1359 TEST (T, 4L, "iv", 2, BASE (1), Eof);
1360 TEST (T, 5L, "v", 1, BASE (1), Eof);
1361 TEST (T, 6L, "vi", 2, BASE (1), Eof);
1362 TEST (T, 7L, "vii", 3, BASE (1), Eof);
1363 TEST (T, 8L, "viii", 4, BASE (1), Eof);
1364 TEST (T, 9L, "viiii", 5, BASE (1), Eof);
1365 TEST (T, 9L, "ix", 2, BASE (1), Eof);
1366 TEST (T, 10L, "x", 1, BASE (1), Eof);
1367
1368 TEST (T, 12L, "XII", 3, BASE (1), Eof);
1369 TEST (T, 123L, "CXXIII", 6, BASE (1), Eof);
1370 TEST (T, 1234L, "MCCXXXIV", 8, BASE (1), Eof);
1371 TEST (T, 2345L, "MMCCCXLV", 8, BASE (1), Eof);
1372 TEST (T, 3456L, "MMMCDLVI", 8, BASE (1), Eof);
1373 TEST (T, 4567L, "MMMMDLXVII", 10, BASE (1), Eof);
1374 TEST (T, 4999L, "MMMMCMXCIX", 10, BASE (1), Eof);
1375 TEST (T, 5000L, "5000", 4, BASE (1), Eof);
1376 TEST (T, 5678L, "5678", 4, BASE (1), Eof);
1377
1378 TEST (T, 5001L, "5001i", 4, BASE (1), Good);
1379 TEST (T, 5002L, "5002v", 4, BASE (1), Good);
1380 TEST (T, 5003L, "5003x", 4, BASE (1), Good);
1381 TEST (T, 5004L, "5004l", 4, BASE (1), Good);
1382 TEST (T, 5005L, "5005d", 4, BASE (1), Good);
1383 TEST (T, 5006L, "5006m", 4, BASE (1), Good);
1384
1385 rw_info (0, 0, 0, "extension: base 2 (ios_base::bin, binary)");
1386
1387 TEST (T, 0L, "0", 1, BASE (2), Eof);
1388 TEST (T, 1L, "1", 1, BASE (2), Eof);
1389 TEST (T, 2L, "10", 2, BASE (2), Eof);
1390 TEST (T, 3L, "11", 2, BASE (2), Eof);
1391 TEST (T, 4L, "100", 3, BASE (2), Eof);
1392 TEST (T, 5L, "101", 3, BASE (2), Eof);
1393 TEST (T, 6L, "110", 3, BASE (2), Eof);
1394 TEST (T, 7L, "111", 3, BASE (2), Eof);
1395 TEST (T, 8L, "1000", 4, BASE (2), Eof);
1396 TEST (T, 9L, "1001", 4, BASE (2), Eof);
1397 TEST (T, 10L, "1010", 4, BASE (2), Eof);
1398 TEST (T, 11L, "1011", 4, BASE (2), Eof);
1399 TEST (T, 12L, "1100", 4, BASE (2), Eof);
1400 TEST (T, 13L, "1101", 4, BASE (2), Eof);
1401 TEST (T, 14L, "1110", 4, BASE (2), Eof);
1402 TEST (T, 15L, "1111", 4, BASE (2), Eof);
1403 TEST (T, 16L, "10000", 5, BASE (2), Eof);
1404 TEST (T, 17L, "+10001", 6, BASE (2), Eof);
1405 TEST (T, -18L, "-10010", 6, BASE (2), Eof);
1406
1407 TEST (T, 17L, "100012", 5, BASE (2), Good);
1408 TEST (T, 18L, "100103", 5, BASE (2), Good);
1409 TEST (T, 19L, "100114", 5, BASE (2), Good);
1410
1411 rw_info (0, 0, 0, "extension: base 3");
1412
1413 TEST (T, 0L, "0", 1, BASE (3), Eof);
1414 TEST (T, 1L, "1", 1, BASE (3), Eof);
1415 TEST (T, 2L, "2", 1, BASE (3), Eof);
1416 TEST (T, 3L, "10", 2, BASE (3), Eof);
1417 TEST (T, 4L, "11", 2, BASE (3), Eof);
1418 TEST (T, 5L, "12", 2, BASE (3), Eof);
1419 TEST (T, 6L, "20", 2, BASE (3), Eof);
1420 TEST (T, 7L, "21", 2, BASE (3), Eof);
1421 TEST (T, 8L, "22", 2, BASE (3), Eof);
1422
1423 TEST (T, 8L, "223", 2, BASE (3), Good);
1424
1425 rw_info (0, 0, 0, "extension: base 4");
1426
1427 TEST (T, 0L, "0", 1, BASE (4), Eof);
1428 TEST (T, 1L, "1", 1, BASE (4), Eof);
1429 TEST (T, 2L, "2", 1, BASE (4), Eof);
1430 TEST (T, 3L, "3", 1, BASE (4), Eof);
1431 TEST (T, 4L, "10", 2, BASE (4), Eof);
1432 TEST (T, 5L, "11", 2, BASE (4), Eof);
1433 TEST (T, 6L, "12", 2, BASE (4), Eof);
1434 TEST (T, 7L, "13", 2, BASE (4), Eof);
1435 TEST (T, 8L, "20", 2, BASE (4), Eof);
1436 TEST (T, 9L, "21", 2, BASE (4), Eof);
1437 TEST (T, 10L, "22", 2, BASE (4), Eof);
1438 TEST (T, 11L, "23", 2, BASE (4), Eof);
1439
1440 TEST (T, 11L, "234", 2, BASE (4), Good);
1441
1442 rw_info (0, 0, 0, "extension: base 5");
1443
1444 TEST (T, 0L, "0", 1, BASE (5), Eof);
1445 TEST (T, 1L, "1", 1, BASE (5), Eof);
1446 TEST (T, 2L, "2", 1, BASE (5), Eof);
1447 TEST (T, 3L, "3", 1, BASE (5), Eof);
1448 TEST (T, 4L, "4", 1, BASE (5), Eof);
1449 TEST (T, 5L, "10", 2, BASE (5), Eof);
1450 TEST (T, 6L, "11", 2, BASE (5), Eof);
1451 TEST (T, 7L, "12", 2, BASE (5), Eof);
1452 TEST (T, 8L, "13", 2, BASE (5), Eof);
1453 TEST (T, 9L, "14", 2, BASE (5), Eof);
1454 TEST (T, 10L, "20", 2, BASE (5), Eof);
1455 TEST (T, 11L, "21", 2, BASE (5), Eof);
1456 TEST (T, 12L, "22", 2, BASE (5), Eof);
1457 TEST (T, 13L, "23", 2, BASE (5), Eof);
1458 TEST (T, 14L, "24", 2, BASE (5), Eof);
1459
1460 TEST (T, 14L, "245", 2, BASE (5), Good);
1461
1462 if (rw_opt_no_errno) {
1463 rw_note (0, 0, 0, "errno test disabled");
1464 }
1465 else {
1466 test_errno (ctype, cname, itype, iname, long ());
1467 }
1468
1469#endif // NO_GET_LONG
1470
1471}
1472
1473
1475static void
1476test_ulong (CharType ctype, const char *cname,
1477 IterType itype, const char *iname)
1478{
1479#ifndef NO_GET_ULONG
1480
1481 const char* const tname = "unsigned long";
1482
1483 rw_info (0, 0, 0, "std::num_get<%s, %s>::get (..., %s&)",
1484 cname, iname, tname);
1485
1486 // negative numbers are conventionally parsed and interpreted
1487 // according to the following algorithm:
1488
1489 // 1. extract sign S
1490 // 2. extract unsigned number N
1491 // 3. if (S == '-' && N <= ULONG_MAX) X = ULONG_MAX - N + 1
1492 // 4. if (S != '-' && N <= ULONG_MAX) X = N
1493 // 5. if (N > ULONG_MAX) X = ULONG_MAX, set failbit
1494 // 6. return X
1495
1496 TEST (T, 0UL, "0", 1, 0, Eof);
1497 TEST (T, 0UL, "+0", 2, 0, Eof);
1498 TEST (T, 0UL, "-0", 2, 0, Eof);
1499 TEST (T, 1UL, "+1", 2, 0, Eof);
1500 TEST (T, 1078UL, "1078", 4, 0, Eof);
1501 TEST (T, ULONG_MAX, "-1", 2, 0, Eof);
1502
1503 TEST (T, 65535UL, "65535", 5, 0, Eof);
1504 TEST (T, ULONG_MAX - 65535UL + 1UL, "-65535", 6, 0, Eof);
1505
1506 // exercise integer overflow
1507#if ULONG_MAX == 0xffffUL
1508 const char ulmax[] = "65535";
1509 const char ulmax_plus_1[] = "65536";
1510 const char ulmax_plus_2[] = "65537";
1511 const char ulmax_plus_3[] = "65538";
1512 const char ulmax_x_f[] = "0xfffff";
1513 const char vflow_1[] = "131061";
1514#elif ULONG_MAX == 0xffffffffUL
1515 const char ulmax[] = "4294967295"; // 0xffffffffUL
1516 const char ulmax_plus_1[] = "4294967296"; // 0xffffffffUL + 1
1517 const char ulmax_plus_2[] = "4294967297"; // 0xffffffffUL + 2
1518 const char ulmax_plus_3[] = "4294967298"; // 0xffffffffUL + 3
1519 const char ulmax_x_f[] = "0xfffffffff"; // extra 'f' (times 0xf)
1520 const char vflow_1[] = "8589934581";
1521#elif ULONG_MAX > 0xffffffffUL
1522 const char ulmax[] = "18446744073709551615";
1523 const char ulmax_plus_1[] = "18446744073709551616";
1524 const char ulmax_plus_2[] = "18446744073709551617";
1525 const char ulmax_plus_3[] = "18446744073709551618";
1526 const char ulmax_x_f[] = "0xfffffffffffffffff";
1527 const char vflow_1[] = "36893488147419103221";
1528#else
1529 // working around a SunPro bug (PR #28279)
1530 const char ulmax[] = "0";
1531 const char ulmax_plus_1[] = "999999999999999999997";
1532 const char ulmax_plus_2[] = "999999999999999999998";
1533 const char ulmax_plus_3[] = "999999999999999999999";
1534 const char ulmax_x_f[] = "0xfffffffffffffffff";
1535 const char vflow_1[] = "999999999999999999990";
1536#endif
1537
1538 TEST (T, ULONG_MAX, ulmax, INTSIZE (ulmax - 1), 0, Eof);
1539 TEST (T, ULONG_MAX, ulmax_plus_1, INTSIZE (ulmax_plus_1 - 1), 0, Eof | Fail);
1540 TEST (T, ULONG_MAX, ulmax_plus_2, INTSIZE (ulmax_plus_2 - 1), 0, Eof | Fail);
1541 TEST (T, ULONG_MAX, ulmax_plus_3, INTSIZE (ulmax_plus_3 - 1), 0, Eof | Fail);
1542 TEST (T, ULONG_MAX, ulmax_x_f, INTSIZE (ulmax_x_f - 1), 0, Eof | Fail);
1543
1544 TEST (T, ULONG_MAX, vflow_1, INTSIZE (vflow_1 - 1), 0, Eof | Fail);
1545
1546 // verify that the combination of ERANGE and ULONG_MAX
1547 // doesn't trip the facet up if it uses strtoul()
1548 errno = ERANGE;
1549 TEST (T, ULONG_MAX, _RWSTD_STRSTR (_RWSTD_ULONG_MAX), -1, 0, Good);
1550
1551 rw_assert (ERANGE == errno, 0, __LINE__,
1552 "errno unexpectedly changed from %d (%{#*m}) to %d (%{#m})",
1553 ERANGE, ERANGE, errno);
1554
1555 if (rw_opt_no_errno) {
1556 rw_note (0, 0, 0, "errno test disabled");
1557 }
1558 else {
1559 test_errno (ctype, cname, itype, iname, (unsigned long)0);
1560 }
1561
1562#endif // NO_GET_ULONG
1563}
1564
1565
1567static void
1568test_llong (CharType ctype, const char *cname,
1569 IterType itype, const char *iname)
1570{
1571#ifndef NO_GET_LLONG
1572# ifndef _RWSTD_NO_LONG_LONG
1573
1574 const char* const tname = "long long";
1575
1576 rw_info (0, 0, 0, "extension: std::num_get<%s, %s>::get (..., %s&)",
1577 cname, iname, tname);
1578
1579# ifndef _MSC_VER
1580# define LL(number) number ## LL
1581# else // if defined (_MSC_VER)
1582 // MSVC 7.0 doesn't recognize the LL suffix
1583# define LL(number) number ## I64
1584# endif // _MSC_VER
1585
1586 TEST (T, LL ( 0), "0", 1, 0, Eof);
1587 TEST (T, LL ( 1), "1", 1, 0, Eof);
1588 TEST (T, LL ( 12), "12", 2, 0, Eof);
1589 TEST (T, LL ( 123), "123", 3, 0, Eof);
1590 TEST (T, LL ( 1234), "1234", 4, 0, Eof);
1591 TEST (T, LL ( 12345), "12345", 5, 0, Eof);
1592 TEST (T, LL ( 123456), "123456", 6, 0, Eof);
1593 TEST (T, LL ( 1234567), "1234567", 7, 0, Eof);
1594 TEST (T, LL ( 12345678), "12345678", 8, 0, Eof);
1595 TEST (T, LL ( 123456789), "123456789", 9, 0, Eof);
1596 TEST (T, LL ( 1234567890), "1234567890", 10, 0, Eof);
1597 TEST (T, LL ( 12345678901), "12345678901", 11, 0, Eof);
1598 TEST (T, LL ( 123456789012), "123456789012", 12, 0, Eof);
1599 TEST (T, LL ( 1234567890123), "1234567890123", 13, 0, Eof);
1600 TEST (T, LL ( 12345678901234), "12345678901234", 14, 0, Eof);
1601 TEST (T, LL ( 123456789012345), "123456789012345", 15, 0, Eof);
1602 TEST (T, LL ( 1234567890123456), "1234567890123456", 16, 0, Eof);
1603 TEST (T, LL ( 12345678901234567), "12345678901234567", 17, 0, Eof);
1604 TEST (T, LL ( 123456789012345678), "123456789012345678", 18, 0, Eof);
1605 TEST (T, LL (1234567890123456789), "1234567890123456789", 19, 0, Eof);
1606
1607 TEST (T, LL ( 0), "0000000000000000000", 19, dec, Eof);
1608 TEST (T, LL ( 1), "0000000000000000001", 19, dec, Eof);
1609 TEST (T, LL ( 2), "000000000000000002", 18, dec, Eof);
1610 TEST (T, LL ( 3), "00000000000000003", 17, dec, Eof);
1611 TEST (T, LL ( 4), "0000000000000004", 16, dec, Eof);
1612 TEST (T, LL ( 5), "000000000000005", 15, dec, Eof);
1613 TEST (T, LL ( 6), "00000000000006", 14, dec, Eof);
1614 TEST (T, LL ( 7), "0000000000007", 13, dec, Eof);
1615 TEST (T, LL ( 8), "000000000008", 12, dec, Eof);
1616 TEST (T, LL ( 9), "00000000009", 11, dec, Eof);
1617 TEST (T, LL ( 1), "0000000001", 10, dec, Eof);
1618 TEST (T, LL ( 2), "000000002", 9, dec, Eof);
1619 TEST (T, LL ( 3), "00000003", 8, dec, Eof);
1620 TEST (T, LL ( 4), "0000004", 7, dec, Eof);
1621 TEST (T, LL ( 5), "000005", 6, dec, Eof);
1622 TEST (T, LL ( 6), "00006", 5, dec, Eof);
1623 TEST (T, LL ( 7), "0007", 4, dec, Eof);
1624 TEST (T, LL ( 8), "008", 3, dec, Eof);
1625 TEST (T, LL ( 9), "09", 2, dec, Eof);
1626
1627 TEST (T, +LL ( 0), "+0", 2, 0, Eof);
1628 TEST (T, +LL ( 1), "+1", 2, 0, Eof);
1629 TEST (T, +LL ( 12), "+12", 3, 0, Eof);
1630 TEST (T, +LL ( 123), "+123", 4, 0, Eof);
1631 TEST (T, +LL ( 1234), "+1234", 5, 0, Eof);
1632 TEST (T, +LL ( 12345), "+12345", 6, 0, Eof);
1633 TEST (T, +LL ( 123456), "+123456", 7, 0, Eof);
1634 TEST (T, +LL ( 1234567), "+1234567", 8, 0, Eof);
1635 TEST (T, +LL ( 12345678), "+12345678", 9, 0, Eof);
1636 TEST (T, +LL ( 123456789), "+123456789", 10, 0, Eof);
1637 TEST (T, +LL ( 1234567890), "+1234567890", 11, 0, Eof);
1638 TEST (T, +LL ( 12345678901), "+12345678901", 12, 0, Eof);
1639 TEST (T, +LL ( 123456789012), "+123456789012", 13, 0, Eof);
1640 TEST (T, +LL ( 1234567890123), "+1234567890123", 14, 0, Eof);
1641 TEST (T, +LL ( 12345678901234), "+12345678901234", 15, 0, Eof);
1642 TEST (T, +LL ( 123456789012345), "+123456789012345", 16, 0, Eof);
1643 TEST (T, +LL ( 1234567890123456), "+1234567890123456", 17, 0, Eof);
1644 TEST (T, +LL ( 12345678901234567), "+12345678901234567", 18, 0, Eof);
1645 TEST (T, +LL ( 123456789012345678), "+123456789012345678", 19, 0, Eof);
1646 TEST (T, +LL (1234567890123456789), "+1234567890123456789", 20, 0, Eof);
1647
1648 TEST (T, +LL ( 0), "+0000000000000000000", 20, dec, Eof);
1649 TEST (T, +LL ( 1), "+0000000000000000001", 20, dec, Eof);
1650 TEST (T, +LL ( 2), "+000000000000000002", 19, dec, Eof);
1651 TEST (T, +LL ( 3), "+00000000000000003", 18, dec, Eof);
1652 TEST (T, +LL ( 4), "+0000000000000004", 17, dec, Eof);
1653 TEST (T, +LL ( 5), "+000000000000005", 16, dec, Eof);
1654 TEST (T, +LL ( 6), "+00000000000006", 15, dec, Eof);
1655 TEST (T, +LL ( 7), "+0000000000007", 14, dec, Eof);
1656 TEST (T, +LL ( 8), "+000000000008", 13, dec, Eof);
1657 TEST (T, +LL ( 9), "+00000000009", 12, dec, Eof);
1658 TEST (T, +LL ( 1), "+0000000001", 11, dec, Eof);
1659 TEST (T, +LL ( 2), "+000000002", 10, dec, Eof);
1660 TEST (T, +LL ( 3), "+00000003", 9, dec, Eof);
1661 TEST (T, +LL ( 4), "+0000004", 8, dec, Eof);
1662 TEST (T, +LL ( 5), "+000005", 7, dec, Eof);
1663 TEST (T, +LL ( 6), "+00006", 6, dec, Eof);
1664 TEST (T, +LL ( 7), "+0007", 5, dec, Eof);
1665 TEST (T, +LL ( 8), "+008", 4, dec, Eof);
1666 TEST (T, +LL ( 9), "+09", 3, dec, Eof);
1667
1668 TEST (T, -LL ( 0), "-0", 2, 0, Eof);
1669 TEST (T, -LL ( 1), "-1", 2, 0, Eof);
1670 TEST (T, -LL ( 12), "-12", 3, 0, Eof);
1671 TEST (T, -LL ( 123), "-123", 4, 0, Eof);
1672 TEST (T, -LL ( 1234), "-1234", 5, 0, Eof);
1673 TEST (T, -LL ( 12345), "-12345", 6, 0, Eof);
1674 TEST (T, -LL ( 123456), "-123456", 7, 0, Eof);
1675 TEST (T, -LL ( 1234567), "-1234567", 8, 0, Eof);
1676 TEST (T, -LL ( 12345678), "-12345678", 9, 0, Eof);
1677 TEST (T, -LL ( 123456789), "-123456789", 10, 0, Eof);
1678 TEST (T, -LL ( 1234567890), "-1234567890", 11, 0, Eof);
1679 TEST (T, -LL ( 12345678901), "-12345678901", 12, 0, Eof);
1680 TEST (T, -LL ( 123456789012), "-123456789012", 13, 0, Eof);
1681 TEST (T, -LL ( 1234567890123), "-1234567890123", 14, 0, Eof);
1682 TEST (T, -LL ( 12345678901234), "-12345678901234", 15, 0, Eof);
1683 TEST (T, -LL ( 123456789012345), "-123456789012345", 16, 0, Eof);
1684 TEST (T, -LL ( 1234567890123456), "-1234567890123456", 17, 0, Eof);
1685 TEST (T, -LL ( 12345678901234567), "-12345678901234567", 18, 0, Eof);
1686 TEST (T, -LL ( 123456789012345678), "-123456789012345678", 19, 0, Eof);
1687 TEST (T, -LL (1234567890123456789), "-1234567890123456789", 20, 0, Eof);
1688
1689 TEST (T, -LL ( 0), "-0000000000000000000", 20, dec, Eof);
1690 TEST (T, -LL ( 1), "-0000000000000000001", 20, dec, Eof);
1691 TEST (T, -LL ( 2), "-000000000000000002", 19, dec, Eof);
1692 TEST (T, -LL ( 3), "-00000000000000003", 18, dec, Eof);
1693 TEST (T, -LL ( 4), "-0000000000000004", 17, dec, Eof);
1694 TEST (T, -LL ( 5), "-000000000000005", 16, dec, Eof);
1695 TEST (T, -LL ( 6), "-00000000000006", 15, dec, Eof);
1696 TEST (T, -LL ( 7), "-0000000000007", 14, dec, Eof);
1697 TEST (T, -LL ( 8), "-000000000008", 13, dec, Eof);
1698 TEST (T, -LL ( 9), "-00000000009", 12, dec, Eof);
1699 TEST (T, -LL ( 1), "-0000000001", 11, dec, Eof);
1700 TEST (T, -LL ( 2), "-000000002", 10, dec, Eof);
1701 TEST (T, -LL ( 3), "-00000003", 9, dec, Eof);
1702 TEST (T, -LL ( 4), "-0000004", 8, dec, Eof);
1703 TEST (T, -LL ( 5), "-000005", 7, dec, Eof);
1704 TEST (T, -LL ( 6), "-00006", 6, dec, Eof);
1705 TEST (T, -LL ( 7), "-0007", 5, dec, Eof);
1706 TEST (T, -LL ( 8), "-008", 4, dec, Eof);
1707 TEST (T, -LL ( 9), "-09", 3, dec, Eof);
1708
1709 // LLONG_MAX for a 64-bit long long
1710 TEST (T, +LL (9223372036854775807), "+9223372036854775807", 20, 0, Eof);
1711
1712 // compute LLONG_MIN for a 64-bit long long using integer arithmetic
1713 // to avoid warnings due to 9223372036854775808 being too large for
1714 // long long
1715 // e.g., gcc 4.0 issues the following:
1716 // warning: integer constant is so large that it is unsigned
1717 // warning: this decimal constant is unsigned only in ISO C90
1718 TEST (T, -LL (9223372036854775807) - 1, "-9223372036854775808", 20, 0, Eof);
1719
1720 // exercise hex parsing
1721 TEST (T, LL ( 0), "0", 1, hex, Eof);
1722 TEST (T, LL ( 0x1), "1", 1, hex, Eof);
1723 TEST (T, LL ( 0x12), "12", 2, hex, Eof);
1724 TEST (T, LL ( 0x123), "123", 3, hex, Eof);
1725 TEST (T, LL ( 0x1234), "1234", 4, hex, Eof);
1726 TEST (T, LL ( 0x12345), "12345", 5, hex, Eof);
1727 TEST (T, LL ( 0x123456), "123456", 6, hex, Eof);
1728 TEST (T, LL ( 0x1234567), "1234567", 7, hex, Eof);
1729 TEST (T, LL ( 0x12345678), "12345678", 8, hex, Eof);
1730 TEST (T, LL ( 0x123456789), "123456789", 9, hex, Eof);
1731 TEST (T, LL ( 0x123456789a), "123456789a", 10, hex, Eof);
1732 TEST (T, LL ( 0x123456789ab), "123456789ab", 11, hex, Eof);
1733 TEST (T, LL ( 0x123456789abc), "123456789abc", 12, hex, Eof);
1734 TEST (T, LL ( 0x123456789abcd), "123456789abcd", 13, hex, Eof);
1735 TEST (T, LL ( 0x123456789abcde), "123456789abcde", 14, hex, Eof);
1736 TEST (T, LL ( 0x123456789abcdef), "123456789abcdef", 15, hex, Eof);
1737 TEST (T, LL ( 0x123456789abcdef0), "123456789abcdef0", 16, hex, Eof);
1738
1739 TEST (T, LL ( 0), "0x0", 3, hex, Eof);
1740 TEST (T, LL ( 0x1), "0x1", 3, hex, Eof);
1741 TEST (T, LL ( 0x12), "0x12", 4, hex, Eof);
1742 TEST (T, LL ( 0x123), "0x123", 5, hex, Eof);
1743 TEST (T, LL ( 0x1234), "0x1234", 6, hex, Eof);
1744 TEST (T, LL ( 0x12345), "0x12345", 7, hex, Eof);
1745 TEST (T, LL ( 0x123456), "0x123456", 8, hex, Eof);
1746 TEST (T, LL ( 0x1234567), "0x1234567", 9, hex, Eof);
1747 TEST (T, LL ( 0x12345678), "0x12345678", 10, hex, Eof);
1748 TEST (T, LL ( 0x123456789), "0x123456789", 11, hex, Eof);
1749 TEST (T, LL ( 0x123456789a), "0x123456789a", 12, hex, Eof);
1750 TEST (T, LL ( 0x123456789ab), "0x123456789ab", 13, hex, Eof);
1751 TEST (T, LL ( 0x123456789abc), "0x123456789abc", 14, hex, Eof);
1752 TEST (T, LL ( 0x123456789abcd), "0x123456789abcd", 15, hex, Eof);
1753 TEST (T, LL ( 0x123456789abcde), "0x123456789abcde", 16, hex, Eof);
1754 TEST (T, LL ( 0x123456789abcdef), "0x123456789abcdef", 17, hex, Eof);
1755 TEST (T, LL ( 0x123456789abcdef0), "0x123456789abcdef0", 18, hex, Eof);
1756
1757 TEST (T, LL ( 0x0), "00000000000000000000", 20, hex, Eof);
1758 TEST (T, LL ( 0x1), "0000000000000000001", 19, hex, Eof);
1759 TEST (T, LL ( 0x2), "000000000000000002", 18, hex, Eof);
1760 TEST (T, LL ( 0x3), "00000000000000003", 17, hex, Eof);
1761 TEST (T, LL ( 0x4), "0000000000000004", 16, hex, Eof);
1762 TEST (T, LL ( 0x5), "000000000000005", 15, hex, Eof);
1763 TEST (T, LL ( 0x6), "00000000000006", 14, hex, Eof);
1764 TEST (T, LL ( 0x7), "0000000000007", 13, hex, Eof);
1765 TEST (T, LL ( 0x8), "000000000008", 12, hex, Eof);
1766 TEST (T, LL ( 0x9), "00000000009", 11, hex, Eof);
1767 TEST (T, LL ( 0xa), "000000000a", 10, hex, Eof);
1768 TEST (T, LL ( 0xb), "00000000b", 9, hex, Eof);
1769 TEST (T, LL ( 0xc), "0000000c", 8, hex, Eof);
1770 TEST (T, LL ( 0xd), "000000d", 7, hex, Eof);
1771 TEST (T, LL ( 0xe), "00000e", 6, hex, Eof);
1772 TEST (T, LL ( 0xf), "0000f", 5, hex, Eof);
1773 TEST (T, LL ( 0x1), "0001", 4, hex, Eof);
1774 TEST (T, LL ( 0x2), "002", 3, hex, Eof);
1775 TEST (T, LL ( 0x3), "03", 2, hex, Eof);
1776 TEST (T, LL ( 0x4), "4", 1, hex, Eof);
1777
1778 TEST (T, LL ( 0x0), "0x000000000000000000", 20, hex, Eof);
1779 TEST (T, LL ( 0x1), "0x00000000000000001", 19, hex, Eof);
1780 TEST (T, LL ( 0x2), "0x0000000000000002", 18, hex, Eof);
1781 TEST (T, LL ( 0x3), "0x000000000000003", 17, hex, Eof);
1782 TEST (T, LL ( 0x4), "0x00000000000004", 16, hex, Eof);
1783 TEST (T, LL ( 0x5), "0x0000000000005", 15, hex, Eof);
1784 TEST (T, LL ( 0x6), "0x000000000006", 14, hex, Eof);
1785 TEST (T, LL ( 0x7), "0x00000000007", 13, hex, Eof);
1786 TEST (T, LL ( 0x8), "0x0000000008", 12, hex, Eof);
1787 TEST (T, LL ( 0x9), "0x000000009", 11, hex, Eof);
1788 TEST (T, LL ( 0xa), "0x0000000a", 10, hex, Eof);
1789 TEST (T, LL ( 0xb), "0x000000b", 9, hex, Eof);
1790 TEST (T, LL ( 0xc), "0x00000c", 8, hex, Eof);
1791 TEST (T, LL ( 0xd), "0x0000d", 7, hex, Eof);
1792 TEST (T, LL ( 0xe), "0x000e", 6, hex, Eof);
1793 TEST (T, LL ( 0xf), "0x00f", 5, hex, Eof);
1794 TEST (T, LL ( 0x1), "0x01", 4, hex, Eof);
1795 TEST (T, LL ( 0x2), "0x2", 3, hex, Eof);
1796
1797 TEST (T, +LL ( 0x0), "+0", 2, hex, Eof);
1798 TEST (T, +LL ( 0x1), "+1", 2, hex, Eof);
1799 TEST (T, +LL ( 0x12), "+12", 3, hex, Eof);
1800 TEST (T, +LL ( 0x123), "+123", 4, hex, Eof);
1801 TEST (T, +LL ( 0x1234), "+1234", 5, hex, Eof);
1802 TEST (T, +LL ( 0x12345), "+12345", 6, hex, Eof);
1803 TEST (T, +LL ( 0x123456), "+123456", 7, hex, Eof);
1804 TEST (T, +LL ( 0x1234567), "+1234567", 8, hex, Eof);
1805 TEST (T, +LL ( 0x12345678), "+12345678", 9, hex, Eof);
1806 TEST (T, +LL ( 0x123456789), "+123456789", 10, hex, Eof);
1807 TEST (T, +LL ( 0x123456789a), "+123456789a", 11, hex, Eof);
1808 TEST (T, +LL ( 0x123456789ab), "+123456789ab", 12, hex, Eof);
1809 TEST (T, +LL ( 0x123456789abc), "+123456789abc", 13, hex, Eof);
1810 TEST (T, +LL ( 0x123456789abcd), "+123456789abcd", 14, hex, Eof);
1811 TEST (T, +LL ( 0x123456789abcde), "+123456789abcde", 15, hex, Eof);
1812 TEST (T, +LL ( 0x123456789abcdef), "+123456789abcdef", 16, hex, Eof);
1813 TEST (T, +LL ( 0x123456789abcdef0), "+123456789abcdef0", 17, hex, Eof);
1814
1815 TEST (T, +LL ( 0x0), "+0x0", 4, hex, Eof);
1816 TEST (T, +LL ( 0x1), "+0x1", 4, hex, Eof);
1817 TEST (T, +LL ( 0x12), "+0x12", 5, hex, Eof);
1818 TEST (T, +LL ( 0x123), "+0x123", 6, hex, Eof);
1819 TEST (T, +LL ( 0x1234), "+0x1234", 7, hex, Eof);
1820 TEST (T, +LL ( 0x12345), "+0x12345", 8, hex, Eof);
1821 TEST (T, +LL ( 0x123456), "+0x123456", 9, hex, Eof);
1822 TEST (T, +LL ( 0x1234567), "+0x1234567", 10, hex, Eof);
1823 TEST (T, +LL ( 0x12345678), "+0x12345678", 11, hex, Eof);
1824 TEST (T, +LL ( 0x123456789), "+0x123456789", 12, hex, Eof);
1825 TEST (T, +LL ( 0x123456789a), "+0x123456789a", 13, hex, Eof);
1826 TEST (T, +LL ( 0x123456789ab), "+0x123456789ab", 14, hex, Eof);
1827 TEST (T, +LL ( 0x123456789abc), "+0x123456789abc", 15, hex, Eof);
1828 TEST (T, +LL ( 0x123456789abcd), "+0x123456789abcd", 16, hex, Eof);
1829 TEST (T, +LL ( 0x123456789abcde), "+0x123456789abcde", 17, hex, Eof);
1830 TEST (T, +LL ( 0x123456789abcdef), "+0x123456789abcdef", 18, hex, Eof);
1831 TEST (T, +LL ( 0x123456789abcdef0), "+0x123456789abcdef0", 19, hex, Eof);
1832
1833 TEST (T, +LL ( 0x0), "+00000000000000000000", 21, hex, Eof);
1834 TEST (T, +LL ( 0x1), "+0000000000000000001", 20, hex, Eof);
1835 TEST (T, +LL ( 0x2), "+000000000000000002", 19, hex, Eof);
1836 TEST (T, +LL ( 0x3), "+00000000000000003", 18, hex, Eof);
1837 TEST (T, +LL ( 0x4), "+0000000000000004", 17, hex, Eof);
1838 TEST (T, +LL ( 0x5), "+000000000000005", 16, hex, Eof);
1839 TEST (T, +LL ( 0x6), "+00000000000006", 15, hex, Eof);
1840 TEST (T, +LL ( 0x7), "+0000000000007", 14, hex, Eof);
1841 TEST (T, +LL ( 0x8), "+000000000008", 13, hex, Eof);
1842 TEST (T, +LL ( 0x9), "+00000000009", 12, hex, Eof);
1843 TEST (T, +LL ( 0xa), "+000000000a", 11, hex, Eof);
1844 TEST (T, +LL ( 0xb), "+00000000b", 10, hex, Eof);
1845 TEST (T, +LL ( 0xc), "+0000000c", 9, hex, Eof);
1846 TEST (T, +LL ( 0xd), "+000000d", 8, hex, Eof);
1847 TEST (T, +LL ( 0xe), "+00000e", 7, hex, Eof);
1848 TEST (T, +LL ( 0xf), "+0000f", 6, hex, Eof);
1849 TEST (T, +LL ( 0x1), "+0001", 5, hex, Eof);
1850 TEST (T, +LL ( 0x2), "+002", 4, hex, Eof);
1851 TEST (T, +LL ( 0x3), "+03", 3, hex, Eof);
1852 TEST (T, +LL ( 0x4), "+4", 2, hex, Eof);
1853
1854 TEST (T, -LL ( 0x0), "-0", 2, hex, Eof);
1855 TEST (T, -LL ( 0x1), "-1", 2, hex, Eof);
1856 TEST (T, -LL ( 0x12), "-12", 3, hex, Eof);
1857 TEST (T, -LL ( 0x123), "-123", 4, hex, Eof);
1858 TEST (T, -LL ( 0x1234), "-1234", 5, hex, Eof);
1859 TEST (T, -LL ( 0x12345), "-12345", 6, hex, Eof);
1860 TEST (T, -LL ( 0x123456), "-123456", 7, hex, Eof);
1861 TEST (T, -LL ( 0x1234567), "-1234567", 8, hex, Eof);
1862 TEST (T, -LL ( 0x12345678), "-12345678", 9, hex, Eof);
1863 TEST (T, -LL ( 0x123456789), "-123456789", 10, hex, Eof);
1864 TEST (T, -LL ( 0x123456789a), "-123456789a", 11, hex, Eof);
1865 TEST (T, -LL ( 0x123456789ab), "-123456789ab", 12, hex, Eof);
1866 TEST (T, -LL ( 0x123456789abc), "-123456789abc", 13, hex, Eof);
1867 TEST (T, -LL ( 0x123456789abcd), "-123456789abcd", 14, hex, Eof);
1868 TEST (T, -LL ( 0x123456789abcde), "-123456789abcde", 15, hex, Eof);
1869 TEST (T, -LL ( 0x123456789abcdef), "-123456789abcdef", 16, hex, Eof);
1870 TEST (T, -LL ( 0x123456789abcdef0), "-123456789abcdef0", 17, hex, Eof);
1871
1872 TEST (T, -LL ( 0x0), "-00000000000000000000", 21, hex, Eof);
1873 TEST (T, -LL ( 0x1), "-0000000000000000001", 20, hex, Eof);
1874 TEST (T, -LL ( 0x2), "-000000000000000002", 19, hex, Eof);
1875 TEST (T, -LL ( 0x3), "-00000000000000003", 18, hex, Eof);
1876 TEST (T, -LL ( 0x4), "-0000000000000004", 17, hex, Eof);
1877 TEST (T, -LL ( 0x5), "-000000000000005", 16, hex, Eof);
1878 TEST (T, -LL ( 0x6), "-00000000000006", 15, hex, Eof);
1879 TEST (T, -LL ( 0x7), "-0000000000007", 14, hex, Eof);
1880 TEST (T, -LL ( 0x8), "-000000000008", 13, hex, Eof);
1881 TEST (T, -LL ( 0x9), "-00000000009", 12, hex, Eof);
1882 TEST (T, -LL ( 0xa), "-000000000a", 11, hex, Eof);
1883 TEST (T, -LL ( 0xb), "-00000000b", 10, hex, Eof);
1884 TEST (T, -LL ( 0xc), "-0000000c", 9, hex, Eof);
1885 TEST (T, -LL ( 0xd), "-000000d", 8, hex, Eof);
1886 TEST (T, -LL ( 0xe), "-00000e", 7, hex, Eof);
1887 TEST (T, -LL ( 0xf), "-0000f", 6, hex, Eof);
1888 TEST (T, -LL ( 0x1), "-0001", 5, hex, Eof);
1889 TEST (T, -LL ( 0x2), "-002", 4, hex, Eof);
1890 TEST (T, -LL ( 0x3), "-03", 3, hex, Eof);
1891 TEST (T, -LL ( 0x4), "-4", 2, hex, Eof);
1892
1893 if (rw_opt_no_errno) {
1894 rw_note (0, 0, 0, "errno test disabled");
1895 }
1896 else {
1897 test_errno (ctype, cname, itype, iname, (long long)0);
1898 }
1899
1900# endif // _RWSTD_NO_LONG_LONG
1901#endif // NO_GET_LLONG
1902
1903}
1904
1905
1907static void
1908test_ullong (CharType ctype, const char *cname,
1909 IterType itype, const char *iname)
1910{
1911#ifndef NO_GET_ULLONG
1912# ifndef _RWSTD_NO_LONG_LONG
1913
1914 const char* const tname = "unsigned long long";
1915
1916 rw_info (0, 0, 0, "extension: std::num_get<%s, %s>::get (..., %s&)",
1917 cname, iname, tname);
1918
1919# ifndef _MSC_VER
1920# define ULL(number) number ## ULL
1921# else // if defined (_MSC_VER)
1922 // MSVC 7.0 doesn't recognize the LL suffix
1923# define ULL(number) number ## UI64
1924# endif // _MSC_VER
1925
1926 TEST (T, ULL ( 0), "0", 1, 0, Eof);
1927 TEST (T, ULL ( 1), "1", 1, 0, Eof);
1928 TEST (T, ULL ( 12), "12", 2, 0, Eof);
1929 TEST (T, ULL ( 123), "123", 3, 0, Eof);
1930 TEST (T, ULL ( 1234), "1234", 4, 0, Eof);
1931 TEST (T, ULL ( 12345), "12345", 5, 0, Eof);
1932 TEST (T, ULL ( 123456), "123456", 6, 0, Eof);
1933 TEST (T, ULL ( 1234567), "1234567", 7, 0, Eof);
1934 TEST (T, ULL ( 12345678), "12345678", 8, 0, Eof);
1935 TEST (T, ULL ( 123456789), "123456789", 9, 0, Eof);
1936 TEST (T, ULL ( 1234567890), "1234567890", 10, 0, Eof);
1937 TEST (T, ULL ( 12345678901), "12345678901", 11, 0, Eof);
1938 TEST (T, ULL ( 123456789012), "123456789012", 12, 0, Eof);
1939 TEST (T, ULL ( 1234567890123), "1234567890123", 13, 0, Eof);
1940 TEST (T, ULL ( 12345678901234), "12345678901234", 14, 0, Eof);
1941 TEST (T, ULL ( 123456789012345), "123456789012345", 15, 0, Eof);
1942 TEST (T, ULL ( 1234567890123456), "1234567890123456", 16, 0, Eof);
1943 TEST (T, ULL ( 12345678901234567), "12345678901234567", 17, 0, Eof);
1944 TEST (T, ULL ( 123456789012345678), "123456789012345678", 18, 0, Eof);
1945 TEST (T, ULL ( 1234567890123456789), "1234567890123456789", 19, 0, Eof);
1946
1947 TEST (T, ULL ( 0), "0000000000000000000", 19, dec, Eof);
1948 TEST (T, ULL ( 1), "0000000000000000001", 19, dec, Eof);
1949 TEST (T, ULL ( 2), "000000000000000002", 18, dec, Eof);
1950 TEST (T, ULL ( 3), "00000000000000003", 17, dec, Eof);
1951 TEST (T, ULL ( 4), "0000000000000004", 16, dec, Eof);
1952 TEST (T, ULL ( 5), "000000000000005", 15, dec, Eof);
1953 TEST (T, ULL ( 6), "00000000000006", 14, dec, Eof);
1954 TEST (T, ULL ( 7), "0000000000007", 13, dec, Eof);
1955 TEST (T, ULL ( 8), "000000000008", 12, dec, Eof);
1956 TEST (T, ULL ( 9), "00000000009", 11, dec, Eof);
1957 TEST (T, ULL ( 1), "0000000001", 10, dec, Eof);
1958 TEST (T, ULL ( 2), "000000002", 9, dec, Eof);
1959 TEST (T, ULL ( 3), "00000003", 8, dec, Eof);
1960 TEST (T, ULL ( 4), "0000004", 7, dec, Eof);
1961 TEST (T, ULL ( 5), "000005", 6, dec, Eof);
1962 TEST (T, ULL ( 6), "00006", 5, dec, Eof);
1963 TEST (T, ULL ( 7), "0007", 4, dec, Eof);
1964 TEST (T, ULL ( 8), "008", 3, dec, Eof);
1965 TEST (T, ULL ( 9), "09", 2, dec, Eof);
1966
1967 TEST (T, ULL ( 0), "+0", 2, 0, Eof);
1968 TEST (T, ULL ( 1), "+1", 2, 0, Eof);
1969 TEST (T, ULL ( 12), "+12", 3, 0, Eof);
1970 TEST (T, ULL ( 123), "+123", 4, 0, Eof);
1971 TEST (T, ULL ( 1234), "+1234", 5, 0, Eof);
1972 TEST (T, ULL ( 12345), "+12345", 6, 0, Eof);
1973 TEST (T, ULL ( 123456), "+123456", 7, 0, Eof);
1974 TEST (T, ULL ( 1234567), "+1234567", 8, 0, Eof);
1975 TEST (T, ULL ( 12345678), "+12345678", 9, 0, Eof);
1976 TEST (T, ULL ( 123456789), "+123456789", 10, 0, Eof);
1977 TEST (T, ULL ( 1234567890), "+1234567890", 11, 0, Eof);
1978 TEST (T, ULL ( 12345678901), "+12345678901", 12, 0, Eof);
1979 TEST (T, ULL ( 123456789012), "+123456789012", 13, 0, Eof);
1980 TEST (T, ULL ( 1234567890123), "+1234567890123", 14, 0, Eof);
1981 TEST (T, ULL ( 12345678901234), "+12345678901234", 15, 0, Eof);
1982 TEST (T, ULL ( 123456789012345), "+123456789012345", 16, 0, Eof);
1983 TEST (T, ULL ( 1234567890123456), "+1234567890123456", 17, 0, Eof);
1984 TEST (T, ULL ( 12345678901234567), "+12345678901234567", 18, 0, Eof);
1985 TEST (T, ULL ( 123456789012345678), "+123456789012345678", 19, 0, Eof);
1986 TEST (T, ULL ( 1234567890123456789), "+1234567890123456789", 20, 0, Eof);
1987
1988 TEST (T, ULL ( 0), "+0000000000000000000", 20, dec, Eof);
1989 TEST (T, ULL ( 1), "+0000000000000000001", 20, dec, Eof);
1990 TEST (T, ULL ( 2), "+000000000000000002", 19, dec, Eof);
1991 TEST (T, ULL ( 3), "+00000000000000003", 18, dec, Eof);
1992 TEST (T, ULL ( 4), "+0000000000000004", 17, dec, Eof);
1993 TEST (T, ULL ( 5), "+000000000000005", 16, dec, Eof);
1994 TEST (T, ULL ( 6), "+00000000000006", 15, dec, Eof);
1995 TEST (T, ULL ( 7), "+0000000000007", 14, dec, Eof);
1996 TEST (T, ULL ( 8), "+000000000008", 13, dec, Eof);
1997 TEST (T, ULL ( 9), "+00000000009", 12, dec, Eof);
1998 TEST (T, ULL ( 1), "+0000000001", 11, dec, Eof);
1999 TEST (T, ULL ( 2), "+000000002", 10, dec, Eof);
2000 TEST (T, ULL ( 3), "+00000003", 9, dec, Eof);
2001 TEST (T, ULL ( 4), "+0000004", 8, dec, Eof);
2002 TEST (T, ULL ( 5), "+000005", 7, dec, Eof);
2003 TEST (T, ULL ( 6), "+00006", 6, dec, Eof);
2004 TEST (T, ULL ( 7), "+0007", 5, dec, Eof);
2005 TEST (T, ULL ( 8), "+008", 4, dec, Eof);
2006 TEST (T, ULL ( 9), "+09", 3, dec, Eof);
2007
2008 TEST (T, ULL ( 0), "-0", 2, 0, Eof);
2009 TEST (T, ULL (18446744073709551615), "-1", 2, 0, Eof);
2010 TEST (T, ULL (18446744073709551604), "-12", 3, 0, Eof);
2011 TEST (T, ULL (18446744073709551493), "-123", 4, 0, Eof);
2012 TEST (T, ULL (18446744073709550382), "-1234", 5, 0, Eof);
2013 TEST (T, ULL (18446744073709539271), "-12345", 6, 0, Eof);
2014 TEST (T, ULL (18446744073709428160), "-123456", 7, 0, Eof);
2015 TEST (T, ULL (18446744073708317049), "-1234567", 8, 0, Eof);
2016 TEST (T, ULL (18446744073697205938), "-12345678", 9, 0, Eof);
2017 TEST (T, ULL (18446744073586094827), "-123456789", 10, 0, Eof);
2018 TEST (T, ULL (18446744072474983726), "-1234567890", 11, 0, Eof);
2019 TEST (T, ULL (18446744061363872715), "-12345678901", 12, 0, Eof);
2020 TEST (T, ULL (18446743950252762604), "-123456789012", 13, 0, Eof);
2021 TEST (T, ULL (18446742839141661493), "-1234567890123", 14, 0, Eof);
2022 TEST (T, ULL (18446731728030650382), "-12345678901234", 15, 0, Eof);
2023 TEST (T, ULL (18446620616920539271), "-123456789012345", 16, 0, Eof);
2024 TEST (T, ULL (18445509505819428160), "-1234567890123456", 17, 0, Eof);
2025 TEST (T, ULL (18434398394808317049), "-12345678901234567", 18, 0, Eof);
2026 TEST (T, ULL (18323287284697205938), "-123456789012345678", 19, 0, Eof);
2027 TEST (T, ULL (17212176183586094827), "-1234567890123456789", 20, 0, Eof);
2028
2029 TEST (T, ULL ( 0), "-0000000000000000000", 20, dec, Eof);
2030 TEST (T, ULL (18446744073709551615), "-0000000000000000001", 20, dec, Eof);
2031 TEST (T, ULL (18446744073709551614), "-000000000000000002", 19, dec, Eof);
2032 TEST (T, ULL (18446744073709551613), "-00000000000000003", 18, dec, Eof);
2033 TEST (T, ULL (18446744073709551612), "-0000000000000004", 17, dec, Eof);
2034 TEST (T, ULL (18446744073709551611), "-000000000000005", 16, dec, Eof);
2035 TEST (T, ULL (18446744073709551610), "-00000000000006", 15, dec, Eof);
2036 TEST (T, ULL (18446744073709551609), "-0000000000007", 14, dec, Eof);
2037 TEST (T, ULL (18446744073709551608), "-000000000008", 13, dec, Eof);
2038 TEST (T, ULL (18446744073709551607), "-00000000009", 12, dec, Eof);
2039 TEST (T, ULL (18446744073709551615), "-0000000001", 11, dec, Eof);
2040 TEST (T, ULL (18446744073709551614), "-000000002", 10, dec, Eof);
2041 TEST (T, ULL (18446744073709551613), "-00000003", 9, dec, Eof);
2042 TEST (T, ULL (18446744073709551612), "-0000004", 8, dec, Eof);
2043 TEST (T, ULL (18446744073709551611), "-000005", 7, dec, Eof);
2044 TEST (T, ULL (18446744073709551610), "-00006", 6, dec, Eof);
2045 TEST (T, ULL (18446744073709551609), "-0007", 5, dec, Eof);
2046 TEST (T, ULL (18446744073709551608), "-008", 4, dec, Eof);
2047 TEST (T, ULL (18446744073709551607), "-09", 3, dec, Eof);
2048
2049 TEST (T, ULL (18446744073709551615), "18446744073709551615", 20, 0, Eof);
2050 TEST (T, ULL (18446744073709551615), "018446744073709551615", 21, dec, Eof);
2051 TEST (T, ULL (18446744073709551615), "+18446744073709551615", 21, 0, Eof);
2052
2053 // exercise hex parsing
2054 TEST (T, ULL ( 0x0), "0x0", 3, hex, Eof);
2055 TEST (T, ULL ( 0x1), "0x1", 3, hex, Eof);
2056 TEST (T, ULL ( 0x12), "0x12", 4, hex, Eof);
2057 TEST (T, ULL ( 0x123), "0x123", 5, hex, Eof);
2058 TEST (T, ULL ( 0x1234), "0x1234", 6, hex, Eof);
2059 TEST (T, ULL ( 0x12345), "0x12345", 7, hex, Eof);
2060 TEST (T, ULL ( 0x123456), "0x123456", 8, hex, Eof);
2061 TEST (T, ULL ( 0x1234567), "0x1234567", 9, hex, Eof);
2062 TEST (T, ULL ( 0x12345678), "0x12345678", 10, hex, Eof);
2063 TEST (T, ULL ( 0x123456789), "0x123456789", 11, hex, Eof);
2064 TEST (T, ULL ( 0x123456789a), "0x123456789a", 12, hex, Eof);
2065 TEST (T, ULL ( 0x123456789ab), "0x123456789ab", 13, hex, Eof);
2066 TEST (T, ULL ( 0x123456789abc), "0x123456789abc", 14, hex, Eof);
2067 TEST (T, ULL ( 0x123456789abcd), "0x123456789abcd", 15, hex, Eof);
2068 TEST (T, ULL ( 0x123456789abcde), "0x123456789abcde", 16, hex, Eof);
2069 TEST (T, ULL ( 0x123456789abcdef), "0x123456789abcdef", 17, hex, Eof);
2070 TEST (T, ULL ( 0x123456789abcdef0), "0x123456789abcdef0", 18, hex, Eof);
2071
2072 if (rw_opt_no_errno) {
2073 rw_note (0, 0, 0, "errno test disabled");
2074 }
2075 else {
2076 test_errno (ctype, cname, itype, iname, (unsigned long long)0);
2077 }
2078
2079# endif // _RWSTD_NO_LONG_LONG
2080#endif // NO_GET_ULLONG
2081
2082}
2083
2084
2086static void
2087test_pvoid (CharType ctype, const char *cname,
2088 IterType itype, const char *iname)
2089{
2090#ifndef NO_GET_PVOID
2091
2092 const char* const tname = "void*";
2093
2094 rw_info (0, 0, 0, "std::num_get<%s, %s>::get (..., %s&)",
2095 cname, iname, tname);
2096
2097 typedef void* PVoid;
2098
2099 TEST (T, PVoid ( 0), "0", 1, 0, Eof);
2100 TEST (T, PVoid ( 1), "1", 1, 0, Eof);
2101 TEST (T, PVoid ( 2), "2", 1, 0, Eof);
2102 TEST (T, PVoid ( 3), "03", 2, 0, Eof);
2103 TEST (T, PVoid (0x000000ff), "ff", 2, 0, Eof);
2104 TEST (T, PVoid (0x00000fff), "FFF", 3, 0, Eof);
2105 TEST (T, PVoid (0x0000ffff), "FfFf", 4, 0, Eof);
2106
2107 // exercise overflow conditions
2108#if defined (_RWSTD_LONG_LONG) && _RWSTD_PTR_SIZE > _RWSTD_LONG_SIZE \
2109 || ULONG_MAX > 0xffffffffUL
2110 const char pvmax[] = "0xffffffffffffffff";
2111 const char pvmax_plus_1[] = "0x10000000000000000";
2112#elif ULONG_MAX == 0xffffUL
2113 const char pvmax[] = "0xffff";
2114 const char pvmax_plus_1[] = "0x10000";
2115#elif ULONG_MAX == 0xffffffffUL
2116 const char pvmax[] = "0xffffffff";
2117 const char pvmax_plus_1[] = "0x100000000";
2118#else
2119 // working around a SunPro bug (PR #28279)
2120 const char pvmax[] = "0";
2121 const char pvmax_plus_1[] = "0xffffffffffffffffffffffffffffffff";
2122#endif
2123
2124#define PVOIDSTR(name) name, INTSIZE (name - 1)
2125
2126 TEST (T, PVoid (~0), PVOIDSTR (pvmax), 0, Eof);
2127 TEST (T, PVoid (~0), PVOIDSTR (pvmax_plus_1), 0, Eof | Fail);
2128
2129#undef PVOIDSTR
2130
2131 // exercise error conditions
2132 TEST (T, PVoid (0), "", 0, 0, Eof | Fail);
2133 TEST (T, PVoid (0), "-", 1, 0, Eof | Fail);
2134 TEST (T, PVoid (0), "+", 1, 0, Eof | Fail);
2135 TEST (T, PVoid (0), "x", 0, 0, Fail);
2136
2137#endif // NO_GET_PVOID
2138}
2139
2140
2142template <class floatT>
2143void test_floating_point (CharType ctype, const char *cname,
2144 IterType itype, const char *iname,
2145 floatT, bool test_locale)
2146{
2147 const char* const tname = rw_any_t (floatT ()).type_name ();
2148
2149 PunctData::thousands_sep_ = ';';
2150
2151 typedef floatT F;
2152
2153 TEST (T, F (0.0), "0", 1, 0, Eof);
2154 TEST (T, F (0.0), "0.", 2, 0, Eof);
2155 TEST (T, F (0.0), ".0", 2, 0, Eof);
2156 TEST (T, F (0.0), "0.0", 3, 0, Eof);
2157 TEST (T, F (1.0), "1", 1, 0, Eof);
2158 TEST (T, F (2.0), "2", 1, 0, Eof);
2159 TEST (T, F (3.0), "3", 1, 0, Eof);
2160 TEST (T, F (4.0), "4 ", 1, 0, Good); // trailing ' ' not extracted
2161 TEST (T, F (5.0), "5.", 2, 0, Eof); // trailing '.' extracted
2162 TEST (T, F (5.0), "5.0", 3, 0, Eof);
2163 TEST (T, F (5.1), "5.1", 3, 0, Eof);
2164 TEST (T, F (5.2), "5.2 ", 3, 0, Good); // trailing ' ' not extracted
2165 TEST (T, F (5.3), "5.3;", 3, 0, Good); // trailing ';' not extracted
2166 TEST (T, F (5.4), "5.4; ", 3, 0, Good);
2167 TEST (T, F (5.41), "5.41", 4, 0, Eof);
2168 TEST (T, F (5.42), "5.42.", 4, 0, Good); // trailing '.' not extracted
2169 TEST (T, F (5.43), "5.43+", 4, 0, Good); // trailing '+' not extracted
2170 TEST (T, F (5.44), "5.44-", 4, 0, Good); // trailing '-' not extracted
2171
2172 TEST (T, F (1.0e+00), "1", 1, 0, Eof);
2173 TEST (T, F (1.0e+01), "10", 2, 0, Eof);
2174 TEST (T, F (1.0e+02), "100", 3, 0, Eof);
2175 TEST (T, F (1.0e+03), "1000", 4, 0, Eof);
2176 TEST (T, F (1.0e+04), "10000", 5, 0, Eof);
2177 TEST (T, F (1.0e+05), "100000", 6, 0, Eof);
2178 TEST (T, F (1.0e+06), "1000000", 7, 0, Eof);
2179 TEST (T, F (1.0e+07), "10000000", 8, 0, Eof);
2180 TEST (T, F (1.0e+08), "100000000", 9, 0, Eof);
2181 TEST (T, F (1.0e+09), "1000000000", 10, 0, Eof);
2182 TEST (T, F (1.0e+10), "10000000000", 11, 0, Eof);
2183 TEST (T, F (1.0e+11), "100000000000", 12, 0, Eof);
2184 TEST (T, F (1.0e+12), "1000000000000", 13, 0, Eof);
2185 TEST (T, F (1.0e+13), "10000000000000", 14, 0, Eof);
2186 TEST (T, F (1.0e+14), "100000000000000", 15, 0, Eof);
2187 TEST (T, F (1.0e+15), "1000000000000000", 16, 0, Eof);
2188 TEST (T, F (1.0e+16), "10000000000000000", 17, 0, Eof);
2189 TEST (T, F (1.0e+17), "100000000000000000", 18, 0, Eof);
2190 TEST (T, F (1.0e+18), "1000000000000000000", 19, 0, Eof);
2191 TEST (T, F (1.0e+19), "10000000000000000000", 20, 0, Eof);
2192 TEST (T, F (1.0e+20), "100000000000000000000", 21, 0, Eof);
2193 TEST (T, F (1.0e+21), "1000000000000000000000", 22, 0, Eof);
2194 TEST (T, F (1.0e+22), "10000000000000000000000", 23, 0, Eof);
2195 TEST (T, F (1.0e+23), "100000000000000000000000", 24, 0, Eof);
2196 TEST (T, F (1.0e+24), "1000000000000000000000000", 25, 0, Eof);
2197 TEST (T, F (1.0e+25), "10000000000000000000000000", 26, 0, Eof);
2198 TEST (T, F (1.0e+26), "100000000000000000000000000", 27, 0, Eof);
2199 TEST (T, F (1.0e+27), "1000000000000000000000000000", 28, 0, Eof);
2200 TEST (T, F (1.0e+28), "10000000000000000000000000000", 29, 0, Eof);
2201 TEST (T, F (1.0e+29), "100000000000000000000000000000", 30, 0, Eof);
2202
2203#define VALSTR(x) floatT (x), #x, int (std::strlen (#x))
2204
2205 // exercise various forms of floating point 0
2206
2207 TEST (T, VALSTR ( 0.), 0, Eof);
2208 TEST (T, VALSTR (+0.), 0, Eof);
2209 TEST (T, VALSTR (-0.), 0, Eof);
2210
2211 TEST (T, VALSTR ( .0), 0, Eof);
2212 TEST (T, VALSTR (+.0), 0, Eof);
2213 TEST (T, VALSTR (-.0), 0, Eof);
2214
2215 TEST (T, VALSTR ( 0e0), 0, Eof);
2216 TEST (T, VALSTR (+0e0), 0, Eof);
2217 TEST (T, VALSTR (-0e0), 0, Eof);
2218
2219 TEST (T, VALSTR ( 0E+0), 0, Eof);
2220 TEST (T, VALSTR (+0E-0), 0, Eof);
2221 TEST (T, VALSTR (-0E+0), 0, Eof);
2222
2223 TEST (T, VALSTR ( 0.0e+0), 0, Eof);
2224 TEST (T, VALSTR (+0.0e+0), 0, Eof);
2225 TEST (T, VALSTR (-0.0e+0), 0, Eof);
2226
2227 TEST (T, VALSTR ( 0.0E+0), 0, Eof);
2228 TEST (T, VALSTR (+0.0E+0), 0, Eof);
2229 TEST (T, VALSTR (-0.0E+0), 0, Eof);
2230
2231 // exercise 'e' immediately following decimal_point
2232 TEST (T, VALSTR ( 0.e+0), 0, Eof);
2233 TEST (T, VALSTR (+0.e+0), 0, Eof);
2234 TEST (T, VALSTR (-0.e+0), 0, Eof);
2235
2236 // same as above but with an 'E'
2237 TEST (T, VALSTR ( 0.E+0), 0, Eof);
2238 TEST (T, VALSTR (+0.E+0), 0, Eof);
2239 TEST (T, VALSTR (-0.E+0), 0, Eof);
2240
2241 // exercise 0 with a non-zero exponent
2242 TEST (T, VALSTR ( 0.0e+1), 0, Eof);
2243 TEST (T, VALSTR ( 0.0e2), 0, Eof);
2244 TEST (T, VALSTR (+0.0e+3), 0, Eof);
2245 TEST (T, VALSTR (+0.0e4), 0, Eof);
2246 TEST (T, VALSTR (-0.0e+5), 0, Eof);
2247 TEST (T, VALSTR (-0.0e+6), 0, Eof);
2248
2249 TEST (T, VALSTR ( 0.0E+7), 0, Eof);
2250 TEST (T, VALSTR ( 0.0E8), 0, Eof);
2251 TEST (T, VALSTR (+0.0E+9), 0, Eof);
2252 TEST (T, VALSTR (+0.0E10), 0, Eof);
2253 TEST (T, VALSTR (-0.0E+11), 0, Eof);
2254 TEST (T, VALSTR (-0.0E+12), 0, Eof);
2255
2256 // exercise 0 with a negative exponent
2257 TEST (T, VALSTR ( 0.0e-1), 0, Eof);
2258 TEST (T, VALSTR (+0.0e-2), 0, Eof);
2259 TEST (T, VALSTR (-0.0e-3), 0, Eof);
2260
2261 // exercise formats with no digits before decimal_point
2262 TEST (T, VALSTR ( .0e1), 0, Eof);
2263 TEST (T, VALSTR ( .0e+2), 0, Eof);
2264 TEST (T, VALSTR (+.0e+3), 0, Eof);
2265 TEST (T, VALSTR (-.0e+4), 0, Eof);
2266
2267 TEST (T, VALSTR (1.0e+0), 0, Eof);
2268 TEST (T, VALSTR (1.0e+2), 0, Eof);
2269 TEST (T, VALSTR (1.2e+3), 0, Eof);
2270 TEST (T, VALSTR (1.3e-4), 0, Eof);
2271 TEST (T, VALSTR (1.4e5), 0, Eof);
2272 TEST (T, VALSTR (1.e+6), 0, Eof);
2273 TEST (T, VALSTR (1.e-7), 0, Eof);
2274 TEST (T, VALSTR (1e+8), 0, Eof);
2275 TEST (T, VALSTR (1e-9), 0, Eof);
2276 TEST (T, VALSTR (1e10), 0, Eof);
2277
2278 TEST (T, VALSTR (+2.0e+0), 0, Eof);
2279 TEST (T, VALSTR (+2.0e+2), 0, Eof);
2280 TEST (T, VALSTR (+2.2e+3), 0, Eof);
2281 TEST (T, VALSTR (+2.3e-4), 0, Eof);
2282 TEST (T, VALSTR (+2.4e5), 0, Eof);
2283 TEST (T, VALSTR (+2.e+6), 0, Eof);
2284 TEST (T, VALSTR (+2.e-7), 0, Eof);
2285 TEST (T, VALSTR (+2e+8), 0, Eof);
2286 TEST (T, VALSTR (+2e-9), 0, Eof);
2287 TEST (T, VALSTR (+2e10), 0, Eof);
2288
2289 TEST (T, VALSTR (-3.0e+0), 0, Eof);
2290 TEST (T, VALSTR (-3.0e+2), 0, Eof);
2291 TEST (T, VALSTR (-3.2e+3), 0, Eof);
2292 TEST (T, VALSTR (-3.3e-4), 0, Eof);
2293 TEST (T, VALSTR (-3.4e5), 0, Eof);
2294 TEST (T, VALSTR (-3.e+6), 0, Eof);
2295 TEST (T, VALSTR (-3.e-7), 0, Eof);
2296 TEST (T, VALSTR (-3e+8), 0, Eof);
2297 TEST (T, VALSTR (-3e-9), 0, Eof);
2298 TEST (T, VALSTR (-3e10), 0, Eof);
2299
2300 // test with grouping (thousands_sep are optional in that they either
2301 // may or may not appear; if one appears, correct grouping is enforced)
2302 TEST (T, F (1.0e+29), "100000000000000000000000000000", 30, 0, Eof, "\1");
2303
2304 // empty grouping, the first thousands_sep terminates parsing
2305 TEST (T, F (1.0),
2306 "1;0;0;0;0;0;0;0;0;0;0;0;0;0;0;0;0;0;0;0;0;0;0;0;0;0;0;0;0;0",
2307 1, 0, Good, "\0");
2308
2309 TEST (T, F (1.0e+29),
2310 "1;0;0;0;0;0;0;0;0;0;0;0;0;0;0;0;0;0;0;0;0;0;0;0;0;0;0;0;0;0",
2311 59, 0, Eof, "\1");
2312
2313 // lwg issue 358: thousands_sep is only interpreted as such and extracted
2314 // in the integral part of a floating point number; it is considered as
2315 // an invalid character that terminates input once the decimal point has
2316 // been encountered
2317 // 0....:....1....
2318 TEST (T, F (123456.789), "123;456.789;012", 11, 0, Good, "\3");
2319 TEST (T, F (123456.780), "123;456.78;9012", 10, 0, Good, "\3");
2320 TEST (T, F (123456.700), "123;456.7;89012", 9, 0, Good, "\3");
2321 TEST (T, F (123456.000), "123;456.;789012", 8, 0, Good, "\3");
2322 TEST (T, F (123456e+1), "123;456e+1;2345", 10, 0, Good, "\3");
2323 TEST (T, F (123456e+2), "123;456e2;34567", 9, 0, Good, "\3");
2324 TEST (T, F (123456e+3), "123456e3;456789", 8, 0, Good, "\3");
2325 TEST (T, F (123456.e+2), "123;456.e+2;345", 11, 0, Good, "\3");
2326 TEST (T, F (123456.e+3), "123;456.e3;4567", 10, 0, Good, "\3");
2327 TEST (T, F (123456.e+4), "123456.e4;56789", 9, 0, Good, "\3");
2328
2329 // exercise behavior on invalid sequences disallowed by the grammar
2330 TEST (T, F (0.0), "", 0, 0, Eof | Fail);
2331 TEST (T, F (0.0), ".", 1, 0, Eof | Fail);
2332 TEST (T, F (0.0), "..", 1, 0, Fail);
2333 TEST (T, F (0.0), ".+", 1, 0, Fail);
2334 TEST (T, F (0.0), ".-", 1, 0, Fail);
2335 TEST (T, F (0.0), ".e", 1, 0, Fail);
2336 TEST (T, F (0.0), ".E", 1, 0, Fail);
2337
2338 TEST (T, F (0.0), "+", 1, 0, Eof | Fail);
2339 TEST (T, F (0.0), "+.", 2, 0, Eof | Fail);
2340 TEST (T, F (0.0), "++", 1, 0, Fail);
2341 TEST (T, F (0.0), "+-", 1, 0, Fail);
2342 TEST (T, F (0.0), "+e", 1, 0, Fail);
2343 TEST (T, F (0.0), "+E", 1, 0, Fail);
2344
2345 TEST (T, F (0.0), "-", 1, 0, Eof | Fail);
2346 TEST (T, F (0.0), "-.", 2, 0, Eof | Fail);
2347 TEST (T, F (0.0), "-+", 1, 0, Fail);
2348 TEST (T, F (0.0), "--", 1, 0, Fail);
2349 TEST (T, F (0.0), "-e", 1, 0, Fail);
2350 TEST (T, F (0.0), "-E", 1, 0, Fail);
2351
2352 TEST (T, F (0.0), ".;", 1, 0, Fail);
2353 TEST (T, F (0.0), ";.;", 0, 0, Fail);
2354
2355 // exercise lwg issue 338 (whitespace after sign not allowed)
2356 TEST (T, F (0.0), "+ 1", 1, 0, Fail);
2357 TEST (T, F (0.0), "- 2", 1, 0, Fail);
2358 TEST (T, F (0.0), "3.0e+ 1", 5, 0, Fail);
2359 TEST (T, F (0.0), "4.0e- 2", 5, 0, Fail);
2360
2361 // exercise the ability to parse input in locales where thousands_sep
2362 // is the plus or minus character (e.g., on AIX, the Romanian locale,
2363 // "RO_RO" -- see bug #609)
2364
2365 PunctData::thousands_sep_ = '+';
2366
2367 TEST (T, F ( 123e+4), "123e+4", 6, 0, Eof, "\1");
2368 TEST (T, F ( 124e+5), "124e+5", 6, 0, Eof, "\1");
2369 TEST (T, F (+125e+6), "+125e+6", 7, 0, Eof, "\1");
2370 TEST (T, F (-126e+7), "-126e+7", 7, 0, Eof, "\1");
2371 TEST (T, F (-127e-8), "-127e-8", 7, 0, Eof, "\1");
2372
2373 PunctData::thousands_sep_ = '-';
2374
2375 TEST (T, F ( 123e-4), "123e-4", 6, 0, Eof, "\1");
2376 TEST (T, F ( 124e-5), "124e-5", 6, 0, Eof, "\1");
2377 TEST (T, F (+125e-6), "+125e-6", 7, 0, Eof, "\1");
2378 TEST (T, F (+126e-7), "+126e-7", 7, 0, Eof, "\1");
2379 TEST (T, F (+127e+8), "+127e+8", 7, 0, Eof, "\1");
2380
2381 // restore to a saner value
2382 PunctData::thousands_sep_ = ';';
2383
2384 if (test_locale) {
2385 // verify that the global LC_NUMERIC locale setting
2386 // has no impact on the facet (in case it uses scanf())
2387 for (const char *name = rw_locales (LC_NUMERIC, 0); name && *name;
2388 name += std::strlen (name) + 1) {
2389
2390 // find the first locale whose decimal_point character
2391 // is different than in the classic C locale (i.e., than '.')
2392 if (0 == std::setlocale (LC_NUMERIC, name))
2393 continue;
2394
2395 const std::lconv* const conv = std::localeconv ();
2396
2397 if (!conv)
2398 continue;
2399
2400 if (conv->decimal_point && '.' != *conv->decimal_point) {
2401 rw_info (0, 0, 0,
2402 "num_get<%s, %s>::get(..., %s&) when "
2403 "LC_NUMERIC=\"%s\"",
2404 cname, iname, tname, name);
2405 break;
2406 }
2407 }
2408
2409 TEST (T, F ( 1.2e+34), "1.2e+34", 7, 0, Eof);
2410 TEST (T, F (+1.3e+33), "+1.3e+33", 8, 0, Eof);
2411 TEST (T, F (-1.4e+32), "-1.4e+32", 8, 0, Eof);
2412 TEST (T, F ( 0.5e+31), ".5e+31", 6, 0, Eof);
2413 TEST (T, F (+0.6e+30), "+.6e+30", 7, 0, Eof);
2414 TEST (T, F (-0.7e+29), "-.7e+29", 7, 0, Eof);
2415
2416 // reset the global locale
2417 std::setlocale (LC_NUMERIC, "C");
2418 }
2419 else
2420 rw_warn (0, 0, 0,
2421 "num_get<%s, %s>::get (..., %s&) known to fail when "
2422 "LC_NUMERIC is set to a locale where decimal_point != '.'",
2423 cname, iname, tname);
2424
2426 // exercise errno
2427 if (rw_opt_no_errno) {
2428 rw_note (0, 0, 0, "errno test disabled");
2429 }
2430 else {
2431 test_errno (ctype, cname, itype, iname, floatT ());
2432 }
2433
2434}
2435
2436
2437
2439static void
2440test_flt_uflow (CharType ctype, const char *cname,
2441 IterType itype, const char *iname)
2442{
2443#ifndef NO_GET_FLT
2444
2445 rw_info (0, 0, 0,
2446 "std::num_get<%s, %s>::get (..., float&) on underflow",
2447 cname, iname);
2448
2449 // exercise bahvior on underflow
2450 static float val = 0;
2451 pmax = &val;
2452
2453 // on underflow, get() follows C99 requirements on strtof()
2454 // i.e., it stores a value in the range [0, +/-FLT_MIN]
2455 // the function does NOT set failbit on underflow (regardless
2456 // of whether strtof() sets errno)
2457 // If the result underflows (7.12.1), the functions return
2458 // a value whose magnitude is no greater than the smallest
2459 // normalized positive number in the return type; whether
2460 // errno acquires the value ERANGE is implementation-defined.
2461
2462 TEST (T, (val = FLT_MIN, 0.0f), "1.111111e-9999", 14, 0, Eof);
2463 rw_assert (!(val < 0.0), 0, __LINE__,
2464 "correct sign after positive underflow");
2465
2466 TEST (T, (val = 0.0f, -FLT_MIN), "-1.111111e-9999", 15, 0, Eof);
2467 rw_assert (!(val > 0.0), 0, __LINE__,
2468 "correct sign after negative underflow");
2469
2470 if (1.234567e-39 < FLT_MIN) {
2471 TEST (T, (val = FLT_MIN, 0.0f), "1.234567e-39", 12, 0, Eof);
2472 TEST (T, (val = 0.0f, -FLT_MIN), "-1.234567e-39", 13, 0, Eof);
2473 }
2474
2475 if (1.234567e-49 < FLT_MIN) {
2476 TEST (T, (val = FLT_MIN, 0.0f), "1.234567e-49", 12, 0, Eof);
2477 TEST (T, (val = 0.0f, -FLT_MIN), "-1.234567e-49", 13, 0, Eof);
2478 }
2479
2480 if (1.234567e-99 < FLT_MIN) {
2481 TEST (T, (val = FLT_MIN, 0.0f), "1.234567e-99", 12, 0, Eof);
2482 TEST (T, (val = 0.0f, -FLT_MIN), "-1.234567e-99", 13, 0, Eof);
2483 }
2484
2485 // exercise facet's behavior on underflow:
2486 // parsing succeeds (fail is clear), +/-min is stored
2487 TEST (T, FLT_MIN, _RWSTD_STRSTR ( _RWSTD_DBL_MIN), -1, 0, Eof);
2488 TEST (T, -FLT_MIN, _RWSTD_STRSTR (-_RWSTD_DBL_MIN), -1, 0, Eof);
2489
2490 pmax = 0; // reset before next test
2491
2492
2493 rw_info (0, 0, 0, "std::num_get<%s, %s>::get (..., float&) on overflow",
2494 cname, iname);
2495
2496 const float inf = std::numeric_limits<float>::infinity ();
2497
2498 // on overflow, get() follows C99 requirements on strtof()
2499 // it sets failbit
2500 TEST (T, inf, _RWSTD_STRSTR ( _RWSTD_DBL_MAX), -1, 0, Eof | Fail);
2501 TEST (T, -inf, _RWSTD_STRSTR (-_RWSTD_DBL_MAX), -1, 0, Eof | Fail);
2502
2503 if (9.876543e+39 > FLT_MAX) {
2504 TEST (T, inf, "9.876543e+39", 12, 0, Eof | Fail);
2505 TEST (T, -inf, "-9.876543e+39", 13, 0, Eof | Fail);
2506 }
2507
2508 if (9.876543e+49 > FLT_MAX) {
2509 TEST (T, inf, "9.876543e+49", 12, 0, Eof | Fail);
2510 TEST (T, -inf, "-9.876543e+49", 13, 0, Eof | Fail);
2511 }
2512
2513 if (9.876543e+99 > FLT_MAX) {
2514 TEST (T, inf, "9.876543e+99", 12, 0, Eof | Fail);
2515 TEST (T, -inf, "-9.876543e+99", 13, 0, Eof | Fail);
2516 }
2517
2518 TEST (T, inf, "9.999999e+9999", 14, 0, Eof | Fail);
2519 TEST (T, -inf, "-9.999999e+9999", 15, 0, Eof | Fail);
2520
2521
2522 // exercise facet's behavior on overflow:
2523 // parsing fails (fail is set) and +/-infinity is stored
2524
2525 TEST (T, inf, _RWSTD_STRSTR ( _RWSTD_DBL_MAX), -1, 0, Eof | Fail);
2526 TEST (T, -inf, _RWSTD_STRSTR (-_RWSTD_DBL_MAX), -1, 0, Eof | Fail);
2527
2528# ifdef _RWSTD_LDBL_MAX
2529
2530 std::ios_base::iostate state = Fail;
2531
2532 // eofbit set unless LDBL_MAX ends in an 'L' or 'l'
2533 // (it may not when it's the same as double)
2534 if (0 == std::strpbrk (_RWSTD_STRSTR (_RWSTD_LDBL_MAX), "Ll"))
2535 state |= Eof;
2536
2537 TEST (T, inf, _RWSTD_STRSTR ( _RWSTD_LDBL_MAX), -1, 0, state);
2538 TEST (T, -inf, _RWSTD_STRSTR (-_RWSTD_LDBL_MAX), -1, 0, state);
2539
2540# endif // _RWSTD_LDBL_MAX
2541
2542
2543#else // if defined (NO_GET_FLT)
2544
2545 _RWSTD_UNUSED (t);
2546
2547#endif // NO_GET_FLT
2548
2549}
2550
2551
2553static void
2554test_flt (CharType ctype, const char *cname,
2555 IterType itype, const char *iname)
2556{
2557#ifndef NO_GET_FLT
2558
2559 const char* const tname = "float";
2560
2561 rw_info (0, 0, 0, "std::num_get<%s, %s>::get (..., %s&)",
2562 cname, iname, tname);
2563
2564 PunctData::thousands_sep_ = ';';
2565
2566# if !defined (_RWSTD_NO_STRTOF) || !defined (_RWSTD_NO_STRTOF_IN_LIBC) \
2567 || !defined (_RWSTD_NO_STRTOD) || !defined (_RWSTD_NO_STRTOD_IN_LIBC)
2568
2569 const bool test_locale = true;
2570
2571# else
2572
2573 const bool test_locale = false;
2574
2575# endif // _RWSTD_NO_STRTO{D,F}(_IN_LIBC)
2576
2577 test_floating_point (ctype, cname, itype, iname, float (), test_locale);
2578
2579 const char *str = _RWSTD_STRSTR (FLT_MAX);
2580
2581 // some platforms, e.g., HP-UX, #define FLT_MAX (float)3.40282347e+38F
2582 // guard against such definitions
2583 if (*str >= '0' && *str <= '9') {
2584 // FLT_MAX is something like "3.40282347e+38F" (note the 'F'
2585 // at the end) so parsing stops before the end is reached,
2586 // i.e., Eof is not set
2587 TEST (T, FLT_MAX, _RWSTD_STRSTR ( FLT_MAX), -1, 0, Good);
2588 TEST (T, -FLT_MAX, _RWSTD_STRSTR (-FLT_MAX), -1, 0, Good);
2589 }
2590 else {
2591 TEST (T, FLT_MAX, _RWSTD_STRSTR ( _RWSTD_FLT_MAX), -1, 0, Good);
2592 TEST (T, -FLT_MAX, _RWSTD_STRSTR (-_RWSTD_FLT_MAX), -1, 0, Good);
2593 }
2594
2595 if (rw_opt_no_uflow) {
2596 rw_note (0, 0, 0, "underflow test disabled");
2597 }
2598 else {
2599 test_flt_uflow (ctype, cname, itype, iname);
2600 }
2601
2602#else // if defined (NO_GET_FLT)
2603
2604 _RWSTD_UNUSED (t);
2605
2606#endif // NO_GET_FLT
2607
2608}
2609
2610
2612void test_dbl_uflow (CharType ctype, const char *cname,
2613 IterType itype, const char *iname)
2614{
2615#ifndef NO_GET_DBL
2616
2617 rw_info (0, 0, 0, "std::num_get<%s, %s>::get (..., double&) on underflow",
2618 cname, iname);
2619
2620 // exercise bahvior on underflow
2621 static double val = DBL_MIN;
2622 pmax = &val;
2623
2624 // on underflow, get() follows C99 requirements on strtod()
2625 // i.e., it stores a value in the range [0, +/-DBL_MIN]
2626 // the function does NOT set failbit on underflow (regardless
2627 // of whether strtod() sets errno)
2628 // If the result underflows (7.12.1), the functions return
2629 // a value whose magnitude is no greater than the smallest
2630 // normalized positive number in the return type; whether
2631 // errno acquires the value ERANGE is implementation-defined.
2632
2633 TEST (T, (val = DBL_MIN, 0.0), "1.111111e-9999", 14, 0, Eof);
2634 TEST (T, (val = 0.0, -DBL_MIN), "-1.111111e-9999", 15, 0, Eof);
2635
2636 if (1.23456789e-309L < DBL_MIN) {
2637 TEST (T, (val = DBL_MIN, 0.0), "1.23456789e-309", 15, 0, Eof);
2638 TEST (T, (val = 0.0, -DBL_MIN), "-1.23456789e-309", 16, 0, Eof);
2639 }
2640
2641 if (1.234567e-409L < DBL_MIN) {
2642 TEST (T, (val = DBL_MIN, 0.0), "1.23456789e-409", 15, 0, Eof);
2643 TEST (T, (val = 0.0, -DBL_MIN), "-1.23456789e-409", 16, 0, Eof);
2644 }
2645
2646 if (1.234567e-999L < DBL_MIN) {
2647 TEST (T, (val = DBL_MIN, 0.0), "1.23456789e-999", 15, 0, Eof);
2648 TEST (T, (val = 0.0, -DBL_MIN), "-1.23456789e-999", 16, 0, Eof);
2649 }
2650
2651 pmax = 0; // reset before next test
2652
2653
2654# ifdef _RWSTD_LDBL_MAX
2655
2656 rw_info (0, 0, 0, "std::num_get<%s, %s>::get (..., double&) on overflow",
2657 cname, iname);
2658
2659 const double inf = std::numeric_limits<double>::infinity ();
2660
2661 if (LDBL_MAX_EXP > DBL_MAX_EXP) {
2662 // exercise bahvior on overflow
2663 TEST (T, inf, _RWSTD_STRSTR ( _RWSTD_LDBL_MAX), -1, 0, Fail);
2664 TEST (T, -inf, _RWSTD_STRSTR (-_RWSTD_LDBL_MAX), -1, 0, Fail);
2665 }
2666
2667 // long double may have the same range and precision as double
2668 TEST (T, inf, "9.999999e+9999", 14, 0, Eof | Fail);
2669 TEST (T, -inf, "-9.999999e+9999", 15, 0, Eof | Fail);
2670
2671# endif // _RWSTD_LDBL_MAX
2672
2673#else // if defined (NO_GET_DBL)
2674
2675 _RWSTD_UNUSED (t);
2676
2677#endif // NO_GET_DBL
2678
2679}
2680
2681
2683static void
2684test_dbl (CharType ctype, const char *cname,
2685 IterType itype, const char *iname)
2686{
2687#ifndef NO_GET_DBL
2688
2689 // 22.2.3.1, p2 -- floating point grammar:
2690 //
2691 // fltval ::= [sign] units [decimal-point [digits]] [e [sign] digits]
2692 // | [sign] decimal-point digits [e [sign] digits]
2693 // sign ::= '+' | '-'
2694 // units ::= digits [thousands-sep units]
2695 // digits ::= digit [digits]
2696 // digit ::= '0' | '1' | '2' | '3' | '4' | '5' | '6' | '7' | '8' | '9'
2697 // e ::= 'e' | 'E'
2698
2699 const char* const tname = "double";
2700
2701 rw_info (0, 0, 0, "std::num_get<%s, %s>::get (..., %s&)",
2702 cname, iname, tname);
2703
2704# if !defined (_RWSTD_NO_STRTOD) || !defined (_RWSTD_NO_STRTOD_IN_LIBC)
2705
2706 const bool test_locale = true;
2707
2708# else
2709
2710 const bool test_locale = false;
2711
2712# endif // _RWSTD_NO_STRTOD(_IN_LIBC)
2713
2714 test_floating_point (ctype, cname, itype, iname, double (), test_locale);
2715
2716 if (rw_opt_no_uflow) {
2717 rw_note (0, 0, 0, "underflow test disabled");
2718 }
2719 else {
2720 test_dbl_uflow (ctype, cname, itype, iname);
2721 }
2722
2723#else // if defined (NO_GET_DBL)
2724
2725 _RWSTD_UNUSED (t);
2726
2727#endif // NO_GET_DBL
2728
2729}
2730
2731
2733static void
2734test_ldbl_uflow (CharType ctype, const char *cname,
2735 IterType itype, const char *iname)
2736{
2737#ifndef NO_GET_LDBL
2738
2739 rw_info (0, 0, 0,
2740 "std::num_get<%s, %s>::get (..., long double&) on underflow",
2741 cname, iname);
2742
2743 // exercise bahvior on underflow
2744 static long double val = LDBL_MIN;
2745 pmax = &val;
2746
2747 // on underflow, get() follows C99 requirements on strtold()
2748 // i.e., it stores a value in the range [0, +/-LDBL__MIN]
2749 // the function does NOT set failbit on underflow (regardless
2750 // of whether strtold() sets errno)
2751 // If the result underflows (7.12.1), the functions return
2752 // a value whose magnitude is no greater than the smallest
2753 // normalized positive number in the return type; whether
2754 // errno acquires the value ERANGE is implementation-defined.
2755
2756 TEST (T, (val = LDBL_MIN, 0.0L), "1.987654321e-99999", 18, 0, Eof);
2757 TEST (T, (val = 0.0L, -LDBL_MIN), "-1.987654321e-99999", 19, 0, Eof);
2758
2759 const char fmt[] = "%Lg";
2760
2761 long double ld = 0.0;
2762 if (1 == std::sscanf ("3.456789e-4932", fmt, &ld) && ld < LDBL_MIN) {
2763 TEST (T, (val = LDBL_MIN, 0.0L), "3.456789e-4932", 14, 0, Eof);
2764 TEST (T, (val = 0.0L, -LDBL_MIN), "-3.456789e-4932", 15, 0, Eof);
2765 }
2766
2767 if (1 == std::sscanf ("3.456789e-9999", fmt, &ld) && ld < LDBL_MIN) {
2768 TEST (T, (val = LDBL_MIN, 0.0L), "3.456789e-9999", 14, 0, Eof);
2769 TEST (T, (val = 0.0L, -LDBL_MIN), "-3.456789e-9999", 15, 0, Eof);
2770 }
2771
2772 pmax = 0; // reset before next test
2773
2774
2775# ifdef _RWSTD_LDBL_MAX
2776
2777 rw_info (0, 0, 0,
2778 "std::num_get<%s, %s>::get (..., long double&) on overflow",
2779 cname, iname);
2780
2781 const double inf = std::numeric_limits<long double>::infinity ();
2782
2783 TEST (T, inf, "9.999999e+9876543210", 20, 0, Eof | Fail);
2784 TEST (T, -inf, "-9.999999e+9876543210", 21, 0, Eof | Fail);
2785
2786# endif // _RWSTD_LDBL_MAX
2787
2788#else // if defined (NO_GET_LDBL)
2789
2790 _RWSTD_UNUSED (t);
2791
2792#endif // NO_GET_LDBL
2793
2794}
2795
2796
2798static void
2799test_ldbl (CharType ctype, const char *cname,
2800 IterType itype, const char *iname)
2801{
2802#ifndef NO_GET_LDBL
2803
2804# ifndef _RWSTD_NO_LONG_DOUBLE
2805
2806 const char* const tname = "long double";
2807
2808 rw_info (0, 0, 0, "std::num_get<%s, %s>::get (..., %s&)",
2809 cname, iname, tname);
2810
2811# if !defined (_RWSTD_NO_STRTOLD) || !defined (_RWSTD_NO_STRTOLD_IN_LIBC)
2812
2813 const bool test_locale = true;
2814
2815# else
2816
2817 const bool test_locale = false;
2818
2819# endif // _RWSTD_NO_STRTOLD(_IN_LIBC)
2820
2821 test_floating_point (ctype, cname, itype, iname, 0.0L, test_locale);
2822
2823 long double long_val;
2824
2825 char long_str [_RWSTD_LDBL_MAX_10_EXP + 2];
2826 std::memset (long_str, '0', sizeof long_str);
2827 long_str [sizeof long_str - 1] = '\0';
2828
2829 // parse a string of LDBL_MAX_10_EXP + 1 zeros
2830 TEST (T, 0.0L, long_str, INTSIZE (long_str - 1), 0, Eof);
2831
2832 const char *start;
2833
2834# if _RWSTD_LDBL_MAX_10_EXP >= 38
2835
2836 // parse "10...<repeats 37 times>" (i.e., 1 followed by 38 zeros)
2837 start = &(long_str [sizeof long_str - 40] = '1');
2838 TEST (T, 1.0e+38L, start, 39, 0, Eof);
2839
2840 // parse the same as above but preceded by a bunch of zeros
2841 TEST (T, 1.0e+38L, long_str, INTSIZE (long_str - 1), 0, Eof);
2842 long_str [sizeof long_str - 40] = '0';
2843
2844# endif // _RWSTD_LDBL_MAX_10_EXP > 129
2845
2846
2847# if _RWSTD_LDBL_MAX_10_EXP >= 128
2848
2849 // parse "10...<repeats 127 times>" (i.e., 1 followed by 128 zeros)
2850 start = &(long_str [sizeof long_str - 130] = '1');
2851 TEST (T, 1.0e+128L, start, 129, 0, Eof);
2852
2853 // parse the same as above but preceded by a bunch of zeros
2854 TEST (T, 1.0e+128L, long_str, INTSIZE (long_str - 1), 0, Eof);
2855 long_str [sizeof long_str - 130] = '0';
2856
2857# endif // _RWSTD_LDBL_MAX_10_EXP > 129
2858
2859# if _RWSTD_LDBL_MAX_10_EXP >= 308
2860
2861 // parse "10...<repeats 307 times>" (i.e., 1 followed by 308 zeros)
2862 start = &(long_str [sizeof long_str - 310] = '1');
2863 TEST (T, 1.0e+308L, start, 309, 0, Eof);
2864
2865 // parse the same as above but preceded by a bunch of zeros
2866 TEST (T, 1.0e+308L, long_str, INTSIZE (long_str - 1), 0, Eof);
2867 long_str [sizeof long_str - 310] = '0';
2868
2869# endif // _RWSTD_LDBL_MAX_10_EXP > 308
2870
2871# undef CAT
2872# undef CONCAT
2873
2874# define CAT(a, b) CONCAT (a, b)
2875# define CONCAT(a, b) a ## b
2876
2877 // parse "10..." (i.e., 1 followed by LDBL_MAX_10_EXP zeros)
2878 long_str [0] = '1';
2879 long_val = CAT (CAT (1.0e+, _RWSTD_LDBL_MAX_10_EXP), L);
2880
2881 TEST (T, long_val, long_str, INTSIZE (long_str - 1), 0, Eof);
2882
2883# endif // _RWSTD_NO_LONG_DOUBLE
2884
2885 if (rw_opt_no_uflow) {
2886 rw_note (0, 0, 0, "underflow test disabled");
2887 }
2888 else {
2889 test_ldbl_uflow (ctype, cname, itype, iname);
2890 }
2891
2892#else // if defined (NO_GET_LDBL)
2893
2894 _RWSTD_UNUSED (t);
2895
2896#endif // NO_GET_LDBL
2897
2898}
2899
2900
2902static void
2903run_tests (CharType ctype, const char *cname,
2904 IterType itype, const char *iname)
2905{
2906#undef TEST
2907#define TEST(T, tname) \
2908 if (rw_enabled (tname)) \
2909 test_ ## T (ctype, cname, itype, iname); \
2910 else \
2911 rw_note (0, __FILE__, __LINE__, "%s test disabled", tname)
2912
2913#ifndef _RWSTD_NO_BOOL
2914 TEST (bool, "bool");
2915#endif // _RWSTD_NO_BOOL
2916
2917 TEST (shrt, "short");
2918 TEST (int, "int");
2919 TEST (long, "long");
2920 TEST (ulong, "unsigned long");
2921
2922#ifndef _RWSTD_NO_LONG_LONG
2923
2924 TEST (llong, "long long");
2925 TEST (ullong, "unsigned long long");
2926
2927#endif // _RWSTD_NO_LONG_LONG
2928
2929 TEST (pvoid, "void*");
2930
2931 TEST (flt, "float");
2932 TEST (dbl, "double");
2933 TEST (ldbl, "long double");
2934}
2935
2936
2938static void
2939run_tests (IterType itype)
2940{
2941 RW_ASSERT (0 <= itype && itype < 3);
2942
2943 if (rw_enabled ("char")) {
2944 static const char* const inames[] = {
2945 "char*", "istreambuf_iterator<char>", "InputIter<char>"
2946 };
2947 run_tests (narrow_char, "char", itype, inames [itype]);
2948 }
2949 else
2950 rw_note (0, __FILE__, __LINE__, "char test disabled");
2951
2952#ifndef _RWSTD_NO_WCHAR_T
2953
2954 if (rw_enabled ("wchar_t")) {
2955 static const char* const inames[] = {
2956 "wchar_t*", "istreambuf_iterator<wchar_t>", "InputIter<wchar_t>"
2957 };
2958 run_tests (wide_char, "wchar_t", itype, inames [itype]);
2959 }
2960 else
2961 rw_note (0, __FILE__, __LINE__, "wchar_t test disabled");
2962
2963#else // if defined (_RWSTD_NO_WCHAR_T)
2964
2965 rw_note (0, __FILE__, __LINE__,
2966 "wchar_t test disabled: _RWSTD_NO_WCHAR_T #defined");
2967
2968#endif // _RWSTD_NO_WCHAR_T
2969
2970#if 0 // disabled
2971
2972 if (rw_enabled ("UserChar")) {
2973 static const char* const inames[] = {
2974 "UserChar*", "istreambuf_iterator<UserChar>", "InputIter<UserChar>"
2975 };
2976 run_tests (narrow_char, "UserChar", itype, inames [itype]);
2977 }
2978 else
2979 rw_note (0, __FILE__, __LINE__, "UserChar test disabled");
2980
2981#endif // disabled
2982
2983}
2984
2985
2987static int
2988run_test (int, char*[])
2989{
2990 run_tests (iter_pointer);
2991 run_tests (iter_istreambuf);
2992 run_tests (iter_input);
2993
2994 return 0;
2995}
2996
2997
2999int main (int argc, char *argv[])
3000{
3001 return rw_test (argc, argv, __FILE__,
3002 "lib.locale.num.get",
3003 0 /* no comment */, run_test,
3004 "|-no-errno# "
3005 "|-no-grouping# "
3006 "|-no-widen# "
3007 "|-no-underflow#",
3008 &rw_opt_no_errno,
3009 &rw_opt_no_grouping,
3010 &rw_opt_no_widen,
3011 &rw_opt_no_uflow);
3012}
nfailures
int nfailures
Definition 0.printf.cpp:63
i
#define i
Definition 17.names.cpp:126
y
#define y
Definition 17.names.cpp:141
t
#define t
Definition 17.names.cpp:136
e
#define e
Definition 17.names.cpp:118
start
#define start
Definition 17.names.cpp:547
F
#define F
Definition 17.names.cpp:149
sb
#define sb
Definition 17.names.cpp:542
x
#define x
Definition 17.names.cpp:140
Traits
#define Traits
Definition 17.names.cpp:556
lineno
#define lineno
Definition 17.names.cpp:491
c
#define c
Definition 17.names.cpp:111
charT
#define charT
Definition 17.names.cpp:456
n
#define n
Definition 17.names.cpp:130
val
#define val
Definition 17.names.cpp:570
T
#define T
Definition 22.locale.num.get.cpp:505
BASE
#define BASE(n)
narrow_char
@ narrow_char
Definition 22.locale.num.get.cpp:439
PVOIDSTR
#define PVOIDSTR(name)
ULL
#define ULL(number)
test_dbl_uflow
void test_dbl_uflow(CharType ctype, const char *cname, IterType itype, const char *iname)
Definition 22.locale.num.get.cpp:2612
dec
#define dec
Definition 22.locale.num.get.cpp:476
INTSIZE
#define INTSIZE(x)
oct
#define oct
Definition 22.locale.num.get.cpp:481
hex
#define hex
Definition 22.locale.num.get.cpp:478
CAT
#define CAT(a, b)
test_floating_point
void test_floating_point(CharType ctype, const char *cname, IterType itype, const char *iname, floatT, bool test_locale)
Definition 22.locale.num.get.cpp:2143
Fail
#define Fail
Definition 22.locale.num.get.cpp:499
TEST
#define TEST
Definition 22.locale.num.get.cpp:504
TEST_ERRNO
#define TEST_ERRNO(val)
Good
#define Good
Definition 22.locale.num.get.cpp:500
LL
#define LL(number)
test_errno
void test_errno(CharType ctype, const char *cname, IterType itype, const char *iname, numT)
Definition 22.locale.num.get.cpp:509
boolalpha
#define boolalpha
Definition 22.locale.num.get.cpp:475
pmax
void * pmax
Definition 22.locale.num.get.cpp:243
Bad
#define Bad
Definition 22.locale.num.get.cpp:497
Eof
#define Eof
Definition 22.locale.num.get.cpp:498
VALSTR
#define VALSTR(x)
iter_istreambuf
@ iter_istreambuf
Definition 22.locale.num.get.cpp:246
iter_pointer
@ iter_pointer
Definition 22.locale.num.get.cpp:246
flags
#define flags
run_tests
void run_tests(ForwardIterator dummy_iter, const T *, const char *predname)
Definition 25.adjacent.find.cpp:172
do_test
void do_test(int line, const char *src, std::size_t resoff, ForwardIterator dummy_iter, const T *, const char *predname)
Definition 25.adjacent.find.cpp:88
run_test
void run_test(const ForwardIterator &dummy, T *, Predicate *pred)
Definition 25.find.first.cpp:275
test_ulong
void test_ulong(CharT *, Traits *, const char *cname, const char *tname)
Definition 27.istream.fmat.arith.cpp:981
test_ullong
void test_ullong(CharT *, Traits *, const char *cname, const char *tname)
Definition 27.istream.fmat.arith.cpp:1078
test_shrt
void test_shrt(CharT *, Traits *, const char *cname, const char *tname)
Definition 27.istream.fmat.arith.cpp:745
test_dbl
void test_dbl(CharT *, Traits *, const char *cname, const char *tname)
Definition 27.istream.fmat.arith.cpp:1171
test_long
void test_long(CharT *, Traits *, const char *cname, const char *tname)
Definition 27.istream.fmat.arith.cpp:925
test_flt
void test_flt(CharT *, Traits *, const char *cname, const char *tname)
Definition 27.istream.fmat.arith.cpp:1143
test_llong
void test_llong(CharT *, Traits *, const char *cname, const char *tname)
Definition 27.istream.fmat.arith.cpp:1022
test_ldbl
void test_ldbl(CharT *, Traits *, const char *cname, const char *tname)
Definition 27.istream.fmat.arith.cpp:1199
test_int
void test_int(CharT *, Traits *, const char *cname, const char *tname)
Definition 27.istream.fmat.arith.cpp:828
test_bool
void test_bool(CharT *, Traits *, const char *cname, const char *tname)
Definition 27.istream.fmat.arith.cpp:692
PVoid
@ PVoid
Definition 27.ostream.cpp:201
main
#define main
Definition BAD_ALLOC_COPY_CTOR.cpp:32
ERANGE
#define ERANGE
zero
volatile int zero
Definition LIMITS.cpp:60
LDBL_MIN
#define LDBL_MIN
Definition _cfloat.h:67
LDBL_MAX_EXP
#define LDBL_MAX_EXP
Definition _cfloat.h:63
DBL_MAX_EXP
#define DBL_MAX_EXP
Definition _cfloat.h:53
FLT_MAX
#define FLT_MAX
Definition _cfloat.h:46
FLT_MIN
#define FLT_MIN
Definition _cfloat.h:47
DBL_MIN
#define DBL_MIN
Definition _cfloat.h:57
LC_NUMERIC
#define LC_NUMERIC
_RWSTD_UNUSED
#define _RWSTD_UNUSED(arg)
Definition _defs.h:972
_RWSTD_ASSERT
#define _RWSTD_ASSERT(ignore)
Definition _defs.h:1108
_RWSTD_STRSTR
#define _RWSTD_STRSTR(x)
Definition _defs.h:1117
_RWSTD_CONST_CAST
#define _RWSTD_CONST_CAST(T, x)
Definition _defs.h:536
rw_any_t
Definition rw_any.h:38
rw_any_t::type_name
const char * type_name() const
Definition any.cpp:310
name
const char * name
Definition codecvt1.cpp:72
init
std::mbstate_t init
Definition codecvt1.cpp:80
str
const char * str
Definition exec.cpp:170
SHRT_MAX
#define SHRT_MAX
Definition limits.h:64
ULONG_MAX
#define ULONG_MAX
Definition limits.h:96
LONG_MAX
#define LONG_MAX
Definition limits.h:88
SHRT_MIN
#define SHRT_MIN
Definition limits.h:68
LONG_MIN
#define LONG_MIN
Definition limits.h:92
std
Definition json.h:5363
rw_alg_test.h
rw_any.h
TOSTR
#define TOSTR(x)
Definition rw_any.h:148
rw_char.h
rw_widen
_TEST_EXPORT char * rw_widen(char *, const char *, _RWSTD_SIZE_T=_RWSTD_SIZE_MAX)
rw_cmdopt.h
rw_enabled
_TEST_EXPORT int rw_enabled(const char *name)
Definition opt_types.cpp:138
rw_driver.h
rw_test
_TEST_EXPORT int rw_test(int argc, char *argv[], const char *filename, const char *clause, const char *comment, int(*testfun)(int, char **), const char *optspec,...)
rw_info
_TEST_EXPORT int rw_info(int, const char *, int, const char *,...)
Definition driver.cpp:1681
rw_note
_TEST_EXPORT int rw_note(int, const char *, int, const char *,...)
Definition driver.cpp:1664
rw_assert
_TEST_EXPORT int rw_assert(int, const char *, int, const char *,...)
Definition driver.cpp:1630
rw_warn
_TEST_EXPORT int rw_warn(int, const char *, int, const char *,...)
Definition driver.cpp:1647
rw_locale.h
rw_locales
_TEST_EXPORT char * rw_locales(int=_UNUSED_CAT, const char *=0, bool=true)
Definition locale.cpp:368
RW_ASSERT
#define RW_ASSERT(expr)
Definition rw_testdefs.h:143
rw_valcmp.h
rw_equal
int rw_equal(T x, T y)
Definition rw_valcmp.h:153
Ctype::char_type
Base::char_type char_type
Definition 22.locale.num.get.cpp:96
Ctype::n_widen_
static int n_widen_
Definition 22.locale.money.get.cpp:64
Ctype::Base
std::ctype< charT > Base
Definition 22.locale.num.get.cpp:94
Ctype::do_widen
virtual const char_type * do_widen(const char *lo, const char *hi, char_type *dst) const
Definition 22.locale.num.get.cpp:123
Ctype::do_widen
virtual char_type do_widen(char c) const
Definition 22.locale.num.get.cpp:102
NumGet::get
iter_type get(iter_type, iter_type, std::ios_base &, std::ios_base::iostate &,...) const
Definition 17.extensions.cpp:166
PunctData::falsename_
static const char * falsename_
Definition 22.locale.num.get.cpp:139
PunctData::n_objs_
static int n_objs_
Definition 22.locale.num.get.cpp:143
PunctData::decimal_point_
static charT decimal_point_[2]
Definition 22.locale.money.get.cpp:109
PunctData::thousands_sep_
static charT thousands_sep_[2]
Definition 22.locale.money.get.cpp:110
PunctData::n_thousands_sep_
static int n_thousands_sep_
Definition 22.locale.num.get.cpp:146
PunctData::grouping_
static const char * grouping_[2]
Definition 22.locale.money.get.cpp:111
PunctData::set_names
static void set_names(const char *fname, const char *tname)
Definition 22.locale.num.get.cpp:148
PunctData::decimal_point_
static char decimal_point_
Definition 22.locale.num.get.cpp:136
PunctData::thousands_sep_
static char thousands_sep_
Definition 22.locale.num.get.cpp:137
PunctData::truename_
static const char * truename_
Definition 22.locale.num.get.cpp:140
Punct::truename_
static const char_type * truename_
Definition 22.locale.num.put.cpp:121
Punct::falsename_
static const char_type * falsename_
Definition 22.locale.num.put.cpp:122
Punct::Punct
Punct(std::size_t ref=0)
Definition 22.locale.num.get.cpp:172
Punct::decimal_point_
static char_type decimal_point_
Definition 22.locale.money.put.cpp:54
Punct::char_type
std::numpunct< charT >::char_type char_type
Definition 22.locale.num.get.cpp:169
Punct::do_truename
virtual string_type do_truename() const
Definition 22.locale.num.get.cpp:194
Punct::n_thousands_sep_
static int n_thousands_sep_
Definition 22.locale.money.get.cpp:180
Punct::n_objs_
static int n_objs_
Definition 22.locale.num.put.cpp:124
Punct::grouping_
static const char * grouping_
Definition 22.locale.money.put.cpp:56
Punct::thousands_sep_
static char_type thousands_sep_
Definition 22.locale.money.put.cpp:55
Punct::string_type
std::numpunct< charT >::string_type string_type
Definition 22.locale.num.get.cpp:170
Punct::UChar
unsigned char UChar
Definition 22.locale.num.get.cpp:168
Punct::do_falsename
virtual string_type do_falsename() const
Definition 22.locale.num.get.cpp:199
Punct::do_decimal_point
virtual char_type do_decimal_point() const
Definition 22.locale.num.get.cpp:181
Punct::do_grouping
virtual std::string do_grouping() const
Definition 22.locale.num.get.cpp:185
Punct::do_thousands_sep
virtual char_type do_thousands_sep() const
Definition 22.locale.num.get.cpp:189
Punct::char_type
Base::char_type char_type
Definition 22.locale.money.get.cpp:177
Punct::string_type
Base::string_type string_type
Definition 22.locale.money.get.cpp:178
Streambuf::gptr_off
std::ptrdiff_t gptr_off() const
Definition 22.locale.num.get.cpp:225
Streambuf::Base
std::basic_streambuf< charT, Traits > Base
Definition 22.locale.num.get.cpp:216
Streambuf::Streambuf
Streambuf(const charT *gbeg, const charT *gend)
Definition 22.locale.num.get.cpp:218
Generated by doxygen 1.9.8