X-Git-Url: https://git.m6w6.name/?a=blobdiff_plain;f=tests%2Fatomsmasher.c;h=8563e4ec19e66bb4cf7c47de93839db3e80efac0;hb=9f7b73d459c70cbed3bbc29b1fef626eb4cf6f3c;hp=490a3f92f202ffc8d8317efee6253b8cd15dd80b;hpb=fd3e3ff98f94ba0f60abfd49ca393d1d5fb4d102;p=m6w6%2Flibmemcached diff --git a/tests/atomsmasher.c b/tests/atomsmasher.c index 490a3f92..8563e4ec 100644 --- a/tests/atomsmasher.c +++ b/tests/atomsmasher.c @@ -12,29 +12,25 @@ /* Sample test application. */ -#include "libmemcached/common.h" +#include "config.h" + +#include "libmemcached/memcached.h" +#include "libmemcached/watchpoint.h" #include #include +#include #include #include #include #include #include #include -#include "server.h" -#include "../clients/generator.h" -#include "../clients/execute.h" - -#ifndef INT64_MAX -#define INT64_MAX LONG_MAX -#endif -#ifndef INT32_MAX -#define INT32_MAX INT_MAX -#endif - +#include +#include -#include "test.h" +#include +#include /* Number of items generated for tests */ #define GLOBAL_COUNT 100000 @@ -47,25 +43,27 @@ 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 *memc __attribute__((unused))) +static test_return_t cleanup_pairs(memcached_st *memc) { + (void)memc; pairs_free(global_pairs); - return 0; + return EXIT_SUCCESS; } -static test_return_t generate_pairs(memcached_st *memc __attribute__((unused))) +static test_return_t generate_pairs(memcached_st *memc) { + (void)memc; global_pairs= pairs_generate(GLOBAL_COUNT, 400); global_count= GLOBAL_COUNT; for (size_t x= 0; x < global_count; x++) { - global_keys[x]= global_pairs[x].key; + global_keys[x]= global_pairs[x].key; global_keys_length[x]= global_pairs[x].key_length; } - return 0; + return EXIT_SUCCESS; } static test_return_t drizzle(memcached_st *memc) @@ -101,12 +99,12 @@ infinite: WATCHPOINT_ERROR(rc); WATCHPOINT_ASSERT(rc); } - } + } else { - rc= memcached_set(memc, global_pairs[test_bit].key, + rc= memcached_set(memc, global_pairs[test_bit].key, global_pairs[test_bit].key_length, - global_pairs[test_bit].value, + global_pairs[test_bit].value, global_pairs[test_bit].value_length, 0, 0); if (rc != MEMCACHED_SUCCESS && rc != MEMCACHED_BUFFERED) @@ -130,7 +128,7 @@ static test_return_t pre_nonblock(memcached_st *memc) return TEST_SUCCESS; } -/* +/* Set the value, then quit to make sure it is flushed. Come back in and test that add fails. */ @@ -143,26 +141,26 @@ static test_return_t add_test(memcached_st *memc) setting_value= memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_NO_BLOCK); - rc= memcached_set(memc, key, strlen(key), + rc= memcached_set(memc, key, strlen(key), value, strlen(value), (time_t)0, (uint32_t)0); - test_truth(rc == MEMCACHED_SUCCESS || rc == MEMCACHED_BUFFERED); + test_true(rc == MEMCACHED_SUCCESS || rc == MEMCACHED_BUFFERED); memcached_quit(memc); - rc= memcached_add(memc, key, strlen(key), + rc= memcached_add(memc, key, strlen(key), value, strlen(value), (time_t)0, (uint32_t)0); /* Too many broken OS'es have broken loopback in async, so we can't be sure of the result */ if (setting_value) { - test_truth(rc == MEMCACHED_NOTSTORED || rc == MEMCACHED_STORED); + test_true(rc == MEMCACHED_NOTSTORED || rc == MEMCACHED_STORED); } else { - test_truth(rc == MEMCACHED_NOTSTORED); + test_true(rc == MEMCACHED_NOTSTORED); } - return 0; + return EXIT_SUCCESS; } /* @@ -175,7 +173,7 @@ static test_return_t many_adds(memcached_st *memc) { add_test(memc); } - return 0; + return EXIT_SUCCESS; } test_st smash_tests[] ={ @@ -186,10 +184,90 @@ test_st smash_tests[] ={ {0, 0, 0} }; +#define BENCHMARK_TEST_LOOP 20000 + +struct benchmark_state_st +{ + bool create_init; + bool clone_init; + memcached_st *create; + memcached_st *clone; +} benchmark_state; + +static test_return_t memcached_create_benchmark(memcached_st *memc) +{ + (void)memc; + benchmark_state.create_init= true; + + for (size_t x= 0; x < BENCHMARK_TEST_LOOP; x++) + { + memcached_st *ptr; + ptr= memcached_create(&benchmark_state.create[x]); + + test_true(ptr); + } + + return TEST_SUCCESS; +} + +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++) + { + memcached_st *ptr; + ptr= memcached_clone(&benchmark_state.clone[x], memc); + + test_true(ptr); + } + + return TEST_SUCCESS; +} + +static test_return_t pre_allocate(memcached_st *memc) +{ + (void)memc; + memset(&benchmark_state, 0, sizeof(benchmark_state)); + + benchmark_state.create= (memcached_st *)calloc(BENCHMARK_TEST_LOOP, sizeof(memcached_st)); + test_true(benchmark_state.create); + benchmark_state.clone= (memcached_st *)calloc(BENCHMARK_TEST_LOOP, sizeof(memcached_st)); + test_true(benchmark_state.clone); + + return TEST_SUCCESS; +} + +static test_return_t post_allocate(memcached_st *memc) +{ + (void)memc; + for (size_t x= 0; x < BENCHMARK_TEST_LOOP; x++) + { + if (benchmark_state.create_init) + memcached_free(&benchmark_state.create[x]); + + if (benchmark_state.clone_init) + memcached_free(&benchmark_state.clone[x]); + } + + free(benchmark_state.create); + free(benchmark_state.clone); + + return TEST_SUCCESS; +} + + +test_st micro_tests[] ={ + {"memcached_create", 1, (test_callback_fn)memcached_create_benchmark }, + {"memcached_clone", 1, (test_callback_fn)memcached_clone_benchmark }, + {0, 0, 0} +}; + collection_st collection[] ={ {"smash", 0, 0, smash_tests}, {"smash_nonblock", (test_callback_fn)pre_nonblock, 0, smash_tests}, + {"micro-benchmark", (test_callback_fn)pre_allocate, (test_callback_fn)post_allocate, micro_tests}, {0, 0, 0, 0} };