Annotation of embedaddon/strongswan/src/libstrongswan/tests/suites/test_bio_reader.c, revision 1.1
1.1 ! misho 1: /*
! 2: * Copyright (C) 2013 Tobias Brunner
! 3: * HSR Hochschule fuer Technik Rapperswil
! 4: *
! 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>.
! 9: *
! 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
! 13: * for more details.
! 14: */
! 15:
! 16: #include "test_suite.h"
! 17:
! 18: #include <bio/bio_reader.h>
! 19:
! 20: /*******************************************************************************
! 21: * different integer reads
! 22: */
! 23:
! 24: #define assert_integer_read(data, bits, val) ({ \
! 25: bio_reader_t *reader = bio_reader_create(data); \
! 26: typeof(val) i; \
! 27: for (i = 0; reader->remaining(reader) >= (bits / 8); i++) \
! 28: { \
! 29: ck_assert(reader->read_uint##bits(reader, &val)); \
! 30: ck_assert_int_eq(i, val); \
! 31: } \
! 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); \
! 36: })
! 37:
! 38: #define assert_integer_read_uneven(data, bits, val) ({ \
! 39: int i; \
! 40: for (i = 0; i <= bits / 8; i++, data.len++) \
! 41: { \
! 42: assert_integer_read(data, bits, val); \
! 43: } \
! 44: })
! 45:
! 46: #define assert_basic_read(bits, val) ({ \
! 47: chunk_t data; \
! 48: data = chunk_empty; \
! 49: assert_integer_read(data, bits, val); \
! 50: data = chunk_alloca(bits / 8); \
! 51: memset(data.ptr, 0, data.len); \
! 52: data.len = 0; \
! 53: assert_integer_read_uneven(data, bits, val); \
! 54: })
! 55:
! 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); \
! 63: })
! 64:
! 65: START_TEST(test_read_uint8)
! 66: {
! 67: chunk_t data = chunk_from_chars(0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07);
! 68: uint8_t val;
! 69:
! 70: assert_integer_read(data, 8, val);
! 71: assert_basic_read(8, val);
! 72: assert_extended_read(data, 8, val);
! 73: }
! 74: END_TEST
! 75:
! 76: START_TEST(test_read_uint16)
! 77: {
! 78: chunk_t data = chunk_from_chars(0x00, 0x00, 0x00, 0x01, 0x00, 0x02, 0x00, 0x03);
! 79: uint16_t val;
! 80:
! 81: assert_integer_read(data, 16, val);
! 82: assert_basic_read(16, val);
! 83: assert_extended_read(data, 16, val);
! 84: }
! 85: END_TEST
! 86:
! 87: START_TEST(test_read_uint24)
! 88: {
! 89: chunk_t data = chunk_from_chars(0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x02, 0x00, 0x00, 0x03);
! 90: uint32_t val;
! 91:
! 92: assert_integer_read(data, 24, val);
! 93: assert_basic_read(24, val);
! 94: assert_extended_read(data, 24, val);
! 95: }
! 96: END_TEST
! 97:
! 98: START_TEST(test_read_uint32)
! 99: {
! 100: chunk_t data = chunk_from_chars(0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01,
! 101: 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x03);
! 102: uint32_t val;
! 103:
! 104: assert_integer_read(data, 32, val);
! 105: assert_basic_read(32, val);
! 106: assert_extended_read(data, 32, val);
! 107: }
! 108: END_TEST
! 109:
! 110: START_TEST(test_read_uint64)
! 111: {
! 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);
! 116: uint64_t val;
! 117:
! 118: assert_integer_read(data, 64, val);
! 119: assert_basic_read(64, val);
! 120: assert_extended_read(data, 64, val);
! 121: }
! 122: END_TEST
! 123:
! 124: /*******************************************************************************
! 125: * different integer reads from the end of a buffer
! 126: */
! 127:
! 128: #define assert_integer_read_end(data, bits, val) ({ \
! 129: bio_reader_t *reader = bio_reader_create(data); \
! 130: typeof(val) i; \
! 131: for (i = 0; reader->remaining(reader) >= (bits / 8); i++) \
! 132: { \
! 133: ck_assert(reader->read_uint##bits##_end(reader, &val)); \
! 134: ck_assert_int_eq(i, val); \
! 135: } \
! 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); \
! 140: })
! 141:
! 142: #define assert_integer_read_end_uneven(data, bits, val) ({ \
! 143: int i; \
! 144: data.ptr += bits / 8; \
! 145: for (i = 0; i <= bits / 8; i++, data.ptr--, data.len++) \
! 146: { \
! 147: assert_integer_read_end(data, bits, val); \
! 148: } \
! 149: })
! 150:
! 151: #define assert_basic_read_end(bits, val) ({ \
! 152: chunk_t data; \
! 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); \
! 157: data.len = 0; \
! 158: assert_integer_read_end_uneven(data, bits, val); \
! 159: })
! 160:
! 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); \
! 168: })
! 169:
! 170: START_TEST(test_read_uint8_end)
! 171: {
! 172: chunk_t data = chunk_from_chars(0x07, 0x06, 0x05, 0x04, 0x03, 0x02, 0x01, 0x00);
! 173: uint8_t val;
! 174:
! 175: assert_integer_read_end(data, 8, val);
! 176: assert_basic_read_end(8, val);
! 177: assert_extended_read_end(data, 8, val);
! 178: }
! 179: END_TEST
! 180:
! 181: START_TEST(test_read_uint16_end)
! 182: {
! 183: chunk_t data = chunk_from_chars(0x00, 0x03, 0x00, 0x02, 0x00, 0x01, 0x00, 0x00);
! 184: uint16_t val;
! 185:
! 186: assert_integer_read_end(data, 16, val);
! 187: assert_basic_read_end(16, val);
! 188: assert_extended_read_end(data, 16, val);
! 189: }
! 190: END_TEST
! 191:
! 192: START_TEST(test_read_uint24_end)
! 193: {
! 194: chunk_t data = chunk_from_chars(0x00, 0x00, 0x03, 0x00, 0x00, 0x02, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00);
! 195: uint32_t val;
! 196:
! 197: assert_integer_read_end(data, 24, val);
! 198: assert_basic_read_end(24, val);
! 199: assert_extended_read_end(data, 24, val);
! 200: }
! 201: END_TEST
! 202:
! 203: START_TEST(test_read_uint32_end)
! 204: {
! 205: chunk_t data = chunk_from_chars(0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x02,
! 206: 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00);
! 207: uint32_t val;
! 208:
! 209: assert_integer_read_end(data, 32, val);
! 210: assert_basic_read_end(32, val);
! 211: assert_extended_read_end(data, 32, val);
! 212: }
! 213: END_TEST
! 214:
! 215: START_TEST(test_read_uint64_end)
! 216: {
! 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);
! 221: uint64_t val;
! 222:
! 223: assert_integer_read_end(data, 64, val);
! 224: assert_basic_read_end(64, val);
! 225: assert_extended_read_end(data, 64, val);
! 226: }
! 227: END_TEST
! 228:
! 229: /*******************************************************************************
! 230: * read data
! 231: */
! 232:
! 233: static inline void assert_reader_after_read(bio_reader_t *reader, chunk_t data)
! 234: {
! 235: chunk_t peek;
! 236:
! 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);
! 243: }
! 244:
! 245: START_TEST(test_read_data)
! 246: {
! 247: chunk_t read, data = chunk_from_chars(0x00, 0x00, 0x00, 0x00);
! 248: bio_reader_t *reader;
! 249:
! 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);
! 255:
! 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);
! 261:
! 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));
! 266:
! 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));
! 271:
! 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));
! 277:
! 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);
! 282: }
! 283: END_TEST
! 284:
! 285: START_TEST(test_read_data_end)
! 286: {
! 287: chunk_t read, data = chunk_from_chars(0x00, 0x00, 0x00, 0x00);
! 288: bio_reader_t *reader;
! 289:
! 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);
! 295:
! 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);
! 301:
! 302: ck_assert(reader->read_data_end(reader, 1, &read));
! 303: ck_assert_int_eq(read.len, 1);
! 304: data.len--;
! 305: ck_assert(read.ptr == data.ptr + data.len);
! 306: assert_reader_after_read(reader, data);
! 307:
! 308: ck_assert(reader->read_data_end(reader, 2, &read));
! 309: ck_assert_int_eq(read.len, 2);
! 310: data.len -= 2;
! 311: ck_assert(read.ptr == data.ptr + data.len);
! 312: assert_reader_after_read(reader, data);
! 313:
! 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);
! 319:
! 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);
! 324: }
! 325: END_TEST
! 326:
! 327: /*******************************************************************************
! 328: * read length followed by data
! 329: */
! 330:
! 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++) \
! 342: { \
! 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); \
! 351: } \
! 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); \
! 356: })
! 357:
! 358: START_TEST(test_read_data8)
! 359: {
! 360: assert_read_data_len(8);
! 361: }
! 362: END_TEST
! 363:
! 364: START_TEST(test_read_data16)
! 365: {
! 366: assert_read_data_len(16);
! 367: }
! 368: END_TEST
! 369:
! 370: START_TEST(test_read_data24)
! 371: {
! 372: assert_read_data_len(24);
! 373: }
! 374: END_TEST
! 375:
! 376: START_TEST(test_read_data32)
! 377: {
! 378: assert_read_data_len(32);
! 379: }
! 380: END_TEST
! 381:
! 382: /*******************************************************************************
! 383: * test constructors
! 384: */
! 385:
! 386: START_TEST(test_create)
! 387: {
! 388: chunk_t data = chunk_from_str("foobar");
! 389: bio_reader_t *reader;
! 390:
! 391: data = chunk_clone(data);
! 392: reader = bio_reader_create(data);
! 393: reader->destroy(reader);
! 394: chunk_free(&data);
! 395: }
! 396: END_TEST
! 397:
! 398: START_TEST(test_create_own)
! 399: {
! 400: chunk_t data = chunk_from_str("foobar");
! 401: bio_reader_t *reader;
! 402:
! 403: data = chunk_clone(data);
! 404: reader = bio_reader_create_own(data);
! 405: reader->destroy(reader);
! 406: }
! 407: END_TEST
! 408:
! 409: Suite *bio_reader_suite_create()
! 410: {
! 411: Suite *s;
! 412: TCase *tc;
! 413:
! 414: s = suite_create("bio_reader");
! 415:
! 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);
! 423:
! 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);
! 431:
! 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);
! 436:
! 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);
! 443:
! 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);
! 448:
! 449: return s;
! 450: }
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>
![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to test_bio_reader.c CVS log ![[TXT]](/icons/cvsweb/text.gif){kind=icon}
![[DIR]](/icons/cvsweb/dir.gif){kind=icon}
Up to [ELWIX - Embedded LightWeight unIX -] / embedaddon / strongswan / src / libstrongswan / tests / suites