1 // file      : tests/cxx/parser/validation/built-in/int/driver.cxx
2 // copyright : Copyright (c) 2006-2017 Code Synthesis Tools CC
3 // license   : GNU GPL v2 + exceptions; see accompanying LICENSE file
4 
5 // Test the built-in integer & friends types validation.
6 //
7 #include <limits.h>
8 
9 #include <string>
10 #include <sstream>
11 #include <cassert>
12 
13 #include <xsd/cxx/parser/validating/exceptions.hxx>
14 #include <xsd/cxx/parser/validating/xml-schema-pimpl.hxx>
15 
16 using namespace std;
17 using namespace xsd::cxx::parser::validating;
18 
19 template <typename T>
20 bool
test_post_fail(T & p)21 test_post_fail (T& p)
22 {
23   try
24   {
25     p._post ();
26   }
27   catch (invalid_value<char> const&)
28   {
29     return true;
30   }
31 
32   return false;
33 }
34 
35 int
main()36 main ()
37 {
38   // Good.
39   //
40 
41   std::string min;
42   std::string max;
43   std::string umax;
44 
45   {
46     ostringstream ostr;
47     ostr << LLONG_MIN;
48     min = ostr.str ();
49   }
50 
51   {
52     ostringstream ostr;
53     ostr << LLONG_MAX;
54     max = ostr.str ();
55   }
56 
57   {
58     ostringstream ostr;
59     ostr << ULLONG_MAX;
60     umax = ostr.str ();
61   }
62 
63   // integer
64   //
65   {
66     integer_pimpl<char> p;
67     p.pre ();
68     p._pre ();
69     p._characters (min.c_str ());
70     p._post ();
71     assert (p.post_integer () == LLONG_MIN);
72   }
73 
74   {
75     integer_pimpl<char> p;
76     p.pre ();
77     p._pre ();
78     p._characters ("0");
79     p._post ();
80     assert (p.post_integer () == 0);
81   }
82 
83   {
84     integer_pimpl<char> p;
85     p.pre ();
86     p._pre ();
87     p._characters (max.c_str ());
88     p._post ();
89     assert (p.post_integer () == LLONG_MAX);
90   }
91 
92   // negative_integer
93   //
94   {
95     negative_integer_pimpl<char> p;
96     p.pre ();
97     p._pre ();
98     p._characters (min.c_str ());
99     p._post ();
100     assert (p.post_negative_integer () == LLONG_MIN);
101   }
102 
103   {
104     negative_integer_pimpl<char> p;
105     p.pre ();
106     p._pre ();
107     p._characters ("-1");
108     p._post ();
109     assert (p.post_negative_integer () == -1);
110   }
111 
112   // non_positive_integer
113   //
114   {
115     non_positive_integer_pimpl<char> p;
116     p.pre ();
117     p._pre ();
118     p._characters (min.c_str ());
119     p._post ();
120     assert (p.post_non_positive_integer () == LLONG_MIN);
121   }
122 
123   {
124     non_positive_integer_pimpl<char> p;
125     p.pre ();
126     p._pre ();
127     p._characters ("+0");
128     p._post ();
129     assert (p.post_non_positive_integer () == 0);
130   }
131 
132   // positive_integer
133   //
134   {
135     positive_integer_pimpl<char> p;
136     p.pre ();
137     p._pre ();
138     p._characters ("1");
139     p._post ();
140     assert (p.post_positive_integer () == 1);
141   }
142 
143   {
144     positive_integer_pimpl<char> p;
145     p.pre ();
146     p._pre ();
147     p._characters (umax.c_str ());
148     p._post ();
149     assert (p.post_positive_integer () == ULLONG_MAX);
150   }
151 
152   // non_negative_integer
153   //
154   /*
155   {
156     non_negative_integer_pimpl<char> p;
157     p.pre ();
158     p._pre ();
159     p._characters ("-0");
160     p._post ();
161     assert (p.post_non_negative_integer () == 0);
162   }
163   */
164 
165   {
166     non_negative_integer_pimpl<char> p;
167     p.pre ();
168     p._pre ();
169     p._characters ("0");
170     p._post ();
171     assert (p.post_non_negative_integer () == 0);
172   }
173 
174   {
175     non_negative_integer_pimpl<char> p;
176     p.pre ();
177     p._pre ();
178     p._characters (umax.c_str ());
179     p._post ();
180     assert (p.post_non_negative_integer () == ULLONG_MAX);
181   }
182 
183 
184   // Bad
185   //
186 
187   std::string past_min (min);
188   std::string past_max (max);
189   std::string past_umax (umax);
190 
191   assert (*past_min.rbegin () != '9');
192   assert (*past_max.rbegin () != '9');
193   assert (*past_umax.rbegin () != '9');
194 
195   (*past_min.rbegin ())++;
196   (*past_max.rbegin ())++;
197   (*past_umax.rbegin ())++;
198 
199   // integer
200   //
201   {
202     integer_pimpl<char> p;
203     p.pre ();
204     p._pre ();
205     p._characters (past_min.c_str ());
206     assert (test_post_fail (p));
207   }
208 
209   {
210     integer_pimpl<char> p;
211     p.pre ();
212     p._pre ();
213     p._characters (past_max.c_str ());
214     assert (test_post_fail (p));
215   }
216 
217   // negative_integer
218   //
219   {
220     negative_integer_pimpl<char> p;
221     p.pre ();
222     p._pre ();
223     p._characters (past_min.c_str ());
224     assert (test_post_fail (p));
225   }
226 
227   {
228     negative_integer_pimpl<char> p;
229     p.pre ();
230     p._pre ();
231     p._characters ("-0");
232     assert (test_post_fail (p));
233   }
234 
235   {
236     negative_integer_pimpl<char> p;
237     p.pre ();
238     p._pre ();
239     p._characters ("1");
240     assert (test_post_fail (p));
241   }
242 
243   // non_positive_integer
244   //
245   {
246     non_positive_integer_pimpl<char> p;
247     p.pre ();
248     p._pre ();
249     p._characters (past_min.c_str ());
250     assert (test_post_fail (p));
251   }
252 
253   {
254     non_positive_integer_pimpl<char> p;
255     p.pre ();
256     p._pre ();
257     p._characters ("1");
258     assert (test_post_fail (p));
259   }
260 
261   // positive_integer
262   //
263   {
264     positive_integer_pimpl<char> p;
265     p.pre ();
266     p._pre ();
267     p._characters ("-1");
268     assert (test_post_fail (p));
269   }
270 
271   {
272     positive_integer_pimpl<char> p;
273     p.pre ();
274     p._pre ();
275     p._characters ("+0");
276     assert (test_post_fail (p));
277   }
278 
279   {
280     positive_integer_pimpl<char> p;
281     p.pre ();
282     p._pre ();
283     p._characters (past_umax.c_str ());
284     assert (test_post_fail (p));
285   }
286 
287   // non_negative_integer
288   //
289   {
290     non_negative_integer_pimpl<char> p;
291     p.pre ();
292     p._pre ();
293     p._characters ("-1");
294     assert (test_post_fail (p));
295   }
296 
297   {
298     non_negative_integer_pimpl<char> p;
299     p.pre ();
300     p._pre ();
301     p._characters (past_umax.c_str ());
302     assert (test_post_fail (p));
303   }
304 }
305