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