]>
git.ipfire.org Git - thirdparty/strongswan.git/blob - src/libstrongswan/tests/test_bio_reader.c
45b20db00118a5d155d4fbcd4ff2e865f726c3c5
2 * Copyright (C) 2013 Tobias Brunner
3 * Hochschule fuer Technik Rapperswil
5 * This program is free software; you can redistribute it and/or modify it
6 * under the terms of the GNU General Public License as published by the
7 * Free Software Foundation; either version 2 of the License, or (at your
8 * option) any later version. See <http://www.fsf.org/copyleft/gpl.txt>.
10 * This program is distributed in the hope that it will be useful, but
11 * WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
12 * or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
16 #include "test_suite.h"
18 #include <bio/bio_reader.h>
20 /*******************************************************************************
21 * different integer reads
24 #define assert_integer_read(data, bits, val) ({ \
25 bio_reader_t *reader = bio_reader_create(data); \
27 for (i = 0; reader->remaining(reader) >= (bits / 8); i++) \
29 ck_assert(reader->read_uint##bits(reader, &val)); \
30 ck_assert_int_eq(i, val); \
32 ck_assert_int_eq(i, data.len / (bits / 8)); \
33 ck_assert_int_eq(reader->remaining(reader), data.len % (bits / 8)); \
34 ck_assert(!reader->read_uint##bits(reader, &val)); \
35 reader->destroy(reader); \
38 #define assert_integer_read_uneven(data, bits, val) ({ \
40 for (i = 0; i <= bits / 8; i++, data.len++) \
42 assert_integer_read(data, bits, val); \
46 #define assert_basic_read(bits, val) ({ \
49 assert_integer_read(data, bits, val); \
50 data = chunk_alloca(bits / 8); \
51 memset(data.ptr, 0, data.len); \
53 assert_integer_read_uneven(data, bits, val); \
56 #define assert_extended_read(data, bits, val) ({ \
57 chunk_t extended = chunk_alloca(data.len + bits / 8); \
58 memset(extended.ptr, 0, extended.len); \
59 extended.ptr[extended.len - 1] = data.len / (bits / 8); \
60 memcpy(extended.ptr, data.ptr, data.len); \
61 extended.len = data.len; \
62 assert_integer_read_uneven(extended, bits, val); \
65 START_TEST(test_read_uint8
)
67 chunk_t data
= chunk_from_chars(0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07);
70 assert_integer_read(data
, 8, val
);
71 assert_basic_read(8, val
);
72 assert_extended_read(data
, 8, val
);
76 START_TEST(test_read_uint16
)
78 chunk_t data
= chunk_from_chars(0x00, 0x00, 0x00, 0x01, 0x00, 0x02, 0x00, 0x03);
81 assert_integer_read(data
, 16, val
);
82 assert_basic_read(16, val
);
83 assert_extended_read(data
, 16, val
);
87 START_TEST(test_read_uint24
)
89 chunk_t data
= chunk_from_chars(0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x02, 0x00, 0x00, 0x03);
92 assert_integer_read(data
, 24, val
);
93 assert_basic_read(24, val
);
94 assert_extended_read(data
, 24, val
);
98 START_TEST(test_read_uint32
)
100 chunk_t data
= chunk_from_chars(0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01,
101 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x03);
104 assert_integer_read(data
, 32, val
);
105 assert_basic_read(32, val
);
106 assert_extended_read(data
, 32, val
);
110 START_TEST(test_read_uint64
)
112 chunk_t data
= chunk_from_chars(0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
113 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01,
114 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02,
115 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03);
118 assert_integer_read(data
, 64, val
);
119 assert_basic_read(64, val
);
120 assert_extended_read(data
, 64, val
);
124 /*******************************************************************************
125 * different integer reads from the end of a buffer
128 #define assert_integer_read_end(data, bits, val) ({ \
129 bio_reader_t *reader = bio_reader_create(data); \
131 for (i = 0; reader->remaining(reader) >= (bits / 8); i++) \
133 ck_assert(reader->read_uint##bits##_end(reader, &val)); \
134 ck_assert_int_eq(i, val); \
136 ck_assert_int_eq(i, data.len / (bits / 8)); \
137 ck_assert_int_eq(reader->remaining(reader), data.len % (bits / 8)); \
138 ck_assert(!reader->read_uint##bits##_end(reader, &val)); \
139 reader->destroy(reader); \
142 #define assert_integer_read_end_uneven(data, bits, val) ({ \
144 data.ptr += bits / 8; \
145 for (i = 0; i <= bits / 8; i++, data.ptr--, data.len++) \
147 assert_integer_read_end(data, bits, val); \
151 #define assert_basic_read_end(bits, val) ({ \
153 data = chunk_empty; \
154 assert_integer_read_end(data, bits, val); \
155 data = chunk_alloca(bits / 8); \
156 memset(data.ptr, 0, data.len); \
158 assert_integer_read_end_uneven(data, bits, val); \
161 #define assert_extended_read_end(data, bits, val) ({ \
162 chunk_t extended = chunk_alloca(data.len + bits / 8); \
163 memset(extended.ptr, 0, extended.len); \
164 extended.ptr[bits / 8 - 1] = data.len / (bits / 8); \
165 memcpy(extended.ptr + bits / 8, data.ptr, data.len); \
166 extended.len = data.len; \
167 assert_integer_read_end_uneven(extended, bits, val); \
170 START_TEST(test_read_uint8_end
)
172 chunk_t data
= chunk_from_chars(0x07, 0x06, 0x05, 0x04, 0x03, 0x02, 0x01, 0x00);
175 assert_integer_read_end(data
, 8, val
);
176 assert_basic_read_end(8, val
);
177 assert_extended_read_end(data
, 8, val
);
181 START_TEST(test_read_uint16_end
)
183 chunk_t data
= chunk_from_chars(0x00, 0x03, 0x00, 0x02, 0x00, 0x01, 0x00, 0x00);
186 assert_integer_read_end(data
, 16, val
);
187 assert_basic_read_end(16, val
);
188 assert_extended_read_end(data
, 16, val
);
192 START_TEST(test_read_uint24_end
)
194 chunk_t data
= chunk_from_chars(0x00, 0x00, 0x03, 0x00, 0x00, 0x02, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00);
197 assert_integer_read_end(data
, 24, val
);
198 assert_basic_read_end(24, val
);
199 assert_extended_read_end(data
, 24, val
);
203 START_TEST(test_read_uint32_end
)
205 chunk_t data
= chunk_from_chars(0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x02,
206 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00);
209 assert_integer_read_end(data
, 32, val
);
210 assert_basic_read_end(32, val
);
211 assert_extended_read_end(data
, 32, val
);
215 START_TEST(test_read_uint64_end
)
217 chunk_t data
= chunk_from_chars(0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03,
218 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02,
219 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01,
220 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00);
223 assert_integer_read_end(data
, 64, val
);
224 assert_basic_read_end(64, val
);
225 assert_extended_read_end(data
, 64, val
);
229 /*******************************************************************************
233 static inline void assert_reader_after_read(bio_reader_t
*reader
, chunk_t data
)
237 ck_assert_int_eq(reader
->remaining(reader
), data
.len
);
238 peek
= reader
->peek(reader
);
239 ck_assert_int_eq(reader
->remaining(reader
), data
.len
);
240 ck_assert(peek
.ptr
== data
.ptr
);
241 data
.ptr
!= NULL
? ck_assert(chunk_equals(peek
, data
))
242 : ck_assert(peek
.ptr
== NULL
);
245 START_TEST(test_read_data
)
247 chunk_t read
, data
= chunk_from_chars(0x00, 0x00, 0x00, 0x00);
248 bio_reader_t
*reader
;
250 reader
= bio_reader_create(chunk_empty
);
251 ck_assert_int_eq(reader
->remaining(reader
), 0);
252 ck_assert(reader
->read_data(reader
, 0, &read
));
253 ck_assert(!reader
->read_data(reader
, 1, &read
));
254 reader
->destroy(reader
);
256 reader
= bio_reader_create(data
);
257 ck_assert(reader
->read_data(reader
, 0, &read
));
258 ck_assert_int_eq(read
.len
, 0);
259 ck_assert(read
.ptr
== data
.ptr
);
260 assert_reader_after_read(reader
, data
);
262 ck_assert(reader
->read_data(reader
, 1, &read
));
263 ck_assert_int_eq(read
.len
, 1);
264 ck_assert(read
.ptr
== data
.ptr
);
265 assert_reader_after_read(reader
, chunk_skip(data
, 1));
267 ck_assert(reader
->read_data(reader
, 2, &read
));
268 ck_assert_int_eq(read
.len
, 2);
269 ck_assert(read
.ptr
== data
.ptr
+ 1);
270 assert_reader_after_read(reader
, chunk_skip(data
, 3));
272 ck_assert(!reader
->read_data(reader
, 2, &read
));
273 ck_assert(reader
->read_data(reader
, 1, &read
));
274 ck_assert_int_eq(read
.len
, 1);
275 ck_assert(read
.ptr
== data
.ptr
+ 3);
276 assert_reader_after_read(reader
, chunk_skip(data
, 4));
278 ck_assert_int_eq(reader
->remaining(reader
), 0);
279 ck_assert(reader
->read_data(reader
, 0, &read
));
280 ck_assert(!reader
->read_data(reader
, 1, &read
));
281 reader
->destroy(reader
);
285 START_TEST(test_read_data_end
)
287 chunk_t read
, data
= chunk_from_chars(0x00, 0x00, 0x00, 0x00);
288 bio_reader_t
*reader
;
290 reader
= bio_reader_create(chunk_empty
);
291 ck_assert_int_eq(reader
->remaining(reader
), 0);
292 ck_assert(reader
->read_data_end(reader
, 0, &read
));
293 ck_assert(!reader
->read_data_end(reader
, 1, &read
));
294 reader
->destroy(reader
);
296 reader
= bio_reader_create(data
);
297 ck_assert(reader
->read_data_end(reader
, 0, &read
));
298 ck_assert_int_eq(read
.len
, 0);
299 ck_assert(read
.ptr
== data
.ptr
+ data
.len
);
300 assert_reader_after_read(reader
, data
);
302 ck_assert(reader
->read_data_end(reader
, 1, &read
));
303 ck_assert_int_eq(read
.len
, 1);
305 ck_assert(read
.ptr
== data
.ptr
+ data
.len
);
306 assert_reader_after_read(reader
, data
);
308 ck_assert(reader
->read_data_end(reader
, 2, &read
));
309 ck_assert_int_eq(read
.len
, 2);
311 ck_assert(read
.ptr
== data
.ptr
+ data
.len
);
312 assert_reader_after_read(reader
, data
);
314 ck_assert(!reader
->read_data(reader
, 2, &read
));
315 ck_assert(reader
->read_data(reader
, 1, &read
));
316 ck_assert_int_eq(read
.len
, 1);
317 ck_assert(read
.ptr
== data
.ptr
);
318 assert_reader_after_read(reader
, chunk_empty
);
320 ck_assert_int_eq(reader
->remaining(reader
), 0);
321 ck_assert(reader
->read_data(reader
, 0, &read
));
322 ck_assert(!reader
->read_data(reader
, 1, &read
));
323 reader
->destroy(reader
);
327 /*******************************************************************************
328 * read length followed by data
331 #define assert_read_data_len(bits) ({ \
332 bio_reader_t *reader; \
333 chunk_t read, data; \
334 int i, len = bits / 8; \
335 data = chunk_empty; \
336 reader = bio_reader_create(data); \
337 ck_assert(!reader->read_data##bits(reader, &read)); \
338 reader->destroy(reader); \
339 data = chunk_alloca(len + 8); \
340 memset(data.ptr, 0, data.len); \
341 for (i = 0; i <= 8; i++) \
343 data.ptr[len - 1] = i; \
344 data.len = len + i; \
345 reader = bio_reader_create(data); \
346 ck_assert(reader->read_data##bits(reader, &read)); \
347 ck_assert_int_eq(reader->remaining(reader), 0); \
348 ck_assert_int_eq(read.len, i); \
349 ck_assert((!read.ptr && !read.len) || (read.ptr == data.ptr + len)); \
350 reader->destroy(reader); \
352 data.ptr[len - 1] = i; \
353 reader = bio_reader_create(data); \
354 ck_assert(!reader->read_data##bits(reader, &read)); \
355 reader->destroy(reader); \
358 START_TEST(test_read_data8
)
360 assert_read_data_len(8);
364 START_TEST(test_read_data16
)
366 assert_read_data_len(16);
370 START_TEST(test_read_data24
)
372 assert_read_data_len(24);
376 START_TEST(test_read_data32
)
378 assert_read_data_len(32);
382 /*******************************************************************************
386 START_TEST(test_create
)
388 chunk_t data
= chunk_from_str("foobar");
389 bio_reader_t
*reader
;
391 data
= chunk_clone(data
);
392 reader
= bio_reader_create(data
);
393 reader
->destroy(reader
);
398 START_TEST(test_create_own
)
400 chunk_t data
= chunk_from_str("foobar");
401 bio_reader_t
*reader
;
403 data
= chunk_clone(data
);
404 reader
= bio_reader_create_own(data
);
405 reader
->destroy(reader
);
409 Suite
*bio_reader_suite_create()
414 s
= suite_create("bio_reader");
416 tc
= tcase_create("integer reads");
417 tcase_add_test(tc
, test_read_uint8
);
418 tcase_add_test(tc
, test_read_uint16
);
419 tcase_add_test(tc
, test_read_uint24
);
420 tcase_add_test(tc
, test_read_uint32
);
421 tcase_add_test(tc
, test_read_uint64
);
422 suite_add_tcase(s
, tc
);
424 tc
= tcase_create("integer reads from end");
425 tcase_add_test(tc
, test_read_uint8_end
);
426 tcase_add_test(tc
, test_read_uint16_end
);
427 tcase_add_test(tc
, test_read_uint24_end
);
428 tcase_add_test(tc
, test_read_uint32_end
);
429 tcase_add_test(tc
, test_read_uint64_end
);
430 suite_add_tcase(s
, tc
);
432 tc
= tcase_create("data reads and peek");
433 tcase_add_test(tc
, test_read_data
);
434 tcase_add_test(tc
, test_read_data_end
);
435 suite_add_tcase(s
, tc
);
437 tc
= tcase_create("data length reads");
438 tcase_add_test(tc
, test_read_data8
);
439 tcase_add_test(tc
, test_read_data16
);
440 tcase_add_test(tc
, test_read_data24
);
441 tcase_add_test(tc
, test_read_data32
);
442 suite_add_tcase(s
, tc
);
444 tc
= tcase_create("constructors");
445 tcase_add_test(tc
, test_create
);
446 tcase_add_test(tc
, test_create_own
);
447 suite_add_tcase(s
, tc
);