X-Git-Url: https://git.m6w6.name/?a=blobdiff_plain;ds=sidebyside;f=tests%2Flibmemcached_world.h;h=dfdddbefe00796336603fa2af813c8c9ef42eef8;hb=12a07e58df95bb8dbe167e4157b29c910177ade8;hp=c26323119b35696044d2e13f94ffc0d0dc23a521;hpb=a246ac50a88e4af750fd2dd209eff94dcadf72d2;p=awesomized%2Flibmemcached diff --git a/tests/libmemcached_world.h b/tests/libmemcached_world.h index c2632311..dfdddbef 100644 --- a/tests/libmemcached_world.h +++ b/tests/libmemcached_world.h @@ -4,25 +4,35 @@ * * Use and distribution licensed under the BSD license. See * the COPYING file in the parent directory for full text. - * + * * Description: This is the startup bits for any libmemcached test. * */ -#ifdef __cplusplus -extern "C" { -#endif +#pragma once + +#include /* The structure we use for the test system */ -typedef struct +struct libmemcached_test_container_st { server_startup_st construct; + memcached_st *parent; memcached_st *memc; -} libmemcached_test_container_st; + + libmemcached_test_container_st() : + parent(NULL), + memc(NULL) + { } +}; + +#ifdef __cplusplus +extern "C" { +#endif /* Prototypes for functions we will pass to test framework */ -libmemcached_test_container_st *world_create(void); -test_return_t world_collection_startup(libmemcached_test_container_st *); +libmemcached_test_container_st *world_create(test_return_t *error); +test_return_t world_test_startup(libmemcached_test_container_st *); test_return_t world_flush(libmemcached_test_container_st *container); test_return_t world_pre_run(libmemcached_test_container_st *); @@ -30,35 +40,64 @@ test_return_t world_post_run(libmemcached_test_container_st *); test_return_t world_on_error(test_return_t, libmemcached_test_container_st *); test_return_t world_destroy(libmemcached_test_container_st *); -static libmemcached_test_container_st global_container; +/** + @note generic shutdown/startup for libmemcached tests. +*/ +test_return_t world_container_startup(libmemcached_test_container_st *container); +test_return_t world_container_shutdown(libmemcached_test_container_st *container); -libmemcached_test_container_st *world_create(void) +libmemcached_test_container_st *world_create(test_return_t *error) { - memset(&global_container, 0, sizeof(global_container)); - global_container.construct.count= SERVERS_TO_CREATE; - global_container.construct.udp= 0; - server_startup(&global_container.construct); + libmemcached_test_container_st *global_container= new libmemcached_test_container_st(); + if (not server_startup(&global_container->construct)) + { + *error= TEST_FAILURE; + return NULL; + } - assert(global_container.construct.servers); + *error= TEST_SUCCESS; - return &global_container; + return global_container; } +test_return_t world_container_startup(libmemcached_test_container_st *container) +{ + char buffer[BUFSIZ]; -test_return_t world_collection_startup(libmemcached_test_container_st *container) + test_compare_got(MEMCACHED_SUCCESS, + libmemcached_check_configuration(container->construct.server_list.c_str(), container->construct.server_list.size(), + buffer, sizeof(buffer)), + buffer); + + assert(not container->parent); + container->parent= memcached(container->construct.server_list.c_str(), container->construct.server_list.size()); + test_true(container->parent); + + return TEST_SUCCESS; +} + +test_return_t world_container_shutdown(libmemcached_test_container_st *container) { - memcached_return_t rc; - container->memc= memcached_create(NULL); - test_truth((container->memc != NULL)); + memcached_free(container->parent); + container->parent= NULL; - rc= memcached_server_push(container->memc, container->construct.servers); - test_truth(rc == MEMCACHED_SUCCESS); + return TEST_SUCCESS; +} + +test_return_t world_test_startup(libmemcached_test_container_st *container) +{ + assert(container); + assert(not container->memc); + assert(container->parent); + container->memc= memcached_clone(NULL, container->parent); + test_true(container->memc); return TEST_SUCCESS; } test_return_t world_flush(libmemcached_test_container_st *container) { + assert(container->memc); memcached_flush(container->memc, 0); memcached_quit(container->memc); @@ -67,12 +106,14 @@ test_return_t world_flush(libmemcached_test_container_st *container) test_return_t world_pre_run(libmemcached_test_container_st *container) { - uint32_t loop; - - for (loop= 0; loop < memcached_server_list_count(container->construct.servers); loop++) + assert(container->memc); + for (uint32_t loop= 0; loop < memcached_server_list_count(container->memc->servers); loop++) { - test_truth(container->memc->hosts[loop].fd == -1); - test_truth(container->memc->hosts[loop].cursor_active == 0); + memcached_server_instance_st instance= + memcached_server_instance_by_position(container->memc, loop); + + test_compare(-1, instance->fd); + test_compare(0, instance->cursor_active); } return TEST_SUCCESS; @@ -81,7 +122,7 @@ test_return_t world_pre_run(libmemcached_test_container_st *container) test_return_t world_post_run(libmemcached_test_container_st *container) { - assert(container->memc); + test_true(container->memc); return TEST_SUCCESS; } @@ -89,19 +130,25 @@ test_return_t world_post_run(libmemcached_test_container_st *container) test_return_t world_on_error(test_return_t test_state, libmemcached_test_container_st *container) { (void)test_state; + assert(container->memc); memcached_free(container->memc); - + container->memc= NULL; + return TEST_SUCCESS; } test_return_t world_destroy(libmemcached_test_container_st *container) { server_startup_st *construct= &container->construct; - memcached_server_st *servers= container->construct.servers; - memcached_server_list_free(servers); server_shutdown(construct); +#ifdef LIBMEMCACHED_WITH_SASL_SUPPORT + sasl_done(); +#endif + + delete container; + return TEST_SUCCESS; } @@ -110,6 +157,8 @@ static test_return_t _runner_default(libmemcached_test_callback_fn func, libmemc { if (func) { + assert(container); + assert(container->memc); return func(container->memc); } else @@ -118,24 +167,48 @@ static test_return_t _runner_default(libmemcached_test_callback_fn func, libmemc } } +static test_return_t _pre_runner_default(libmemcached_test_callback_fn func, libmemcached_test_container_st *container) +{ + if (func) + { + return func(container->parent); + } + else + { + return TEST_SUCCESS; + } +} + +static test_return_t _post_runner_default(libmemcached_test_callback_fn func, libmemcached_test_container_st *container) +{ + if (func) + { + return func(container->parent); + } + else + { + return TEST_SUCCESS; + } +} + #ifdef __cplusplus } #endif #ifdef __cplusplus -static world_runner_st defualt_libmemcached_runner= { - reinterpret_cast(_runner_default), - reinterpret_cast(_runner_default), - reinterpret_cast(_runner_default) +static Runner defualt_libmemcached_runner= { + reinterpret_cast(_pre_runner_default), + reinterpret_cast(_runner_default), + reinterpret_cast(_post_runner_default) }; #else -static world_runner_st defualt_libmemcached_runner= { - (test_callback_runner_fn)_runner_default, +static Runner defualt_libmemcached_runner= { + (test_callback_runner_fn)_pre_runner_default, (test_callback_runner_fn)_runner_default, - (test_callback_runner_fn)_runner_default + (test_callback_runner_fn)_post_runner_default }; #endif