X-Git-Url: https://git.m6w6.name/?a=blobdiff_plain;f=tests%2Fmem_functions.c;h=ccd4b95b3ac000978d0edde406f6dd5070234ca8;hb=b95041363ea69ccfb9eacb6bba1852814c32b4ee;hp=357ea23760d4380ec95b644733e4242e6b8edeff;hpb=7bcddad3df8a0382e712c3a47ca9a1813dea10af;p=awesomized%2Flibmemcached diff --git a/tests/mem_functions.c b/tests/mem_functions.c index 357ea237..ccd4b95b 100644 --- a/tests/mem_functions.c +++ b/tests/mem_functions.c @@ -26,13 +26,17 @@ #include "libmemcached/common.h" -#include "server.h" +#include + #include "clients/generator.h" #include "clients/execute.h" #define SMALL_STRING_LEN 1024 -#include "test.h" +#include +#include "tests/parser.h" +#include "tests/replication.h" +#include "tests/print.h" #ifdef HAVE_LIBMEMCACHEDUTIL @@ -55,9 +59,10 @@ static size_t global_keys_length[GLOBAL_COUNT]; static test_return_t pre_binary(memcached_st *memc); -static test_return_t init_test(memcached_st *not_used __attribute__((unused))) +static test_return_t init_test(memcached_st *not_used) { memcached_st memc; + (void)not_used; (void)memcached_create(&memc); memcached_free(&memc); @@ -65,10 +70,11 @@ static test_return_t init_test(memcached_st *not_used __attribute__((unused))) return TEST_SUCCESS; } -static test_return_t server_list_null_test(memcached_st *ptr __attribute__((unused))) +static test_return_t server_list_null_test(memcached_st *ptr) { memcached_server_st *server_list; memcached_return_t rc; + (void)ptr; server_list= memcached_server_list_append_with_weight(NULL, NULL, 0, 0, NULL); test_true(server_list == NULL); @@ -85,26 +91,28 @@ static test_return_t server_list_null_test(memcached_st *ptr __attribute__((unus #define TEST_PORT_COUNT 7 in_port_t test_ports[TEST_PORT_COUNT]; -static memcached_return_t server_display_function(const memcached_st *ptr __attribute__((unused)), +static memcached_return_t server_display_function(const memcached_st *ptr, const memcached_server_st *server, void *context) { /* Do Nothing */ size_t bigger= *((size_t *)(context)); + (void)ptr; assert(bigger <= memcached_server_port(server)); *((size_t *)(context))= memcached_server_port(server); return MEMCACHED_SUCCESS; } -static memcached_return_t dump_server_information(const memcached_st *ptr __attribute__((unused)), +static memcached_return_t dump_server_information(const memcached_st *ptr, const memcached_server_st *instance, void *context) { /* Do Nothing */ FILE *stream= (FILE *)context; + (void)ptr; - fprintf(stream, "Memcached Server: %s %u Version %u.%u.%u\n", + fprintf(stream, "Memcached Server: %s %u Version %u.%u.%u\n", memcached_server_name(instance), memcached_server_port(instance), instance->major_version, @@ -114,13 +122,14 @@ static memcached_return_t dump_server_information(const memcached_st *ptr __attr return MEMCACHED_SUCCESS; } -static test_return_t server_sort_test(memcached_st *ptr __attribute__((unused))) +static test_return_t server_sort_test(memcached_st *ptr) { size_t bigger= 0; /* Prime the value for the test_true in server_display_function */ memcached_return_t rc; memcached_server_fn callbacks[1]; memcached_st *local_memc; + (void)ptr; local_memc= memcached_create(NULL); test_true(local_memc); @@ -146,13 +155,14 @@ static test_return_t server_sort_test(memcached_st *ptr __attribute__((unused))) return TEST_SUCCESS; } -static test_return_t server_sort2_test(memcached_st *ptr __attribute__((unused))) +static test_return_t server_sort2_test(memcached_st *ptr) { size_t bigger= 0; /* Prime the value for the test_true in server_display_function */ memcached_return_t rc; memcached_server_fn callbacks[1]; memcached_st *local_memc; memcached_server_instance_st instance; + (void)ptr; local_memc= memcached_create(NULL); test_true(local_memc); @@ -182,20 +192,7 @@ static test_return_t server_sort2_test(memcached_st *ptr __attribute__((unused)) return TEST_SUCCESS; } -static memcached_return_t server_print_callback(const memcached_st *ptr __attribute__((unused)), - const memcached_server_st *server, - void *context __attribute__((unused))) -{ - (void)server; // Just in case we aren't printing. - -#if 0 - fprintf(stderr, "%s(%d)", memcached_server_name(server), memcached_server_port(server)); -#endif - - return MEMCACHED_SUCCESS; -} - -static test_return_t memcached_server_remove_test(memcached_st *ptr __attribute__((unused))) +static test_return_t memcached_server_remove_test(memcached_st *ptr) { memcached_return_t rc; memcached_st local_memc; @@ -204,6 +201,7 @@ static test_return_t memcached_server_remove_test(memcached_st *ptr __attribute_ memcached_server_fn callbacks[1]; const char *server_string= "localhost:4444, localhost:4445, localhost:4446, localhost:4447, localhost, memcache1.memcache.bk.sapo.pt:11211, memcache1.memcache.bk.sapo.pt:11212, memcache1.memcache.bk.sapo.pt:11213, memcache1.memcache.bk.sapo.pt:11214, memcache2.memcache.bk.sapo.pt:11211, memcache2.memcache.bk.sapo.pt:11212, memcache2.memcache.bk.sapo.pt:11213, memcache2.memcache.bk.sapo.pt:11214"; + (void)ptr; memc= memcached_create(&local_memc); @@ -220,12 +218,13 @@ static test_return_t memcached_server_remove_test(memcached_st *ptr __attribute_ return TEST_SUCCESS; } -static memcached_return_t server_display_unsort_function(const memcached_st *ptr __attribute__((unused)), +static memcached_return_t server_display_unsort_function(const memcached_st *ptr, const memcached_server_st *server, void *context) { /* Do Nothing */ uint32_t x= *((uint32_t *)(context)); + (void)ptr; assert(test_ports[x] == server->port); *((uint32_t *)(context))= ++x; @@ -233,13 +232,14 @@ static memcached_return_t server_display_unsort_function(const memcached_st *ptr return MEMCACHED_SUCCESS; } -static test_return_t server_unsort_test(memcached_st *ptr __attribute__((unused))) +static test_return_t server_unsort_test(memcached_st *ptr) { size_t counter= 0; /* Prime the value for the test_true in server_display_function */ size_t bigger= 0; /* Prime the value for the test_true in server_display_function */ memcached_return_t rc; memcached_server_fn callbacks[1]; memcached_st *local_memc; + (void)ptr; local_memc= memcached_create(NULL); test_true(local_memc); @@ -269,8 +269,9 @@ static test_return_t server_unsort_test(memcached_st *ptr __attribute__((unused) return TEST_SUCCESS; } -static test_return_t allocation_test(memcached_st *not_used __attribute__((unused))) +static test_return_t allocation_test(memcached_st *not_used) { + (void)not_used; memcached_st *memc; memc= memcached_create(NULL); test_true(memc); @@ -759,10 +760,11 @@ static test_return_t flush_test(memcached_st *memc) return TEST_SUCCESS; } -static memcached_return_t server_function(const memcached_st *ptr __attribute__((unused)), - const memcached_server_st *server __attribute__((unused)), - void *context __attribute__((unused))) +static memcached_return_t server_function(const memcached_st *ptr, + const memcached_server_st *server, + void *context) { + (void)ptr; (void)server; (void)context; /* Do Nothing */ return MEMCACHED_SUCCESS; @@ -876,12 +878,12 @@ static test_return_t bad_key_test(memcached_st *memc) } #define READ_THROUGH_VALUE "set for me" -static memcached_return_t read_through_trigger(memcached_st *memc __attribute__((unused)), - char *key __attribute__((unused)), - size_t key_length __attribute__((unused)), +static memcached_return_t read_through_trigger(memcached_st *memc, + char *key, + size_t key_length, memcached_result_st *result) { - + (void)memc;(void)key;(void)key_length; return memcached_result_set_value(result, READ_THROUGH_VALUE, strlen(READ_THROUGH_VALUE)); } @@ -924,10 +926,11 @@ static test_return_t read_through(memcached_st *memc) return TEST_SUCCESS; } -static memcached_return_t delete_trigger(memcached_st *ptr __attribute__((unused)), +static memcached_return_t delete_trigger(memcached_st *ptr, const char *key, - size_t key_length __attribute__((unused))) + size_t key_length) { + (void)ptr;(void)key_length; assert(key); return MEMCACHED_SUCCESS; @@ -1575,10 +1578,11 @@ static test_return_t mget_result_alloc_test(memcached_st *memc) } /* Count the results */ -static memcached_return_t callback_counter(const memcached_st *ptr __attribute__((unused)), - memcached_result_st *result __attribute__((unused)), +static memcached_return_t callback_counter(const memcached_st *ptr, + memcached_result_st *result, void *context) { + (void)ptr; (void)result; size_t *counter= (size_t *)context; *counter= *counter + 1; @@ -1805,9 +1809,10 @@ static test_return_t get_stats_keys(memcached_st *memc) return TEST_SUCCESS; } -static test_return_t version_string_test(memcached_st *memc __attribute__((unused))) +static test_return_t version_string_test(memcached_st *memc) { const char *version_string; + (void)memc; version_string= memcached_lib_version(); @@ -1875,13 +1880,15 @@ static test_return_t add_host_test(memcached_st *memc) return TEST_SUCCESS; } -static memcached_return_t clone_test_callback(memcached_st *parent __attribute__((unused)), memcached_st *memc_clone __attribute__((unused))) +static memcached_return_t clone_test_callback(memcached_st *parent, memcached_st *memc_clone) { + (void)parent;(void)memc_clone; return MEMCACHED_SUCCESS; } -static memcached_return_t cleanup_test_callback(memcached_st *ptr __attribute__((unused))) +static memcached_return_t cleanup_test_callback(memcached_st *ptr) { + (void)ptr; return MEMCACHED_SUCCESS; } @@ -2407,7 +2414,7 @@ static test_return_t user_supplied_bug6(memcached_st *memc) return TEST_SUCCESS; } -static test_return_t user_supplied_bug8(memcached_st *memc __attribute__((unused))) +static test_return_t user_supplied_bug8(memcached_st *memc) { memcached_return_t rc; memcached_st *mine; @@ -2416,6 +2423,7 @@ static test_return_t user_supplied_bug8(memcached_st *memc __attribute__((unused memcached_server_st *servers; const char *server_list= "memcache1.memcache.bk.sapo.pt:11211, memcache1.memcache.bk.sapo.pt:11212, memcache1.memcache.bk.sapo.pt:11213, memcache1.memcache.bk.sapo.pt:11214, memcache2.memcache.bk.sapo.pt:11211, memcache2.memcache.bk.sapo.pt:11212, memcache2.memcache.bk.sapo.pt:11213, memcache2.memcache.bk.sapo.pt:11214"; + (void)memc; servers= memcached_servers_parse(server_list); test_true(servers); @@ -2960,8 +2968,9 @@ static test_return_t user_supplied_bug18(memcached_st *trash) */ /* sighandler_t function that always asserts false */ -static void fail(int unused __attribute__((unused))) +static void fail(int unused) { + (void)unused; assert(0); } @@ -3329,15 +3338,17 @@ static test_return_t string_alloc_append_toobig(memcached_st *memc) return TEST_SUCCESS; } -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 TEST_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; @@ -3350,8 +3361,9 @@ static test_return_t generate_pairs(memcached_st *memc __attribute__((unused))) return TEST_SUCCESS; } -static test_return_t generate_large_pairs(memcached_st *memc __attribute__((unused))) +static test_return_t generate_large_pairs(memcached_st *memc) { + (void)memc; global_pairs= pairs_generate(GLOBAL2_COUNT, MEMCACHED_MAX_BUFFER+10); global_count= GLOBAL2_COUNT; @@ -3855,9 +3867,10 @@ static test_return_t pre_replication_noblock(memcached_st *memc) } -static void my_free(const memcached_st *ptr __attribute__((unused)), void *mem, void *context) +static void my_free(const memcached_st *ptr, void *mem, void *context) { - (void) context; + (void)context; + (void)ptr; #ifdef HARD_MALLOC_TESTS void *real_ptr= (mem == NULL) ? mem : (void*)((caddr_t)mem - 8); free(real_ptr); @@ -3867,9 +3880,10 @@ static void my_free(const memcached_st *ptr __attribute__((unused)), void *mem, } -static void *my_malloc(const memcached_st *ptr __attribute__((unused)), const size_t size, void *context) +static void *my_malloc(const memcached_st *ptr, const size_t size, void *context) { (void)context; + (void)ptr; #ifdef HARD_MALLOC_TESTS void *ret= malloc(size + 8); if (ret != NULL) @@ -3889,7 +3903,7 @@ static void *my_malloc(const memcached_st *ptr __attribute__((unused)), const si } -static void *my_realloc(const memcached_st *ptr __attribute__((unused)), void *mem, const size_t size, void *context) +static void *my_realloc(const memcached_st *ptr, void *mem, const size_t size, void *context) { (void)context; #ifdef HARD_MALLOC_TESTS @@ -3904,12 +3918,13 @@ static void *my_realloc(const memcached_st *ptr __attribute__((unused)), void *m return ret; #else + (void)ptr; return realloc(mem, size); #endif } -static void *my_calloc(const memcached_st *ptr __attribute__((unused)), size_t nelem, const size_t size, void *context) +static void *my_calloc(const memcached_st *ptr, size_t nelem, const size_t size, void *context) { (void)context; #ifdef HARD_MALLOC_TESTS @@ -3921,6 +3936,7 @@ static void *my_calloc(const memcached_st *ptr __attribute__((unused)), size_t n return mem; #else + (void)ptr; return calloc(nelem, size); #endif } @@ -4347,11 +4363,12 @@ static test_return_t analyzer_test(memcached_st *memc) } /* Count the objects */ -static memcached_return_t callback_dump_counter(const memcached_st *ptr __attribute__((unused)), - const char *key __attribute__((unused)), - size_t key_length __attribute__((unused)), +static memcached_return_t callback_dump_counter(const memcached_st *ptr, + const char *key, + size_t key_length, void *context) { + (void)ptr; (void)key; (void)key_length; size_t *counter= (size_t *)context; *counter= *counter + 1; @@ -4545,259 +4562,6 @@ static test_return_t ping_test(memcached_st *memc) } #endif -static test_return_t replication_set_test(memcached_st *memc) -{ - memcached_return_t rc; - memcached_st *memc_clone= memcached_clone(NULL, memc); - memcached_behavior_set(memc_clone, MEMCACHED_BEHAVIOR_NUMBER_OF_REPLICAS, 0); - - rc= memcached_set(memc, "bubba", 5, "0", 1, 0, 0); - test_true(rc == MEMCACHED_SUCCESS); - - /* - ** We are using the quiet commands to store the replicas, so we need - ** to ensure that all of them are processed before we can continue. - ** In the test we go directly from storing the object to trying to - ** receive the object from all of the different servers, so we - ** could end up in a race condition (the memcached server hasn't yet - ** processed the quiet command from the replication set when it process - ** the request from the other client (created by the clone)). As a - ** workaround for that we call memcached_quit to send the quit command - ** to the server and wait for the response ;-) If you use the test code - ** as an example for your own code, please note that you shouldn't need - ** to do this ;-) - */ - memcached_quit(memc); - - /* - ** "bubba" should now be stored on all of our servers. We don't have an - ** easy to use API to address each individual server, so I'll just iterate - ** through a bunch of "master keys" and I should most likely hit all of the - ** servers... - */ - for (int x= 'a'; x <= 'z'; ++x) - { - char key[2]= { [0]= (char)x }; - size_t len; - uint32_t flags; - char *val= memcached_get_by_key(memc_clone, key, 1, "bubba", 5, - &len, &flags, &rc); - test_true(rc == MEMCACHED_SUCCESS); - test_true(val != NULL); - free(val); - } - - memcached_free(memc_clone); - - return TEST_SUCCESS; -} - -static test_return_t replication_get_test(memcached_st *memc) -{ - memcached_return_t rc; - - /* - * Don't do the following in your code. I am abusing the internal details - * within the library, and this is not a supported interface. - * This is to verify correct behavior in the library - */ - for (uint32_t host= 0; host < memcached_server_count(memc); ++host) - { - memcached_st *memc_clone= memcached_clone(NULL, memc); - memcached_server_instance_st instance= - memcached_server_instance_by_position(memc_clone, host); - - ((memcached_server_write_instance_st)instance)->port= 0; - - for (int x= 'a'; x <= 'z'; ++x) - { - char key[2]= { [0]= (char)x }; - size_t len; - uint32_t flags; - char *val= memcached_get_by_key(memc_clone, key, 1, "bubba", 5, - &len, &flags, &rc); - test_true(rc == MEMCACHED_SUCCESS); - test_true(val != NULL); - free(val); - } - - memcached_free(memc_clone); - } - - return TEST_SUCCESS; -} - -static test_return_t replication_mget_test(memcached_st *memc) -{ - memcached_return_t rc; - memcached_st *memc_clone= memcached_clone(NULL, memc); - memcached_behavior_set(memc_clone, MEMCACHED_BEHAVIOR_NUMBER_OF_REPLICAS, 0); - - const char *keys[]= { "bubba", "key1", "key2", "key3" }; - size_t len[]= { 5, 4, 4, 4 }; - - for (size_t x= 0; x< 4; ++x) - { - rc= memcached_set(memc, keys[x], len[x], "0", 1, 0, 0); - test_true(rc == MEMCACHED_SUCCESS); - } - - /* - ** We are using the quiet commands to store the replicas, so we need - ** to ensure that all of them are processed before we can continue. - ** In the test we go directly from storing the object to trying to - ** receive the object from all of the different servers, so we - ** could end up in a race condition (the memcached server hasn't yet - ** processed the quiet command from the replication set when it process - ** the request from the other client (created by the clone)). As a - ** workaround for that we call memcached_quit to send the quit command - ** to the server and wait for the response ;-) If you use the test code - ** as an example for your own code, please note that you shouldn't need - ** to do this ;-) - */ - memcached_quit(memc); - - /* - * Don't do the following in your code. I am abusing the internal details - * within the library, and this is not a supported interface. - * This is to verify correct behavior in the library - */ - memcached_result_st result_obj; - for (uint32_t host= 0; host < memc_clone->number_of_hosts; host++) - { - memcached_st *new_clone= memcached_clone(NULL, memc); - memcached_server_instance_st instance= - memcached_server_instance_by_position(new_clone, host); - ((memcached_server_write_instance_st)instance)->port= 0; - - for (int x= 'a'; x <= 'z'; ++x) - { - char key[2]= { [0]= (char)x, [1]= 0 }; - - rc= memcached_mget_by_key(new_clone, key, 1, keys, len, 4); - test_true(rc == MEMCACHED_SUCCESS); - - memcached_result_st *results= memcached_result_create(new_clone, &result_obj); - test_true(results); - - int hits= 0; - while ((results= memcached_fetch_result(new_clone, &result_obj, &rc)) != NULL) - { - hits++; - } - test_true(hits == 4); - memcached_result_free(&result_obj); - } - - memcached_free(new_clone); - } - - memcached_free(memc_clone); - - return TEST_SUCCESS; -} - -static test_return_t replication_randomize_mget_test(memcached_st *memc) -{ - memcached_result_st result_obj; - memcached_return_t rc; - memcached_st *memc_clone= memcached_clone(NULL, memc); - memcached_behavior_set(memc_clone, MEMCACHED_BEHAVIOR_NUMBER_OF_REPLICAS, 3); - memcached_behavior_set(memc_clone, MEMCACHED_BEHAVIOR_RANDOMIZE_REPLICA_READ, 1); - - const char *keys[]= { "key1", "key2", "key3", "key4", "key5", "key6", "key7" }; - size_t len[]= { 4, 4, 4, 4, 4, 4, 4 }; - - for (size_t x= 0; x< 7; ++x) - { - rc= memcached_set(memc, keys[x], len[x], "1", 1, 0, 0); - test_true(rc == MEMCACHED_SUCCESS); - } - - memcached_quit(memc); - - for (size_t x= 0; x< 7; ++x) - { - const char key[2]= { [0]= (const char)x }; - - rc= memcached_mget_by_key(memc_clone, key, 1, keys, len, 7); - test_true(rc == MEMCACHED_SUCCESS); - - memcached_result_st *results= memcached_result_create(memc_clone, &result_obj); - test_true(results); - - int hits= 0; - while ((results= memcached_fetch_result(memc_clone, &result_obj, &rc)) != NULL) - { - ++hits; - } - test_true(hits == 7); - memcached_result_free(&result_obj); - } - memcached_free(memc_clone); - return TEST_SUCCESS; -} - -static test_return_t replication_delete_test(memcached_st *memc) -{ - memcached_return_t rc; - memcached_st *memc_clone= memcached_clone(NULL, memc); - /* Delete the items from all of the servers except 1 */ - uint64_t repl= memcached_behavior_get(memc, - MEMCACHED_BEHAVIOR_NUMBER_OF_REPLICAS); - memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_NUMBER_OF_REPLICAS, --repl); - - const char *keys[]= { "bubba", "key1", "key2", "key3" }; - size_t len[]= { 5, 4, 4, 4 }; - - for (size_t x= 0; x< 4; ++x) - { - rc= memcached_delete_by_key(memc, keys[0], len[0], keys[x], len[x], 0); - test_true(rc == MEMCACHED_SUCCESS); - } - - /* - * Don't do the following in your code. I am abusing the internal details - * within the library, and this is not a supported interface. - * This is to verify correct behavior in the library - */ - uint32_t hash= memcached_generate_hash(memc, keys[0], len[0]); - for (uint32_t x= 0; x < (repl + 1); ++x) - { - memcached_server_instance_st instance= - memcached_server_instance_by_position(memc_clone, x); - - ((memcached_server_write_instance_st)instance)->port= 0; - if (++hash == memc_clone->number_of_hosts) - hash= 0; - } - - memcached_result_st result_obj; - for (uint32_t host= 0; host < memc_clone->number_of_hosts; ++host) - { - for (size_t x= 'a'; x <= 'z'; ++x) - { - const char key[2]= { [0]= (const char)x }; - - rc= memcached_mget_by_key(memc_clone, key, 1, keys, len, 4); - test_true(rc == MEMCACHED_SUCCESS); - - memcached_result_st *results= memcached_result_create(memc_clone, &result_obj); - test_true(results); - - int hits= 0; - while ((results= memcached_fetch_result(memc_clone, &result_obj, &rc)) != NULL) - { - ++hits; - } - test_true(hits == 4); - memcached_result_free(&result_obj); - } - } - memcached_free(memc_clone); - - return TEST_SUCCESS; -} #if 0 static test_return_t hash_sanity_test (memcached_st *memc) @@ -4848,10 +4612,11 @@ static test_return_t murmur_avaibility_test (memcached_st *memc) return TEST_SUCCESS; } -static test_return_t one_at_a_time_run (memcached_st *memc __attribute__((unused))) +static test_return_t one_at_a_time_run (memcached_st *memc) { uint32_t x; const char **ptr; + (void)memc; for (ptr= list_to_hash, x= 0; *ptr; ptr++, x++) { @@ -4864,10 +4629,11 @@ static test_return_t one_at_a_time_run (memcached_st *memc __attribute__((unused return TEST_SUCCESS; } -static test_return_t md5_run (memcached_st *memc __attribute__((unused))) +static test_return_t md5_run (memcached_st *memc) { uint32_t x; const char **ptr; + (void)memc; for (ptr= list_to_hash, x= 0; *ptr; ptr++, x++) { @@ -4880,10 +4646,11 @@ static test_return_t md5_run (memcached_st *memc __attribute__((unused))) return TEST_SUCCESS; } -static test_return_t crc_run (memcached_st *memc __attribute__((unused))) +static test_return_t crc_run (memcached_st *memc) { uint32_t x; const char **ptr; + (void)memc; for (ptr= list_to_hash, x= 0; *ptr; ptr++, x++) { @@ -4896,10 +4663,11 @@ static test_return_t crc_run (memcached_st *memc __attribute__((unused))) return TEST_SUCCESS; } -static test_return_t fnv1_64_run (memcached_st *memc __attribute__((unused))) +static test_return_t fnv1_64_run (memcached_st *memc) { uint32_t x; const char **ptr; + (void)memc; for (ptr= list_to_hash, x= 0; *ptr; ptr++, x++) { @@ -4912,10 +4680,11 @@ static test_return_t fnv1_64_run (memcached_st *memc __attribute__((unused))) return TEST_SUCCESS; } -static test_return_t fnv1a_64_run (memcached_st *memc __attribute__((unused))) +static test_return_t fnv1a_64_run (memcached_st *memc) { uint32_t x; const char **ptr; + (void)memc; for (ptr= list_to_hash, x= 0; *ptr; ptr++, x++) { @@ -4928,11 +4697,11 @@ static test_return_t fnv1a_64_run (memcached_st *memc __attribute__((unused))) return TEST_SUCCESS; } -static test_return_t fnv1_32_run (memcached_st *memc __attribute__((unused))) +static test_return_t fnv1_32_run (memcached_st *memc) { uint32_t x; const char **ptr; - + (void)memc; for (ptr= list_to_hash, x= 0; *ptr; ptr++, x++) { @@ -4945,10 +4714,11 @@ static test_return_t fnv1_32_run (memcached_st *memc __attribute__((unused))) return TEST_SUCCESS; } -static test_return_t fnv1a_32_run (memcached_st *memc __attribute__((unused))) +static test_return_t fnv1a_32_run (memcached_st *memc) { uint32_t x; const char **ptr; + (void)memc; for (ptr= list_to_hash, x= 0; *ptr; ptr++, x++) { @@ -4961,10 +4731,11 @@ static test_return_t fnv1a_32_run (memcached_st *memc __attribute__((unused))) return TEST_SUCCESS; } -static test_return_t hsieh_run (memcached_st *memc __attribute__((unused))) +static test_return_t hsieh_run (memcached_st *memc) { uint32_t x; const char **ptr; + (void)memc; for (ptr= list_to_hash, x= 0; *ptr; ptr++, x++) { @@ -4977,7 +4748,7 @@ static test_return_t hsieh_run (memcached_st *memc __attribute__((unused))) return TEST_SUCCESS; } -static test_return_t murmur_run (memcached_st *memc __attribute__((unused))) +static test_return_t murmur_run (memcached_st *memc) { #ifdef WORDS_BIGENDIAN (void)murmur_values; @@ -4985,6 +4756,7 @@ static test_return_t murmur_run (memcached_st *memc __attribute__((unused))) #else uint32_t x; const char **ptr; + (void)memc; for (ptr= list_to_hash, x= 0; *ptr; ptr++, x++) { @@ -4998,11 +4770,11 @@ static test_return_t murmur_run (memcached_st *memc __attribute__((unused))) #endif } -static test_return_t jenkins_run (memcached_st *memc __attribute__((unused))) +static test_return_t jenkins_run (memcached_st *memc) { uint32_t x; const char **ptr; - + (void)memc; for (ptr= list_to_hash, x= 0; *ptr; ptr++, x++) { @@ -5097,9 +4869,9 @@ static test_return_t memcached_get_hashkit_test (memcached_st *memc) } /* - Test case adapted from John Gorman + Test case adapted from John Gorman - We are testing the error condition when we connect to a server via memcached_get() + We are testing the error condition when we connect to a server via memcached_get() but find that the server is not available. */ static test_return_t memcached_get_MEMCACHED_ERRNO(memcached_st *memc) @@ -5132,7 +4904,7 @@ static test_return_t memcached_get_MEMCACHED_ERRNO(memcached_st *memc) return TEST_SUCCESS; } -/* +/* We connect to a server which exists, but search for a key that does not exist. */ static test_return_t memcached_get_MEMCACHED_NOTFOUND(memcached_st *memc) @@ -5154,9 +4926,9 @@ static test_return_t memcached_get_MEMCACHED_NOTFOUND(memcached_st *memc) } /* - Test case adapted from John Gorman + Test case adapted from John Gorman - We are testing the error condition when we connect to a server via memcached_get_by_key() + We are testing the error condition when we connect to a server via memcached_get_by_key() but find that the server is not available. */ static test_return_t memcached_get_by_key_MEMCACHED_ERRNO(memcached_st *memc) @@ -5189,7 +4961,7 @@ static test_return_t memcached_get_by_key_MEMCACHED_ERRNO(memcached_st *memc) return TEST_SUCCESS; } -/* +/* We connect to a server which exists, but search for a key that does not exist. */ static test_return_t memcached_get_by_key_MEMCACHED_NOTFOUND(memcached_st *memc) @@ -5643,16 +5415,16 @@ static test_return_t regression_bug_447342(memcached_st *memc) static test_return_t regression_bug_463297(memcached_st *memc) { - memcached_st *memc_clone= memcached_clone(NULL, memc); - test_true(memc_clone != NULL); - test_true(memcached_version(memc_clone) == MEMCACHED_SUCCESS); + memcached_st *memc_clone= memcached_clone(NULL, memc); + test_true(memc_clone != NULL); + test_true(memcached_version(memc_clone) == MEMCACHED_SUCCESS); - memcached_server_instance_st instance= - memcached_server_instance_by_position(memc_clone, 0); + memcached_server_instance_st instance= + memcached_server_instance_by_position(memc_clone, 0); - if (instance->major_version > 1 || - (instance->major_version == 1 && - instance->minor_version > 2)) + if (instance->major_version > 1 || + (instance->major_version == 1 && + instance->minor_version > 2)) { /* Binary protocol doesn't support deferred delete */ memcached_st *bin_clone= memcached_clone(NULL, memc); @@ -5671,7 +5443,7 @@ static test_return_t regression_bug_463297(memcached_st *memc) memcached_return_t rc= memcached_delete(memc, "foo", 3, 1); /* but there is a bug in some of the memcached servers (1.4) that treats - * the counter as noreply so it doesn't send the proper error message + * the counter as noreply so it doesn't send the proper error message */ test_true_got(rc == MEMCACHED_PROTOCOL_ERROR || rc == MEMCACHED_NOTFOUND || rc == MEMCACHED_CLIENT_ERROR || rc == MEMCACHED_INVALID_ARGUMENTS, memcached_strerror(NULL, rc)); @@ -6086,6 +5858,30 @@ static test_return_t regression_bug_583031(memcached_st *unused) return TEST_SUCCESS; } +// Look for memory leak +static test_return_t regression_bug_728286(memcached_st *unused) +{ + (void)unused; + memcached_server_st *servers = memcached_servers_parse("1.2.3.4:99"); + memcached_server_free(servers); + + return TEST_SUCCESS; +} + +static test_return_t regression_bug_581030(memcached_st *unused) +{ + (void)unused; + +#ifndef DEBUG + memcached_stat_st *local_stat= memcached_stat(NULL, NULL, NULL); + test_false(local_stat); + + memcached_stat_free(NULL, NULL); +#endif + + return TEST_SUCCESS; +} + static void memcached_die(memcached_st* mc, memcached_return error, const char* what, uint32_t it) { fprintf(stderr, "Iteration #%u: ", it); @@ -6114,7 +5910,7 @@ static test_return_t regression_bug_(memcached_st *memc) return TEST_SKIPPED; } - for (uint32_t x= 0; x < TEST_CONSTANT_CREATION; x++) + for (uint32_t x= 0; x < TEST_CONSTANT_CREATION; x++) { memcached_st* mc= memcached_create(NULL); memcached_return rc; @@ -6144,7 +5940,7 @@ static test_return_t regression_bug_(memcached_st *memc) if (rc == MEMCACHED_SUCCESS) { - if (x > 0) + if (x > 0) { size_t get_value_len; char *get_value; @@ -6403,6 +6199,8 @@ test_st regression_tests[]= { {"lp:490486", 1, (test_callback_fn)regression_bug_490486 }, {"lp:583031", 1, (test_callback_fn)regression_bug_583031 }, {"lp:?", 1, (test_callback_fn)regression_bug_ }, + {"lp:728286", 1, (test_callback_fn)regression_bug_728286 }, + {"lp:581030", 1, (test_callback_fn)regression_bug_581030 }, {0, 0, (test_callback_fn)0} }; @@ -6498,6 +6296,16 @@ test_st error_conditions[] ={ {0, 0, (test_callback_fn)0} }; + +test_st parser_tests[] ={ + {"behavior", 0, (test_callback_fn)behavior_parser_test }, + {"distribtions", 0, (test_callback_fn)parser_distribution_test }, + {"hash", 0, (test_callback_fn)parser_hash_test }, + {"server", 0, (test_callback_fn)server_test }, + {"servers", 0, (test_callback_fn)servers_test }, + {0, 0, (test_callback_fn)0} +}; + collection_st collection[] ={ #if 0 {"hash_sanity", 0, 0, hash_sanity}, @@ -6560,6 +6368,7 @@ collection_st collection[] ={ {"behaviors", 0, 0, behavior_tests}, {"regression_binary_vs_block", (test_callback_fn)key_setup, (test_callback_fn)key_teardown, regression_binary_vs_block}, {"error_conditions", 0, 0, error_conditions}, + {"parser", 0, 0, parser_tests}, {0, 0, 0, 0} };