get_long_double_en_US.pass.cpp revision f5256e16dfc425c1d466f6308d4026d529ce9e0b 
1//===----------------------------------------------------------------------===//
2//
3//                     The LLVM Compiler Infrastructure
4//
5// This file is distributed under the University of Illinois Open Source
6// License. See LICENSE.TXT for details.
7//
8//===----------------------------------------------------------------------===//
9
10// <locale>
11
12// class money_get<charT, InputIterator>
13
14// iter_type get(iter_type b, iter_type e, bool intl, ios_base& iob,
15//               ios_base::iostate& err, long double& v) const;
16
17#include <locale>
18#include <ios>
19#include <streambuf>
20#include <cassert>
21#include "iterators.h"
22
23typedef std::money_get<char, input_iterator<const char*> > Fn;
24
25class my_facet
26    : public Fn
27{
28public:
29    explicit my_facet(std::size_t refs = 0)
30        : Fn(refs) {}
31};
32
33typedef std::money_get<wchar_t, input_iterator<const wchar_t*> > Fw;
34
35class my_facetw
36    : public Fw
37{
38public:
39    explicit my_facetw(std::size_t refs = 0)
40        : Fw(refs) {}
41};
42
43int main()
44{
45    std::ios ios(0);
46    std::string loc_name("en_US");
47    ios.imbue(std::locale(ios.getloc(),
48                          new std::moneypunct_byname<char, false>(loc_name)));
49    ios.imbue(std::locale(ios.getloc(),
50                          new std::moneypunct_byname<char, true>(loc_name)));
51    ios.imbue(std::locale(ios.getloc(),
52                          new std::moneypunct_byname<wchar_t, false>(loc_name)));
53    ios.imbue(std::locale(ios.getloc(),
54                          new std::moneypunct_byname<wchar_t, true>(loc_name)));
55    {
56        const my_facet f(1);
57        // char, national
58        {   // zero
59            std::string v = "0.00";
60            typedef input_iterator<const char*> I;
61            long double ex;
62            std::ios_base::iostate err = std::ios_base::goodbit;
63            I iter = f.get(I(v.data()), I(v.data() + v.size()),
64                                                false, ios, err, ex);
65            assert(iter.base() == v.data() + v.size());
66            assert(err == std::ios_base::eofbit);
67            assert(ex == 0);
68        }
69        {   // negative one
70            std::string v = "-0.01";
71            typedef input_iterator<const char*> I;
72            long double ex;
73            std::ios_base::iostate err = std::ios_base::goodbit;
74            I iter = f.get(I(v.data()), I(v.data() + v.size()),
75                                                false, ios, err, ex);
76            assert(iter.base() == v.data() + v.size());
77            assert(err == std::ios_base::eofbit);
78            assert(ex == -1);
79        }
80        {   // positive
81            std::string v = "1,234,567.89";
82            typedef input_iterator<const char*> I;
83            long double ex;
84            std::ios_base::iostate err = std::ios_base::goodbit;
85            I iter = f.get(I(v.data()), I(v.data() + v.size()),
86                                                false, ios, err, ex);
87            assert(iter.base() == v.data() + v.size());
88            assert(err == std::ios_base::eofbit);
89            assert(ex == 123456789);
90        }
91        {   // negative
92            std::string v = "-1,234,567.89";
93            typedef input_iterator<const char*> I;
94            long double ex;
95            std::ios_base::iostate err = std::ios_base::goodbit;
96            I iter = f.get(I(v.data()), I(v.data() + v.size()),
97                                                false, ios, err, ex);
98            assert(iter.base() == v.data() + v.size());
99            assert(err == std::ios_base::eofbit);
100            assert(ex == -123456789);
101        }
102        {   // negative
103            std::string v = "-1234567.89";
104            typedef input_iterator<const char*> I;
105            long double ex;
106            std::ios_base::iostate err = std::ios_base::goodbit;
107            I iter = f.get(I(v.data()), I(v.data() + v.size()),
108                                                false, ios, err, ex);
109            assert(iter.base() == v.data() + v.size());
110            assert(err == std::ios_base::eofbit);
111            assert(ex == -123456789);
112        }
113        {   // zero, showbase
114            std::string v = "$0.00";
115            typedef input_iterator<const char*> I;
116            long double ex;
117            std::ios_base::iostate err = std::ios_base::goodbit;
118            I iter = f.get(I(v.data()), I(v.data() + v.size()),
119                                                false, ios, err, ex);
120            assert(iter.base() == v.data() + v.size());
121            assert(err == std::ios_base::eofbit);
122            assert(ex == 0);
123        }
124        {   // zero, showbase
125            std::string v = "$0.00";
126            showbase(ios);
127            typedef input_iterator<const char*> I;
128            long double ex;
129            std::ios_base::iostate err = std::ios_base::goodbit;
130            I iter = f.get(I(v.data()), I(v.data() + v.size()),
131                                                false, ios, err, ex);
132            assert(iter.base() == v.data() + v.size());
133            assert(err == std::ios_base::eofbit);
134            assert(ex == 0);
135            noshowbase(ios);
136        }
137        {   // negative one, showbase
138            std::string v = "-$0.01";
139            typedef input_iterator<const char*> I;
140            long double ex;
141            std::ios_base::iostate err = std::ios_base::goodbit;
142            I iter = f.get(I(v.data()), I(v.data() + v.size()),
143                                                false, ios, err, ex);
144            assert(iter.base() == v.data() + v.size());
145            assert(err == std::ios_base::eofbit);
146            assert(ex == -1);
147        }
148        {   // negative one, showbase
149            std::string v = "-$0.01";
150            showbase(ios);
151            typedef input_iterator<const char*> I;
152            long double ex;
153            std::ios_base::iostate err = std::ios_base::goodbit;
154            I iter = f.get(I(v.data()), I(v.data() + v.size()),
155                                                false, ios, err, ex);
156            assert(iter.base() == v.data() + v.size());
157            assert(err == std::ios_base::eofbit);
158            assert(ex == -1);
159            noshowbase(ios);
160        }
161        {   // positive, showbase
162            std::string v = "$1,234,567.89";
163            typedef input_iterator<const char*> I;
164            long double ex;
165            std::ios_base::iostate err = std::ios_base::goodbit;
166            I iter = f.get(I(v.data()), I(v.data() + v.size()),
167                                                false, ios, err, ex);
168            assert(iter.base() == v.data() + v.size());
169            assert(err == std::ios_base::eofbit);
170            assert(ex == 123456789);
171        }
172        {   // positive, showbase
173            std::string v = "$1,234,567.89";
174            showbase(ios);
175            typedef input_iterator<const char*> I;
176            long double ex;
177            std::ios_base::iostate err = std::ios_base::goodbit;
178            I iter = f.get(I(v.data()), I(v.data() + v.size()),
179                                                false, ios, err, ex);
180            assert(iter.base() == v.data() + v.size());
181            assert(err == std::ios_base::eofbit);
182            assert(ex == 123456789);
183            noshowbase(ios);
184        }
185        {   // negative, showbase
186            std::string v = "-$1,234,567.89";
187            showbase(ios);
188            typedef input_iterator<const char*> I;
189            long double ex;
190            std::ios_base::iostate err = std::ios_base::goodbit;
191            I iter = f.get(I(v.data()), I(v.data() + v.size()),
192                                                false, ios, err, ex);
193            assert(iter.base() == v.data() + v.size());
194            assert(err == std::ios_base::eofbit);
195            assert(ex == -123456789);
196            noshowbase(ios);
197        }
198        {   // negative, showbase
199            std::string v = "-USD 1,234,567.89";
200            showbase(ios);
201            typedef input_iterator<const char*> I;
202            long double ex;
203            std::ios_base::iostate err = std::ios_base::goodbit;
204            I iter = f.get(I(v.data()), I(v.data() + v.size()),
205                                                false, ios, err, ex);
206            assert(iter.base() == v.data() + 1);
207            assert(err == std::ios_base::failbit);
208            noshowbase(ios);
209        }
210        {   // negative, showbase
211            std::string v = "-USD 1,234,567.89";
212            typedef input_iterator<const char*> I;
213            long double ex;
214            std::ios_base::iostate err = std::ios_base::goodbit;
215            I iter = f.get(I(v.data()), I(v.data() + v.size()),
216                                                false, ios, err, ex);
217            assert(iter.base() == v.data() + 1);
218            assert(err == std::ios_base::failbit);
219        }
220    }
221    {
222        const my_facet f(1);
223        // char, international
224        {   // zero
225            std::string v = "0.00";
226            typedef input_iterator<const char*> I;
227            long double ex;
228            std::ios_base::iostate err = std::ios_base::goodbit;
229            I iter = f.get(I(v.data()), I(v.data() + v.size()),
230                                                true, ios, err, ex);
231            assert(iter.base() == v.data() + v.size());
232            assert(err == std::ios_base::eofbit);
233            assert(ex == 0);
234        }
235        {   // negative one
236            std::string v = "-0.01";
237            typedef input_iterator<const char*> I;
238            long double ex;
239            std::ios_base::iostate err = std::ios_base::goodbit;
240            I iter = f.get(I(v.data()), I(v.data() + v.size()),
241                                                true, ios, err, ex);
242            assert(iter.base() == v.data() + v.size());
243            assert(err == std::ios_base::eofbit);
244            assert(ex == -1);
245        }
246        {   // positive
247            std::string v = "1,234,567.89";
248            typedef input_iterator<const char*> I;
249            long double ex;
250            std::ios_base::iostate err = std::ios_base::goodbit;
251            I iter = f.get(I(v.data()), I(v.data() + v.size()),
252                                                true, ios, err, ex);
253            assert(iter.base() == v.data() + v.size());
254            assert(err == std::ios_base::eofbit);
255            assert(ex == 123456789);
256        }
257        {   // negative
258            std::string v = "-1,234,567.89";
259            typedef input_iterator<const char*> I;
260            long double ex;
261            std::ios_base::iostate err = std::ios_base::goodbit;
262            I iter = f.get(I(v.data()), I(v.data() + v.size()),
263                                                true, ios, err, ex);
264            assert(iter.base() == v.data() + v.size());
265            assert(err == std::ios_base::eofbit);
266            assert(ex == -123456789);
267        }
268        {   // negative
269            std::string v = "-1234567.89";
270            typedef input_iterator<const char*> I;
271            long double ex;
272            std::ios_base::iostate err = std::ios_base::goodbit;
273            I iter = f.get(I(v.data()), I(v.data() + v.size()),
274                                                true, ios, err, ex);
275            assert(iter.base() == v.data() + v.size());
276            assert(err == std::ios_base::eofbit);
277            assert(ex == -123456789);
278        }
279        {   // zero, showbase
280            std::string v = "USD 0.00";
281            typedef input_iterator<const char*> I;
282            long double ex;
283            std::ios_base::iostate err = std::ios_base::goodbit;
284            I iter = f.get(I(v.data()), I(v.data() + v.size()),
285                                                true, ios, err, ex);
286            assert(iter.base() == v.data() + v.size());
287            assert(err == std::ios_base::eofbit);
288            assert(ex == 0);
289        }
290        {   // zero, showbase
291            std::string v = "USD 0.00";
292            showbase(ios);
293            typedef input_iterator<const char*> I;
294            long double ex;
295            std::ios_base::iostate err = std::ios_base::goodbit;
296            I iter = f.get(I(v.data()), I(v.data() + v.size()),
297                                                true, ios, err, ex);
298            assert(iter.base() == v.data() + v.size());
299            assert(err == std::ios_base::eofbit);
300            assert(ex == 0);
301            noshowbase(ios);
302        }
303        {   // negative one, showbase
304            std::string v = "-USD 0.01";
305            typedef input_iterator<const char*> I;
306            long double ex;
307            std::ios_base::iostate err = std::ios_base::goodbit;
308            I iter = f.get(I(v.data()), I(v.data() + v.size()),
309                                                true, ios, err, ex);
310            assert(iter.base() == v.data() + v.size());
311            assert(err == std::ios_base::eofbit);
312            assert(ex == -1);
313        }
314        {   // negative one, showbase
315            std::string v = "-USD 0.01";
316            showbase(ios);
317            typedef input_iterator<const char*> I;
318            long double ex;
319            std::ios_base::iostate err = std::ios_base::goodbit;
320            I iter = f.get(I(v.data()), I(v.data() + v.size()),
321                                                true, ios, err, ex);
322            assert(iter.base() == v.data() + v.size());
323            assert(err == std::ios_base::eofbit);
324            assert(ex == -1);
325            noshowbase(ios);
326        }
327        {   // positive, showbase
328            std::string v = "USD 1,234,567.89";
329            typedef input_iterator<const char*> I;
330            long double ex;
331            std::ios_base::iostate err = std::ios_base::goodbit;
332            I iter = f.get(I(v.data()), I(v.data() + v.size()),
333                                                true, ios, err, ex);
334            assert(iter.base() == v.data() + v.size());
335            assert(err == std::ios_base::eofbit);
336            assert(ex == 123456789);
337        }
338        {   // positive, showbase
339            std::string v = "USD 1,234,567.89";
340            showbase(ios);
341            typedef input_iterator<const char*> I;
342            long double ex;
343            std::ios_base::iostate err = std::ios_base::goodbit;
344            I iter = f.get(I(v.data()), I(v.data() + v.size()),
345                                                true, ios, err, ex);
346            assert(iter.base() == v.data() + v.size());
347            assert(err == std::ios_base::eofbit);
348            assert(ex == 123456789);
349            noshowbase(ios);
350        }
351        {   // negative, showbase
352            std::string v = "-USD 1,234,567.89";
353            showbase(ios);
354            typedef input_iterator<const char*> I;
355            long double ex;
356            std::ios_base::iostate err = std::ios_base::goodbit;
357            I iter = f.get(I(v.data()), I(v.data() + v.size()),
358                                                true, ios, err, ex);
359            assert(iter.base() == v.data() + v.size());
360            assert(err == std::ios_base::eofbit);
361            assert(ex == -123456789);
362            noshowbase(ios);
363        }
364        {   // negative, showbase
365            std::string v = "-$1,234,567.89";
366            showbase(ios);
367            typedef input_iterator<const char*> I;
368            long double ex;
369            std::ios_base::iostate err = std::ios_base::goodbit;
370            I iter = f.get(I(v.data()), I(v.data() + v.size()),
371                                                true, ios, err, ex);
372            assert(iter.base() == v.data() + 1);
373            assert(err == std::ios_base::failbit);
374            noshowbase(ios);
375        }
376        {   // negative, showbase
377            std::string v = "-$1,234,567.89";
378            typedef input_iterator<const char*> I;
379            long double ex;
380            std::ios_base::iostate err = std::ios_base::goodbit;
381            I iter = f.get(I(v.data()), I(v.data() + v.size()),
382                                                true, ios, err, ex);
383            assert(iter.base() == v.data() + 1);
384            assert(err == std::ios_base::failbit);
385        }
386    }
387    {
388        const my_facetw f(1);
389        // wchar_t, national
390        {   // zero
391            std::wstring v = L"0.00";
392            typedef input_iterator<const wchar_t*> I;
393            long double ex;
394            std::ios_base::iostate err = std::ios_base::goodbit;
395            I iter = f.get(I(v.data()), I(v.data() + v.size()),
396                                                false, ios, err, ex);
397            assert(iter.base() == v.data() + v.size());
398            assert(err == std::ios_base::eofbit);
399            assert(ex == 0);
400        }
401        {   // negative one
402            std::wstring v = L"-0.01";
403            typedef input_iterator<const wchar_t*> I;
404            long double ex;
405            std::ios_base::iostate err = std::ios_base::goodbit;
406            I iter = f.get(I(v.data()), I(v.data() + v.size()),
407                                                false, ios, err, ex);
408            assert(iter.base() == v.data() + v.size());
409            assert(err == std::ios_base::eofbit);
410            assert(ex == -1);
411        }
412        {   // positive
413            std::wstring v = L"1,234,567.89";
414            typedef input_iterator<const wchar_t*> I;
415            long double ex;
416            std::ios_base::iostate err = std::ios_base::goodbit;
417            I iter = f.get(I(v.data()), I(v.data() + v.size()),
418                                                false, ios, err, ex);
419            assert(iter.base() == v.data() + v.size());
420            assert(err == std::ios_base::eofbit);
421            assert(ex == 123456789);
422        }
423        {   // negative
424            std::wstring v = L"-1,234,567.89";
425            typedef input_iterator<const wchar_t*> I;
426            long double ex;
427            std::ios_base::iostate err = std::ios_base::goodbit;
428            I iter = f.get(I(v.data()), I(v.data() + v.size()),
429                                                false, ios, err, ex);
430            assert(iter.base() == v.data() + v.size());
431            assert(err == std::ios_base::eofbit);
432            assert(ex == -123456789);
433        }
434        {   // negative
435            std::wstring v = L"-1234567.89";
436            typedef input_iterator<const wchar_t*> I;
437            long double ex;
438            std::ios_base::iostate err = std::ios_base::goodbit;
439            I iter = f.get(I(v.data()), I(v.data() + v.size()),
440                                                false, ios, err, ex);
441            assert(iter.base() == v.data() + v.size());
442            assert(err == std::ios_base::eofbit);
443            assert(ex == -123456789);
444        }
445        {   // zero, showbase
446            std::wstring v = L"$0.00";
447            typedef input_iterator<const wchar_t*> I;
448            long double ex;
449            std::ios_base::iostate err = std::ios_base::goodbit;
450            I iter = f.get(I(v.data()), I(v.data() + v.size()),
451                                                false, ios, err, ex);
452            assert(iter.base() == v.data() + v.size());
453            assert(err == std::ios_base::eofbit);
454            assert(ex == 0);
455        }
456        {   // zero, showbase
457            std::wstring v = L"$0.00";
458            showbase(ios);
459            typedef input_iterator<const wchar_t*> I;
460            long double ex;
461            std::ios_base::iostate err = std::ios_base::goodbit;
462            I iter = f.get(I(v.data()), I(v.data() + v.size()),
463                                                false, ios, err, ex);
464            assert(iter.base() == v.data() + v.size());
465            assert(err == std::ios_base::eofbit);
466            assert(ex == 0);
467            noshowbase(ios);
468        }
469        {   // negative one, showbase
470            std::wstring v = L"-$0.01";
471            typedef input_iterator<const wchar_t*> I;
472            long double ex;
473            std::ios_base::iostate err = std::ios_base::goodbit;
474            I iter = f.get(I(v.data()), I(v.data() + v.size()),
475                                                false, ios, err, ex);
476            assert(iter.base() == v.data() + v.size());
477            assert(err == std::ios_base::eofbit);
478            assert(ex == -1);
479        }
480        {   // negative one, showbase
481            std::wstring v = L"-$0.01";
482            showbase(ios);
483            typedef input_iterator<const wchar_t*> I;
484            long double ex;
485            std::ios_base::iostate err = std::ios_base::goodbit;
486            I iter = f.get(I(v.data()), I(v.data() + v.size()),
487                                                false, ios, err, ex);
488            assert(iter.base() == v.data() + v.size());
489            assert(err == std::ios_base::eofbit);
490            assert(ex == -1);
491            noshowbase(ios);
492        }
493        {   // positive, showbase
494            std::wstring v = L"$1,234,567.89";
495            typedef input_iterator<const wchar_t*> I;
496            long double ex;
497            std::ios_base::iostate err = std::ios_base::goodbit;
498            I iter = f.get(I(v.data()), I(v.data() + v.size()),
499                                                false, ios, err, ex);
500            assert(iter.base() == v.data() + v.size());
501            assert(err == std::ios_base::eofbit);
502            assert(ex == 123456789);
503        }
504        {   // positive, showbase
505            std::wstring v = L"$1,234,567.89";
506            showbase(ios);
507            typedef input_iterator<const wchar_t*> I;
508            long double ex;
509            std::ios_base::iostate err = std::ios_base::goodbit;
510            I iter = f.get(I(v.data()), I(v.data() + v.size()),
511                                                false, ios, err, ex);
512            assert(iter.base() == v.data() + v.size());
513            assert(err == std::ios_base::eofbit);
514            assert(ex == 123456789);
515            noshowbase(ios);
516        }
517        {   // negative, showbase
518            std::wstring v = L"-$1,234,567.89";
519            showbase(ios);
520            typedef input_iterator<const wchar_t*> I;
521            long double ex;
522            std::ios_base::iostate err = std::ios_base::goodbit;
523            I iter = f.get(I(v.data()), I(v.data() + v.size()),
524                                                false, ios, err, ex);
525            assert(iter.base() == v.data() + v.size());
526            assert(err == std::ios_base::eofbit);
527            assert(ex == -123456789);
528            noshowbase(ios);
529        }
530        {   // negative, showbase
531            std::wstring v = L"-USD 1,234,567.89";
532            showbase(ios);
533            typedef input_iterator<const wchar_t*> I;
534            long double ex;
535            std::ios_base::iostate err = std::ios_base::goodbit;
536            I iter = f.get(I(v.data()), I(v.data() + v.size()),
537                                                false, ios, err, ex);
538            assert(iter.base() == v.data() + 1);
539            assert(err == std::ios_base::failbit);
540            noshowbase(ios);
541        }
542        {   // negative, showbase
543            std::wstring v = L"-USD 1,234,567.89";
544            typedef input_iterator<const wchar_t*> I;
545            long double ex;
546            std::ios_base::iostate err = std::ios_base::goodbit;
547            I iter = f.get(I(v.data()), I(v.data() + v.size()),
548                                                false, ios, err, ex);
549            assert(iter.base() == v.data() + 1);
550            assert(err == std::ios_base::failbit);
551        }
552    }
553    {
554        const my_facetw f(1);
555        // wchar_t, international
556        {   // zero
557            std::wstring v = L"0.00";
558            typedef input_iterator<const wchar_t*> I;
559            long double ex;
560            std::ios_base::iostate err = std::ios_base::goodbit;
561            I iter = f.get(I(v.data()), I(v.data() + v.size()),
562                                                true, ios, err, ex);
563            assert(iter.base() == v.data() + v.size());
564            assert(err == std::ios_base::eofbit);
565            assert(ex == 0);
566        }
567        {   // negative one
568            std::wstring v = L"-0.01";
569            typedef input_iterator<const wchar_t*> I;
570            long double ex;
571            std::ios_base::iostate err = std::ios_base::goodbit;
572            I iter = f.get(I(v.data()), I(v.data() + v.size()),
573                                                true, ios, err, ex);
574            assert(iter.base() == v.data() + v.size());
575            assert(err == std::ios_base::eofbit);
576            assert(ex == -1);
577        }
578        {   // positive
579            std::wstring v = L"1,234,567.89";
580            typedef input_iterator<const wchar_t*> I;
581            long double ex;
582            std::ios_base::iostate err = std::ios_base::goodbit;
583            I iter = f.get(I(v.data()), I(v.data() + v.size()),
584                                                true, ios, err, ex);
585            assert(iter.base() == v.data() + v.size());
586            assert(err == std::ios_base::eofbit);
587            assert(ex == 123456789);
588        }
589        {   // negative
590            std::wstring v = L"-1,234,567.89";
591            typedef input_iterator<const wchar_t*> I;
592            long double ex;
593            std::ios_base::iostate err = std::ios_base::goodbit;
594            I iter = f.get(I(v.data()), I(v.data() + v.size()),
595                                                true, ios, err, ex);
596            assert(iter.base() == v.data() + v.size());
597            assert(err == std::ios_base::eofbit);
598            assert(ex == -123456789);
599        }
600        {   // negative
601            std::wstring v = L"-1234567.89";
602            typedef input_iterator<const wchar_t*> I;
603            long double ex;
604            std::ios_base::iostate err = std::ios_base::goodbit;
605            I iter = f.get(I(v.data()), I(v.data() + v.size()),
606                                                true, ios, err, ex);
607            assert(iter.base() == v.data() + v.size());
608            assert(err == std::ios_base::eofbit);
609            assert(ex == -123456789);
610        }
611        {   // zero, showbase
612            std::wstring v = L"USD 0.00";
613            typedef input_iterator<const wchar_t*> I;
614            long double ex;
615            std::ios_base::iostate err = std::ios_base::goodbit;
616            I iter = f.get(I(v.data()), I(v.data() + v.size()),
617                                                true, ios, err, ex);
618            assert(iter.base() == v.data() + v.size());
619            assert(err == std::ios_base::eofbit);
620            assert(ex == 0);
621        }
622        {   // zero, showbase
623            std::wstring v = L"USD 0.00";
624            showbase(ios);
625            typedef input_iterator<const wchar_t*> I;
626            long double ex;
627            std::ios_base::iostate err = std::ios_base::goodbit;
628            I iter = f.get(I(v.data()), I(v.data() + v.size()),
629                                                true, ios, err, ex);
630            assert(iter.base() == v.data() + v.size());
631            assert(err == std::ios_base::eofbit);
632            assert(ex == 0);
633            noshowbase(ios);
634        }
635        {   // negative one, showbase
636            std::wstring v = L"-USD 0.01";
637            typedef input_iterator<const wchar_t*> I;
638            long double ex;
639            std::ios_base::iostate err = std::ios_base::goodbit;
640            I iter = f.get(I(v.data()), I(v.data() + v.size()),
641                                                true, ios, err, ex);
642            assert(iter.base() == v.data() + v.size());
643            assert(err == std::ios_base::eofbit);
644            assert(ex == -1);
645        }
646        {   // negative one, showbase
647            std::wstring v = L"-USD 0.01";
648            showbase(ios);
649            typedef input_iterator<const wchar_t*> I;
650            long double ex;
651            std::ios_base::iostate err = std::ios_base::goodbit;
652            I iter = f.get(I(v.data()), I(v.data() + v.size()),
653                                                true, ios, err, ex);
654            assert(iter.base() == v.data() + v.size());
655            assert(err == std::ios_base::eofbit);
656            assert(ex == -1);
657            noshowbase(ios);
658        }
659        {   // positive, showbase
660            std::wstring v = L"USD 1,234,567.89";
661            typedef input_iterator<const wchar_t*> I;
662            long double ex;
663            std::ios_base::iostate err = std::ios_base::goodbit;
664            I iter = f.get(I(v.data()), I(v.data() + v.size()),
665                                                true, ios, err, ex);
666            assert(iter.base() == v.data() + v.size());
667            assert(err == std::ios_base::eofbit);
668            assert(ex == 123456789);
669        }
670        {   // positive, showbase
671            std::wstring v = L"USD 1,234,567.89";
672            showbase(ios);
673            typedef input_iterator<const wchar_t*> I;
674            long double ex;
675            std::ios_base::iostate err = std::ios_base::goodbit;
676            I iter = f.get(I(v.data()), I(v.data() + v.size()),
677                                                true, ios, err, ex);
678            assert(iter.base() == v.data() + v.size());
679            assert(err == std::ios_base::eofbit);
680            assert(ex == 123456789);
681            noshowbase(ios);
682        }
683        {   // negative, showbase
684            std::wstring v = L"-USD 1,234,567.89";
685            showbase(ios);
686            typedef input_iterator<const wchar_t*> I;
687            long double ex;
688            std::ios_base::iostate err = std::ios_base::goodbit;
689            I iter = f.get(I(v.data()), I(v.data() + v.size()),
690                                                true, ios, err, ex);
691            assert(iter.base() == v.data() + v.size());
692            assert(err == std::ios_base::eofbit);
693            assert(ex == -123456789);
694            noshowbase(ios);
695        }
696        {   // negative, showbase
697            std::wstring v = L"-$1,234,567.89";
698            showbase(ios);
699            typedef input_iterator<const wchar_t*> I;
700            long double ex;
701            std::ios_base::iostate err = std::ios_base::goodbit;
702            I iter = f.get(I(v.data()), I(v.data() + v.size()),
703                                                true, ios, err, ex);
704            assert(iter.base() == v.data() + 1);
705            assert(err == std::ios_base::failbit);
706            noshowbase(ios);
707        }
708        {   // negative, showbase
709            std::wstring v = L"-$1,234,567.89";
710            typedef input_iterator<const wchar_t*> I;
711            long double ex;
712            std::ios_base::iostate err = std::ios_base::goodbit;
713            I iter = f.get(I(v.data()), I(v.data() + v.size()),
714                                                true, ios, err, ex);
715            assert(iter.base() == v.data() + 1);
716            assert(err == std::ios_base::failbit);
717        }
718    }
719}
720