Branch data Line data Source code
1 : : /*
2 : : SSSD
3 : :
4 : : InfoPipe
5 : :
6 : : Copyright (C) Stephen Gallagher <sgallagh@redhat.com> 2009
7 : :
8 : : This program is free software; you can redistribute it and/or modify
9 : : it under the terms of the GNU General Public License as published by
10 : : the Free Software Foundation; either version 3 of the License, or
11 : : (at your option) any later version.
12 : :
13 : : This program is distributed in the hope that it will be useful,
14 : : but WITHOUT ANY WARRANTY; without even the implied warranty of
15 : : MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 : : GNU General Public License for more details.
17 : :
18 : : You should have received a copy of the GNU General Public License
19 : : along with this program. If not, see <http://www.gnu.org/licenses/>.
20 : : */
21 : :
22 : : #include <stdlib.h>
23 : : #include <check.h>
24 : : #include <errno.h>
25 : : #include <popt.h>
26 : : #include "util/util.h"
27 : : #include "util/strtonum.h"
28 : : #include "tests/common.h"
29 : :
30 : : /********************
31 : : * Utility routines *
32 : : ********************/
33 : : #define EXPECT_UNSET_ERRNO(error) \
34 : : do { \
35 : : fail_unless(error == 0, "errno unexpectedly set to %d[%s]", \
36 : : error, strerror(error)); \
37 : : } while(0)
38 : :
39 : : #define CHECK_RESULT(expected, actual) \
40 : : do { \
41 : : fail_unless(actual == expected, "Expected %ld, got %ld", \
42 : : expected, actual); \
43 : : } while(0)
44 : :
45 : : #define CHECK_ERRNO(expected, actual) \
46 : : do { \
47 : : fail_unless(actual == expected, "Expected errno %d[%s], got %d[%s]", \
48 : : expected, strerror(expected), \
49 : : actual, strerror(actual)); \
50 : : } while(0)
51 : :
52 : : #define CHECK_ENDPTR(expected, actual) \
53 : : do { \
54 : : fail_unless(actual == expected, "Expected endptr %p, got %p", \
55 : : expected, actual); \
56 : : } while(0)
57 : :
58 : : #define CHECK_ZERO_ENDPTR(endptr) \
59 : : do { \
60 : : fail_unless(endptr && *endptr == '\0', "Invalid endptr"); \
61 : : } while(0)
62 : :
63 : : /******************
64 : : * strtoint tests *
65 : : ******************/
66 : :
67 : : /* Base-10 */
68 : 1 : START_TEST (test_strtoint32_pos_integer_base_10)
69 : : {
70 : : int32_t result;
71 : 1 : const char *input = "123";
72 : 1 : int32_t expected = 123;
73 : : char *endptr;
74 : : errno_t error;
75 : :
76 : 1 : result = strtoint32(input, &endptr, 10);
77 : 1 : error = errno;
78 : :
79 : 1 : EXPECT_UNSET_ERRNO(error);
80 [ + - ][ - + ]: 1 : CHECK_ZERO_ENDPTR(endptr);
81 : 1 : CHECK_RESULT(expected, result);
82 : : }
83 : 1 : END_TEST
84 : :
85 : 1 : START_TEST (test_strtoint32_neg_integer_base_10)
86 : : {
87 : : int32_t result;
88 : 1 : const char *input = "-123";
89 : 1 : int32_t expected = -123;
90 : : char *endptr;
91 : : errno_t error;
92 : :
93 : 1 : result = strtoint32(input, &endptr, 10);
94 : 1 : error = errno;
95 : :
96 : 1 : EXPECT_UNSET_ERRNO(error);
97 [ + - ][ - + ]: 1 : CHECK_ZERO_ENDPTR(endptr);
98 : 1 : CHECK_RESULT(expected, result);
99 : : }
100 : 1 : END_TEST
101 : :
102 : 1 : START_TEST (test_strtoint32_pos_integer_intmax_base_10)
103 : : {
104 : : int32_t result;
105 : 1 : const char *input = "2147483647";
106 : 1 : int32_t expected = INT32_MAX;
107 : : char *endptr;
108 : : errno_t error;
109 : :
110 : 1 : result = strtoint32(input, &endptr, 10);
111 : 1 : error = errno;
112 : :
113 : 1 : EXPECT_UNSET_ERRNO(error);
114 [ + - ][ - + ]: 1 : CHECK_ZERO_ENDPTR(endptr);
115 : 1 : CHECK_RESULT(expected, result);
116 : : }
117 : 1 : END_TEST
118 : :
119 : 1 : START_TEST (test_strtoint32_neg_integer_intmin_base_10)
120 : : {
121 : : int32_t result;
122 : 1 : const char *input = "-2147483648";
123 : 1 : int32_t expected = INT32_MIN;
124 : : char *endptr;
125 : : errno_t error;
126 : :
127 : 1 : result = strtoint32(input, &endptr, 10);
128 : 1 : error = errno;
129 : :
130 : 1 : EXPECT_UNSET_ERRNO(error);
131 [ + - ][ - + ]: 1 : CHECK_ZERO_ENDPTR(endptr);
132 : 1 : CHECK_RESULT(expected, result);
133 : : }
134 : 1 : END_TEST
135 : :
136 : 1 : START_TEST (test_strtoint32_pos_integer_overflow_base_10)
137 : : {
138 : : int32_t result;
139 : 1 : const char *input = "8589934592";
140 : 1 : int32_t expected = INT32_MAX;
141 : : char *endptr;
142 : : errno_t error;
143 : :
144 : 1 : result = strtoint32(input, &endptr, 10);
145 : 1 : error = errno;
146 : :
147 : 1 : CHECK_ERRNO(ERANGE, error);
148 [ + - ][ - + ]: 1 : CHECK_ZERO_ENDPTR(endptr);
149 : 1 : CHECK_RESULT(expected, result);
150 : : }
151 : 1 : END_TEST
152 : :
153 : 1 : START_TEST (test_strtoint32_pos_integer_underflow_base_10)
154 : : {
155 : : int32_t result;
156 : 1 : const char *input = "-8589934592";
157 : 1 : int32_t expected = INT32_MIN;
158 : : char *endptr;
159 : : errno_t error;
160 : :
161 : 1 : result = strtoint32(input, &endptr, 10);
162 : 1 : error = errno;
163 : :
164 : 1 : CHECK_ERRNO(ERANGE, error);
165 [ + - ][ - + ]: 1 : CHECK_ZERO_ENDPTR(endptr);
166 : 1 : CHECK_RESULT(expected, result);
167 : : }
168 : 1 : END_TEST
169 : :
170 : 1 : START_TEST (test_strtoint32_mixed_alphanumeric_base_10)
171 : : {
172 : : int32_t result;
173 : 1 : const char *input = "12b13";
174 : 1 : int32_t expected = 12;
175 : : char *endptr;
176 : 1 : const char *expected_endptr = input+2;
177 : : errno_t error;
178 : :
179 : 1 : result = strtoint32(input, &endptr, 10);
180 : 1 : error = errno;
181 : :
182 : 1 : EXPECT_UNSET_ERRNO(error);
183 : 1 : CHECK_ENDPTR(expected_endptr, endptr);
184 : 1 : CHECK_RESULT(expected, result);
185 : : }
186 : 1 : END_TEST
187 : :
188 : 1 : START_TEST (test_strtoint32_alphaonly_base_10)
189 : : {
190 : : int32_t result;
191 : 1 : const char *input = "alpha";
192 : 1 : int32_t expected = 0;
193 : : char *endptr;
194 : 1 : const char *expected_endptr = input;
195 : : errno_t error;
196 : :
197 : 1 : result = strtoint32(input, &endptr, 10);
198 : 1 : error = errno;
199 : :
200 : 1 : EXPECT_UNSET_ERRNO(error);
201 : 1 : CHECK_ENDPTR(expected_endptr, endptr);
202 : 1 : CHECK_RESULT(expected, result);
203 : : }
204 : 1 : END_TEST
205 : :
206 : 1 : START_TEST (test_strtoint32_alphastart_base_10)
207 : : {
208 : : int32_t result;
209 : 1 : const char *input = "alpha12345";
210 : 1 : int32_t expected = 0;
211 : : char *endptr;
212 : 1 : const char *expected_endptr = input;
213 : : errno_t error;
214 : :
215 : 1 : result = strtoint32(input, &endptr, 10);
216 : 1 : error = errno;
217 : :
218 : 1 : EXPECT_UNSET_ERRNO(error);
219 : 1 : CHECK_ENDPTR(expected_endptr, endptr);
220 : 1 : CHECK_RESULT(expected, result);
221 : : }
222 : 1 : END_TEST
223 : :
224 : 1 : START_TEST (test_strtoint32_emptystring_base_10)
225 : : {
226 : : int32_t result;
227 : 1 : const char *input = "";
228 : 1 : int32_t expected = 0;
229 : : char *endptr;
230 : 1 : const char *expected_endptr = input;
231 : : errno_t error;
232 : :
233 : 1 : result = strtoint32(input, &endptr, 10);
234 : 1 : error = errno;
235 : :
236 : 1 : EXPECT_UNSET_ERRNO(error);
237 : 1 : CHECK_ENDPTR(expected_endptr, endptr);
238 : 1 : CHECK_RESULT(expected, result);
239 : : }
240 : 1 : END_TEST
241 : :
242 : : /*******************
243 : : * strtouint tests *
244 : : *******************/
245 : :
246 : : /* Base-10 */
247 : 1 : START_TEST (test_strtouint32_pos_integer_base_10)
248 : : {
249 : : uint32_t result;
250 : 1 : const char *input = "123";
251 : 1 : uint32_t expected = 123;
252 : : char *endptr;
253 : : errno_t error;
254 : :
255 : 1 : result = strtouint32(input, &endptr, 10);
256 : 1 : error = errno;
257 : :
258 : 1 : EXPECT_UNSET_ERRNO(error);
259 [ + - ][ - + ]: 1 : CHECK_ZERO_ENDPTR(endptr);
260 : 1 : CHECK_RESULT(expected, result);
261 : : }
262 : 1 : END_TEST
263 : :
264 : 1 : START_TEST (test_strtouint32_neg_integer_base_10)
265 : : {
266 : : uint32_t result;
267 : 1 : const char *input = "-123";
268 : 1 : uint32_t expected = UINT32_MAX;
269 : : char *endptr;
270 : : errno_t error;
271 : :
272 : 1 : result = strtouint32(input, &endptr, 10);
273 : 1 : error = errno;
274 : :
275 : 1 : CHECK_ERRNO(ERANGE, error);
276 [ + - ][ - + ]: 1 : CHECK_ZERO_ENDPTR(endptr);
277 : 1 : CHECK_RESULT(expected, result);
278 : : }
279 : 1 : END_TEST
280 : :
281 : 1 : START_TEST (test_strtouint32_pos_integer_uintmax_base_10)
282 : : {
283 : : uint32_t result;
284 : 1 : const char *input = "4294967295";
285 : 1 : uint32_t expected = UINT32_MAX;
286 : : char *endptr;
287 : : errno_t error;
288 : :
289 : 1 : result = strtouint32(input, &endptr, 10);
290 : 1 : error = errno;
291 : :
292 : 1 : EXPECT_UNSET_ERRNO(error);
293 [ + - ][ - + ]: 1 : CHECK_ZERO_ENDPTR(endptr);
294 : 1 : CHECK_RESULT(expected, result);
295 : : }
296 : 1 : END_TEST
297 : :
298 : :
299 : 1 : START_TEST (test_strtouint32_pos_integer_overflow_base_10)
300 : : {
301 : : uint32_t result;
302 : 1 : const char *input = "8589934592";
303 : 1 : uint32_t expected = UINT32_MAX;
304 : : char *endptr;
305 : : errno_t error;
306 : :
307 : 1 : result = strtouint32(input, &endptr, 10);
308 : 1 : error = errno;
309 : :
310 : 1 : CHECK_ERRNO(ERANGE, error);
311 [ + - ][ - + ]: 1 : CHECK_ZERO_ENDPTR(endptr);
312 : 1 : CHECK_RESULT(expected, result);
313 : : }
314 : 1 : END_TEST
315 : :
316 : 1 : START_TEST (test_strtouint32_mixed_alphanumeric_base_10)
317 : : {
318 : : uint32_t result;
319 : 1 : const char *input = "12b13";
320 : 1 : uint32_t expected = 12;
321 : : char *endptr;
322 : 1 : const char *expected_endptr = input+2;
323 : : errno_t error;
324 : :
325 : 1 : result = strtouint32(input, &endptr, 10);
326 : 1 : error = errno;
327 : :
328 : 1 : EXPECT_UNSET_ERRNO(error);
329 : 1 : CHECK_ENDPTR(expected_endptr, endptr);
330 : 1 : CHECK_RESULT(expected, result);
331 : : }
332 : 1 : END_TEST
333 : :
334 : 1 : START_TEST (test_strtouint32_alphaonly_base_10)
335 : : {
336 : : uint32_t result;
337 : 1 : const char *input = "alpha";
338 : 1 : uint32_t expected = 0;
339 : : char *endptr;
340 : 1 : const char *expected_endptr = input;
341 : : errno_t error;
342 : :
343 : 1 : result = strtouint32(input, &endptr, 10);
344 : 1 : error = errno;
345 : :
346 : 1 : EXPECT_UNSET_ERRNO(error);
347 : 1 : CHECK_ENDPTR(expected_endptr, endptr);
348 : 1 : CHECK_RESULT(expected, result);
349 : : }
350 : 1 : END_TEST
351 : :
352 : 1 : START_TEST (test_strtouint32_alphastart_base_10)
353 : : {
354 : : uint32_t result;
355 : 1 : const char *input = "alpha12345";
356 : 1 : uint32_t expected = 0;
357 : : char *endptr;
358 : 1 : const char *expected_endptr = input;
359 : : errno_t error;
360 : :
361 : 1 : result = strtouint32(input, &endptr, 10);
362 : 1 : error = errno;
363 : :
364 : 1 : EXPECT_UNSET_ERRNO(error);
365 : 1 : CHECK_ENDPTR(expected_endptr, endptr);
366 : 1 : CHECK_RESULT(expected, result);
367 : : }
368 : 1 : END_TEST
369 : :
370 : 1 : START_TEST (test_strtouint32_emptystring_base_10)
371 : : {
372 : : uint32_t result;
373 : 1 : const char *input = "";
374 : 1 : uint32_t expected = 0;
375 : : char *endptr;
376 : 1 : const char *expected_endptr = input;
377 : : errno_t error;
378 : :
379 : 1 : result = strtouint32(input, &endptr, 10);
380 : 1 : error = errno;
381 : :
382 : 1 : EXPECT_UNSET_ERRNO(error);
383 : 1 : CHECK_ENDPTR(expected_endptr, endptr);
384 : 1 : CHECK_RESULT(expected, result);
385 : : }
386 : 1 : END_TEST
387 : :
388 : :
389 : :
390 : 19 : Suite *create_strtonum_suite(void)
391 : : {
392 : 19 : Suite *s = suite_create("strtonum");
393 : :
394 : 19 : TCase *tc_strtoint32 = tcase_create("strtoint32 Tests");
395 : 19 : tcase_add_test(tc_strtoint32, test_strtoint32_pos_integer_base_10);
396 : 19 : tcase_add_test(tc_strtoint32, test_strtoint32_neg_integer_base_10);
397 : 19 : tcase_add_test(tc_strtoint32, test_strtoint32_pos_integer_intmax_base_10);
398 : 19 : tcase_add_test(tc_strtoint32, test_strtoint32_neg_integer_intmin_base_10);
399 : 19 : tcase_add_test(tc_strtoint32, test_strtoint32_pos_integer_overflow_base_10);
400 : 19 : tcase_add_test(tc_strtoint32, test_strtoint32_pos_integer_underflow_base_10);
401 : 19 : tcase_add_test(tc_strtoint32, test_strtoint32_mixed_alphanumeric_base_10);
402 : 19 : tcase_add_test(tc_strtoint32, test_strtoint32_alphaonly_base_10);
403 : 19 : tcase_add_test(tc_strtoint32, test_strtoint32_alphastart_base_10);
404 : 19 : tcase_add_test(tc_strtoint32, test_strtoint32_emptystring_base_10);
405 : :
406 : 19 : TCase *tc_strtouint32 = tcase_create("strtouint32 Tests");
407 : 19 : tcase_add_test(tc_strtouint32, test_strtouint32_pos_integer_base_10);
408 : 19 : tcase_add_test(tc_strtouint32, test_strtouint32_neg_integer_base_10);
409 : 19 : tcase_add_test(tc_strtouint32, test_strtouint32_pos_integer_uintmax_base_10);
410 : 19 : tcase_add_test(tc_strtouint32, test_strtouint32_pos_integer_overflow_base_10);
411 : 19 : tcase_add_test(tc_strtouint32, test_strtouint32_mixed_alphanumeric_base_10);
412 : 19 : tcase_add_test(tc_strtouint32, test_strtouint32_alphaonly_base_10);
413 : 19 : tcase_add_test(tc_strtouint32, test_strtouint32_alphastart_base_10);
414 : 19 : tcase_add_test(tc_strtouint32, test_strtouint32_emptystring_base_10);
415 : :
416 : : /* Add all test cases to the suite */
417 : 19 : suite_add_tcase(s, tc_strtoint32);
418 : 19 : suite_add_tcase(s, tc_strtouint32);
419 : :
420 : 19 : return s;
421 : : }
422 : :
423 : :
424 : 19 : int main(int argc, const char *argv[]) {
425 : : int opt;
426 : : poptContext pc;
427 : : int failure_count;
428 : : Suite *strtonum_suite;
429 : : SRunner *sr;
430 : :
431 : 95 : struct poptOption long_options[] = {
432 : : POPT_AUTOHELP
433 : 76 : SSSD_MAIN_OPTS
434 : : POPT_TABLEEND
435 : : };
436 : :
437 : : /* Set debug level to invalid value so we can deside if -d 0 was used. */
438 : 19 : debug_level = SSSDBG_INVALID;
439 : :
440 : 19 : pc = poptGetContext(argv[0], argc, argv, long_options, 0);
441 [ - + ]: 19 : while((opt = poptGetNextOpt(pc)) != -1) {
442 : : switch(opt) {
443 : : default:
444 : 0 : fprintf(stderr, "\nInvalid option %s: %s\n\n",
445 : : poptBadOption(pc, 0), poptStrerror(opt));
446 : 0 : poptPrintUsage(pc, stderr, 0);
447 : : return 1;
448 : : }
449 : : }
450 : 19 : poptFreeContext(pc);
451 : :
452 [ - + ]: 19 : DEBUG_INIT(debug_level);
453 : :
454 : 19 : tests_set_cwd();
455 : :
456 : 19 : strtonum_suite = create_strtonum_suite();
457 : 19 : sr = srunner_create(strtonum_suite);
458 : : /* If CK_VERBOSITY is set, use that, otherwise it defaults to CK_NORMAL */
459 : 19 : srunner_run_all(sr, CK_ENV);
460 : 1 : failure_count = srunner_ntests_failed(sr);
461 : 1 : srunner_free(sr);
462 : 1 : return (failure_count==0 ? EXIT_SUCCESS : EXIT_FAILURE);
463 : : }
|
