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// PR11871
11// XFAIL: with_system_cxx_lib=macosx10.7
12
13// <locale>
14
15// class num_get<charT, InputIterator>
16
17// iter_type get(iter_type in, iter_type end, ios_base&,
18//               ios_base::iostate& err, long double& v) const;
19
20#include <locale>
21#include <ios>
22#include <cassert>
23#include <streambuf>
24#include <cmath>
25#include "test_iterators.h"
26#include "hexfloat.h"
27
28#include "float_comparison.h"
29
30typedef std::num_get<char, input_iterator<const char*> > F;
31
32class my_facet
33    : public F
34{
35public:
36    explicit my_facet(std::size_t refs = 0)
37        : F(refs) {}
38};
39
40
41int main()
42{
43    const my_facet f(1);
44    std::ios ios(0);
45    long double v = -1;
46    {
47        const char str[] = "123";
48        assert((ios.flags() & ios.basefield) == ios.dec);
49        assert(ios.getloc().name() == "C");
50        std::ios_base::iostate err = ios.goodbit;
51        input_iterator<const char*> iter =
52            f.get(input_iterator<const char*>(str),
53                  input_iterator<const char*>(str+sizeof(str)),
54                  ios, err, v);
55        assert(iter.base() == str+sizeof(str)-1);
56        assert(err == ios.goodbit);
57        assert(v == 123);
58    }
59    {
60        const char str[] = "-123";
61        std::ios_base::iostate err = ios.goodbit;
62        input_iterator<const char*> iter =
63            f.get(input_iterator<const char*>(str),
64                  input_iterator<const char*>(str+sizeof(str)),
65                  ios, err, v);
66        assert(iter.base() == str+sizeof(str)-1);
67        assert(err == ios.goodbit);
68        assert(v == -123);
69    }
70    {
71        const char str[] = "123.5";
72        std::ios_base::iostate err = ios.goodbit;
73        input_iterator<const char*> iter =
74            f.get(input_iterator<const char*>(str),
75                  input_iterator<const char*>(str+sizeof(str)),
76                  ios, err, v);
77        assert(iter.base() == str+sizeof(str)-1);
78        assert(err == ios.goodbit);
79        assert(v == 123.5);
80    }
81    {
82        const char str[] = "125e-1";
83        hex(ios);
84        std::ios_base::iostate err = ios.goodbit;
85        input_iterator<const char*> iter =
86            f.get(input_iterator<const char*>(str),
87                  input_iterator<const char*>(str+sizeof(str)),
88                  ios, err, v);
89        assert(iter.base() == str+sizeof(str)-1);
90        assert(err == ios.goodbit);
91        assert(v == 125e-1);
92    }
93    {
94        const char str[] = "0x125p-1";
95        hex(ios);
96        std::ios_base::iostate err = ios.goodbit;
97        input_iterator<const char*> iter =
98            f.get(input_iterator<const char*>(str),
99                  input_iterator<const char*>(str+sizeof(str)),
100                  ios, err, v);
101        assert(iter.base() == str+sizeof(str)-1);
102        assert(err == ios.goodbit);
103        assert(v == hexfloat<long double>(0x125, 0, -1));
104    }
105    {
106        const char str[] = "inf";
107        hex(ios);
108        std::ios_base::iostate err = ios.goodbit;
109        input_iterator<const char*> iter =
110            f.get(input_iterator<const char*>(str),
111                  input_iterator<const char*>(str+sizeof(str)),
112                  ios, err, v);
113        assert(iter.base() == str+sizeof(str)-1);
114        assert(err == ios.goodbit);
115        assert(v == INFINITY);
116    }
117    {
118        const char str[] = "INF";
119        hex(ios);
120        std::ios_base::iostate err = ios.goodbit;
121        input_iterator<const char*> iter =
122            f.get(input_iterator<const char*>(str),
123                  input_iterator<const char*>(str+sizeof(str)),
124                  ios, err, v);
125        assert(iter.base() == str+sizeof(str)-1);
126        assert(err == ios.goodbit);
127        assert(v == INFINITY);
128    }
129    {
130        const char str[] = "-inf";
131        hex(ios);
132        std::ios_base::iostate err = ios.goodbit;
133        input_iterator<const char*> iter =
134            f.get(input_iterator<const char*>(str),
135                  input_iterator<const char*>(str+sizeof(str)),
136                  ios, err, v);
137        assert(iter.base() == str+sizeof(str)-1);
138        assert(err == ios.goodbit);
139        assert(v == -INFINITY);
140    }
141    {
142        const char str[] = "-INF";
143        hex(ios);
144        std::ios_base::iostate err = ios.goodbit;
145        input_iterator<const char*> iter =
146            f.get(input_iterator<const char*>(str),
147                  input_iterator<const char*>(str+sizeof(str)),
148                  ios, err, v);
149        assert(iter.base() == str+sizeof(str)-1);
150        assert(err == ios.goodbit);
151        assert(v == -INFINITY);
152    }
153    {
154        const char str[] = "nan";
155        hex(ios);
156        std::ios_base::iostate err = ios.goodbit;
157        input_iterator<const char*> iter =
158            f.get(input_iterator<const char*>(str),
159                  input_iterator<const char*>(str+sizeof(str)),
160                  ios, err, v);
161        assert(iter.base() == str+sizeof(str)-1);
162        assert(err == ios.goodbit);
163        assert(std::isnan(v));
164    }
165    {
166        const char str[] = "NAN";
167        hex(ios);
168        std::ios_base::iostate err = ios.goodbit;
169        input_iterator<const char*> iter =
170            f.get(input_iterator<const char*>(str),
171                  input_iterator<const char*>(str+sizeof(str)),
172                  ios, err, v);
173        assert(iter.base() == str+sizeof(str)-1);
174        assert(err == ios.goodbit);
175        assert(std::isnan(v));
176    }
177    {
178        const char str[] = "1.189731495357231765021264e+49321";
179        std::ios_base::iostate err = ios.goodbit;
180        v = 0;
181        input_iterator<const char*> iter =
182            f.get(input_iterator<const char*>(str),
183                  input_iterator<const char*>(str+sizeof(str)),
184                  ios, err, v);
185        assert(iter.base() == str+sizeof(str)-1);
186        assert(err == ios.failbit);
187        assert(v == INFINITY);
188    }
189    {
190        const char str[] = "1.189731495357231765021264e+49329";
191        std::ios_base::iostate err = ios.goodbit;
192        v = 0;
193        input_iterator<const char*> iter =
194            f.get(input_iterator<const char*>(str),
195                  input_iterator<const char*>(str+sizeof(str)),
196                  ios, err, v);
197        assert(iter.base() == str+sizeof(str)-1);
198        assert(err == ios.failbit);
199        assert(v == INFINITY);
200    }
201    {
202        const char str[] = "11.189731495357231765021264e+4932";
203        std::ios_base::iostate err = ios.goodbit;
204        v = 0;
205        input_iterator<const char*> iter =
206            f.get(input_iterator<const char*>(str),
207                  input_iterator<const char*>(str+sizeof(str)),
208                  ios, err, v);
209        assert(iter.base() == str+sizeof(str)-1);
210        assert(err == ios.failbit);
211        assert(v == INFINITY);
212    }
213    {
214        const char str[] = "91.189731495357231765021264e+4932";
215        std::ios_base::iostate err = ios.goodbit;
216        v = 0;
217        input_iterator<const char*> iter =
218            f.get(input_iterator<const char*>(str),
219                  input_iterator<const char*>(str+sizeof(str)),
220                  ios, err, v);
221        assert(iter.base() == str+sizeof(str)-1);
222        assert(err == ios.failbit);
223        assert(v == INFINITY);
224    }
225    {
226        const char str[] = "304888344611713860501504000000";
227        std::ios_base::iostate err = ios.goodbit;
228        v = 0;
229        input_iterator<const char*> iter =
230            f.get(input_iterator<const char*>(str),
231                  input_iterator<const char*>(str+sizeof(str)),
232                  ios, err, v);
233
234        FloatingPoint<long double> actual(v);
235        FloatingPoint<long double> expected(304888344611713860501504000000.0L);
236        assert(actual.AlmostEquals(expected));
237    }
238    {
239        v = -1;
240        const char str[] = "1.19973e+4933"; // unrepresentable
241        std::ios_base::iostate err = ios.goodbit;
242        input_iterator<const char*> iter =
243            f.get(input_iterator<const char*>(str),
244                  input_iterator<const char*>(str+sizeof(str)),
245                  ios, err, v);
246        assert(iter.base() == str+sizeof(str)-1);
247        assert(err == ios.failbit);
248        assert(v == HUGE_VALL);
249    }
250    {
251        v = -1;
252        const char str[] = "-1.18974e+4932"; // unrepresentable
253        std::ios_base::iostate err = ios.goodbit;
254        input_iterator<const char*> iter =
255            f.get(input_iterator<const char*>(str),
256                  input_iterator<const char*>(str+sizeof(str)),
257                  ios, err, v);
258        assert(iter.base() == str+sizeof(str)-1);
259        assert(err == ios.failbit);
260        assert(v == -HUGE_VALL);
261    }
262    {
263        v = -1;
264        const char str[] = "2-";
265        std::ios_base::iostate err = ios.goodbit;
266        input_iterator<const char*> iter =
267            f.get(input_iterator<const char*>(str),
268                  input_iterator<const char*>(str+sizeof(str)),
269                  ios, err, v);
270        assert(iter.base() == str+1);
271        assert(err == ios.goodbit);
272        assert(v == 2);
273    }
274}
275