get_bool.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, bool& 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 p1
34    : public std::numpunct<char>
35{
36public:
37    p1() : std::numpunct<char>() {}
38
39protected:
40    virtual string_type do_truename() const {return "a";}
41    virtual string_type do_falsename() const {return "abb";}
42};
43
44class p2
45    : public std::numpunct<char>
46{
47public:
48    p2() : std::numpunct<char>() {}
49
50protected:
51    virtual string_type do_truename() const {return "a";}
52    virtual string_type do_falsename() const {return "ab";}
53};
54
55int main()
56{
57    const my_facet f(1);
58    std::ios ios(0);
59    {
60        const char str[] = "1";
61        std::ios_base::iostate err = ios.goodbit;
62        bool b;
63        input_iterator<const char*> iter =
64            f.get(input_iterator<const char*>(str),
65                  input_iterator<const char*>(str+sizeof(str)),
66                  ios, err, b);
67        assert(iter.base() == str+sizeof(str)-1);
68        assert(err == ios.goodbit);
69        assert(b == true);
70    }
71    {
72        const char str[] = "0";
73        std::ios_base::iostate err = ios.goodbit;
74        bool b;
75        input_iterator<const char*> iter =
76            f.get(input_iterator<const char*>(str),
77                  input_iterator<const char*>(str+sizeof(str)),
78                  ios, err, b);
79        assert(iter.base() == str+sizeof(str)-1);
80        assert(err == ios.goodbit);
81        assert(b == false);
82    }
83    {
84        const char str[] = "12";
85        std::ios_base::iostate err = ios.goodbit;
86        bool b;
87        input_iterator<const char*> iter =
88            f.get(input_iterator<const char*>(str),
89                  input_iterator<const char*>(str+sizeof(str)),
90                  ios, err, b);
91        assert(iter.base() == str+sizeof(str)-1);
92        assert(err == ios.failbit);
93        assert(b == true);
94    }
95    {
96        const char str[] = "*12";
97        std::ios_base::iostate err = ios.goodbit;
98        bool b;
99        input_iterator<const char*> iter =
100            f.get(input_iterator<const char*>(str),
101                  input_iterator<const char*>(str+sizeof(str)),
102                  ios, err, b);
103        assert(iter.base() == str+0);
104        assert(err == ios.failbit);
105        assert(b == false);
106    }
107    boolalpha(ios);
108    {
109        const char str[] = "1";
110        std::ios_base::iostate err = ios.goodbit;
111        bool b;
112        input_iterator<const char*> iter =
113            f.get(input_iterator<const char*>(str),
114                  input_iterator<const char*>(str+sizeof(str)),
115                  ios, err, b);
116        assert(iter.base() == str+0);
117        assert(err == ios.failbit);
118        assert(b == false);
119    }
120    {
121        const char str[] = "true";
122        std::ios_base::iostate err = ios.goodbit;
123        bool b;
124        input_iterator<const char*> iter =
125            f.get(input_iterator<const char*>(str),
126                  input_iterator<const char*>(str+sizeof(str)),
127                  ios, err, b);
128        assert(iter.base() == str+sizeof(str)-1);
129        assert(err == ios.goodbit);
130        assert(b == true);
131    }
132    {
133        const char str[] = "false";
134        std::ios_base::iostate err = ios.goodbit;
135        bool b;
136        input_iterator<const char*> iter =
137            f.get(input_iterator<const char*>(str),
138                  input_iterator<const char*>(str+sizeof(str)),
139                  ios, err, b);
140        assert(iter.base() == str+sizeof(str)-1);
141        assert(err == ios.goodbit);
142        assert(b == false);
143    }
144    ios.imbue(std::locale(ios.getloc(), new p1));
145    {
146        const char str[] = "a";
147        std::ios_base::iostate err = ios.goodbit;
148        bool b;
149        input_iterator<const char*> iter =
150            f.get(input_iterator<const char*>(str),
151                  input_iterator<const char*>(str+1),
152                  ios, err, b);
153        assert(iter.base() == str+1);
154        assert(err == ios.eofbit);
155        assert(b == true);
156    }
157    {
158        const char str[] = "abc";
159        std::ios_base::iostate err = ios.goodbit;
160        bool b;
161        input_iterator<const char*> iter =
162            f.get(input_iterator<const char*>(str),
163                  input_iterator<const char*>(str+3),
164                  ios, err, b);
165        assert(iter.base() == str+2);
166        assert(err == ios.failbit);
167        assert(b == false);
168    }
169    {
170        const char str[] = "acc";
171        std::ios_base::iostate err = ios.goodbit;
172        bool b;
173        input_iterator<const char*> iter =
174            f.get(input_iterator<const char*>(str),
175                  input_iterator<const char*>(str+3),
176                  ios, err, b);
177        assert(iter.base() == str+1);
178        assert(err == ios.goodbit);
179        assert(b == true);
180    }
181    ios.imbue(std::locale(ios.getloc(), new p2));
182    {
183        const char str[] = "a";
184        std::ios_base::iostate err = ios.goodbit;
185        bool b;
186        input_iterator<const char*> iter =
187            f.get(input_iterator<const char*>(str),
188                  input_iterator<const char*>(str+1),
189                  ios, err, b);
190        assert(iter.base() == str+1);
191        assert(err == ios.eofbit);
192        assert(b == true);
193    }
194    {
195        const char str[] = "ab";
196        std::ios_base::iostate err = ios.goodbit;
197        bool b;
198        input_iterator<const char*> iter =
199            f.get(input_iterator<const char*>(str),
200                  input_iterator<const char*>(str+2),
201                  ios, err, b);
202        assert(iter.base() == str+2);
203        assert(err == ios.eofbit);
204        assert(b == false);
205    }
206    {
207        const char str[] = "abc";
208        std::ios_base::iostate err = ios.goodbit;
209        bool b;
210        input_iterator<const char*> iter =
211            f.get(input_iterator<const char*>(str),
212                  input_iterator<const char*>(str+3),
213                  ios, err, b);
214        assert(iter.base() == str+2);
215        assert(err == ios.goodbit);
216        assert(b == false);
217    }
218    {
219        const char str[] = "ac";
220        std::ios_base::iostate err = ios.goodbit;
221        bool b;
222        input_iterator<const char*> iter =
223            f.get(input_iterator<const char*>(str),
224                  input_iterator<const char*>(str+2),
225                  ios, err, b);
226        assert(iter.base() == str+1);
227        assert(err == ios.goodbit);
228        assert(b == true);
229    }
230}
231