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)21test_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()36main () 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