X-Git-Url: https://git.m6w6.name/?a=blobdiff_plain;f=tests%2Flibmemcached-1.0%2Fmem_functions.cc;h=3b1701e8315da782714a59810861b44c7720f3b2;hb=40353ce2b76875202b3d37ad32c645ec18933bed;hp=d44b5561262be58e5dfc83b52a130b7f208b2b49;hpb=a2d3699da26720a399bd7f563ccdbccf26e610c5;p=awesomized%2Flibmemcached diff --git a/tests/libmemcached-1.0/mem_functions.cc b/tests/libmemcached-1.0/mem_functions.cc index d44b5561..3b1701e8 100644 --- a/tests/libmemcached-1.0/mem_functions.cc +++ b/tests/libmemcached-1.0/mem_functions.cc @@ -52,7 +52,8 @@ #include -#include +#include + #include #include #include @@ -88,120 +89,9 @@ using namespace libtest; #define UUID_STRING_MAXLENGTH 36 -struct keys_st { -public: - keys_st(size_t arg) - { - init(arg, UUID_STRING_MAXLENGTH); - } - - keys_st(size_t arg, size_t padding) - { - init(arg, padding); - } - - void init(size_t arg, size_t padding) - { - _lengths.resize(arg); - _keys.resize(arg); - - for (size_t x= 0; x < _keys.size(); x++) - { - libtest::vchar_t key_buffer; - key_buffer.resize(padding +1); - memset(&key_buffer[0], 'x', padding); - - if (HAVE_LIBUUID) - { -#if defined(HAVE_LIBUUID) && HAVE_LIBUUID - uuid_t out; - uuid_generate(out); +#include "tests/keys.hpp" - uuid_unparse(out, &key_buffer[0]); - _keys[x]= strdup(&key_buffer[0]); - (_keys[x])[UUID_STRING_MAXLENGTH]= 'x'; -#endif - } - else // We just use a number and pad the string if UUID is not available - { - char int_buffer[MEMCACHED_MAXIMUM_INTEGER_DISPLAY_LENGTH +1]; - int key_length= snprintf(int_buffer, sizeof(int_buffer), "%u", uint32_t(x)); - memcpy(&key_buffer[0], int_buffer, key_length); - _keys[x]= strdup(&key_buffer[0]); - } - _lengths[x]= padding; - } - } - - ~keys_st() - { - for (libtest::vchar_ptr_t::iterator iter= _keys.begin(); - iter != _keys.end(); - iter++) - { - ::free(*iter); - } - } - - libtest::vchar_ptr_t::iterator begin() - { - return _keys.begin(); - } - - libtest::vchar_ptr_t::iterator end() - { - return _keys.end(); - } - - size_t size() const - { - return _keys.size(); - } - - std::vector& lengths() - { - return _lengths; - } - - libtest::vchar_ptr_t& keys() - { - return _keys; - } - - size_t* lengths_ptr() - { - return &_lengths[0]; - } - - char** keys_ptr() - { - return &_keys[0]; - } - - char* key_at(size_t arg) - { - return _keys[arg]; - } - - size_t length_at(size_t arg) - { - return _lengths[arg]; - } - -private: - libtest::vchar_ptr_t _keys; - std::vector _lengths; -}; - -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; -} +#include "libmemcached/instance.h" static memcached_st * create_single_instance_memcached(const memcached_st *original_memc, const char *options) { @@ -284,20 +174,20 @@ test_return_t init_test(memcached_st *not_used) in_port_t test_ports[TEST_PORT_COUNT]; static memcached_return_t server_display_function(const memcached_st *ptr, - const memcached_server_st *server, + memcached_server_instance_st server, void *context) { /* Do Nothing */ size_t bigger= *((size_t *)(context)); (void)ptr; - assert(bigger <= memcached_server_port(server)); + fatal_assert(bigger <= memcached_server_port(server)); *((size_t *)(context))= memcached_server_port(server); return MEMCACHED_SUCCESS; } static memcached_return_t dump_server_information(const memcached_st *ptr, - const memcached_server_st *instance, + memcached_server_instance_st instance, void *context) { /* Do Nothing */ @@ -403,15 +293,15 @@ test_return_t memcached_server_remove_test(memcached_st*) } static memcached_return_t server_display_unsort_function(const memcached_st*, - const memcached_server_st *server, + memcached_server_instance_st server, void *context) { /* Do Nothing */ uint32_t x= *((uint32_t *)(context)); - if (! (test_ports[x] == server->port)) + if (! (test_ports[x] == memcached_server_port(server))) { - fprintf(stderr, "%lu -> %lu\n", (unsigned long)test_ports[x], (unsigned long)server->port); + fprintf(stderr, "%lu -> %lu\n", (unsigned long)test_ports[x], (unsigned long)memcached_server_port(server)); return MEMCACHED_FAILURE; } @@ -500,7 +390,7 @@ test_return_t clone_test(memcached_st *memc) test_true(memc_clone->flags.buffer_requests == memc->flags.buffer_requests); test_true(memc_clone->flags.use_sort_hosts == memc->flags.use_sort_hosts); test_true(memc_clone->flags.verify_key == memc->flags.verify_key); - test_true(memc_clone->ketama.weighted == memc->ketama.weighted); + 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.reply == memc->flags.reply); @@ -631,7 +521,7 @@ 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 or rc == MEMCACHED_BUFFERED, memcached_strerror(NULL, rc)); + test_true(rc == MEMCACHED_SUCCESS or rc == MEMCACHED_BUFFERED); return TEST_SUCCESS; } @@ -724,13 +614,14 @@ test_return_t memcached_mget_mixed_memcached_get_TEST(memcached_st *memc) for (libtest::vchar_ptr_t::iterator iter= keys.begin(); iter != keys.end(); - iter++) + ++iter) { - test_compare(MEMCACHED_SUCCESS, - memcached_set(memc, - (*iter), 36, - NULL, 0, - time_t(0), uint32_t(0))); + test_compare_hint(MEMCACHED_SUCCESS, + memcached_set(memc, + (*iter), 36, + NULL, 0, + time_t(0), uint32_t(0)), + memcached_last_error_message(memc)); } for (ptrdiff_t loop= 0; loop < 20; loop++) @@ -749,7 +640,7 @@ test_return_t memcached_mget_mixed_memcached_get_TEST(memcached_st *memc) { result_count++; } - test_compare(keys.size(), result_count); + test_true(keys.size() >= result_count); } else { @@ -759,7 +650,12 @@ test_return_t memcached_mget_mixed_memcached_get_TEST(memcached_st *memc) memcached_return_t rc; char *out_value= memcached_get(memc, keys.key_at(which_key), keys.length_at(which_key), &value_length, &flags, &rc); - test_compare(MEMCACHED_SUCCESS, rc); + if (rc == MEMCACHED_NOTFOUND) + { } // It is possible that the value has been purged. + else + { + test_compare(MEMCACHED_SUCCESS, rc); + } test_null(out_value); test_zero(value_length); test_zero(flags); @@ -908,27 +804,55 @@ test_return_t prepend_test(memcached_st *memc) return TEST_SUCCESS; } +/* + Set the value, then quit to make sure it is flushed. + Come back in and test that add fails. +*/ +test_return_t memcached_add_SUCCESS_TEST(memcached_st *memc) +{ + memcached_return_t rc; + test_null(memcached_get(memc, test_literal_param(__func__), NULL, NULL, &rc)); + test_compare(MEMCACHED_NOTFOUND, rc); + + test_compare(MEMCACHED_SUCCESS, + memcached_add(memc, + test_literal_param(__func__), + test_literal_param("try something else"), + time_t(0), uint32_t(0))); + + return TEST_SUCCESS; +} + /* Set the value, then quit to make sure it is flushed. Come back in and test that add fails. */ test_return_t add_test(memcached_st *memc) { - 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)); + 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))); memcached_quit(memc); - 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)); + size_t value_length; + uint32_t flags; + memcached_return_t rc; + char *check_value= memcached_get(memc, + test_literal_param(__func__), + &value_length, &flags, &rc); + test_memcmp(check_value, "when we sanitize", strlen("when we sanitize")); + test_compare(test_literal_param_size("when we sanitize"), value_length); + test_compare(MEMCACHED_SUCCESS, rc); + free(check_value); + + test_compare(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))); return TEST_SUCCESS; } @@ -951,7 +875,9 @@ test_return_t add_wrapper(memcached_st *memc) #endif for (uint32_t x= 0; x < max; x++) + { add_test(memc); + } return TEST_SUCCESS; } @@ -981,11 +907,10 @@ test_return_t delete_test(memcached_st *memc) test_literal_param("when we sanitize"), time_t(0), uint32_t(0))); - test_compare_hint(return_value_based_on_buffering(memc), - memcached_delete(memc, - test_literal_param(__func__), - time_t(0)), - memcached_last_error_message(memc)); + test_compare(return_value_based_on_buffering(memc), + memcached_delete(memc, + test_literal_param(__func__), + time_t(0))); return TEST_SUCCESS; } @@ -1001,7 +926,7 @@ test_return_t flush_test(memcached_st *memc) } static memcached_return_t server_function(const memcached_st *, - const memcached_server_st *, + memcached_server_instance_st, void *) { /* Do Nothing */ @@ -1062,7 +987,7 @@ test_return_t bad_key_test(memcached_st *memc) 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_compare(MEMCACHED_NOTFOUND, rc); test_zero(string_length); test_false(string); } @@ -1131,12 +1056,11 @@ test_return_t bad_key_test(memcached_st *memc) } #define READ_THROUGH_VALUE "set for me" -static memcached_return_t read_through_trigger(memcached_st *memc, - char *key, - size_t key_length, +static memcached_return_t read_through_trigger(memcached_st *, // memc + char *, // key + size_t, // key_length, memcached_result_st *result) { - (void)memc;(void)key;(void)key_length; return memcached_result_set_value(result, READ_THROUGH_VALUE, strlen(READ_THROUGH_VALUE)); } @@ -1167,8 +1091,8 @@ test_return_t read_through(memcached_st *memc) &string_length, &flags, &rc); test_compare(MEMCACHED_SUCCESS, rc); - test_compare(string_length, sizeof(READ_THROUGH_VALUE) -1); - test_true(string[sizeof(READ_THROUGH_VALUE) -1] == 0); + test_compare(sizeof(READ_THROUGH_VALUE) -1, string_length); + test_compare(0, string[sizeof(READ_THROUGH_VALUE) -1]); test_strcmp(READ_THROUGH_VALUE, string); free(string); @@ -1186,62 +1110,6 @@ test_return_t read_through(memcached_st *memc) return TEST_SUCCESS; } -test_return_t get_test(memcached_st *memc) -{ - uint64_t query_id= memcached_query_id(memc); - memcached_return_t rc= memcached_delete(memc, - test_literal_param(__func__), - time_t(0)); - test_true_hint(rc == MEMCACHED_BUFFERED or rc == MEMCACHED_NOTFOUND, memcached_last_error_message(memc)); - test_compare(query_id +1, memcached_query_id(memc)); - - size_t string_length; - uint32_t flags; - char *string= memcached_get(memc, - test_literal_param(__func__), - &string_length, &flags, &rc); - - test_compare_got(MEMCACHED_NOTFOUND, rc, memcached_last_error_message(memc)); - test_false(string_length); - test_false(string); - - return TEST_SUCCESS; -} - -test_return_t get_test2(memcached_st *memc) -{ - const char *value= "when we sanitize"; - - uint64_t query_id= memcached_query_id(memc); - 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); - test_true(query_id); - - uint32_t flags; - size_t string_length; - 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)); - - test_compare_got(MEMCACHED_SUCCESS, rc, memcached_strerror(NULL, rc)); - test_compare_got(MEMCACHED_SUCCESS, memcached_last_error(memc), memcached_last_error_message(memc)); - test_true(string); - test_compare(strlen(value), string_length); - test_memcmp(string, value, string_length); - - free(string); - - return TEST_SUCCESS; -} - test_return_t set_test2(memcached_st *memc) { for (uint32_t x= 0; x < 10; x++) @@ -1275,137 +1143,16 @@ test_return_t set_test3(memcached_st *memc) snprintf(key, sizeof(key), "foo%u", x); uint64_t query_id= memcached_query_id(memc); - 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(return_value_based_on_buffering(memc), + memcached_set(memc, key, strlen(key), + &value[0], value.size(), + time_t(0), uint32_t(0))); test_compare(query_id +1, memcached_query_id(memc)); } return TEST_SUCCESS; } -test_return_t get_test3(memcached_st *memc) -{ - size_t value_length= 8191; - - libtest::vchar_t value; - value.reserve(value_length); - for (uint32_t x= 0; x < value_length; x++) - { - value.push_back(char(x % 127)); - } - - 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; - 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(value.size(), string_length); - test_memcmp(string, &value[0], string_length); - - free(string); - - return TEST_SUCCESS; -} - -test_return_t get_test4(memcached_st *memc) -{ - size_t value_length= 8191; - - libtest::vchar_t value; - value.reserve(value_length); - for (uint32_t x= 0; x < value_length; x++) - { - value.push_back(char(x % 127)); - } - - 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; - 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(value.size(), string_length); - test_memcmp(string, &value[0], string_length); - free(string); - } - - return TEST_SUCCESS; -} - -/* - * This test verifies that memcached_read_one_response doesn't try to - * dereference a NIL-pointer if you issue a multi-get and don't read out all - * responses before you execute a storage command. - */ -test_return_t get_test5(memcached_st *memc) -{ - /* - ** Request the same key twice, to ensure that we hash to the same server - ** (so that we have multiple response values queued up) ;-) - */ - const char *keys[]= { "key", "key" }; - size_t lengths[]= { 3, 3 }; - uint32_t flags; - size_t rlen; - - 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); - - memcached_result_free(&results_obj); - - /* Don't read out the second result, but issue a set instead.. */ - test_compare(MEMCACHED_SUCCESS, memcached_set(memc, keys[0], lengths[0], keys[0], lengths[0], 0, 0)); - - char *val= memcached_get_by_key(memc, keys[0], lengths[0], "yek", 3, - &rlen, &flags, &rc); - test_false(val); - test_compare(MEMCACHED_NOTFOUND, rc); - val= memcached_get(memc, keys[0], lengths[0], &rlen, &flags, &rc); - test_true(val); - test_compare(MEMCACHED_SUCCESS, rc); - free(val); - - return TEST_SUCCESS; -} - test_return_t mget_end(memcached_st *memc) { const char *keys[]= { "foo", "foo2" }; @@ -1545,6 +1292,7 @@ test_return_t decrement_test(memcached_st *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)); @@ -1729,14 +1477,14 @@ test_return_t quit_test(memcached_st *memc) memcached_set(memc, test_literal_param(__func__), value, strlen(value), - (time_t)10, (uint32_t)3)); + time_t(10), uint32_t(3))); memcached_quit(memc); test_compare(return_value_based_on_buffering(memc), memcached_set(memc, test_literal_param(__func__), value, strlen(value), - (time_t)50, (uint32_t)9)); + time_t(50), uint32_t(9))); return TEST_SUCCESS; } @@ -1747,9 +1495,7 @@ test_return_t mget_result_test(memcached_st *memc) size_t key_length[]= {5, 3, 4}; memcached_result_st results_obj; - memcached_result_st *results; - - results= memcached_result_create(memc, &results_obj); + memcached_result_st *results= memcached_result_create(memc, &results_obj); test_true(results); test_true(&results_obj == results); @@ -1768,14 +1514,14 @@ test_return_t mget_result_test(memcached_st *memc) while ((results= memcached_fetch_result(memc, &results_obj, &rc))) { test_true(false); /* We should never see a value returned */ }; test_false(results); - test_compare_got(MEMCACHED_NOTFOUND, rc, memcached_strerror(NULL, rc)); + test_compare(MEMCACHED_NOTFOUND, rc); 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_true_got(rc == MEMCACHED_SUCCESS or rc == MEMCACHED_BUFFERED, memcached_strerror(NULL, rc)); + test_true(rc == MEMCACHED_SUCCESS or rc == MEMCACHED_BUFFERED); } test_compare(MEMCACHED_SUCCESS, @@ -1817,14 +1563,14 @@ test_return_t mget_result_alloc_test(memcached_st *memc) test_true(results); } test_false(results); - test_compare_got(MEMCACHED_NOTFOUND, rc, memcached_strerror(NULL, rc)); + test_compare(MEMCACHED_NOTFOUND, rc); 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_true_got(rc == MEMCACHED_SUCCESS or rc == MEMCACHED_BUFFERED, memcached_strerror(NULL, rc)); + test_true(rc == MEMCACHED_SUCCESS or rc == MEMCACHED_BUFFERED); } test_compare(MEMCACHED_SUCCESS, @@ -1906,7 +1652,7 @@ 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_got(rc == MEMCACHED_SUCCESS or rc == MEMCACHED_BUFFERED, memcached_strerror(NULL, rc)); + test_true(rc == MEMCACHED_SUCCESS or rc == MEMCACHED_BUFFERED); } test_compare(MEMCACHED_SUCCESS, memcached_mget(memc, keys, key_length, 3)); @@ -1948,8 +1694,7 @@ test_return_t mget_execute(memcached_st *original_memc) keys.key_at(x), keys.length_at(x), blob, sizeof(blob), 0, 0); - test_true_got(rc == MEMCACHED_SUCCESS or rc == MEMCACHED_BUFFERED, - memcached_strerror(NULL, rc)); + test_true(rc == MEMCACHED_SUCCESS or rc == MEMCACHED_BUFFERED); test_compare(query_id +1, memcached_query_id(memc)); } @@ -1977,7 +1722,7 @@ test_return_t mget_execute(memcached_st *original_memc) } #define REGRESSION_BINARY_VS_BLOCK_COUNT 20480 -static pairs_st *global_pairs; +static pairs_st *global_pairs= NULL; test_return_t key_setup(memcached_st *memc) { @@ -1991,6 +1736,7 @@ test_return_t key_setup(memcached_st *memc) test_return_t key_teardown(memcached_st *) { pairs_free(global_pairs); + global_pairs= NULL; return TEST_SUCCESS; } @@ -2000,10 +1746,16 @@ test_return_t block_add_regression(memcached_st *memc) /* First add all of the items.. */ for (ptrdiff_t x= 0; x < REGRESSION_BINARY_VS_BLOCK_COUNT; ++x) { - char blob[1024] = {0}; + libtest::vchar_t blob; + libtest::vchar::make(blob, 1024); - memcached_return_t rc= memcached_add_by_key(memc, "bob", 3, global_pairs[x].key, global_pairs[x].key_length, blob, sizeof(blob), 0, 0); - test_true_got(rc == MEMCACHED_SUCCESS or rc == MEMCACHED_SERVER_MEMORY_ALLOCATION_FAILURE, memcached_strerror(NULL, rc)); + memcached_return_t rc= memcached_add_by_key(memc, + test_literal_param("bob"), + global_pairs[x].key, global_pairs[x].key_length, + &blob[0], blob.size(), + time_t(0), uint32_t(0)); + test_compare(*memc, MEMCACHED_SUCCESS); + test_compare(rc, MEMCACHED_SUCCESS); } return TEST_SUCCESS; @@ -2012,9 +1764,7 @@ test_return_t block_add_regression(memcached_st *memc) test_return_t binary_add_regression(memcached_st *memc) { test_skip(MEMCACHED_SUCCESS, memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL, true)); - test_return_t rc= block_add_regression(memc); - - return rc; + return block_add_regression(memc); } test_return_t get_stats_keys(memcached_st *memc) @@ -2102,7 +1852,7 @@ test_return_t memcached_fetch_result_NOT_FOUND(memcached_st *memc) memcached_result_st *result= memcached_fetch_result(memc, NULL, &rc); test_null(result); - test_compare_got(MEMCACHED_NOTFOUND, rc, memcached_strerror(NULL, rc)); + test_compare(MEMCACHED_NOTFOUND, rc); memcached_result_free(result); @@ -2396,7 +2146,7 @@ test_return_t user_supplied_bug6(memcached_st *memc) count++; } test_zero(count); - test_compare_got(MEMCACHED_NOTFOUND, rc, memcached_strerror(NULL, rc)); + test_compare(MEMCACHED_NOTFOUND, rc); for (uint32_t x= 0; x < test_array_length(keys); x++) { @@ -2477,10 +2227,9 @@ test_return_t user_supplied_bug7(memcached_st *memc) 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)); + test_compare(MEMCACHED_SUCCESS, memcached_set(memc, keys, key_length, + insert_data, VALUE_SIZE_BUG5, + time_t(0), 245U)); memcached_return_t rc; size_t value_length; @@ -2576,9 +2325,8 @@ test_return_t user_supplied_bug10(memcached_st *memc) &value[0], value.size(), 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 - or rc == MEMCACHED_SERVER_TEMPORARILY_DISABLED), - memcached_strerror(NULL, rc)); + test_true((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)); if (rc == MEMCACHED_WRITE_FAILURE or rc == MEMCACHED_TIMEOUT) { @@ -2731,7 +2479,7 @@ test_return_t user_supplied_bug14(memcached_st *memc) test_compare(string_length, current_length); char buffer[1024]; snprintf(buffer, sizeof(buffer), "%u", uint32_t(string_length)); - test_memcmp_hint(string, &value[0], string_length, buffer); + test_memcmp(string, &value[0], string_length); free(string); } @@ -2777,10 +2525,9 @@ test_return_t user_supplied_bug15(memcached_st *memc) /* Check the return sizes on FLAGS to make sure it stores 32bit unsigned values correctly */ test_return_t user_supplied_bug16(memcached_st *memc) { - 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, memcached_set(memc, test_literal_param("mykey"), + NULL, 0, + (time_t)0, UINT32_MAX)); size_t length; @@ -2814,7 +2561,7 @@ test_return_t user_supplied_bug17(memcached_st *memc) char *value2= memcached_get(memc, key, strlen(key), &length, &flags, &rc); - test_true(length==strlen(value)); + test_compare(length, strlen(value)); test_compare(MEMCACHED_SUCCESS, rc); test_memcmp(value, value2, length); free(value2); @@ -2833,7 +2580,7 @@ test_return_t user_supplied_bug19(memcached_st *) memcached_st *memc= memcached(test_literal_param("--server=localhost:11311/?100 --server=localhost:11312/?100")); - const memcached_server_st *server= memcached_server_by_key(memc, "a", 1, &res); + memcached_server_instance_st server= memcached_server_by_key(memc, "a", 1, &res); test_true(server); memcached_free(memc); @@ -2884,7 +2631,7 @@ test_return_t user_supplied_bug20(memcached_st *memc) /* sighandler_t function that always asserts false */ static void fail(int) { - assert(0); + fatal_assert(0); } @@ -3320,20 +3067,21 @@ test_return_t set_memory_alloc(memcached_st *memc) test_return_t enable_consistent_crc(memcached_st *memc) { + test_compare(MEMCACHED_SUCCESS, memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_DISTRIBUTION, MEMCACHED_DISTRIBUTION_CONSISTENT)); + test_compare(memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_DISTRIBUTION), uint64_t(MEMCACHED_DISTRIBUTION_CONSISTENT)); + test_return_t rc; - memcached_server_distribution_t value= MEMCACHED_DISTRIBUTION_CONSISTENT; - memcached_hash_t hash; - memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_DISTRIBUTION, value); if ((rc= pre_crc(memc)) != TEST_SUCCESS) + { return rc; + } - value= (memcached_server_distribution_t)memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_DISTRIBUTION); - test_true(value == MEMCACHED_DISTRIBUTION_CONSISTENT); - - hash= (memcached_hash_t)memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_HASH); + test_compare(memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_DISTRIBUTION), uint64_t(MEMCACHED_DISTRIBUTION_CONSISTENT)); - if (hash != MEMCACHED_HASH_CRC) + if (memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_HASH) != MEMCACHED_HASH_CRC) + { return TEST_SKIPPED; + } return TEST_SUCCESS; } @@ -3341,33 +3089,27 @@ test_return_t enable_consistent_crc(memcached_st *memc) test_return_t enable_consistent_hsieh(memcached_st *memc) { test_return_t rc; - memcached_server_distribution_t value= MEMCACHED_DISTRIBUTION_CONSISTENT; - memcached_hash_t hash; - memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_DISTRIBUTION, value); + memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_DISTRIBUTION, MEMCACHED_DISTRIBUTION_CONSISTENT); 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); - - hash= (memcached_hash_t)memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_HASH); + test_compare(memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_DISTRIBUTION), uint64_t(MEMCACHED_DISTRIBUTION_CONSISTENT)); - if (hash != MEMCACHED_HASH_HSIEH) + if (memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_HASH) != MEMCACHED_HASH_HSIEH) + { return TEST_SKIPPED; - + } return TEST_SUCCESS; } test_return_t enable_cas(memcached_st *memc) { - unsigned int set= 1; - if (libmemcached_util_version_check(memc, 1, 2, 4)) { - memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_SUPPORT_CAS, set); + memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_SUPPORT_CAS, true); return TEST_SUCCESS; } @@ -3484,7 +3226,12 @@ test_return_t noreply_test(memcached_st *memc) uint32_t flags; char* value=memcached_get(memc, key, strlen(key), &length, &flags, &ret); - test_true_got(ret == MEMCACHED_SUCCESS && value != NULL, memcached_strerror(NULL, ret)); + // For the moment we will just go to the next key + if (MEMCACHED_TIMEOUT == ret) + { + continue; + } + test_true(ret == MEMCACHED_SUCCESS and value != NULL); switch (count) { case 0: /* FALLTHROUGH */ @@ -3565,7 +3312,7 @@ test_return_t analyzer_test(memcached_st *memc) test_return_t util_version_test(memcached_st *memc) { - test_compare_hint(MEMCACHED_SUCCESS, memcached_version(memc), memcached_last_error_message(memc)); + test_compare(MEMCACHED_SUCCESS, memcached_version(memc)); test_true(libmemcached_util_version_check(memc, 0, 0, 0)); bool if_successful= libmemcached_util_version_check(memc, 9, 9, 9); @@ -3661,20 +3408,32 @@ test_return_t getpid_test(memcached_st *memc) return TEST_SUCCESS; } -test_return_t ping_test(memcached_st *memc) +static memcached_return_t ping_each_server(const memcached_st*, + memcached_server_instance_st instance, + void*) { + // Test both the version that returns a code, and the one that does not. memcached_return_t rc; - memcached_server_instance_st instance= - memcached_server_instance_by_position(memc, 0); + if (libmemcached_util_ping(memcached_server_name(instance), + memcached_server_port(instance), &rc) == false) + { + throw libtest::fatal(LIBYATL_DEFAULT_PARAM, "%s:%d %s", memcached_server_name(instance), + memcached_server_port(instance), memcached_strerror(NULL, rc)); + } - // Test both the version that returns a code, and the one that does not. - test_true(libmemcached_util_ping(memcached_server_name(instance), - memcached_server_port(instance), NULL)); + if (libmemcached_util_ping(memcached_server_name(instance), + memcached_server_port(instance), NULL) == false) + { + throw libtest::fatal(LIBYATL_DEFAULT_PARAM, "%s:%d", memcached_server_name(instance), memcached_server_port(instance)); + } - test_true(libmemcached_util_ping(memcached_server_name(instance), - memcached_server_port(instance), &rc)); + return MEMCACHED_SUCCESS; +} - test_compare(MEMCACHED_SUCCESS, rc); +test_return_t libmemcached_util_ping_TEST(memcached_st *memc) +{ + memcached_server_fn callbacks[1]= { ping_each_server }; + memcached_server_cursor(memc, callbacks, NULL, 1); return TEST_SUCCESS; } @@ -4285,11 +4044,11 @@ test_return_t regression_bug_447342(memcached_st *memc) */ memcached_server_instance_st instance_one= memcached_server_instance_by_position(memc, 0); memcached_server_instance_st instance_two= memcached_server_instance_by_position(memc, 2); - in_port_t port0= instance_one->port; - in_port_t port2= instance_two->port; + in_port_t port0= instance_one->port(); + in_port_t port2= instance_two->port(); - ((memcached_server_write_instance_st)instance_one)->port= 0; - ((memcached_server_write_instance_st)instance_two)->port= 0; + ((memcached_server_write_instance_st)instance_one)->port(0); + ((memcached_server_write_instance_st)instance_two)->port(0); test_compare(MEMCACHED_SUCCESS, memcached_mget(memc, @@ -4301,8 +4060,8 @@ test_return_t regression_bug_447342(memcached_st *memc) test_compare(counter, keys.size()); /* restore the memc handle */ - ((memcached_server_write_instance_st)instance_one)->port= port0; - ((memcached_server_write_instance_st)instance_two)->port= port2; + ((memcached_server_write_instance_st)instance_one)->port(port0); + ((memcached_server_write_instance_st)instance_two)->port(port2); memcached_quit(memc); @@ -4317,8 +4076,8 @@ test_return_t regression_bug_447342(memcached_st *memc) } memcached_quit(memc); - ((memcached_server_write_instance_st)instance_one)->port= 0; - ((memcached_server_write_instance_st)instance_two)->port= 0; + ((memcached_server_write_instance_st)instance_one)->port(0); + ((memcached_server_write_instance_st)instance_two)->port(0); /* now retry the command, this time we should have cache misses */ test_compare(MEMCACHED_SUCCESS, @@ -4331,8 +4090,8 @@ test_return_t regression_bug_447342(memcached_st *memc) test_compare(counter, (unsigned int)(keys.size() >> 1)); /* restore the memc handle */ - ((memcached_server_write_instance_st)instance_one)->port= port0; - ((memcached_server_write_instance_st)instance_two)->port= port2; + ((memcached_server_write_instance_st)instance_one)->port(port0); + ((memcached_server_write_instance_st)instance_two)->port(port2); return TEST_SUCCESS; } @@ -4616,6 +4375,34 @@ test_return_t wrong_failure_counter_two_test(memcached_st *memc) return TEST_SUCCESS; } +test_return_t regression_996813_TEST(memcached_st *) +{ + memcached_st* memc= memcached_create(NULL); + + test_compare(MEMCACHED_SUCCESS, memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_DISTRIBUTION, MEMCACHED_DISTRIBUTION_CONSISTENT_KETAMA)); + 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_BINARY_PROTOCOL, 1)); + test_compare(MEMCACHED_SUCCESS, memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_POLL_TIMEOUT, 1)); + test_compare(MEMCACHED_SUCCESS, memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_CONNECT_TIMEOUT, 300)); + test_compare(MEMCACHED_SUCCESS, memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_RETRY_TIMEOUT, 30)); + + // We will never connect to these servers + in_port_t base_port= 11211; + for (size_t x= 0; x < 17; x++) + { + test_compare(MEMCACHED_SUCCESS, memcached_server_add(memc, "10.2.3.4", base_port +x)); + } + test_compare(6U, memcached_generate_hash(memc, test_literal_param("SZ6hu0SHweFmpwpc0w2R"))); + test_compare(1U, memcached_generate_hash(memc, test_literal_param("SQCK9eiCf53YxHWnYA.o"))); + test_compare(9U, memcached_generate_hash(memc, test_literal_param("SUSDkGXuuZC9t9VhMwa."))); + test_compare(0U, memcached_generate_hash(memc, test_literal_param("SnnqnJARfaCNT679iAF_"))); + + memcached_free(memc); + + return TEST_SUCCESS; +} + /* * Test that ensures mget_execute does not end into recursive calls that finally fails @@ -4687,6 +4474,27 @@ test_return_t regression_bug_490486(memcached_st *original_memc) return TEST_SUCCESS; } +test_return_t regression_1021819_TEST(memcached_st *original) +{ + memcached_st *memc= memcached_clone(NULL, original); + test_true(memc); + + test_compare(memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_SND_TIMEOUT, 2000000), MEMCACHED_SUCCESS); + test_compare(memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_RCV_TIMEOUT, 3000000), MEMCACHED_SUCCESS); + + memcached_return_t rc; + + memcached_get(memc, + test_literal_param(__func__), + NULL, NULL, &rc); + + test_compare(rc, MEMCACHED_NOTFOUND); + + memcached_free(memc); + + return TEST_SUCCESS; +} + test_return_t regression_bug_583031(memcached_st *) { memcached_st *memc= memcached_create(NULL); @@ -4828,6 +4636,65 @@ test_return_t regression_bug_490520(memcached_st *original_memc) return TEST_SUCCESS; } +test_return_t regression_1009493_TEST(memcached_st*) +{ + memcached_st* memc= memcached_create(NULL); + test_true(memc); + test_compare(MEMCACHED_SUCCESS, memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_KETAMA, true)); + + memcached_st* clone= memcached_clone(NULL, memc); + test_true(clone); + + test_compare(memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_KETAMA_WEIGHTED), + memcached_behavior_get(clone, MEMCACHED_BEHAVIOR_KETAMA_WEIGHTED)); + + memcached_free(memc); + memcached_free(clone); + + return TEST_SUCCESS; +} + +test_return_t regression_994772_TEST(memcached_st* memc) +{ + test_skip(MEMCACHED_SUCCESS, memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL, 1)); + + test_compare(MEMCACHED_SUCCESS, + memcached_set(memc, + test_literal_param(__func__), // Key + test_literal_param(__func__), // Value + time_t(0), uint32_t(0))); + + const char *keys[] = { __func__ }; + size_t key_length[]= { strlen(__func__) }; + test_compare(MEMCACHED_SUCCESS, + memcached_mget(memc, keys, key_length, 1)); + + memcached_return_t rc; + memcached_result_st *results= memcached_fetch_result(memc, NULL, &rc); + test_true(results); + test_compare(MEMCACHED_SUCCESS, rc); + + test_strcmp(__func__, memcached_result_value(results)); + uint64_t cas_value= memcached_result_cas(results); + test_true(cas_value); + + memcached_result_free(results); + + // Bad cas value, sanity check + test_true(cas_value != 9999); + test_compare(MEMCACHED_END, + memcached_cas(memc, + test_literal_param(__func__), // Key + test_literal_param(__FILE__), // Value + time_t(0), uint32_t(0), 9999)); + + test_compare(MEMCACHED_SUCCESS, memcached_set(memc, + "different", strlen("different"), // Key + test_literal_param(__FILE__), // Value + time_t(0), uint32_t(0))); + + return TEST_SUCCESS; +} test_return_t regression_bug_854604(memcached_st *) { @@ -4849,7 +4716,7 @@ test_return_t regression_bug_854604(memcached_st *) return TEST_SUCCESS; } -static void memcached_die(memcached_st* mc, memcached_return error, const char* what, uint32_t it) +static void die_message(memcached_st* mc, memcached_return error, const char* what, uint32_t it) { fprintf(stderr, "Iteration #%u: ", it); @@ -4885,19 +4752,19 @@ test_return_t regression_bug_(memcached_st *memc) rc= memcached_behavior_set(mc, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL, 1); if (rc != MEMCACHED_SUCCESS) { - memcached_die(mc, rc, "memcached_behavior_set", x); + die_message(mc, rc, "memcached_behavior_set", x); } rc= memcached_behavior_set(mc, MEMCACHED_BEHAVIOR_CACHE_LOOKUPS, 1); if (rc != MEMCACHED_SUCCESS) { - memcached_die(mc, rc, "memcached_behavior_set", x); + die_message(mc, rc, "memcached_behavior_set", x); } rc= memcached_server_add(mc, remote_server, 0); if (rc != MEMCACHED_SUCCESS) { - memcached_die(mc, rc, "memcached_server_add", x); + die_message(mc, rc, "memcached_server_add", x); } const char *set_key= "akey"; @@ -4917,7 +4784,7 @@ test_return_t regression_bug_(memcached_st *memc) &get_value_flags, &rc); if (rc != MEMCACHED_SUCCESS) { - memcached_die(mc, rc, "memcached_get", x); + die_message(mc, rc, "memcached_get", x); } else { @@ -4941,7 +4808,7 @@ test_return_t regression_bug_(memcached_st *memc) ); if (rc != MEMCACHED_SUCCESS) { - memcached_die(mc, rc, "memcached_set", x); + die_message(mc, rc, "memcached_set", x); } } @@ -4976,7 +4843,7 @@ test_return_t kill_HUP_TEST(memcached_st *original_memc) 0, 0)); test_true_got(kill(pid, SIGHUP) == 0, strerror(errno)); - test_compare(MEMCACHED_SUCCESS, + test_compare(MEMCACHED_CONNECTION_FAILURE, memcached_set(memc, test_literal_param(__func__), // Keys test_literal_param(__func__), // Values