The FreeRADIUS server  $Id: 15bac2a4c627c01d1aa2047687b3418955ac7f00 $
size_tests.c
Go to the documentation of this file.
1 /*
2  * This library is free software; you can redistribute it and/or
3  * modify it under the terms of the GNU Lesser General Public
4  * License as published by the Free Software Foundation; either
5  * version 2.1 of the License, or (at your option) any later version.
6  *
7  * This library is distributed in the hope that it will be useful,
8  * but WITHOUT ANY WARRANTY; without even the implied warranty of
9  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
10  * Lesser General Public License for more details.
11  *
12  * You should have received a copy of the GNU Lesser General Public
13  * License along with this library; if not, write to the Free Software
14  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
15  */
16 
17 /** Size printing/parsing
18  *
19  * @file src/lib/util/size_tests.c
20  * @copyright Arran Cudbard-Bell (a.cudbardb@freeradius.org)
21  */
22 
23 #include <freeradius-devel/util/acutest.h>
24 #include <freeradius-devel/util/acutest_helpers.h>
25 #include <freeradius-devel/util/size.h>
26 
27 #ifdef HAVE_GPERFTOOLS_PROFILER_H
28 # include <gperftools/profiler.h>
29 #endif
30 
31 /*
32 fr_slen_t fr_size_from_str(size_t *out, fr_sbuff_t *in);
33 
34 fr_slen_t fr_size_to_str(fr_sbuff_t *out, size_t in);
35 */
36 
37 
38 #define test_str(_str) &FR_SBUFF_IN(_str, strlen(_str))
39 #define test_out(_buff) &FR_SBUFF_OUT(_buff, sizeof(_buff))
40 
41 static char buff[sizeof("18446744073709551615") + 3];
42 
43 static void test_size_parse_bytes(void)
44 {
45  size_t size;
46 
47  TEST_MSG("Parse zero b");
48  TEST_CHECK_SLEN(fr_size_from_str(&size, test_str("0")), 1);
49  TEST_CHECK_LEN(size, 0);
50 
51  TEST_MSG("Parse one b");
52  TEST_CHECK_SLEN(fr_size_from_str(&size, test_str("1")), 1);
53  TEST_CHECK_LEN(size, 1);
54 
55  TEST_MSG("Parse ten b");
56  TEST_CHECK_SLEN(fr_size_from_str(&size, test_str("10")), 2);
57  TEST_CHECK_LEN(size, 10);
58 
59  TEST_MSG("Parse max b");
60  snprintf(buff, sizeof(buff), "%zu", SIZE_MAX);
61  TEST_CHECK_SLEN(fr_size_from_str(&size, test_str(buff)), (ssize_t)strlen(buff));
62  TEST_CHECK_LEN(size, SIZE_MAX);
63 
64  TEST_MSG("Allow suffix b");
65  snprintf(buff, sizeof(buff), "%zub", SIZE_MAX);
66  TEST_CHECK_SLEN(fr_size_from_str(&size, test_str(buff)), (ssize_t)strlen(buff));
67  TEST_CHECK_LEN(size, SIZE_MAX);
68 
69  TEST_MSG("Allow trailing none-int");
70  TEST_CHECK_SLEN(fr_size_from_str(&size, test_str("1b_")), 2);
71  TEST_CHECK_LEN(size, 1);
72 
73  TEST_MSG("Fail on negative");
74  TEST_CHECK_SLEN(fr_size_from_str(&size, test_str("-10")), -1);
75 
76 /*
77  TEST_MSG("Fail on trailing");
78  TEST_CHECK_RET(fr_size_from_str(&size, test_str("1a0")), -2);
79 */
80 }
81 
82 static void test_size_parse_suffix_base2(void)
83 {
84  size_t size;
85 
86  TEST_MSG("Parse zero ki");
87  TEST_CHECK_SLEN(fr_size_from_str(&size, test_str("0ki")), 3);
88  TEST_CHECK_LEN(size, 0);
89 
90  TEST_MSG("Parse zero kib");
91  TEST_CHECK_SLEN(fr_size_from_str(&size, test_str("0kib")), 4);
92  TEST_CHECK_LEN(size, 0);
93 
94  TEST_MSG("Parse one ki");
95  TEST_CHECK_SLEN(fr_size_from_str(&size, test_str("1ki")), 3);
96  TEST_CHECK_LEN(size, 1024ULL);
97 
98  TEST_MSG("Parse one kib");
99  TEST_CHECK_SLEN(fr_size_from_str(&size, test_str("1kib")), 4);
100  TEST_CHECK_LEN(size, 1024ULL);
101 
102  TEST_MSG("Parse one KIB");
103  TEST_CHECK_SLEN(fr_size_from_str(&size, test_str("1KIB")), 4);
104  TEST_CHECK_LEN(size, 1024ULL);
105 
106  TEST_MSG("Parse one mib");
107  TEST_CHECK_SLEN(fr_size_from_str(&size, test_str("1mib")), 4);
108  TEST_CHECK_LEN(size, 1024ULL * 1024);
109 
110  TEST_MSG("Parse one gib");
111  TEST_CHECK_SLEN(fr_size_from_str(&size, test_str("1gib")), 4);
112  TEST_CHECK_LEN(size, 1024ULL * 1024 * 1024);
113 
114  TEST_MSG("Parse one tib");
115  TEST_CHECK_SLEN(fr_size_from_str(&size, test_str("1tib")), 4);
116  TEST_CHECK_LEN(size, 1024ULL * 1024 * 1024 * 1024);
117 
118 #if SIZE_MAX > UINT32_MAX
119  TEST_MSG("Parse one pib");
120  TEST_CHECK_SLEN(fr_size_from_str(&size, test_str("1pib")), 4);
121  TEST_CHECK_LEN(size, 1024ULL * 1024 * 1024 * 1024 * 1024);
122 
123  TEST_MSG("Parse one eib");
124  TEST_CHECK_SLEN(fr_size_from_str(&size, test_str("1eib")), 4);
125  TEST_CHECK_LEN(size, 1024ULL * 1024 * 1024 * 1024 * 1024 * 1024);
126 #endif
127 
128  TEST_MSG("Overflow");
129  TEST_CHECK_SLEN(fr_size_from_str(&size, test_str("100000000eib")), -1);
130 }
131 
132 static void test_size_parse_suffix_base10(void)
133 {
134  size_t size;
135 
136  TEST_MSG("Parse zero k");
137  TEST_CHECK_SLEN(fr_size_from_str(&size, test_str("0k")), 2);
138  TEST_CHECK_LEN(size, 0);
139 
140  TEST_MSG("Parse zero kb");
141  TEST_CHECK_SLEN(fr_size_from_str(&size, test_str("0kb")), 3);
142  TEST_CHECK_LEN(size, 0);
143 
144  TEST_MSG("Parse one k");
145  TEST_CHECK_SLEN(fr_size_from_str(&size, test_str("1k")), 2);
146  TEST_CHECK_LEN(size, 1000ULL);
147 
148  TEST_MSG("Parse one K");
149  TEST_CHECK_SLEN(fr_size_from_str(&size, test_str("1K")), 2);
150  TEST_CHECK_LEN(size, 1000ULL);
151 
152  TEST_MSG("Parse one KB");
153  TEST_CHECK_SLEN(fr_size_from_str(&size, test_str("1KB")), 3);
154  TEST_CHECK_LEN(size, 1000ULL);
155 
156  TEST_MSG("Parse one kb");
157  TEST_CHECK_SLEN(fr_size_from_str(&size, test_str("1kb")), 3);
158  TEST_CHECK_LEN(size, 1000ULL);
159 
160  TEST_MSG("Parse one mb");
161  TEST_CHECK_SLEN(fr_size_from_str(&size, test_str("1mb")), 3);
162  TEST_CHECK_LEN(size, 1000ULL * 1000);
163 
164  TEST_MSG("Parse one gb");
165  TEST_CHECK_SLEN(fr_size_from_str(&size, test_str("1gb")), 3);
166  TEST_CHECK_LEN(size, 1000ULL * 1000 * 1000);
167 
168  TEST_MSG("Parse one tb");
169  TEST_CHECK_SLEN(fr_size_from_str(&size, test_str("1tb")), 3);
170  TEST_CHECK_LEN(size, 1000ULL * 1000 * 1000 * 1000);
171 
172 #if SIZE_MAX > UINT32_MAX
173  TEST_MSG("Parse one pb");
174  TEST_CHECK_SLEN(fr_size_from_str(&size, test_str("1pb")), 3);
175  TEST_CHECK_LEN(size, 1000ULL * 1000 * 1000 * 1000 * 1000);
176 
177  TEST_MSG("Parse one eb");
178  TEST_CHECK_SLEN(fr_size_from_str(&size, test_str("1eb")), 3);
179  TEST_CHECK_LEN(size, 1000ULL * 1000 * 1000 * 1000 * 1000 * 1000);
180 #endif
181 
182  TEST_MSG("Overflow");
183  TEST_CHECK_SLEN(fr_size_from_str(&size, test_str("100000000eb")), -1);
184 }
185 
186 static void test_size_print_bytes(void)
187 {
188  TEST_CHECK_SLEN(fr_size_to_str(test_out(buff), (size_t)1), 2);
189  TEST_CHECK_STRCMP(buff, "1B");
190 
191  TEST_CHECK_SLEN(fr_size_to_str(test_out(buff), (size_t)2), 2);
192  TEST_CHECK_STRCMP(buff, "2B");
193 
194  TEST_CHECK_SLEN(fr_size_to_str(test_out(buff), (size_t)3), 2);
195  TEST_CHECK_STRCMP(buff, "3B");
196 
197  TEST_CHECK_SLEN(fr_size_to_str(test_out(buff), (size_t)4), 2);
198  TEST_CHECK_STRCMP(buff, "4B");
199 
200  TEST_CHECK_SLEN(fr_size_to_str(test_out(buff), (size_t)5), 2);
201  TEST_CHECK_STRCMP(buff, "5B");
202 
203  TEST_CHECK_SLEN(fr_size_to_str(test_out(buff), (size_t)6), 2);
204  TEST_CHECK_STRCMP(buff, "6B");
205 
206  TEST_CHECK_SLEN(fr_size_to_str(test_out(buff), (size_t)7), 2);
207  TEST_CHECK_STRCMP(buff, "7B");
208 
209  TEST_CHECK_SLEN(fr_size_to_str(test_out(buff), (size_t)8), 2);
210  TEST_CHECK_STRCMP(buff, "8B");
211 
212  TEST_CHECK_SLEN(fr_size_to_str(test_out(buff), (size_t)9), 2);
213  TEST_CHECK_STRCMP(buff, "9B");
214 
215  TEST_CHECK_SLEN(fr_size_to_str(test_out(buff), (size_t)10), 3);
216  TEST_CHECK_STRCMP(buff, "10B");
217 
218  TEST_CHECK_SLEN(fr_size_to_str(test_out(buff), (size_t)100), 4);
219  TEST_CHECK_STRCMP(buff, "100B");
220 
221  TEST_CHECK_SLEN(fr_size_to_str(test_out(buff), (size_t)999), 4);
222  TEST_CHECK_STRCMP(buff, "999B");
223 
224  TEST_CHECK_SLEN(fr_size_to_str(test_out(buff), (size_t)1001), 5);
225  TEST_CHECK_STRCMP(buff, "1001B");
226 
227  TEST_CHECK_SLEN(fr_size_to_str(test_out(buff), (size_t)1020), 5);
228  TEST_CHECK_STRCMP(buff, "1020B");
229 
230  TEST_CHECK_SLEN(fr_size_to_str(test_out(buff), (size_t)1021), 5);
231  TEST_CHECK_STRCMP(buff, "1021B");
232 
233  TEST_CHECK_SLEN(fr_size_to_str(test_out(buff), (size_t)1022), 5);
234  TEST_CHECK_STRCMP(buff, "1022B");
235 
236  TEST_CHECK_SLEN(fr_size_to_str(test_out(buff), (size_t)1023), 5);
237  TEST_CHECK_STRCMP(buff, "1023B");
238 
239  TEST_CHECK_SLEN(fr_size_to_str(test_out(buff), (size_t)1025), 5);
240  TEST_CHECK_STRCMP(buff, "1025B");
241 
242  TEST_CHECK_SLEN(fr_size_to_str(test_out(buff), (size_t)1026), 5);
243  TEST_CHECK_STRCMP(buff, "1026B");
244 
245  TEST_CHECK_SLEN(fr_size_to_str(test_out(buff), (size_t)1027), 5);
246  TEST_CHECK_STRCMP(buff, "1027B");
247 
248  TEST_CHECK_SLEN(fr_size_to_str(test_out(buff), (size_t)1028), 5);
249  TEST_CHECK_STRCMP(buff, "1028B");
250 
251  TEST_CHECK_SLEN(fr_size_to_str(test_out(buff), (size_t)1029), 5);
252  TEST_CHECK_STRCMP(buff, "1029B");
253 
254  TEST_CHECK_SLEN(fr_size_to_str(test_out(buff), (size_t)1030), 5);
255  TEST_CHECK_STRCMP(buff, "1030B");
256 }
257 
258 static void test_size_print_base2(void)
259 {
260  TEST_CHECK_SLEN(fr_size_to_str(test_out(buff), (size_t)1024), 4);
261  TEST_CHECK_STRCMP(buff, "1KiB");
262 
263  TEST_CHECK_SLEN(fr_size_to_str(test_out(buff), (size_t)1024 * 1024), 4);
264  TEST_CHECK_STRCMP(buff, "1MiB");
265 
266  TEST_CHECK_SLEN(fr_size_to_str(test_out(buff), (size_t)1024 * 1024 * 1024), 4);
267  TEST_CHECK_STRCMP(buff, "1GiB");
268 
269  TEST_CHECK_SLEN(fr_size_to_str(test_out(buff), (size_t)1024 * 1024 * 1024 * 1024), 4);
270  TEST_CHECK_STRCMP(buff, "1TiB");
271 
272 #if SIZE_MAX > UINT32_MAX
273  TEST_CHECK_SLEN(fr_size_to_str(test_out(buff), (size_t)1024 * 1024 * 1024 * 1024 * 1024), 4);
274  TEST_CHECK_STRCMP(buff, "1PiB");
275 
276  TEST_CHECK_SLEN(fr_size_to_str(test_out(buff), (size_t)1024 * 1024 * 1024 * 1024 * 1024 * 1024), 4);
277  TEST_CHECK_STRCMP(buff, "1EiB");
278 #endif
279 
280  TEST_MSG("Fall back to KiB");
281  TEST_CHECK_SLEN(fr_size_to_str(test_out(buff), ((size_t)1024 * 1024 * 1024 * 1024) + 1024), 13);
282  TEST_CHECK_STRCMP(buff, "1073741825KiB");
283 
284  TEST_MSG("Fall back to B");
285  TEST_CHECK_SLEN(fr_size_to_str(test_out(buff), ((size_t)1024 * 1024 * 1024 * 1024) + 1025), 14);
286  TEST_CHECK_STRCMP(buff, "1099511628801B");
287 
288  /* Regression - Was displayed as 524288KB because it took the base 10 path */
289  TEST_CHECK_SLEN(fr_size_to_str(test_out(buff), (size_t)524288000), 6);
290  TEST_CHECK_STRCMP(buff, "500MiB");
291 }
292 
293 static void test_size_print_base10(void)
294 {
295  TEST_CHECK_SLEN(fr_size_to_str(test_out(buff), (size_t)1000), 3);
296  TEST_CHECK_STRCMP(buff, "1KB");
297 
298  TEST_CHECK_SLEN(fr_size_to_str(test_out(buff), (size_t)1000 * 1000), 3);
299  TEST_CHECK_STRCMP(buff, "1MB");
300 
301  TEST_CHECK_SLEN(fr_size_to_str(test_out(buff), (size_t)1000 * 1000 + 64000), 6);
302  TEST_CHECK_STRCMP(buff, "1064KB");
303 
304  TEST_CHECK_SLEN(fr_size_to_str(test_out(buff), (size_t)1000 * 1000 * 1000), 3);
305  TEST_CHECK_STRCMP(buff, "1GB");
306 
307  TEST_CHECK_SLEN(fr_size_to_str(test_out(buff), (size_t)1000 * 1000 * 1000 * 1000), 3);
308  TEST_CHECK_STRCMP(buff, "1TB");
309 
310 #if SIZE_MAX > UINT32_MAX
311  TEST_CHECK_SLEN(fr_size_to_str(test_out(buff), (size_t)1000 * 1000 * 1000 * 1000 * 1000), 3);
312  TEST_CHECK_STRCMP(buff, "1PB");
313 
314  TEST_CHECK_SLEN(fr_size_to_str(test_out(buff), (size_t)1000 * 1000 * 1000 * 1000 * 1000 * 1000), 3);
315  TEST_CHECK_STRCMP(buff, "1EB");
316 #endif
317 
318  TEST_MSG("Fall back to KB");
319  TEST_CHECK_SLEN(fr_size_to_str(test_out(buff), ((size_t)1000 * 1000 * 1000 * 1000) + 1000), 12);
320  TEST_CHECK_STRCMP(buff, "1000000001KB");
321 
322  TEST_MSG("Fall back to B");
323  TEST_CHECK_SLEN(fr_size_to_str(test_out(buff), ((size_t)1000 * 1000 * 1000 * 1000) + 1025), 14);
324  TEST_CHECK_STRCMP(buff, "1000000001025B");
325 }
326 
327 TEST_LIST = {
328  /*
329  * Allocation and management
330  */
331  { "parse_bytes", test_size_parse_bytes },
332  { "parse_suffix_base2", test_size_parse_suffix_base2 },
333  { "parse_suffix_base10", test_size_parse_suffix_base10 },
334 
335  { "print_bytes", test_size_print_bytes },
336  { "print_base2", test_size_print_base2 },
337  { "print_base10", test_size_print_base10 },
338 
339  { NULL }
340 };
TEST_MSG
#define TEST_MSG(...)
Definition: acutest.h:215
TEST_CHECK_SLEN
#define TEST_CHECK_SLEN(_got, _exp)
Definition: acutest_helpers.h:38
TEST_CHECK_LEN
#define TEST_CHECK_LEN(_got, _exp)
Definition: acutest_helpers.h:30
TEST_CHECK_STRCMP
#define TEST_CHECK_STRCMP(_got, _exp)
Definition: acutest_helpers.h:63
ssize_t
long int ssize_t
Definition: merged_model.c:24
fr_size_from_str
fr_slen_t fr_size_from_str(size_t *out, fr_sbuff_t *in)
Parse a size string with optional unit.
Definition: size.c:40
fr_size_to_str
fr_slen_t fr_size_to_str(fr_sbuff_t *out, size_t in)
Print a size string with unit.
Definition: size.c:155
test_size_print_base2
static void test_size_print_base2(void)
Definition: size_tests.c:258
TEST_LIST
TEST_LIST
Definition: size_tests.c:327
test_size_parse_bytes
static void test_size_parse_bytes(void)
Definition: size_tests.c:43
test_size_print_bytes
static void test_size_print_bytes(void)
Definition: size_tests.c:186
test_size_parse_suffix_base10
static void test_size_parse_suffix_base10(void)
Definition: size_tests.c:132
buff
static char buff[sizeof("18446744073709551615")+3]
Definition: size_tests.c:41
test_size_print_base10
static void test_size_print_base10(void)
Definition: size_tests.c:293
test_out
#define test_out(_buff)
Definition: size_tests.c:39
test_size_parse_suffix_base2
static void test_size_parse_suffix_base2(void)
Definition: size_tests.c:82
test_str
#define test_str(_str)
Definition: size_tests.c:38
snprintf
PUBLIC int snprintf(char *string, size_t length, char *format, va_alist)
Definition: snprintf.c:689
Generated by   doxygen 1.9.1