X-Git-Url: https://git.m6w6.name/?a=blobdiff_plain;f=tests%2Fmem_functions.cc;h=cca23464e01ac16d9b63aa21e2c5cdef6ca3395d;hb=a60c98bb02391f995a03c3db5898e146ff2f6f3b;hp=835fc0c71b7fd3abc37b518294e7d16d3bc1509b;hpb=45fc4ad7cbf8d981f800eca27f24c8f758e92df1;p=awesomized%2Flibmemcached diff --git a/tests/mem_functions.cc b/tests/mem_functions.cc index 835fc0c7..cca23464 100644 --- a/tests/mem_functions.cc +++ b/tests/mem_functions.cc @@ -42,12 +42,17 @@ Test cases */ -#define BUILDING_LIBMEMCACHED -// !NEVER use common.h, always use memcached.h in your own apps -#include +#include +#include +#include + +#include #include +#include #include +#include +#include #include #include #include @@ -64,24 +69,24 @@ #define SMALL_STRING_LEN 1024 #include + +#include "tests/basic.h" +#include "tests/debug.h" #include "tests/deprecated.h" +#include "tests/error_conditions.h" +#include "tests/exist.h" +#include "tests/ketama.h" +#include "tests/namespace.h" #include "tests/parser.h" #include "tests/pool.h" -#include "tests/namespace.h" -#include "tests/string.h" -#include "tests/replication.h" -#include "tests/debug.h" -#include "tests/basic.h" -#include "tests/error_conditions.h" #include "tests/print.h" +#include "tests/replication.h" +#include "tests/server_add.h" #include "tests/virtual_buckets.h" using namespace libtest; -#ifdef HAVE_LIBMEMCACHEDUTIL -#include -#include "libmemcached/memcached_util.h" -#endif +#include #include "hash_results.h" @@ -419,7 +424,7 @@ static test_return_t libmemcached_string_distribution_test(memcached_st *) return TEST_SUCCESS; } -static test_return_t error_test(memcached_st *memc) +static test_return_t memcached_return_t_TEST(memcached_st *memc) { uint32_t values[] = { 851992627U, 2337886783U, 4109241422U, 4001849190U, 982370485U, 1263635348U, 4242906218U, 3829656100U, @@ -432,7 +437,8 @@ static test_return_t error_test(memcached_st *memc) 54481931U, 4186304426U, 1741088401U, 2979625118U, 4159057246U, 3425930182U, 2593724503U, 1868899624U, 1769812374U, 2302537950U, 1110330676U, 3365377466U, - 1336171666U, 3021258493U, 2334992265U, 3365377466U }; + 1336171666U, 3021258493U, 2334992265U, 3861994737U, + 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) @@ -443,12 +449,12 @@ static test_return_t error_test(memcached_st *memc) MEMCACHED_HASH_JENKINS); if (values[rc] != hash_val) { - fprintf(stderr, "\n\nYou have updated memcached_return_t without updating the error_test\n"); + fprintf(stderr, "\n\nYou have updated memcached_return_t without updating the memcached_return_t_TEST\n"); fprintf(stderr, "%u, %s, (%u)\n\n", (uint32_t)rc, memcached_strerror(memc, memcached_return_t(rc)), hash_val); } test_compare(values[rc], hash_val); } - test_compare(47, int(MEMCACHED_MAXIMUM_RETURN)); + test_compare(48, int(MEMCACHED_MAXIMUM_RETURN)); return TEST_SUCCESS; } @@ -567,9 +573,11 @@ static test_return_t cas2_test(memcached_st *memc) test_compare(MEMCACHED_SUCCESS, rc); } - rc= memcached_mget(memc, keys, key_length, 3); + test_compare(MEMCACHED_SUCCESS, + memcached_mget(memc, keys, key_length, 3)); results= memcached_result_create(memc, &results_obj); + test_true(results); results= memcached_fetch_result(memc, &results_obj, &rc); test_true(results); @@ -612,9 +620,11 @@ static test_return_t cas_test(memcached_st *memc) (time_t)0, (uint32_t)0); test_compare(MEMCACHED_SUCCESS, rc); - rc= memcached_mget(memc, keys, keylengths, 1); + test_compare(MEMCACHED_SUCCESS, + memcached_mget(memc, keys, keylengths, 1)); results= memcached_result_create(memc, &results_obj); + test_true(results); results= memcached_fetch_result(memc, &results_obj, &rc); test_true(results); @@ -813,17 +823,14 @@ static test_return_t bad_key_test(memcached_st *memc) { memcached_return_t rc; const char *key= "foo bad"; - char *string; - size_t string_length; uint32_t flags; memcached_st *memc_clone; - unsigned int set= 1; - size_t max_keylen= 0xffff; - // Just skip if we are in binary mode. uint64_t query_id= memcached_query_id(memc); - if (memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL)) - return TEST_SKIPPED; + + // Just skip if we are in binary mode. + test_skip(false, memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL)); + 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); @@ -831,37 +838,42 @@ static test_return_t bad_key_test(memcached_st *memc) query_id= memcached_query_id(memc_clone); test_compare(MEMCACHED_SUCCESS, - memcached_behavior_set(memc_clone, MEMCACHED_BEHAVIOR_VERIFY_KEY, set)); + memcached_behavior_set(memc_clone, MEMCACHED_BEHAVIOR_VERIFY_KEY, true)); 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)) { - query_id= memcached_query_id(memc_clone); - string= memcached_get(memc_clone, key, strlen(key), - &string_length, &flags, &rc); - test_compare(MEMCACHED_BAD_KEY_PROVIDED, rc); - test_zero(string_length); - test_false(string); + uint64_t before_query_id= memcached_query_id(memc_clone); + { + size_t string_length; + char *string= memcached_get(memc_clone, key, strlen(key), + &string_length, &flags, &rc); + test_compare(MEMCACHED_BAD_KEY_PROVIDED, rc); + test_zero(string_length); + test_false(string); + } + test_compare(before_query_id +1, memcached_query_id(memc_clone)); - set= 0; query_id= memcached_query_id(memc_clone); test_compare(MEMCACHED_SUCCESS, - memcached_behavior_set(memc_clone, MEMCACHED_BEHAVIOR_VERIFY_KEY, set)); + memcached_behavior_set(memc_clone, MEMCACHED_BEHAVIOR_VERIFY_KEY, false)); test_compare(query_id, memcached_query_id(memc_clone)); // We should not increase the query_id for memcached_behavior_set() - string= memcached_get(memc_clone, key, strlen(key), - &string_length, &flags, &rc); - test_compare_got(MEMCACHED_NOTFOUND, rc, memcached_strerror(NULL, rc)); - test_zero(string_length); - test_false(string); + { + size_t string_length; + char *string= memcached_get(memc_clone, key, strlen(key), + &string_length, &flags, &rc); + test_compare_got(MEMCACHED_NOTFOUND, rc, memcached_strerror(NULL, rc)); + test_zero(string_length); + test_false(string); + } /* Test multi key for bad keys */ const char *keys[] = { "GoodKey", "Bad Key", "NotMine" }; size_t key_lengths[] = { 7, 7, 7 }; - set= 1; query_id= memcached_query_id(memc_clone); test_compare(MEMCACHED_SUCCESS, - memcached_behavior_set(memc_clone, MEMCACHED_BEHAVIOR_VERIFY_KEY, set)); + memcached_behavior_set(memc_clone, MEMCACHED_BEHAVIOR_VERIFY_KEY, true)); test_compare(query_id, memcached_query_id(memc_clone)); query_id= memcached_query_id(memc_clone); @@ -874,8 +886,6 @@ static test_return_t bad_key_test(memcached_st *memc) memcached_mget_by_key(memc_clone, "foo daddy", 9, keys, key_lengths, 1)); test_compare(query_id +1, memcached_query_id(memc_clone)); - max_keylen= 250; - /* The following test should be moved to the end of this function when the memcached server is updated to allow max size length of the keys in the binary protocol @@ -883,35 +893,33 @@ static test_return_t bad_key_test(memcached_st *memc) test_compare(MEMCACHED_SUCCESS, memcached_callback_set(memc_clone, MEMCACHED_CALLBACK_NAMESPACE, NULL)); - char *longkey= (char *)malloc(max_keylen + 1); - if (longkey) + std::vector longkey; + longkey.insert(longkey.end(), MEMCACHED_MAX_KEY, 'a'); + test_compare(longkey.size(), size_t(MEMCACHED_MAX_KEY)); { - memset(longkey, 'a', max_keylen + 1); - string= memcached_get(memc_clone, longkey, max_keylen, - &string_length, &flags, &rc); + size_t string_length; + // We subtract 1 + test_null(memcached_get(memc_clone, &longkey[0], longkey.size() -1, &string_length, &flags, &rc)); test_compare(MEMCACHED_NOTFOUND, rc); test_zero(string_length); - test_false(string); - string= memcached_get(memc_clone, longkey, max_keylen + 1, - &string_length, &flags, &rc); + test_null(memcached_get(memc_clone, &longkey[0], longkey.size(), &string_length, &flags, &rc)); test_compare(MEMCACHED_BAD_KEY_PROVIDED, rc); test_zero(string_length); - test_false(string); - - free(longkey); } } /* Make sure zero length keys are marked as bad */ - set= 1; - test_compare(MEMCACHED_SUCCESS, - memcached_behavior_set(memc_clone, MEMCACHED_BEHAVIOR_VERIFY_KEY, set)); - string= memcached_get(memc_clone, key, 0, - &string_length, &flags, &rc); - test_compare(MEMCACHED_BAD_KEY_PROVIDED, rc); - test_zero(string_length); - test_false(string); + { + test_compare(MEMCACHED_SUCCESS, + memcached_behavior_set(memc_clone, MEMCACHED_BEHAVIOR_VERIFY_KEY, true)); + size_t string_length; + char *string= memcached_get(memc_clone, key, 0, + &string_length, &flags, &rc); + test_compare(MEMCACHED_BAD_KEY_PROVIDED, rc); + test_zero(string_length); + test_false(string); + } memcached_free(memc_clone); @@ -986,12 +994,11 @@ static memcached_return_t delete_trigger(memcached_st *, static test_return_t delete_through(memcached_st *memc) { memcached_trigger_delete_key_fn callback; - memcached_return_t rc; callback= (memcached_trigger_delete_key_fn)delete_trigger; - rc= memcached_callback_set(memc, MEMCACHED_CALLBACK_DELETE_TRIGGER, *(void**)&callback); - test_compare(MEMCACHED_SUCCESS, rc); + test_compare(MEMCACHED_SUCCESS, + memcached_callback_set(memc, MEMCACHED_CALLBACK_DELETE_TRIGGER, *(void**)&callback)); return TEST_SUCCESS; } @@ -1091,7 +1098,7 @@ static test_return_t set_test3(memcached_st *memc) memcached_return_t rc= memcached_set(memc, key, strlen(key), value, value_length, (time_t)0, (uint32_t)0); - test_true(rc == MEMCACHED_SUCCESS || rc == MEMCACHED_BUFFERED); + test_true_got(rc == MEMCACHED_SUCCESS or rc == MEMCACHED_BUFFERED, memcached_strerror(NULL, rc)); test_compare(query_id +1, memcached_query_id(memc)); } @@ -1260,6 +1267,7 @@ static test_return_t mget_end(memcached_st *memc) // this should indicate end string= memcached_fetch(memc, key, &key_length, &string_length, &flags, &rc); test_compare(MEMCACHED_END, rc); + test_null(string); // now get just one rc= memcached_mget(memc, keys, lengths, 1); @@ -1275,7 +1283,8 @@ static test_return_t mget_end(memcached_st *memc) // this should indicate end string= memcached_fetch(memc, key, &key_length, &string_length, &flags, &rc); - test_true(rc == MEMCACHED_END); + test_compare(MEMCACHED_END, rc); + test_null(string); return TEST_SUCCESS; } @@ -1287,10 +1296,11 @@ static test_return_t stats_servername_test(memcached_st *memc) memcached_server_instance_st instance= memcached_server_instance_by_position(memc, 0); -#ifdef LIBMEMCACHED_WITH_SASL_SUPPORT - if (memcached_get_sasl_callbacks(memc) != NULL) + if (LIBMEMCACHED_WITH_SASL_SUPPORT and memcached_get_sasl_callbacks(memc)) + { return TEST_SKIPPED; -#endif + } + test_compare(MEMCACHED_SUCCESS, memcached_stat_servername(&memc_stat, NULL, memcached_server_name(instance), memcached_server_port(instance))); @@ -1493,6 +1503,35 @@ 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) +{ + memcached_st *memc= memcached_clone(NULL, orig_memc); + + test_skip(TEST_SUCCESS, pre_binary(memc)); + + 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); + + uint64_t new_number; + test_compare(MEMCACHED_SUCCESS, memcached_increment(memc, + test_literal_param("number"), + 1, &new_number)); + test_compare(uint64_t(1), new_number); + + test_compare(MEMCACHED_SUCCESS, memcached_increment(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) { @@ -1503,7 +1542,7 @@ static test_return_t quit_test(memcached_st *memc) rc= memcached_set(memc, key, strlen(key), value, strlen(value), (time_t)10, (uint32_t)3); - test_true(rc == MEMCACHED_SUCCESS or rc == MEMCACHED_BUFFERED); + test_true_got(rc == MEMCACHED_SUCCESS or rc == MEMCACHED_BUFFERED, memcached_strerror(NULL, rc)); memcached_quit(memc); rc= memcached_set(memc, key, strlen(key), @@ -1548,7 +1587,7 @@ static test_return_t mget_result_test(memcached_st *memc) 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_true_got(rc == MEMCACHED_SUCCESS or rc == MEMCACHED_BUFFERED, memcached_strerror(NULL, rc)); } test_compare(MEMCACHED_SUCCESS, @@ -1597,7 +1636,7 @@ static test_return_t mget_result_alloc_test(memcached_st *memc) 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_true_got(rc == MEMCACHED_SUCCESS or rc == MEMCACHED_BUFFERED, memcached_strerror(NULL, rc)); } test_compare(MEMCACHED_SUCCESS, @@ -1694,7 +1733,7 @@ static test_return_t mget_test(memcached_st *memc) 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_true_got(rc == MEMCACHED_SUCCESS or rc == MEMCACHED_BUFFERED, memcached_strerror(NULL, rc)); } test_compare(MEMCACHED_SUCCESS, memcached_mget(memc, keys, key_length, 3)); @@ -1750,7 +1789,7 @@ static test_return_t mget_execute(memcached_st *memc) test_true(keys[x] != NULL); uint64_t query_id= memcached_query_id(memc); rc= memcached_add(memc, keys[x], key_length[x], blob, sizeof(blob), 0, 0); - test_true(rc == MEMCACHED_SUCCESS || rc == MEMCACHED_BUFFERED); + test_true_got(rc == MEMCACHED_SUCCESS or rc == MEMCACHED_BUFFERED, memcached_strerror(NULL, rc)); test_compare(query_id +1, memcached_query_id(memc)); } @@ -2582,16 +2621,13 @@ static test_return_t user_supplied_bug9(memcached_st *memc) /* We are testing with aggressive timeout to get failures */ static test_return_t user_supplied_bug10(memcached_st *memc) { - const char *key= "foo"; size_t value_length= 512; - size_t key_len= 3; unsigned int set= 1; memcached_st *mclone= memcached_clone(NULL, memc); memcached_behavior_set(mclone, MEMCACHED_BEHAVIOR_NO_BLOCK, set); memcached_behavior_set(mclone, MEMCACHED_BEHAVIOR_TCP_NODELAY, set); - int32_t timeout= 0; - memcached_behavior_set(mclone, MEMCACHED_BEHAVIOR_POLL_TIMEOUT, (uint64_t)timeout); + memcached_behavior_set(mclone, MEMCACHED_BEHAVIOR_POLL_TIMEOUT, uint64_t(0)); char *value= (char*)malloc(value_length * sizeof(char)); @@ -2602,9 +2638,12 @@ static test_return_t user_supplied_bug10(memcached_st *memc) for (unsigned int x= 1; x <= 100000; ++x) { - memcached_return_t rc= memcached_set(mclone, key, key_len,value, value_length, 0, 0); + memcached_return_t rc= memcached_set(mclone, + test_literal_param("foo"), + value, value_length, 0, 0); - test_true_got(rc == MEMCACHED_SUCCESS or rc == MEMCACHED_WRITE_FAILURE or rc == MEMCACHED_BUFFERED or rc == MEMCACHED_TIMEOUT or rc == MEMCACHED_CONNECTION_FAILURE, + test_true_got((rc == MEMCACHED_SUCCESS or rc == MEMCACHED_WRITE_FAILURE or rc == MEMCACHED_BUFFERED or rc == MEMCACHED_TIMEOUT or rc == MEMCACHED_CONNECTION_FAILURE + or rc == MEMCACHED_SERVER_TEMPORARILY_DISABLED), memcached_strerror(NULL, rc)); if (rc == MEMCACHED_WRITE_FAILURE or rc == MEMCACHED_TIMEOUT) @@ -2747,43 +2786,33 @@ static test_return_t user_supplied_bug13(memcached_st *memc) */ static test_return_t user_supplied_bug14(memcached_st *memc) { - size_t setter= 1; - memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_TCP_NODELAY, setter); - memcached_return_t rc; - const char *key= "foo"; - char *value; - size_t value_length= 18000; - char *string; - size_t string_length; - uint32_t flags; - unsigned int x; - size_t current_length; - - value = (char*)malloc(value_length); - test_true(value); + memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_TCP_NODELAY, true); - for (x= 0; x < value_length; x++) - value[x] = (char) (x % 127); + std::vector value; + for (size_t x= 0; x < 18000; x++) + { + value.push_back((char) (x % 127)); + } - for (current_length= 0; current_length < value_length; current_length++) + for (size_t current_length= 0; current_length < value.size(); current_length++) { - rc= memcached_set(memc, key, strlen(key), - value, current_length, - (time_t)0, (uint32_t)0); - test_true(rc == MEMCACHED_SUCCESS || rc == MEMCACHED_BUFFERED); + memcached_return_t rc= memcached_set(memc, test_literal_param("foo"), + &value[0], current_length, + (time_t)0, (uint32_t)0); + test_true(rc == MEMCACHED_SUCCESS or rc == MEMCACHED_BUFFERED); - string= memcached_get(memc, key, strlen(key), - &string_length, &flags, &rc); + size_t string_length; + uint32_t flags; + char *string= memcached_get(memc, test_literal_param("foo"), + &string_length, &flags, &rc); test_compare(MEMCACHED_SUCCESS, rc); - test_true(string_length == current_length); - test_memcmp(string, value, string_length); + test_compare(string_length, current_length); + test_memcmp(string, &value[0], string_length); free(string); } - free(value); - return TEST_SUCCESS; } @@ -2792,35 +2821,31 @@ static test_return_t user_supplied_bug14(memcached_st *memc) */ static test_return_t user_supplied_bug15(memcached_st *memc) { - uint32_t x; - memcached_return_t rc; - const char *key= "mykey"; - size_t length; - uint32_t flags; - - for (x= 0; x < 2; x++) + for (uint32_t x= 0; x < 2; x++) { - rc= memcached_set(memc, key, strlen(key), - NULL, 0, - (time_t)0, (uint32_t)0); + memcached_return_t rc= memcached_set(memc, test_literal_param("mykey"), + NULL, 0, + (time_t)0, (uint32_t)0); test_compare(MEMCACHED_SUCCESS, rc); - char *value= memcached_get(memc, key, strlen(key), + size_t length; + uint32_t flags; + char *value= memcached_get(memc, test_literal_param("mykey"), &length, &flags, &rc); test_compare(MEMCACHED_SUCCESS, rc); test_false(value); - test_false(length); - test_false(flags); + test_zero(length); + test_zero(flags); - value= memcached_get(memc, key, strlen(key), + value= memcached_get(memc, test_literal_param("mykey"), &length, &flags, &rc); test_compare(MEMCACHED_SUCCESS, rc); test_true(value == NULL); - test_true(length == 0); - test_true(flags == 0); + test_zero(length); + test_zero(flags); } return TEST_SUCCESS; @@ -2829,25 +2854,21 @@ 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; - const char *key= "mykey"; - char *value; - size_t length; - uint32_t flags; - - rc= memcached_set(memc, key, strlen(key), - NULL, 0, - (time_t)0, UINT32_MAX); + memcached_return_t rc= memcached_set(memc, test_literal_param("mykey"), + NULL, 0, + (time_t)0, UINT32_MAX); test_compare(MEMCACHED_SUCCESS, rc); - value= memcached_get(memc, key, strlen(key), + size_t length; + uint32_t flags; + char *value= memcached_get(memc, test_literal_param("mykey"), &length, &flags, &rc); test_compare(MEMCACHED_SUCCESS, rc); test_true(value == NULL); - test_true(length == 0); - test_true(flags == UINT32_MAX); + test_zero(length); + test_compare(flags, UINT32_MAX); return TEST_SUCCESS; } @@ -2856,21 +2877,18 @@ static test_return_t user_supplied_bug16(memcached_st *memc) /* Check the validity of chinese key*/ static test_return_t user_supplied_bug17(memcached_st *memc) { - memcached_return_t rc; const char *key= "豆瓣"; const char *value="我们在炎热抑郁的夏天无法停止豆瓣"; - char *value2; - size_t length; - uint32_t flags; - - rc= memcached_set(memc, key, strlen(key), - value, strlen(value), - (time_t)0, 0); + memcached_return_t rc= memcached_set(memc, key, strlen(key), + value, strlen(value), + (time_t)0, 0); test_compare(MEMCACHED_SUCCESS, rc); - value2= memcached_get(memc, key, strlen(key), - &length, &flags, &rc); + size_t length; + uint32_t flags; + char *value2= memcached_get(memc, key, strlen(key), + &length, &flags, &rc); test_true(length==strlen(value)); test_compare(MEMCACHED_SUCCESS, rc); @@ -2902,98 +2920,36 @@ static test_return_t user_supplied_bug19(memcached_st *) /* CAS test from Andei */ static test_return_t user_supplied_bug20(memcached_st *memc) { - memcached_return_t status; - memcached_result_st *result, result_obj; - const char *key = "abc"; - size_t key_len = strlen("abc"); - const char *value = "foobar"; - size_t value_len = strlen(value); + const char *key= "abc"; + size_t key_len= strlen("abc"); - memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_SUPPORT_CAS, 1); + test_skip(MEMCACHED_SUCCESS, memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_SUPPORT_CAS, true)); - status = memcached_set(memc, key, key_len, value, value_len, (time_t)0, (uint32_t)0); - test_true(status == MEMCACHED_SUCCESS); + test_compare(MEMCACHED_SUCCESS, + memcached_set(memc, + test_literal_param("abc"), + test_literal_param("foobar"), + (time_t)0, (uint32_t)0)); - status = memcached_mget(memc, &key, &key_len, 1); - test_true(status == MEMCACHED_SUCCESS); + test_compare(MEMCACHED_SUCCESS, + memcached_mget(memc, &key, &key_len, 1)); - result= memcached_result_create(memc, &result_obj); + memcached_result_st result_obj; + memcached_result_st *result= memcached_result_create(memc, &result_obj); test_true(result); memcached_result_create(memc, &result_obj); + memcached_return_t status; result= memcached_fetch_result(memc, &result_obj, &status); test_true(result); - test_true(status == MEMCACHED_SUCCESS); + test_compare(MEMCACHED_SUCCESS, status); memcached_result_free(result); return TEST_SUCCESS; } -#include "ketama_test_cases.h" -static test_return_t user_supplied_bug18(memcached_st *trash) -{ - memcached_return_t rc; - uint64_t value; - int x; - memcached_st *memc; - - (void)trash; - - memc= memcached_create(NULL); - test_true(memc); - - rc= memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_KETAMA_WEIGHTED, 1); - test_compare(MEMCACHED_SUCCESS, rc); - - value= memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_KETAMA_WEIGHTED); - test_true(value == 1); - - rc= memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_KETAMA_HASH, MEMCACHED_HASH_MD5); - test_compare(MEMCACHED_SUCCESS, rc); - - value= memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_KETAMA_HASH); - test_true(value == MEMCACHED_HASH_MD5); - - memcached_server_st *server_pool= memcached_servers_parse("10.0.1.1:11211 600,10.0.1.2:11211 300,10.0.1.3:11211 200,10.0.1.4:11211 350,10.0.1.5:11211 1000,10.0.1.6:11211 800,10.0.1.7:11211 950,10.0.1.8:11211 100"); - memcached_server_push(memc, server_pool); - - /* verify that the server list was parsed okay. */ - test_true(memcached_server_count(memc) == 8); - test_strcmp(server_pool[0].hostname, "10.0.1.1"); - test_true(server_pool[0].port == 11211); - test_true(server_pool[0].weight == 600); - test_strcmp(server_pool[2].hostname, "10.0.1.3"); - test_true(server_pool[2].port == 11211); - test_true(server_pool[2].weight == 200); - test_strcmp(server_pool[7].hostname, "10.0.1.8"); - test_true(server_pool[7].port == 11211); - test_true(server_pool[7].weight == 100); - - /* VDEAAAAA hashes to fffcd1b5, after the last continuum point, and lets - * us test the boundary wraparound. - */ - test_true(memcached_generate_hash(memc, (char *)"VDEAAAAA", 8) == memc->ketama.continuum[0].index); - - /* verify the standard ketama set. */ - for (x= 0; x < 99; x++) - { - uint32_t server_idx = memcached_generate_hash(memc, ketama_test_cases[x].key, strlen(ketama_test_cases[x].key)); - - memcached_server_instance_st instance= - memcached_server_instance_by_position(memc, server_idx); - - const char *hostname = memcached_server_name(instance); - test_strcmp(hostname, ketama_test_cases[x].server); - } - - memcached_server_list_free(server_pool); - memcached_free(memc); - - return TEST_SUCCESS; -} - /* Large mget() of missing keys with binary proto * * If many binary quiet commands (such as getq's in an mget) fill the output @@ -3021,7 +2977,7 @@ static test_return_t _user_supplied_bug21(memcached_st* memc, size_t key_count) test_true(memc_clone); /* only binproto uses getq for mget */ - test_compare(MEMCACHED_SUCCESS, memcached_behavior_set(memc_clone, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL, 1)); + test_compare(MEMCACHED_SUCCESS, memcached_behavior_set(memc_clone, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL, true)); /* empty the cache to ensure misses (hence non-responses) */ test_compare(MEMCACHED_SUCCESS, memcached_flush(memc_clone, 0)); @@ -3085,7 +3041,9 @@ static test_return_t user_supplied_bug21(memcached_st *memc) test_rc= pre_binary(memc); if (test_rc != TEST_SUCCESS) + { return test_rc; + } /* should work as of r580 */ test_compare(TEST_SUCCESS, @@ -3098,102 +3056,20 @@ static test_return_t user_supplied_bug21(memcached_st *memc) return TEST_SUCCESS; } -static test_return_t auto_eject_hosts(memcached_st *trash) -{ - (void) trash; - memcached_server_instance_st instance; - - memcached_return_t rc; - memcached_st *memc= memcached_create(NULL); - test_true(memc); - - rc= memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_KETAMA_WEIGHTED, 1); - test_compare(MEMCACHED_SUCCESS, rc); - - uint64_t value= memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_KETAMA_WEIGHTED); - test_true(value == 1); - - rc= memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_KETAMA_HASH, MEMCACHED_HASH_MD5); - test_compare(MEMCACHED_SUCCESS, rc); - - value= memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_KETAMA_HASH); - test_true(value == MEMCACHED_HASH_MD5); - - /* server should be removed when in delay */ - rc= memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_AUTO_EJECT_HOSTS, 1); - test_compare(MEMCACHED_SUCCESS, rc); - - value= memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_AUTO_EJECT_HOSTS); - test_true(value == 1); - - memcached_server_st *server_pool; - server_pool = memcached_servers_parse("10.0.1.1:11211 600,10.0.1.2:11211 300,10.0.1.3:11211 200,10.0.1.4:11211 350,10.0.1.5:11211 1000,10.0.1.6:11211 800,10.0.1.7:11211 950,10.0.1.8:11211 100"); - memcached_server_push(memc, server_pool); - - /* verify that the server list was parsed okay. */ - test_true(memcached_server_count(memc) == 8); - test_strcmp(server_pool[0].hostname, "10.0.1.1"); - test_true(server_pool[0].port == 11211); - test_true(server_pool[0].weight == 600); - test_strcmp(server_pool[2].hostname, "10.0.1.3"); - test_true(server_pool[2].port == 11211); - test_true(server_pool[2].weight == 200); - test_strcmp(server_pool[7].hostname, "10.0.1.8"); - test_true(server_pool[7].port == 11211); - test_true(server_pool[7].weight == 100); - - instance= memcached_server_instance_by_position(memc, 2); - ((memcached_server_write_instance_st)instance)->next_retry = time(NULL) + 15; - memc->ketama.next_distribution_rebuild= time(NULL) - 1; - - /* - This would not work if there were only two hosts. - */ - for (size_t x= 0; x < 99; x++) - { - memcached_autoeject(memc); - uint32_t server_idx= memcached_generate_hash(memc, ketama_test_cases[x].key, strlen(ketama_test_cases[x].key)); - test_true(server_idx != 2); - } - - /* and re-added when it's back. */ - ((memcached_server_write_instance_st)instance)->next_retry = time(NULL) - 1; - memc->ketama.next_distribution_rebuild= time(NULL) - 1; - memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_DISTRIBUTION, - memc->distribution); - for (size_t x= 0; x < 99; x++) - { - uint32_t server_idx = memcached_generate_hash(memc, ketama_test_cases[x].key, strlen(ketama_test_cases[x].key)); - // We re-use instance from above. - instance= - memcached_server_instance_by_position(memc, server_idx); - const char *hostname = memcached_server_name(instance); - test_strcmp(hostname, ketama_test_cases[x].server); - } - - memcached_server_list_free(server_pool); - memcached_free(memc); - - return TEST_SUCCESS; -} - -static test_return_t output_ketama_weighted_keys(memcached_st *trash) +static test_return_t output_ketama_weighted_keys(memcached_st *) { - (void) trash; - - memcached_return_t rc; memcached_st *memc= memcached_create(NULL); test_true(memc); - rc= memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_KETAMA_WEIGHTED, 1); - test_compare(MEMCACHED_SUCCESS, rc); + test_compare(MEMCACHED_SUCCESS, + memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_KETAMA_WEIGHTED, true)); uint64_t value= memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_KETAMA_WEIGHTED); - test_true(value == 1); + test_compare(value, uint64_t(1)); - rc= memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_KETAMA_HASH, MEMCACHED_HASH_MD5); - test_compare(MEMCACHED_SUCCESS, rc); + test_compare(MEMCACHED_SUCCESS, + memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_KETAMA_HASH, MEMCACHED_HASH_MD5)); value= memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_KETAMA_HASH); test_true(value == MEMCACHED_HASH_MD5); @@ -3240,30 +3116,26 @@ static test_return_t output_ketama_weighted_keys(memcached_st *trash) static test_return_t result_static(memcached_st *memc) { memcached_result_st result; - memcached_result_st *result_ptr; - - result_ptr= memcached_result_create(memc, &result); - test_true(result.options.is_allocated == false); - test_true(memcached_is_initialized(&result) == true); + memcached_result_st *result_ptr= memcached_result_create(memc, &result); + test_false(result.options.is_allocated); + test_true(memcached_is_initialized(&result)); test_true(result_ptr); test_true(result_ptr == &result); memcached_result_free(&result); - test_true(result.options.is_allocated == false); - test_true(memcached_is_initialized(&result) == false); + test_false(result.options.is_allocated); + test_false(memcached_is_initialized(&result)); return TEST_SUCCESS; } static test_return_t result_alloc(memcached_st *memc) { - memcached_result_st *result_ptr; - - result_ptr= memcached_result_create(memc, NULL); + memcached_result_st *result_ptr= memcached_result_create(memc, NULL); test_true(result_ptr); - test_true(result_ptr->options.is_allocated == true); - test_true(memcached_is_initialized(result_ptr) == true); + test_true(result_ptr->options.is_allocated); + test_true(memcached_is_initialized(result_ptr)); memcached_result_free(result_ptr); return TEST_SUCCESS; @@ -3277,9 +3149,8 @@ static test_return_t cleanup_pairs(memcached_st *memc) return TEST_SUCCESS; } -static test_return_t generate_pairs(memcached_st *memc) +static test_return_t generate_pairs(memcached_st *) { - (void)memc; global_pairs= pairs_generate(GLOBAL_COUNT, 400); global_count= GLOBAL_COUNT; @@ -3330,12 +3201,13 @@ static test_return_t generate_data_with_stats(memcached_st *memc) for (host_index= 0; host_index < SERVERS_TO_CREATE; host_index++) { /* This test was changes so that "make test" would work properlly */ -#ifdef DEBUG - memcached_server_instance_st instance= - memcached_server_instance_by_position(memc, host_index); + if (DEBUG) + { + memcached_server_instance_st instance= + memcached_server_instance_by_position(memc, host_index); - printf("\nserver %u|%s|%u bytes: %llu\n", host_index, instance->hostname, instance->port, (unsigned long long)(stat_p + host_index)->bytes); -#endif + printf("\nserver %u|%s|%u bytes: %llu\n", host_index, instance->hostname, instance->port, (unsigned long long)(stat_p + host_index)->bytes); + } test_true((unsigned long long)(stat_p + host_index)->bytes); } @@ -3345,10 +3217,7 @@ static test_return_t generate_data_with_stats(memcached_st *memc) } static test_return_t generate_buffer_data(memcached_st *memc) { - size_t latch= 0; - - latch= 1; - memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_BUFFER_REQUESTS, latch); + memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_BUFFER_REQUESTS, true); generate_data(memc); return TEST_SUCCESS; @@ -3423,7 +3292,7 @@ static test_return_t mget_read(memcached_st *memc) unsigned int keys_returned; test_compare(TEST_SUCCESS, fetch_all_results(memc, keys_returned, MEMCACHED_SUCCESS)); test_true(keys_returned > 0); - test_compare_got(global_count, keys_returned, "Possible false, positive, memcached may have ejected key/value based on memory needs"); + test_compare_warn_hint(global_count, keys_returned, "Possible false, positive, memcached may have ejected key/value based on memory needs"); } return TEST_SUCCESS; @@ -3441,6 +3310,7 @@ static test_return_t mget_read_result(memcached_st *memc) { memcached_result_st results_obj; memcached_result_st *results= memcached_result_create(memc, &results_obj); + test_true(results); memcached_return_t rc; while ((results= memcached_fetch_result(memc, &results_obj, &rc))) @@ -3511,6 +3381,8 @@ static test_return_t mget_read_partial_result(memcached_st *memc) { memcached_result_st results_obj; memcached_result_st *results= memcached_result_create(memc, &results_obj); + test_true(results); + test_false(memcached_is_allocated(results)); memcached_return_t rc; while ((results= memcached_fetch_result(memc, &results_obj, &rc))) @@ -3553,8 +3425,7 @@ static test_return_t delete_generate(memcached_st *memc) static test_return_t delete_buffer_generate(memcached_st *memc) { - uint64_t latch= 1; - memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_BUFFER_REQUESTS, latch); + memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_BUFFER_REQUESTS, true); for (size_t x= 0; x < global_count; x++) { @@ -3653,13 +3524,8 @@ static test_return_t pre_nonblock_binary(memcached_st *memc) static test_return_t pre_murmur(memcached_st *memc) { -#ifdef HAVE_MURMUR_HASH - memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_HASH, (uint64_t)MEMCACHED_HASH_MURMUR); + test_skip(MEMCACHED_SUCCESS, memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_HASH, (uint64_t)MEMCACHED_HASH_MURMUR)); return TEST_SUCCESS; -#else - (void) memc; - return TEST_SKIPPED; -#endif } static test_return_t pre_jenkins(memcached_st *memc) @@ -3686,25 +3552,20 @@ static test_return_t pre_crc(memcached_st *memc) static test_return_t pre_hsieh(memcached_st *memc) { -#ifdef HAVE_HSIEH_HASH - memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_HASH, (uint64_t)MEMCACHED_HASH_HSIEH); + test_skip(MEMCACHED_SUCCESS, memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_HASH, (uint64_t)MEMCACHED_HASH_HSIEH)); return TEST_SUCCESS; -#else - (void) memc; - return TEST_SKIPPED; -#endif } static test_return_t pre_hash_fnv1_64(memcached_st *memc) { - memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_HASH, (uint64_t)MEMCACHED_HASH_MURMUR); + test_skip(MEMCACHED_SUCCESS, memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_HASH, (uint64_t)MEMCACHED_HASH_MURMUR)); return TEST_SUCCESS; } static test_return_t pre_hash_fnv1a_64(memcached_st *memc) { - memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_HASH, (uint64_t)MEMCACHED_HASH_FNV1A_64); + test_skip(MEMCACHED_SUCCESS, memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_HASH, (uint64_t)MEMCACHED_HASH_FNV1A_64)); return TEST_SUCCESS; } @@ -3729,7 +3590,7 @@ static test_return_t pre_behavior_ketama(memcached_st *memc) test_compare(MEMCACHED_SUCCESS, rc); uint64_t value= memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_KETAMA); - test_true(value == 1); + test_compare(value, uint64_t(1)); return TEST_SUCCESS; } @@ -3740,13 +3601,13 @@ static test_return_t pre_behavior_ketama_weighted(memcached_st *memc) test_compare(MEMCACHED_SUCCESS, rc); uint64_t value= memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_KETAMA_WEIGHTED); - test_true(value == 1); + test_compare(value, uint64_t(1)); - rc= memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_KETAMA_HASH, MEMCACHED_HASH_MD5); - test_compare(MEMCACHED_SUCCESS, rc); + test_compare(MEMCACHED_SUCCESS, + memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_KETAMA_HASH, MEMCACHED_HASH_MD5)); value= memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_KETAMA_HASH); - test_true(value == MEMCACHED_HASH_MD5); + test_compare(MEMCACHED_HASH_MD5, memcached_hash_t(value)); return TEST_SUCCESS; } @@ -3768,32 +3629,6 @@ static test_return_t pre_binary(memcached_st *memc) return rc == MEMCACHED_SUCCESS ? TEST_SUCCESS : TEST_SKIPPED; } -static test_return_t pre_sasl(memcached_st *memc) -{ - memcached_return_t rc= MEMCACHED_FAILURE; - -#ifdef LIBMEMCACHED_WITH_SASL_SUPPORT - const char *server= getenv("LIBMEMCACHED_TEST_SASL_SERVER"); - const char *user= getenv("LIBMEMCACHED_TEST_SASL_USERNAME"); - const char *pass= getenv("LIBMEMCACHED_TEST_SASL_PASSWORD"); - - if (server and user and pass) - { - memcached_server_st *servers= memcached_servers_parse(server); - test_true(servers); - memcached_servers_reset(memc); - test_true(memcached_server_push(memc, servers) == MEMCACHED_SUCCESS); - memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL, 1); - rc= memcached_set_sasl_auth_data(memc, user, pass); - test_compare(MEMCACHED_SUCCESS, rc); - } -#else - (void)memc; -#endif - - return rc == MEMCACHED_SUCCESS ? TEST_SUCCESS : TEST_SKIPPED; -} - static test_return_t pre_replication(memcached_st *memc) { test_skip(TEST_SUCCESS, pre_binary(memc)); @@ -3897,6 +3732,7 @@ static test_return_t selection_of_namespace_tests(memcached_st *memc) /* Make sure be default none exists */ value= (char*)memcached_callback_get(memc, MEMCACHED_CALLBACK_NAMESPACE, &rc); + test_null(value); test_compare_got(MEMCACHED_FAILURE, rc, memcached_strerror(NULL, rc)); /* Test a clean set */ @@ -3968,6 +3804,7 @@ static test_return_t set_namespace(memcached_st *memc) /* Make sure be default none exists */ value= (char*)memcached_callback_get(memc, MEMCACHED_CALLBACK_NAMESPACE, &rc); + test_null(value); test_compare_got(MEMCACHED_FAILURE, rc, memcached_strerror(NULL, rc)); /* Test a clean set */ @@ -4041,7 +3878,7 @@ static test_return_t deprecated_set_memory_alloc(memcached_st *memc) static test_return_t set_memory_alloc(memcached_st *memc) { - test_compare(MEMCACHED_FAILURE, + test_compare(MEMCACHED_INVALID_ARGUMENTS, memcached_set_memory_allocators(memc, NULL, my_free, my_realloc, my_calloc, NULL)); @@ -4091,7 +3928,9 @@ static test_return_t enable_consistent_hsieh(memcached_st *memc) memcached_hash_t hash; memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_DISTRIBUTION, value); if ((rc= pre_hsieh(memc)) != TEST_SUCCESS) + { return rc; + } value= (memcached_server_distribution_t)memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_DISTRIBUTION); test_true(value == MEMCACHED_DISTRIBUTION_CONSISTENT); @@ -4166,13 +4005,12 @@ static test_return_t pre_settimer(memcached_st *memc) return TEST_SUCCESS; } -static test_return_t poll_timeout(memcached_st *memc) +static test_return_t MEMCACHED_BEHAVIOR_POLL_TIMEOUT_test(memcached_st *memc) { const uint64_t timeout= 100; // Not using, just checking that it sets memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_POLL_TIMEOUT, timeout); - test_compare(timeout, memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_POLL_TIMEOUT)); return TEST_SUCCESS; @@ -4180,18 +4018,18 @@ static test_return_t poll_timeout(memcached_st *memc) static test_return_t noreply_test(memcached_st *memc) { + test_compare(MEMCACHED_SUCCESS, + memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_NOREPLY, 1)); + test_compare(MEMCACHED_SUCCESS, + memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_BUFFER_REQUESTS, 1)); + test_compare(MEMCACHED_SUCCESS, + memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_SUPPORT_CAS, 1)); + 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)); + memcached_return_t ret; - ret= memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_NOREPLY, 1); - test_true(ret == MEMCACHED_SUCCESS); - ret= memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_BUFFER_REQUESTS, 1); - test_true(ret == MEMCACHED_SUCCESS); - ret= memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_SUPPORT_CAS, 1); - test_true(ret == MEMCACHED_SUCCESS); - test_true(memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_NOREPLY) == 1); - test_true(memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_BUFFER_REQUESTS) == 1); - test_true(memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_SUPPORT_CAS) == 1); - - for (int count=0; count < 5; ++count) + for (int count= 0; count < 5; ++count) { for (size_t x= 0; x < 100; ++x) { @@ -4222,7 +4060,7 @@ static test_return_t noreply_test(memcached_st *memc) test_true(count); break; } - test_true(ret == MEMCACHED_SUCCESS || ret == MEMCACHED_BUFFERED); + test_true_got(ret == MEMCACHED_SUCCESS or ret == MEMCACHED_BUFFERED, memcached_strerror(NULL, ret)); } /* @@ -4239,7 +4077,7 @@ static test_return_t noreply_test(memcached_st *memc) } test_true(no_msg == 0); - test_true(memcached_flush_buffers(memc) == MEMCACHED_SUCCESS); + test_compare(MEMCACHED_SUCCESS, memcached_flush_buffers(memc)); /* ** Now validate that all items was set properly! @@ -4257,7 +4095,7 @@ static test_return_t noreply_test(memcached_st *memc) uint32_t flags; char* value=memcached_get(memc, key, strlen(key), &length, &flags, &ret); - test_true(ret == MEMCACHED_SUCCESS && value != NULL); + test_true_got(ret == MEMCACHED_SUCCESS && value != NULL, memcached_strerror(NULL, ret)); switch (count) { case 0: /* FALLTHROUGH */ @@ -4289,26 +4127,26 @@ static test_return_t noreply_test(memcached_st *memc) uint32_t flags; memcached_result_st results_obj; memcached_result_st *results; - ret= memcached_mget(memc, keys, lengths, 1); - test_true(ret == MEMCACHED_SUCCESS); + test_compare(MEMCACHED_SUCCESS, + memcached_mget(memc, keys, lengths, 1)); results= memcached_result_create(memc, &results_obj); test_true(results); results= memcached_fetch_result(memc, &results_obj, &ret); test_true(results); - test_true(ret == MEMCACHED_SUCCESS); + test_compare(MEMCACHED_SUCCESS, ret); uint64_t cas= memcached_result_cas(results); memcached_result_free(&results_obj); - ret= memcached_cas(memc, keys[0], lengths[0], keys[0], lengths[0], 0, 0, cas); - test_true(ret == MEMCACHED_SUCCESS); + test_compare(MEMCACHED_SUCCESS, + memcached_cas(memc, keys[0], lengths[0], keys[0], lengths[0], 0, 0, cas)); /* * The item will have a new cas value, so try to set it again with the old * value. This should fail! */ - ret= memcached_cas(memc, keys[0], lengths[0], keys[0], lengths[0], 0, 0, cas); - test_true(ret == MEMCACHED_SUCCESS); + test_compare(MEMCACHED_SUCCESS, + memcached_cas(memc, keys[0], lengths[0], keys[0], lengths[0], 0, 0, cas)); test_true(memcached_flush_buffers(memc) == MEMCACHED_SUCCESS); char* value=memcached_get(memc, keys[0], lengths[0], &length, &flags, &ret); test_true(ret == MEMCACHED_SUCCESS && value != NULL); @@ -4320,10 +4158,9 @@ static test_return_t noreply_test(memcached_st *memc) static test_return_t analyzer_test(memcached_st *memc) { memcached_return_t rc; - memcached_stat_st *memc_stat; memcached_analysis_st *report; - memc_stat= memcached_stat(memc, NULL, &rc); + memcached_stat_st *memc_stat= memcached_stat(memc, NULL, &rc); test_compare(MEMCACHED_SUCCESS, rc); test_true(memc_stat); @@ -4355,68 +4192,85 @@ static test_return_t dump_test(memcached_st *memc) return TEST_SUCCESS; } -struct test_pool_context_st { - memcached_pool_st* pool; - memcached_st* mmc; -}; - -static void* connection_release(void *arg) -{ - test_pool_context_st *resource= static_cast(arg); - - usleep(250); - // Release all of the memc we are holding - assert(memcached_success(memcached_pool_push(resource->pool, resource->mmc))); - 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, POOL_SIZE); - test_true(pool != NULL); + test_true(pool); memcached_st *mmc[POOL_SIZE]; - memcached_return_t rc; // Fill up our array that we will store the memc that are in the pool for (size_t x= 0; x < POOL_SIZE; ++x) { - mmc[x]= memcached_pool_pop(pool, false, &rc); - test_true(mmc[x] != NULL); + memcached_return_t rc; + mmc[x]= memcached_pool_fetch(pool, NULL, &rc); test_compare(MEMCACHED_SUCCESS, rc); + test_true(mmc[x]); } // All memc should be gone - test_true(memcached_pool_pop(pool, false, &rc) == NULL); - test_compare(MEMCACHED_SUCCESS, rc); + { + memcached_return_t rc; + test_null(memcached_pool_fetch(pool, NULL, &rc)); + test_compare(MEMCACHED_NOTFOUND, rc); + } - pthread_t tid; - test_pool_context_st item= { pool, mmc[9] }; + // Release them.. + for (size_t x= 0; x < POOL_SIZE; ++x) + { + if (mmc[x]) + { + test_compare(MEMCACHED_SUCCESS, memcached_pool_release(pool, mmc[x])); + } + } + test_true(memcached_pool_destroy(pool) == memc); - pthread_create(&tid, NULL, connection_release, &item); - mmc[9]= memcached_pool_pop(pool, true, &rc); - test_compare(MEMCACHED_SUCCESS, rc); - pthread_join(tid, NULL); - test_true(mmc[9]); - const char *key= "key"; - size_t keylen= strlen(key); + return TEST_SUCCESS; +} + +static test_return_t connection_pool2_test(memcached_st *memc) +{ + memcached_pool_st* pool= memcached_pool_create(memc, 5, POOL_SIZE); + test_true(pool); + memcached_st *mmc[POOL_SIZE]; + + // Fill up our array that we will store the memc that are in the pool + for (size_t x= 0; x < POOL_SIZE; ++x) + { + memcached_return_t rc; + mmc[x]= memcached_pool_fetch(pool, NULL, &rc); + test_compare(MEMCACHED_SUCCESS, rc); + test_true(mmc[x]); + } + + // All memc should be gone + { + memcached_return_t rc; + test_null(memcached_pool_fetch(pool, NULL, &rc)); + test_compare(MEMCACHED_NOTFOUND, rc); + } // verify that I can do ops with all connections test_compare(MEMCACHED_SUCCESS, - memcached_set(mmc[0], key, keylen, "0", 1, 0, 0)); + memcached_set(mmc[0], + test_literal_param("key"), + "0", 1, 0, 0)); for (uint64_t x= 0; x < POOL_SIZE; ++x) { uint64_t number_value; test_compare(MEMCACHED_SUCCESS, - memcached_increment(mmc[x], key, keylen, 1, &number_value)); + memcached_increment(mmc[x], + test_literal_param("key"), + 1, &number_value)); test_compare(number_value, (x+1)); } // Release them.. for (size_t x= 0; x < POOL_SIZE; ++x) { - test_compare(MEMCACHED_SUCCESS, memcached_pool_push(pool, mmc[x])); + test_compare(MEMCACHED_SUCCESS, memcached_pool_release(pool, mmc[x])); } @@ -4424,22 +4278,137 @@ static test_return_t connection_pool_test(memcached_st *memc) * of the connections in the pool. It should however be enabled * when I push the item into the pool */ - mmc[0]= memcached_pool_pop(pool, false, &rc); + mmc[0]= memcached_pool_fetch(pool, NULL, NULL); test_true(mmc[0]); - rc= memcached_pool_behavior_set(pool, MEMCACHED_BEHAVIOR_IO_MSG_WATERMARK, 9999); - test_compare(MEMCACHED_SUCCESS, rc); + test_compare(MEMCACHED_SUCCESS, + memcached_pool_behavior_set(pool, MEMCACHED_BEHAVIOR_IO_MSG_WATERMARK, 9999)); - mmc[1]= memcached_pool_pop(pool, false, &rc); - test_true(mmc[1]); + { + memcached_return_t rc; + mmc[1]= memcached_pool_fetch(pool, NULL, &rc); + test_true(mmc[1]); + test_compare(MEMCACHED_SUCCESS, rc); + } test_compare(UINT64_C(9999), memcached_behavior_get(mmc[1], MEMCACHED_BEHAVIOR_IO_MSG_WATERMARK)); - test_compare(MEMCACHED_SUCCESS, memcached_pool_push(pool, mmc[1])); - test_compare(MEMCACHED_SUCCESS, memcached_pool_push(pool, mmc[0])); + test_compare(MEMCACHED_SUCCESS, memcached_pool_release(pool, mmc[1])); + test_compare(MEMCACHED_SUCCESS, memcached_pool_release(pool, mmc[0])); + + { + memcached_return_t rc; + mmc[0]= memcached_pool_fetch(pool, NULL, &rc); + test_true(mmc[0]); + test_compare(MEMCACHED_SUCCESS, rc); + } - mmc[0]= memcached_pool_pop(pool, false, &rc); test_compare(UINT64_C(9999), memcached_behavior_get(mmc[0], MEMCACHED_BEHAVIOR_IO_MSG_WATERMARK)); - test_compare(MEMCACHED_SUCCESS, memcached_pool_push(pool, mmc[0])); + test_compare(MEMCACHED_SUCCESS, memcached_pool_release(pool, mmc[0])); + + test_true(memcached_pool_destroy(pool) == memc); + + return TEST_SUCCESS; +} + +struct test_pool_context_st { + volatile memcached_return_t rc; + memcached_pool_st* pool; + memcached_st* mmc; + sem_t _lock; + + test_pool_context_st(memcached_pool_st *pool_arg, memcached_st *memc_arg): + rc(MEMCACHED_FAILURE), + pool(pool_arg), + mmc(memc_arg) + { + sem_init(&_lock, 0, 0); + } + + void wait() + { + sem_wait(&_lock); + } + + void release() + { + sem_post(&_lock); + } + + ~test_pool_context_st() + { + sem_destroy(&_lock); + } +}; + +static void* connection_release(void *arg) +{ + test_pool_context_st *resource= static_cast(arg); + assert(resource); + if (resource == NULL) + { + abort(); + } + + // Release all of the memc we are holding + resource->rc= memcached_pool_release(resource->pool, resource->mmc); + resource->release(); + + pthread_exit(arg); +} + +static test_return_t connection_pool3_test(memcached_st *memc) +{ + memcached_pool_st* pool= memcached_pool_create(memc, 1, 1); + test_true(pool); + + memcached_st *pool_memc; + { + memcached_return_t rc; + pool_memc= memcached_pool_fetch(pool, NULL, &rc); + test_compare(MEMCACHED_SUCCESS, rc); + test_true(pool_memc); + } + + /* + @note This comment was written to describe what was believed to be the original authors intent. + + This portion of the test creates a thread that will wait until told to free a memcached_st + that will be grabbed by the main thread. + + It is believed that this tests whether or not we are handling ownership correctly. + */ + pthread_t tid; + test_pool_context_st item(pool, pool_memc); + + test_zero(pthread_create(&tid, NULL, connection_release, &item)); + item.wait(); + + memcached_return_t rc; + memcached_st *pop_memc; + int counter= 5; + do + { + struct timespec relative_time= { 0, 0 }; + pop_memc= memcached_pool_fetch(pool, &relative_time, &rc); + + if (memcached_failed(rc)) + { + test_null(pop_memc); + } + } while (rc == MEMCACHED_TIMEOUT and --counter); + + if (memcached_failed(rc)) // Cleanup thread since we will exit once we test. + { + pthread_join(tid, NULL); + test_compare(MEMCACHED_SUCCESS, rc); + } + + { + int pthread_ret= pthread_join(tid, NULL); + test_true(pthread_ret == 0 or pthread_ret == ESRCH); + } + test_compare(MEMCACHED_SUCCESS, rc); + test_true(pool_memc == pop_memc); test_true(memcached_pool_destroy(pool) == memc); @@ -4476,20 +4445,32 @@ static test_return_t util_version_test(memcached_st *memc) test_true(if_successful == true); if (instance->micro_version > 0) + { if_successful= libmemcached_util_version_check(memc, instance->major_version, instance->minor_version, (uint8_t)(instance->micro_version -1)); + } else if (instance->minor_version > 0) + { if_successful= libmemcached_util_version_check(memc, instance->major_version, (uint8_t)(instance->minor_version - 1), instance->micro_version); + } else if (instance->major_version > 0) + { if_successful= libmemcached_util_version_check(memc, (uint8_t)(instance->major_version -1), instance->minor_version, instance->micro_version); + } test_true(if_successful == true); if (instance->micro_version > 0) + { if_successful= libmemcached_util_version_check(memc, instance->major_version, instance->minor_version, (uint8_t)(instance->micro_version +1)); + } else if (instance->minor_version > 0) + { if_successful= libmemcached_util_version_check(memc, instance->major_version, (uint8_t)(instance->minor_version +1), instance->micro_version); + } else if (instance->major_version > 0) + { if_successful= libmemcached_util_version_check(memc, (uint8_t)(instance->major_version +1), instance->minor_version, instance->micro_version); + } test_true(if_successful == false); @@ -4575,26 +4556,21 @@ static test_return_t hash_sanity_test (memcached_st *memc) static test_return_t hsieh_avaibility_test (memcached_st *memc) { - memcached_return_t expected_rc= MEMCACHED_INVALID_ARGUMENTS; -#ifdef HAVE_HSIEH_HASH - expected_rc= MEMCACHED_SUCCESS; -#endif - memcached_return_t rc= memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_HASH, - (uint64_t)MEMCACHED_HASH_HSIEH); - test_true(rc == expected_rc); + test_skip(true, libhashkit_has_algorithm(HASHKIT_HASH_HSIEH)); + + test_compare(MEMCACHED_SUCCESS, + memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_HASH, + (uint64_t)MEMCACHED_HASH_HSIEH)); return TEST_SUCCESS; } static test_return_t murmur_avaibility_test (memcached_st *memc) { - memcached_return_t expected_rc= MEMCACHED_INVALID_ARGUMENTS; -#ifdef HAVE_MURMUR_HASH - expected_rc= MEMCACHED_SUCCESS; -#endif - memcached_return_t rc= memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_HASH, - (uint64_t)MEMCACHED_HASH_MURMUR); - test_true(rc == expected_rc); + test_skip(true, libhashkit_has_algorithm(HASHKIT_HASH_MURMUR)); + + test_compare(MEMCACHED_SUCCESS, + memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_HASH, (uint64_t)MEMCACHED_HASH_MURMUR)); return TEST_SUCCESS; } @@ -4606,10 +4582,8 @@ static test_return_t one_at_a_time_run (memcached_st *) for (ptr= list_to_hash, x= 0; *ptr; ptr++, x++) { - uint32_t hash_val; - - hash_val= memcached_generate_hash_value(*ptr, strlen(*ptr), MEMCACHED_HASH_DEFAULT); - test_true(one_at_a_time_values[x] == hash_val); + test_compare(one_at_a_time_values[x], + memcached_generate_hash_value(*ptr, strlen(*ptr), MEMCACHED_HASH_DEFAULT)); } return TEST_SUCCESS; @@ -4622,10 +4596,8 @@ static test_return_t md5_run (memcached_st *) for (ptr= list_to_hash, x= 0; *ptr; ptr++, x++) { - uint32_t hash_val; - - hash_val= memcached_generate_hash_value(*ptr, strlen(*ptr), MEMCACHED_HASH_MD5); - test_true(md5_values[x] == hash_val); + test_compare(md5_values[x], + memcached_generate_hash_value(*ptr, strlen(*ptr), MEMCACHED_HASH_MD5)); } return TEST_SUCCESS; @@ -4638,10 +4610,8 @@ static test_return_t crc_run (memcached_st *) for (ptr= list_to_hash, x= 0; *ptr; ptr++, x++) { - uint32_t hash_val; - - hash_val= memcached_generate_hash_value(*ptr, strlen(*ptr), MEMCACHED_HASH_CRC); - test_true(crc_values[x] == hash_val); + test_compare(crc_values[x], + memcached_generate_hash_value(*ptr, strlen(*ptr), MEMCACHED_HASH_CRC)); } return TEST_SUCCESS; @@ -4649,15 +4619,15 @@ static test_return_t crc_run (memcached_st *) static test_return_t fnv1_64_run (memcached_st *) { + test_skip(true, libhashkit_has_algorithm(HASHKIT_HASH_FNV1_64)); + uint32_t x; const char **ptr; for (ptr= list_to_hash, x= 0; *ptr; ptr++, x++) { - uint32_t hash_val; - - hash_val= memcached_generate_hash_value(*ptr, strlen(*ptr), MEMCACHED_HASH_FNV1_64); - test_true(fnv1_64_values[x] == hash_val); + test_compare(fnv1_64_values[x], + memcached_generate_hash_value(*ptr, strlen(*ptr), MEMCACHED_HASH_FNV1_64)); } return TEST_SUCCESS; @@ -4665,15 +4635,15 @@ static test_return_t fnv1_64_run (memcached_st *) static test_return_t fnv1a_64_run (memcached_st *) { + test_skip(true, libhashkit_has_algorithm(HASHKIT_HASH_FNV1A_64)); + uint32_t x; const char **ptr; for (ptr= list_to_hash, x= 0; *ptr; ptr++, x++) { - uint32_t hash_val; - - hash_val= memcached_generate_hash_value(*ptr, strlen(*ptr), MEMCACHED_HASH_FNV1A_64); - test_true(fnv1a_64_values[x] == hash_val); + test_compare(fnv1a_64_values[x], + memcached_generate_hash_value(*ptr, strlen(*ptr), MEMCACHED_HASH_FNV1A_64)); } return TEST_SUCCESS; @@ -4686,10 +4656,8 @@ static test_return_t fnv1_32_run (memcached_st *) for (ptr= list_to_hash, x= 0; *ptr; ptr++, x++) { - uint32_t hash_val; - - hash_val= memcached_generate_hash_value(*ptr, strlen(*ptr), MEMCACHED_HASH_FNV1_32); - test_true(fnv1_32_values[x] == hash_val); + test_compare(fnv1_32_values[x], + memcached_generate_hash_value(*ptr, strlen(*ptr), MEMCACHED_HASH_FNV1_32)); } return TEST_SUCCESS; @@ -4702,10 +4670,8 @@ static test_return_t fnv1a_32_run (memcached_st *) for (ptr= list_to_hash, x= 0; *ptr; ptr++, x++) { - uint32_t hash_val; - - hash_val= memcached_generate_hash_value(*ptr, strlen(*ptr), MEMCACHED_HASH_FNV1A_32); - test_true(fnv1a_32_values[x] == hash_val); + test_compare(fnv1a_32_values[x], + memcached_generate_hash_value(*ptr, strlen(*ptr), MEMCACHED_HASH_FNV1A_32)); } return TEST_SUCCESS; @@ -4713,15 +4679,15 @@ static test_return_t fnv1a_32_run (memcached_st *) static test_return_t hsieh_run (memcached_st *) { + test_skip(true, libhashkit_has_algorithm(HASHKIT_HASH_HSIEH)); + uint32_t x; const char **ptr; for (ptr= list_to_hash, x= 0; *ptr; ptr++, x++) { - uint32_t hash_val; - - hash_val= memcached_generate_hash_value(*ptr, strlen(*ptr), MEMCACHED_HASH_HSIEH); - test_true(hsieh_values[x] == hash_val); + test_compare(hsieh_values[x], + memcached_generate_hash_value(*ptr, strlen(*ptr), MEMCACHED_HASH_HSIEH)); } return TEST_SUCCESS; @@ -4729,6 +4695,8 @@ static test_return_t hsieh_run (memcached_st *) static test_return_t murmur_run (memcached_st *) { + test_skip(true, libhashkit_has_algorithm(HASHKIT_HASH_MURMUR)); + #ifdef WORDS_BIGENDIAN (void)murmur_values; return TEST_SKIPPED; @@ -4738,10 +4706,8 @@ static test_return_t murmur_run (memcached_st *) for (ptr= list_to_hash, x= 0; *ptr; ptr++, x++) { - uint32_t hash_val; - - hash_val= memcached_generate_hash_value(*ptr, strlen(*ptr), MEMCACHED_HASH_MURMUR); - test_true(murmur_values[x] == hash_val); + test_compare(murmur_values[x], + memcached_generate_hash_value(*ptr, strlen(*ptr), MEMCACHED_HASH_MURMUR)); } return TEST_SUCCESS; @@ -4755,24 +4721,20 @@ static test_return_t jenkins_run (memcached_st *) for (ptr= list_to_hash, x= 0; *ptr; ptr++, x++) { - uint32_t hash_val; - - hash_val= memcached_generate_hash_value(*ptr, strlen(*ptr), MEMCACHED_HASH_JENKINS); - test_true(jenkins_values[x] == hash_val); + test_compare(jenkins_values[x], + memcached_generate_hash_value(*ptr, strlen(*ptr), MEMCACHED_HASH_JENKINS)); } return TEST_SUCCESS; } -static uint32_t hash_md5_test_function(const char *string, size_t string_length, void *context) +static uint32_t hash_md5_test_function(const char *string, size_t string_length, void *) { - (void)context; return libhashkit_md5(string, string_length); } -static uint32_t hash_crc_test_function(const char *string, size_t string_length, void *context) +static uint32_t hash_crc_test_function(const char *string, size_t string_length, void *) { - (void)context; return libhashkit_crc32(string, string_length); } @@ -4882,10 +4844,9 @@ static test_return_t memcached_get_MEMCACHED_NOTFOUND(memcached_st *memc) size_t len; uint32_t flags; memcached_return rc; - char *value; // See if memcached is reachable. - value= memcached_get(memc, key, strlen(key), &len, &flags, &rc); + char *value= memcached_get(memc, key, strlen(key), &len, &flags, &rc); test_false(value); test_zero(len); @@ -4951,110 +4912,6 @@ static test_return_t memcached_get_by_key_MEMCACHED_NOTFOUND(memcached_st *memc) return TEST_SUCCESS; } - -static test_return_t ketama_compatibility_libmemcached(memcached_st *) -{ - memcached_st *memc= memcached_create(NULL); - test_true(memc); - - test_compare(MEMCACHED_SUCCESS, - memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_KETAMA_WEIGHTED, 1)); - - test_compare(uint64_t(1), memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_KETAMA_WEIGHTED)); - - test_compare(MEMCACHED_SUCCESS, memcached_behavior_set_distribution(memc, MEMCACHED_DISTRIBUTION_CONSISTENT_KETAMA)); - test_compare(MEMCACHED_DISTRIBUTION_CONSISTENT_KETAMA, memcached_behavior_get_distribution(memc)); - - memcached_server_st *server_pool= memcached_servers_parse("10.0.1.1:11211 600,10.0.1.2:11211 300,10.0.1.3:11211 200,10.0.1.4:11211 350,10.0.1.5:11211 1000,10.0.1.6:11211 800,10.0.1.7:11211 950,10.0.1.8:11211 100"); - memcached_server_push(memc, server_pool); - - /* verify that the server list was parsed okay. */ - test_compare(8U, memcached_server_count(memc)); - test_strcmp(server_pool[0].hostname, "10.0.1.1"); - test_compare(in_port_t(11211), server_pool[0].port); - test_compare(600U, server_pool[0].weight); - test_strcmp(server_pool[2].hostname, "10.0.1.3"); - test_compare(in_port_t(11211), server_pool[2].port); - test_compare(200U, server_pool[2].weight); - test_strcmp(server_pool[7].hostname, "10.0.1.8"); - test_compare(in_port_t(11211), server_pool[7].port); - test_compare(100U, server_pool[7].weight); - - /* VDEAAAAA hashes to fffcd1b5, after the last continuum point, and lets - * us test the boundary wraparound. - */ - test_true(memcached_generate_hash(memc, (char *)"VDEAAAAA", 8) == memc->ketama.continuum[0].index); - - /* verify the standard ketama set. */ - for (uint32_t x= 0; x < 99; x++) - { - uint32_t server_idx = memcached_generate_hash(memc, ketama_test_cases[x].key, strlen(ketama_test_cases[x].key)); - memcached_server_instance_st instance= - memcached_server_instance_by_position(memc, server_idx); - const char *hostname = memcached_server_name(instance); - - test_strcmp(hostname, ketama_test_cases[x].server); - } - - memcached_server_list_free(server_pool); - memcached_free(memc); - - return TEST_SUCCESS; -} - -static test_return_t ketama_compatibility_spymemcached(memcached_st *) -{ - memcached_st *memc= memcached_create(NULL); - test_true(memc); - - test_compare(MEMCACHED_SUCCESS, - memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_KETAMA_WEIGHTED, 1)); - - test_compare(UINT64_C(1), memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_KETAMA_WEIGHTED)); - - test_compare(MEMCACHED_SUCCESS, memcached_behavior_set_distribution(memc, MEMCACHED_DISTRIBUTION_CONSISTENT_KETAMA_SPY)); - test_compare(MEMCACHED_DISTRIBUTION_CONSISTENT_KETAMA_SPY, memcached_behavior_get_distribution(memc)); - - memcached_server_st *server_pool= memcached_servers_parse("10.0.1.1:11211 600,10.0.1.2:11211 300,10.0.1.3:11211 200,10.0.1.4:11211 350,10.0.1.5:11211 1000,10.0.1.6:11211 800,10.0.1.7:11211 950,10.0.1.8:11211 100"); - test_true(server_pool); - memcached_server_push(memc, server_pool); - - /* verify that the server list was parsed okay. */ - test_compare(8U, memcached_server_count(memc)); - test_strcmp(server_pool[0].hostname, "10.0.1.1"); - test_compare(in_port_t(11211), server_pool[0].port); - test_compare(600U, server_pool[0].weight); - test_strcmp(server_pool[2].hostname, "10.0.1.3"); - test_compare(in_port_t(11211), server_pool[2].port); - test_compare(200U, server_pool[2].weight); - test_strcmp(server_pool[7].hostname, "10.0.1.8"); - test_compare(in_port_t(11211), server_pool[7].port); - test_compare(100U, server_pool[7].weight); - - /* VDEAAAAA hashes to fffcd1b5, after the last continuum point, and lets - * us test the boundary wraparound. - */ - test_true(memcached_generate_hash(memc, (char *)"VDEAAAAA", 8) == memc->ketama.continuum[0].index); - - /* verify the standard ketama set. */ - for (uint32_t x= 0; x < 99; x++) - { - uint32_t server_idx= memcached_generate_hash(memc, ketama_test_cases_spy[x].key, strlen(ketama_test_cases_spy[x].key)); - - memcached_server_instance_st instance= - memcached_server_instance_by_position(memc, server_idx); - - const char *hostname= memcached_server_name(instance); - - test_strcmp(hostname, ketama_test_cases_spy[x].server); - } - - memcached_server_list_free(server_pool); - memcached_free(memc); - - return TEST_SUCCESS; -} - static test_return_t regression_bug_434484(memcached_st *memc) { test_return_t test_rc; @@ -5500,7 +5357,7 @@ static test_return_t test_multiple_get_last_disconnect(memcached_st *) { const char *msg= memcached_strerror(memc, memcached_return_t(x)); memcached_return_t ret= memcached_set(memc, msg, strlen(msg), NULL, 0, (time_t)0, (uint32_t)0); - test_compare_got(MEMCACHED_CONNECTION_FAILURE, ret, memcached_last_error_message(memc)); + test_true_got((ret == MEMCACHED_CONNECTION_FAILURE or ret == MEMCACHED_SERVER_TEMPORARILY_DISABLED), memcached_last_error_message(memc)); memcached_server_instance_st disconnected_server= memcached_server_get_last_disconnect(memc); test_true(disconnected_server); @@ -5526,66 +5383,6 @@ static test_return_t test_verbosity(memcached_st *memc) return TEST_SUCCESS; } -static test_return_t test_server_failure(memcached_st *memc) -{ - if (memcached_server_count(memc) < 2) - return TEST_SKIPPED; - - memcached_server_instance_st instance= memcached_server_instance_by_position(memc, 0); - - memcached_st *local_memc= memcached_create(NULL); - - memcached_server_add(local_memc, memcached_server_name(instance), memcached_server_port(instance)); - memcached_behavior_set(local_memc, MEMCACHED_BEHAVIOR_SERVER_FAILURE_LIMIT, 2); - - uint32_t server_count= memcached_server_count(local_memc); - test_compare(1U, server_count); - - // Disable the server - instance= memcached_server_instance_by_position(local_memc, 0); - ((memcached_server_write_instance_st)instance)->server_failure_counter= 2; - - memcached_return_t rc; - test_compare_got(MEMCACHED_SERVER_MARKED_DEAD, - rc= memcached_set(local_memc, "foo", strlen("foo"), NULL, 0, (time_t)0, (uint32_t)0), - memcached_last_error_message(local_memc)); - - ((memcached_server_write_instance_st)instance)->server_failure_counter= 0; - test_compare(MEMCACHED_SUCCESS, - memcached_set(local_memc, "foo", strlen("foo"), NULL, 0, (time_t)0, (uint32_t)0)); -#if 0 - memcached_last_error_message(local_memc)); -#endif - - - memcached_free(local_memc); - - return TEST_SUCCESS; -} - -static test_return_t test_cull_servers(memcached_st *memc) -{ - uint32_t count= memcached_server_count(memc); - - if (count < 2) - { - return TEST_SKIPPED; - } - - // Do not do this in your code, it is not supported. - memc->servers[1].options.is_dead= true; - memc->state.is_time_for_rebuild= true; - - uint32_t new_count= memcached_server_count(memc); - test_compare(count, new_count); - -#if 0 - test_true(count == new_count + 1 ); -#endif - - return TEST_SUCCESS; -} - static memcached_return_t stat_printer(memcached_server_instance_st server, const char *key, size_t key_length, @@ -5891,7 +5688,7 @@ static test_return_t regression_bug_655423(memcached_st *memc) test_compare(MEMCACHED_SUCCESS, rc); test_true(value); - test_compare(100UL, value_length); + test_compare(100LLU, value_length); free(value); } @@ -5975,11 +5772,32 @@ static test_return_t regression_bug_490520(memcached_st *memc) return TEST_SUCCESS; } + +static test_return_t regression_bug_854604(memcached_st *) +{ + char buffer[1024]; + + test_compare(MEMCACHED_INVALID_ARGUMENTS, libmemcached_check_configuration(0, 0, buffer, 0)); + + test_compare(MEMCACHED_PARSE_ERROR, libmemcached_check_configuration(test_literal_param("syntax error"), buffer, 0)); + + test_compare(MEMCACHED_PARSE_ERROR, libmemcached_check_configuration(test_literal_param("syntax error"), buffer, 1)); + test_compare(buffer[0], 0); + + test_compare(MEMCACHED_PARSE_ERROR, libmemcached_check_configuration(test_literal_param("syntax error"), buffer, 10)); + test_true(strlen(buffer)); + + test_compare(MEMCACHED_PARSE_ERROR, libmemcached_check_configuration(test_literal_param("syntax error"), buffer, sizeof(buffer))); + test_true(strlen(buffer)); + + return TEST_SUCCESS; +} + static void memcached_die(memcached_st* mc, memcached_return error, const char* what, uint32_t it) { fprintf(stderr, "Iteration #%u: ", it); - if(error == MEMCACHED_ERRNO) + if (error == MEMCACHED_ERRNO) { fprintf(stderr, "system error %d from %s: %s\n", errno, what, strerror(errno)); @@ -6083,39 +5901,6 @@ static test_return_t regression_bug_(memcached_st *memc) return TEST_SUCCESS; } -/* - * Test that the sasl authentication works. We cannot use the default - * pool of servers, because that would require that all servers we want - * to test supports SASL authentication, and that they use the default - * creds. - */ -static test_return_t sasl_auth_test(memcached_st *memc) -{ -#ifdef LIBMEMCACHED_WITH_SASL_SUPPORT - test_compare(MEMCACHED_SUCCESS, memcached_set(memc, "foo", 3, "bar", 3, (time_t)0, (uint32_t)0)); - test_compare(MEMCACHED_SUCCESS, memcached_delete(memc, "foo", 3, 0)); - test_compare(MEMCACHED_SUCCESS, memcached_destroy_sasl_auth_data(memc)); - test_compare(MEMCACHED_FAILURE, memcached_destroy_sasl_auth_data(memc)); - test_compare(MEMCACHED_FAILURE, memcached_destroy_sasl_auth_data(NULL)); - memcached_quit(memc); - - test_compare(MEMCACHED_SUCCESS, - memcached_set_sasl_auth_data(memc, - getenv("LIBMEMCACHED_TEST_SASL_USERNAME"), - getenv("LIBMEMCACHED_TEST_SASL_SERVER"))); - - test_compare(MEMCACHED_AUTH_FAILURE, - memcached_set(memc, "foo", 3, "bar", 3, (time_t)0, (uint32_t)0)); - test_compare(MEMCACHED_SUCCESS, memcached_destroy_sasl_auth_data(memc)); - - memcached_quit(memc); - return TEST_SUCCESS; -#else - (void)memc; - return TEST_FAILURE; -#endif -} - /* Clean the server before beginning testing */ test_st tests[] ={ {"util_version", true, (test_callback_fn*)util_version_test }, @@ -6131,7 +5916,6 @@ 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}, - {"error", false, (test_callback_fn*)error_test }, {"set", false, (test_callback_fn*)set_test }, {"set2", false, (test_callback_fn*)set_test2 }, {"set3", false, (test_callback_fn*)set_test3 }, @@ -6154,6 +5938,7 @@ test_st tests[] ={ {"increment_with_initial_by_key", true, (test_callback_fn*)increment_with_initial_by_key_test }, {"decrement_by_key", false, (test_callback_fn*)decrement_by_key_test }, {"decrement_with_initial_by_key", true, (test_callback_fn*)decrement_with_initial_by_key_test }, + {"binary_increment_with_prefix", 1, (test_callback_fn*)binary_increment_with_prefix_test }, {"quit", false, (test_callback_fn*)quit_test }, {"mget", true, (test_callback_fn*)mget_test }, {"mget_result", true, (test_callback_fn*)mget_result_test }, @@ -6172,13 +5957,17 @@ test_st tests[] ={ {"delete_through", true, (test_callback_fn*)delete_through }, {"noreply", true, (test_callback_fn*)noreply_test}, {"analyzer", true, (test_callback_fn*)analyzer_test}, - {"connectionpool", true, (test_callback_fn*)connection_pool_test }, + {"memcached_pool_st", true, (test_callback_fn*)connection_pool_test }, + {"memcached_pool_st #2", true, (test_callback_fn*)connection_pool2_test }, + {"memcached_pool_st #3", true, (test_callback_fn*)connection_pool3_test }, {"memcached_pool_test", true, (test_callback_fn*)memcached_pool_test }, {"test_get_last_disconnect", true, (test_callback_fn*)test_get_last_disconnect}, {"verbosity", true, (test_callback_fn*)test_verbosity}, - {"test_server_failure", true, (test_callback_fn*)test_server_failure}, - {"cull_servers", true, (test_callback_fn*)test_cull_servers}, {"memcached_stat_execute", true, (test_callback_fn*)memcached_stat_execute_test}, + {"memcached_exist(MEMCACHED_NOTFOUND)", true, (test_callback_fn*)memcached_exist_NOTFOUND }, + {"memcached_exist(MEMCACHED_SUCCESS)", true, (test_callback_fn*)memcached_exist_SUCCESS }, + {"memcached_exist_by_key(MEMCACHED_NOTFOUND)", true, (test_callback_fn*)memcached_exist_by_key_NOTFOUND }, + {"memcached_exist_by_key(MEMCACHED_SUCCESS)", true, (test_callback_fn*)memcached_exist_by_key_SUCCESS }, {0, 0, 0} }; @@ -6189,6 +5978,7 @@ test_st behavior_tests[] ={ {"MEMCACHED_BEHAVIOR_CORK", false, (test_callback_fn*)MEMCACHED_BEHAVIOR_CORK_test}, {"MEMCACHED_BEHAVIOR_TCP_KEEPALIVE", false, (test_callback_fn*)MEMCACHED_BEHAVIOR_TCP_KEEPALIVE_test}, {"MEMCACHED_BEHAVIOR_TCP_KEEPIDLE", false, (test_callback_fn*)MEMCACHED_BEHAVIOR_TCP_KEEPIDLE_test}, + {"MEMCACHED_BEHAVIOR_POLL_TIMEOUT", false, (test_callback_fn*)MEMCACHED_BEHAVIOR_POLL_TIMEOUT_test}, {0, 0, 0} }; @@ -6206,6 +5996,7 @@ test_st basic_tests[] ={ {"reset heap", true, (test_callback_fn*)basic_reset_heap_test}, {"reset stack clone", true, (test_callback_fn*)basic_reset_stack_clone_test}, {"reset heap clone", true, (test_callback_fn*)basic_reset_heap_clone_test}, + {"memcached_return_t", false, (test_callback_fn*)memcached_return_t_TEST }, {0, 0, 0} }; @@ -6220,17 +6011,6 @@ test_st async_tests[] ={ {0, 0, 0} }; -test_st string_tests[] ={ - {"string static with null", false, (test_callback_fn*)string_static_null }, - {"string alloc with null", false, (test_callback_fn*)string_alloc_null }, - {"string alloc with 1K", false, (test_callback_fn*)string_alloc_with_size }, - {"string alloc with malloc failure", false, (test_callback_fn*)string_alloc_with_size_toobig }, - {"string append", false, (test_callback_fn*)string_alloc_append }, - {"string append failure (too big)", false, (test_callback_fn*)string_alloc_append_toobig }, - {"string_alloc_append_multiple", false, (test_callback_fn*)string_alloc_append_multiple }, - {0, 0, (test_callback_fn*)0} -}; - test_st memcached_server_get_last_disconnect_tests[] ={ {"memcached_server_get_last_disconnect()", false, (test_callback_fn*)test_multiple_get_last_disconnect}, {0, 0, (test_callback_fn*)0} @@ -6325,14 +6105,10 @@ test_st regression_tests[]= { {"lp:71231153 poll()", true, (test_callback_fn*)regression_bug_71231153_poll }, {"lp:655423", true, (test_callback_fn*)regression_bug_655423 }, {"lp:490520", true, (test_callback_fn*)regression_bug_490520 }, + {"lp:854604", true, (test_callback_fn*)regression_bug_854604 }, {0, false, (test_callback_fn*)0} }; -test_st sasl_auth_tests[]= { - {"sasl_auth", true, (test_callback_fn*)sasl_auth_test }, - {0, 0, (test_callback_fn*)0} -}; - test_st ketama_compatibility[]= { {"libmemcached", true, (test_callback_fn*)ketama_compatibility_libmemcached }, {"spymemcached", true, (test_callback_fn*)ketama_compatibility_spymemcached }, @@ -6450,6 +6226,12 @@ test_st virtual_bucket_tests[] ={ {0, 0, (test_callback_fn*)0} }; +test_st memcached_server_add_tests[] ={ + {"memcached_server_add(\"\")", false, (test_callback_fn*)memcached_server_add_empty_test }, + {"memcached_server_add(NULL)", false, (test_callback_fn*)memcached_server_add_null_test }, + {0, 0, (test_callback_fn*)0} +}; + test_st namespace_tests[] ={ {"basic tests", true, (test_callback_fn*)selection_of_namespace_tests }, {"increment", true, (test_callback_fn*)memcached_increment_namespace }, @@ -6464,6 +6246,7 @@ collection_st collection[] ={ {"basic", 0, 0, basic_tests}, {"hsieh_availability", 0, 0, hsieh_availability}, {"murmur_availability", 0, 0, murmur_availability}, + {"memcached_server_add", 0, 0, memcached_server_add_tests}, {"block", 0, 0, tests}, {"binary", (test_callback_fn*)pre_binary, 0, tests}, {"nonblock", (test_callback_fn*)pre_nonblock, 0, tests}, @@ -6481,7 +6264,6 @@ collection_st collection[] ={ {"ketama_auto_eject_hosts", (test_callback_fn*)pre_behavior_ketama, 0, ketama_auto_eject_hosts}, {"unix_socket", (test_callback_fn*)pre_unix_socket, 0, tests}, {"unix_socket_nodelay", (test_callback_fn*)pre_nodelay, 0, tests}, - {"poll_timeout", (test_callback_fn*)poll_timeout, 0, tests}, {"gets", (test_callback_fn*)enable_cas, 0, tests}, {"consistent_crc", (test_callback_fn*)enable_consistent_crc, 0, tests}, {"consistent_hsieh", (test_callback_fn*)enable_consistent_hsieh, 0, tests}, @@ -6493,15 +6275,12 @@ collection_st collection[] ={ {"namespace(BINARY)", (test_callback_fn*)set_namespace_and_binary, 0, tests}, {"specific namespace", 0, 0, namespace_tests}, {"specific namespace(BINARY)", (test_callback_fn*)pre_binary, 0, namespace_tests}, - {"sasl_auth", (test_callback_fn*)pre_sasl, 0, sasl_auth_tests }, - {"sasl", (test_callback_fn*)pre_sasl, 0, tests }, {"version_1_2_3", (test_callback_fn*)check_for_1_2_3, 0, version_1_2_3}, - {"string", 0, 0, string_tests}, {"result", 0, 0, result_tests}, {"async", (test_callback_fn*)pre_nonblock, 0, async_tests}, {"async(BINARY)", (test_callback_fn*)pre_nonblock_binary, 0, async_tests}, {"Cal Haldenbrand's tests", 0, 0, haldenbrand_tests}, - {"user", 0, 0, user_tests}, + {"user written tests", 0, 0, user_tests}, {"generate", 0, 0, generate_tests}, {"generate_hsieh", (test_callback_fn*)pre_hsieh, 0, generate_tests}, {"generate_ketama", (test_callback_fn*)pre_behavior_ketama, 0, generate_tests}, @@ -6530,6 +6309,8 @@ collection_st collection[] ={ {0, 0, 0, 0} }; +#define TEST_PORT_BASE MEMCACHED_DEFAULT_PORT +10 + #include "tests/libmemcached_world.h" void get_world(Framework *world)