| [21580dd] | 1 | /*
|
|---|
| 2 | * Copyright (c) 2009 Lukas Mejdrech
|
|---|
| 3 | * All rights reserved.
|
|---|
| 4 | *
|
|---|
| 5 | * Redistribution and use in source and binary forms, with or without
|
|---|
| 6 | * modification, are permitted provided that the following conditions
|
|---|
| 7 | * are met:
|
|---|
| 8 | *
|
|---|
| 9 | * - Redistributions of source code must retain the above copyright
|
|---|
| 10 | * notice, this list of conditions and the following disclaimer.
|
|---|
| 11 | * - Redistributions in binary form must reproduce the above copyright
|
|---|
| 12 | * notice, this list of conditions and the following disclaimer in the
|
|---|
| 13 | * documentation and/or other materials provided with the distribution.
|
|---|
| 14 | * - The name of the author may not be used to endorse or promote products
|
|---|
| 15 | * derived from this software without specific prior written permission.
|
|---|
| 16 | *
|
|---|
| 17 | * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
|
|---|
| 18 | * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
|
|---|
| 19 | * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
|
|---|
| 20 | * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
|
|---|
| 21 | * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
|
|---|
| 22 | * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
|
|---|
| 23 | * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
|
|---|
| 24 | * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
|
|---|
| 25 | * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
|
|---|
| 26 | * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
|---|
| 27 | */
|
|---|
| 28 |
|
|---|
| 29 | /** @addtogroup net
|
|---|
| [4011fa0] | 30 | * @{
|
|---|
| [21580dd] | 31 | */
|
|---|
| 32 |
|
|---|
| 33 | /** @file
|
|---|
| [4011fa0] | 34 | * Networking self-tests implementation.
|
|---|
| 35 | *
|
|---|
| [21580dd] | 36 | */
|
|---|
| 37 |
|
|---|
| 38 | #include <errno.h>
|
|---|
| 39 | #include <malloc.h>
|
|---|
| 40 | #include <stdio.h>
|
|---|
| 41 |
|
|---|
| [849ed54] | 42 | #include <net_checksum.h>
|
|---|
| 43 | #include <adt/int_map.h>
|
|---|
| 44 | #include <adt/char_map.h>
|
|---|
| 45 | #include <adt/generic_char_map.h>
|
|---|
| 46 | #include <adt/measured_strings.h>
|
|---|
| 47 | #include <adt/dynamic_fifo.h>
|
|---|
| [21580dd] | 48 |
|
|---|
| 49 | #include "self_test.h"
|
|---|
| 50 |
|
|---|
| [24ab58b3] | 51 | /** Test the statement, compare the result and evaluate.
|
|---|
| [4011fa0] | 52 | *
|
|---|
| [24ab58b3] | 53 | * @param[in] statement The statement to test.
|
|---|
| 54 | * @param[in] result The expected result.
|
|---|
| [4011fa0] | 55 | *
|
|---|
| [21580dd] | 56 | */
|
|---|
| [4011fa0] | 57 | #define TEST(statement, result) \
|
|---|
| 58 | do { \
|
|---|
| 59 | printf("\n\t%s == %s", #statement, #result); \
|
|---|
| 60 | if ((statement) != (result)) { \
|
|---|
| 61 | printf("\tfailed\n"); \
|
|---|
| 62 | fprintf(stderr, "\nNetwork self-test failed\n"); \
|
|---|
| 63 | return EINVAL; \
|
|---|
| 64 | } else \
|
|---|
| 65 | printf("\tOK"); \
|
|---|
| 66 | } while (0)
|
|---|
| 67 |
|
|---|
| 68 | #define XMALLOC(var, type) \
|
|---|
| 69 | do { \
|
|---|
| 70 | (var) = (type *) malloc(sizeof(type)); \
|
|---|
| 71 | if ((var) == NULL) { \
|
|---|
| 72 | fprintf(stderr, "\nMemory allocation error\n"); \
|
|---|
| 73 | return ENOMEM; \
|
|---|
| 74 | } \
|
|---|
| 75 | } while (0)
|
|---|
| 76 |
|
|---|
| 77 | GENERIC_CHAR_MAP_DECLARE(int_char_map, int);
|
|---|
| 78 | GENERIC_CHAR_MAP_IMPLEMENT(int_char_map, int);
|
|---|
| 79 |
|
|---|
| 80 | GENERIC_FIELD_DECLARE(int_field, int);
|
|---|
| 81 | GENERIC_FIELD_IMPLEMENT(int_field, int);
|
|---|
| 82 |
|
|---|
| 83 | INT_MAP_DECLARE(int_map, int);
|
|---|
| 84 | INT_MAP_IMPLEMENT(int_map, int);
|
|---|
| 85 |
|
|---|
| [24ab58b3] | 86 | /** Self-test start function.
|
|---|
| 87 | *
|
|---|
| 88 | * Run all self-tests.
|
|---|
| 89 | *
|
|---|
| 90 | * @returns EOK on success.
|
|---|
| 91 | * @returns The first error occurred.
|
|---|
| 92 | *
|
|---|
| 93 | */
|
|---|
| [4011fa0] | 94 | int self_test(void)
|
|---|
| 95 | {
|
|---|
| 96 | printf("Running networking self-tests\n");
|
|---|
| 97 |
|
|---|
| [aadf01e] | 98 | printf("\nChar map test");
|
|---|
| [4011fa0] | 99 | char_map_t cm;
|
|---|
| 100 |
|
|---|
| 101 | TEST(char_map_update(&cm, "ucho", 0, 3), EINVAL);
|
|---|
| 102 | TEST(char_map_initialize(&cm), EOK);
|
|---|
| 103 | TEST(char_map_exclude(&cm, "bla", 0), CHAR_MAP_NULL);
|
|---|
| 104 | TEST(char_map_find(&cm, "bla", 0), CHAR_MAP_NULL);
|
|---|
| 105 | TEST(char_map_add(&cm, "bla", 0, 1), EOK);
|
|---|
| 106 | TEST(char_map_find(&cm, "bla", 0), 1);
|
|---|
| 107 | TEST(char_map_add(&cm, "bla", 0, 10), EEXISTS);
|
|---|
| 108 | TEST(char_map_update(&cm, "bla", 0, 2), EOK);
|
|---|
| 109 | TEST(char_map_find(&cm, "bla", 0), 2);
|
|---|
| 110 | TEST(char_map_update(&cm, "ucho", 0, 2), EOK);
|
|---|
| 111 | TEST(char_map_exclude(&cm, "bla", 0), 2);
|
|---|
| 112 | TEST(char_map_exclude(&cm, "bla", 0), CHAR_MAP_NULL);
|
|---|
| 113 | TEST(char_map_find(&cm, "ucho", 0), 2);
|
|---|
| 114 | TEST(char_map_update(&cm, "ucho", 0, 3), EOK);
|
|---|
| 115 | TEST(char_map_find(&cm, "ucho", 0), 3);
|
|---|
| 116 | TEST(char_map_add(&cm, "blabla", 0, 5), EOK);
|
|---|
| 117 | TEST(char_map_find(&cm, "blabla", 0), 5);
|
|---|
| 118 | TEST(char_map_add(&cm, "bla", 0, 6), EOK);
|
|---|
| 119 | TEST(char_map_find(&cm, "bla", 0), 6);
|
|---|
| 120 | TEST(char_map_exclude(&cm, "bla", 0), 6);
|
|---|
| 121 | TEST(char_map_find(&cm, "bla", 0), CHAR_MAP_NULL);
|
|---|
| 122 | TEST(char_map_find(&cm, "blabla", 0), 5);
|
|---|
| 123 | TEST(char_map_add(&cm, "auto", 0, 7), EOK);
|
|---|
| 124 | TEST(char_map_find(&cm, "auto", 0), 7);
|
|---|
| 125 | TEST(char_map_add(&cm, "kara", 0, 8), EOK);
|
|---|
| 126 | TEST(char_map_find(&cm, "kara", 0), 8);
|
|---|
| 127 | TEST(char_map_add(&cm, "nic", 0, 9), EOK);
|
|---|
| 128 | TEST(char_map_find(&cm, "nic", 0), 9);
|
|---|
| 129 | TEST(char_map_find(&cm, "blabla", 0), 5);
|
|---|
| 130 | TEST(char_map_add(&cm, "micnicnic", 5, 9), EOK);
|
|---|
| 131 | TEST(char_map_find(&cm, "micni", 0), 9);
|
|---|
| 132 | TEST(char_map_find(&cm, "micnicn", 5), 9);
|
|---|
| 133 | TEST(char_map_add(&cm, "\x10\x0\x2\x2", 4, 15), EOK);
|
|---|
| 134 | TEST(char_map_find(&cm, "\x10\x0\x2\x2", 4), 15);
|
|---|
| 135 |
|
|---|
| 136 | TEST((char_map_destroy(&cm), EOK), EOK);
|
|---|
| 137 | TEST(char_map_update(&cm, "ucho", 0, 3), EINVAL);
|
|---|
| 138 |
|
|---|
| [a64c64d] | 139 | printf("\nCRC computation test");
|
|---|
| [4011fa0] | 140 | uint32_t value;
|
|---|
| 141 |
|
|---|
| 142 | TEST(value = ~compute_crc32(~0, "123456789", 8 * 9), 0xcbf43926);
|
|---|
| 143 | TEST(value = ~compute_crc32(~0, "1", 8), 0x83dcefb7);
|
|---|
| 144 | TEST(value = ~compute_crc32(~0, "12", 8 * 2), 0x4f5344cd);
|
|---|
| 145 | TEST(value = ~compute_crc32(~0, "123", 8 * 3), 0x884863d2);
|
|---|
| 146 | TEST(value = ~compute_crc32(~0, "1234", 8 * 4), 0x9be3e0a3);
|
|---|
| 147 | TEST(value = ~compute_crc32(~0, "12345678", 8 * 8), 0x9ae0daaf);
|
|---|
| 148 | TEST(value = ~compute_crc32(~0, "ahoj pane", 8 * 9), 0x5fc3d706);
|
|---|
| 149 |
|
|---|
| [a64c64d] | 150 | printf("\nDynamic fifo test");
|
|---|
| [4011fa0] | 151 | dyn_fifo_t fifo;
|
|---|
| 152 |
|
|---|
| 153 | TEST(dyn_fifo_push(&fifo, 1, 0), EINVAL);
|
|---|
| 154 | TEST(dyn_fifo_initialize(&fifo, 1), EOK);
|
|---|
| 155 | TEST(dyn_fifo_push(&fifo, 1, 0), EOK);
|
|---|
| 156 | TEST(dyn_fifo_pop(&fifo), 1);
|
|---|
| 157 | TEST(dyn_fifo_pop(&fifo), ENOENT);
|
|---|
| 158 | TEST(dyn_fifo_push(&fifo, 2, 1), EOK);
|
|---|
| 159 | TEST(dyn_fifo_push(&fifo, 3, 1), ENOMEM);
|
|---|
| 160 | TEST(dyn_fifo_push(&fifo, 3, 0), EOK);
|
|---|
| 161 | TEST(dyn_fifo_pop(&fifo), 2);
|
|---|
| 162 | TEST(dyn_fifo_pop(&fifo), 3);
|
|---|
| 163 | TEST(dyn_fifo_push(&fifo, 4, 2), EOK);
|
|---|
| 164 | TEST(dyn_fifo_push(&fifo, 5, 2), EOK);
|
|---|
| 165 | TEST(dyn_fifo_push(&fifo, 6, 2), ENOMEM);
|
|---|
| 166 | TEST(dyn_fifo_push(&fifo, 6, 5), EOK);
|
|---|
| 167 | TEST(dyn_fifo_push(&fifo, 7, 5), EOK);
|
|---|
| 168 | TEST(dyn_fifo_pop(&fifo), 4);
|
|---|
| 169 | TEST(dyn_fifo_pop(&fifo), 5);
|
|---|
| 170 | TEST(dyn_fifo_push(&fifo, 8, 5), EOK);
|
|---|
| 171 | TEST(dyn_fifo_push(&fifo, 9, 5), EOK);
|
|---|
| 172 | TEST(dyn_fifo_push(&fifo, 10, 6), EOK);
|
|---|
| 173 | TEST(dyn_fifo_push(&fifo, 11, 6), EOK);
|
|---|
| 174 | TEST(dyn_fifo_pop(&fifo), 6);
|
|---|
| 175 | TEST(dyn_fifo_pop(&fifo), 7);
|
|---|
| 176 | TEST(dyn_fifo_push(&fifo, 12, 6), EOK);
|
|---|
| 177 | TEST(dyn_fifo_push(&fifo, 13, 6), EOK);
|
|---|
| 178 | TEST(dyn_fifo_push(&fifo, 14, 6), ENOMEM);
|
|---|
| 179 | TEST(dyn_fifo_push(&fifo, 14, 8), EOK);
|
|---|
| 180 | TEST(dyn_fifo_pop(&fifo), 8);
|
|---|
| 181 | TEST(dyn_fifo_pop(&fifo), 9);
|
|---|
| 182 | TEST(dyn_fifo_pop(&fifo), 10);
|
|---|
| 183 | TEST(dyn_fifo_pop(&fifo), 11);
|
|---|
| 184 | TEST(dyn_fifo_pop(&fifo), 12);
|
|---|
| 185 | TEST(dyn_fifo_pop(&fifo), 13);
|
|---|
| 186 | TEST(dyn_fifo_pop(&fifo), 14);
|
|---|
| 187 | TEST(dyn_fifo_destroy(&fifo), EOK);
|
|---|
| 188 | TEST(dyn_fifo_push(&fifo, 1, 0), EINVAL);
|
|---|
| 189 |
|
|---|
| 190 | printf("\nGeneric char map test");
|
|---|
| 191 |
|
|---|
| 192 | int *x;
|
|---|
| 193 | int *y;
|
|---|
| 194 | int *z;
|
|---|
| 195 | int *u;
|
|---|
| 196 | int *v;
|
|---|
| 197 | int *w;
|
|---|
| 198 |
|
|---|
| 199 | XMALLOC(x, int);
|
|---|
| 200 | XMALLOC(y, int);
|
|---|
| 201 | XMALLOC(z, int);
|
|---|
| 202 | XMALLOC(u, int);
|
|---|
| 203 | XMALLOC(v, int);
|
|---|
| 204 | XMALLOC(w, int);
|
|---|
| 205 |
|
|---|
| [a64c64d] | 206 | int_char_map_t icm;
|
|---|
| 207 | icm.magic = 0;
|
|---|
| [4011fa0] | 208 |
|
|---|
| 209 | TEST(int_char_map_add(&icm, "ucho", 0, z), EINVAL);
|
|---|
| 210 | TEST(int_char_map_initialize(&icm), EOK);
|
|---|
| 211 | TEST((int_char_map_exclude(&icm, "bla", 0), EOK), EOK);
|
|---|
| 212 | TEST(int_char_map_find(&icm, "bla", 0), NULL);
|
|---|
| 213 | TEST(int_char_map_add(&icm, "bla", 0, x), EOK);
|
|---|
| 214 | TEST(int_char_map_find(&icm, "bla", 0), x);
|
|---|
| 215 | TEST(int_char_map_add(&icm, "bla", 0, y), EEXISTS);
|
|---|
| 216 | TEST((int_char_map_exclude(&icm, "bla", 0), EOK), EOK);
|
|---|
| 217 | TEST((int_char_map_exclude(&icm, "bla", 0), EOK), EOK);
|
|---|
| 218 | TEST(int_char_map_add(&icm, "blabla", 0, v), EOK);
|
|---|
| 219 | TEST(int_char_map_find(&icm, "blabla", 0), v);
|
|---|
| 220 | TEST(int_char_map_add(&icm, "bla", 0, w), EOK);
|
|---|
| 221 | TEST(int_char_map_find(&icm, "bla", 0), w);
|
|---|
| 222 | TEST((int_char_map_exclude(&icm, "bla", 0), EOK), EOK);
|
|---|
| 223 | TEST(int_char_map_find(&icm, "bla", 0), NULL);
|
|---|
| 224 | TEST(int_char_map_find(&icm, "blabla", 0), v);
|
|---|
| 225 | TEST(int_char_map_add(&icm, "auto", 0, u), EOK);
|
|---|
| 226 | TEST(int_char_map_find(&icm, "auto", 0), u);
|
|---|
| 227 | TEST((int_char_map_destroy(&icm), EOK), EOK);
|
|---|
| 228 | TEST(int_char_map_add(&icm, "ucho", 0, z), EINVAL);
|
|---|
| 229 |
|
|---|
| 230 | printf("\nGeneric field test");
|
|---|
| 231 |
|
|---|
| 232 | XMALLOC(x, int);
|
|---|
| 233 | XMALLOC(y, int);
|
|---|
| 234 | XMALLOC(z, int);
|
|---|
| 235 | XMALLOC(u, int);
|
|---|
| 236 | XMALLOC(v, int);
|
|---|
| 237 | XMALLOC(w, int);
|
|---|
| 238 |
|
|---|
| [aadf01e] | 239 | int_field_t gf;
|
|---|
| [21580dd] | 240 | gf.magic = 0;
|
|---|
| [4011fa0] | 241 |
|
|---|
| 242 | TEST(int_field_add(&gf, x), EINVAL);
|
|---|
| 243 | TEST(int_field_count(&gf), -1);
|
|---|
| 244 | TEST(int_field_initialize(&gf), EOK);
|
|---|
| 245 | TEST(int_field_count(&gf), 0);
|
|---|
| 246 | TEST(int_field_get_index(&gf, 1), NULL);
|
|---|
| 247 | TEST(int_field_add(&gf, x), 0);
|
|---|
| 248 | TEST(int_field_get_index(&gf, 0), x);
|
|---|
| 249 | TEST((int_field_exclude_index(&gf, 0), EOK), EOK);
|
|---|
| 250 | TEST(int_field_get_index(&gf, 0), NULL);
|
|---|
| 251 | TEST(int_field_add(&gf, y), 1);
|
|---|
| 252 | TEST(int_field_get_index(&gf, 1), y);
|
|---|
| 253 | TEST(int_field_add(&gf, z), 2);
|
|---|
| 254 | TEST(int_field_get_index(&gf, 2), z);
|
|---|
| 255 | TEST(int_field_get_index(&gf, 1), y);
|
|---|
| 256 | TEST(int_field_count(&gf), 3);
|
|---|
| 257 | TEST(int_field_add(&gf, u), 3);
|
|---|
| 258 | TEST(int_field_get_index(&gf, 3), u);
|
|---|
| 259 | TEST(int_field_add(&gf, v), 4);
|
|---|
| 260 | TEST(int_field_get_index(&gf, 4), v);
|
|---|
| 261 | TEST(int_field_add(&gf, w), 5);
|
|---|
| 262 | TEST(int_field_get_index(&gf, 5), w);
|
|---|
| 263 | TEST(int_field_count(&gf), 6);
|
|---|
| 264 | TEST((int_field_exclude_index(&gf, 1), EOK), EOK);
|
|---|
| 265 | TEST(int_field_get_index(&gf, 1), NULL);
|
|---|
| 266 | TEST(int_field_get_index(&gf, 3), u);
|
|---|
| 267 | TEST((int_field_exclude_index(&gf, 7), EOK), EOK);
|
|---|
| 268 | TEST(int_field_get_index(&gf, 3), u);
|
|---|
| 269 | TEST(int_field_get_index(&gf, 5), w);
|
|---|
| 270 | TEST((int_field_exclude_index(&gf, 4), EOK), EOK);
|
|---|
| 271 | TEST(int_field_get_index(&gf, 4), NULL);
|
|---|
| 272 | TEST((int_field_destroy(&gf), EOK), EOK);
|
|---|
| 273 | TEST(int_field_count(&gf), -1);
|
|---|
| 274 |
|
|---|
| 275 | printf("\nInt map test");
|
|---|
| 276 |
|
|---|
| 277 | XMALLOC(x, int);
|
|---|
| 278 | XMALLOC(y, int);
|
|---|
| 279 | XMALLOC(z, int);
|
|---|
| 280 | XMALLOC(u, int);
|
|---|
| 281 | XMALLOC(v, int);
|
|---|
| 282 | XMALLOC(w, int);
|
|---|
| 283 |
|
|---|
| [a64c64d] | 284 | int_map_t im;
|
|---|
| 285 | im.magic = 0;
|
|---|
| [4011fa0] | 286 |
|
|---|
| 287 | TEST(int_map_add(&im, 1, x), EINVAL);
|
|---|
| 288 | TEST(int_map_count(&im), -1);
|
|---|
| 289 | TEST(int_map_initialize(&im), EOK);
|
|---|
| 290 | TEST(int_map_count(&im), 0);
|
|---|
| 291 | TEST(int_map_find(&im, 1), NULL);
|
|---|
| 292 | TEST(int_map_add(&im, 1, x), 0);
|
|---|
| 293 | TEST(int_map_find(&im, 1), x);
|
|---|
| 294 | TEST((int_map_exclude(&im, 1), EOK), EOK);
|
|---|
| 295 | TEST(int_map_find(&im, 1), NULL);
|
|---|
| 296 | TEST(int_map_add(&im, 1, y), 1);
|
|---|
| 297 | TEST(int_map_find(&im, 1), y);
|
|---|
| 298 | TEST(int_map_add(&im, 4, z), 2);
|
|---|
| 299 | TEST(int_map_get_index(&im, 2), z);
|
|---|
| 300 | TEST(int_map_find(&im, 4), z);
|
|---|
| 301 | TEST(int_map_find(&im, 1), y);
|
|---|
| 302 | TEST(int_map_count(&im), 3);
|
|---|
| 303 | TEST(int_map_add(&im, 2, u), 3);
|
|---|
| 304 | TEST(int_map_find(&im, 2), u);
|
|---|
| 305 | TEST(int_map_add(&im, 3, v), 4);
|
|---|
| 306 | TEST(int_map_find(&im, 3), v);
|
|---|
| 307 | TEST(int_map_get_index(&im, 4), v);
|
|---|
| 308 | TEST(int_map_add(&im, 6, w), 5);
|
|---|
| 309 | TEST(int_map_find(&im, 6), w);
|
|---|
| 310 | TEST(int_map_count(&im), 6);
|
|---|
| 311 | TEST((int_map_exclude(&im, 1), EOK), EOK);
|
|---|
| 312 | TEST(int_map_find(&im, 1), NULL);
|
|---|
| 313 | TEST(int_map_find(&im, 2), u);
|
|---|
| 314 | TEST((int_map_exclude(&im, 7), EOK), EOK);
|
|---|
| 315 | TEST(int_map_find(&im, 2), u);
|
|---|
| 316 | TEST(int_map_find(&im, 6), w);
|
|---|
| 317 | TEST((int_map_exclude_index(&im, 4), EOK), EOK);
|
|---|
| 318 | TEST(int_map_get_index(&im, 4), NULL);
|
|---|
| 319 | TEST(int_map_find(&im, 3), NULL);
|
|---|
| 320 | TEST((int_map_destroy(&im), EOK), EOK);
|
|---|
| 321 | TEST(int_map_count(&im), -1);
|
|---|
| 322 |
|
|---|
| [a64c64d] | 323 | printf("\nMeasured strings test");
|
|---|
| [4011fa0] | 324 |
|
|---|
| 325 | measured_string_ref string =
|
|---|
| 326 | measured_string_create_bulk("I am a measured string!", 0);
|
|---|
| 327 | printf("\n%x, %s at %x of %d\n", string, string->value, string->value,
|
|---|
| 328 | string->length);
|
|---|
| 329 |
|
|---|
| [21580dd] | 330 | return EOK;
|
|---|
| 331 | }
|
|---|
| 332 |
|
|---|
| 333 | /** @}
|
|---|
| 334 | */
|
|---|
