Annotation of embedaddon/strongswan/src/libstrongswan/tests/suites/test_chunk.c, revision 1.1
1.1 ! misho 1: /*
! 2: * Copyright (C) 2013 Tobias Brunner
! 3: * Copyright (C) 2008 Martin Willi
! 4: * HSR Hochschule fuer Technik Rapperswil
! 5: *
! 6: * This program is free software; you can redistribute it and/or modify it
! 7: * under the terms of the GNU General Public License as published by the
! 8: * Free Software Foundation; either version 2 of the License, or (at your
! 9: * option) any later version. See <http://www.fsf.org/copyleft/gpl.txt>.
! 10: *
! 11: * This program is distributed in the hope that it will be useful, but
! 12: * WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
! 13: * or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
! 14: * for more details.
! 15: */
! 16:
! 17: #include "test_suite.h"
! 18:
! 19: #include <unistd.h>
! 20: #include <sys/types.h>
! 21: #include <sys/stat.h>
! 22: #include <fcntl.h>
! 23: #include <errno.h>
! 24:
! 25: #include <utils/chunk.h>
! 26: #include <threading/thread.h>
! 27:
! 28: /*******************************************************************************
! 29: * utilities
! 30: */
! 31:
! 32: static void assert_chunk_empty(chunk_t chunk)
! 33: {
! 34: ck_assert(chunk.len == 0 && chunk.ptr == NULL);
! 35: }
! 36:
! 37: /*******************************************************************************
! 38: * equals
! 39: */
! 40:
! 41: START_TEST(test_chunk_equals)
! 42: {
! 43: chunk_t chunk = chunk_from_str("chunk");
! 44: chunk_t chunk_a, chunk_b;
! 45:
! 46: chunk_a = chunk_empty;
! 47: chunk_b = chunk_empty;
! 48: ck_assert(!chunk_equals(chunk_a, chunk_b));
! 49:
! 50: chunk_a = chunk;
! 51: ck_assert(!chunk_equals(chunk_a, chunk_b));
! 52: chunk_b = chunk;
! 53: ck_assert(chunk_equals(chunk_a, chunk_b));
! 54:
! 55: chunk_b = chunk_from_str("asdf");
! 56: ck_assert(!chunk_equals(chunk_a, chunk_b));
! 57:
! 58: chunk_b = chunk_from_str("chunk");
! 59: ck_assert(chunk_equals(chunk_a, chunk_b));
! 60: }
! 61: END_TEST
! 62:
! 63: /*******************************************************************************
! 64: * equals_const
! 65: */
! 66:
! 67: START_TEST(test_chunk_equals_const)
! 68: {
! 69: chunk_t chunk = chunk_from_str("chunk");
! 70: chunk_t chunk_a, chunk_b;
! 71:
! 72: chunk_a = chunk_empty;
! 73: chunk_b = chunk_empty;
! 74: ck_assert(!chunk_equals_const(chunk_a, chunk_b));
! 75:
! 76: chunk_a = chunk;
! 77: ck_assert(!chunk_equals_const(chunk_a, chunk_b));
! 78: chunk_b = chunk;
! 79: ck_assert(chunk_equals_const(chunk_a, chunk_b));
! 80:
! 81: chunk_b = chunk_from_str("asdf");
! 82: ck_assert(!chunk_equals_const(chunk_a, chunk_b));
! 83:
! 84: chunk_b = chunk_from_str("chunk");
! 85: ck_assert(chunk_equals_const(chunk_a, chunk_b));
! 86: }
! 87: END_TEST
! 88:
! 89: /*******************************************************************************
! 90: * chunk_compare test
! 91: */
! 92:
! 93: static struct {
! 94: int result;
! 95: chunk_t a;
! 96: chunk_t b;
! 97: } compare_data[] = {
! 98: { 0, { NULL, 0 }, { NULL, 0 }},
! 99: { 0, chunk_from_chars(0x00), chunk_from_chars(0x00)},
! 100: {-1, chunk_from_chars(0x00), chunk_from_chars(0x01)},
! 101: { 1, chunk_from_chars(0x01), chunk_from_chars(0x00)},
! 102: { 0, chunk_from_chars(0x00, 0x00), chunk_from_chars(0x00, 0x00)},
! 103: {-1, chunk_from_chars(0x00, 0x00), chunk_from_chars(0x00, 0x01)},
! 104: { 1, chunk_from_chars(0x00, 0x01), chunk_from_chars(0x00, 0x00)},
! 105: {-1, chunk_from_chars(0x00, 0x00), chunk_from_chars(0x01, 0x00)},
! 106: { 1, chunk_from_chars(0x01, 0x00), chunk_from_chars(0x00, 0x00)},
! 107: {-1, chunk_from_chars(0xff), chunk_from_chars(0x00, 0x00)},
! 108: { 1, chunk_from_chars(0x00, 0x00), chunk_from_chars(0xff)},
! 109: };
! 110:
! 111: START_TEST(test_compare)
! 112: {
! 113: int result, expected;
! 114:
! 115: result = chunk_compare(compare_data[_i].a, compare_data[_i].b);
! 116: expected = compare_data[_i].result;
! 117: ck_assert((result == 0 && expected == 0) ||
! 118: (result < 0 && expected < 0) ||
! 119: (result > 0 && expected > 0));
! 120: }
! 121: END_TEST
! 122:
! 123: /*******************************************************************************
! 124: * clear
! 125: */
! 126:
! 127: START_TEST(test_chunk_clear)
! 128: {
! 129: chunk_t chunk;
! 130: u_char *ptr;
! 131: int i;
! 132: bool cleared = TRUE;
! 133:
! 134: chunk = chunk_empty;
! 135: chunk_clear(&chunk);
! 136: chunk_free(&chunk);
! 137:
! 138: chunk = chunk_alloc(64);
! 139: ptr = chunk.ptr;
! 140: for (i = 0; i < 64; i++)
! 141: {
! 142: chunk.ptr[i] = i;
! 143: }
! 144: chunk_clear(&chunk);
! 145: /* check memory area of freed chunk. We can't use ck_assert() for this
! 146: * test directly, as it might allocate data at the freed area. comparing
! 147: * two bytes at once reduces the chances of conflicts if memory got
! 148: * overwritten already */
! 149: for (i = 0; i < 64; i += 2)
! 150: {
! 151: if (ptr[i] != 0 && ptr[i] == i &&
! 152: ptr[i+1] != 0 && ptr[i+1] == i+1)
! 153: {
! 154: cleared = FALSE;
! 155: break;
! 156: }
! 157: }
! 158: assert_chunk_empty(chunk);
! 159: ck_assert(cleared);
! 160: }
! 161: END_TEST
! 162:
! 163: /*******************************************************************************
! 164: * chunk_length
! 165: */
! 166:
! 167: START_TEST(test_chunk_length)
! 168: {
! 169: chunk_t a, b, c;
! 170: size_t len;
! 171:
! 172: a = chunk_empty;
! 173: b = chunk_empty;
! 174: c = chunk_empty;
! 175: len = chunk_length("ccc", a, b, c);
! 176: ck_assert_int_eq(len, 0);
! 177:
! 178: a = chunk_from_str("foo");
! 179: b = chunk_from_str("bar");
! 180: len = chunk_length("ccc", a, b, c);
! 181: ck_assert_int_eq(len, 6);
! 182:
! 183: len = chunk_length("zcc", a, b, c);
! 184: ck_assert_int_eq(len, 0);
! 185:
! 186: len = chunk_length("czc", a, b, c);
! 187: ck_assert_int_eq(len, 3);
! 188:
! 189: a = chunk_from_str("foo");
! 190: b = chunk_from_str("bar");
! 191: c = chunk_from_str("baz");
! 192: len = chunk_length("ccc", a, b, c);
! 193: ck_assert_int_eq(len, 9);
! 194: }
! 195: END_TEST
! 196:
! 197: /*******************************************************************************
! 198: * chunk_create_cat
! 199: */
! 200:
! 201: START_TEST(test_chunk_create_cat)
! 202: {
! 203: chunk_t foo, bar;
! 204: chunk_t a, b, c;
! 205: u_char *ptra, *ptrb;
! 206:
! 207: foo = chunk_from_str("foo");
! 208: bar = chunk_from_str("bar");
! 209:
! 210: /* to simplify things we use the chunk_cata macro */
! 211:
! 212: a = chunk_empty;
! 213: b = chunk_empty;
! 214: c = chunk_cata("cc", a, b);
! 215: ck_assert_int_eq(c.len, 0);
! 216: ck_assert(c.ptr != NULL);
! 217:
! 218: a = foo;
! 219: b = bar;
! 220: c = chunk_cata("cc", a, b);
! 221: ck_assert_int_eq(c.len, 6);
! 222: ck_assert(chunk_equals(c, chunk_from_str("foobar")));
! 223:
! 224: a = chunk_clone(foo);
! 225: b = chunk_clone(bar);
! 226: c = chunk_cata("mm", a, b);
! 227: ck_assert_int_eq(c.len, 6);
! 228: ck_assert(chunk_equals(c, chunk_from_str("foobar")));
! 229:
! 230: a = chunk_clone(foo);
! 231: b = chunk_clone(bar);
! 232: ptra = a.ptr;
! 233: ptrb = b.ptr;
! 234: c = chunk_cata("ss", a, b);
! 235: ck_assert_int_eq(c.len, 6);
! 236: ck_assert(chunk_equals(c, chunk_from_str("foobar")));
! 237: /* check memory area of cleared chunk */
! 238: ck_assert(!chunk_equals(foo, chunk_create(ptra, 3)));
! 239: ck_assert(!chunk_equals(bar, chunk_create(ptrb, 3)));
! 240: }
! 241: END_TEST
! 242:
! 243: /*******************************************************************************
! 244: * chunk_split
! 245: */
! 246:
! 247: static bool mem_in_chunk(u_char *ptr, chunk_t chunk)
! 248: {
! 249: return ptr >= chunk.ptr && ptr < (chunk.ptr + chunk.len);
! 250: }
! 251:
! 252: START_TEST(test_chunk_split)
! 253: {
! 254: chunk_t foo, bar, foobar;
! 255: chunk_t a, b, c;
! 256: u_char *ptra, *ptrb;
! 257:
! 258: foo = chunk_from_str("foo");
! 259: bar = chunk_from_str("bar");
! 260: foobar = chunk_from_str("foobar");
! 261:
! 262: chunk_split(foobar, "aa", 3, &a, 3, &b);
! 263: ck_assert(chunk_equals(a, foo));
! 264: ck_assert(chunk_equals(b, bar));
! 265: ck_assert(!mem_in_chunk(a.ptr, foobar));
! 266: ck_assert(!mem_in_chunk(b.ptr, foobar));
! 267: chunk_free(&a);
! 268: chunk_free(&b);
! 269:
! 270: chunk_split(foobar, "mm", 3, &a, 3, &b);
! 271: ck_assert(chunk_equals(a, foo));
! 272: ck_assert(chunk_equals(b, bar));
! 273: ck_assert(mem_in_chunk(a.ptr, foobar));
! 274: ck_assert(mem_in_chunk(b.ptr, foobar));
! 275:
! 276: chunk_split(foobar, "am", 3, &a, 3, &b);
! 277: ck_assert(chunk_equals(a, foo));
! 278: ck_assert(chunk_equals(b, bar));
! 279: ck_assert(!mem_in_chunk(a.ptr, foobar));
! 280: ck_assert(mem_in_chunk(b.ptr, foobar));
! 281: chunk_free(&a);
! 282:
! 283: a = chunk_alloca(3);
! 284: ptra = a.ptr;
! 285: b = chunk_alloca(3);
! 286: ptrb = b.ptr;
! 287: chunk_split(foobar, "cc", 3, &a, 3, &b);
! 288: ck_assert(chunk_equals(a, foo));
! 289: ck_assert(chunk_equals(b, bar));
! 290: ck_assert(a.ptr == ptra);
! 291: ck_assert(b.ptr == ptrb);
! 292:
! 293: chunk_split(foobar, "mm", 1, NULL, 2, &a, 2, NULL, 1, &b);
! 294: ck_assert(chunk_equals(a, chunk_from_str("oo")));
! 295: ck_assert(chunk_equals(b, chunk_from_str("r")));
! 296:
! 297: chunk_split(foobar, "mm", 6, &a, 6, &b);
! 298: ck_assert(chunk_equals(a, foobar));
! 299: assert_chunk_empty(b);
! 300:
! 301: chunk_split(foobar, "mac", 12, &a, 12, &b, 12, &c);
! 302: ck_assert(chunk_equals(a, foobar));
! 303: assert_chunk_empty(b);
! 304: assert_chunk_empty(c);
! 305: }
! 306: END_TEST
! 307:
! 308: /*******************************************************************************
! 309: * chunk_skip[_zero]
! 310: */
! 311:
! 312: START_TEST(test_chunk_skip)
! 313: {
! 314: chunk_t foobar, a;
! 315:
! 316: foobar = chunk_from_str("foobar");
! 317: a = foobar;
! 318: a = chunk_skip(a, 0);
! 319: ck_assert_chunk_eq(a, foobar);
! 320: a = chunk_skip(a, 1);
! 321: ck_assert_chunk_eq(a, chunk_from_str("oobar"));
! 322: a = chunk_skip(a, 2);
! 323: ck_assert_chunk_eq(a, chunk_from_str("bar"));
! 324: a = chunk_skip(a, 3);
! 325: assert_chunk_empty(a);
! 326:
! 327: a = foobar;
! 328: a = chunk_skip(a, 6);
! 329: assert_chunk_empty(a);
! 330:
! 331: a = foobar;
! 332: a = chunk_skip(a, 10);
! 333: assert_chunk_empty(a);
! 334: }
! 335: END_TEST
! 336:
! 337: START_TEST(test_chunk_skip_zero)
! 338: {
! 339: chunk_t foobar, a;
! 340:
! 341: a = chunk_skip_zero(chunk_empty);
! 342: assert_chunk_empty(a);
! 343:
! 344: foobar = chunk_from_str("foobar");
! 345: a = chunk_skip_zero(foobar);
! 346: ck_assert_chunk_eq(a, foobar);
! 347:
! 348: foobar = chunk_from_chars(0x00);
! 349: a = chunk_skip_zero(foobar);
! 350: ck_assert_chunk_eq(a, foobar);
! 351:
! 352: a = chunk_skip_zero(chunk_from_chars(0x00, 0xaa, 0xbb, 0xcc));
! 353: ck_assert_chunk_eq(a, chunk_from_chars(0xaa, 0xbb, 0xcc));
! 354: a = chunk_skip_zero(a);
! 355: ck_assert_chunk_eq(a, chunk_from_chars(0xaa, 0xbb, 0xcc));
! 356:
! 357: a = chunk_skip_zero(chunk_from_chars(0x00, 0x00, 0xaa, 0xbb, 0xcc));
! 358: ck_assert_chunk_eq(a, chunk_from_chars(0xaa, 0xbb, 0xcc));
! 359: }
! 360: END_TEST
! 361:
! 362: /*******************************************************************************
! 363: * BASE16 encoding test
! 364: */
! 365:
! 366: START_TEST(test_base16)
! 367: {
! 368: /* test vectors from RFC 4648:
! 369: *
! 370: * BASE16("") = ""
! 371: * BASE16("f") = "66"
! 372: * BASE16("fo") = "666F"
! 373: * BASE16("foo") = "666F6F"
! 374: * BASE16("foob") = "666F6F62"
! 375: * BASE16("fooba") = "666F6F6261"
! 376: * BASE16("foobar") = "666F6F626172"
! 377: */
! 378: typedef struct {
! 379: bool upper;
! 380: char *in;
! 381: char *out;
! 382: } testdata_t;
! 383:
! 384: testdata_t test[] = {
! 385: {TRUE, "", ""},
! 386: {TRUE, "f", "66"},
! 387: {TRUE, "fo", "666F"},
! 388: {TRUE, "foo", "666F6F"},
! 389: {TRUE, "foob", "666F6F62"},
! 390: {TRUE, "fooba", "666F6F6261"},
! 391: {TRUE, "foobar", "666F6F626172"},
! 392: {FALSE, "", ""},
! 393: {FALSE, "f", "66"},
! 394: {FALSE, "fo", "666f"},
! 395: {FALSE, "foo", "666f6f"},
! 396: {FALSE, "foob", "666f6f62"},
! 397: {FALSE, "fooba", "666f6f6261"},
! 398: {FALSE, "foobar", "666f6f626172"},
! 399: };
! 400: testdata_t test_prefix_colon[] = {
! 401: {TRUE, "", "0x"},
! 402: {TRUE, "f", "0x66"},
! 403: {TRUE, "fo", "66:6F"},
! 404: {TRUE, "foo", "0x66:6F:6F"},
! 405: {FALSE, "foob", "66:6f:6f:62"},
! 406: {FALSE, "fooba", "0x66:6f:6f:62:61"},
! 407: {FALSE, "foobar", "66:6f:6f:62:61:72"},
! 408: {FALSE, "foobar", "0x66:6f6f:6261:72"},
! 409: };
! 410: int i;
! 411:
! 412: for (i = 0; i < countof(test); i++)
! 413: {
! 414: chunk_t out;
! 415:
! 416: out = chunk_to_hex(chunk_create(test[i].in, strlen(test[i].in)), NULL,
! 417: test[i].upper);
! 418: ck_assert_str_eq(out.ptr, test[i].out);
! 419: free(out.ptr);
! 420: }
! 421:
! 422: for (i = 0; i < countof(test); i++)
! 423: {
! 424: chunk_t out;
! 425:
! 426: out = chunk_from_hex(chunk_create(test[i].out, strlen(test[i].out)), NULL);
! 427: fail_unless(strneq(out.ptr, test[i].in, out.len),
! 428: "base16 conversion error - should '%s', is %#B",
! 429: test[i].in, &out);
! 430: free(out.ptr);
! 431: }
! 432:
! 433: for (i = 0; i < countof(test_prefix_colon); i++)
! 434: {
! 435: chunk_t out;
! 436:
! 437: out = chunk_from_hex(chunk_create(test_prefix_colon[i].out,
! 438: strlen(test_prefix_colon[i].out)), NULL);
! 439: fail_unless(strneq(out.ptr, test_prefix_colon[i].in, out.len),
! 440: "base16 conversion error - should '%s', is %#B",
! 441: test_prefix_colon[i].in, &out);
! 442: free(out.ptr);
! 443: }
! 444: }
! 445: END_TEST
! 446:
! 447: /*******************************************************************************
! 448: * BASE64 encoding test
! 449: */
! 450:
! 451: START_TEST(test_base64)
! 452: {
! 453: /* test vectors from RFC 4648:
! 454: *
! 455: * BASE64("") = ""
! 456: * BASE64("f") = "Zg=="
! 457: * BASE64("fo") = "Zm8="
! 458: * BASE64("foo") = "Zm9v"
! 459: * BASE64("foob") = "Zm9vYg=="
! 460: * BASE64("fooba") = "Zm9vYmE="
! 461: * BASE64("foobar") = "Zm9vYmFy"
! 462: */
! 463: typedef struct {
! 464: char *in;
! 465: char *out;
! 466: } testdata_t;
! 467:
! 468: testdata_t test[] = {
! 469: {"", ""},
! 470: {"f", "Zg=="},
! 471: {"fo", "Zm8="},
! 472: {"foo", "Zm9v"},
! 473: {"foob", "Zm9vYg=="},
! 474: {"fooba", "Zm9vYmE="},
! 475: {"foobar", "Zm9vYmFy"},
! 476: };
! 477: int i;
! 478:
! 479: for (i = 0; i < countof(test); i++)
! 480: {
! 481: chunk_t out;
! 482:
! 483: out = chunk_to_base64(chunk_create(test[i].in, strlen(test[i].in)), NULL);
! 484: ck_assert_str_eq(out.ptr, test[i].out);
! 485: free(out.ptr);
! 486: }
! 487:
! 488: for (i = 0; i < countof(test); i++)
! 489: {
! 490: chunk_t out;
! 491:
! 492: out = chunk_from_base64(chunk_create(test[i].out, strlen(test[i].out)), NULL);
! 493: fail_unless(strneq(out.ptr, test[i].in, out.len),
! 494: "base64 conversion error - should '%s', is %#B",
! 495: test[i].in, &out);
! 496: free(out.ptr);
! 497: }
! 498: }
! 499: END_TEST
! 500:
! 501: /*******************************************************************************
! 502: * BASE32 encoding test
! 503: */
! 504:
! 505: START_TEST(test_base32)
! 506: {
! 507: /* test vectors from RFC 4648:
! 508: *
! 509: * BASE32("") = ""
! 510: * BASE32("f") = "MY======"
! 511: * BASE32("fo") = "MZXQ===="
! 512: * BASE32("foo") = "MZXW6==="
! 513: * BASE32("foob") = "MZXW6YQ="
! 514: * BASE32("fooba") = "MZXW6YTB"
! 515: * BASE32("foobar") = "MZXW6YTBOI======"
! 516: */
! 517: typedef struct {
! 518: char *in;
! 519: char *out;
! 520: } testdata_t;
! 521:
! 522: testdata_t test[] = {
! 523: {"", ""},
! 524: {"f", "MY======"},
! 525: {"fo", "MZXQ===="},
! 526: {"foo", "MZXW6==="},
! 527: {"foob", "MZXW6YQ="},
! 528: {"fooba", "MZXW6YTB"},
! 529: {"foobar", "MZXW6YTBOI======"},
! 530: };
! 531: int i;
! 532:
! 533: for (i = 0; i < countof(test); i++)
! 534: {
! 535: chunk_t out;
! 536:
! 537: out = chunk_to_base32(chunk_create(test[i].in, strlen(test[i].in)), NULL);
! 538: ck_assert_str_eq(out.ptr, test[i].out);
! 539: free(out.ptr);
! 540: }
! 541: }
! 542: END_TEST
! 543:
! 544: /*******************************************************************************
! 545: * chunk_increment test
! 546: */
! 547:
! 548: static struct {
! 549: bool overflow;
! 550: chunk_t in;
! 551: chunk_t out;
! 552: } increment_data[] = {
! 553: {TRUE, { NULL, 0 }, { NULL, 0 }},
! 554: {FALSE, chunk_from_chars(0x00), chunk_from_chars(0x01)},
! 555: {FALSE, chunk_from_chars(0xfe), chunk_from_chars(0xff)},
! 556: {TRUE, chunk_from_chars(0xff), chunk_from_chars(0x00)},
! 557: {FALSE, chunk_from_chars(0x00, 0x00), chunk_from_chars(0x00, 0x01)},
! 558: {FALSE, chunk_from_chars(0x00, 0xff), chunk_from_chars(0x01, 0x00)},
! 559: {FALSE, chunk_from_chars(0xfe, 0xff), chunk_from_chars(0xff, 0x00)},
! 560: {TRUE, chunk_from_chars(0xff, 0xff), chunk_from_chars(0x00, 0x00)},
! 561: };
! 562:
! 563: START_TEST(test_increment)
! 564: {
! 565: chunk_t chunk;
! 566: bool overflow;
! 567:
! 568: chunk = chunk_clonea(increment_data[_i].in);
! 569: overflow = chunk_increment(chunk);
! 570: ck_assert(overflow == increment_data[_i].overflow);
! 571: ck_assert(!increment_data[_i].out.ptr ||
! 572: chunk_equals(chunk, increment_data[_i].out));
! 573: }
! 574: END_TEST
! 575:
! 576: /*******************************************************************************
! 577: * chunk_copy_pad tests
! 578: */
! 579:
! 580: static struct {
! 581: size_t len;
! 582: u_char chr;
! 583: chunk_t src;
! 584: chunk_t exp;
! 585: } copy_pad_data[] = {
! 586: {0, 0x00, { NULL, 0 }, { NULL, 0 }},
! 587: {4, 0x00, { NULL, 0 }, chunk_from_chars(0x00,0x00,0x00,0x00)},
! 588: {0, 0x00, chunk_from_chars(0x01), { NULL, 0 }},
! 589: {1, 0x00, chunk_from_chars(0x01), chunk_from_chars(0x01)},
! 590: {2, 0x00, chunk_from_chars(0x01), chunk_from_chars(0x00,0x01)},
! 591: {3, 0x00, chunk_from_chars(0x01), chunk_from_chars(0x00,0x00,0x01)},
! 592: {4, 0x00, chunk_from_chars(0x01), chunk_from_chars(0x00,0x00,0x00,0x01)},
! 593: {4, 0x02, chunk_from_chars(0x01), chunk_from_chars(0x02,0x02,0x02,0x01)},
! 594: {1, 0x00, chunk_from_chars(0x01,0x02,0x03,0x04), chunk_from_chars(0x04)},
! 595: {2, 0x00, chunk_from_chars(0x01,0x02,0x03,0x04), chunk_from_chars(0x03,0x04)},
! 596: {3, 0x00, chunk_from_chars(0x01,0x02,0x03,0x04), chunk_from_chars(0x02,0x03,0x04)},
! 597: {4, 0x00, chunk_from_chars(0x01,0x02,0x03,0x04), chunk_from_chars(0x01,0x02,0x03,0x04)},
! 598: };
! 599:
! 600: START_TEST(test_copy_pad)
! 601: {
! 602: chunk_t chunk;
! 603:
! 604: chunk = chunk_copy_pad(chunk_alloca(copy_pad_data[_i].len),
! 605: copy_pad_data[_i].src, copy_pad_data[_i].chr);
! 606: ck_assert_chunk_eq(chunk, copy_pad_data[_i].exp);
! 607: }
! 608: END_TEST
! 609:
! 610: /*******************************************************************************
! 611: * chunk_printable tests
! 612: */
! 613:
! 614: static struct {
! 615: bool printable;
! 616: chunk_t in;
! 617: char *out;
! 618: } printable_data[] = {
! 619: {TRUE, chunk_from_chars(0x31), "1"},
! 620: {FALSE, chunk_from_chars(0x00), "?"},
! 621: {FALSE, chunk_from_chars(0x31, 0x00), "1?"},
! 622: {FALSE, chunk_from_chars(0x00, 0x31), "?1"},
! 623: {TRUE, chunk_from_chars(0x3f, 0x31), "?1"},
! 624: {FALSE, chunk_from_chars(0x00, 0x31, 0x00), "?1?"},
! 625: {FALSE, chunk_from_chars(0x00, 0x31, 0x00, 0x32), "?1?2"},
! 626: };
! 627:
! 628: START_TEST(test_printable)
! 629: {
! 630: bool printable;
! 631:
! 632: printable = chunk_printable(printable_data[_i].in, NULL, ' ');
! 633: ck_assert(printable == printable_data[_i].printable);
! 634: }
! 635: END_TEST
! 636:
! 637: START_TEST(test_printable_sanitize)
! 638: {
! 639: chunk_t sane, expected;
! 640: bool printable;
! 641:
! 642: printable = chunk_printable(printable_data[_i].in, &sane, '?');
! 643: ck_assert(printable == printable_data[_i].printable);
! 644: expected = chunk_from_str(printable_data[_i].out);
! 645: ck_assert(chunk_equals(sane, expected));
! 646: chunk_free(&sane);
! 647: }
! 648: END_TEST
! 649:
! 650: START_TEST(test_printable_empty)
! 651: {
! 652: chunk_t sane;
! 653: bool printable;
! 654:
! 655: printable = chunk_printable(chunk_empty, NULL, ' ');
! 656: ck_assert(printable);
! 657:
! 658: sane.ptr = (void*)1;
! 659: sane.len = 1;
! 660: printable = chunk_printable(chunk_empty, &sane, ' ');
! 661: ck_assert(printable);
! 662: assert_chunk_empty(sane);
! 663: }
! 664: END_TEST
! 665:
! 666: /*******************************************************************************
! 667: * test for chunk_mac(), i.e. SipHash-2-4
! 668: */
! 669:
! 670: /**
! 671: * SipHash-2-4 output with
! 672: * k = 00 01 02 ...
! 673: * and
! 674: * in = (empty string)
! 675: * in = 00 (1 byte)
! 676: * in = 00 01 (2 bytes)
! 677: * in = 00 01 02 (3 bytes)
! 678: * ...
! 679: * in = 00 01 02 ... 3e (63 bytes)
! 680: */
! 681: static const u_char sip_vectors[64][8] =
! 682: {
! 683: { 0x31, 0x0e, 0x0e, 0xdd, 0x47, 0xdb, 0x6f, 0x72, },
! 684: { 0xfd, 0x67, 0xdc, 0x93, 0xc5, 0x39, 0xf8, 0x74, },
! 685: { 0x5a, 0x4f, 0xa9, 0xd9, 0x09, 0x80, 0x6c, 0x0d, },
! 686: { 0x2d, 0x7e, 0xfb, 0xd7, 0x96, 0x66, 0x67, 0x85, },
! 687: { 0xb7, 0x87, 0x71, 0x27, 0xe0, 0x94, 0x27, 0xcf, },
! 688: { 0x8d, 0xa6, 0x99, 0xcd, 0x64, 0x55, 0x76, 0x18, },
! 689: { 0xce, 0xe3, 0xfe, 0x58, 0x6e, 0x46, 0xc9, 0xcb, },
! 690: { 0x37, 0xd1, 0x01, 0x8b, 0xf5, 0x00, 0x02, 0xab, },
! 691: { 0x62, 0x24, 0x93, 0x9a, 0x79, 0xf5, 0xf5, 0x93, },
! 692: { 0xb0, 0xe4, 0xa9, 0x0b, 0xdf, 0x82, 0x00, 0x9e, },
! 693: { 0xf3, 0xb9, 0xdd, 0x94, 0xc5, 0xbb, 0x5d, 0x7a, },
! 694: { 0xa7, 0xad, 0x6b, 0x22, 0x46, 0x2f, 0xb3, 0xf4, },
! 695: { 0xfb, 0xe5, 0x0e, 0x86, 0xbc, 0x8f, 0x1e, 0x75, },
! 696: { 0x90, 0x3d, 0x84, 0xc0, 0x27, 0x56, 0xea, 0x14, },
! 697: { 0xee, 0xf2, 0x7a, 0x8e, 0x90, 0xca, 0x23, 0xf7, },
! 698: { 0xe5, 0x45, 0xbe, 0x49, 0x61, 0xca, 0x29, 0xa1, },
! 699: { 0xdb, 0x9b, 0xc2, 0x57, 0x7f, 0xcc, 0x2a, 0x3f, },
! 700: { 0x94, 0x47, 0xbe, 0x2c, 0xf5, 0xe9, 0x9a, 0x69, },
! 701: { 0x9c, 0xd3, 0x8d, 0x96, 0xf0, 0xb3, 0xc1, 0x4b, },
! 702: { 0xbd, 0x61, 0x79, 0xa7, 0x1d, 0xc9, 0x6d, 0xbb, },
! 703: { 0x98, 0xee, 0xa2, 0x1a, 0xf2, 0x5c, 0xd6, 0xbe, },
! 704: { 0xc7, 0x67, 0x3b, 0x2e, 0xb0, 0xcb, 0xf2, 0xd0, },
! 705: { 0x88, 0x3e, 0xa3, 0xe3, 0x95, 0x67, 0x53, 0x93, },
! 706: { 0xc8, 0xce, 0x5c, 0xcd, 0x8c, 0x03, 0x0c, 0xa8, },
! 707: { 0x94, 0xaf, 0x49, 0xf6, 0xc6, 0x50, 0xad, 0xb8, },
! 708: { 0xea, 0xb8, 0x85, 0x8a, 0xde, 0x92, 0xe1, 0xbc, },
! 709: { 0xf3, 0x15, 0xbb, 0x5b, 0xb8, 0x35, 0xd8, 0x17, },
! 710: { 0xad, 0xcf, 0x6b, 0x07, 0x63, 0x61, 0x2e, 0x2f, },
! 711: { 0xa5, 0xc9, 0x1d, 0xa7, 0xac, 0xaa, 0x4d, 0xde, },
! 712: { 0x71, 0x65, 0x95, 0x87, 0x66, 0x50, 0xa2, 0xa6, },
! 713: { 0x28, 0xef, 0x49, 0x5c, 0x53, 0xa3, 0x87, 0xad, },
! 714: { 0x42, 0xc3, 0x41, 0xd8, 0xfa, 0x92, 0xd8, 0x32, },
! 715: { 0xce, 0x7c, 0xf2, 0x72, 0x2f, 0x51, 0x27, 0x71, },
! 716: { 0xe3, 0x78, 0x59, 0xf9, 0x46, 0x23, 0xf3, 0xa7, },
! 717: { 0x38, 0x12, 0x05, 0xbb, 0x1a, 0xb0, 0xe0, 0x12, },
! 718: { 0xae, 0x97, 0xa1, 0x0f, 0xd4, 0x34, 0xe0, 0x15, },
! 719: { 0xb4, 0xa3, 0x15, 0x08, 0xbe, 0xff, 0x4d, 0x31, },
! 720: { 0x81, 0x39, 0x62, 0x29, 0xf0, 0x90, 0x79, 0x02, },
! 721: { 0x4d, 0x0c, 0xf4, 0x9e, 0xe5, 0xd4, 0xdc, 0xca, },
! 722: { 0x5c, 0x73, 0x33, 0x6a, 0x76, 0xd8, 0xbf, 0x9a, },
! 723: { 0xd0, 0xa7, 0x04, 0x53, 0x6b, 0xa9, 0x3e, 0x0e, },
! 724: { 0x92, 0x59, 0x58, 0xfc, 0xd6, 0x42, 0x0c, 0xad, },
! 725: { 0xa9, 0x15, 0xc2, 0x9b, 0xc8, 0x06, 0x73, 0x18, },
! 726: { 0x95, 0x2b, 0x79, 0xf3, 0xbc, 0x0a, 0xa6, 0xd4, },
! 727: { 0xf2, 0x1d, 0xf2, 0xe4, 0x1d, 0x45, 0x35, 0xf9, },
! 728: { 0x87, 0x57, 0x75, 0x19, 0x04, 0x8f, 0x53, 0xa9, },
! 729: { 0x10, 0xa5, 0x6c, 0xf5, 0xdf, 0xcd, 0x9a, 0xdb, },
! 730: { 0xeb, 0x75, 0x09, 0x5c, 0xcd, 0x98, 0x6c, 0xd0, },
! 731: { 0x51, 0xa9, 0xcb, 0x9e, 0xcb, 0xa3, 0x12, 0xe6, },
! 732: { 0x96, 0xaf, 0xad, 0xfc, 0x2c, 0xe6, 0x66, 0xc7, },
! 733: { 0x72, 0xfe, 0x52, 0x97, 0x5a, 0x43, 0x64, 0xee, },
! 734: { 0x5a, 0x16, 0x45, 0xb2, 0x76, 0xd5, 0x92, 0xa1, },
! 735: { 0xb2, 0x74, 0xcb, 0x8e, 0xbf, 0x87, 0x87, 0x0a, },
! 736: { 0x6f, 0x9b, 0xb4, 0x20, 0x3d, 0xe7, 0xb3, 0x81, },
! 737: { 0xea, 0xec, 0xb2, 0xa3, 0x0b, 0x22, 0xa8, 0x7f, },
! 738: { 0x99, 0x24, 0xa4, 0x3c, 0xc1, 0x31, 0x57, 0x24, },
! 739: { 0xbd, 0x83, 0x8d, 0x3a, 0xaf, 0xbf, 0x8d, 0xb7, },
! 740: { 0x0b, 0x1a, 0x2a, 0x32, 0x65, 0xd5, 0x1a, 0xea, },
! 741: { 0x13, 0x50, 0x79, 0xa3, 0x23, 0x1c, 0xe6, 0x60, },
! 742: { 0x93, 0x2b, 0x28, 0x46, 0xe4, 0xd7, 0x06, 0x66, },
! 743: { 0xe1, 0x91, 0x5f, 0x5c, 0xb1, 0xec, 0xa4, 0x6c, },
! 744: { 0xf3, 0x25, 0x96, 0x5c, 0xa1, 0x6d, 0x62, 0x9f, },
! 745: { 0x57, 0x5f, 0xf2, 0x8e, 0x60, 0x38, 0x1b, 0xe5, },
! 746: { 0x72, 0x45, 0x06, 0xeb, 0x4c, 0x32, 0x8a, 0x95, }
! 747: };
! 748:
! 749: /**
! 750: * Our SipHash-2-4 implementation returns the result in host order, which
! 751: * doesn't matter for practical purposes and even avoids a byte swap. But
! 752: * because the test vectors are in little-endian we have to account for this
! 753: * with this custom comparison function.
! 754: */
! 755: static inline bool sipeq(const void *a, const void *b, size_t n)
! 756: {
! 757: u_char *ap = (u_char*)a, *bp = (u_char*)b;
! 758: int i;
! 759:
! 760: for (i = 0; i < n; i++)
! 761: {
! 762: #ifdef WORDS_BIGENDIAN
! 763: if (ap[i] != bp[n - i - 1])
! 764: #else
! 765: if (ap[i] != bp[i])
! 766: #endif
! 767: {
! 768: return FALSE;
! 769: }
! 770: }
! 771: return TRUE;
! 772: }
! 773:
! 774: START_TEST(test_chunk_mac)
! 775: {
! 776: chunk_t in;
! 777: u_char key[16];
! 778: uint64_t out;
! 779: int i, count;
! 780:
! 781: count = countof(sip_vectors);
! 782: in = chunk_alloca(count);
! 783:
! 784: for (i = 0; i < 16; ++i)
! 785: {
! 786: key[i] = i;
! 787: }
! 788:
! 789: for (i = 0; i < count; ++i)
! 790: {
! 791: in.ptr[i] = i;
! 792: in.len = i;
! 793: out = chunk_mac(in, key);
! 794: fail_unless(sipeq(&out, sip_vectors[i], 8),
! 795: "test vector failed for %d bytes", i);
! 796: }
! 797: }
! 798: END_TEST
! 799:
! 800: /*******************************************************************************
! 801: * test for chunk_hash[_inc]()
! 802: */
! 803:
! 804: START_TEST(test_chunk_hash)
! 805: {
! 806: chunk_t chunk;
! 807: uint32_t hash_a, hash_b, hash_c;
! 808:
! 809: chunk = chunk_from_str("asdf");
! 810:
! 811: /* output is randomized, so there are no test-vectors we could use */
! 812: hash_a = chunk_hash(chunk);
! 813: hash_b = chunk_hash(chunk);
! 814: ck_assert(hash_a == hash_b);
! 815: hash_b = chunk_hash_inc(chunk, hash_a);
! 816: ck_assert(hash_a != hash_b);
! 817: hash_c = chunk_hash_inc(chunk, hash_a);
! 818: ck_assert(hash_b == hash_c);
! 819: }
! 820: END_TEST
! 821:
! 822: /*******************************************************************************
! 823: * test for chunk_hash_static[_inc]()
! 824: */
! 825:
! 826: START_TEST(test_chunk_hash_static)
! 827: {
! 828: chunk_t in;
! 829: uint32_t out, hash_a, hash_b, hash_inc = 0x7b891a95;
! 830: int i, count;
! 831:
! 832: count = countof(sip_vectors);
! 833: in = chunk_alloca(count);
! 834:
! 835: for (i = 0; i < count; ++i)
! 836: {
! 837: in.ptr[i] = i;
! 838: in.len = i;
! 839: /* compared to chunk_mac() we only get half the value back */
! 840: out = chunk_hash_static(in);
! 841: fail_unless(sipeq(&out, sip_vectors[i], 4),
! 842: "test vector failed for %d bytes", i);
! 843: }
! 844: hash_a = chunk_hash_static_inc(in, out);
! 845: ck_assert_int_eq(hash_a, hash_inc);
! 846: hash_b = chunk_hash_static_inc(in, out);
! 847: ck_assert_int_eq(hash_a, hash_b);
! 848: }
! 849: END_TEST
! 850:
! 851: /*******************************************************************************
! 852: * test for chunk_internet_checksum[_inc]()
! 853: */
! 854:
! 855: static inline uint16_t compensate_alignment(uint16_t val)
! 856: {
! 857: return ((val & 0xff) << 8) | (val >> 8);
! 858: }
! 859:
! 860: START_TEST(test_chunk_internet_checksum)
! 861: {
! 862: chunk_t chunk;
! 863: uint16_t sum;
! 864:
! 865: chunk = chunk_from_chars(0x45,0x00,0x00,0x30,0x44,0x22,0x40,0x00,0x80,0x06,
! 866: 0x00,0x00,0x8c,0x7c,0x19,0xac,0xae,0x24,0x1e,0x2b);
! 867:
! 868: sum = chunk_internet_checksum(chunk);
! 869: ck_assert_int_eq(0x442e, ntohs(sum));
! 870:
! 871: sum = chunk_internet_checksum(chunk_create(chunk.ptr, 10));
! 872: sum = chunk_internet_checksum_inc(chunk_create(chunk.ptr+10, 10), sum);
! 873: ck_assert_int_eq(0x442e, ntohs(sum));
! 874:
! 875: /* need to compensate for even/odd alignment */
! 876: sum = chunk_internet_checksum(chunk_create(chunk.ptr, 9));
! 877: sum = compensate_alignment(sum);
! 878: sum = chunk_internet_checksum_inc(chunk_create(chunk.ptr+9, 11), sum);
! 879: sum = compensate_alignment(sum);
! 880: ck_assert_int_eq(0x442e, ntohs(sum));
! 881:
! 882: chunk = chunk_from_chars(0x45,0x00,0x00,0x30,0x44,0x22,0x40,0x00,0x80,0x06,
! 883: 0x00,0x00,0x8c,0x7c,0x19,0xac,0xae,0x24,0x1e);
! 884:
! 885: sum = chunk_internet_checksum(chunk);
! 886: ck_assert_int_eq(0x4459, ntohs(sum));
! 887:
! 888: sum = chunk_internet_checksum(chunk_create(chunk.ptr, 10));
! 889: sum = chunk_internet_checksum_inc(chunk_create(chunk.ptr+10, 9), sum);
! 890: ck_assert_int_eq(0x4459, ntohs(sum));
! 891:
! 892: /* need to compensate for even/odd alignment */
! 893: sum = chunk_internet_checksum(chunk_create(chunk.ptr, 9));
! 894: sum = compensate_alignment(sum);
! 895: sum = chunk_internet_checksum_inc(chunk_create(chunk.ptr+9, 10), sum);
! 896: sum = compensate_alignment(sum);
! 897: ck_assert_int_eq(0x4459, ntohs(sum));
! 898: }
! 899: END_TEST
! 900:
! 901: /*******************************************************************************
! 902: * test for chunk_map and friends
! 903: */
! 904:
! 905: START_TEST(test_chunk_map)
! 906: {
! 907: chunk_t *map, contents = chunk_from_chars(0x01,0x02,0x03,0x04,0x05);
! 908: #ifdef WIN32
! 909: char *path = "C:\\Windows\\Temp\\strongswan-chunk-map-test";
! 910: #else
! 911: char *path = "/tmp/strongswan-chunk-map-test";
! 912: #endif
! 913:
! 914: ck_assert(chunk_write(contents, path, 022, TRUE));
! 915:
! 916: /* read */
! 917: map = chunk_map(path, FALSE);
! 918: ck_assert(map != NULL);
! 919: ck_assert_msg(chunk_equals(*map, contents), "%B", map);
! 920: /* altering mapped chunk should not hurt */
! 921: *map = chunk_empty;
! 922: ck_assert(chunk_unmap(map));
! 923:
! 924: /* write */
! 925: map = chunk_map(path, TRUE);
! 926: ck_assert(map != NULL);
! 927: ck_assert_msg(chunk_equals(*map, contents), "%B", map);
! 928: map->ptr[0] = 0x06;
! 929: ck_assert(chunk_unmap(map));
! 930:
! 931: /* verify write */
! 932: contents.ptr[0] = 0x06;
! 933: map = chunk_map(path, FALSE);
! 934: ck_assert(map != NULL);
! 935: ck_assert_msg(chunk_equals(*map, contents), "%B", map);
! 936: ck_assert(chunk_unmap(map));
! 937:
! 938: unlink(path);
! 939: }
! 940: END_TEST
! 941:
! 942: /*******************************************************************************
! 943: * test for chunk_from_fd
! 944: */
! 945:
! 946: START_TEST(test_chunk_from_fd_file)
! 947: {
! 948: chunk_t in, contents = chunk_from_chars(0x01,0x02,0x03,0x04,0x05);
! 949: #ifdef WIN32
! 950: char *path = "C:\\Windows\\Temp\\strongswan-chunk-fd-test";
! 951: #else
! 952: char *path = "/tmp/strongswan-chunk-fd-test";
! 953: #endif
! 954: int fd;
! 955:
! 956: ck_assert(chunk_write(contents, path, 022, TRUE));
! 957:
! 958: fd = open(path, O_RDONLY);
! 959: ck_assert(fd != -1);
! 960:
! 961: ck_assert(chunk_from_fd(fd, &in));
! 962: close(fd);
! 963: ck_assert_msg(chunk_equals(in, contents), "%B", &in);
! 964: unlink(path);
! 965: free(in.ptr);
! 966: }
! 967: END_TEST
! 968:
! 969: START_TEST(test_chunk_from_fd_skt)
! 970: {
! 971: chunk_t in, contents = chunk_from_chars(0x01,0x02,0x03,0x04,0x05);
! 972: int s[2];
! 973:
! 974: ck_assert(socketpair(AF_UNIX, SOCK_STREAM, 0, s) == 0);
! 975: ck_assert_int_eq(send(s[1], contents.ptr, contents.len, 0), contents.len);
! 976: close(s[1]);
! 977: ck_assert_msg(chunk_from_fd(s[0], &in), "%s", strerror(errno));
! 978: close(s[0]);
! 979: ck_assert_msg(chunk_equals(in, contents), "%B", &in);
! 980: free(in.ptr);
! 981: }
! 982: END_TEST
! 983:
! 984: #define FROM_FD_COUNT 8192
! 985:
! 986: void *chunk_from_fd_run(void *data)
! 987: {
! 988: int i, fd = (uintptr_t)data;
! 989:
! 990: for (i = 0; i < FROM_FD_COUNT; i++)
! 991: {
! 992: ck_assert(send(fd, &i, sizeof(i), 0) == sizeof(i));
! 993: }
! 994: close(fd);
! 995: return NULL;
! 996: }
! 997:
! 998: START_TEST(test_chunk_from_fd_huge)
! 999: {
! 1000: thread_t *thread;
! 1001: chunk_t in;
! 1002: int s[2], i;
! 1003:
! 1004: ck_assert(socketpair(AF_UNIX, SOCK_STREAM, 0, s) == 0);
! 1005:
! 1006: thread = thread_create(chunk_from_fd_run, (void*)(uintptr_t)s[1]);
! 1007: ck_assert_msg(chunk_from_fd(s[0], &in), "%s", strerror(errno));
! 1008: ck_assert_int_eq(in.len, FROM_FD_COUNT * sizeof(i));
! 1009: for (i = 0; i < FROM_FD_COUNT; i++)
! 1010: {
! 1011: ck_assert_int_eq(((int*)in.ptr)[i], i);
! 1012: }
! 1013: thread->join(thread);
! 1014: close(s[0]);
! 1015: free(in.ptr);
! 1016: }
! 1017: END_TEST
! 1018:
! 1019: /*******************************************************************************
! 1020: * printf_hook tests
! 1021: */
! 1022:
! 1023: static struct {
! 1024: chunk_t in;
! 1025: char *out;
! 1026: char *out_plus;
! 1027: } printf_hook_data[] = {
! 1028: {chunk_from_chars(), "", ""},
! 1029: {chunk_from_chars(0x00), "00", "00"},
! 1030: {chunk_from_chars(0x00, 0x01), "00:01", "0001"},
! 1031: {chunk_from_chars(0x00, 0x01, 0x02), "00:01:02", "000102"},
! 1032: };
! 1033:
! 1034: START_TEST(test_printf_hook_hash)
! 1035: {
! 1036: char buf[16];
! 1037: int len;
! 1038:
! 1039: len = snprintf(buf, sizeof(buf), "%#B", &printf_hook_data[_i].in);
! 1040: ck_assert(len >= 0 && len < sizeof(buf));
! 1041: ck_assert_str_eq(buf, printf_hook_data[_i].out);
! 1042: }
! 1043: END_TEST
! 1044:
! 1045: START_TEST(test_printf_hook_plus)
! 1046: {
! 1047: char buf[16];
! 1048: int len;
! 1049:
! 1050: len = snprintf(buf, sizeof(buf), "%+B", &printf_hook_data[_i].in);
! 1051: ck_assert(len >= 0 && len < sizeof(buf));
! 1052: ck_assert_str_eq(buf, printf_hook_data[_i].out_plus);
! 1053: }
! 1054: END_TEST
! 1055:
! 1056: START_TEST(test_printf_hook)
! 1057: {
! 1058: char buf[128], mem[128];
! 1059: int len;
! 1060:
! 1061: /* %B should be the same as %b, which is what we check, comparing the
! 1062: * actual result could be tricky as %b prints the chunk's memory address */
! 1063: len = snprintf(buf, sizeof(buf), "%B", &printf_hook_data[_i].in);
! 1064: ck_assert(len >= 0 && len < sizeof(buf));
! 1065: len = snprintf(mem, sizeof(mem), "%b", printf_hook_data[_i].in.ptr,
! 1066: (u_int)printf_hook_data[_i].in.len);
! 1067: ck_assert(len >= 0 && len < sizeof(mem));
! 1068: ck_assert_str_eq(buf, mem);
! 1069: }
! 1070: END_TEST
! 1071:
! 1072: Suite *chunk_suite_create()
! 1073: {
! 1074: Suite *s;
! 1075: TCase *tc;
! 1076:
! 1077: s = suite_create("chunk");
! 1078:
! 1079: tc = tcase_create("equals");
! 1080: tcase_add_test(tc, test_chunk_equals);
! 1081: tcase_add_test(tc, test_chunk_equals_const);
! 1082: suite_add_tcase(s, tc);
! 1083:
! 1084: tc = tcase_create("chunk_compare");
! 1085: tcase_add_loop_test(tc, test_compare, 0, countof(compare_data));
! 1086: suite_add_tcase(s, tc);
! 1087:
! 1088: tc = tcase_create("clear");
! 1089: tcase_add_test(tc, test_chunk_clear);
! 1090: suite_add_tcase(s, tc);
! 1091:
! 1092: tc = tcase_create("chunk_length");
! 1093: tcase_add_test(tc, test_chunk_length);
! 1094: suite_add_tcase(s, tc);
! 1095:
! 1096: tc = tcase_create("chunk_create_cat");
! 1097: tcase_add_test(tc, test_chunk_create_cat);
! 1098: suite_add_tcase(s, tc);
! 1099:
! 1100: tc = tcase_create("chunk_split");
! 1101: tcase_add_test(tc, test_chunk_split);
! 1102: suite_add_tcase(s, tc);
! 1103:
! 1104: tc = tcase_create("chunk_skip");
! 1105: tcase_add_test(tc, test_chunk_skip);
! 1106: tcase_add_test(tc, test_chunk_skip_zero);
! 1107: suite_add_tcase(s, tc);
! 1108:
! 1109: tc = tcase_create("chunk_increment");
! 1110: tcase_add_loop_test(tc, test_increment, 0, countof(increment_data));
! 1111: suite_add_tcase(s, tc);
! 1112:
! 1113: tc = tcase_create("chunk_copy_pad");
! 1114: tcase_add_loop_test(tc, test_copy_pad, 0, countof(copy_pad_data));
! 1115: suite_add_tcase(s, tc);
! 1116:
! 1117: tc = tcase_create("chunk_printable");
! 1118: tcase_add_loop_test(tc, test_printable, 0, countof(printable_data));
! 1119: tcase_add_loop_test(tc, test_printable_sanitize, 0, countof(printable_data));
! 1120: tcase_add_test(tc, test_printable_empty);
! 1121: suite_add_tcase(s, tc);
! 1122:
! 1123: tc = tcase_create("baseXX");
! 1124: tcase_add_test(tc, test_base64);
! 1125: tcase_add_test(tc, test_base32);
! 1126: tcase_add_test(tc, test_base16);
! 1127: suite_add_tcase(s, tc);
! 1128:
! 1129: tc = tcase_create("chunk_mac");
! 1130: tcase_add_test(tc, test_chunk_mac);
! 1131: suite_add_tcase(s, tc);
! 1132:
! 1133: tc = tcase_create("chunk_hash");
! 1134: tcase_add_test(tc, test_chunk_hash);
! 1135: suite_add_tcase(s, tc);
! 1136:
! 1137: tc = tcase_create("chunk_hash_static");
! 1138: tcase_add_test(tc, test_chunk_hash_static);
! 1139: suite_add_tcase(s, tc);
! 1140:
! 1141: tc = tcase_create("chunk_internet_checksum");
! 1142: tcase_add_test(tc, test_chunk_internet_checksum);
! 1143: suite_add_tcase(s, tc);
! 1144:
! 1145: tc = tcase_create("chunk_map");
! 1146: tcase_add_test(tc, test_chunk_map);
! 1147: suite_add_tcase(s, tc);
! 1148:
! 1149: tc = tcase_create("chunk_from_fd");
! 1150: tcase_add_test(tc, test_chunk_from_fd_file);
! 1151: tcase_add_test(tc, test_chunk_from_fd_skt);
! 1152: tcase_add_test(tc, test_chunk_from_fd_huge);
! 1153: suite_add_tcase(s, tc);
! 1154:
! 1155: tc = tcase_create("printf_hook");
! 1156: tcase_add_loop_test(tc, test_printf_hook_hash, 0, countof(printf_hook_data));
! 1157: tcase_add_loop_test(tc, test_printf_hook_plus, 0, countof(printf_hook_data));
! 1158: tcase_add_loop_test(tc, test_printf_hook, 0, countof(printf_hook_data));
! 1159: suite_add_tcase(s, tc);
! 1160:
! 1161: return s;
! 1162: }
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>
![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to test_chunk.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