src/charon-tkm/tests/id_manager_tests.c

   1 /*
   2  * Copyright (C) 2012 Reto Buerki
   3  * Copyright (C) 2012 Adrian-Ken Rueegsegger
   4  *
   5  * Copyright (C) secunet Security Networks AG
   6  *
   7  * This program is free software; you can redistribute it and/or modify it
   8  * under the terms of the GNU General Public License as published by the
   9  * Free Software Foundation; either version 2 of the License, or (at your
  10  * option) any later version.  See <http://www.fsf.org/copyleft/gpl.txt>.
  11  *
  12  * This program is distributed in the hope that it will be useful, but
  13  * WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
  14  * or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
  15  * for more details.
  16  */
  17
  18 #include <tests/test_suite.h>
  19
  20 #include "tkm_id_manager.h"
  21
  22 static const tkm_limits_t limits = {125, 100, 55, 30, 200, 42};
  23
  24 START_TEST(test_id_mgr_creation)
  25 {
  26         tkm_id_manager_t *idmgr = NULL;
  27
  28         idmgr = tkm_id_manager_create(limits);
  29         fail_if(idmgr == NULL, "Error creating tkm id manager");
  30
  31         idmgr->destroy(idmgr);
  32 }
  33 END_TEST
  34
  35 START_TEST(test_acquire_id)
  36 {
  37         int i, id = 0;
  38         tkm_id_manager_t *idmgr = tkm_id_manager_create(limits);
  39
  40         for (i = 0; i < TKM_CTX_MAX; i++)
  41         {
  42                 id = idmgr->acquire_id(idmgr, i);
  43                 fail_unless(id > 0, "Error acquiring id of context kind %d", i);
  44
  45                 /* Reset test variable */
  46                 id = 0;
  47         }
  48
  49         idmgr->destroy(idmgr);
  50 }
  51 END_TEST
  52
  53 START_TEST(test_acquire_id_invalid_kind)
  54 {
  55         int id = 0;
  56         tkm_id_manager_t *idmgr = tkm_id_manager_create(limits);
  57
  58         id = idmgr->acquire_id(idmgr, TKM_CTX_MAX);
  59         fail_unless(id == 0, "Acquired id for invalid context kind %d", TKM_CTX_MAX);
  60
  61         /* Reset test variable */
  62         id = 0;
  63
  64         id = idmgr->acquire_id(idmgr, -1);
  65         fail_unless(id == 0, "Acquired id for invalid context kind %d", -1);
  66
  67         idmgr->destroy(idmgr);
  68 }
  69 END_TEST
  70
  71 START_TEST(test_acquire_id_same)
  72 {
  73         int id1 = 0, id2 = 0;
  74         tkm_id_manager_t *idmgr = tkm_id_manager_create(limits);
  75
  76         id1 = idmgr->acquire_id(idmgr, TKM_CTX_NONCE);
  77         fail_unless(id1 > 0, "Unable to acquire first id");
  78
  79         /* Acquire another id, must be different than first */
  80         id2 = idmgr->acquire_id(idmgr, TKM_CTX_NONCE);
  81         fail_unless(id2 > 0, "Unable to acquire second id");
  82         fail_unless(id1 != id2, "Same id received twice");
  83
  84         idmgr->destroy(idmgr);
  85 }
  86 END_TEST
  87
  88 START_TEST(test_acquire_ref)
  89 {
  90         int i, id = 0;
  91         bool acquired = false;
  92         tkm_id_manager_t *idmgr = tkm_id_manager_create(limits);
  93
  94         for (i = 0; i < TKM_CTX_MAX; i++)
  95         {
  96                 id = idmgr->acquire_id(idmgr, i);
  97                 acquired = idmgr->acquire_ref(idmgr, i, id);
  98                 fail_unless(acquired, "Error acquiring reference context kind %d", i);
  99
 100                 /* Reset test variable */
 101                 acquired = false;
 102         }
 103
 104         idmgr->destroy(idmgr);
 105 }
 106 END_TEST
 107
 108 START_TEST(test_acquire_ref_invalid_kind)
 109 {
 110         bool acquired;
 111         tkm_id_manager_t *idmgr = tkm_id_manager_create(limits);
 112
 113         acquired = idmgr->acquire_ref(idmgr, TKM_CTX_MAX, 1);
 114         fail_if(acquired, "Acquired reference for invalid context kind %d", TKM_CTX_MAX);
 115
 116         /* Reset test variable */
 117         acquired = 0;
 118
 119         acquired = idmgr->acquire_ref(idmgr, -1, 1);
 120         fail_if(acquired, "Acquired reference for invalid context kind %d", -1);
 121
 122         idmgr->destroy(idmgr);
 123 }
 124 END_TEST
 125
 126 START_TEST(test_acquire_ref_invalid_id)
 127 {
 128         int i;
 129         bool acquired;
 130         tkm_id_manager_t *idmgr = tkm_id_manager_create(limits);
 131
 132         for (i = 0; i < TKM_CTX_MAX; i++)
 133         {
 134                 acquired = idmgr->acquire_ref(idmgr, i, -1);
 135                 fail_if(acquired,
 136                                 "Acquired reference for negative id of context kind %d", i);
 137
 138                 /* Reset test variable */
 139                 acquired = false;
 140
 141                 acquired = idmgr->acquire_ref(idmgr, i, limits[i] + 1);
 142                 fail_if(acquired,
 143                                 "Acquired reference exceeding limit of context kind %d", i);
 144
 145                 /* Reset test variable */
 146                 acquired = false;
 147         }
 148
 149         idmgr->destroy(idmgr);
 150 }
 151 END_TEST
 152
 153 START_TEST(test_release_id)
 154 {
 155         int i, count, id = 0;
 156         tkm_id_manager_t *idmgr = tkm_id_manager_create(limits);
 157
 158         for (i = 0; i < TKM_CTX_MAX; i++)
 159         {
 160                 id = idmgr->acquire_id(idmgr, i);
 161                 count = idmgr->release_id(idmgr, i, id);
 162
 163                 fail_unless(count == 0, "Error releasing id of context kind %d", i);
 164
 165                 /* Reset count variable */
 166                 count = 0;
 167         }
 168
 169         idmgr->destroy(idmgr);
 170 }
 171 END_TEST
 172
 173 START_TEST(test_release_id_invalid_kind)
 174 {
 175         int count = 0;
 176         tkm_id_manager_t *idmgr = tkm_id_manager_create(limits);
 177
 178         count = idmgr->release_id(idmgr, TKM_CTX_MAX, 1);
 179         fail_if(count >= 0, "Released id for invalid context kind %d", TKM_CTX_MAX);
 180
 181         /* Reset test variable */
 182         count = 0;
 183
 184         count = idmgr->release_id(idmgr, -1, 1);
 185         fail_if(count >= 0, "Released id for invalid context kind %d", -1);
 186
 187         idmgr->destroy(idmgr);
 188 }
 189 END_TEST
 190
 191 START_TEST(test_release_id_nonexistent)
 192 {
 193         int count = 0;
 194         tkm_id_manager_t *idmgr = tkm_id_manager_create(limits);
 195
 196         count = idmgr->release_id(idmgr, TKM_CTX_NONCE, 1);
 197         fail_unless(count == 0, "Release of nonexistent id failed");
 198
 199         idmgr->destroy(idmgr);
 200 }
 201 END_TEST
 202
 203 Suite *make_id_manager_tests()
 204 {
 205         Suite *s;
 206         TCase *tc;
 207
 208         s = suite_create("context id manager");
 209
 210         tc = tcase_create("creation");
 211         tcase_add_test(tc, test_id_mgr_creation);
 212         suite_add_tcase(s, tc);
 213
 214         tc = tcase_create("acquire");
 215         tcase_add_test(tc, test_acquire_id);
 216         tcase_add_test(tc, test_acquire_id_invalid_kind);
 217         tcase_add_test(tc, test_acquire_id_same);
 218         tcase_add_test(tc, test_acquire_ref);
 219         tcase_add_test(tc, test_acquire_ref_invalid_kind);
 220         tcase_add_test(tc, test_acquire_ref_invalid_id);
 221         suite_add_tcase(s, tc);
 222
 223         tc = tcase_create("release");
 224         tcase_add_test(tc, test_release_id);
 225         tcase_add_test(tc, test_release_id_invalid_kind);
 226         tcase_add_test(tc, test_release_id_nonexistent);
 227         suite_add_tcase(s, tc);
 228
 229         return s;
 230 }