X-Git-Url: https://git.m6w6.name/?a=blobdiff_plain;f=tests%2Ftest.c;h=ee6f94dcd3e5f0d1d6928513f4ecdc0e5764e1ed;hb=e26021d3a6abec207f79f129d620cef1c9a18e9a;hp=47db82c733a2e43aec483f3e5fe28d281a570e28;hpb=1d7f999b7d38db3308a0533a83fea23987fb0178;p=m6w6%2Flibmemcached diff --git a/tests/test.c b/tests/test.c index 47db82c7..ee6f94dc 100644 --- a/tests/test.c +++ b/tests/test.c @@ -1,3 +1,11 @@ +/* uTest + * Copyright (C) 2006-2009 Brian Aker + * All rights reserved. + * + * Use and distribution licensed under the BSD license. See + * the COPYING file in the parent directory for full text. + */ + /* Sample test application. */ @@ -7,48 +15,125 @@ #include #include #include +#include #include #include #include -#include "server.h" #include "test.h" -long int timedif(struct timeval a, struct timeval b) +static void world_stats_print(world_stats_st *stats) +{ + fprintf(stderr, "Total\t\t\t\t%u\n", stats->total); + fprintf(stderr, "\tFailed\t\t\t%u\n", stats->failed); + fprintf(stderr, "\tSkipped\t\t\t%u\n", stats->skipped); + fprintf(stderr, "\tSucceeded\t\t%u\n", stats->success); +} + +static long int timedif(struct timeval a, struct timeval b) { - register int us, s; + long us, s; - us = a.tv_usec - b.tv_usec; + us = (int)(a.tv_usec - b.tv_usec); us /= 1000; - s = a.tv_sec - b.tv_sec; + s = (int)(a.tv_sec - b.tv_sec); s *= 1000; return s + us; } +const char *test_strerror(test_return_t code) +{ + switch (code) { + case TEST_SUCCESS: + return "ok"; + case TEST_FAILURE: + return "failed"; + case TEST_MEMORY_ALLOCATION_FAILURE: + return "memory allocation"; + case TEST_SKIPPED: + return "skipped"; + case TEST_MAXIMUM_RETURN: + default: + fprintf(stderr, "Unknown return value\n"); + abort(); + } +} + +void create_core(void) +{ + if (getenv("LIBMEMCACHED_NO_COREDUMP") == NULL) + { + pid_t pid= fork(); + + if (pid == 0) + { + abort(); + } + else + { + while (waitpid(pid, NULL, 0) != pid) + { + ; + } + } + } +} + + +static test_return_t _runner_default(test_callback_fn func, void *p) +{ + if (func) + { + return func(p); + } + else + { + return TEST_SUCCESS; + } +} + +static world_runner_st defualt_runners= { + _runner_default, + _runner_default, + _runner_default +}; + + int main(int argc, char *argv[]) { + test_return_t return_code; unsigned int x; char *collection_to_run= NULL; char *wildcard= NULL; - server_startup_st *startup_ptr; - memcached_server_st *servers; world_st world; collection_st *collection; collection_st *next; - uint8_t failed; void *world_ptr; - memset(&world, 0, sizeof(world_st)); + world_stats_st stats; + + memset(&stats, 0, sizeof(stats)); + memset(&world, 0, sizeof(world)); get_world(&world); + + if (! world.runner) + { + world.runner= &defualt_runners; + } + collection= world.collections; if (world.create) - world_ptr= world.create(); - else + { + test_return_t error; + world_ptr= world.create(&error); + if (error != TEST_SUCCESS) + exit(1); + } + else + { world_ptr= NULL; - - startup_ptr= (server_startup_st *)world_ptr; - servers= (memcached_server_st *)startup_ptr->servers; + } if (argc > 1) collection_to_run= argv[1]; @@ -68,71 +153,106 @@ int main(int argc, char *argv[]) for (x= 0; run->name; run++) { - unsigned int loop; - memcached_st *memc; - memcached_return rc; struct timeval start_time, end_time; - long int load_time; + long int load_time= 0; if (wildcard && fnmatch(wildcard, run->name, 0)) continue; fprintf(stderr, "Testing %s", run->name); - memc= memcached_create(NULL); - assert(memc); - - rc= memcached_server_push(memc, servers); - assert(rc == MEMCACHED_SUCCESS); + if (world.test_startup) + { + world.test_startup(world_ptr); + } - if (run->requires_flush) + if (run->requires_flush && world.flush) { - memcached_flush(memc, 0); - memcached_quit(memc); + world.flush(world_ptr); } - for (loop= 0; loop < memcached_server_list_count(servers); loop++) + if (world.pre_run) { - assert(memc->hosts[loop].fd == -1); - assert(memc->hosts[loop].cursor_active == 0); + world.pre_run(world_ptr); } - if (next->pre) + + if (next->pre && world.runner->pre) { - memcached_return rc; - rc= next->pre(memc); + return_code= world.runner->pre(next->pre, world_ptr); - if (rc != MEMCACHED_SUCCESS) + if (return_code != TEST_SUCCESS) { - fprintf(stderr, "\t\t\t\t\t [ skipping ]\n"); goto error; } } gettimeofday(&start_time, NULL); - failed= run->function(memc); + return_code= world.runner->run(run->test_fn, world_ptr); gettimeofday(&end_time, NULL); load_time= timedif(end_time, start_time); - if (failed) - fprintf(stderr, "\t\t\t\t\t %ld.%03ld [ failed ]\n", load_time / 1000, - load_time % 1000); - else - fprintf(stderr, "\t\t\t\t\t %ld.%03ld [ ok ]\n", load_time / 1000, - load_time % 1000); - if (next->post) - (void)next->post(memc); + if (next->post && world.runner->post) + { + (void) world.runner->post(next->post, world_ptr); + } + + if (world.post_run) + { + world.post_run(world_ptr); + } - assert(memc); error: - memcached_free(memc); + stats.total++; + + fprintf(stderr, "\t\t\t\t\t"); + + switch (return_code) + { + case TEST_SUCCESS: + fprintf(stderr, "%ld.%03ld ", load_time / 1000, load_time % 1000); + stats.success++; + break; + case TEST_FAILURE: + stats.failed++; + break; + case TEST_SKIPPED: + stats.skipped++; + break; + case TEST_MEMORY_ALLOCATION_FAILURE: + case TEST_MAXIMUM_RETURN: + default: + break; + } + + fprintf(stderr, "[ %s ]\n", test_strerror(return_code)); + + if (world.on_error) + { + test_return_t rc; + rc= world.on_error(return_code, world_ptr); + + if (rc != TEST_SUCCESS) + break; + } } } fprintf(stderr, "All tests completed successfully\n\n"); if (world.destroy) - world.destroy(world_ptr); + { + test_return_t error; + error= world.destroy(world_ptr); + + if (error != TEST_SUCCESS) + { + fprintf(stderr, "Failure during shutdown.\n"); + stats.failed++; // We do this to make our exit code return 1 + } + } + + world_stats_print(&stats); - return 0; + return stats.failed == 0 ? 0 : 1; }