Index: uspace/srv/net/netstart/configuration.h =================================================================== --- uspace/srv/net/netstart/configuration.h (revision 849ed54afbef3ad0ec3af831e93a1353f9eaaf0f) +++ (revision ) @@ -1,95 +1,0 @@ -/* - * Copyright (c) 2009 Lukas Mejdrech - * All rights reserved. - * - * Redistribution and use in source and binary forms, with or without - * modification, are permitted provided that the following conditions - * are met: - * - * - Redistributions of source code must retain the above copyright - * notice, this list of conditions and the following disclaimer. - * - Redistributions in binary form must reproduce the above copyright - * notice, this list of conditions and the following disclaimer in the - * documentation and/or other materials provided with the distribution. - * - The name of the author may not be used to endorse or promote products - * derived from this software without specific prior written permission. - * - * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR - * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES - * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. - * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, - * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT - * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, - * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY - * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT - * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF - * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. - */ - -/** @addtogroup net - * @{ - */ - -/** @file - * Networking subsystem compilation configuration. - */ - -#ifndef __NET_CONFIGURATION_H__ -#define __NET_CONFIGURATION_H__ - -/** Activates the self test. - */ -#define NET_SELF_TEST 0 - -/** @name Specific self tests switches - */ -/*@{*/ - -/** Activates the char map self test. - * The NET_SELF_TEST has to be activated. - * @see char_map.h - */ -#define NET_SELF_TEST_CHAR_MAP 1 - -/** Activates the CRC computation self test. - * The NET_SELF_TEST has to be activated. - * @see crc.h - */ -#define NET_SELF_TEST_CRC 1 - -/** Activates the dynamic fifo self test. - * The NET_SELF_TEST has to be activated. - * @see dynamic_fifo.h - */ -#define NET_SELF_TEST_DYNAMIC_FIFO 1 - -/** Activates the generic char map self test. - * The NET_SELF_TEST has to be activated. - * @see generic_char_map.h - */ -#define NET_SELF_TEST_GENERIC_CHAR_MAP 1 - -/** Activates the generic field self test. - * The NET_SELF_TEST has to be activated. - * @see generic_field.h - */ -#define NET_SELF_TEST_GENERIC_FIELD 1 - -/** Activates the integral map self test. - * The NET_SELF_TEST has to be activated. - * @see int_map.h - */ -#define NET_SELF_TEST_INT_MAP 1 - -/** Activates the measured strings self test. - * The NET_SELF_TEST has to be activated. - * @see measured_strings.h - */ -#define NET_SELF_TEST_MEASURED_STRINGS 1 - -/*@}*/ - -#endif - -/** @} - */ Index: uspace/srv/net/netstart/netstart.c =================================================================== --- uspace/srv/net/netstart/netstart.c (revision 849ed54afbef3ad0ec3af831e93a1353f9eaaf0f) +++ uspace/srv/net/netstart/netstart.c (revision 4011fa009e7bf59bf7c5a27c73601b2a1c0db7c2) @@ -28,17 +28,20 @@ /** @addtogroup net - * @{ + * @{ */ /** @file - * Starts the networking subsystem. - * Performs self test if configured to. - * @see configuration.h + * + * Start the networking subsystem. + * Perform networking self-test if executed + * with the -s argument. + * */ + +#define NAME "netstart" #include #include #include - #include #include @@ -47,61 +50,63 @@ #include #include + #include "self_test.h" -/** Networking startup module name. +/** Start a module. + * + * @param[in] desc The module description + * @param[in] path The module absolute path. + * + * @returns true on succesful spanwning + * @returns false on failure + * */ -#define NAME "Networking startup" - -/** Starts the module. - * @param[in] fname The module absolute name. - * @returns The started module task identifier. - * @returns Other error codes as defined for the task_spawn() function. - */ -static task_id_t spawn(const char * fname){ - const char * argv[2]; - task_id_t res; - - argv[0] = fname; +static bool spawn(const char *desc, const char *path) +{ + printf("%s: Spawning %s (%s)\n", NAME, desc, path); + + const char *argv[2]; + + argv[0] = path; argv[1] = NULL; - res = task_spawn(fname, argv); - return res; + if (task_spawn(path, argv) == 0) { + fprintf(stderr, "%s: Error spawning %s\n", NAME, path); + return false; + } + + return true; } -/** Module entry point. - * @param[in] argc The number of command line parameters. - * @param[in] argv The command line parameters. - * @returns EOK on success. - * @returns EINVAL if the net module cannot be started. - * @returns Other error codes as defined for the self_test() function. - * @returns Other error codes as defined for the NET_NET_STARTUP message. +/** Network startup entry point. + * + * @param[in] argc The number of command line parameters. + * @param[in] argv The command line parameters. + * + * @returns EOK on success. + * @returns EINVAL if the net module cannot be started. + * @returns Other error codes as defined for the self_test() function. + * @returns Other error codes as defined for the NET_NET_STARTUP message. + * */ -int main(int argc, char * argv[]){ +int main(int argc, char *argv[]) +{ ERROR_DECLARE; - - int net_phone; - - // print the module label - printf("Task %d - ", task_get_id()); - printf("%s\n", NAME); - - // run self tests - ERROR_PROPAGATE(self_test()); - - // start the networking service - if(! spawn("/srv/net")){ - fprintf(stderr, "Could not spawn net\n"); + + /* Run self-tests */ + if ((argc > 1) && (str_cmp(argv[1], "-s") == 0)) + ERROR_PROPAGATE(self_test()); + + if (!spawn("networking service", "/srv/net")) return EINVAL; + + printf("%s: Initializing networking\n", NAME); + + int net_phone = connect_to_service(SERVICE_NETWORKING); + if (ERROR_OCCURRED(ipc_call_sync_0_0(net_phone, NET_NET_STARTUP))) { + fprintf(stderr, "%s: Networking error %d\n", NAME, ERROR_CODE); + return ERROR_CODE; } - - // start the networking - net_phone = connect_to_service(SERVICE_NETWORKING); - if(ERROR_OCCURRED(ipc_call_sync_0_0(net_phone, NET_NET_STARTUP))){ - printf("ERROR %d\n", ERROR_CODE); - return ERROR_CODE; - }else{ - printf("OK\n"); - } - + return EOK; } Index: uspace/srv/net/netstart/self_test.c =================================================================== --- uspace/srv/net/netstart/self_test.c (revision 849ed54afbef3ad0ec3af831e93a1353f9eaaf0f) +++ uspace/srv/net/netstart/self_test.c (revision 4011fa009e7bf59bf7c5a27c73601b2a1c0db7c2) @@ -28,14 +28,11 @@ /** @addtogroup net - * @{ + * @{ */ /** @file - * Self tests implementation. - */ - -#include "configuration.h" - -#if NET_SELF_TEST + * Networking self-tests implementation. + * + */ #include @@ -52,349 +49,279 @@ #include "self_test.h" -/** Tests the function, compares the result and remembers if the result differs. - * @param[in] name The test name. +/** Test the function, compare the result and remember if the result differs. + * + * @param[in] name The test name. * @param[in] function_call The function to be called and checked. - * @param[in] result The expected result. - */ -#define TEST(name, function_call, result); { \ - printf("\n\t%s", (name)); \ - if((function_call) != (result)){ \ - printf("\tERROR\n"); \ - error = 1; \ - }else{ \ - printf("\tOK\n"); \ - } \ -} - -#if NET_SELF_TEST_GENERIC_CHAR_MAP - - GENERIC_CHAR_MAP_DECLARE(int_char_map, int) - - GENERIC_CHAR_MAP_IMPLEMENT(int_char_map, int) - -#endif - -#if NET_SELF_TEST_GENERIC_FIELD - - GENERIC_FIELD_DECLARE(int_field, int) - - GENERIC_FIELD_IMPLEMENT(int_field, int) - -#endif - -#if NET_SELF_TEST_INT_MAP - - INT_MAP_DECLARE(int_map, int); - - INT_MAP_IMPLEMENT(int_map, int); - -#endif - -int self_test(void){ - int error; - int * x; - int * y; - int * z; - int * u; - int * v; - int * w; - - error = 0; - -#if NET_SELF_TEST_CHAR_MAP + * @param[in] result The expected result. + * + */ +#define TEST(statement, result) \ + do { \ + printf("\n\t%s == %s", #statement, #result); \ + if ((statement) != (result)) { \ + printf("\tfailed\n"); \ + fprintf(stderr, "\nNetwork self-test failed\n"); \ + return EINVAL; \ + } else \ + printf("\tOK"); \ + } while (0) + +#define XMALLOC(var, type) \ + do { \ + (var) = (type *) malloc(sizeof(type)); \ + if ((var) == NULL) { \ + fprintf(stderr, "\nMemory allocation error\n"); \ + return ENOMEM; \ + } \ + } while (0) + +GENERIC_CHAR_MAP_DECLARE(int_char_map, int); +GENERIC_CHAR_MAP_IMPLEMENT(int_char_map, int); + +GENERIC_FIELD_DECLARE(int_field, int); +GENERIC_FIELD_IMPLEMENT(int_field, int); + +INT_MAP_DECLARE(int_map, int); +INT_MAP_IMPLEMENT(int_map, int); + +int self_test(void) +{ + printf("Running networking self-tests\n"); + + printf("\nChar map test"); char_map_t cm; - - printf("\nChar map test"); - TEST("update ucho 3 einval", char_map_update(&cm, "ucho", 0, 3), EINVAL); - TEST("initialize", char_map_initialize(&cm), EOK); - TEST("exclude bla null", char_map_exclude(&cm, "bla", 0), CHAR_MAP_NULL); - TEST("find bla null", char_map_find(&cm, "bla", 0), CHAR_MAP_NULL); - TEST("add bla 1 eok", char_map_add(&cm, "bla", 0, 1), EOK); - TEST("find bla 1", char_map_find(&cm, "bla", 0), 1); - TEST("add bla 10 eexists", char_map_add(&cm, "bla", 0, 10), EEXISTS); - TEST("update bla 2 eok", char_map_update(&cm, "bla", 0, 2), EOK); - TEST("find bla 2", char_map_find(&cm, "bla", 0), 2); - TEST("update ucho 2 eok", char_map_update(&cm, "ucho", 0, 2), EOK); - TEST("exclude bla 2", char_map_exclude(&cm, "bla", 0), 2); - TEST("exclude bla null", char_map_exclude(&cm, "bla", 0), CHAR_MAP_NULL); - TEST("find ucho 2", char_map_find(&cm, "ucho", 0), 2); - TEST("update ucho 3 eok", char_map_update(&cm, "ucho", 0, 3), EOK); - TEST("find ucho 3", char_map_find(&cm, "ucho", 0), 3); - TEST("add blabla 5 eok", char_map_add(&cm, "blabla", 0, 5), EOK); - TEST("find blabla 5", char_map_find(&cm, "blabla", 0), 5); - TEST("add bla 6 eok", char_map_add(&cm, "bla", 0, 6), EOK); - TEST("find bla 6", char_map_find(&cm, "bla", 0), 6); - TEST("exclude bla 6", char_map_exclude(&cm, "bla", 0), 6); - TEST("find bla null", char_map_find(&cm, "bla", 0), CHAR_MAP_NULL); - TEST("find blabla 5", char_map_find(&cm, "blabla", 0), 5); - TEST("add auto 7 eok", char_map_add(&cm, "auto", 0, 7), EOK); - TEST("find auto 7", char_map_find(&cm, "auto", 0), 7); - TEST("add kara 8 eok", char_map_add(&cm, "kara", 0, 8), EOK); - TEST("find kara 8", char_map_find(&cm, "kara", 0), 8); - TEST("add nic 9 eok", char_map_add(&cm, "nic", 0, 9), EOK); - TEST("find nic 9", char_map_find(&cm, "nic", 0), 9); - TEST("find blabla 5", char_map_find(&cm, "blabla", 0), 5); - TEST("add micnicnic 5 9 eok", char_map_add(&cm, "micnicnic", 5, 9), EOK); - TEST("find micni 9", char_map_find(&cm, "micni", 0), 9); - TEST("find micnicn 5 9", char_map_find(&cm, "micnicn", 5), 9); - TEST("add 10.0.2.2 4 15 eok", char_map_add(&cm, "\x10\x0\x2\x2", 4, 15), EOK); - TEST("find 10.0.2.2 4 15", char_map_find(&cm, "\x10\x0\x2\x2", 4), 15); - printf("\n\tdestroy"); - char_map_destroy(&cm); - TEST("update ucho 3 einval", char_map_update(&cm, "ucho", 0, 3), EINVAL); - printf("\nOK"); - - if(error){ - return EINVAL; - } - -#endif - -#if NET_SELF_TEST_CRC + + TEST(char_map_update(&cm, "ucho", 0, 3), EINVAL); + TEST(char_map_initialize(&cm), EOK); + TEST(char_map_exclude(&cm, "bla", 0), CHAR_MAP_NULL); + TEST(char_map_find(&cm, "bla", 0), CHAR_MAP_NULL); + TEST(char_map_add(&cm, "bla", 0, 1), EOK); + TEST(char_map_find(&cm, "bla", 0), 1); + TEST(char_map_add(&cm, "bla", 0, 10), EEXISTS); + TEST(char_map_update(&cm, "bla", 0, 2), EOK); + TEST(char_map_find(&cm, "bla", 0), 2); + TEST(char_map_update(&cm, "ucho", 0, 2), EOK); + TEST(char_map_exclude(&cm, "bla", 0), 2); + TEST(char_map_exclude(&cm, "bla", 0), CHAR_MAP_NULL); + TEST(char_map_find(&cm, "ucho", 0), 2); + TEST(char_map_update(&cm, "ucho", 0, 3), EOK); + TEST(char_map_find(&cm, "ucho", 0), 3); + TEST(char_map_add(&cm, "blabla", 0, 5), EOK); + TEST(char_map_find(&cm, "blabla", 0), 5); + TEST(char_map_add(&cm, "bla", 0, 6), EOK); + TEST(char_map_find(&cm, "bla", 0), 6); + TEST(char_map_exclude(&cm, "bla", 0), 6); + TEST(char_map_find(&cm, "bla", 0), CHAR_MAP_NULL); + TEST(char_map_find(&cm, "blabla", 0), 5); + TEST(char_map_add(&cm, "auto", 0, 7), EOK); + TEST(char_map_find(&cm, "auto", 0), 7); + TEST(char_map_add(&cm, "kara", 0, 8), EOK); + TEST(char_map_find(&cm, "kara", 0), 8); + TEST(char_map_add(&cm, "nic", 0, 9), EOK); + TEST(char_map_find(&cm, "nic", 0), 9); + TEST(char_map_find(&cm, "blabla", 0), 5); + TEST(char_map_add(&cm, "micnicnic", 5, 9), EOK); + TEST(char_map_find(&cm, "micni", 0), 9); + TEST(char_map_find(&cm, "micnicn", 5), 9); + TEST(char_map_add(&cm, "\x10\x0\x2\x2", 4, 15), EOK); + TEST(char_map_find(&cm, "\x10\x0\x2\x2", 4), 15); + + TEST((char_map_destroy(&cm), EOK), EOK); + TEST(char_map_update(&cm, "ucho", 0, 3), EINVAL); + + printf("\nCRC computation test"); uint32_t value; - - printf("\nCRC computation test"); - value = ~ compute_crc32(~ 0, "123456789", 8 * 9); - TEST("123456789", value, 0xCBF43926); - printf("\t=> %X", value); - value = ~ compute_crc32(~ 0, "1", 8); - TEST("1", value, 0x83DCEFB7); - printf("\t=> %X", value); - value = ~ compute_crc32(~ 0, "12", 8 * 2); - TEST("12", value, 0x4F5344CD); - printf("\t=> %X", value); - value = ~ compute_crc32(~ 0, "123", 8 * 3); - TEST("123", value, 0x884863D2); - printf("\t=> %X", value); - value = ~ compute_crc32(~ 0, "1234", 8 * 4); - TEST("1234", value, 0x9BE3E0A3); - printf("\t=> %X", value); - value = ~ compute_crc32(~ 0, "12345678", 8 * 8); - TEST("12345678", value, 0x9AE0DAAF); - printf("\t=> %X", value); - value = ~ compute_crc32(~ 0, "ahoj pane", 8 * 9); - TEST("ahoj pane", value, 0x5FC3D706); - printf("\t=> %X", value); - - if(error){ - return EINVAL; - } - -#endif - -#if NET_SELF_TEST_DYNAMIC_FIFO + + TEST(value = ~compute_crc32(~0, "123456789", 8 * 9), 0xcbf43926); + TEST(value = ~compute_crc32(~0, "1", 8), 0x83dcefb7); + TEST(value = ~compute_crc32(~0, "12", 8 * 2), 0x4f5344cd); + TEST(value = ~compute_crc32(~0, "123", 8 * 3), 0x884863d2); + TEST(value = ~compute_crc32(~0, "1234", 8 * 4), 0x9be3e0a3); + TEST(value = ~compute_crc32(~0, "12345678", 8 * 8), 0x9ae0daaf); + TEST(value = ~compute_crc32(~0, "ahoj pane", 8 * 9), 0x5fc3d706); + + printf("\nDynamic fifo test"); dyn_fifo_t fifo; - - printf("\nDynamic fifo test"); - TEST("add 1 einval", dyn_fifo_push(&fifo, 1, 0), EINVAL); - TEST("initialize", dyn_fifo_initialize(&fifo, 1), EOK); - TEST("add 1 eok", dyn_fifo_push(&fifo, 1, 0), EOK); - TEST("pop 1", dyn_fifo_pop(&fifo), 1); - TEST("pop enoent", dyn_fifo_pop(&fifo), ENOENT); - TEST("add 2 eok", dyn_fifo_push(&fifo, 2, 1), EOK); - TEST("add 3 enomem", dyn_fifo_push(&fifo, 3, 1), ENOMEM); - TEST("add 3 eok", dyn_fifo_push(&fifo, 3, 0), EOK); - TEST("pop 2", dyn_fifo_pop(&fifo), 2); - TEST("pop 3", dyn_fifo_pop(&fifo), 3); - TEST("add 4 eok", dyn_fifo_push(&fifo, 4, 2), EOK); - TEST("add 5 eok", dyn_fifo_push(&fifo, 5, 2), EOK); - TEST("add 6 enomem", dyn_fifo_push(&fifo, 6, 2), ENOMEM); - TEST("add 6 eok", dyn_fifo_push(&fifo, 6, 5), EOK); - TEST("add 7 eok", dyn_fifo_push(&fifo, 7, 5), EOK); - TEST("pop 4", dyn_fifo_pop(&fifo), 4); - TEST("pop 5", dyn_fifo_pop(&fifo), 5); - TEST("add 8 eok", dyn_fifo_push(&fifo, 8, 5), EOK); - TEST("add 9 eok", dyn_fifo_push(&fifo, 9, 5), EOK); - TEST("add 10 eok", dyn_fifo_push(&fifo, 10, 6), EOK); - TEST("add 11 eok", dyn_fifo_push(&fifo, 11, 6), EOK); - TEST("pop 6", dyn_fifo_pop(&fifo), 6); - TEST("pop 7", dyn_fifo_pop(&fifo), 7); - TEST("add 12 eok", dyn_fifo_push(&fifo, 12, 6), EOK); - TEST("add 13 eok", dyn_fifo_push(&fifo, 13, 6), EOK); - TEST("add 14 enomem", dyn_fifo_push(&fifo, 14, 6), ENOMEM); - TEST("add 14 eok", dyn_fifo_push(&fifo, 14, 8), EOK); - TEST("pop 8", dyn_fifo_pop(&fifo), 8); - TEST("pop 9", dyn_fifo_pop(&fifo), 9); - TEST("pop 10", dyn_fifo_pop(&fifo), 10); - TEST("pop 11", dyn_fifo_pop(&fifo), 11); - TEST("pop 12", dyn_fifo_pop(&fifo), 12); - TEST("pop 13", dyn_fifo_pop(&fifo), 13); - TEST("pop 14", dyn_fifo_pop(&fifo), 14); - TEST("destroy", dyn_fifo_destroy(&fifo), EOK); - TEST("add 15 einval", dyn_fifo_push(&fifo, 1, 0), EINVAL); - if(error){ - return EINVAL; - } - -#endif - -#if NET_SELF_TEST_GENERIC_CHAR_MAP + + TEST(dyn_fifo_push(&fifo, 1, 0), EINVAL); + TEST(dyn_fifo_initialize(&fifo, 1), EOK); + TEST(dyn_fifo_push(&fifo, 1, 0), EOK); + TEST(dyn_fifo_pop(&fifo), 1); + TEST(dyn_fifo_pop(&fifo), ENOENT); + TEST(dyn_fifo_push(&fifo, 2, 1), EOK); + TEST(dyn_fifo_push(&fifo, 3, 1), ENOMEM); + TEST(dyn_fifo_push(&fifo, 3, 0), EOK); + TEST(dyn_fifo_pop(&fifo), 2); + TEST(dyn_fifo_pop(&fifo), 3); + TEST(dyn_fifo_push(&fifo, 4, 2), EOK); + TEST(dyn_fifo_push(&fifo, 5, 2), EOK); + TEST(dyn_fifo_push(&fifo, 6, 2), ENOMEM); + TEST(dyn_fifo_push(&fifo, 6, 5), EOK); + TEST(dyn_fifo_push(&fifo, 7, 5), EOK); + TEST(dyn_fifo_pop(&fifo), 4); + TEST(dyn_fifo_pop(&fifo), 5); + TEST(dyn_fifo_push(&fifo, 8, 5), EOK); + TEST(dyn_fifo_push(&fifo, 9, 5), EOK); + TEST(dyn_fifo_push(&fifo, 10, 6), EOK); + TEST(dyn_fifo_push(&fifo, 11, 6), EOK); + TEST(dyn_fifo_pop(&fifo), 6); + TEST(dyn_fifo_pop(&fifo), 7); + TEST(dyn_fifo_push(&fifo, 12, 6), EOK); + TEST(dyn_fifo_push(&fifo, 13, 6), EOK); + TEST(dyn_fifo_push(&fifo, 14, 6), ENOMEM); + TEST(dyn_fifo_push(&fifo, 14, 8), EOK); + TEST(dyn_fifo_pop(&fifo), 8); + TEST(dyn_fifo_pop(&fifo), 9); + TEST(dyn_fifo_pop(&fifo), 10); + TEST(dyn_fifo_pop(&fifo), 11); + TEST(dyn_fifo_pop(&fifo), 12); + TEST(dyn_fifo_pop(&fifo), 13); + TEST(dyn_fifo_pop(&fifo), 14); + TEST(dyn_fifo_destroy(&fifo), EOK); + TEST(dyn_fifo_push(&fifo, 1, 0), EINVAL); + + printf("\nGeneric char map test"); + + int *x; + int *y; + int *z; + int *u; + int *v; + int *w; + + XMALLOC(x, int); + XMALLOC(y, int); + XMALLOC(z, int); + XMALLOC(u, int); + XMALLOC(v, int); + XMALLOC(w, int); + int_char_map_t icm; - - x = (int *) malloc(sizeof(int)); - y = (int *) malloc(sizeof(int)); - z = (int *) malloc(sizeof(int)); - u = (int *) malloc(sizeof(int)); - v = (int *) malloc(sizeof(int)); - w = (int *) malloc(sizeof(int)); - icm.magic = 0; - printf("\nGeneric char map test"); - TEST("add ucho z einval", int_char_map_add(&icm, "ucho", 0, z), EINVAL); - TEST("initialize", int_char_map_initialize(&icm), EOK); - printf("\n\texclude bla null"); - int_char_map_exclude(&icm, "bla", 0); - TEST("find bla null", int_char_map_find(&icm, "bla", 0), NULL); - TEST("add bla x eok", int_char_map_add(&icm, "bla", 0, x), EOK); - TEST("find bla x", int_char_map_find(&icm, "bla", 0), x); - TEST("add bla y eexists", int_char_map_add(&icm, "bla", 0, y), EEXISTS); - printf("\n\texclude bla y"); - int_char_map_exclude(&icm, "bla", 0); - printf("\n\texclude bla null"); - int_char_map_exclude(&icm, "bla", 0); - TEST("add blabla v eok", int_char_map_add(&icm, "blabla", 0, v), EOK); - TEST("find blabla v", int_char_map_find(&icm, "blabla", 0), v); - TEST("add bla w eok", int_char_map_add(&icm, "bla", 0, w), EOK); - TEST("find bla w", int_char_map_find(&icm, "bla", 0), w); - printf("\n\texclude bla"); - int_char_map_exclude(&icm, "bla", 0); - TEST("find bla null", int_char_map_find(&icm, "bla", 0), NULL); - TEST("find blabla v", int_char_map_find(&icm, "blabla", 0), v); - TEST("add auto u eok", int_char_map_add(&icm, "auto", 0, u), EOK); - TEST("find auto u", int_char_map_find(&icm, "auto", 0), u); - printf("\n\tdestroy"); - int_char_map_destroy(&icm); - TEST("add ucho z einval", int_char_map_add(&icm, "ucho", 0, z), EINVAL); - printf("\nOK"); - - if(error){ - return EINVAL; - } - -#endif - -#if NET_SELF_TEST_GENERIC_FIELD + + TEST(int_char_map_add(&icm, "ucho", 0, z), EINVAL); + TEST(int_char_map_initialize(&icm), EOK); + TEST((int_char_map_exclude(&icm, "bla", 0), EOK), EOK); + TEST(int_char_map_find(&icm, "bla", 0), NULL); + TEST(int_char_map_add(&icm, "bla", 0, x), EOK); + TEST(int_char_map_find(&icm, "bla", 0), x); + TEST(int_char_map_add(&icm, "bla", 0, y), EEXISTS); + TEST((int_char_map_exclude(&icm, "bla", 0), EOK), EOK); + TEST((int_char_map_exclude(&icm, "bla", 0), EOK), EOK); + TEST(int_char_map_add(&icm, "blabla", 0, v), EOK); + TEST(int_char_map_find(&icm, "blabla", 0), v); + TEST(int_char_map_add(&icm, "bla", 0, w), EOK); + TEST(int_char_map_find(&icm, "bla", 0), w); + TEST((int_char_map_exclude(&icm, "bla", 0), EOK), EOK); + TEST(int_char_map_find(&icm, "bla", 0), NULL); + TEST(int_char_map_find(&icm, "blabla", 0), v); + TEST(int_char_map_add(&icm, "auto", 0, u), EOK); + TEST(int_char_map_find(&icm, "auto", 0), u); + TEST((int_char_map_destroy(&icm), EOK), EOK); + TEST(int_char_map_add(&icm, "ucho", 0, z), EINVAL); + + printf("\nGeneric field test"); + + XMALLOC(x, int); + XMALLOC(y, int); + XMALLOC(z, int); + XMALLOC(u, int); + XMALLOC(v, int); + XMALLOC(w, int); + int_field_t gf; - - x = (int *) malloc(sizeof(int)); - y = (int *) malloc(sizeof(int)); - z = (int *) malloc(sizeof(int)); - u = (int *) malloc(sizeof(int)); - v = (int *) malloc(sizeof(int)); - w = (int *) malloc(sizeof(int)); - gf.magic = 0; - printf("\nGeneric field test"); - TEST("add x einval", int_field_add(&gf, x), EINVAL); - TEST("count -1", int_field_count(&gf), -1); - TEST("initialize", int_field_initialize(&gf), EOK); - TEST("count 0", int_field_count(&gf), 0); - TEST("get 1 null", int_field_get_index(&gf, 1), NULL); - TEST("add x 0", int_field_add(&gf, x), 0); - TEST("get 0 x", int_field_get_index(&gf, 0), x); - int_field_exclude_index(&gf, 0); - TEST("get 0 null", int_field_get_index(&gf, 0), NULL); - TEST("add y 1", int_field_add(&gf, y), 1); - TEST("get 1 y", int_field_get_index(&gf, 1), y); - TEST("add z 2", int_field_add(&gf, z), 2); - TEST("get 2 z", int_field_get_index(&gf, 2), z); - TEST("get 1 y", int_field_get_index(&gf, 1), y); - TEST("count 3", int_field_count(&gf), 3); - TEST("add u 3", int_field_add(&gf, u), 3); - TEST("get 3 u", int_field_get_index(&gf, 3), u); - TEST("add v 4", int_field_add(&gf, v), 4); - TEST("get 4 v", int_field_get_index(&gf, 4), v); - TEST("add w 5", int_field_add(&gf, w), 5); - TEST("get 5 w", int_field_get_index(&gf, 5), w); - TEST("count 6", int_field_count(&gf), 6); - int_field_exclude_index(&gf, 1); - TEST("get 1 null", int_field_get_index(&gf, 1), NULL); - TEST("get 3 u", int_field_get_index(&gf, 3), u); - int_field_exclude_index(&gf, 7); - TEST("get 3 u", int_field_get_index(&gf, 3), u); - TEST("get 5 w", int_field_get_index(&gf, 5), w); - int_field_exclude_index(&gf, 4); - TEST("get 4 null", int_field_get_index(&gf, 4), NULL); - printf("\n\tdestroy"); - int_field_destroy(&gf); - TEST("count -1", int_field_count(&gf), -1); - printf("\nOK"); - - if(error){ - return EINVAL; - } - -#endif - -#if NET_SELF_TEST_INT_MAP + + TEST(int_field_add(&gf, x), EINVAL); + TEST(int_field_count(&gf), -1); + TEST(int_field_initialize(&gf), EOK); + TEST(int_field_count(&gf), 0); + TEST(int_field_get_index(&gf, 1), NULL); + TEST(int_field_add(&gf, x), 0); + TEST(int_field_get_index(&gf, 0), x); + TEST((int_field_exclude_index(&gf, 0), EOK), EOK); + TEST(int_field_get_index(&gf, 0), NULL); + TEST(int_field_add(&gf, y), 1); + TEST(int_field_get_index(&gf, 1), y); + TEST(int_field_add(&gf, z), 2); + TEST(int_field_get_index(&gf, 2), z); + TEST(int_field_get_index(&gf, 1), y); + TEST(int_field_count(&gf), 3); + TEST(int_field_add(&gf, u), 3); + TEST(int_field_get_index(&gf, 3), u); + TEST(int_field_add(&gf, v), 4); + TEST(int_field_get_index(&gf, 4), v); + TEST(int_field_add(&gf, w), 5); + TEST(int_field_get_index(&gf, 5), w); + TEST(int_field_count(&gf), 6); + TEST((int_field_exclude_index(&gf, 1), EOK), EOK); + TEST(int_field_get_index(&gf, 1), NULL); + TEST(int_field_get_index(&gf, 3), u); + TEST((int_field_exclude_index(&gf, 7), EOK), EOK); + TEST(int_field_get_index(&gf, 3), u); + TEST(int_field_get_index(&gf, 5), w); + TEST((int_field_exclude_index(&gf, 4), EOK), EOK); + TEST(int_field_get_index(&gf, 4), NULL); + TEST((int_field_destroy(&gf), EOK), EOK); + TEST(int_field_count(&gf), -1); + + printf("\nInt map test"); + + XMALLOC(x, int); + XMALLOC(y, int); + XMALLOC(z, int); + XMALLOC(u, int); + XMALLOC(v, int); + XMALLOC(w, int); + int_map_t im; - - x = (int *) malloc(sizeof(int)); - y = (int *) malloc(sizeof(int)); - z = (int *) malloc(sizeof(int)); - u = (int *) malloc(sizeof(int)); - v = (int *) malloc(sizeof(int)); - w = (int *) malloc(sizeof(int)); - im.magic = 0; - printf("\nInt map test"); - TEST("add 1 x einval", int_map_add(&im, 1, x), EINVAL); - TEST("count -1", int_map_count(&im), -1); - TEST("initialize", int_map_initialize(&im), EOK); - TEST("count 0", int_map_count(&im), 0); - TEST("find 1 null", int_map_find(&im, 1), NULL); - TEST("add 1 x 0", int_map_add(&im, 1, x), 0); - TEST("find 1 x", int_map_find(&im, 1), x); - int_map_exclude(&im, 1); - TEST("find 1 null", int_map_find(&im, 1), NULL); - TEST("add 1 y 1", int_map_add(&im, 1, y), 1); - TEST("find 1 y", int_map_find(&im, 1), y); - TEST("add 4 z 2", int_map_add(&im, 4, z), 2); - TEST("get 2 z", int_map_get_index(&im, 2), z); - TEST("find 4 z", int_map_find(&im, 4), z); - TEST("find 1 y", int_map_find(&im, 1), y); - TEST("count 3", int_map_count(&im), 3); - TEST("add 2 u 3", int_map_add(&im, 2, u), 3); - TEST("find 2 u", int_map_find(&im, 2), u); - TEST("add 3 v 4", int_map_add(&im, 3, v), 4); - TEST("find 3 v", int_map_find(&im, 3), v); - TEST("get 4 v", int_map_get_index(&im, 4), v); - TEST("add 6 w 5", int_map_add(&im, 6, w), 5); - TEST("find 6 w", int_map_find(&im, 6), w); - TEST("count 6", int_map_count(&im), 6); - int_map_exclude(&im, 1); - TEST("find 1 null", int_map_find(&im, 1), NULL); - TEST("find 2 u", int_map_find(&im, 2), u); - int_map_exclude(&im, 7); - TEST("find 2 u", int_map_find(&im, 2), u); - TEST("find 6 w", int_map_find(&im, 6), w); - int_map_exclude_index(&im, 4); - TEST("get 4 null", int_map_get_index(&im, 4), NULL); - TEST("find 3 null", int_map_find(&im, 3), NULL); - printf("\n\tdestroy"); - int_map_destroy(&im); - TEST("count -1", int_map_count(&im), -1); - printf("\nOK"); - - if(error){ - return EINVAL; - } - -#endif - -#if NET_SELF_TEST_MEASURED_STRINGS - measured_string_ref string; - + + TEST(int_map_add(&im, 1, x), EINVAL); + TEST(int_map_count(&im), -1); + TEST(int_map_initialize(&im), EOK); + TEST(int_map_count(&im), 0); + TEST(int_map_find(&im, 1), NULL); + TEST(int_map_add(&im, 1, x), 0); + TEST(int_map_find(&im, 1), x); + TEST((int_map_exclude(&im, 1), EOK), EOK); + TEST(int_map_find(&im, 1), NULL); + TEST(int_map_add(&im, 1, y), 1); + TEST(int_map_find(&im, 1), y); + TEST(int_map_add(&im, 4, z), 2); + TEST(int_map_get_index(&im, 2), z); + TEST(int_map_find(&im, 4), z); + TEST(int_map_find(&im, 1), y); + TEST(int_map_count(&im), 3); + TEST(int_map_add(&im, 2, u), 3); + TEST(int_map_find(&im, 2), u); + TEST(int_map_add(&im, 3, v), 4); + TEST(int_map_find(&im, 3), v); + TEST(int_map_get_index(&im, 4), v); + TEST(int_map_add(&im, 6, w), 5); + TEST(int_map_find(&im, 6), w); + TEST(int_map_count(&im), 6); + TEST((int_map_exclude(&im, 1), EOK), EOK); + TEST(int_map_find(&im, 1), NULL); + TEST(int_map_find(&im, 2), u); + TEST((int_map_exclude(&im, 7), EOK), EOK); + TEST(int_map_find(&im, 2), u); + TEST(int_map_find(&im, 6), w); + TEST((int_map_exclude_index(&im, 4), EOK), EOK); + TEST(int_map_get_index(&im, 4), NULL); + TEST(int_map_find(&im, 3), NULL); + TEST((int_map_destroy(&im), EOK), EOK); + TEST(int_map_count(&im), -1); + printf("\nMeasured strings test"); - string = measured_string_create_bulk("I am a measured string!", 0); - printf("\n%x, %s at %x of %d", string, string->value, string->value, string->length); - printf("\nOK"); -#endif - + + measured_string_ref string = + measured_string_create_bulk("I am a measured string!", 0); + printf("\n%x, %s at %x of %d\n", string, string->value, string->value, + string->length); + return EOK; } -#endif - /** @} */ Index: uspace/srv/net/netstart/self_test.h =================================================================== --- uspace/srv/net/netstart/self_test.h (revision 849ed54afbef3ad0ec3af831e93a1353f9eaaf0f) +++ uspace/srv/net/netstart/self_test.h (revision 4011fa009e7bf59bf7c5a27c73601b2a1c0db7c2) @@ -28,10 +28,5 @@ /** @addtogroup net - * @{ - */ - -/** @file - * Self tests. - * @see configuration.h + * @{ */ @@ -39,23 +34,5 @@ #define __SELF_TEST_H__ -#include "configuration.h" - -/** Self test start function. - * Runs all the configured self tests. - * @see configuration.h - * @returns EOK on success. - * @returns The first error occurred. - */ -#if NET_SELF_TEST - extern int self_test(void); - -#else - -#include - -#define self_test() EOK - -#endif #endif