X-Git-Url: https://git.m6w6.name/?a=blobdiff_plain;f=tests%2Ftest.c;h=653cc7313a5ffebf80a23889f63283a73f4c43fa;hb=287c4d7cd3873c6ae9f7908bd4f34d6fbc9efcd4;hp=78fe4a70ff8b284ee4db96e3256ef4eed46135bb;hpb=ef9ddf55563059fcf3608bab479e15f28e9ceb0f;p=m6w6%2Flibmemcached diff --git a/tests/test.c b/tests/test.c index 78fe4a70..653cc731 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,13 +15,21 @@ #include #include #include +#include #include #include #include -#include "server.h" #include "test.h" +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; @@ -25,30 +41,99 @@ static long int timedif(struct timeval a, struct timeval b) 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,70 +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.collection_startup) + { + world.collection_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) { - 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; }