X-Git-Url: https://git.m6w6.name/?a=blobdiff_plain;f=tests%2Flibmemcached-1.0%2Fmem_functions.cc;h=ff0455da3be3ccbd68fbefe96669280b56d68bda;hb=b5536bea274b350239bcba9cb84a18586a74a2d3;hp=dd2abef27d18de63078e232672f244707fe826d4;hpb=324548f9250e1c0ad5814f1436e401ad989c84f3;p=awesomized%2Flibmemcached diff --git a/tests/libmemcached-1.0/mem_functions.cc b/tests/libmemcached-1.0/mem_functions.cc index dd2abef2..ff0455da 100644 --- a/tests/libmemcached-1.0/mem_functions.cc +++ b/tests/libmemcached-1.0/mem_functions.cc @@ -38,6 +38,10 @@ #include #include +#if defined(HAVE_LIBUUID) && HAVE_LIBUUID +#include +#endif + /* Test cases */ @@ -64,7 +68,6 @@ #include #include "clients/generator.h" -#include "clients/execute.h" #define SMALL_STRING_LEN 1024 @@ -78,6 +81,11 @@ #include "tests/ketama.h" #include "tests/namespace.h" #include "tests/parser.h" +#include "tests/libmemcached-1.0/dump.h" +#include "tests/libmemcached-1.0/generate.h" +#include "tests/libmemcached-1.0/fetch_all_results.h" +#include "tests/libmemcached-1.0/haldenbrand.h" +#include "tests/libmemcached-1.0/stat.h" #include "tests/touch.h" #include "tests/callbacks.h" #include "tests/pool.h" @@ -92,14 +100,111 @@ using namespace libtest; #include "tests/hash_results.h" -#define GLOBAL_COUNT 10000 -#define GLOBAL2_COUNT 100 -#define SERVERS_TO_CREATE 5 -static uint32_t global_count= GLOBAL2_COUNT; +#include "tests/libmemcached-1.0/servers_to_create.h" -static pairs_st *global_pairs; -static const char *global_keys[GLOBAL_COUNT]; -static size_t global_keys_length[GLOBAL_COUNT]; +#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) + { + uuid_t out; + uuid_generate(out); + + uuid_unparse(out, &key_buffer[0]); + _keys[x]= strdup(&key_buffer[0]); + } + 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; +}; /** @note This should be testing to see if the server really supports the binary protocol. @@ -465,7 +570,7 @@ static test_return_t libmemcached_string_behavior_test(memcached_st *) { test_true(libmemcached_string_behavior(memcached_behavior_t(x))); } - test_compare(36, int(MEMCACHED_BEHAVIOR_MAX)); + test_compare(37, int(MEMCACHED_BEHAVIOR_MAX)); return TEST_SUCCESS; } @@ -485,7 +590,7 @@ static test_return_t memcached_return_t_TEST(memcached_st *memc) { uint32_t values[] = { 851992627U, 2337886783U, 4109241422U, 4001849190U, 982370485U, 1263635348U, 4242906218U, 3829656100U, - 1891735253U, 334139633U, 2257084983U, 3088286104U, + 1891735253U, 334139633U, 2257084983U, 3351789013U, 13199785U, 2542027183U, 1097051614U, 199566778U, 2748246961U, 2465192557U, 1664094137U, 2405439045U, 1842224848U, 692413798U, 3479807801U, 919913813U, @@ -609,6 +714,57 @@ static test_return_t append_binary_test(memcached_st *memc) return TEST_SUCCESS; } +static test_return_t memcached_mget_mixed_memcached_get_TEST(memcached_st *memc) +{ + keys_st keys(200); + + for (libtest::vchar_ptr_t::iterator iter= keys.begin(); + iter != keys.end(); + iter++) + { + test_compare(MEMCACHED_SUCCESS, + memcached_set(memc, + (*iter), 36, + NULL, 0, + time_t(0), uint32_t(0))); + } + + for (size_t loop= 0; loop < 20; loop++) + { + if (random() %2) + { + test_compare(MEMCACHED_SUCCESS, + memcached_mget(memc, keys.keys_ptr(), keys.lengths_ptr(), keys.size())); + + memcached_result_st *results= memcached_result_create(memc, NULL); + test_true(results); + + size_t result_count= 0; + memcached_return_t rc; + while (memcached_fetch_result(memc, results, &rc)) + { + result_count++; + } + test_compare(keys.size(), result_count); + } + else + { + int which_key= random() %keys.size(); + size_t value_length; + uint32_t flags; + 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); + test_null(out_value); + test_zero(value_length); + test_zero(flags); + } + } + + return TEST_SUCCESS; +} + static test_return_t cas2_test(memcached_st *memc) { const char *keys[]= {"fudge", "son", "food"}; @@ -880,7 +1036,7 @@ static test_return_t bad_key_test(memcached_st *memc) test_compare(query_id, memcached_query_id(memc_clone)); // We should not increase the query_id for memcached_behavior_set() /* All keys are valid in the binary protocol (except for length) */ - if (not memcached_behavior_get(memc_clone, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL)) + if (memcached_behavior_get(memc_clone, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL) == false) { uint64_t before_query_id= memcached_query_id(memc_clone); { @@ -920,7 +1076,8 @@ static test_return_t bad_key_test(memcached_st *memc) test_compare(query_id +1, memcached_query_id(memc_clone)); query_id= memcached_query_id(memc_clone); - test_compare(MEMCACHED_BAD_KEY_PROVIDED, + // Grouping keys are not required to follow normal key behaviors + test_compare(MEMCACHED_SUCCESS, memcached_mget_by_key(memc_clone, "foo daddy", 9, keys, key_lengths, 1)); test_compare(query_id +1, memcached_query_id(memc_clone)); @@ -931,9 +1088,9 @@ static test_return_t bad_key_test(memcached_st *memc) test_compare(MEMCACHED_SUCCESS, memcached_callback_set(memc_clone, MEMCACHED_CALLBACK_NAMESPACE, NULL)); - std::vector longkey; + libtest::vchar_t longkey; { - std::vector::iterator it= longkey.begin(); + libtest::vchar_t::iterator it= longkey.begin(); longkey.insert(it, MEMCACHED_MAX_KEY, 'a'); } @@ -1101,7 +1258,7 @@ static test_return_t set_test3(memcached_st *memc) { size_t value_length= 8191; - std::vector value; + libtest::vchar_t value; value.reserve(value_length); for (uint32_t x= 0; x < value_length; x++) { @@ -1131,7 +1288,7 @@ static test_return_t get_test3(memcached_st *memc) { size_t value_length= 8191; - std::vector value; + libtest::vchar_t value; value.reserve(value_length); for (uint32_t x= 0; x < value_length; x++) { @@ -1166,7 +1323,7 @@ static test_return_t get_test4(memcached_st *memc) { size_t value_length= 8191; - std::vector value; + libtest::vchar_t value; value.reserve(value_length); for (uint32_t x= 0; x < value_length; x++) { @@ -1536,11 +1693,9 @@ static test_return_t decrement_with_initial_by_key_test(memcached_st *memc) return TEST_SUCCESS; } -static test_return_t binary_increment_with_prefix_test(memcached_st *orig_memc) +static test_return_t binary_increment_with_prefix_test(memcached_st *memc) { - memcached_st *memc= memcached_clone(NULL, orig_memc); - - test_skip(TEST_SUCCESS, pre_binary(memc)); + test_skip(true, memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL)); test_compare(MEMCACHED_SUCCESS, memcached_callback_set(memc, MEMCACHED_CALLBACK_PREFIX_KEY, (void *)"namespace:")); @@ -1560,7 +1715,6 @@ static test_return_t binary_increment_with_prefix_test(memcached_st *orig_memc) test_literal_param("number"), 1, &new_number)); test_compare(uint64_t(2), new_number); - memcached_free(memc); return TEST_SUCCESS; } @@ -1843,6 +1997,7 @@ static test_return_t mget_execute(memcached_st *original_memc) } #define REGRESSION_BINARY_VS_BLOCK_COUNT 20480 +static pairs_st *global_pairs; static test_return_t key_setup(memcached_st *memc) { @@ -2115,164 +2270,6 @@ static test_return_t MEMCACHED_BEHAVIOR_TCP_KEEPIDLE_test(memcached_st *memc) return TEST_SUCCESS; } -static test_return_t fetch_all_results(memcached_st *memc, unsigned int &keys_returned, memcached_return_t& rc) -{ - keys_returned= 0; - - memcached_result_st* result= NULL; - while ((result= memcached_fetch_result(memc, result, &rc))) - { - test_compare(MEMCACHED_SUCCESS, rc); - keys_returned+= 1; - } - memcached_result_free(result); - - return TEST_SUCCESS; -} - -static test_return_t fetch_all_results(memcached_st *memc, unsigned int &keys_returned) -{ - memcached_return_t rc; - return fetch_all_results(memc, keys_returned, rc); -} - -/* Test case provided by Cal Haldenbrand */ -#define HALDENBRAND_KEY_COUNT 3000U // * 1024576 -#define HALDENBRAND_FLAG_KEY 99 // * 1024576 -static test_return_t user_supplied_bug1(memcached_st *memc) -{ - /* We just keep looking at the same values over and over */ - srandom(10); - - test_compare(MEMCACHED_SUCCESS, - memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_NO_BLOCK, true)); - test_compare(MEMCACHED_SUCCESS, - memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_TCP_NODELAY, true)); - - - /* add key */ - unsigned long long total= 0; - for (uint32_t x= 0 ; total < 20 * 1024576 ; x++ ) - { - uint32_t size= (uint32_t)(rand() % ( 5 * 1024 ) ) + 400; - char randomstuff[6 * 1024]; - memset(randomstuff, 0, 6 * 1024); - test_true(size < 6 * 1024); /* Being safe here */ - - for (uint32_t j= 0 ; j < size ;j++) - { - randomstuff[j] = (signed char) ((rand() % 26) + 97); - } - - total+= size; - char key[MEMCACHED_MAXIMUM_INTEGER_DISPLAY_LENGTH +1]; - int key_length= snprintf(key, sizeof(key), "%u", x); - test_compare(MEMCACHED_SUCCESS, - memcached_set(memc, key, key_length, - randomstuff, strlen(randomstuff), - time_t(0), HALDENBRAND_FLAG_KEY)); - } - test_true(total > HALDENBRAND_KEY_COUNT); - - return TEST_SUCCESS; -} - -/* Test case provided by Cal Haldenbrand */ -static test_return_t user_supplied_bug2(memcached_st *memc) -{ - test_compare(MEMCACHED_SUCCESS, - memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_NO_BLOCK, true)); - - test_compare(MEMCACHED_SUCCESS, - memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_TCP_NODELAY, true)); - -#ifdef NOT_YET - test_compare(MEMCACHED_SUCCESS, memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_SOCKET_SEND_SIZE, 20 * 1024576)); - test_compare(MEMCACHED_SUCCESS, memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_SOCKET_RECV_SIZE, 20 * 1024576)); - getter = memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_SOCKET_SEND_SIZE); - getter = memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_SOCKET_RECV_SIZE); - - for (x= 0, errors= 0; total < 20 * 1024576 ; x++) -#endif - - size_t total_value_length= 0; - for (uint32_t x= 0, errors= 0; total_value_length < 24576 ; x++) - { - uint32_t flags= 0; - size_t val_len= 0; - - char key[MEMCACHED_MAXIMUM_INTEGER_DISPLAY_LENGTH +1]; - int key_length= snprintf(key, sizeof(key), "%u", x); - - memcached_return_t rc; - char *getval= memcached_get(memc, key, key_length, &val_len, &flags, &rc); - if (memcached_failed(rc)) - { - if (rc == MEMCACHED_NOTFOUND) - { - errors++; - } - else - { - test_true(rc); - } - - continue; - } - test_compare(uint32_t(HALDENBRAND_FLAG_KEY), flags); - test_true(getval); - - total_value_length+= val_len; - errors= 0; - ::free(getval); - } - - return TEST_SUCCESS; -} - -/* Do a large mget() over all the keys we think exist */ -static test_return_t user_supplied_bug3(memcached_st *memc) -{ - test_compare(MEMCACHED_SUCCESS, memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_NO_BLOCK, true)); - test_compare(MEMCACHED_SUCCESS, memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_TCP_NODELAY, true)); - -#ifdef NOT_YET - memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_SOCKET_SEND_SIZE, 20 * 1024576); - memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_SOCKET_RECV_SIZE, 20 * 1024576); - getter = memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_SOCKET_SEND_SIZE); - getter = memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_SOCKET_RECV_SIZE); -#endif - - std::vector key_lengths; - key_lengths.resize(HALDENBRAND_KEY_COUNT); - std::vector keys; - keys.resize(key_lengths.size()); - for (uint32_t x= 0; x < key_lengths.size(); x++) - { - char key[MEMCACHED_MAXIMUM_INTEGER_DISPLAY_LENGTH +1]; - int key_length= snprintf(key, sizeof(key), "%u", x); - test_true(key_length > 0 and key_length < MEMCACHED_MAXIMUM_INTEGER_DISPLAY_LENGTH +1); - keys[x]= strdup(key); - key_lengths[x]= key_length; - } - - test_compare(MEMCACHED_SUCCESS, - memcached_mget(memc, &keys[0], &key_lengths[0], key_lengths.size())); - - unsigned int keys_returned; - test_compare(TEST_SUCCESS, fetch_all_results(memc, keys_returned)); - test_compare(HALDENBRAND_KEY_COUNT, keys_returned); - - for (std::vector::iterator iter= keys.begin(); - iter != keys.end(); - iter++) - { - ::free(*iter); - } - - return TEST_SUCCESS; -} - /* Make sure we behave properly if server list has no values */ static test_return_t user_supplied_bug4(memcached_st *memc) { @@ -2584,7 +2581,7 @@ static test_return_t user_supplied_bug10(memcached_st *memc) memcached_behavior_set(mclone, MEMCACHED_BEHAVIOR_TCP_NODELAY, set); memcached_behavior_set(mclone, MEMCACHED_BEHAVIOR_POLL_TIMEOUT, uint64_t(0)); - std::vector value; + libtest::vchar_t value; value.reserve(value_length); for (uint32_t x= 0; x < value_length; x++) { @@ -2627,7 +2624,7 @@ static test_return_t user_supplied_bug11(memcached_st *memc) test_compare(-1, int32_t(memcached_behavior_get(mclone, MEMCACHED_BEHAVIOR_POLL_TIMEOUT))); - std::vector value; + libtest::vchar_t value; value.reserve(512); for (unsigned int x= 0; x < 512; x++) { @@ -2695,27 +2692,24 @@ static test_return_t user_supplied_bug12(memcached_st *memc) static test_return_t user_supplied_bug13(memcached_st *memc) { char key[] = "key34567890"; - memcached_return_t rc; - size_t overflowSize; char commandFirst[]= "set key34567890 0 0 "; char commandLast[] = " \r\n"; /* first line of command sent to server */ size_t commandLength; - size_t testSize; commandLength = strlen(commandFirst) + strlen(commandLast) + 4; /* 4 is number of characters in size, probably 8196 */ - overflowSize = MEMCACHED_MAX_BUFFER - commandLength; + size_t overflowSize = MEMCACHED_MAX_BUFFER - commandLength; - for (testSize= overflowSize - 1; testSize < overflowSize + 1; testSize++) + for (size_t testSize= overflowSize - 1; testSize < overflowSize + 1; testSize++) { char *overflow= new (std::nothrow) char[testSize]; test_true(overflow); memset(overflow, 'x', testSize); - rc= memcached_set(memc, key, strlen(key), - overflow, testSize, 0, 0); - test_compare(MEMCACHED_SUCCESS, rc); + test_compare(MEMCACHED_SUCCESS, + memcached_set(memc, key, strlen(key), + overflow, testSize, 0, 0)); delete [] overflow; } @@ -2733,7 +2727,7 @@ static test_return_t user_supplied_bug14(memcached_st *memc) { memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_TCP_NODELAY, true); - std::vector value; + libtest::vchar_t value; value.reserve(18000); for (size_t x= 0; x < 18000; x++) { @@ -2789,7 +2783,7 @@ static test_return_t user_supplied_bug15(memcached_st *memc) &length, &flags, &rc); test_compare(MEMCACHED_SUCCESS, rc); - test_true(value == NULL); + test_null(value); test_zero(length); test_zero(flags); } @@ -2929,24 +2923,14 @@ static test_return_t _user_supplied_bug21(memcached_st* memc, size_t key_count) /* empty the cache to ensure misses (hence non-responses) */ test_compare(MEMCACHED_SUCCESS, memcached_flush(memc_clone, 0)); - std::vector key_lengths; - key_lengths.resize(key_count); - std::vector keys; - keys.resize(key_lengths.size()); - for (unsigned int x= 0; x < key_lengths.size(); x++) - { - char key[MEMCACHED_MAXIMUM_INTEGER_DISPLAY_LENGTH +1]; - int key_length= snprintf(key, sizeof(key), "%u", x); - test_true(key_length > 0 and key_length < MEMCACHED_MAXIMUM_INTEGER_DISPLAY_LENGTH +1); - keys[x]= strdup(key); - key_lengths[x]= key_length; - } + keys_st keys(key_count); oldalarm= signal(SIGALRM, fail); alarm(5); test_compare_got(MEMCACHED_SUCCESS, - memcached_mget(memc_clone, &keys[0], &key_lengths[0], key_count), memcached_last_error_message(memc_clone)); + memcached_mget(memc_clone, keys.keys_ptr(), keys.lengths_ptr(), keys.size()), + memcached_last_error_message(memc_clone)); alarm(0); signal(SIGALRM, oldalarm); @@ -2968,13 +2952,6 @@ static test_return_t _user_supplied_bug21(memcached_st* memc, size_t key_count) test_false(return_key[0]); test_false(return_value); - for (std::vector::iterator iter= keys.begin(); - iter != keys.end(); - iter++) - { - free(*iter); - } - memcached_free(memc_clone); return TEST_SUCCESS; @@ -3081,311 +3058,6 @@ static test_return_t result_alloc(memcached_st *memc) return TEST_SUCCESS; } -static test_return_t cleanup_pairs(memcached_st *memc) -{ - (void)memc; - pairs_free(global_pairs); - - return TEST_SUCCESS; -} - -static test_return_t generate_pairs(memcached_st *) -{ - global_pairs= pairs_generate(GLOBAL_COUNT, 400); - global_count= GLOBAL_COUNT; - - for (size_t x= 0; x < global_count; x++) - { - global_keys[x]= global_pairs[x].key; - global_keys_length[x]= global_pairs[x].key_length; - } - - return TEST_SUCCESS; -} - -static test_return_t generate_large_pairs(memcached_st *) -{ - global_pairs= pairs_generate(GLOBAL2_COUNT, MEMCACHED_MAX_BUFFER+10); - global_count= GLOBAL2_COUNT; - - for (size_t x= 0; x < global_count; x++) - { - global_keys[x]= global_pairs[x].key; - global_keys_length[x]= global_pairs[x].key_length; - } - - return TEST_SUCCESS; -} - -static test_return_t generate_data(memcached_st *memc) -{ - unsigned int check_execute= execute_set(memc, global_pairs, global_count); - - test_compare_warn_hint(global_count, check_execute, "Possible false, positive, memcached may have ejected key/value based on memory needs"); - - return TEST_SUCCESS; -} - -static test_return_t generate_data_with_stats(memcached_st *memc) -{ - unsigned int check_execute= execute_set(memc, global_pairs, global_count); - - test_compare(check_execute, global_count); - - // @todo hosts used size stats - memcached_return_t rc; - memcached_stat_st *stat_p= memcached_stat(memc, NULL, &rc); - test_true(stat_p); - - for (uint32_t host_index= 0; host_index < SERVERS_TO_CREATE; host_index++) - { - /* This test was changes so that "make test" would work properlly */ - 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); - } - test_true((unsigned long long)(stat_p + host_index)->bytes); - } - - memcached_stat_free(NULL, stat_p); - - return TEST_SUCCESS; -} -static test_return_t generate_buffer_data(memcached_st *memc) -{ - memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_BUFFER_REQUESTS, true); - generate_data(memc); - - return TEST_SUCCESS; -} - -static test_return_t get_read_count(memcached_st *memc) -{ - memcached_st *memc_clone= memcached_clone(NULL, memc); - test_true(memc_clone); - - memcached_server_add_with_weight(memc_clone, "localhost", 6666, 0); - - { - char *return_value; - size_t return_value_length; - uint32_t flags; - uint32_t count; - - for (size_t x= count= 0; x < global_count; x++) - { - memcached_return_t rc; - return_value= memcached_get(memc_clone, global_keys[x], global_keys_length[x], - &return_value_length, &flags, &rc); - if (rc == MEMCACHED_SUCCESS) - { - count++; - if (return_value) - { - free(return_value); - } - } - } - } - - memcached_free(memc_clone); - - return TEST_SUCCESS; -} - -static test_return_t get_read(memcached_st *memc) -{ - size_t keys_returned= 0; - for (size_t x= 0; x < global_count; x++) - { - size_t return_value_length; - uint32_t flags; - memcached_return_t rc; - char *return_value= memcached_get(memc, global_keys[x], global_keys_length[x], - &return_value_length, &flags, &rc); - /* - test_true(return_value); - test_compare(MEMCACHED_SUCCESS, rc); - */ - if (rc == MEMCACHED_SUCCESS && return_value) - { - keys_returned++; - free(return_value); - } - } - test_compare_warn_hint(global_count, keys_returned, "Possible false, positive, memcached may have ejected key/value based on memory needs"); - - return TEST_SUCCESS; -} - -static test_return_t mget_read(memcached_st *memc) -{ - - test_skip(true, bool(libmemcached_util_version_check(memc, 1, 4, 4))); - - test_compare(MEMCACHED_SUCCESS, - memcached_mget(memc, global_keys, global_keys_length, global_count)); - - // Go fetch the keys and test to see if all of them were returned - { - unsigned int keys_returned; - test_compare(TEST_SUCCESS, fetch_all_results(memc, keys_returned)); - test_true(keys_returned > 0); - test_compare_warn_hint(global_count, keys_returned, "Possible false, positive, memcached may have ejected key/value based on memory needs"); - } - - return TEST_SUCCESS; -} - -static test_return_t mget_read_result(memcached_st *memc) -{ - - test_skip(true, bool(libmemcached_util_version_check(memc, 1, 4, 4))); - - test_compare(MEMCACHED_SUCCESS, - memcached_mget(memc, global_keys, global_keys_length, global_count)); - - /* Turn this into a help function */ - { - 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))) - { - if (rc == MEMCACHED_IN_PROGRESS) - { - continue; - } - - test_true(results); - test_compare(MEMCACHED_SUCCESS, rc); - } - test_compare(MEMCACHED_END, rc); - - memcached_result_free(&results_obj); - } - - return TEST_SUCCESS; -} - -static test_return_t mget_read_internal_result(memcached_st *memc) -{ - - test_skip(true, bool(libmemcached_util_version_check(memc, 1, 4, 4))); - - test_compare(MEMCACHED_SUCCESS, - memcached_mget(memc, global_keys, global_keys_length, global_count)); - { - memcached_result_st *results= NULL; - memcached_return_t rc; - while ((results= memcached_fetch_result(memc, results, &rc))) - { - test_true(results); - test_compare(MEMCACHED_SUCCESS, rc); - } - test_compare(MEMCACHED_END, rc); - - memcached_result_free(results); - } - - return TEST_SUCCESS; -} - -static test_return_t mget_read_partial_result(memcached_st *memc) -{ - - test_skip(true, bool(libmemcached_util_version_check(memc, 1, 4, 4))); - - test_compare(MEMCACHED_SUCCESS, - memcached_mget(memc, global_keys, global_keys_length, global_count)); - - // We will scan for just one key - { - memcached_result_st results_obj; - memcached_result_st *results= memcached_result_create(memc, &results_obj); - - memcached_return_t rc; - results= memcached_fetch_result(memc, results, &rc); - test_true(results); - test_compare(MEMCACHED_SUCCESS, rc); - - memcached_result_free(&results_obj); - } - - // We already have a read happening, lets start up another one. - test_compare(MEMCACHED_SUCCESS, - memcached_mget(memc, global_keys, global_keys_length, global_count)); - { - 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))) - { - test_true(results); - test_compare(MEMCACHED_SUCCESS, rc); - } - test_compare(MEMCACHED_END, rc); - - memcached_result_free(&results_obj); - } - - return TEST_SUCCESS; -} - -static test_return_t mget_read_function(memcached_st *memc) -{ - test_skip(true, bool(libmemcached_util_version_check(memc, 1, 4, 4))); - - test_compare(MEMCACHED_SUCCESS, - memcached_mget(memc, global_keys, global_keys_length, global_count)); - - memcached_execute_fn callbacks[]= { &callback_counter }; - size_t counter= 0; - test_compare(MEMCACHED_SUCCESS, - memcached_fetch_execute(memc, callbacks, (void *)&counter, 1)); - - return TEST_SUCCESS; -} - -static test_return_t delete_generate(memcached_st *memc) -{ - size_t total= 0; - for (size_t x= 0; x < global_count; x++) - { - if (memcached_success(memcached_delete(memc, global_keys[x], global_keys_length[x], (time_t)0))) - { - total++; - } - } - test_compare_warn_hint(global_count, total, "Possible false, positive, memcached may have ejected key/value based on memory needs"); - - return TEST_SUCCESS; -} - -static test_return_t delete_buffer_generate(memcached_st *memc) -{ - memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_BUFFER_REQUESTS, true); - - size_t total= 0; - for (size_t x= 0; x < global_count; x++) - { - if (memcached_success(memcached_delete(memc, global_keys[x], global_keys_length[x], (time_t)0))) - { - total++; - } - } - test_compare_warn_hint(global_count, total, "Possible false, positive, memcached may have ejected key/value based on memory needs"); - - return TEST_SUCCESS; -} static test_return_t add_host_test1(memcached_st *memc) { @@ -3967,7 +3639,7 @@ static test_return_t noreply_test(memcached_st *memc) { for (size_t x= 0; x < 100; ++x) { - char key[10]; + char key[MEMCACHED_MAXIMUM_INTEGER_DISPLAY_LENGTH +1]; int check_length= (size_t)snprintf(key, sizeof(key), "%lu", (unsigned long)x); test_false((size_t)check_length >= sizeof(key) || check_length < 0); @@ -3994,7 +3666,8 @@ static test_return_t noreply_test(memcached_st *memc) test_true(count); break; } - test_true_got(ret == MEMCACHED_SUCCESS or ret == MEMCACHED_BUFFERED, memcached_strerror(NULL, ret)); + test_true_got(ret == MEMCACHED_SUCCESS or ret == MEMCACHED_BUFFERED, + memcached_strerror(NULL, ret)); } /* @@ -4002,6 +3675,7 @@ static test_return_t noreply_test(memcached_st *memc) ** API and is _ONLY_ done this way to verify that the library works the ** way it is supposed to do!!!! */ +#if 0 int no_msg=0; for (uint32_t x= 0; x < memcached_server_count(memc); ++x) { @@ -4011,6 +3685,7 @@ static test_return_t noreply_test(memcached_st *memc) } test_true(no_msg == 0); +#endif test_compare(MEMCACHED_SUCCESS, memcached_flush_buffers(memc)); /* @@ -4091,8 +3766,8 @@ static test_return_t noreply_test(memcached_st *memc) static test_return_t analyzer_test(memcached_st *memc) { - memcached_return_t rc; memcached_analysis_st *report; + memcached_return_t rc; memcached_stat_st *memc_stat= memcached_stat(memc, NULL, &rc); test_compare(MEMCACHED_SUCCESS, rc); @@ -4108,24 +3783,6 @@ static test_return_t analyzer_test(memcached_st *memc) return TEST_SUCCESS; } -/* Count the objects */ - -static test_return_t dump_test(memcached_st *memc) -{ - /* No support for Binary protocol yet */ - test_skip(false, memc->flags.binary_protocol); - - test_compare(TEST_SUCCESS, set_test3(memc)); - - // confirm_key_count() call dump - size_t counter= confirm_key_count(memc); - - /* We may have more then 32 if our previous flush has not completed */ - test_true(counter >= 32); - - return TEST_SUCCESS; -} - static test_return_t util_version_test(memcached_st *memc) { test_compare_hint(MEMCACHED_SUCCESS, memcached_version(memc), memcached_last_error_message(memc)); @@ -4681,6 +4338,8 @@ static test_return_t regression_bug_434843(memcached_st *original_memc) test_compare(MEMCACHED_SUCCESS, memcached_mget(memc, (const char**)keys, key_length, max_keys)); + // One the first run we should get a NOT_FOUND, but on the second some data + // should be returned. test_compare(y ? MEMCACHED_SUCCESS : MEMCACHED_NOTFOUND, memcached_fetch_execute(memc, callbacks, (void *)&counter, 1)); @@ -4791,8 +4450,7 @@ static test_return_t regression_bug_442914(memcached_st *memc) test_true(rc == MEMCACHED_SUCCESS || rc == MEMCACHED_BUFFERED); } - (void)snprintf(k, sizeof(k), "%037u", 251U); - len= strlen(k); + len= snprintf(k, sizeof(k), "%037u", 251U); memcached_return_t rc= memcached_delete(memc, k, len, 0); test_true(rc == MEMCACHED_SUCCESS || rc == MEMCACHED_BUFFERED); @@ -4929,6 +4587,10 @@ static test_return_t regression_bug_447342(memcached_st *memc) static test_return_t regression_bug_463297(memcached_st *memc) { + test_compare(MEMCACHED_INVALID_ARGUMENTS, memcached_delete(memc, "foo", 3, 1)); + + // Since we blocked timed delete, this test is no longer valid. +#if 0 memcached_st *memc_clone= memcached_clone(NULL, memc); test_true(memc_clone); test_true(memcached_version(memc_clone) == MEMCACHED_SUCCESS); @@ -4984,6 +4646,8 @@ static test_return_t regression_bug_463297(memcached_st *memc) } memcached_free(memc_clone); +#endif + return TEST_SUCCESS; } @@ -5451,7 +5115,7 @@ static test_return_t regression_bug_490520(memcached_st *memc) test_true(keys[x]); memcached_return rc= memcached_set(memc, keys[x], key_length[x], blob, sizeof(blob), 0, 0); - test_true(rc == MEMCACHED_SUCCESS or rc == MEMCACHED_BUFFERED); + test_true_got(rc == MEMCACHED_SUCCESS or rc == MEMCACHED_BUFFERED, memcached_last_error_message(memc)); } for (uint32_t x= 0; x < regression_bug_490520_COUNT; ++x) @@ -5608,10 +5272,9 @@ test_st tests[] ={ {"connection_test", false, (test_callback_fn*)connection_test}, {"callback_test", false, (test_callback_fn*)callback_test}, {"userdata_test", false, (test_callback_fn*)userdata_test}, - {"set", false, (test_callback_fn*)set_test }, - {"set2", false, (test_callback_fn*)set_test2 }, - {"set3", false, (test_callback_fn*)set_test3 }, - {"dump", true, (test_callback_fn*)dump_test}, + {"memcached_set()", false, (test_callback_fn*)set_test }, + {"memcached_set() 2", false, (test_callback_fn*)set_test2 }, + {"memcached_set() 3", false, (test_callback_fn*)set_test3 }, {"add", true, (test_callback_fn*)add_test }, {"memcached_fetch_result(MEMCACHED_NOTFOUND)", true, (test_callback_fn*)memcached_fetch_result_NOT_FOUND }, {"replace", true, (test_callback_fn*)replace_test }, @@ -5630,7 +5293,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 }, + {"binary_increment_with_prefix", true, (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 }, @@ -5642,7 +5305,8 @@ test_st tests[] ={ {"add_host_test", false, (test_callback_fn*)add_host_test }, {"add_host_test_1", false, (test_callback_fn*)add_host_test1 }, {"get_stats_keys", false, (test_callback_fn*)get_stats_keys }, - {"version_string_test", false, (test_callback_fn*)version_string_test}, + {"version_string_test", true, (test_callback_fn*)version_string_test}, + {"memcached_mget() mixed memcached_get()", true, (test_callback_fn*)memcached_mget_mixed_memcached_get_TEST}, {"bad_key", true, (test_callback_fn*)bad_key_test }, {"memcached_server_cursor", true, (test_callback_fn*)memcached_server_cursor_test }, {"read_through", true, (test_callback_fn*)read_through }, @@ -5664,6 +5328,10 @@ test_st tests[] ={ {"memcached_exist_by_key(MEMCACHED_SUCCESS)", true, (test_callback_fn*)memcached_exist_by_key_SUCCESS }, {"memcached_touch", 0, (test_callback_fn*)test_memcached_touch}, {"memcached_touch_with_prefix", 0, (test_callback_fn*)test_memcached_touch_by_key}, +#if 0 + {"memcached_dump() no data", true, (test_callback_fn*)memcached_dump_TEST }, +#endif + {"memcached_dump() with data", true, (test_callback_fn*)memcached_dump_TEST2 }, {0, 0, 0} }; @@ -5673,6 +5341,12 @@ test_st touch_tests[] ={ {0, 0, 0} }; +test_st memcached_stat_tests[] ={ + {"memcached_stat() INVALID ARG", 0, (test_callback_fn*)memcached_stat_TEST}, + {"memcached_stat()", 0, (test_callback_fn*)memcached_stat_TEST2}, + {0, 0, 0} +}; + test_st behavior_tests[] ={ {"libmemcached_string_behavior()", false, (test_callback_fn*)libmemcached_string_behavior_test}, {"libmemcached_string_distribution()", false, (test_callback_fn*)libmemcached_string_distribution_test}, @@ -5735,10 +5409,10 @@ test_st version_1_2_3[] ={ {0, 0, (test_callback_fn*)0} }; -test_st haldenbrand_tests[] ={ - {"memcached_set", false, (test_callback_fn*)user_supplied_bug1 }, - {"memcached_get()", false, (test_callback_fn*)user_supplied_bug2 }, - {"memcached_mget()", false, (test_callback_fn*)user_supplied_bug3 }, +test_st haldenbrand_TESTS[] ={ + {"memcached_set", false, (test_callback_fn*)haldenbrand_TEST1 }, + {"memcached_get()", false, (test_callback_fn*)haldenbrand_TEST2 }, + {"memcached_mget()", false, (test_callback_fn*)haldenbrand_TEST3 }, {0, 0, (test_callback_fn*)0} }; @@ -5781,6 +5455,7 @@ test_st replication_tests[]= { {"mget", false, (test_callback_fn*)replication_mget_test }, {"delete", true, (test_callback_fn*)replication_delete_test }, {"rand_mget", false, (test_callback_fn*)replication_randomize_mget_test }, + {"miss", false, (test_callback_fn*)replication_miss_test }, {"fail", false, (test_callback_fn*)replication_randomize_mget_fail_test }, {0, 0, (test_callback_fn*)0} }; @@ -5981,7 +5656,7 @@ collection_st collection[] ={ {"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}, + {"Cal Haldenbrand's tests", 0, 0, haldenbrand_TESTS}, {"user written tests", 0, 0, user_tests}, {"generate", 0, 0, generate_tests}, {"generate_hsieh", (test_callback_fn*)pre_hsieh, 0, generate_tests}, @@ -6009,6 +5684,8 @@ collection_st collection[] ={ {"virtual buckets", 0, 0, virtual_bucket_tests}, {"memcached_server_get_last_disconnect", 0, 0, memcached_server_get_last_disconnect_tests}, {"touch", 0, 0, touch_tests}, + {"touch", (test_callback_fn*)pre_binary, 0, touch_tests}, + {"memcached_stat()", 0, 0, memcached_stat_tests}, {0, 0, 0, 0} };