1 /* $NetBSD: t_strtol.c,v 1.6 2016/06/01 01:12:02 pgoyette Exp $ */
2
3 /*-
4 * Copyright (c) 2011 The NetBSD Foundation, Inc.
5 * All rights reserved.
6 *
7 * This code is derived from software contributed to The NetBSD Foundation
8 * by Jukka Ruohonen.
9 *
10 * Redistribution and use in source and binary forms, with or without
11 * modification, are permitted provided that the following conditions
12 * are met:
13 * 1. Redistributions of source code must retain the above copyright
14 * notice, this list of conditions and the following disclaimer.
15 * 2. Redistributions in binary form must reproduce the above copyright
16 * notice, this list of conditions and the following disclaimer in the
17 * documentation and/or other materials provided with the distribution.
18 *
19 * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS
20 * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
21 * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
22 * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS
23 * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
24 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
25 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
26 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
27 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
28 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
29 * POSSIBILITY OF SUCH DAMAGE.
30 */
31
32 #include <sys/cdefs.h>
33 __RCSID("$NetBSD: t_strtol.c,v 1.6 2016/06/01 01:12:02 pgoyette Exp $");
34
35 #include <atf-c.h>
36 #include <errno.h>
37 #include <stdlib.h>
38 #include <string.h>
39 #include <limits.h>
40
41 struct test {
42 const char *str;
43 int64_t res;
44 int base;
45 const char *end;
46 };
47
48 static void check(struct test *, long int, long long int, char *);
49
50 static void
check(struct test * t,long int li,long long int lli,char * end)51 check(struct test *t, long int li, long long int lli, char *end)
52 {
53
54 if (li != -1 && li != t->res)
55 atf_tc_fail_nonfatal("strtol(%s, &end, %d) failed "
56 "(rv = %ld)", t->str, t->base, li);
57
58 if (lli != -1 && lli != t->res)
59 atf_tc_fail_nonfatal("strtoll(%s, NULL, %d) failed "
60 "(rv = %lld)", t->str, t->base, lli);
61
62 if ((t->end != NULL && strcmp(t->end, end) != 0) ||
63 (t->end == NULL && *end != '\0'))
64 atf_tc_fail_nonfatal("invalid end pointer ('%s') from "
65 "strtol(%s, &end, %d)", end, t->str, t->base);
66 }
67
68 ATF_TC(strtol_base);
ATF_TC_HEAD(strtol_base,tc)69 ATF_TC_HEAD(strtol_base, tc)
70 {
71 atf_tc_set_md_var(tc, "descr", "Test strtol(3) with different bases");
72 }
73
ATF_TC_BODY(strtol_base,tc)74 ATF_TC_BODY(strtol_base, tc)
75 {
76 struct test t[] = {
77 { "123456789", 123456789, 0, NULL },
78 { "111010110111100110100010101", 123456789, 2, NULL },
79 { "22121022020212200", 123456789, 3, NULL },
80 { "13112330310111", 123456789, 4, NULL },
81 { "223101104124", 123456789, 5, NULL },
82 { "20130035113", 123456789, 6, NULL },
83 { "3026236221", 123456789, 7, NULL },
84 { "726746425", 123456789, 8, NULL },
85 { "277266780", 123456789, 9, NULL },
86 { "123456789", 123456789, 10, NULL },
87 { "63762A05", 123456789, 11, NULL },
88 { "35418A99", 123456789, 12, NULL },
89 { "1C767471", 123456789, 13, NULL },
90 { "12579781", 123456789, 14, NULL },
91 { "AC89BC9", 123456789, 15, NULL },
92 { "75BCD15", 123456789, 16, NULL },
93 { "1234567", 342391, 8, NULL },
94 { "01234567", 342391, 0, NULL },
95 { "0123456789", 123456789, 10, NULL },
96 { "0x75bcd15", 123456789, 0, NULL },
97 #ifdef __FreeBSD__
98 { "0x", 0, 0, "x" },
99 { "0b111010110111100110100010101", 123456789, 0, NULL },
100 { "0b0123", 1, 0, "23" },
101 { "0b", 0, 0, "b" },
102 #endif
103 };
104
105 long long int lli;
106 long int li;
107 char *end;
108 size_t i;
109
110 for (i = 0; i < __arraycount(t); i++) {
111
112 li = strtol(t[i].str, &end, t[i].base);
113 lli = strtoll(t[i].str, NULL, t[i].base);
114
115 check(&t[i], li, lli, end);
116 }
117 }
118
119 ATF_TC(strtol_case);
ATF_TC_HEAD(strtol_case,tc)120 ATF_TC_HEAD(strtol_case, tc)
121 {
122 atf_tc_set_md_var(tc, "descr", "Case insensitivity with strtol(3)");
123 }
124
ATF_TC_BODY(strtol_case,tc)125 ATF_TC_BODY(strtol_case, tc)
126 {
127 struct test t[] = {
128 { "abcd", 0xabcd, 16, NULL },
129 { " dcba", 0xdcba, 16, NULL },
130 { "abcd dcba", 0xabcd, 16, " dcba" },
131 { "abc0x123", 0xabc0, 16, "x123" },
132 { "abcd\0x123", 0xabcd, 16, "\0x123" },
133 { "ABCD", 0xabcd, 16, NULL },
134 { "aBcD", 0xabcd, 16, NULL },
135 { "0xABCD", 0xabcd, 16, NULL },
136 { "0xABCDX", 0xabcd, 16, "X" },
137 };
138
139 long long int lli;
140 long int li;
141 char *end;
142 size_t i;
143
144 for (i = 0; i < __arraycount(t); i++) {
145
146 li = strtol(t[i].str, &end, t[i].base);
147 lli = strtoll(t[i].str, NULL, t[i].base);
148
149 check(&t[i], li, lli, end);
150 }
151 }
152
153 ATF_TC(strtol_range);
ATF_TC_HEAD(strtol_range,tc)154 ATF_TC_HEAD(strtol_range, tc)
155 {
156 atf_tc_set_md_var(tc, "descr", "Test ERANGE from strtol(3)");
157 }
158
ATF_TC_BODY(strtol_range,tc)159 ATF_TC_BODY(strtol_range, tc)
160 {
161
162 #if LONG_MAX == 0x7fffffff /* XXX: Is this portable? */
163
164 struct test t[] = {
165 { "20000000000", 2147483647, 8, NULL },
166 { "2147483648", 2147483647, 10, NULL },
167 { "80000000", 2147483647, 16, NULL },
168 };
169 #else
170 struct test t[] = {
171 { "1000000000000000000000", 9223372036854775807, 8, NULL },
172 { "9223372036854775808", 9223372036854775807, 10, NULL },
173 { "8000000000000000", 9223372036854775807, 16, NULL },
174 };
175 #endif
176
177 long int li;
178 char *end;
179 size_t i;
180
181 for (i = 0; i < __arraycount(t); i++) {
182
183 errno = 0;
184 li = strtol(t[i].str, &end, t[i].base);
185
186 if (errno != ERANGE)
187 atf_tc_fail("strtol(3) did not catch ERANGE");
188
189 check(&t[i], li, -1, end);
190 }
191 }
192
193 ATF_TC(strtol_signed);
ATF_TC_HEAD(strtol_signed,tc)194 ATF_TC_HEAD(strtol_signed, tc)
195 {
196 atf_tc_set_md_var(tc, "descr", "A basic test of strtol(3)");
197 }
198
ATF_TC_BODY(strtol_signed,tc)199 ATF_TC_BODY(strtol_signed, tc)
200 {
201 struct test t[] = {
202 { "1", 1, 0, NULL },
203 { " 2", 2, 0, NULL },
204 { " 3", 3, 0, NULL },
205 { " -3", -3, 0, NULL },
206 { "--1", 0, 0, "--1" },
207 { "+-2", 0, 0, "+-2" },
208 { "++3", 0, 0, "++3" },
209 { "+9", 9, 0, NULL },
210 { "+123", 123, 0, NULL },
211 { "-1 3", -1, 0, " 3" },
212 { "-1.3", -1, 0, ".3" },
213 { "- 3", 0, 0, "- 3" },
214 { "+33.", 33, 0, "." },
215 { "30x0", 30, 0, "x0" },
216 };
217
218 long long int lli;
219 long int li;
220 char *end;
221 size_t i;
222
223 for (i = 0; i < __arraycount(t); i++) {
224
225 li = strtol(t[i].str, &end, t[i].base);
226 lli = strtoll(t[i].str, NULL, t[i].base);
227
228 check(&t[i], li, lli, end);
229 }
230 }
231
ATF_TP_ADD_TCS(tp)232 ATF_TP_ADD_TCS(tp)
233 {
234
235 ATF_TP_ADD_TC(tp, strtol_base);
236 ATF_TP_ADD_TC(tp, strtol_case);
237 ATF_TP_ADD_TC(tp, strtol_range);
238 ATF_TP_ADD_TC(tp, strtol_signed);
239
240 return atf_no_error();
241 }
242