X-Git-Url: https://git.m6w6.name/?a=blobdiff_plain;f=tests%2Flibmemcached-1.0%2Fmem_functions.cc;h=0256588dcba108750bbe76fcb8aa1666cd9fdebf;hb=7ccbfda85fd7004ac0b3ef24283a7027fe2651cd;hp=cf021afea19d790ce96a860f7d57dcf4ea8ae790;hpb=2565909cfc50c91a28a91da59131815f3d23227d;p=awesomized%2Flibmemcached diff --git a/tests/libmemcached-1.0/mem_functions.cc b/tests/libmemcached-1.0/mem_functions.cc index cf021afe..0256588d 100644 --- a/tests/libmemcached-1.0/mem_functions.cc +++ b/tests/libmemcached-1.0/mem_functions.cc @@ -78,6 +78,8 @@ #include "tests/ketama.h" #include "tests/namespace.h" #include "tests/parser.h" +#include "tests/libmemcached-1.0/dump.h" +#include "tests/libmemcached-1.0/stat.h" #include "tests/touch.h" #include "tests/callbacks.h" #include "tests/pool.h" @@ -95,7 +97,7 @@ using namespace libtest; #define GLOBAL_COUNT 10000 #define GLOBAL2_COUNT 100 #define SERVERS_TO_CREATE 5 -static uint32_t global_count; +static uint32_t global_count= GLOBAL2_COUNT; static pairs_st *global_pairs; static const char *global_keys[GLOBAL_COUNT]; @@ -112,6 +114,16 @@ static test_return_t pre_binary(memcached_st *memc) return TEST_SUCCESS; } +static memcached_return_t return_value_based_on_buffering(memcached_st *memc) +{ + if (memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_BUFFER_REQUESTS)) + { + return MEMCACHED_BUFFERED; + } + + return MEMCACHED_SUCCESS; +} + static memcached_st * create_single_instance_memcached(const memcached_st *original_memc, const char *options) { /* @@ -384,7 +396,7 @@ static test_return_t clone_test(memcached_st *memc) test_true(memc_clone->ketama.weighted == memc->ketama.weighted); test_true(memc_clone->flags.binary_protocol == memc->flags.binary_protocol); test_true(memc_clone->flags.hash_with_namespace == memc->flags.hash_with_namespace); - test_true(memc_clone->flags.no_reply == memc->flags.no_reply); + test_true(memc_clone->flags.reply == memc->flags.reply); test_true(memc_clone->flags.use_udp == memc->flags.use_udp); test_true(memc_clone->flags.auto_eject_hosts == memc->flags.auto_eject_hosts); test_true(memc_clone->flags.randomize_replica_read == memc->flags.randomize_replica_read); @@ -455,7 +467,7 @@ static test_return_t libmemcached_string_behavior_test(memcached_st *) { test_true(libmemcached_string_behavior(memcached_behavior_t(x))); } - test_compare(36, int(MEMCACHED_BEHAVIOR_MAX)); + test_compare(37, int(MEMCACHED_BEHAVIOR_MAX)); return TEST_SUCCESS; } @@ -475,7 +487,7 @@ static test_return_t memcached_return_t_TEST(memcached_st *memc) { uint32_t values[] = { 851992627U, 2337886783U, 4109241422U, 4001849190U, 982370485U, 1263635348U, 4242906218U, 3829656100U, - 1891735253U, 334139633U, 2257084983U, 3088286104U, + 1891735253U, 334139633U, 2257084983U, 3351789013U, 13199785U, 2542027183U, 1097051614U, 199566778U, 2748246961U, 2465192557U, 1664094137U, 2405439045U, 1842224848U, 692413798U, 3479807801U, 919913813U, @@ -485,7 +497,7 @@ static test_return_t memcached_return_t_TEST(memcached_st *memc) 4159057246U, 3425930182U, 2593724503U, 1868899624U, 1769812374U, 2302537950U, 1110330676U, 3365377466U, 1336171666U, 3021258493U, 2334992265U, 3861994737U, - 3582734124, 3365377466U }; + 3582734124U, 3365377466U }; // You have updated the memcache_error messages but not updated docs/tests. for (int rc= int(MEMCACHED_SUCCESS); rc < int(MEMCACHED_MAXIMUM_RETURN); ++rc) @@ -512,7 +524,7 @@ static test_return_t set_test(memcached_st *memc) test_literal_param("foo"), test_literal_param("when we sanitize"), time_t(0), (uint32_t)0); - test_true_got(rc == MEMCACHED_SUCCESS || rc == MEMCACHED_BUFFERED, memcached_strerror(NULL, rc)); + test_true_got(rc == MEMCACHED_SUCCESS or rc == MEMCACHED_BUFFERED, memcached_strerror(NULL, rc)); return TEST_SUCCESS; } @@ -520,32 +532,34 @@ static test_return_t set_test(memcached_st *memc) static test_return_t append_test(memcached_st *memc) { memcached_return_t rc; - const char *key= "fig"; const char *in_value= "we"; - char *out_value= NULL; size_t value_length; uint32_t flags; - rc= memcached_flush(memc, 0); - test_compare(MEMCACHED_SUCCESS, rc); - - rc= memcached_set(memc, key, strlen(key), - in_value, strlen(in_value), - (time_t)0, (uint32_t)0); - test_compare(MEMCACHED_SUCCESS, rc); + test_compare(MEMCACHED_SUCCESS, + memcached_flush(memc, 0)); - rc= memcached_append(memc, key, strlen(key), - " the", strlen(" the"), - (time_t)0, (uint32_t)0); - test_compare(MEMCACHED_SUCCESS, rc); + test_compare(MEMCACHED_SUCCESS, + memcached_set(memc, + test_literal_param(__func__), + in_value, strlen(in_value), + time_t(0), uint32_t(0))); - rc= memcached_append(memc, key, strlen(key), - " people", strlen(" people"), - (time_t)0, (uint32_t)0); - test_compare(MEMCACHED_SUCCESS, rc); + test_compare(MEMCACHED_SUCCESS, + memcached_append(memc, + test_literal_param(__func__), + " the", strlen(" the"), + time_t(0), uint32_t(0))); - out_value= memcached_get(memc, key, strlen(key), - &value_length, &flags, &rc); + test_compare(MEMCACHED_SUCCESS, + memcached_append(memc, + test_literal_param(__func__), + " people", strlen(" people"), + time_t(0), uint32_t(0))); + + char *out_value= memcached_get(memc, + test_literal_param(__func__), + &value_length, &flags, &rc); test_memcmp(out_value, "we the people", strlen("we the people")); test_compare(strlen("we the people"), value_length); test_compare(MEMCACHED_SUCCESS, rc); @@ -556,40 +570,40 @@ static test_return_t append_test(memcached_st *memc) static test_return_t append_binary_test(memcached_st *memc) { - memcached_return_t rc; - const char *key= "numbers"; uint32_t store_list[] = { 23, 56, 499, 98, 32847, 0 }; - uint32_t *value; - size_t value_length; - uint32_t flags; - uint32_t x; - rc= memcached_flush(memc, 0); - test_compare(MEMCACHED_SUCCESS, rc); + test_compare(MEMCACHED_SUCCESS, + memcached_flush(memc, 0)); - rc= memcached_set(memc, - key, strlen(key), - NULL, 0, - (time_t)0, (uint32_t)0); - test_compare_got(MEMCACHED_SUCCESS, rc, memcached_strerror(NULL, rc)); + test_compare(MEMCACHED_SUCCESS, + memcached_set(memc, + test_literal_param(__func__), + NULL, 0, + time_t(0), uint32_t(0))); - for (x= 0; store_list[x] ; x++) + size_t count= 0; + for (uint32_t x= 0; store_list[x] ; x++) { - rc= memcached_append(memc, - key, strlen(key), + test_compare(MEMCACHED_SUCCESS, + memcached_append(memc, + test_literal_param(__func__), (char *)&store_list[x], sizeof(uint32_t), - (time_t)0, (uint32_t)0); - test_compare(MEMCACHED_SUCCESS, rc); + time_t(0), uint32_t(0))); + count++; } - value= (uint32_t *)memcached_get(memc, key, strlen(key), - &value_length, &flags, &rc); - test_compare(value_length, sizeof(uint32_t) * x); + size_t value_length; + uint32_t flags; + memcached_return_t rc; + uint32_t *value= (uint32_t *)memcached_get(memc, + test_literal_param(__func__), + &value_length, &flags, &rc); + test_compare(value_length, sizeof(uint32_t) * count); test_compare(MEMCACHED_SUCCESS, rc); - for (uint32_t counter= x, *ptr= value; counter; counter--) + for (uint32_t counter= count, *ptr= value; counter; counter--) { - test_compare(*ptr, store_list[x - counter]); + test_compare(*ptr, store_list[count - counter]); ptr++; } free(value); @@ -599,34 +613,31 @@ static test_return_t append_binary_test(memcached_st *memc) static test_return_t cas2_test(memcached_st *memc) { - memcached_return_t rc; const char *keys[]= {"fudge", "son", "food"}; size_t key_length[]= {5, 3, 4}; const char *value= "we the people"; size_t value_length= strlen("we the people"); - memcached_result_st results_obj; - memcached_result_st *results; - unsigned int set= 1; test_compare(MEMCACHED_SUCCESS, memcached_flush(memc, 0)); - memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_SUPPORT_CAS, set); + test_compare(MEMCACHED_SUCCESS, memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_SUPPORT_CAS, true)); for (uint32_t x= 0; x < 3; x++) { - rc= memcached_set(memc, keys[x], key_length[x], - keys[x], key_length[x], - (time_t)50, (uint32_t)9); - test_compare(MEMCACHED_SUCCESS, rc); + test_compare(MEMCACHED_SUCCESS, + memcached_set(memc, keys[x], key_length[x], + keys[x], key_length[x], + time_t(50), uint32_t(9))); } test_compare(MEMCACHED_SUCCESS, memcached_mget(memc, keys, key_length, 3)); - results= memcached_result_create(memc, &results_obj); + memcached_result_st *results= memcached_result_create(memc, NULL); test_true(results); - results= memcached_fetch_result(memc, &results_obj, &rc); + memcached_return_t rc; + results= memcached_fetch_result(memc, results, &rc); test_true(results); test_true(results->item_cas); test_compare(MEMCACHED_SUCCESS, rc); @@ -636,51 +647,44 @@ static test_return_t cas2_test(memcached_st *memc) test_compare(strlen("we the people"), value_length); test_compare(MEMCACHED_SUCCESS, rc); - memcached_result_free(&results_obj); + memcached_result_free(results); return TEST_SUCCESS; } static test_return_t cas_test(memcached_st *memc) { - memcached_return_t rc; - const char *key= "fun"; - size_t key_length= strlen(key); - const char *value= "we the people"; - const char* keys[2] = { key, NULL }; - size_t keylengths[2] = { strlen(key), 0 }; - size_t value_length= strlen(value); - const char *value2= "change the value"; - size_t value2_length= strlen(value2); + const char* keys[2] = { __func__, NULL }; + size_t keylengths[2] = { strlen(__func__), 0 }; memcached_result_st results_obj; - memcached_result_st *results; - unsigned int set= 1; - rc= memcached_flush(memc, 0); - test_compare(MEMCACHED_SUCCESS, rc); + test_compare(MEMCACHED_SUCCESS, memcached_flush(memc, 0)); - memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_SUPPORT_CAS, set); + test_skip(true, memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_SUPPORT_CAS, true)); - rc= memcached_set(memc, key, strlen(key), - value, strlen(value), - (time_t)0, (uint32_t)0); - test_compare(MEMCACHED_SUCCESS, rc); + test_compare(MEMCACHED_SUCCESS, + memcached_set(memc, + test_literal_param(__func__), + test_literal_param("we the people"), + (time_t)0, (uint32_t)0)); test_compare(MEMCACHED_SUCCESS, memcached_mget(memc, keys, keylengths, 1)); - results= memcached_result_create(memc, &results_obj); + memcached_result_st *results= memcached_result_create(memc, &results_obj); test_true(results); + memcached_return_t rc; results= memcached_fetch_result(memc, &results_obj, &rc); test_true(results); test_compare(MEMCACHED_SUCCESS, rc); test_true(memcached_result_cas(results)); - test_memcmp(value, memcached_result_value(results), value_length); - test_compare(strlen(memcached_result_value(results)), value_length); - test_compare(MEMCACHED_SUCCESS, rc); - uint64_t cas = memcached_result_cas(results); + test_memcmp("we the people", memcached_result_value(results), test_literal_param_size("we the people")); + test_compare(test_literal_param_size("we the people"), + strlen(memcached_result_value(results))); + + uint64_t cas= memcached_result_cas(results); #if 0 results= memcached_fetch_result(memc, &results_obj, &rc); @@ -688,15 +692,21 @@ static test_return_t cas_test(memcached_st *memc) test_true(results == NULL); #endif - rc= memcached_cas(memc, key, key_length, value2, value2_length, 0, 0, cas); - test_compare(MEMCACHED_SUCCESS, rc); + test_compare(MEMCACHED_SUCCESS, + memcached_cas(memc, + test_literal_param(__func__), + test_literal_param("change the value"), + 0, 0, cas)); /* * The item will have a new cas value, so try to set it again with the old * value. This should fail! */ - rc= memcached_cas(memc, key, key_length, value2, value2_length, 0, 0, cas); - test_compare(MEMCACHED_DATA_EXISTS, rc); + test_compare(MEMCACHED_DATA_EXISTS, + memcached_cas(memc, + test_literal_param(__func__), + test_literal_param("change the value"), + 0, 0, cas)); memcached_result_free(&results_obj); @@ -705,32 +715,31 @@ static test_return_t cas_test(memcached_st *memc) static test_return_t prepend_test(memcached_st *memc) { - memcached_return_t rc; const char *key= "fig"; const char *value= "people"; - char *out_value= NULL; - size_t value_length; - uint32_t flags; - rc= memcached_flush(memc, 0); - test_compare(MEMCACHED_SUCCESS, rc); + test_compare(MEMCACHED_SUCCESS, + memcached_flush(memc, 0)); - rc= memcached_set(memc, key, strlen(key), - value, strlen(value), - (time_t)0, (uint32_t)0); - test_compare(MEMCACHED_SUCCESS, rc); + test_compare(MEMCACHED_SUCCESS, + memcached_set(memc, key, strlen(key), + value, strlen(value), + time_t(0), uint32_t(0))); - rc= memcached_prepend(memc, key, strlen(key), - "the ", strlen("the "), - (time_t)0, (uint32_t)0); - test_compare(MEMCACHED_SUCCESS, rc); + test_compare(MEMCACHED_SUCCESS, + memcached_prepend(memc, key, strlen(key), + "the ", strlen("the "), + time_t(0), uint32_t(0))); - rc= memcached_prepend(memc, key, strlen(key), - "we ", strlen("we "), - (time_t)0, (uint32_t)0); - test_compare(MEMCACHED_SUCCESS, rc); + test_compare(MEMCACHED_SUCCESS, + memcached_prepend(memc, key, strlen(key), + "we ", strlen("we "), + time_t(0), uint32_t(0))); - out_value= memcached_get(memc, key, strlen(key), + size_t value_length; + uint32_t flags; + memcached_return_t rc; + char *out_value= memcached_get(memc, key, strlen(key), &value_length, &flags, &rc); test_memcmp(out_value, "we the people", strlen("we the people")); test_compare(strlen("we the people"), value_length); @@ -746,31 +755,21 @@ static test_return_t prepend_test(memcached_st *memc) */ static test_return_t add_test(memcached_st *memc) { - memcached_return_t rc; - const char *key= "foo"; - const char *value= "when we sanitize"; - unsigned long long setting_value; + test_compare_hint(return_value_based_on_buffering(memc), + memcached_set(memc, + test_literal_param(__func__), + test_literal_param("when we sanitize"), + time_t(0), uint32_t(0)), + memcached_last_error_message(memc)); - setting_value= memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_NO_BLOCK); - - rc= memcached_set(memc, key, strlen(key), - value, strlen(value), - (time_t)0, (uint32_t)0); - test_true(rc == MEMCACHED_SUCCESS || rc == MEMCACHED_BUFFERED); memcached_quit(memc); - 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_true(rc == MEMCACHED_NOTSTORED || rc == MEMCACHED_STORED); - } - else - { - test_true(rc == MEMCACHED_NOTSTORED || rc == MEMCACHED_DATA_EXISTS); - } + test_compare_hint(memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL) ? MEMCACHED_DATA_EXISTS : MEMCACHED_NOTSTORED, + memcached_add(memc, + test_literal_param(__func__), + test_literal_param("try something else"), + time_t(0), uint32_t(0)), + memcached_last_error_message(memc)); return TEST_SUCCESS; } @@ -800,37 +799,34 @@ static test_return_t add_wrapper(memcached_st *memc) static test_return_t replace_test(memcached_st *memc) { - memcached_return_t rc; - const char *key= "foo"; - const char *value= "when we sanitize"; - const char *original= "first we insert some data"; - - rc= memcached_set(memc, key, strlen(key), - original, strlen(original), - (time_t)0, (uint32_t)0); - test_true(rc == MEMCACHED_SUCCESS || rc == MEMCACHED_BUFFERED); + test_compare(return_value_based_on_buffering(memc), + memcached_set(memc, + test_literal_param(__func__), + test_literal_param("when we sanitize"), + time_t(0), uint32_t(0))); test_compare(MEMCACHED_SUCCESS, - memcached_replace(memc, key, strlen(key), - value, strlen(value), - (time_t)0, (uint32_t)0)); + memcached_replace(memc, + test_literal_param(__func__), + test_literal_param("first we insert some data"), + time_t(0), uint32_t(0))); return TEST_SUCCESS; } static test_return_t delete_test(memcached_st *memc) { - memcached_return_t rc; - const char *key= "foo"; - const char *value= "when we sanitize"; - - rc= memcached_set(memc, key, strlen(key), - value, strlen(value), - (time_t)0, (uint32_t)0); - test_true(rc == MEMCACHED_SUCCESS || rc == MEMCACHED_BUFFERED); + test_compare(return_value_based_on_buffering(memc), + memcached_set(memc, + test_literal_param(__func__), + test_literal_param("when we sanitize"), + time_t(0), uint32_t(0))); - rc= memcached_delete(memc, key, strlen(key), (time_t)0); - test_true(rc == MEMCACHED_SUCCESS || rc == MEMCACHED_BUFFERED); + test_compare_hint(return_value_based_on_buffering(memc), + memcached_delete(memc, + test_literal_param(__func__), + time_t(0)), + memcached_last_error_message(memc)); return TEST_SUCCESS; } @@ -845,13 +841,11 @@ static test_return_t flush_test(memcached_st *memc) return TEST_SUCCESS; } -static memcached_return_t server_function(const memcached_st *ptr, - const memcached_server_st *server, - void *context) +static memcached_return_t server_function(const memcached_st *, + const memcached_server_st *, + void *) { - (void)ptr; (void)server; (void)context; /* Do Nothing */ - return MEMCACHED_SUCCESS; } @@ -871,7 +865,6 @@ static test_return_t bad_key_test(memcached_st *memc) memcached_return_t rc; const char *key= "foo bad"; uint32_t flags; - memcached_st *memc_clone; uint64_t query_id= memcached_query_id(memc); @@ -880,7 +873,7 @@ static test_return_t bad_key_test(memcached_st *memc) test_compare(query_id, memcached_query_id(memc)); // We should not increase the query_id for memcached_behavior_get() - memc_clone= memcached_clone(NULL, memc); + memcached_st *memc_clone= memcached_clone(NULL, memc); test_true(memc_clone); query_id= memcached_query_id(memc_clone); @@ -889,7 +882,7 @@ static test_return_t bad_key_test(memcached_st *memc) test_compare(query_id, memcached_query_id(memc_clone)); // We should not increase the query_id for memcached_behavior_set() /* All keys are valid in the binary protocol (except for length) */ - if (not memcached_behavior_get(memc_clone, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL)) + if (memcached_behavior_get(memc_clone, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL) == false) { uint64_t before_query_id= memcached_query_id(memc_clone); { @@ -993,24 +986,24 @@ static memcached_return_t read_through_trigger(memcached_st *memc, static test_return_t read_through(memcached_st *memc) { - memcached_return_t rc; - const char *key= "foo"; - char *string; - size_t string_length; - uint32_t flags; memcached_trigger_key_fn cb= (memcached_trigger_key_fn)read_through_trigger; - string= memcached_get(memc, key, strlen(key), - &string_length, &flags, &rc); + size_t string_length; + uint32_t flags; + memcached_return_t rc; + char *string= memcached_get(memc, + test_literal_param(__func__), + &string_length, &flags, &rc); test_compare(MEMCACHED_NOTFOUND, rc); test_false(string_length); test_false(string); - rc= memcached_callback_set(memc, MEMCACHED_CALLBACK_GET_FAILURE, *(void **)&cb); - test_compare(MEMCACHED_SUCCESS, rc); + test_compare(MEMCACHED_SUCCESS, + memcached_callback_set(memc, MEMCACHED_CALLBACK_GET_FAILURE, *(void **)&cb)); - string= memcached_get(memc, key, strlen(key), + string= memcached_get(memc, + test_literal_param(__func__), &string_length, &flags, &rc); test_compare(MEMCACHED_SUCCESS, rc); @@ -1019,7 +1012,8 @@ static test_return_t read_through(memcached_st *memc) test_strcmp(READ_THROUGH_VALUE, string); free(string); - string= memcached_get(memc, key, strlen(key), + string= memcached_get(memc, + test_literal_param(__func__), &string_length, &flags, &rc); test_compare(MEMCACHED_SUCCESS, rc); @@ -1035,17 +1029,19 @@ static test_return_t read_through(memcached_st *memc) static test_return_t get_test(memcached_st *memc) { memcached_return_t rc; - const char *key= "foo"; char *string; size_t string_length; uint32_t flags; uint64_t query_id= memcached_query_id(memc); - rc= memcached_delete(memc, key, strlen(key), (time_t)0); - test_true(rc == MEMCACHED_BUFFERED || rc == MEMCACHED_NOTFOUND); + rc= memcached_delete(memc, + test_literal_param(__func__), + time_t(0)); + test_true_got(rc == MEMCACHED_BUFFERED or rc == MEMCACHED_NOTFOUND, memcached_last_error_message(memc)); test_compare(query_id +1, memcached_query_id(memc)); - string= memcached_get(memc, key, strlen(key), + string= memcached_get(memc, + test_literal_param(__func__), &string_length, &flags, &rc); test_compare_got(MEMCACHED_NOTFOUND, rc, memcached_strerror(NULL, rc)); @@ -1057,14 +1053,14 @@ static test_return_t get_test(memcached_st *memc) static test_return_t get_test2(memcached_st *memc) { - const char *key= "foo"; const char *value= "when we sanitize"; uint64_t query_id= memcached_query_id(memc); - memcached_return_t rc= memcached_set(memc, key, strlen(key), - value, strlen(value), - (time_t)0, (uint32_t)0); - test_true(rc == MEMCACHED_SUCCESS or rc == MEMCACHED_BUFFERED); + test_compare(return_value_based_on_buffering(memc), + memcached_set(memc, + test_literal_param(__func__), + value, strlen(value), + time_t(0), uint32_t(0))); test_compare(query_id +1, memcached_query_id(memc)); query_id= memcached_query_id(memc); @@ -1072,7 +1068,9 @@ static test_return_t get_test2(memcached_st *memc) uint32_t flags; size_t string_length; - char *string= memcached_get(memc, key, strlen(key), + memcached_return_t rc; + char *string= memcached_get(memc, + test_literal_param(__func__), &string_length, &flags, &rc); test_compare(query_id +1, memcached_query_id(memc)); @@ -1091,11 +1089,11 @@ static test_return_t set_test2(memcached_st *memc) { for (uint32_t x= 0; x < 10; x++) { - memcached_return_t rc= memcached_set(memc, - test_literal_param("foo"), - test_literal_param("train in the brain"), - time_t(0), uint32_t(0)); - test_true(rc == MEMCACHED_SUCCESS or rc == MEMCACHED_BUFFERED); + test_compare(return_value_based_on_buffering(memc), + memcached_set(memc, + test_literal_param("foo"), + test_literal_param("train in the brain"), + time_t(0), uint32_t(0))); } return TEST_SUCCESS; @@ -1120,10 +1118,11 @@ static test_return_t set_test3(memcached_st *memc) snprintf(key, sizeof(key), "foo%u", x); uint64_t query_id= memcached_query_id(memc); - memcached_return_t rc= memcached_set(memc, key, strlen(key), - &value[0], value.size(), - (time_t)0, (uint32_t)0); - test_true_got(rc == MEMCACHED_SUCCESS or rc == MEMCACHED_BUFFERED, memcached_strerror(NULL, rc)); + test_compare_hint(return_value_based_on_buffering(memc), + memcached_set(memc, key, strlen(key), + &value[0], value.size(), + time_t(0), uint32_t(0)), + memcached_last_error_message(memc)); test_compare(query_id +1, memcached_query_id(memc)); } @@ -1132,7 +1131,6 @@ static test_return_t set_test3(memcached_st *memc) static test_return_t get_test3(memcached_st *memc) { - const char *key= "foo"; size_t value_length= 8191; std::vector value; @@ -1142,20 +1140,23 @@ static test_return_t get_test3(memcached_st *memc) value.push_back(char(x % 127)); } - memcached_return_t rc; - rc= memcached_set(memc, key, strlen(key), - &value[0], value.size(), - (time_t)0, (uint32_t)0); - test_true(rc == MEMCACHED_SUCCESS or rc == MEMCACHED_BUFFERED); + test_compare_hint(return_value_based_on_buffering(memc), + memcached_set(memc, + test_literal_param(__func__), + &value[0], value.size(), + time_t(0), uint32_t(0)), + memcached_last_error_message(memc)); size_t string_length; uint32_t flags; - char *string= memcached_get(memc, key, strlen(key), + memcached_return_t rc; + char *string= memcached_get(memc, + test_literal_param(__func__), &string_length, &flags, &rc); test_compare(MEMCACHED_SUCCESS, rc); test_true(string); - test_compare(string_length, value_length); + test_compare(value.size(), string_length); test_memcmp(string, &value[0], string_length); free(string); @@ -1165,7 +1166,6 @@ static test_return_t get_test3(memcached_st *memc) static test_return_t get_test4(memcached_st *memc) { - const char *key= "foo"; size_t value_length= 8191; std::vector value; @@ -1175,21 +1175,25 @@ static test_return_t get_test4(memcached_st *memc) value.push_back(char(x % 127)); } - memcached_return_t rc= memcached_set(memc, key, strlen(key), - &value[0], value.size(), - (time_t)0, (uint32_t)0); - test_true(rc == MEMCACHED_SUCCESS or rc == MEMCACHED_BUFFERED); + test_compare_hint(return_value_based_on_buffering(memc), + memcached_set(memc, + test_literal_param(__func__), + &value[0], value.size(), + time_t(0), uint32_t(0)), + memcached_last_error_message(memc)); for (uint32_t x= 0; x < 10; x++) { uint32_t flags; size_t string_length; - char *string= memcached_get(memc, key, strlen(key), + memcached_return_t rc; + char *string= memcached_get(memc, + test_literal_param(__func__), &string_length, &flags, &rc); test_compare(MEMCACHED_SUCCESS, rc); test_true(string); - test_compare(string_length, value_length); + test_compare(value.size(), string_length); test_memcmp(string, &value[0], string_length); free(string); } @@ -1213,14 +1217,18 @@ static test_return_t get_test5(memcached_st *memc) uint32_t flags; size_t rlen; - memcached_return_t rc= memcached_set(memc, keys[0], lengths[0], - keys[0], lengths[0], 0, 0); + test_compare_hint(return_value_based_on_buffering(memc), + memcached_set(memc, keys[0], lengths[0], + keys[0], lengths[0], + time_t(0), uint32_t(0)), + memcached_last_error_message(memc)); test_compare(MEMCACHED_SUCCESS, memcached_mget(memc, keys, lengths, test_array_length(keys))); memcached_result_st results_obj; memcached_result_st *results= memcached_result_create(memc, &results_obj); test_true(results); + memcached_return_t rc; results= memcached_fetch_result(memc, &results_obj, &rc); test_true(results); @@ -1247,12 +1255,14 @@ static test_return_t mget_end(memcached_st *memc) size_t lengths[]= { 3, 4 }; const char *values[]= { "fjord", "41" }; - memcached_return_t rc; - // Set foo and foo2 for (size_t x= 0; x < test_array_length(keys); x++) { - test_compare(MEMCACHED_SUCCESS, memcached_set(memc, keys[x], lengths[x], values[x], strlen(values[x]), (time_t)0, (uint32_t)0)); + test_compare(MEMCACHED_SUCCESS, + memcached_set(memc, + keys[x], lengths[x], + values[x], strlen(values[x]), + time_t(0), uint32_t(0))); } char *string; @@ -1260,10 +1270,14 @@ static test_return_t mget_end(memcached_st *memc) uint32_t flags; // retrieve both via mget - test_compare(MEMCACHED_SUCCESS, memcached_mget(memc, keys, lengths, test_array_length(keys))); + test_compare(MEMCACHED_SUCCESS, + memcached_mget(memc, + keys, lengths, + test_array_length(keys))); char key[MEMCACHED_MAX_KEY]; size_t key_length; + memcached_return_t rc; // this should get both for (size_t x= 0; x < test_array_length(keys); x++) @@ -1288,8 +1302,8 @@ static test_return_t mget_end(memcached_st *memc) test_null(string); // now get just one - rc= memcached_mget(memc, keys, lengths, 1); - test_compare(MEMCACHED_SUCCESS, rc); + test_compare(MEMCACHED_SUCCESS, + memcached_mget(memc, keys, lengths, 1)); string= memcached_fetch(memc, key, &key_length, &string_length, &flags, &rc); test_compare(key_length, lengths[0]); @@ -1369,25 +1383,24 @@ static test_return_t increment_with_initial_test(memcached_st *memc) static test_return_t decrement_test(memcached_st *memc) { - uint64_t new_number; - memcached_return_t rc; - const char *value= "3"; - - rc= memcached_set(memc, - test_literal_param("number"), - value, strlen(value), - (time_t)0, (uint32_t)0); - test_true(rc == MEMCACHED_SUCCESS or rc == MEMCACHED_BUFFERED); + test_compare(return_value_based_on_buffering(memc), + memcached_set(memc, + test_literal_param(__func__), + test_literal_param("3"), + time_t(0), uint32_t(0))); + // Make sure we flush the value we just set + test_compare(MEMCACHED_SUCCESS, memcached_flush_buffers(memc)); + uint64_t new_number; test_compare(MEMCACHED_SUCCESS, memcached_decrement(memc, - test_literal_param("number"), + test_literal_param(__func__), 1, &new_number)); test_compare(uint64_t(2), new_number); test_compare(MEMCACHED_SUCCESS, memcached_decrement(memc, - test_literal_param("number"), + test_literal_param(__func__), 1, &new_number)); test_compare(uint64_t(1), new_number); @@ -1398,21 +1411,23 @@ static test_return_t decrement_with_initial_test(memcached_st *memc) { test_skip(true, memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL)); - uint64_t new_number; uint64_t initial= 3; test_compare(MEMCACHED_SUCCESS, memcached_flush_buffers(memc)); + uint64_t new_number; test_compare(MEMCACHED_SUCCESS, memcached_decrement_with_initial(memc, - test_literal_param("number"), - 1, initial, 0, &new_number)); + test_literal_param(__func__), + 1, initial, + 0, &new_number)); test_compare(new_number, initial); test_compare(MEMCACHED_SUCCESS, memcached_decrement_with_initial(memc, - test_literal_param("number"), - 1, initial, 0, &new_number)); + test_literal_param(__func__), + 1, initial, + 0, &new_number)); test_compare(new_number, (initial - 1)); return TEST_SUCCESS; @@ -1420,24 +1435,28 @@ static test_return_t decrement_with_initial_test(memcached_st *memc) static test_return_t increment_by_key_test(memcached_st *memc) { - uint64_t new_number; - memcached_return_t rc; const char *master_key= "foo"; const char *key= "number"; const char *value= "0"; - rc= memcached_set_by_key(memc, master_key, strlen(master_key), - key, strlen(key), - value, strlen(value), - (time_t)0, (uint32_t)0); - test_true(rc == MEMCACHED_SUCCESS or rc == MEMCACHED_BUFFERED); + test_compare(return_value_based_on_buffering(memc), + memcached_set_by_key(memc, master_key, strlen(master_key), + key, strlen(key), + value, strlen(value), + time_t(0), uint32_t(0))); + + // Make sure we flush the value we just set + test_compare(MEMCACHED_SUCCESS, memcached_flush_buffers(memc)); + uint64_t new_number; test_compare(MEMCACHED_SUCCESS, - memcached_increment_by_key(memc, master_key, strlen(master_key), key, strlen(key), 1, &new_number)); + memcached_increment_by_key(memc, master_key, strlen(master_key), + key, strlen(key), 1, &new_number)); test_compare(uint64_t(1), new_number); test_compare(MEMCACHED_SUCCESS, - memcached_increment_by_key(memc, master_key, strlen(master_key), key, strlen(key), 1, &new_number)); + memcached_increment_by_key(memc, master_key, strlen(master_key), + key, strlen(key), 1, &new_number)); test_compare(uint64_t(2), new_number); return TEST_SUCCESS; @@ -1448,21 +1467,20 @@ static test_return_t increment_with_initial_by_key_test(memcached_st *memc) test_skip(true, memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL)); uint64_t new_number; - memcached_return_t rc; const char *master_key= "foo"; const char *key= "number"; uint64_t initial= 0; - rc= memcached_increment_with_initial_by_key(memc, master_key, strlen(master_key), - key, strlen(key), - 1, initial, 0, &new_number); - test_compare(MEMCACHED_SUCCESS, rc); + test_compare(MEMCACHED_SUCCESS, + memcached_increment_with_initial_by_key(memc, master_key, strlen(master_key), + key, strlen(key), + 1, initial, 0, &new_number)); test_compare(new_number, initial); - rc= memcached_increment_with_initial_by_key(memc, master_key, strlen(master_key), - key, strlen(key), - 1, initial, 0, &new_number); - test_compare(MEMCACHED_SUCCESS, rc); + test_compare(MEMCACHED_SUCCESS, + memcached_increment_with_initial_by_key(memc, master_key, strlen(master_key), + key, strlen(key), + 1, initial, 0, &new_number)); test_compare(new_number, (initial +1)); return TEST_SUCCESS; @@ -1471,15 +1489,14 @@ static test_return_t increment_with_initial_by_key_test(memcached_st *memc) static test_return_t decrement_by_key_test(memcached_st *memc) { uint64_t new_number; - memcached_return_t rc; const char *value= "3"; - rc= memcached_set_by_key(memc, - test_literal_param("foo"), - test_literal_param("number"), - value, strlen(value), - (time_t)0, (uint32_t)0); - test_true(rc == MEMCACHED_SUCCESS or rc == MEMCACHED_BUFFERED); + test_compare(return_value_based_on_buffering(memc), + memcached_set_by_key(memc, + test_literal_param("foo"), + test_literal_param("number"), + value, strlen(value), + (time_t)0, (uint32_t)0)); test_compare(MEMCACHED_SUCCESS, memcached_decrement_by_key(memc, @@ -1521,20 +1538,17 @@ static test_return_t decrement_with_initial_by_key_test(memcached_st *memc) return TEST_SUCCESS; } -static test_return_t binary_increment_with_prefix_test(memcached_st *orig_memc) +static test_return_t binary_increment_with_prefix_test(memcached_st *memc) { - memcached_st *memc= memcached_clone(NULL, orig_memc); - - test_skip(TEST_SUCCESS, pre_binary(memc)); + test_skip(true, memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL)); test_compare(MEMCACHED_SUCCESS, memcached_callback_set(memc, MEMCACHED_CALLBACK_PREFIX_KEY, (void *)"namespace:")); - memcached_return_t rc; - rc= memcached_set(memc, - test_literal_param("number"), - test_literal_param("0"), - (time_t)0, (uint32_t)0); - test_true(rc == MEMCACHED_SUCCESS || rc == MEMCACHED_BUFFERED); + test_compare(return_value_based_on_buffering(memc), + memcached_set(memc, + test_literal_param("number"), + test_literal_param("0"), + (time_t)0, (uint32_t)0)); uint64_t new_number; test_compare(MEMCACHED_SUCCESS, memcached_increment(memc, @@ -1546,27 +1560,26 @@ static test_return_t binary_increment_with_prefix_test(memcached_st *orig_memc) test_literal_param("number"), 1, &new_number)); test_compare(uint64_t(2), new_number); - memcached_free(memc); return TEST_SUCCESS; } static test_return_t quit_test(memcached_st *memc) { - memcached_return_t rc; - const char *key= "fudge"; const char *value= "sanford and sun"; - rc= memcached_set(memc, key, strlen(key), - value, strlen(value), - (time_t)10, (uint32_t)3); - test_true_got(rc == MEMCACHED_SUCCESS or rc == MEMCACHED_BUFFERED, memcached_strerror(NULL, rc)); + test_compare(return_value_based_on_buffering(memc), + memcached_set(memc, + test_literal_param(__func__), + value, strlen(value), + (time_t)10, (uint32_t)3)); memcached_quit(memc); - rc= memcached_set(memc, key, strlen(key), - value, strlen(value), - (time_t)50, (uint32_t)9); - test_true(rc == MEMCACHED_SUCCESS or rc == MEMCACHED_BUFFERED); + test_compare(return_value_based_on_buffering(memc), + memcached_set(memc, + test_literal_param(__func__), + value, strlen(value), + (time_t)50, (uint32_t)9)); return TEST_SUCCESS; } @@ -1693,16 +1706,15 @@ static test_return_t mget_result_function(memcached_st *memc) size_t counter; memcached_execute_fn callbacks[1]; - /* We need to empty the server before continueing test */ - test_compare(MEMCACHED_SUCCESS, - memcached_flush(memc, 0)); for (uint32_t x= 0; x < 3; x++) { - memcached_return_t rc= memcached_set(memc, keys[x], key_length[x], - keys[x], key_length[x], - (time_t)50, (uint32_t)9); - test_true(rc == MEMCACHED_SUCCESS || rc == MEMCACHED_BUFFERED); + test_compare(return_value_based_on_buffering(memc), + memcached_set(memc, keys[x], key_length[x], + keys[x], key_length[x], + time_t(50), uint32_t(9))); } + test_compare(MEMCACHED_SUCCESS, memcached_flush_buffers(memc)); + memcached_quit(memc); test_compare(MEMCACHED_SUCCESS, memcached_mget(memc, keys, key_length, 3)); @@ -1728,10 +1740,6 @@ static test_return_t mget_test(memcached_st *memc) char *return_value; size_t return_value_length; - /* We need to empty the server before continueing test */ - test_compare(MEMCACHED_SUCCESS, - memcached_flush(memc, 0)); - test_compare(MEMCACHED_SUCCESS, memcached_mget(memc, keys, key_length, 3)); @@ -2106,36 +2114,25 @@ 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, unsigned int &keys_returned, const memcached_return_t expect) +static test_return_t fetch_all_results(memcached_st *memc, unsigned int &keys_returned, memcached_return_t& rc) { - memcached_return_t rc; - char return_key[MEMCACHED_MAX_KEY]; - size_t return_key_length; - char *return_value; - 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))) + + memcached_result_st* result= NULL; + while ((result= memcached_fetch_result(memc, result, &rc))) { - test_true(return_value); - test_compare_got(MEMCACHED_SUCCESS, rc, memcached_strerror(NULL, rc)); - free(return_value); + test_compare(MEMCACHED_SUCCESS, rc); keys_returned+= 1; } + memcached_result_free(result); - if (memcached_success(expect) and memcached_success(rc)) - { - return TEST_SUCCESS; - } - else if (expect == rc) - { - return TEST_SUCCESS; - } - fprintf(stderr, "\n%s:%u %s(#%u)\n", __FILE__, __LINE__, memcached_strerror(NULL, rc), keys_returned); + return TEST_SUCCESS; +} - return TEST_FAILURE; +static test_return_t fetch_all_results(memcached_st *memc, unsigned int &keys_returned) +{ + memcached_return_t rc; + return fetch_all_results(memc, keys_returned, rc); } /* Test case provided by Cal Haldenbrand */ @@ -2167,10 +2164,12 @@ static test_return_t user_supplied_bug1(memcached_st *memc) } total+= size; - char key[22]; + char key[MEMCACHED_MAXIMUM_INTEGER_DISPLAY_LENGTH +1]; int key_length= snprintf(key, sizeof(key), "%u", x); test_compare(MEMCACHED_SUCCESS, - memcached_set(memc, key, key_length, randomstuff, strlen(randomstuff), time_t(0), HALDENBRAND_FLAG_KEY)); + memcached_set(memc, key, key_length, + randomstuff, strlen(randomstuff), + time_t(0), HALDENBRAND_FLAG_KEY)); } test_true(total > HALDENBRAND_KEY_COUNT); @@ -2220,10 +2219,11 @@ static test_return_t user_supplied_bug2(memcached_st *memc) continue; } test_compare(uint32_t(HALDENBRAND_FLAG_KEY), flags); + test_true(getval); total_value_length+= val_len; errors= 0; - free(getval); + ::free(getval); } return TEST_SUCCESS; @@ -2232,8 +2232,8 @@ static test_return_t user_supplied_bug2(memcached_st *memc) /* Do a large mget() over all the keys we think exist */ static test_return_t user_supplied_bug3(memcached_st *memc) { - test_compare(MEMCACHED_SUCCESS, memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_NO_BLOCK, 1)); - test_compare(MEMCACHED_SUCCESS, memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_TCP_NODELAY, 1)); + test_compare(MEMCACHED_SUCCESS, memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_NO_BLOCK, true)); + test_compare(MEMCACHED_SUCCESS, memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_TCP_NODELAY, true)); #ifdef NOT_YET memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_SOCKET_SEND_SIZE, 20 * 1024576); @@ -2259,14 +2259,14 @@ static test_return_t user_supplied_bug3(memcached_st *memc) memcached_mget(memc, &keys[0], &key_lengths[0], key_lengths.size())); unsigned int keys_returned; - test_compare(TEST_SUCCESS, fetch_all_results(memc, keys_returned, MEMCACHED_SUCCESS)); + test_compare(TEST_SUCCESS, fetch_all_results(memc, keys_returned)); test_compare(HALDENBRAND_KEY_COUNT, keys_returned); for (std::vector::iterator iter= keys.begin(); iter != keys.end(); iter++) { - free(*iter); + ::free(*iter); } return TEST_SUCCESS; @@ -2289,9 +2289,13 @@ static test_return_t user_supplied_bug4(memcached_st *memc) test_compare(MEMCACHED_NO_SERVERS, memcached_mget(memc, keys, key_length, 3)); - unsigned int keys_returned; - test_compare(TEST_SUCCESS, fetch_all_results(memc, keys_returned, MEMCACHED_NOTFOUND)); - test_zero(keys_returned); + { + unsigned int keys_returned; + memcached_return_t rc; + test_compare(TEST_SUCCESS, fetch_all_results(memc, keys_returned, rc)); + test_compare(MEMCACHED_NOTFOUND, rc); + test_zero(keys_returned); + } for (uint32_t x= 0; x < 3; x++) { @@ -2351,7 +2355,8 @@ static test_return_t user_supplied_bug5(memcached_st *memc) memcached_mget(memc, keys, key_length, 4)); unsigned int count; - test_compare(TEST_SUCCESS, fetch_all_results(memc, count, MEMCACHED_NOTFOUND)); + test_compare(TEST_SUCCESS, fetch_all_results(memc, count, rc)); + test_compare(MEMCACHED_NOTFOUND, rc); test_zero(count); for (uint32_t x= 0; x < 4; x++) @@ -2368,12 +2373,12 @@ static test_return_t user_supplied_bug5(memcached_st *memc) &value_length, &flags, &rc); test_compare(rc, MEMCACHED_SUCCESS); test_true(value); - free(value); + ::free(value); test_compare(MEMCACHED_SUCCESS, memcached_mget(memc, keys, key_length, 4)); - test_compare(TEST_SUCCESS, fetch_all_results(memc, count, MEMCACHED_SUCCESS)); + test_compare(TEST_SUCCESS, fetch_all_results(memc, count)); test_compare(4U, count); } delete [] insert_data; @@ -2483,37 +2488,36 @@ static test_return_t user_supplied_bug8(memcached_st *) /* Test flag store/retrieve */ static test_return_t user_supplied_bug7(memcached_st *memc) { - const char *keys= "036790384900"; - size_t key_length= strlen(keys); - char return_key[MEMCACHED_MAX_KEY]; - size_t return_key_length; - char *value; - size_t value_length; - uint32_t flags; char *insert_data= new (std::nothrow) char[VALUE_SIZE_BUG5]; + test_true(insert_data); - for (unsigned int x= 0; x < VALUE_SIZE_BUG5; x++) + for (size_t x= 0; x < VALUE_SIZE_BUG5; x++) { insert_data[x]= (signed char)rand(); } memcached_flush(memc, 0); - flags= 245; - test_compare(MEMCACHED_SUCCESS, memcached_set(memc, keys, key_length, - insert_data, VALUE_SIZE_BUG5, - (time_t)0, flags)); + const char *keys= "036790384900"; + size_t key_length= strlen(keys); + test_compare_hint(MEMCACHED_SUCCESS, memcached_set(memc, keys, key_length, + insert_data, VALUE_SIZE_BUG5, + time_t(0), 245U), + memcached_last_error_message(memc)); memcached_return_t rc; - flags= 0; - value= memcached_get(memc, keys, key_length, - &value_length, &flags, &rc); + size_t value_length; + uint32_t flags= 0; + char *value= memcached_get(memc, keys, key_length, + &value_length, &flags, &rc); test_compare(245U, flags); test_true(value); free(value); test_compare(MEMCACHED_SUCCESS, memcached_mget(memc, &keys, &key_length, 1)); + char return_key[MEMCACHED_MAX_KEY]; + size_t return_key_length; flags= 0; value= memcached_fetch(memc, return_key, &return_key_length, &value_length, &flags, &rc); @@ -2795,19 +2799,20 @@ static test_return_t user_supplied_bug15(memcached_st *memc) /* Check the return sizes on FLAGS to make sure it stores 32bit unsigned values correctly */ static test_return_t user_supplied_bug16(memcached_st *memc) { - memcached_return_t rc= memcached_set(memc, test_literal_param("mykey"), - NULL, 0, - (time_t)0, UINT32_MAX); + test_compare_hint(MEMCACHED_SUCCESS, memcached_set(memc, test_literal_param("mykey"), + NULL, 0, + (time_t)0, UINT32_MAX), + memcached_last_error_message(memc)); - test_compare(MEMCACHED_SUCCESS, rc); size_t length; uint32_t flags; + memcached_return_t rc; char *value= memcached_get(memc, test_literal_param("mykey"), &length, &flags, &rc); test_compare(MEMCACHED_SUCCESS, rc); - test_true(value == NULL); + test_null(value); test_zero(length); test_compare(flags, UINT32_MAX); @@ -3115,7 +3120,7 @@ static test_return_t generate_data(memcached_st *memc) { unsigned int check_execute= execute_set(memc, global_pairs, global_count); - test_compare(check_execute, global_count); + test_compare_warn_hint(global_count, check_execute, "Possible false, positive, memcached may have ejected key/value based on memory needs"); return TEST_SUCCESS; } @@ -3192,6 +3197,7 @@ static test_return_t get_read_count(memcached_st *memc) static test_return_t get_read(memcached_st *memc) { + size_t keys_returned= 0; for (size_t x= 0; x < global_count; x++) { size_t return_value_length; @@ -3205,9 +3211,11 @@ static test_return_t get_read(memcached_st *memc) */ if (rc == MEMCACHED_SUCCESS && return_value) { + keys_returned++; free(return_value); } } + test_compare_warn_hint(global_count, keys_returned, "Possible false, positive, memcached may have ejected key/value based on memory needs"); return TEST_SUCCESS; } @@ -3223,7 +3231,7 @@ static test_return_t mget_read(memcached_st *memc) // Go fetch the keys and test to see if all of them were returned { unsigned int keys_returned; - test_compare(TEST_SUCCESS, fetch_all_results(memc, keys_returned, MEMCACHED_SUCCESS)); + test_compare(TEST_SUCCESS, fetch_all_results(memc, keys_returned)); test_true(keys_returned > 0); test_compare_warn_hint(global_count, keys_returned, "Possible false, positive, memcached may have ejected key/value based on memory needs"); } @@ -3348,10 +3356,15 @@ static test_return_t mget_read_function(memcached_st *memc) static test_return_t delete_generate(memcached_st *memc) { + size_t total= 0; for (size_t x= 0; x < global_count; x++) { - (void)memcached_delete(memc, global_keys[x], global_keys_length[x], (time_t)0); + if (memcached_success(memcached_delete(memc, global_keys[x], global_keys_length[x], (time_t)0))) + { + total++; + } } + test_compare_warn_hint(global_count, total, "Possible false, positive, memcached may have ejected key/value based on memory needs"); return TEST_SUCCESS; } @@ -3360,10 +3373,15 @@ static test_return_t delete_buffer_generate(memcached_st *memc) { memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_BUFFER_REQUESTS, true); + size_t total= 0; for (size_t x= 0; x < global_count; x++) { - (void)memcached_delete(memc, global_keys[x], global_keys_length[x], (time_t)0); + if (memcached_success(memcached_delete(memc, global_keys[x], global_keys_length[x], (time_t)0))) + { + total++; + } } + test_compare_warn_hint(global_count, total, "Possible false, positive, memcached may have ejected key/value based on memory needs"); return TEST_SUCCESS; } @@ -3934,11 +3952,11 @@ static test_return_t MEMCACHED_BEHAVIOR_POLL_TIMEOUT_test(memcached_st *memc) static test_return_t noreply_test(memcached_st *memc) { test_compare(MEMCACHED_SUCCESS, - memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_NOREPLY, 1)); + memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_NOREPLY, true)); test_compare(MEMCACHED_SUCCESS, - memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_BUFFER_REQUESTS, 1)); + memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_BUFFER_REQUESTS, true)); test_compare(MEMCACHED_SUCCESS, - memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_SUPPORT_CAS, 1)); + memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_SUPPORT_CAS, true)); test_compare(1LLU, memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_NOREPLY)); test_compare(1LLU, memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_BUFFER_REQUESTS)); test_compare(1LLU, memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_SUPPORT_CAS)); @@ -3948,7 +3966,7 @@ static test_return_t noreply_test(memcached_st *memc) { for (size_t x= 0; x < 100; ++x) { - char key[10]; + char key[MEMCACHED_MAXIMUM_INTEGER_DISPLAY_LENGTH +1]; int check_length= (size_t)snprintf(key, sizeof(key), "%lu", (unsigned long)x); test_false((size_t)check_length >= sizeof(key) || check_length < 0); @@ -4072,8 +4090,8 @@ static test_return_t noreply_test(memcached_st *memc) static test_return_t analyzer_test(memcached_st *memc) { - memcached_return_t rc; memcached_analysis_st *report; + memcached_return_t rc; memcached_stat_st *memc_stat= memcached_stat(memc, NULL, &rc); test_compare(MEMCACHED_SUCCESS, rc); @@ -4089,24 +4107,6 @@ static test_return_t analyzer_test(memcached_st *memc) return TEST_SUCCESS; } -/* Count the objects */ - -static test_return_t dump_test(memcached_st *memc) -{ - /* No support for Binary protocol yet */ - test_skip(false, memc->flags.binary_protocol); - - test_compare(TEST_SUCCESS, set_test3(memc)); - - // confirm_key_count() call dump - size_t counter= confirm_key_count(memc); - - /* We may have more then 32 if our previous flush has not completed */ - test_true(counter >= 32); - - return TEST_SUCCESS; -} - static test_return_t util_version_test(memcached_st *memc) { test_compare_hint(MEMCACHED_SUCCESS, memcached_version(memc), memcached_last_error_message(memc)); @@ -4662,6 +4662,8 @@ static test_return_t regression_bug_434843(memcached_st *original_memc) test_compare(MEMCACHED_SUCCESS, memcached_mget(memc, (const char**)keys, key_length, max_keys)); + // One the first run we should get a NOT_FOUND, but on the second some data + // should be returned. test_compare(y ? MEMCACHED_SUCCESS : MEMCACHED_NOTFOUND, memcached_fetch_execute(memc, callbacks, (void *)&counter, 1)); @@ -4772,8 +4774,7 @@ static test_return_t regression_bug_442914(memcached_st *memc) test_true(rc == MEMCACHED_SUCCESS || rc == MEMCACHED_BUFFERED); } - (void)snprintf(k, sizeof(k), "%037u", 251U); - len= strlen(k); + len= snprintf(k, sizeof(k), "%037u", 251U); memcached_return_t rc= memcached_delete(memc, k, len, 0); test_true(rc == MEMCACHED_SUCCESS || rc == MEMCACHED_BUFFERED); @@ -4910,6 +4911,10 @@ static test_return_t regression_bug_447342(memcached_st *memc) static test_return_t regression_bug_463297(memcached_st *memc) { + test_compare(MEMCACHED_INVALID_ARGUMENTS, memcached_delete(memc, "foo", 3, 1)); + + // Since we blocked timed delete, this test is no longer valid. +#if 0 memcached_st *memc_clone= memcached_clone(NULL, memc); test_true(memc_clone); test_true(memcached_version(memc_clone) == MEMCACHED_SUCCESS); @@ -4965,6 +4970,8 @@ static test_return_t regression_bug_463297(memcached_st *memc) } memcached_free(memc_clone); +#endif + return TEST_SUCCESS; } @@ -5088,14 +5095,14 @@ static test_return_t memcached_stat_execute_test(memcached_st *memc) memcached_return_t rc= memcached_stat_execute(memc, NULL, stat_printer, NULL); test_compare(MEMCACHED_SUCCESS, rc); - rc= memcached_stat_execute(memc, "slabs", stat_printer, NULL); - test_compare(MEMCACHED_SUCCESS, rc); + test_compare(MEMCACHED_SUCCESS, + memcached_stat_execute(memc, "slabs", stat_printer, NULL)); - rc= memcached_stat_execute(memc, "items", stat_printer, NULL); - test_compare(MEMCACHED_SUCCESS, rc); + test_compare(MEMCACHED_SUCCESS, + memcached_stat_execute(memc, "items", stat_printer, NULL)); - rc= memcached_stat_execute(memc, "sizes", stat_printer, NULL); - test_compare(MEMCACHED_SUCCESS, rc); + test_compare(MEMCACHED_SUCCESS, + memcached_stat_execute(memc, "sizes", stat_printer, NULL)); return TEST_SUCCESS; } @@ -5125,7 +5132,7 @@ static test_return_t wrong_failure_counter_test(memcached_st *memc) rc= memcached_set(memc, key, strlen(key), value, strlen(value), (time_t)0, (uint32_t)0); - test_true(rc == MEMCACHED_SUCCESS || rc == MEMCACHED_BUFFERED); + test_true(rc == MEMCACHED_SUCCESS or rc == MEMCACHED_BUFFERED); instance= memcached_server_instance_by_position(memc, 0); @@ -5155,53 +5162,45 @@ static test_return_t wrong_failure_counter_test(memcached_st *memc) */ static test_return_t wrong_failure_counter_two_test(memcached_st *memc) { - memcached_return rc; - - memcached_st *memc_clone; - memc_clone= memcached_clone(NULL, memc); - test_true(memc_clone); - /* Set value to force connection to the server */ const char *key= "marmotte"; const char *value= "milka"; - char *string = NULL; - size_t string_length; - uint32_t flags; - rc= memcached_set(memc_clone, key, strlen(key), - value, strlen(value), - (time_t)0, (uint32_t)0); - test_true_got(rc == MEMCACHED_SUCCESS || rc == MEMCACHED_BUFFERED, memcached_strerror(NULL, rc)); + test_compare_hint(MEMCACHED_SUCCESS, + memcached_set(memc, key, strlen(key), + value, strlen(value), + (time_t)0, (uint32_t)0), + memcached_last_error_message(memc)); /* put failure limit to 1 */ test_compare(MEMCACHED_SUCCESS, - memcached_behavior_set(memc_clone, MEMCACHED_BEHAVIOR_SERVER_FAILURE_LIMIT, 1)); + memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_SERVER_FAILURE_LIMIT, true)); /* Put a retry timeout to effectively activate failure_limit effect */ test_compare(MEMCACHED_SUCCESS, - memcached_behavior_set(memc_clone, MEMCACHED_BEHAVIOR_RETRY_TIMEOUT, 1)); + memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_RETRY_TIMEOUT, true)); /* change behavior that triggers memcached_quit()*/ test_compare(MEMCACHED_SUCCESS, - memcached_behavior_set(memc_clone, MEMCACHED_BEHAVIOR_TCP_NODELAY, 1)); + memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_TCP_NODELAY, true)); /* Check if we still are connected */ - string= memcached_get(memc_clone, key, strlen(key), - &string_length, &flags, &rc); + uint32_t flags; + size_t string_length; + memcached_return rc; + char *string= memcached_get(memc, key, strlen(key), + &string_length, &flags, &rc); test_compare_got(MEMCACHED_SUCCESS, rc, memcached_strerror(NULL, rc)); test_true(string); free(string); - memcached_free(memc_clone); return TEST_SUCCESS; } - - /* * Test that ensures mget_execute does not end into recursive calls that finally fails */ @@ -5440,7 +5439,7 @@ static test_return_t regression_bug_490520(memcached_st *memc) test_true(keys[x]); memcached_return rc= memcached_set(memc, keys[x], key_length[x], blob, sizeof(blob), 0, 0); - test_true(rc == MEMCACHED_SUCCESS or rc == MEMCACHED_BUFFERED); + test_true_got(rc == MEMCACHED_SUCCESS or rc == MEMCACHED_BUFFERED, memcached_last_error_message(memc)); } for (uint32_t x= 0; x < regression_bug_490520_COUNT; ++x) @@ -5597,10 +5596,9 @@ test_st tests[] ={ {"connection_test", false, (test_callback_fn*)connection_test}, {"callback_test", false, (test_callback_fn*)callback_test}, {"userdata_test", false, (test_callback_fn*)userdata_test}, - {"set", false, (test_callback_fn*)set_test }, - {"set2", false, (test_callback_fn*)set_test2 }, - {"set3", false, (test_callback_fn*)set_test3 }, - {"dump", true, (test_callback_fn*)dump_test}, + {"memcached_set()", false, (test_callback_fn*)set_test }, + {"memcached_set() 2", false, (test_callback_fn*)set_test2 }, + {"memcached_set() 3", false, (test_callback_fn*)set_test3 }, {"add", true, (test_callback_fn*)add_test }, {"memcached_fetch_result(MEMCACHED_NOTFOUND)", true, (test_callback_fn*)memcached_fetch_result_NOT_FOUND }, {"replace", true, (test_callback_fn*)replace_test }, @@ -5653,6 +5651,10 @@ test_st tests[] ={ {"memcached_exist_by_key(MEMCACHED_SUCCESS)", true, (test_callback_fn*)memcached_exist_by_key_SUCCESS }, {"memcached_touch", 0, (test_callback_fn*)test_memcached_touch}, {"memcached_touch_with_prefix", 0, (test_callback_fn*)test_memcached_touch_by_key}, +#if 0 + {"memcached_dump() no data", true, (test_callback_fn*)memcached_dump_TEST }, +#endif + {"memcached_dump() with data", true, (test_callback_fn*)memcached_dump_TEST2 }, {0, 0, 0} }; @@ -5662,6 +5664,12 @@ test_st touch_tests[] ={ {0, 0, 0} }; +test_st memcached_stat_tests[] ={ + {"memcached_stat() INVALID ARG", 0, (test_callback_fn*)memcached_stat_TEST}, + {"memcached_stat()", 0, (test_callback_fn*)memcached_stat_TEST2}, + {0, 0, 0} +}; + test_st behavior_tests[] ={ {"libmemcached_string_behavior()", false, (test_callback_fn*)libmemcached_string_behavior_test}, {"libmemcached_string_distribution()", false, (test_callback_fn*)libmemcached_string_distribution_test}, @@ -5998,6 +6006,8 @@ collection_st collection[] ={ {"virtual buckets", 0, 0, virtual_bucket_tests}, {"memcached_server_get_last_disconnect", 0, 0, memcached_server_get_last_disconnect_tests}, {"touch", 0, 0, touch_tests}, + {"touch", (test_callback_fn*)pre_binary, 0, touch_tests}, + {"memcached_stat()", 0, 0, memcached_stat_tests}, {0, 0, 0, 0} };