Annotation of embedaddon/strongswan/src/libcharon/tests/suites/test_mem_pool.c, revision 1.1
1.1 ! misho 1: /*
! 2: * Copyright (C) 2014 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 <attributes/mem_pool.h>
! 19:
! 20: static void assert_host(char *expected, host_t *host)
! 21: {
! 22: if (!expected)
! 23: {
! 24: ck_assert_msg(!host, "not expecting IP != %+H", host);
! 25: }
! 26: else
! 27: {
! 28: host_t *verifier;
! 29: verifier = host_create_from_string(expected, 0);
! 30: ck_assert_msg(host, "expected IP %+H != NULL", verifier);
! 31: ck_assert_msg(verifier->ip_equals(verifier, host), "expected IP %+H != "
! 32: "%+H", verifier, host);;
! 33: verifier->destroy(verifier);
! 34: }
! 35: }
! 36:
! 37: static void assert_acquire(mem_pool_t *pool, char *requested, char *expected,
! 38: mem_pool_op_t operation)
! 39: {
! 40: identification_t *id;
! 41: host_t *req, *acquired;
! 42:
! 43: id = identification_create_from_string("tester");
! 44: req = host_create_from_string(requested, 0);
! 45:
! 46: acquired = pool->acquire_address(pool, id, req, operation, NULL);
! 47: assert_host(expected, acquired);
! 48: DESTROY_IF(acquired);
! 49:
! 50: req->destroy(req);
! 51: id->destroy(id);
! 52: }
! 53:
! 54: static void assert_acquires_new(mem_pool_t *pool, char *pattern, int first)
! 55: {
! 56: char expected[16];
! 57: int i;
! 58:
! 59: for (i = 0; i < pool->get_size(pool); i++)
! 60: {
! 61: snprintf(expected, sizeof(expected), pattern, first + i);
! 62: assert_acquire(pool, "0.0.0.0", expected, MEM_POOL_NEW);
! 63: ck_assert_int_eq(i + 1, pool->get_online(pool));
! 64: }
! 65: assert_acquire(pool, "0.0.0.0", NULL, MEM_POOL_NEW);
! 66: }
! 67:
! 68: START_TEST(test_config)
! 69: {
! 70: mem_pool_t *pool;
! 71:
! 72: pool = mem_pool_create("test", NULL, 0);
! 73: ck_assert_int_eq(0, pool->get_size(pool));
! 74: assert_acquire(pool, "192.168.0.1", "192.168.0.1", MEM_POOL_NEW);
! 75: assert_acquire(pool, "10.0.1.1", "10.0.1.1", MEM_POOL_NEW);
! 76: assert_acquire(pool, "0.0.0.0", "0.0.0.0", MEM_POOL_NEW);
! 77: assert_acquire(pool, "255.255.255.255", "255.255.255.255", MEM_POOL_NEW);
! 78: ck_assert_int_eq(0, pool->get_online(pool));
! 79: pool->destroy(pool);
! 80: }
! 81: END_TEST
! 82:
! 83: START_TEST(test_cidr)
! 84: {
! 85: mem_pool_t *pool;
! 86: host_t *base;
! 87:
! 88: base = host_create_from_string("192.168.0.0", 0);
! 89:
! 90: pool = mem_pool_create("test", base, 32);
! 91: ck_assert_int_eq(1, pool->get_size(pool));
! 92: assert_acquires_new(pool, "192.168.0.%d", 0);
! 93: pool->destroy(pool);
! 94:
! 95: pool = mem_pool_create("test", base, 31);
! 96: ck_assert_int_eq(2, pool->get_size(pool));
! 97: assert_acquires_new(pool, "192.168.0.%d", 0);
! 98: pool->destroy(pool);
! 99:
! 100: pool = mem_pool_create("test", base, 30);
! 101: ck_assert_int_eq(2, pool->get_size(pool));
! 102: assert_acquires_new(pool, "192.168.0.%d", 1);
! 103: pool->destroy(pool);
! 104:
! 105: pool = mem_pool_create("test", base, 29);
! 106: ck_assert_int_eq(6, pool->get_size(pool));
! 107: assert_acquires_new(pool, "192.168.0.%d", 1);
! 108: pool->destroy(pool);
! 109:
! 110: pool = mem_pool_create("test", base, 24);
! 111: ck_assert_int_eq(254, pool->get_size(pool));
! 112: assert_acquires_new(pool, "192.168.0.%d", 1);
! 113: pool->destroy(pool);
! 114:
! 115: base->destroy(base);
! 116: }
! 117: END_TEST
! 118:
! 119: START_TEST(test_cidr_offset)
! 120: {
! 121: mem_pool_t *pool;
! 122: host_t *base;
! 123:
! 124: base = host_create_from_string("192.168.0.1", 0);
! 125: pool = mem_pool_create("test", base, 31);
! 126: ck_assert_int_eq(1, pool->get_size(pool));
! 127: assert_acquires_new(pool, "192.168.0.%d", 1);
! 128: pool->destroy(pool);
! 129:
! 130: pool = mem_pool_create("test", base, 30);
! 131: ck_assert_int_eq(2, pool->get_size(pool));
! 132: assert_acquires_new(pool, "192.168.0.%d", 1);
! 133: pool->destroy(pool);
! 134: base->destroy(base);
! 135:
! 136: base = host_create_from_string("192.168.0.2", 0);
! 137: pool = mem_pool_create("test", base, 30);
! 138: ck_assert_int_eq(1, pool->get_size(pool));
! 139: assert_acquires_new(pool, "192.168.0.%d", 2);
! 140: pool->destroy(pool);
! 141:
! 142: pool = mem_pool_create("test", base, 24);
! 143: ck_assert_int_eq(253, pool->get_size(pool));
! 144: assert_acquires_new(pool, "192.168.0.%d", 2);
! 145: pool->destroy(pool);
! 146: base->destroy(base);
! 147:
! 148: base = host_create_from_string("192.168.0.254", 0);
! 149: pool = mem_pool_create("test", base, 24);
! 150: ck_assert_int_eq(1, pool->get_size(pool));
! 151: assert_acquires_new(pool, "192.168.0.%d", 254);
! 152: pool->destroy(pool);
! 153: base->destroy(base);
! 154:
! 155: /* due to size == 0 we get the requested IP back */
! 156: base = host_create_from_string("192.168.0.255", 0);
! 157: pool = mem_pool_create("test", base, 24);
! 158: ck_assert_int_eq(0, pool->get_size(pool));
! 159: assert_acquire(pool, "192.168.0.1", "192.168.0.1", MEM_POOL_NEW);
! 160: pool->destroy(pool);
! 161:
! 162: base->destroy(base);
! 163: }
! 164: END_TEST
! 165:
! 166: START_TEST(test_range)
! 167: {
! 168: mem_pool_t *pool;
! 169: host_t *from, *to;
! 170:
! 171: from = host_create_from_string("192.168.0.0", 0);
! 172: to = host_create_from_string("192.168.0.0", 0);
! 173: pool = mem_pool_create_range("test", from, to);
! 174: ck_assert_int_eq(1, pool->get_size(pool));
! 175: assert_acquires_new(pool, "192.168.0.%d", 0);
! 176: pool->destroy(pool);
! 177:
! 178: to->destroy(to);
! 179: to = host_create_from_string("192.168.0.1", 0);
! 180: pool = mem_pool_create_range("test", from, to);
! 181: ck_assert_int_eq(2, pool->get_size(pool));
! 182: assert_acquires_new(pool, "192.168.0.%d", 0);
! 183: pool->destroy(pool);
! 184:
! 185: from->destroy(from);
! 186: from = host_create_from_string("192.168.0.10", 0);
! 187: pool = mem_pool_create_range("test", from, to);
! 188: ck_assert(!pool);
! 189:
! 190: to->destroy(to);
! 191: to = host_create_from_string("192.168.0.20", 0);
! 192: pool = mem_pool_create_range("test", from, to);
! 193: ck_assert_int_eq(11, pool->get_size(pool));
! 194: assert_acquires_new(pool, "192.168.0.%d", 10);
! 195: pool->destroy(pool);
! 196:
! 197: from->destroy(from);
! 198: from = host_create_from_string("fec::1", 0);
! 199: to->destroy(to);
! 200: to = host_create_from_string("fed::1", 0);
! 201: pool = mem_pool_create_range("test", from, to);
! 202: ck_assert(!pool);
! 203:
! 204: from->destroy(from);
! 205: to->destroy(to);
! 206: }
! 207: END_TEST
! 208:
! 209: Suite *mem_pool_suite_create()
! 210: {
! 211: Suite *s;
! 212: TCase *tc;
! 213:
! 214: s = suite_create("mem_pool");
! 215:
! 216: tc = tcase_create("%config-like pool");
! 217: tcase_add_test(tc, test_config);
! 218: suite_add_tcase(s, tc);
! 219:
! 220: tc = tcase_create("cidr constructor");
! 221: tcase_add_test(tc, test_cidr);
! 222: tcase_add_test(tc, test_cidr_offset);
! 223: suite_add_tcase(s, tc);
! 224:
! 225: tc = tcase_create("range constructor");
! 226: tcase_add_test(tc, test_range);
! 227: suite_add_tcase(s, tc);
! 228:
! 229: return s;
! 230: }
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>
![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to test_mem_pool.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 / libcharon / tests / suites