get_float.pass.cpp revision b64f8b07c104c6cc986570ac8ee0ed16a9f23976 
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, float& v) const;
16
17#include <locale>
18#include <ios>
19#include <cassert>
20#include <streambuf>
21#include <cmath>
22#include "iterators.h"
23
24typedef std::num_get<char, input_iterator<const char*> > F;
25
26class my_facet
27    : public F
28{
29public:
30    explicit my_facet(std::size_t refs = 0)
31        : F(refs) {}
32};
33
34int main()
35{
36    const my_facet f(1);
37    std::ios ios(0);
38    float v = -1;
39    {
40        const char str[] = "123";
41        assert((ios.flags() & ios.basefield) == ios.dec);
42        assert(ios.getloc().name() == "C");
43        std::ios_base::iostate err = ios.goodbit;
44        input_iterator<const char*> iter =
45            f.get(input_iterator<const char*>(str),
46                  input_iterator<const char*>(str+sizeof(str)),
47                  ios, err, v);
48        assert(iter.base() == str+sizeof(str)-1);
49        assert(err == ios.goodbit);
50        assert(v == 123);
51    }
52    {
53        const char str[] = "-123";
54        std::ios_base::iostate err = ios.goodbit;
55        input_iterator<const char*> iter =
56            f.get(input_iterator<const char*>(str),
57                  input_iterator<const char*>(str+sizeof(str)),
58                  ios, err, v);
59        assert(iter.base() == str+sizeof(str)-1);
60        assert(err == ios.goodbit);
61        assert(v == -123);
62    }
63    {
64        const char str[] = "123.5";
65        std::ios_base::iostate err = ios.goodbit;
66        input_iterator<const char*> iter =
67            f.get(input_iterator<const char*>(str),
68                  input_iterator<const char*>(str+sizeof(str)),
69                  ios, err, v);
70        assert(iter.base() == str+sizeof(str)-1);
71        assert(err == ios.goodbit);
72        assert(v == 123.5);
73    }
74    {
75        const char str[] = "125e-1";
76        hex(ios);
77        std::ios_base::iostate err = ios.goodbit;
78        input_iterator<const char*> iter =
79            f.get(input_iterator<const char*>(str),
80                  input_iterator<const char*>(str+sizeof(str)),
81                  ios, err, v);
82        assert(iter.base() == str+sizeof(str)-1);
83        assert(err == ios.goodbit);
84        assert(v == 125e-1);
85    }
86    {
87        const char str[] = "0x125p-1";
88        hex(ios);
89        std::ios_base::iostate err = ios.goodbit;
90        input_iterator<const char*> iter =
91            f.get(input_iterator<const char*>(str),
92                  input_iterator<const char*>(str+sizeof(str)),
93                  ios, err, v);
94        assert(iter.base() == str+sizeof(str)-1);
95        assert(err == ios.goodbit);
96        assert(v == 0x125p-1);
97    }
98    {
99        const char str[] = "inf";
100        hex(ios);
101        std::ios_base::iostate err = ios.goodbit;
102        input_iterator<const char*> iter =
103            f.get(input_iterator<const char*>(str),
104                  input_iterator<const char*>(str+sizeof(str)),
105                  ios, err, v);
106        assert(iter.base() == str+sizeof(str)-1);
107        assert(err == ios.goodbit);
108        assert(v == INFINITY);
109    }
110    {
111        const char str[] = "INF";
112        hex(ios);
113        std::ios_base::iostate err = ios.goodbit;
114        input_iterator<const char*> iter =
115            f.get(input_iterator<const char*>(str),
116                  input_iterator<const char*>(str+sizeof(str)),
117                  ios, err, v);
118        assert(iter.base() == str+sizeof(str)-1);
119        assert(err == ios.goodbit);
120        assert(v == INFINITY);
121    }
122    {
123        const char str[] = "-inf";
124        hex(ios);
125        std::ios_base::iostate err = ios.goodbit;
126        input_iterator<const char*> iter =
127            f.get(input_iterator<const char*>(str),
128                  input_iterator<const char*>(str+sizeof(str)),
129                  ios, err, v);
130        assert(iter.base() == str+sizeof(str)-1);
131        assert(err == ios.goodbit);
132        assert(v == -INFINITY);
133    }
134    {
135        const char str[] = "-INF";
136        hex(ios);
137        std::ios_base::iostate err = ios.goodbit;
138        input_iterator<const char*> iter =
139            f.get(input_iterator<const char*>(str),
140                  input_iterator<const char*>(str+sizeof(str)),
141                  ios, err, v);
142        assert(iter.base() == str+sizeof(str)-1);
143        assert(err == ios.goodbit);
144        assert(v == -INFINITY);
145    }
146    {
147        const char str[] = "nan";
148        hex(ios);
149        std::ios_base::iostate err = ios.goodbit;
150        input_iterator<const char*> iter =
151            f.get(input_iterator<const char*>(str),
152                  input_iterator<const char*>(str+sizeof(str)),
153                  ios, err, v);
154        assert(iter.base() == str+sizeof(str)-1);
155        assert(err == ios.goodbit);
156        assert(std::isnan(v));
157    }
158    {
159        const char str[] = "NAN";
160        hex(ios);
161        std::ios_base::iostate err = ios.goodbit;
162        input_iterator<const char*> iter =
163            f.get(input_iterator<const char*>(str),
164                  input_iterator<const char*>(str+sizeof(str)),
165                  ios, err, v);
166        assert(iter.base() == str+sizeof(str)-1);
167        assert(err == ios.goodbit);
168        assert(std::isnan(v));
169    }
170}
171