src/libstrongswan/tests/suites/test_metadata_set.c

   1 /*
   2  * Copyright (C) 2021 Tobias Brunner
   3  *
   4  * Copyright (C) secunet Security Networks AG
   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 <metadata/metadata_set.h>
  20
  21 START_TEST(test_destroy_null)
  22 {
  23         metadata_set_t *set = NULL;
  24         metadata_set_destroy(set);
  25 }
  26 END_TEST
  27
  28 START_TEST(test_destroy_empty)
  29 {
  30         metadata_set_t *set = metadata_set_create();
  31         metadata_set_destroy(set);
  32 }
  33 END_TEST
  34
  35 START_TEST(test_put_null)
  36 {
  37         metadata_set_t *set = NULL;
  38         metadata_t *metadata;
  39
  40         metadata = lib->metadata->create(lib->metadata, "int", 42);
  41         metadata_set_put(set, "key", metadata);
  42         metadata_set_put(set, "other", NULL);
  43 }
  44 END_TEST
  45
  46 START_TEST(test_put)
  47 {
  48         metadata_set_t *set = metadata_set_create();
  49         metadata_t *metadata;
  50
  51         metadata = lib->metadata->create(lib->metadata, "int", 42);
  52         metadata_set_put(set, "key", metadata);
  53         metadata_set_destroy(set);
  54 }
  55 END_TEST
  56
  57 START_TEST(test_get_null)
  58 {
  59         metadata_set_t *set = NULL;
  60         metadata_t *metadata;
  61
  62         metadata = metadata_set_get(set, "key");
  63         ck_assert(!metadata);
  64 }
  65 END_TEST
  66
  67 /**
  68  * Assert that the given int metadata value is found with the given key.
  69  */
  70 static void assert_int_value(metadata_set_t *set, const char *key, int expected)
  71 {
  72         metadata_t *metadata;
  73         int value;
  74
  75         metadata = metadata_set_get(set, key);
  76         ck_assert(metadata);
  77         metadata->get(metadata, &value);
  78         ck_assert_int_eq(expected, value);
  79 }
  80
  81 START_TEST(test_get)
  82 {
  83         metadata_set_t *set = metadata_set_create();
  84         metadata_t *metadata;
  85
  86         metadata = lib->metadata->create(lib->metadata, "int", 42);
  87         metadata_set_put(set, "key", metadata);
  88         assert_int_value(set, "key", 42);
  89         metadata_set_destroy(set);
  90 }
  91 END_TEST
  92
  93 START_TEST(test_get_missing)
  94 {
  95         metadata_set_t *set = metadata_set_create();
  96         metadata_t *metadata;
  97
  98         metadata = metadata_set_get(set, "key");
  99         ck_assert(!metadata);
 100
 101         metadata = lib->metadata->create(lib->metadata, "int", 42);
 102         metadata_set_put(set, "other", metadata);
 103         metadata = metadata_set_get(set, "key");
 104         ck_assert(!metadata);
 105         metadata_set_destroy(set);
 106 }
 107 END_TEST
 108
 109 START_TEST(test_get_multi)
 110 {
 111         metadata_set_t *set = metadata_set_create();
 112         metadata_t *metadata;
 113
 114         metadata = lib->metadata->create(lib->metadata, "int", 42);
 115         metadata_set_put(set, "key", metadata);
 116         metadata = lib->metadata->create(lib->metadata, "int", 0);
 117         metadata_set_put(set, "other", metadata);
 118         assert_int_value(set, "key", 42);
 119         assert_int_value(set, "other", 0);
 120         metadata_set_destroy(set);
 121 }
 122 END_TEST
 123
 124 START_TEST(test_put_replace)
 125 {
 126         metadata_set_t *set = metadata_set_create();
 127         metadata_t *metadata;
 128
 129         metadata = lib->metadata->create(lib->metadata, "int", 42);
 130         metadata_set_put(set, "whatever", metadata);
 131         metadata = lib->metadata->create(lib->metadata, "int", 0);
 132         metadata_set_put(set, "other", metadata);
 133         metadata = lib->metadata->create(lib->metadata, "int", 666);
 134         metadata_set_put(set, "other", metadata);
 135         assert_int_value(set, "whatever", 42);
 136         assert_int_value(set, "other", 666);
 137         metadata_set_destroy(set);
 138 }
 139 END_TEST
 140
 141 START_TEST(test_put_remove)
 142 {
 143         metadata_set_t *set = metadata_set_create();
 144         metadata_t *metadata;
 145
 146         metadata = lib->metadata->create(lib->metadata, "int", 42);
 147         metadata_set_put(set, "key", metadata);
 148         metadata = lib->metadata->create(lib->metadata, "int", 0);
 149         metadata_set_put(set, "other", metadata);
 150         metadata_set_put(set, "other", NULL);
 151         assert_int_value(set, "key", 42);
 152         metadata = metadata_set_get(set, "other");
 153         ck_assert(!metadata);
 154         metadata_set_put(set, "key", NULL);
 155         metadata = metadata_set_get(set, "key");
 156         ck_assert(!metadata);
 157         metadata_set_destroy(set);
 158 }
 159 END_TEST
 160
 161 START_TEST(test_put_remove_missing)
 162 {
 163         metadata_set_t *set = metadata_set_create();
 164         metadata_t *metadata;
 165
 166         metadata_set_put(set, "key", NULL);
 167         metadata = lib->metadata->create(lib->metadata, "int", 42);
 168         metadata_set_put(set, "key", metadata);
 169         assert_int_value(set, "key", 42);
 170         metadata_set_put(set, "key", NULL);
 171         metadata = metadata_set_get(set, "key");
 172         ck_assert(!metadata);
 173         metadata_set_put(set, "key", NULL);
 174         metadata_set_destroy(set);
 175 }
 176 END_TEST
 177
 178 START_TEST(test_clone_null)
 179 {
 180         metadata_set_t *set = NULL, *clone;
 181
 182         clone = metadata_set_clone(set);
 183         ck_assert(!clone);
 184 }
 185 END_TEST
 186
 187 START_TEST(test_clone_empty)
 188 {
 189         metadata_set_t *set = metadata_set_create(), *clone;
 190
 191         clone = metadata_set_clone(set);
 192         ck_assert(clone != set);
 193
 194         metadata_set_destroy(clone);
 195         metadata_set_destroy(set);
 196 }
 197 END_TEST
 198
 199 START_TEST(test_clone)
 200 {
 201         metadata_set_t *set = metadata_set_create(), *clone;
 202         metadata_t *metadata;
 203         struct {
 204                 const char *key;
 205                 int value;
 206         }  expected[] = {
 207                 { "key", 42, },
 208                 { "other", 666, },
 209                 { "abc", 4500, },
 210         };
 211         int i;
 212
 213         for (i = 0; i < countof(expected); i++)
 214         {
 215                 metadata = lib->metadata->create(lib->metadata, "int", expected[i].value);
 216                 metadata_set_put(set, expected[i].key, metadata);
 217         }
 218
 219         clone = metadata_set_clone(set);
 220         ck_assert(clone != set);
 221
 222         for (i = 0; i < countof(expected); i++)
 223         {
 224                 assert_int_value(set, expected[i].key, expected[i].value);
 225                 assert_int_value(clone, expected[i].key, expected[i].value);
 226         }
 227
 228         metadata_set_put(set, expected[0].key, NULL);
 229         assert_int_value(clone, expected[0].key, expected[0].value);
 230
 231         metadata_set_destroy(clone);
 232         metadata_set_destroy(set);
 233 }
 234 END_TEST
 235
 236 Suite *metadata_set_suite_create()
 237 {
 238         Suite *s;
 239         TCase *tc;
 240
 241         s = suite_create("metadata_set");
 242
 243         tc = tcase_create("create/destroy");
 244         tcase_add_test(tc, test_destroy_null);
 245         tcase_add_test(tc, test_destroy_empty);
 246         suite_add_tcase(s, tc);
 247
 248         tc = tcase_create("put/get");
 249         tcase_add_test(tc, test_put_null);
 250         tcase_add_test(tc, test_put);
 251         tcase_add_test(tc, test_get_null);
 252         tcase_add_test(tc, test_get);
 253         tcase_add_test(tc, test_get_missing);
 254         tcase_add_test(tc, test_get_multi);
 255         tcase_add_test(tc, test_put_replace);
 256         tcase_add_test(tc, test_put_remove);
 257         tcase_add_test(tc, test_put_remove_missing);
 258         suite_add_tcase(s, tc);
 259
 260         tc = tcase_create("clone");
 261         tcase_add_test(tc, test_clone_null);
 262         tcase_add_test(tc, test_clone_empty);
 263         tcase_add_test(tc, test_clone);
 264         suite_add_tcase(s, tc);
 265
 266         return s;
 267 }