1 #include "config.h"
2 #include "ntp_stdlib.h"
3 #include "ntp_fp.h"
4 #include "binio.h"
5
6 #include "unity.h"
7 #include "unity_fixture.h"
8
9 /*
10 * Tests for libparse/binio.c, in -lparse
11 *
12 */
13
14 TEST_GROUP(binio);
15
TEST_SETUP(binio)16 TEST_SETUP(binio) {}
17
TEST_TEAR_DOWN(binio)18 TEST_TEAR_DOWN(binio) {}
19
20 /* LSB int tests */
21
TEST(binio,get_lsb_int160)22 TEST(binio, get_lsb_int160) {
23 long ret;
24 unsigned char zero[2] = { 0, 0};
25 unsigned char *bp = &zero[0];
26
27 ret = get_lsb_int16( &bp);
28
29 TEST_ASSERT_EQUAL_INT64( 0, ret );
30 }
31
TEST(binio,get_lsb_int161)32 TEST(binio, get_lsb_int161) {
33 long ret;
34 unsigned char zero[2] = { 1, 2};
35 unsigned char *bp = &zero[0];
36
37 ret = get_lsb_int16( &bp);
38
39 TEST_ASSERT_EQUAL_HEX64( 0x0201UL, ret );
40 }
41
TEST(binio,get_lsb_int162)42 TEST(binio, get_lsb_int162) {
43 long ret;
44 unsigned char zero[2] = { 2, 1};
45 unsigned char *bp = &zero[0];
46
47 ret = get_lsb_int16( &bp);
48
49 TEST_ASSERT_EQUAL_HEX64( 0x0102UL, ret );
50 }
51
TEST(binio,get_lsb_int163)52 TEST(binio, get_lsb_int163) {
53 long ret;
54 unsigned char zero[2] = { 0xff, 0xff};
55 unsigned char *bp = &zero[0];
56
57 ret = get_lsb_int16( &bp);
58
59 TEST_ASSERT_EQUAL_HEX64( -1L, ret );
60 }
61
TEST(binio,get_lsb_int164)62 TEST(binio, get_lsb_int164) {
63 long ret;
64 unsigned char zero[2] = { 0, 0x80};
65 unsigned char *bp = &zero[0];
66
67 ret = get_lsb_int16( &bp);
68
69 TEST_ASSERT_EQUAL_HEX64( -0x8000L, ret );
70 }
71
72
TEST(binio,get_lsb_int320)73 TEST(binio, get_lsb_int320) {
74 int32_t ret;
75 unsigned char zero[4] = { 0, 0, 0, 0};
76 unsigned char *bp = &zero[0];
77
78 ret = get_lsb_int32( &bp);
79
80 TEST_ASSERT_EQUAL_INT32( 0, ret );
81 }
82
83
TEST(binio,get_lsb_int321)84 TEST(binio, get_lsb_int321) {
85 int32_t ret;
86 unsigned char zero[4] = { 1, 2, 3, 4};
87 unsigned char *bp = &zero[0];
88
89 ret = get_lsb_int32( &bp);
90
91 TEST_ASSERT_EQUAL_HEX32( 0x04030201UL, ret );
92 }
93
94
TEST(binio,get_lsb_int322)95 TEST(binio, get_lsb_int322) {
96 int32_t ret;
97 unsigned char zero[4] = { 4, 3, 2, 1};
98 unsigned char *bp = &zero[0];
99
100 ret = get_lsb_int32( &bp);
101
102 TEST_ASSERT_EQUAL_HEX32( 0x01020304UL, ret );
103 }
104
105
TEST(binio,get_lsb_int323)106 TEST(binio, get_lsb_int323) {
107 int32_t ret;
108 unsigned char zero[4] = { 0xff, 0xff, 0xff, 0xff};
109 unsigned char *bp = &zero[0];
110
111 ret = get_lsb_int32( &bp);
112
113 TEST_ASSERT_EQUAL_HEX32( 0x0FFFFFFFFUL, ret );
114 }
115
116
TEST(binio,get_lsb_int324)117 TEST(binio, get_lsb_int324) {
118 int32_t ret;
119 unsigned char zero[4] = { 0, 0, 0, 0x80};
120 unsigned char *bp = &zero[0];
121
122 ret = get_lsb_int32( &bp);
123
124 TEST_ASSERT_EQUAL_HEX32( 0x080000000UL, ret );
125 }
126
127
TEST(binio,put_lsb_uint160)128 TEST(binio, put_lsb_uint160) {
129 unsigned char ret[2] = { 0, 0};
130 unsigned char expect[2] = { 0, 0};
131 unsigned char *bp = &ret[0];
132
133 put_lsb_uint16( &bp, 0);
134
135 TEST_ASSERT_EQUAL_HEX8_ARRAY( expect, ret, 2 );
136 }
137
TEST(binio,put_lsb_uint161)138 TEST(binio, put_lsb_uint161) {
139 unsigned char ret[2] = { 0, 0};
140 unsigned char expect[2] = { 1, 0};
141 unsigned char *bp = &ret[0];
142
143 put_lsb_uint16( &bp, 1);
144
145 TEST_ASSERT_EQUAL_HEX8_ARRAY( expect, ret, 2 );
146 }
147
TEST(binio,put_lsb_uint162)148 TEST(binio, put_lsb_uint162) {
149 unsigned char ret[2] = { 0, 0};
150 unsigned char expect[2] = { 0, 1};
151 unsigned char *bp = &ret[0];
152
153 put_lsb_uint16( &bp, 256);
154
155 TEST_ASSERT_EQUAL_HEX8_ARRAY( expect, ret, 2 );
156 }
157
TEST(binio,put_lsb_uint163)158 TEST(binio, put_lsb_uint163) {
159 unsigned char ret[2] = { 0, 0};
160 unsigned char expect[2] = { 0xff, 0xff };
161 unsigned char *bp = &ret[0];
162
163 put_lsb_uint16( &bp, 0xffff);
164
165 TEST_ASSERT_EQUAL_HEX8_ARRAY( expect, ret, 2 );
166 }
167
TEST(binio,put_lsb_uint164)168 TEST(binio, put_lsb_uint164) {
169 unsigned char ret[2] = { 0, 0};
170 unsigned char expect[2] = { 1, 0x80};
171 unsigned char *bp = &ret[0];
172
173 put_lsb_uint16( &bp, 0x8001);
174
175 TEST_ASSERT_EQUAL_HEX8_ARRAY( expect, ret, 2 );
176 }
177
178
179 /* LSB unsigned int tests */
180
TEST(binio,get_lsb_uint160)181 TEST(binio, get_lsb_uint160) {
182 long ret;
183 unsigned char zero[2] = { 0, 0};
184 unsigned char *bp = &zero[0];
185
186 ret = get_lsb_uint16( &bp);
187
188 TEST_ASSERT_EQUAL_INT64( 0, ret );
189 }
190
TEST(binio,get_lsb_uint161)191 TEST(binio, get_lsb_uint161) {
192 long ret;
193 unsigned char zero[2] = { 1, 2};
194 unsigned char *bp = &zero[0];
195
196 ret = get_lsb_uint16( &bp);
197
198 TEST_ASSERT_EQUAL_HEX64( 0x0201UL, ret );
199 }
200
TEST(binio,get_lsb_uint162)201 TEST(binio, get_lsb_uint162) {
202 long ret;
203 unsigned char zero[2] = { 2, 1};
204 unsigned char *bp = &zero[0];
205
206 ret = get_lsb_uint16( &bp);
207
208 TEST_ASSERT_EQUAL_HEX64( 0x0102UL, ret );
209 }
210
TEST(binio,get_lsb_uint163)211 TEST(binio, get_lsb_uint163) {
212 long ret;
213 unsigned char zero[2] = { 0xff, 0xff};
214 unsigned char *bp = &zero[0];
215
216 ret = get_lsb_uint16( &bp);
217
218 TEST_ASSERT_EQUAL_HEX64( 0x0ffffUL, ret );
219 }
220
TEST(binio,get_lsb_uint164)221 TEST(binio, get_lsb_uint164) {
222 long ret;
223 unsigned char zero[2] = { 0, 0x80};
224 unsigned char *bp = &zero[0];
225
226 ret = get_lsb_uint16( &bp);
227
228 TEST_ASSERT_EQUAL_HEX64( 0x8000L, ret );
229 }
230
231
TEST(binio,get_lsb_uint320)232 TEST(binio, get_lsb_uint320) {
233 uint32_t ret;
234 unsigned char zero[4] = { 0, 0, 0, 0};
235 unsigned char *bp = &zero[0];
236
237 ret = get_lsb_uint32( &bp);
238
239 TEST_ASSERT_EQUAL_UINT32( 0, ret );
240 }
241
242
TEST(binio,get_lsb_uint321)243 TEST(binio, get_lsb_uint321) {
244 uint32_t ret;
245 unsigned char zero[4] = { 1, 2, 3, 4};
246 unsigned char *bp = &zero[0];
247
248 ret = get_lsb_uint32( &bp);
249
250 TEST_ASSERT_EQUAL_HEX32( 0x04030201UL, ret );
251 }
252
253
TEST(binio,get_lsb_uint322)254 TEST(binio, get_lsb_uint322) {
255 uint32_t ret;
256 unsigned char zero[4] = { 4, 3, 2, 1};
257 unsigned char *bp = &zero[0];
258
259 ret = get_lsb_uint32( &bp);
260
261 TEST_ASSERT_EQUAL_HEX32( 0x01020304UL, ret );
262 }
263
264
TEST(binio,get_lsb_uint323)265 TEST(binio, get_lsb_uint323) {
266 uint32_t ret;
267 unsigned char zero[4] = { 0xff, 0xff, 0xff, 0xff};
268 unsigned char *bp = &zero[0];
269
270 ret = get_lsb_uint32( &bp);
271
272 TEST_ASSERT_EQUAL_HEX32( 0x0FFFFFFFFUL, ret );
273 }
274
275
TEST(binio,get_lsb_uint324)276 TEST(binio, get_lsb_uint324) {
277 uint32_t ret;
278 unsigned char zero[4] = { 0, 0, 0, 0x80};
279 unsigned char *bp = &zero[0];
280
281 ret = get_lsb_uint32( &bp);
282
283 TEST_ASSERT_EQUAL_HEX32( 0x080000000UL, ret );
284 }
285
286 /* MSB tests */
287
TEST(binio,get_msb_short0)288 TEST(binio, get_msb_short0) {
289 long ret;
290 unsigned char zero[2] = { 0, 0};
291 unsigned char *bp = &zero[0];
292
293 ret = get_msb_short( &bp);
294
295 TEST_ASSERT_EQUAL_INT64( 0, ret );
296 }
297
TEST(binio,get_msb_short1)298 TEST(binio, get_msb_short1) {
299 long ret;
300 unsigned char zero[2] = { 2, 1};
301 unsigned char *bp = &zero[0];
302
303 ret = get_msb_short( &bp);
304
305 TEST_ASSERT_EQUAL_HEX64( 0x0201UL, ret );
306 }
307
TEST(binio,get_msb_short2)308 TEST(binio, get_msb_short2) {
309 long ret;
310 unsigned char zero[2] = { 1, 2};
311 unsigned char *bp = &zero[0];
312
313 ret = get_msb_short( &bp);
314
315 TEST_ASSERT_EQUAL_HEX64( 0x0102UL, ret );
316 }
317
TEST(binio,get_msb_short3)318 TEST(binio, get_msb_short3) {
319 long ret;
320 unsigned char zero[2] = { 0xff, 0xff};
321 unsigned char *bp = &zero[0];
322
323 ret = get_msb_short( &bp);
324
325 TEST_ASSERT_EQUAL_HEX64( -1L, ret );
326 }
327
TEST(binio,get_msb_short4)328 TEST(binio, get_msb_short4) {
329 long ret;
330 unsigned char zero[2] = { 0x80, 0};
331 unsigned char *bp = &zero[0];
332
333 ret = get_msb_short( &bp);
334
335 TEST_ASSERT_EQUAL_HEX64( -0x8000L, ret );
336 }
337
TEST(binio,getmsb_short0)338 TEST(binio, getmsb_short0) {
339 int ret;
340 unsigned char zero[2] = { 0, 0};
341
342 ret = getmsb_short( zero);
343
344 TEST_ASSERT_EQUAL_INT( 0, ret );
345 }
346
TEST(binio,getmsb_short1)347 TEST(binio, getmsb_short1) {
348 int ret;
349 unsigned char zero[2] = { 2, 1};
350
351 ret = getmsb_short( zero);
352
353 TEST_ASSERT_EQUAL_INT( 0x0201L, ret );
354 }
355
TEST(binio,getmsb_short2)356 TEST(binio, getmsb_short2) {
357 int ret;
358 unsigned char zero[2] = { 1, 2};
359
360 ret = getmsb_short( zero);
361
362 TEST_ASSERT_EQUAL_INT( 0x0102L, ret );
363 }
364
TEST(binio,getmsb_short3)365 TEST(binio, getmsb_short3) {
366 int ret;
367 unsigned char zero[2] = { 0xff, 0xff};
368
369 ret = getmsb_short( zero);
370
371 TEST_ASSERT_EQUAL_INT( -1, ret );
372 }
373
TEST(binio,getmsb_short4)374 TEST(binio, getmsb_short4) {
375 int ret;
376 unsigned char zero[2] = { 0x80, 0};
377
378 ret = getmsb_short( zero);
379
380 TEST_ASSERT_EQUAL_INT( -0x8000L, ret );
381 }
382
TEST(binio,get_msb_ushort0)383 TEST(binio, get_msb_ushort0) {
384 uint32_t ret;
385 unsigned char zero[2] = { 0, 0};
386
387 ret = get_msb_ushort( zero);
388
389 TEST_ASSERT_EQUAL_HEX32( 0, ret );
390 }
391
TEST(binio,get_msb_ushort1)392 TEST(binio, get_msb_ushort1) {
393 uint32_t ret;
394 unsigned char zero[2] = { 2, 1};
395
396 ret = get_msb_ushort( zero);
397
398 TEST_ASSERT_EQUAL_HEX32( 0x0201UL, ret );
399 }
400
TEST(binio,get_msb_ushort2)401 TEST(binio, get_msb_ushort2) {
402 uint32_t ret;
403 unsigned char zero[2] = { 1, 2};
404
405 ret = get_msb_ushort( zero);
406
407 TEST_ASSERT_EQUAL_HEX32( 0x0102UL, ret );
408 }
409
TEST(binio,get_msb_ushort3)410 TEST(binio, get_msb_ushort3) {
411 uint32_t ret;
412 unsigned char zero[2] = { 0xff, 0xff};
413
414 ret = get_msb_ushort( zero);
415
416 TEST_ASSERT_EQUAL_HEX32( 0x0FFFFUL, ret );
417 }
418
TEST(binio,get_msb_ushort4)419 TEST(binio, get_msb_ushort4) {
420 uint32_t ret;
421 unsigned char zero[2] = { 0x80, 0};
422
423 ret = get_msb_ushort( zero);
424
425 TEST_ASSERT_EQUAL_HEX32( 0x8000UL, ret );
426 }
427
TEST_GROUP_RUNNER(binio)428 TEST_GROUP_RUNNER(binio) {
429 /* LSB int tests */
430 RUN_TEST_CASE(binio, get_lsb_int160);
431 RUN_TEST_CASE(binio, get_lsb_int161);
432 RUN_TEST_CASE(binio, get_lsb_int162);
433 RUN_TEST_CASE(binio, get_lsb_int163);
434 RUN_TEST_CASE(binio, get_lsb_int164);
435
436 RUN_TEST_CASE(binio, get_lsb_int320);
437 RUN_TEST_CASE(binio, get_lsb_int321);
438 RUN_TEST_CASE(binio, get_lsb_int322);
439 RUN_TEST_CASE(binio, get_lsb_int323);
440 RUN_TEST_CASE(binio, get_lsb_int324);
441
442 RUN_TEST_CASE(binio, put_lsb_uint160);
443 RUN_TEST_CASE(binio, put_lsb_uint161);
444 RUN_TEST_CASE(binio, put_lsb_uint162);
445 RUN_TEST_CASE(binio, put_lsb_uint163);
446 RUN_TEST_CASE(binio, put_lsb_uint164);
447
448 /* LSB unsigned int tests */
449 RUN_TEST_CASE(binio, get_lsb_uint160);
450 RUN_TEST_CASE(binio, get_lsb_uint161);
451 RUN_TEST_CASE(binio, get_lsb_uint162);
452 RUN_TEST_CASE(binio, get_lsb_uint163);
453 RUN_TEST_CASE(binio, get_lsb_uint164);
454
455 RUN_TEST_CASE(binio, get_lsb_uint320);
456 RUN_TEST_CASE(binio, get_lsb_uint321);
457 RUN_TEST_CASE(binio, get_lsb_uint322);
458 RUN_TEST_CASE(binio, get_lsb_uint323);
459 RUN_TEST_CASE(binio, get_lsb_uint324);
460
461 /* MSB tests */
462 RUN_TEST_CASE(binio, get_msb_short0);
463 RUN_TEST_CASE(binio, get_msb_short1);
464 RUN_TEST_CASE(binio, get_msb_short2);
465 RUN_TEST_CASE(binio, get_msb_short3);
466 RUN_TEST_CASE(binio, get_msb_short4);
467
468 RUN_TEST_CASE(binio, getmsb_short0);
469 RUN_TEST_CASE(binio, getmsb_short1);
470 RUN_TEST_CASE(binio, getmsb_short2);
471 RUN_TEST_CASE(binio, getmsb_short3);
472 RUN_TEST_CASE(binio, getmsb_short4);
473
474 RUN_TEST_CASE(binio, get_msb_ushort0);
475 RUN_TEST_CASE(binio, get_msb_ushort1);
476 RUN_TEST_CASE(binio, get_msb_ushort2);
477 RUN_TEST_CASE(binio, get_msb_ushort3);
478 RUN_TEST_CASE(binio, get_msb_ushort4);
479
480 }
481