get_long.pass.cpp revision b04ad4162df9080ad93163c0aeb0b7227c465eb3 
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// <locale>
11
12// class num_get<charT, InputIterator>
13
14// iter_type get(iter_type in, iter_type end, ios_base&,
15//               ios_base::iostate& err, long& v) const;
16
17#include <locale>
18#include <ios>
19#include <cassert>
20#include <streambuf>
21#include "iterators.h"
22
23typedef std::num_get<char, input_iterator<const char*> > F;
24
25class my_facet
26    : public F
27{
28public:
29    explicit my_facet(std::size_t refs = 0)
30        : F(refs) {}
31};
32
33class my_numpunct
34    : public std::numpunct<char>
35{
36public:
37    my_numpunct() : std::numpunct<char>() {}
38
39protected:
40    virtual char_type do_thousands_sep() const {return '_';}
41    virtual std::string do_grouping() const {return std::string("\1\2\3");}
42};
43
44int main()
45{
46    const my_facet f(1);
47    std::ios ios(0);
48    long v = -1;
49    {
50        const char str[] = "123";
51        assert((ios.flags() & ios.basefield) == ios.dec);
52        assert(ios.getloc().name() == "C");
53        std::ios_base::iostate err = ios.goodbit;
54        input_iterator<const char*> iter =
55            f.get(input_iterator<const char*>(str),
56                  input_iterator<const char*>(str+sizeof(str)),
57                  ios, err, v);
58        assert(iter.base() == str+3);
59        assert(err == ios.goodbit);
60        assert(v == 123);
61    }
62    {
63        const char str[] = "-123";
64        assert((ios.flags() & ios.basefield) == ios.dec);
65        assert(ios.getloc().name() == "C");
66        std::ios_base::iostate err = ios.goodbit;
67        input_iterator<const char*> iter =
68            f.get(input_iterator<const char*>(str),
69                  input_iterator<const char*>(str+sizeof(str)),
70                  ios, err, v);
71        assert(iter.base() == str+4);
72        assert(err == ios.goodbit);
73        assert(v == -123);
74    }
75    {
76        const char str[] = "123";
77        oct(ios);
78        std::ios_base::iostate err = ios.goodbit;
79        input_iterator<const char*> iter =
80            f.get(input_iterator<const char*>(str),
81                  input_iterator<const char*>(str+sizeof(str)),
82                  ios, err, v);
83        assert(iter.base() == str+3);
84        assert(err == ios.goodbit);
85        assert(v == 83);
86    }
87    {
88        const char str[] = "123";
89        hex(ios);
90        std::ios_base::iostate err = ios.goodbit;
91        input_iterator<const char*> iter =
92            f.get(input_iterator<const char*>(str),
93                  input_iterator<const char*>(str+sizeof(str)),
94                  ios, err, v);
95        assert(iter.base() == str+3);
96        assert(err == ios.goodbit);
97        assert(v == 291);
98    }
99    {
100        const char str[] = "0x123";
101        hex(ios);
102        std::ios_base::iostate err = ios.goodbit;
103        input_iterator<const char*> iter =
104            f.get(input_iterator<const char*>(str),
105                  input_iterator<const char*>(str+sizeof(str)),
106                  ios, err, v);
107        assert(iter.base() == str+sizeof(str)-1);
108        assert(err == ios.goodbit);
109        assert(v == 291);
110    }
111    {
112        const char str[] = "123";
113        ios.setf(0, ios.basefield);
114        std::ios_base::iostate err = ios.goodbit;
115        input_iterator<const char*> iter =
116            f.get(input_iterator<const char*>(str),
117                  input_iterator<const char*>(str+sizeof(str)),
118                  ios, err, v);
119        assert(iter.base() == str+sizeof(str)-1);
120        assert(err == ios.goodbit);
121        assert(v == 123);
122    }
123    {
124        const char str[] = "0x123";
125        ios.setf(0, ios.basefield);
126        std::ios_base::iostate err = ios.goodbit;
127        input_iterator<const char*> iter =
128            f.get(input_iterator<const char*>(str),
129                  input_iterator<const char*>(str+sizeof(str)),
130                  ios, err, v);
131        assert(iter.base() == str+sizeof(str)-1);
132        assert(err == ios.goodbit);
133        assert(v == 291);
134    }
135    {
136        const char str[] = "0123";
137        ios.setf(0, ios.basefield);
138        std::ios_base::iostate err = ios.goodbit;
139        input_iterator<const char*> iter =
140            f.get(input_iterator<const char*>(str),
141                  input_iterator<const char*>(str+sizeof(str)),
142                  ios, err, v);
143        assert(iter.base() == str+sizeof(str)-1);
144        assert(err == ios.goodbit);
145        assert(v == 83);
146    }
147    {
148        const char str[] = "2-";
149        ios.setf(0, ios.basefield);
150        std::ios_base::iostate err = ios.goodbit;
151        input_iterator<const char*> iter =
152            f.get(input_iterator<const char*>(str),
153                  input_iterator<const char*>(str+sizeof(str)),
154                  ios, err, v);
155        assert(iter.base() == str+1);
156        assert(err == ios.goodbit);
157        assert(v == 2);
158    }
159    dec(ios);
160    ios.imbue(std::locale(std::locale(), new my_numpunct));
161    {
162        v = -1;
163        const char str[] = "123";
164        std::ios_base::iostate err = ios.goodbit;
165        input_iterator<const char*> iter =
166            f.get(input_iterator<const char*>(str),
167                  input_iterator<const char*>(str+sizeof(str)),
168                  ios, err, v);
169        assert(iter.base() == str+sizeof(str)-1);
170        assert(err == ios.failbit);
171        assert(v == 123);
172    }
173    {
174        v = -1;
175        const char str[] = "+1";
176        std::ios_base::iostate err = ios.goodbit;
177        input_iterator<const char*> iter =
178            f.get(input_iterator<const char*>(str),
179                  input_iterator<const char*>(str+sizeof(str)),
180                  ios, err, v);
181        assert(iter.base() == str+sizeof(str)-1);
182        assert(err == ios.goodbit);
183        assert(v == 1);
184    }
185    {
186        v = -1;
187        const char str[] = "+1_";
188        std::ios_base::iostate err = ios.goodbit;
189        input_iterator<const char*> iter =
190            f.get(input_iterator<const char*>(str),
191                  input_iterator<const char*>(str+sizeof(str)),
192                  ios, err, v);
193        assert(iter.base() == str+sizeof(str)-1);
194        assert(err == ios.failbit);
195        assert(v == 1);
196    }
197    {
198        v = -1;
199        const char str[] = "+_1";
200        std::ios_base::iostate err = ios.goodbit;
201        input_iterator<const char*> iter =
202            f.get(input_iterator<const char*>(str),
203                  input_iterator<const char*>(str+sizeof(str)),
204                  ios, err, v);
205        assert(iter.base() == str+sizeof(str)-1);
206        assert(err == ios.failbit);
207        assert(v == 1);
208    }
209    {
210        v = -1;
211        const char str[] = "_+1";
212        std::ios_base::iostate err = ios.goodbit;
213        input_iterator<const char*> iter =
214            f.get(input_iterator<const char*>(str),
215                  input_iterator<const char*>(str+sizeof(str)),
216                  ios, err, v);
217        assert(iter.base() == str+sizeof(str)-1);
218        assert(err == ios.failbit);
219        assert(v == 1);
220    }
221    {
222        v = -1;
223        const char str[] = "+1__";
224        std::ios_base::iostate err = ios.goodbit;
225        input_iterator<const char*> iter =
226            f.get(input_iterator<const char*>(str),
227                  input_iterator<const char*>(str+sizeof(str)),
228                  ios, err, v);
229        assert(iter.base() == str+sizeof(str)-1);
230        assert(err == ios.failbit);
231        assert(v == 1);
232    }
233    {
234        v = -1;
235        const char str[] = "+_1_";
236        std::ios_base::iostate err = ios.goodbit;
237        input_iterator<const char*> iter =
238            f.get(input_iterator<const char*>(str),
239                  input_iterator<const char*>(str+sizeof(str)),
240                  ios, err, v);
241        assert(iter.base() == str+sizeof(str)-1);
242        assert(err == ios.failbit);
243        assert(v == 1);
244    }
245    {
246        v = -1;
247        const char str[] = "_+1_";
248        std::ios_base::iostate err = ios.goodbit;
249        input_iterator<const char*> iter =
250            f.get(input_iterator<const char*>(str),
251                  input_iterator<const char*>(str+sizeof(str)),
252                  ios, err, v);
253        assert(iter.base() == str+sizeof(str)-1);
254        assert(err == ios.failbit);
255        assert(v == 1);
256    }
257    {
258        v = -1;
259        const char str[] = "+__1";
260        std::ios_base::iostate err = ios.goodbit;
261        input_iterator<const char*> iter =
262            f.get(input_iterator<const char*>(str),
263                  input_iterator<const char*>(str+sizeof(str)),
264                  ios, err, v);
265        assert(iter.base() == str+sizeof(str)-1);
266        assert(err == ios.failbit);
267        assert(v == 1);
268    }
269    {
270        v = -1;
271        const char str[] = "_+_1";
272        std::ios_base::iostate err = ios.goodbit;
273        input_iterator<const char*> iter =
274            f.get(input_iterator<const char*>(str),
275                  input_iterator<const char*>(str+sizeof(str)),
276                  ios, err, v);
277        assert(iter.base() == str+sizeof(str)-1);
278        assert(err == ios.failbit);
279        assert(v == 1);
280    }
281    {
282        v = -1;
283        const char str[] = "__+1";
284        std::ios_base::iostate err = ios.goodbit;
285        input_iterator<const char*> iter =
286            f.get(input_iterator<const char*>(str),
287                  input_iterator<const char*>(str+sizeof(str)),
288                  ios, err, v);
289        assert(iter.base() == str+sizeof(str)-1);
290        assert(err == ios.failbit);
291        assert(v == 1);
292    }
293    {
294        v = -1;
295        const char str[] = "+1_2";
296        std::ios_base::iostate err = ios.goodbit;
297        input_iterator<const char*> iter =
298            f.get(input_iterator<const char*>(str),
299                  input_iterator<const char*>(str+sizeof(str)),
300                  ios, err, v);
301        assert(iter.base() == str+sizeof(str)-1);
302        assert(err == ios.goodbit);
303        assert(v == 12);
304    }
305    {
306        v = -1;
307        const char str[] = "+12_";
308        std::ios_base::iostate err = ios.goodbit;
309        input_iterator<const char*> iter =
310            f.get(input_iterator<const char*>(str),
311                  input_iterator<const char*>(str+sizeof(str)),
312                  ios, err, v);
313        assert(iter.base() == str+sizeof(str)-1);
314        assert(err == ios.failbit);
315        assert(v == 12);
316    }
317    {
318        v = -1;
319        const char str[] = "+_12";
320        std::ios_base::iostate err = ios.goodbit;
321        input_iterator<const char*> iter =
322            f.get(input_iterator<const char*>(str),
323                  input_iterator<const char*>(str+sizeof(str)),
324                  ios, err, v);
325        assert(iter.base() == str+sizeof(str)-1);
326        assert(err == ios.failbit);
327        assert(v == 12);
328    }
329    {
330        v = -1;
331        const char str[] = "+1__2";
332        std::ios_base::iostate err = ios.goodbit;
333        input_iterator<const char*> iter =
334            f.get(input_iterator<const char*>(str),
335                  input_iterator<const char*>(str+sizeof(str)),
336                  ios, err, v);
337        assert(iter.base() == str+sizeof(str)-1);
338        assert(err == ios.failbit);
339        assert(v == 12);
340    }
341    {
342        v = -1;
343        const char str[] = "+12_3";
344        std::ios_base::iostate err = ios.goodbit;
345        input_iterator<const char*> iter =
346            f.get(input_iterator<const char*>(str),
347                  input_iterator<const char*>(str+sizeof(str)),
348                  ios, err, v);
349        assert(iter.base() == str+sizeof(str)-1);
350        assert(err == ios.goodbit);
351        assert(v == 123);
352    }
353    {
354        v = -1;
355        const char str[] = "+1_23";
356        std::ios_base::iostate err = ios.goodbit;
357        input_iterator<const char*> iter =
358            f.get(input_iterator<const char*>(str),
359                  input_iterator<const char*>(str+sizeof(str)),
360                  ios, err, v);
361        assert(iter.base() == str+sizeof(str)-1);
362        assert(err == ios.failbit);
363        assert(v == 123);
364    }
365    {
366        v = -1;
367        const char str[] = "+1_23_4";
368        std::ios_base::iostate err = ios.goodbit;
369        input_iterator<const char*> iter =
370            f.get(input_iterator<const char*>(str),
371                  input_iterator<const char*>(str+sizeof(str)),
372                  ios, err, v);
373        assert(iter.base() == str+sizeof(str)-1);
374        assert(err == ios.goodbit);
375        assert(v == 1234);
376    }
377    {
378        v = -1;
379        const char str[] = "+123_4";
380        std::ios_base::iostate err = ios.goodbit;
381        input_iterator<const char*> iter =
382            f.get(input_iterator<const char*>(str),
383                  input_iterator<const char*>(str+sizeof(str)),
384                  ios, err, v);
385        assert(iter.base() == str+sizeof(str)-1);
386        assert(err == ios.failbit);
387        assert(v == 1234);
388    }
389    {
390        v = -1;
391        const char str[] = "+12_34";
392        std::ios_base::iostate err = ios.goodbit;
393        input_iterator<const char*> iter =
394            f.get(input_iterator<const char*>(str),
395                  input_iterator<const char*>(str+sizeof(str)),
396                  ios, err, v);
397        assert(iter.base() == str+sizeof(str)-1);
398        assert(err == ios.failbit);
399        assert(v == 1234);
400    }
401    {
402        v = -1;
403        const char str[] = "+12_34_5";
404        std::ios_base::iostate err = ios.goodbit;
405        input_iterator<const char*> iter =
406            f.get(input_iterator<const char*>(str),
407                  input_iterator<const char*>(str+sizeof(str)),
408                  ios, err, v);
409        assert(iter.base() == str+sizeof(str)-1);
410        assert(err == ios.goodbit);
411        assert(v == 12345);
412    }
413    {
414        v = -1;
415        const char str[] = "+123_45_6";
416        std::ios_base::iostate err = ios.goodbit;
417        input_iterator<const char*> iter =
418            f.get(input_iterator<const char*>(str),
419                  input_iterator<const char*>(str+sizeof(str)),
420                  ios, err, v);
421        assert(iter.base() == str+sizeof(str)-1);
422        assert(err == ios.goodbit);
423        assert(v == 123456);
424    }
425    {
426        v = -1;
427        const char str[] = "+1_23_45_6";
428        std::ios_base::iostate err = ios.goodbit;
429        input_iterator<const char*> iter =
430            f.get(input_iterator<const char*>(str),
431                  input_iterator<const char*>(str+sizeof(str)),
432                  ios, err, v);
433        assert(iter.base() == str+sizeof(str)-1);
434        assert(err == ios.failbit);
435        assert(v == 123456);
436    }
437    {
438        v = -1;
439        const char str[] = "+1_234_56_7";
440        std::ios_base::iostate err = ios.goodbit;
441        input_iterator<const char*> iter =
442            f.get(input_iterator<const char*>(str),
443                  input_iterator<const char*>(str+sizeof(str)),
444                  ios, err, v);
445        assert(iter.base() == str+sizeof(str)-1);
446        assert(err == ios.goodbit);
447        assert(v == 1234567);
448    }
449    {
450        v = -1;
451        const char str[] = "+1_234_567_89_0";
452        std::ios_base::iostate err = ios.goodbit;
453        input_iterator<const char*> iter =
454            f.get(input_iterator<const char*>(str),
455                  input_iterator<const char*>(str+sizeof(str)),
456                  ios, err, v);
457        assert(iter.base() == str+sizeof(str)-1);
458        assert(err == ios.goodbit);
459        assert(v == 1234567890);
460    }
461    {
462        v = -1;
463        const char str[] = "-1_234_567_89_0";
464        std::ios_base::iostate err = ios.goodbit;
465        input_iterator<const char*> iter =
466            f.get(input_iterator<const char*>(str),
467                  input_iterator<const char*>(str+sizeof(str)),
468                  ios, err, v);
469        assert(iter.base() == str+sizeof(str)-1);
470        assert(err == ios.goodbit);
471        assert(v == -1234567890);
472    }
473    {
474        v = -1;
475        const char str[] = "1_234_567_89_0";
476        std::ios_base::iostate err = ios.goodbit;
477        input_iterator<const char*> iter =
478            f.get(input_iterator<const char*>(str),
479                  input_iterator<const char*>(str+sizeof(str)),
480                  ios, err, v);
481        assert(iter.base() == str+sizeof(str)-1);
482        assert(err == ios.goodbit);
483        assert(v == 1234567890);
484    }
485    {
486        v = -1;
487        const char str[] = "1234_567_89_0";
488        std::ios_base::iostate err = ios.goodbit;
489        input_iterator<const char*> iter =
490            f.get(input_iterator<const char*>(str),
491                  input_iterator<const char*>(str+sizeof(str)),
492                  ios, err, v);
493        assert(iter.base() == str+sizeof(str)-1);
494        assert(err == ios.failbit);
495        assert(v == 1234567890);
496    }
497    {
498        v = -1;
499        const char str[] = "1_2_3_4_5_6_7_8_9_0_1_2_3_4_5_6_7_8_9_0_1_2_3_4_5_6_7_8_9_0_"
500                           "1_2_3_4_5_6_7_8_9_0_1_2_3_4_5_6_7_8_9_0_1_2_3_4_5_6_7_8_9_0_"
501                           "1_2_3_4_5_6_7_8_9_0_1_2_3_4_5_6_7_8_9_0_1_2_3_4_5_6_7_8_9_0_"
502                           "1_2_3_4_5_6_7_8_9_0_1_2_3_4_5_6_7_8_9_0_1_2_3_4_5_6_7_8_9_0_"
503                           "1_2_3_4_5_6_7_8_9_0_1_2_3_4_5_6_7_8_9_0_1_2_3_4_5_6_7_8_9_0_"
504                           "1_2_3_4_5_6_7_8_9_0_1_2_3_4_5_6_7_8_9_0_1_2_3_4_5_6_7_8_9_0_"
505                           "1_2_3_4_5_6_7_8_9_0_1_2_3_4_5_6_7_8_9_0_1_2_3_4_5_6_7_8_9_0_"
506                           "1_2_3_4_5_6_7_8_9_0_1_2_3_4_5_6_7_8_9_0_1_2_3_4_5_6_7_8_9_0_"
507                           "1_2_3_4_5_6_7_8_9_0_1_2_3_4_5_6_7_8_9_0_1_2_3_4_5_6_7_8_9_0_"
508                           "1_2_3_4_5_6_7_8_9_0_1_2_3_4_5_6_7_8_9_0_1_2_3_4_5_6_7_8_9_0_"
509                           "1_2_3_4_5_6_7_8_9_0_1_2_3_4_5_6_7_8_9_0_1_2_3_4_5_6_7_8_9_0_";
510        std::ios_base::iostate err = ios.goodbit;
511        input_iterator<const char*> iter =
512            f.get(input_iterator<const char*>(str),
513                  input_iterator<const char*>(str+sizeof(str)),
514                  ios, err, v);
515        assert(iter.base() == str+sizeof(str)-1);
516        assert(err == ios.failbit);
517        assert(v == std::numeric_limits<long>::max());
518    }
519}
520