X-Git-Url: https://git.m6w6.name/?a=blobdiff_plain;f=tests%2Flibmemcached-1.0%2Fatomsmasher.cc;h=e5d53b60ea76079026aa300385d3ecac8471e658;hb=23bbe3972dada1e21493437ba64be129e86b59fc;hp=bab25d031c04e4d9af33d7602b2da261b90b0566;hpb=2565909cfc50c91a28a91da59131815f3d23227d;p=m6w6%2Flibmemcached diff --git a/tests/libmemcached-1.0/atomsmasher.cc b/tests/libmemcached-1.0/atomsmasher.cc index bab25d03..e5d53b60 100644 --- a/tests/libmemcached-1.0/atomsmasher.cc +++ b/tests/libmemcached-1.0/atomsmasher.cc @@ -34,6 +34,8 @@ #include +#include "tests/libmemcached-1.0/generate.h" + using namespace libtest; /* Number of items generated for tests */ @@ -41,25 +43,23 @@ using namespace libtest; /* Number of times to run the test loop */ #define TEST_COUNTER 500000 -static uint32_t global_count; static pairs_st *global_pairs; static char *global_keys[GLOBAL_COUNT]; static size_t global_keys_length[GLOBAL_COUNT]; -static test_return_t cleanup_pairs(memcached_st *) +static test_return_t cleanup_pairs_TEST(memcached_st *) { pairs_free(global_pairs); return TEST_SUCCESS; } -static test_return_t generate_pairs(memcached_st *) +static test_return_t generate_pairs_TEST(memcached_st *) { global_pairs= pairs_generate(GLOBAL_COUNT, 400); - global_count= GLOBAL_COUNT; - for (size_t x= 0; x < global_count; x++) + for (ptrdiff_t x= 0; x < GLOBAL_COUNT; x++) { global_keys[x]= global_pairs[x].key; global_keys_length[x]= global_pairs[x].key_length; @@ -68,26 +68,22 @@ static test_return_t generate_pairs(memcached_st *) return TEST_SUCCESS; } -static test_return_t drizzle(memcached_st *memc) +static test_return_t drizzle_TEST(memcached_st *memc) { infinite: - for (size_t x= 0; x < TEST_COUNTER; x++) + for (ptrdiff_t x= 0; x < TEST_COUNTER; x++) { memcached_return_t rc; - char *return_value; - size_t return_value_length; - uint32_t flags; - - uint32_t test_bit; - uint8_t which; - test_bit= (uint32_t)(random() % GLOBAL_COUNT); - which= (uint8_t)(random() % 2); + uint32_t test_bit= (uint32_t)(random() % GLOBAL_COUNT); + uint8_t which= (uint8_t)(random() % 2); if (which == 0) { - return_value= memcached_get(memc, global_keys[test_bit], global_keys_length[test_bit], - &return_value_length, &flags, &rc); + size_t return_value_length; + uint32_t flags; + char* return_value= memcached_get(memc, global_keys[test_bit], global_keys_length[test_bit], + &return_value_length, &flags, &rc); if (rc == MEMCACHED_SUCCESS && return_value) { free(return_value); @@ -125,7 +121,7 @@ infinite: static test_return_t pre_nonblock(memcached_st *memc) { - memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_NO_BLOCK, 0); + test_skip(MEMCACHED_SUCCESS, memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_NO_BLOCK, 0)); return TEST_SUCCESS; } @@ -139,10 +135,9 @@ static test_return_t add_test(memcached_st *memc) const char *key= "foo"; const char *value= "when we sanitize"; - memcached_return_t rc; - rc= memcached_set(memc, key, strlen(key), - value, strlen(value), - (time_t)0, (uint32_t)0); + memcached_return_t rc= memcached_set(memc, key, strlen(key), + value, strlen(value), + time_t(0), uint32_t(0)); test_true_got(rc == MEMCACHED_SUCCESS or rc == MEMCACHED_BUFFERED, memcached_strerror(NULL, rc)); memcached_quit(memc); rc= memcached_add(memc, key, strlen(key), @@ -174,7 +169,7 @@ static test_return_t add_test(memcached_st *memc) static test_return_t many_adds(memcached_st *memc) { test_true(memc); - for (size_t x= 0; x < TEST_COUNTER; x++) + for (ptrdiff_t x= 0; x < TEST_COUNTER; x++) { test_compare_got(TEST_SUCCESS, add_test(memc), x); } @@ -182,9 +177,9 @@ static test_return_t many_adds(memcached_st *memc) } test_st smash_tests[] ={ - {"generate_pairs", true, (test_callback_fn*)generate_pairs }, - {"drizzle", true, (test_callback_fn*)drizzle }, - {"cleanup", true, (test_callback_fn*)cleanup_pairs }, + {"generate_pairs", true, (test_callback_fn*)generate_pairs_TEST }, + {"drizzle", true, (test_callback_fn*)drizzle_TEST }, + {"cleanup", true, (test_callback_fn*)cleanup_pairs_TEST }, {"many_adds", true, (test_callback_fn*)many_adds }, {0, 0, 0} }; @@ -203,10 +198,9 @@ static test_return_t memcached_create_benchmark(memcached_st *) { benchmark_state.create_init= true; - for (size_t x= 0; x < BENCHMARK_TEST_LOOP; x++) + for (ptrdiff_t x= 0; x < BENCHMARK_TEST_LOOP; x++) { - memcached_st *ptr; - ptr= memcached_create(&benchmark_state.create[x]); + memcached_st *ptr= memcached_create(&benchmark_state.create[x]); test_true(ptr); } @@ -218,10 +212,9 @@ static test_return_t memcached_clone_benchmark(memcached_st *memc) { benchmark_state.clone_init= true; - for (size_t x= 0; x < BENCHMARK_TEST_LOOP; x++) + for (ptrdiff_t x= 0; x < BENCHMARK_TEST_LOOP; x++) { - memcached_st *ptr; - ptr= memcached_clone(&benchmark_state.clone[x], memc); + memcached_st *ptr= memcached_clone(&benchmark_state.clone[x], memc); test_true(ptr); } @@ -243,7 +236,7 @@ static test_return_t pre_allocate(memcached_st *) static test_return_t post_allocate(memcached_st *) { - for (size_t x= 0; x < BENCHMARK_TEST_LOOP; x++) + for (ptrdiff_t x= 0; x < BENCHMARK_TEST_LOOP; x++) { if (benchmark_state.create_init) { @@ -278,25 +271,14 @@ collection_st collection[] ={ }; -#define TEST_PORT_BASE MEMCACHED_DEFAULT_PORT +10 - #include "tests/libmemcached_world.h" void get_world(Framework *world) { - world->collections= collection; - - world->_create= (test_callback_create_fn*)world_create; - world->_destroy= (test_callback_destroy_fn*)world_destroy; - - world->item._startup= (test_callback_fn*)world_test_startup; - world->item._flush= (test_callback_fn*)world_flush; - world->item.set_pre((test_callback_fn*)world_pre_run); - world->item.set_post((test_callback_fn*)world_post_run); - world->_on_error= (test_callback_error_fn*)world_on_error; + world->collections(collection); - world->collection_startup= (test_callback_fn*)world_container_startup; - world->collection_shutdown= (test_callback_fn*)world_container_shutdown; + world->create((test_callback_create_fn*)world_create); + world->destroy((test_callback_destroy_fn*)world_destroy); - world->set_runner(&defualt_libmemcached_runner); + world->set_runner(new LibmemcachedRunner); }