get_long_double_ru_RU.pass.cpp revision bc8d3f97eb5c958007f2713238472e0c1c8fe02c 
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("ru_RU");
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 \xD1\x80\xD1\x83\xD0\xB1"".";
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() + 5);
121            assert(err == std::ios_base::goodbit);
122            assert(ex == 0);
123        }
124        {   // zero, showbase
125            std::string v = "0,00 \xD1\x80\xD1\x83\xD0\xB1"".";
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 \xD1\x80\xD1\x83\xD0\xB1"".";
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() + 6);
145            assert(err == std::ios_base::goodbit);
146            assert(ex == -1);
147        }
148        {   // negative one, showbase
149            std::string v = "-0,01 \xD1\x80\xD1\x83\xD0\xB1"".";
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 \xD1\x80\xD1\x83\xD0\xB1"".";
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() + 13);
169            assert(err == std::ios_base::goodbit);
170            assert(ex == 123456789);
171        }
172        {   // positive, showbase
173            std::string v = "1 234 567,89 \xD1\x80\xD1\x83\xD0\xB1"".";
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 \xD1\x80\xD1\x83\xD0\xB1"".";
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 = "-1 234 567,89 RUR ";
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() + 14);
207            assert(err == std::ios_base::failbit);
208            noshowbase(ios);
209        }
210        {   // negative, showbase
211            std::string v = "-1 234 567,89 RUR ";
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() + 14);
218            assert(err == std::ios_base::goodbit);
219            assert(ex == -123456789);
220        }
221    }
222    {
223        const my_facet f(1);
224        // char, international
225        {   // zero
226            std::string v = "0,00";
227            typedef input_iterator<const char*> I;
228            long double ex;
229            std::ios_base::iostate err = std::ios_base::goodbit;
230            I iter = f.get(I(v.data()), I(v.data() + v.size()),
231                                                true, ios, err, ex);
232            assert(iter.base() == v.data() + v.size());
233            assert(err == std::ios_base::eofbit);
234            assert(ex == 0);
235        }
236        {   // negative one
237            std::string v = "-0,01 ";
238            typedef input_iterator<const char*> I;
239            long double ex;
240            std::ios_base::iostate err = std::ios_base::goodbit;
241            I iter = f.get(I(v.data()), I(v.data() + v.size()),
242                                                true, ios, err, ex);
243            assert(iter.base() == v.data() + v.size());
244            assert(err == std::ios_base::eofbit);
245            assert(ex == -1);
246        }
247        {   // positive
248            std::string v = "1 234 567,89 ";
249            typedef input_iterator<const char*> I;
250            long double ex;
251            std::ios_base::iostate err = std::ios_base::goodbit;
252            I iter = f.get(I(v.data()), I(v.data() + v.size()),
253                                                true, ios, err, ex);
254            assert(iter.base() == v.data() + v.size());
255            assert(err == std::ios_base::eofbit);
256            assert(ex == 123456789);
257        }
258        {   // negative
259            std::string v = "-1 234 567,89 ";
260            typedef input_iterator<const char*> I;
261            long double ex;
262            std::ios_base::iostate err = std::ios_base::goodbit;
263            I iter = f.get(I(v.data()), I(v.data() + v.size()),
264                                                true, ios, err, ex);
265            assert(iter.base() == v.data() + v.size());
266            assert(err == std::ios_base::eofbit);
267            assert(ex == -123456789);
268        }
269        {   // negative
270            std::string v = "-1234567,89 ";
271            typedef input_iterator<const char*> I;
272            long double ex;
273            std::ios_base::iostate err = std::ios_base::goodbit;
274            I iter = f.get(I(v.data()), I(v.data() + v.size()),
275                                                true, ios, err, ex);
276            assert(iter.base() == v.data() + v.size());
277            assert(err == std::ios_base::eofbit);
278            assert(ex == -123456789);
279        }
280        {   // zero, showbase
281            std::string v = "0,00 RUR ";
282            typedef input_iterator<const char*> I;
283            long double ex;
284            std::ios_base::iostate err = std::ios_base::goodbit;
285            I iter = f.get(I(v.data()), I(v.data() + v.size()),
286                                                true, ios, err, ex);
287            assert(iter.base() == v.data() + 5);
288            assert(err == std::ios_base::goodbit);
289            assert(ex == 0);
290        }
291        {   // zero, showbase
292            std::string v = "0,00 RUR ";
293            showbase(ios);
294            typedef input_iterator<const char*> I;
295            long double ex;
296            std::ios_base::iostate err = std::ios_base::goodbit;
297            I iter = f.get(I(v.data()), I(v.data() + v.size()),
298                                                true, ios, err, ex);
299            assert(iter.base() == v.data() + v.size());
300            assert(err == std::ios_base::eofbit);
301            assert(ex == 0);
302            noshowbase(ios);
303        }
304        {   // negative one, showbase
305            std::string v = "-0,01 RUR ";
306            typedef input_iterator<const char*> I;
307            long double ex;
308            std::ios_base::iostate err = std::ios_base::goodbit;
309            I iter = f.get(I(v.data()), I(v.data() + v.size()),
310                                                true, ios, err, ex);
311            assert(iter.base() == v.data() + 6);
312            assert(err == std::ios_base::goodbit);
313            assert(ex == -1);
314        }
315        {   // negative one, showbase
316            std::string v = "-0,01 RUR ";
317            showbase(ios);
318            typedef input_iterator<const char*> I;
319            long double ex;
320            std::ios_base::iostate err = std::ios_base::goodbit;
321            I iter = f.get(I(v.data()), I(v.data() + v.size()),
322                                                true, ios, err, ex);
323            assert(iter.base() == v.data() + v.size());
324            assert(err == std::ios_base::eofbit);
325            assert(ex == -1);
326            noshowbase(ios);
327        }
328        {   // positive, showbase
329            std::string v = "1 234 567,89 RUR ";
330            typedef input_iterator<const char*> I;
331            long double ex;
332            std::ios_base::iostate err = std::ios_base::goodbit;
333            I iter = f.get(I(v.data()), I(v.data() + v.size()),
334                                                true, ios, err, ex);
335            assert(iter.base() == v.data() + 13);
336            assert(err == std::ios_base::goodbit);
337            assert(ex == 123456789);
338        }
339        {   // positive, showbase
340            std::string v = "1 234 567,89 RUR ";
341            showbase(ios);
342            typedef input_iterator<const char*> I;
343            long double ex;
344            std::ios_base::iostate err = std::ios_base::goodbit;
345            I iter = f.get(I(v.data()), I(v.data() + v.size()),
346                                                true, ios, err, ex);
347            assert(iter.base() == v.data() + v.size());
348            assert(err == std::ios_base::eofbit);
349            assert(ex == 123456789);
350            noshowbase(ios);
351        }
352        {   // negative, showbase
353            std::string v = "-1 234 567,89 RUR ";
354            showbase(ios);
355            typedef input_iterator<const char*> I;
356            long double ex;
357            std::ios_base::iostate err = std::ios_base::goodbit;
358            I iter = f.get(I(v.data()), I(v.data() + v.size()),
359                                                true, ios, err, ex);
360            assert(iter.base() == v.data() + v.size());
361            assert(err == std::ios_base::eofbit);
362            assert(ex == -123456789);
363            noshowbase(ios);
364        }
365        {   // negative, showbase
366            std::string v = "-1 234 567,89 \xD1\x80\xD1\x83\xD0\xB1"".";
367            showbase(ios);
368            typedef input_iterator<const char*> I;
369            long double ex;
370            std::ios_base::iostate err = std::ios_base::goodbit;
371            I iter = f.get(I(v.data()), I(v.data() + v.size()),
372                                                true, ios, err, ex);
373            assert(iter.base() == v.data() + 14);
374            assert(err == std::ios_base::failbit);
375            noshowbase(ios);
376        }
377        {   // negative, showbase
378            std::string v = "-1 234 567,89 \xD1\x80\xD1\x83\xD0\xB1"".";
379            typedef input_iterator<const char*> I;
380            long double ex;
381            std::ios_base::iostate err = std::ios_base::goodbit;
382            I iter = f.get(I(v.data()), I(v.data() + v.size()),
383                                                true, ios, err, ex);
384            assert(iter.base() == v.data() + 14);
385            assert(err == std::ios_base::goodbit);
386            assert(ex == -123456789);
387        }
388    }
389    {
390        const my_facetw f(1);
391        // wchar_t, national
392        {   // zero
393            std::wstring v = L"0,00";
394            typedef input_iterator<const wchar_t*> I;
395            long double ex;
396            std::ios_base::iostate err = std::ios_base::goodbit;
397            I iter = f.get(I(v.data()), I(v.data() + v.size()),
398                                                false, ios, err, ex);
399            assert(iter.base() == v.data() + v.size());
400            assert(err == std::ios_base::eofbit);
401            assert(ex == 0);
402        }
403        {   // negative one
404            std::wstring v = L"-0,01 ";
405            typedef input_iterator<const wchar_t*> I;
406            long double ex;
407            std::ios_base::iostate err = std::ios_base::goodbit;
408            I iter = f.get(I(v.data()), I(v.data() + v.size()),
409                                                false, ios, err, ex);
410            assert(iter.base() == v.data() + v.size());
411            assert(err == std::ios_base::eofbit);
412            assert(ex == -1);
413        }
414        {   // positive
415            std::wstring v = L"1 234 567,89 ";
416            typedef input_iterator<const wchar_t*> I;
417            long double ex;
418            std::ios_base::iostate err = std::ios_base::goodbit;
419            I iter = f.get(I(v.data()), I(v.data() + v.size()),
420                                                false, ios, err, ex);
421            assert(iter.base() == v.data() + v.size());
422            assert(err == std::ios_base::eofbit);
423            assert(ex == 123456789);
424        }
425        {   // negative
426            std::wstring v = L"-1 234 567,89 ";
427            typedef input_iterator<const wchar_t*> I;
428            long double ex;
429            std::ios_base::iostate err = std::ios_base::goodbit;
430            I iter = f.get(I(v.data()), I(v.data() + v.size()),
431                                                false, ios, err, ex);
432            assert(iter.base() == v.data() + v.size());
433            assert(err == std::ios_base::eofbit);
434            assert(ex == -123456789);
435        }
436        {   // negative
437            std::wstring v = L"-1234567,89 ";
438            typedef input_iterator<const wchar_t*> I;
439            long double ex;
440            std::ios_base::iostate err = std::ios_base::goodbit;
441            I iter = f.get(I(v.data()), I(v.data() + v.size()),
442                                                false, ios, err, ex);
443            assert(iter.base() == v.data() + v.size());
444            assert(err == std::ios_base::eofbit);
445            assert(ex == -123456789);
446        }
447        {   // zero, showbase
448            std::wstring v = L"0,00 \x440\x443\x431"".";
449            typedef input_iterator<const wchar_t*> I;
450            long double ex;
451            std::ios_base::iostate err = std::ios_base::goodbit;
452            I iter = f.get(I(v.data()), I(v.data() + v.size()),
453                                                false, ios, err, ex);
454            assert(iter.base() == v.data() + 5);
455            assert(err == std::ios_base::goodbit);
456            assert(ex == 0);
457        }
458        {   // zero, showbase
459            std::wstring v = L"0,00 \x440\x443\x431"".";
460            showbase(ios);
461            typedef input_iterator<const wchar_t*> I;
462            long double ex;
463            std::ios_base::iostate err = std::ios_base::goodbit;
464            I iter = f.get(I(v.data()), I(v.data() + v.size()),
465                                                false, ios, err, ex);
466            assert(iter.base() == v.data() + v.size());
467            assert(err == std::ios_base::eofbit);
468            assert(ex == 0);
469            noshowbase(ios);
470        }
471        {   // negative one, showbase
472            std::wstring v = L"-0,01 \x440\x443\x431"".";
473            typedef input_iterator<const wchar_t*> I;
474            long double ex;
475            std::ios_base::iostate err = std::ios_base::goodbit;
476            I iter = f.get(I(v.data()), I(v.data() + v.size()),
477                                                false, ios, err, ex);
478            assert(iter.base() == v.data() + 6);
479            assert(err == std::ios_base::goodbit);
480            assert(ex == -1);
481        }
482        {   // negative one, showbase
483            std::wstring v = L"-0,01 \x440\x443\x431"".";
484            showbase(ios);
485            typedef input_iterator<const wchar_t*> I;
486            long double ex;
487            std::ios_base::iostate err = std::ios_base::goodbit;
488            I iter = f.get(I(v.data()), I(v.data() + v.size()),
489                                                false, ios, err, ex);
490            assert(iter.base() == v.data() + v.size());
491            assert(err == std::ios_base::eofbit);
492            assert(ex == -1);
493            noshowbase(ios);
494        }
495        {   // positive, showbase
496            std::wstring v = L"1 234 567,89 \x440\x443\x431"".";
497            typedef input_iterator<const wchar_t*> I;
498            long double ex;
499            std::ios_base::iostate err = std::ios_base::goodbit;
500            I iter = f.get(I(v.data()), I(v.data() + v.size()),
501                                                false, ios, err, ex);
502            assert(iter.base() == v.data() + 13);
503            assert(err == std::ios_base::goodbit);
504            assert(ex == 123456789);
505        }
506        {   // positive, showbase
507            std::wstring v = L"1 234 567,89 \x440\x443\x431"".";
508            showbase(ios);
509            typedef input_iterator<const wchar_t*> I;
510            long double ex;
511            std::ios_base::iostate err = std::ios_base::goodbit;
512            I iter = f.get(I(v.data()), I(v.data() + v.size()),
513                                                false, ios, err, ex);
514            assert(iter.base() == v.data() + v.size());
515            assert(err == std::ios_base::eofbit);
516            assert(ex == 123456789);
517            noshowbase(ios);
518        }
519        {   // negative, showbase
520            std::wstring v = L"-1 234 567,89 \x440\x443\x431"".";
521            showbase(ios);
522            typedef input_iterator<const wchar_t*> I;
523            long double ex;
524            std::ios_base::iostate err = std::ios_base::goodbit;
525            I iter = f.get(I(v.data()), I(v.data() + v.size()),
526                                                false, ios, err, ex);
527            assert(iter.base() == v.data() + v.size());
528            assert(err == std::ios_base::eofbit);
529            assert(ex == -123456789);
530            noshowbase(ios);
531        }
532        {   // negative, showbase
533            std::wstring v = L"-1 234 567,89 RUR ";
534            showbase(ios);
535            typedef input_iterator<const wchar_t*> I;
536            long double ex;
537            std::ios_base::iostate err = std::ios_base::goodbit;
538            I iter = f.get(I(v.data()), I(v.data() + v.size()),
539                                                false, ios, err, ex);
540            assert(iter.base() == v.data() + 14);
541            assert(err == std::ios_base::failbit);
542            noshowbase(ios);
543        }
544        {   // negative, showbase
545            std::wstring v = L"-1 234 567,89 RUR ";
546            typedef input_iterator<const wchar_t*> I;
547            long double ex;
548            std::ios_base::iostate err = std::ios_base::goodbit;
549            I iter = f.get(I(v.data()), I(v.data() + v.size()),
550                                                false, ios, err, ex);
551            assert(iter.base() == v.data() + 14);
552            assert(err == std::ios_base::goodbit);
553            assert(ex == -123456789);
554        }
555    }
556    {
557        const my_facetw f(1);
558        // wchar_t, international
559        {   // zero
560            std::wstring v = L"0,00";
561            typedef input_iterator<const wchar_t*> I;
562            long double ex;
563            std::ios_base::iostate err = std::ios_base::goodbit;
564            I iter = f.get(I(v.data()), I(v.data() + v.size()),
565                                                true, ios, err, ex);
566            assert(iter.base() == v.data() + v.size());
567            assert(err == std::ios_base::eofbit);
568            assert(ex == 0);
569        }
570        {   // negative one
571            std::wstring v = L"-0,01 ";
572            typedef input_iterator<const wchar_t*> I;
573            long double ex;
574            std::ios_base::iostate err = std::ios_base::goodbit;
575            I iter = f.get(I(v.data()), I(v.data() + v.size()),
576                                                true, ios, err, ex);
577            assert(iter.base() == v.data() + v.size());
578            assert(err == std::ios_base::eofbit);
579            assert(ex == -1);
580        }
581        {   // positive
582            std::wstring v = L"1 234 567,89 ";
583            typedef input_iterator<const wchar_t*> I;
584            long double ex;
585            std::ios_base::iostate err = std::ios_base::goodbit;
586            I iter = f.get(I(v.data()), I(v.data() + v.size()),
587                                                true, ios, err, ex);
588            assert(iter.base() == v.data() + v.size());
589            assert(err == std::ios_base::eofbit);
590            assert(ex == 123456789);
591        }
592        {   // negative
593            std::wstring v = L"-1 234 567,89 ";
594            typedef input_iterator<const wchar_t*> I;
595            long double ex;
596            std::ios_base::iostate err = std::ios_base::goodbit;
597            I iter = f.get(I(v.data()), I(v.data() + v.size()),
598                                                true, ios, err, ex);
599            assert(iter.base() == v.data() + v.size());
600            assert(err == std::ios_base::eofbit);
601            assert(ex == -123456789);
602        }
603        {   // negative
604            std::wstring v = L"-1234567,89 ";
605            typedef input_iterator<const wchar_t*> I;
606            long double ex;
607            std::ios_base::iostate err = std::ios_base::goodbit;
608            I iter = f.get(I(v.data()), I(v.data() + v.size()),
609                                                true, ios, err, ex);
610            assert(iter.base() == v.data() + v.size());
611            assert(err == std::ios_base::eofbit);
612            assert(ex == -123456789);
613        }
614        {   // zero, showbase
615            std::wstring v = L"0,00 RUR ";
616            typedef input_iterator<const wchar_t*> I;
617            long double ex;
618            std::ios_base::iostate err = std::ios_base::goodbit;
619            I iter = f.get(I(v.data()), I(v.data() + v.size()),
620                                                true, ios, err, ex);
621            assert(iter.base() == v.data() + 5);
622            assert(err == std::ios_base::goodbit);
623            assert(ex == 0);
624        }
625        {   // zero, showbase
626            std::wstring v = L"0,00 RUR ";
627            showbase(ios);
628            typedef input_iterator<const wchar_t*> I;
629            long double ex;
630            std::ios_base::iostate err = std::ios_base::goodbit;
631            I iter = f.get(I(v.data()), I(v.data() + v.size()),
632                                                true, ios, err, ex);
633            assert(iter.base() == v.data() + v.size());
634            assert(err == std::ios_base::eofbit);
635            assert(ex == 0);
636            noshowbase(ios);
637        }
638        {   // negative one, showbase
639            std::wstring v = L"-0,01 RUR ";
640            typedef input_iterator<const wchar_t*> I;
641            long double ex;
642            std::ios_base::iostate err = std::ios_base::goodbit;
643            I iter = f.get(I(v.data()), I(v.data() + v.size()),
644                                                true, ios, err, ex);
645            assert(iter.base() == v.data() + 6);
646            assert(err == std::ios_base::goodbit);
647            assert(ex == -1);
648        }
649        {   // negative one, showbase
650            std::wstring v = L"-0,01 RUR ";
651            showbase(ios);
652            typedef input_iterator<const wchar_t*> I;
653            long double ex;
654            std::ios_base::iostate err = std::ios_base::goodbit;
655            I iter = f.get(I(v.data()), I(v.data() + v.size()),
656                                                true, ios, err, ex);
657            assert(iter.base() == v.data() + v.size());
658            assert(err == std::ios_base::eofbit);
659            assert(ex == -1);
660            noshowbase(ios);
661        }
662        {   // positive, showbase
663            std::wstring v = L"1 234 567,89 RUR ";
664            typedef input_iterator<const wchar_t*> I;
665            long double ex;
666            std::ios_base::iostate err = std::ios_base::goodbit;
667            I iter = f.get(I(v.data()), I(v.data() + v.size()),
668                                                true, ios, err, ex);
669            assert(iter.base() == v.data() + 13);
670            assert(err == std::ios_base::goodbit);
671            assert(ex == 123456789);
672        }
673        {   // positive, showbase
674            std::wstring v = L"1 234 567,89 RUR ";
675            showbase(ios);
676            typedef input_iterator<const wchar_t*> I;
677            long double ex;
678            std::ios_base::iostate err = std::ios_base::goodbit;
679            I iter = f.get(I(v.data()), I(v.data() + v.size()),
680                                                true, ios, err, ex);
681            assert(iter.base() == v.data() + v.size());
682            assert(err == std::ios_base::eofbit);
683            assert(ex == 123456789);
684            noshowbase(ios);
685        }
686        {   // negative, showbase
687            std::wstring v = L"-1 234 567,89 RUR ";
688            showbase(ios);
689            typedef input_iterator<const wchar_t*> I;
690            long double ex;
691            std::ios_base::iostate err = std::ios_base::goodbit;
692            I iter = f.get(I(v.data()), I(v.data() + v.size()),
693                                                true, ios, err, ex);
694            assert(iter.base() == v.data() + v.size());
695            assert(err == std::ios_base::eofbit);
696            assert(ex == -123456789);
697            noshowbase(ios);
698        }
699        {   // negative, showbase
700            std::wstring v = L"-1 234 567,89 \x440\x443\x431"".";
701            showbase(ios);
702            typedef input_iterator<const wchar_t*> I;
703            long double ex;
704            std::ios_base::iostate err = std::ios_base::goodbit;
705            I iter = f.get(I(v.data()), I(v.data() + v.size()),
706                                                true, ios, err, ex);
707            assert(iter.base() == v.data() + 14);
708            assert(err == std::ios_base::failbit);
709            noshowbase(ios);
710        }
711        {   // negative, showbase
712            std::wstring v = L"-1 234 567,89 \x440\x443\x431"".";
713            typedef input_iterator<const wchar_t*> I;
714            long double ex;
715            std::ios_base::iostate err = std::ios_base::goodbit;
716            I iter = f.get(I(v.data()), I(v.data() + v.size()),
717                                                true, ios, err, ex);
718            assert(iter.base() == v.data() + 14);
719            assert(err == std::ios_base::goodbit);
720            assert(ex == -123456789);
721        }
722    }
723}
724