X-Git-Url: https://git.m6w6.name/?a=blobdiff_plain;f=tests%2Fmem_functions.c;h=48b254dbfcf921de08f853e0af9cd2d303e04961;hb=6c2bd52dfa24287c856b0b679270b7f7681333a5;hp=c436b261cd7e63e243d6ab5eb06eb3ddef0e89d9;hpb=36583b08f3d20bebd7d9874dd08131e1b3c6ffaf;p=awesomized%2Flibmemcached diff --git a/tests/mem_functions.c b/tests/mem_functions.c index c436b261..48b254db 100644 --- a/tests/mem_functions.c +++ b/tests/mem_functions.c @@ -55,9 +55,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 +66,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,25 +87,45 @@ 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 test_return_t server_sort_test(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", + memcached_server_name(instance), + memcached_server_port(instance), + instance->major_version, + instance->minor_version, + instance->micro_version); + + return MEMCACHED_SUCCESS; +} + +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); @@ -129,13 +151,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); @@ -165,11 +188,13 @@ 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)), +static memcached_return_t server_print_callback(const memcached_st *ptr, const memcached_server_st *server, - void *context __attribute__((unused))) + void *context) { (void)server; // Just in case we aren't printing. + (void)ptr; + (void)context; #if 0 fprintf(stderr, "%s(%d)", memcached_server_name(server), memcached_server_port(server)); @@ -178,7 +203,7 @@ static memcached_return_t server_print_callback(const memcached_st *ptr __attrib 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; @@ -187,6 +212,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); @@ -203,12 +229,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; @@ -216,13 +243,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); @@ -252,8 +280,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); @@ -742,10 +771,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; @@ -859,12 +889,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)); } @@ -907,10 +937,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; @@ -1014,7 +1045,7 @@ static test_return_t set_test3(memcached_st *memc) { char key[16]; - sprintf(key, "foo%u", x); + snprintf(key, sizeof(key), "foo%u", x); rc= memcached_set(memc, key, strlen(key), value, value_length, @@ -1558,10 +1589,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; @@ -1683,7 +1715,7 @@ static test_return_t mget_execute(memcached_st *memc) { char k[251]; - key_length[x]= (size_t)snprintf(k, sizeof(k), "0200%zu", x); + key_length[x]= (size_t)snprintf(k, sizeof(k), "0200%lu", (unsigned long)x); keys[x]= strdup(k); test_true(keys[x] != NULL); rc= memcached_add(memc, keys[x], key_length[x], blob, sizeof(blob), 0, 0); @@ -1788,9 +1820,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(); @@ -1858,13 +1891,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; } @@ -2037,7 +2072,7 @@ static test_return_t MEMCACHED_BEHAVIOR_TCP_KEEPIDLE_test(memcached_st *memc) return TEST_SUCCESS; } -static test_return_t fetch_all_results(memcached_st *memc) +static test_return_t fetch_all_results(memcached_st *memc, size_t *keys_returned) { memcached_return_t rc= MEMCACHED_SUCCESS; char return_key[MEMCACHED_MAX_KEY]; @@ -2046,15 +2081,20 @@ static test_return_t fetch_all_results(memcached_st *memc) size_t return_value_length; uint32_t flags; + *keys_returned= 0; + while ((return_value= memcached_fetch(memc, return_key, &return_key_length, &return_value_length, &flags, &rc))) { test_true(return_value); test_true(rc == MEMCACHED_SUCCESS); free(return_value); + *keys_returned= *keys_returned +1; } - return ((rc == MEMCACHED_END) || (rc == MEMCACHED_SUCCESS)) ? TEST_SUCCESS : TEST_FAILURE; + test_true_got(rc == MEMCACHED_END || rc == MEMCACHED_SUCCESS, memcached_strerror(NULL, rc)); + + return TEST_SUCCESS; } /* Test case provided by Cal Haldenbrand */ @@ -2192,7 +2232,8 @@ static test_return_t user_supplied_bug3(memcached_st *memc) rc= memcached_mget(memc, (const char **)keys, key_lengths, KEY_COUNT); test_true(rc == MEMCACHED_SUCCESS); - test_true(fetch_all_results(memc) == TEST_SUCCESS); + size_t keys_returned; + test_true(fetch_all_results(memc, &keys_returned) == TEST_SUCCESS); for (x= 0; x < KEY_COUNT; x++) free(keys[x]); @@ -2384,7 +2425,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; @@ -2393,6 +2434,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); @@ -2937,14 +2979,20 @@ 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); } static test_return_t _user_supplied_bug21(memcached_st* memc, size_t key_count) { +#ifdef WIN32 + (void)memc; + (void)key_count; + return TEST_SKIPPED; +#else memcached_return_t rc; unsigned int x; char **keys; @@ -2983,7 +3031,8 @@ static test_return_t _user_supplied_bug21(memcached_st* memc, size_t key_count) alarm(0); signal(SIGALRM, oldalarm); - test_true(fetch_all_results(memc) == TEST_SUCCESS); + size_t keys_returned; + test_true(fetch_all_results(memc, &keys_returned) == TEST_SUCCESS); for (x= 0; x < key_count; x++) free(keys[x]); @@ -2993,6 +3042,7 @@ static test_return_t _user_supplied_bug21(memcached_st* memc, size_t key_count) memcached_free(memc_clone); return TEST_SUCCESS; +#endif } static test_return_t user_supplied_bug21(memcached_st *memc) @@ -3137,7 +3187,7 @@ static test_return_t output_ketama_weighted_keys(memcached_st *trash) for (int x= 0; x < 10000; x++) { char key[10]; - sprintf(key, "%d", x); + snprintf(key, sizeof(key), "%d", x); uint32_t server_idx = memcached_generate_hash(memc, key, strlen(key)); char *hostname = memc->hosts[server_idx].hostname; @@ -3299,15 +3349,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; @@ -3320,8 +3372,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; @@ -3336,7 +3389,9 @@ static test_return_t generate_large_pairs(memcached_st *memc __attribute__((unus static test_return_t generate_data(memcached_st *memc) { - execute_set(memc, global_pairs, global_count); + unsigned int check_execute= execute_set(memc, global_pairs, global_count); + + test_true(check_execute == global_count); return TEST_SUCCESS; } @@ -3346,7 +3401,9 @@ static test_return_t generate_data_with_stats(memcached_st *memc) memcached_stat_st *stat_p; memcached_return_t rc; uint32_t host_index= 0; - execute_set(memc, global_pairs, global_count); + unsigned int check_execute= execute_set(memc, global_pairs, global_count); + + test_true(check_execute == global_count); //TODO: hosts used size stats stat_p= memcached_stat(memc, NULL, &rc); @@ -3442,9 +3499,22 @@ static test_return_t mget_read(memcached_st *memc) { memcached_return_t rc; + if (! libmemcached_util_version_check(memc, 1, 4, 4)) + return TEST_SKIPPED; + rc= memcached_mget(memc, global_keys, global_keys_length, global_count); - test_true(rc == MEMCACHED_SUCCESS); - test_true(fetch_all_results(memc) == TEST_SUCCESS); + + test_true_got(rc == MEMCACHED_SUCCESS, memcached_strerror(NULL, rc)); + + // Go fetch the keys and test to see if all of them were returned + { + size_t keys_returned; + test_true(fetch_all_results(memc, &keys_returned) == TEST_SUCCESS); + char buffer[30]; + snprintf(buffer, sizeof(buffer), "%lu", (unsigned long)keys_returned); + test_true_got(global_count == keys_returned, buffer); + } + return TEST_SUCCESS; } @@ -3453,8 +3523,13 @@ static test_return_t mget_read_result(memcached_st *memc) { memcached_return_t rc; + if (! libmemcached_util_version_check(memc, 1, 4, 4)) + return TEST_SKIPPED; + rc= memcached_mget(memc, global_keys, global_keys_length, global_count); - test_true(rc == MEMCACHED_SUCCESS); + + test_true_got(rc == MEMCACHED_SUCCESS, memcached_strerror(NULL, rc)); + /* Turn this into a help function */ { memcached_result_st results_obj; @@ -3480,8 +3555,12 @@ static test_return_t mget_read_function(memcached_st *memc) size_t counter; memcached_execute_fn callbacks[1]; + if (! libmemcached_util_version_check(memc, 1, 4, 4)) + return TEST_SKIPPED; + rc= memcached_mget(memc, global_keys, global_keys_length, global_count); - test_true(rc == MEMCACHED_SUCCESS); + + test_true_got(rc == MEMCACHED_SUCCESS, memcached_strerror(NULL, rc)); callbacks[0]= &callback_counter; counter= 0; @@ -3529,7 +3608,7 @@ static test_return_t add_host_test1(memcached_st *memc) { char buffer[SMALL_STRING_LEN]; - snprintf(buffer, SMALL_STRING_LEN, "%zu.example.com", 400+x); + snprintf(buffer, SMALL_STRING_LEN, "%lu.example.com", (unsigned long)(400 +x)); servers= memcached_server_list_append_with_weight(servers, buffer, 401, 0, &rc); test_true(rc == MEMCACHED_SUCCESS); @@ -3597,7 +3676,7 @@ static test_return_t pre_nonblock_binary(memcached_st *memc) // will not toggle protocol on an connection. memcached_version(memc_clone); - if (libmemcached_util_version_check(memc_clone, 1, 3, 0)) + if (libmemcached_util_version_check(memc_clone, 1, 4, 4)) { memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_NO_BLOCK, 0); rc = memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL, 1); @@ -3723,7 +3802,7 @@ static test_return_t pre_binary(memcached_st *memc) { memcached_return_t rc= MEMCACHED_FAILURE; - if (libmemcached_util_version_check(memc, 1, 3, 0)) + if (libmemcached_util_version_check(memc, 1, 4, 4)) { rc = memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL, 1); test_true(rc == MEMCACHED_SUCCESS); @@ -3795,9 +3874,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); @@ -3807,9 +3887,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) @@ -3829,7 +3910,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 @@ -3844,12 +3925,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 @@ -3861,6 +3943,7 @@ static void *my_calloc(const memcached_st *ptr __attribute__((unused)), size_t n return mem; #else + (void)ptr; return calloc(nelem, size); #endif } @@ -4145,7 +4228,11 @@ static test_return_t noreply_test(memcached_st *memc) for (size_t x= 0; x < 100; ++x) { char key[10]; - size_t len= (size_t)sprintf(key, "%zu", x); + int check_length= (size_t)snprintf(key, sizeof(key), "%lu", (unsigned long)x); + test_false((size_t)check_length >= sizeof(key) || check_length < 0); + + size_t len= (size_t)check_length; + switch (count) { case 0: @@ -4193,7 +4280,11 @@ static test_return_t noreply_test(memcached_st *memc) { char key[10]; - size_t len= (size_t)sprintf(key, "%zu", x); + int check_length= (size_t)snprintf(key, sizeof(key), "%lu", (unsigned long)x); + + test_false((size_t)check_length >= sizeof(key) || check_length < 0); + + size_t len= (size_t)check_length; size_t length; uint32_t flags; char* value=memcached_get(memc, key, strlen(key), @@ -4279,11 +4370,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; @@ -4330,14 +4422,15 @@ static void* connection_release(void *arg) return arg; } +#define POOL_SIZE 10 static test_return_t connection_pool_test(memcached_st *memc) { - memcached_pool_st* pool= memcached_pool_create(memc, 5, 10); + memcached_pool_st* pool= memcached_pool_create(memc, 5, POOL_SIZE); test_true(pool != NULL); - memcached_st* mmc[10]; + memcached_st *mmc[POOL_SIZE]; memcached_return_t rc; - for (size_t x= 0; x < 10; ++x) + for (size_t x= 0; x < POOL_SIZE; ++x) { mmc[x]= memcached_pool_pop(pool, false, &rc); test_true(mmc[x] != NULL); @@ -4364,7 +4457,7 @@ static test_return_t connection_pool_test(memcached_st *memc) rc= memcached_set(mmc[0], key, keylen, "0", 1, 0, 0); test_true(rc == MEMCACHED_SUCCESS); - for (size_t x= 0; x < 10; ++x) + for (size_t x= 0; x < POOL_SIZE; ++x) { uint64_t number_value; rc= memcached_increment(mmc[x], key, keylen, 1, &number_value); @@ -4373,7 +4466,7 @@ static test_return_t connection_pool_test(memcached_st *memc) } // Release them.. - for (size_t x= 0; x < 10; ++x) + for (size_t x= 0; x < POOL_SIZE; ++x) { test_true(memcached_pool_push(pool, mmc[x]) == MEMCACHED_SUCCESS); } @@ -4400,8 +4493,8 @@ static test_return_t connection_pool_test(memcached_st *memc) test_true(memcached_behavior_get(mmc[0], MEMCACHED_BEHAVIOR_IO_MSG_WATERMARK) == 9999); test_true(memcached_pool_push(pool, mmc[0]) == MEMCACHED_SUCCESS); - test_true(memcached_pool_destroy(pool) == memc); + return TEST_SUCCESS; } @@ -4413,6 +4506,18 @@ static test_return_t util_version_test(memcached_st *memc) test_true(if_successful == true); if_successful= libmemcached_util_version_check(memc, 9, 9, 9); + + // We expect failure + if (if_successful) + { + fprintf(stderr, "\n----------------------------------------------------------------------\n"); + fprintf(stderr, "\nDumping Server Information\n\n"); + memcached_server_fn callbacks[1]; + + callbacks[0]= dump_server_information; + memcached_server_cursor(memc, callbacks, (void *)stderr, 1); + fprintf(stderr, "\n----------------------------------------------------------------------\n"); + } test_true(if_successful == false); memcached_server_instance_st instance= @@ -4754,10 +4859,11 @@ static test_return_t hsieh_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++) { @@ -4770,10 +4876,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++) { @@ -4786,10 +4893,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++) { @@ -4802,10 +4910,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++) { @@ -4818,10 +4927,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++) { @@ -4834,11 +4944,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++) { @@ -4851,10 +4961,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++) { @@ -4867,10 +4978,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++) { @@ -4883,13 +4995,14 @@ 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 return TEST_SKIPPED; #else uint32_t x; const char **ptr; + (void)memc; for (ptr= list_to_hash, x= 0; *ptr; ptr++, x++) { @@ -4903,11 +5016,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++) { @@ -5002,9 +5115,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) @@ -5030,14 +5143,14 @@ static test_return_t memcached_get_MEMCACHED_ERRNO(memcached_st *memc) test_false(value); test_true(len == 0); - test_true(rc == MEMCACHED_ERRNO); + test_false(rc == MEMCACHED_SUCCESS); memcached_free(tl_memc_h); 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) @@ -5059,9 +5172,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) @@ -5087,14 +5200,14 @@ static test_return_t memcached_get_by_key_MEMCACHED_ERRNO(memcached_st *memc) test_false(value); test_true(len == 0); - test_true(rc == MEMCACHED_ERRNO); + test_false(rc == MEMCACHED_SUCCESS); memcached_free(tl_memc_h); 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) @@ -5290,7 +5403,7 @@ static test_return_t regression_bug_434843(memcached_st *memc) { char k[251]; - key_length[x]= (size_t)snprintf(k, sizeof(k), "0200%zu", x); + key_length[x]= (size_t)snprintf(k, sizeof(k), "0200%lu", (unsigned long)x); keys[x]= strdup(k); test_true(keys[x] != NULL); } @@ -5431,7 +5544,7 @@ static test_return_t regression_bug_447342(memcached_st *memc) memcached_server_instance_st instance_one; memcached_server_instance_st instance_two; - if (memcached_server_count(memc) < 3 || pre_replication(memc) != MEMCACHED_SUCCESS) + if (memcached_server_count(memc) < 3 || pre_replication(memc) != TEST_SUCCESS) return TEST_SKIPPED; memcached_return_t rc; @@ -5447,7 +5560,7 @@ static test_return_t regression_bug_447342(memcached_st *memc) { char k[251]; - key_length[x]= (size_t)snprintf(k, sizeof(k), "0200%zu", x); + key_length[x]= (size_t)snprintf(k, sizeof(k), "0200%lu", (unsigned long)x); keys[x]= strdup(k); test_true(keys[x] != NULL); rc= memcached_set(memc, k, key_length[x], k, key_length[x], 0, 0); @@ -5548,16 +5661,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); @@ -5577,18 +5690,18 @@ static test_return_t regression_bug_463297(memcached_st *memc) /* 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 - */ - test_true(rc == MEMCACHED_PROTOCOL_ERROR || rc == MEMCACHED_NOTFOUND || rc == MEMCACHED_CLIENT_ERROR); + */ + test_true_got(rc == MEMCACHED_PROTOCOL_ERROR || rc == MEMCACHED_NOTFOUND || rc == MEMCACHED_CLIENT_ERROR || rc == MEMCACHED_INVALID_ARGUMENTS, memcached_strerror(NULL, rc)); /* And buffered mode should be disabled and we should get protocol error */ test_true(memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_BUFFER_REQUESTS, 1) == MEMCACHED_SUCCESS); rc= memcached_delete(memc, "foo", 3, 1); - test_true(rc == MEMCACHED_PROTOCOL_ERROR || rc == MEMCACHED_NOTFOUND || rc == MEMCACHED_CLIENT_ERROR); + test_true_got(rc == MEMCACHED_PROTOCOL_ERROR || rc == MEMCACHED_NOTFOUND || rc == MEMCACHED_CLIENT_ERROR || rc == MEMCACHED_INVALID_ARGUMENTS, memcached_strerror(NULL, rc)); /* Same goes for noreply... */ test_true(memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_NOREPLY, 1) == MEMCACHED_SUCCESS); rc= memcached_delete(memc, "foo", 3, 1); - test_true(rc == MEMCACHED_PROTOCOL_ERROR || rc == MEMCACHED_NOTFOUND || rc == MEMCACHED_CLIENT_ERROR); + test_true_got(rc == MEMCACHED_PROTOCOL_ERROR || rc == MEMCACHED_NOTFOUND || rc == MEMCACHED_CLIENT_ERROR || rc == MEMCACHED_INVALID_ARGUMENTS, memcached_strerror(NULL, rc)); /* but a normal request should go through (and be buffered) */ test_true((rc= memcached_delete(memc, "foo", 3, 0)) == MEMCACHED_BUFFERED); @@ -5844,7 +5957,7 @@ static test_return_t regression_bug_490486(memcached_st *memc) for (size_t x= 0; x < max_keys; ++x) { char k[251]; - key_length[x]= (size_t)snprintf(k, sizeof(k), "0200%zu", x); + key_length[x]= (size_t)snprintf(k, sizeof(k), "0200%lu", (unsigned long)x); keys[x]= strdup(k); assert(keys[x] != NULL); rc= memcached_set(memc, keys[x], key_length[x], blob, sizeof(blob), 0, 0); @@ -5937,7 +6050,7 @@ static test_return_t regression_bug_583031(memcached_st *unused) (void)memcached_get(memc, "dsf", 3, &length, &flags, &rc); - test_true(rc == MEMCACHED_TIMEOUT); + test_true_got(rc == MEMCACHED_TIMEOUT, memcached_strerror(NULL, rc)); memcached_free(memc); @@ -5972,7 +6085,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; @@ -6002,7 +6115,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;