X-Git-Url: https://git.m6w6.name/?a=blobdiff_plain;f=tests%2Flibmemcached-1.0%2Fmem_functions.cc;h=eb74f00e4e9e9f56f2d6aba7f256f882aeec75a9;hb=d9db3f534bc38ea22e83e5529ff93aea4150ab19;hp=9fdf6bf3fdd934990ac415bf239d447ce84dddde;hpb=facfe08e21d2c3135c508ff098ff603ddaacef3e;p=awesomized%2Flibmemcached diff --git a/tests/libmemcached-1.0/mem_functions.cc b/tests/libmemcached-1.0/mem_functions.cc index 9fdf6bf3..eb74f00e 100644 --- a/tests/libmemcached-1.0/mem_functions.cc +++ b/tests/libmemcached-1.0/mem_functions.cc @@ -35,11 +35,11 @@ * */ -#include +#include #include #if defined(HAVE_LIBUUID) && HAVE_LIBUUID -#include +# include #endif /* @@ -47,8 +47,8 @@ */ #include -#include -#include +#include "libmemcached/is.h" +#include "libmemcached/server_instance.h" #include @@ -76,7 +76,7 @@ using namespace libtest; -#include +#include #include "tests/hash_results.h" @@ -86,12 +86,13 @@ using namespace libtest; #include "tests/libmemcached-1.0/setup_and_teardowns.h" #include "tests/print.h" #include "tests/debug.h" +#include "tests/memc.hpp" #define UUID_STRING_MAXLENGTH 36 #include "tests/keys.hpp" -#include "libmemcached/instance.h" +#include "libmemcached/instance.hpp" static memcached_st * create_single_instance_memcached(const memcached_st *original_memc, const char *options) { @@ -111,7 +112,7 @@ static memcached_st * create_single_instance_memcached(const memcached_st *origi * I only want to hit _one_ server so I know the number of requests I'm * sending in the pipeline. */ - memcached_server_instance_st instance= memcached_server_instance_by_position(original_memc, 0); + const memcached_instance_st * instance= memcached_server_instance_by_position(original_memc, 0); char server_string[1024]; int server_string_length; @@ -174,7 +175,7 @@ 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, - memcached_server_instance_st server, + const memcached_instance_st * server, void *context) { /* Do Nothing */ @@ -187,7 +188,7 @@ static memcached_return_t server_display_function(const memcached_st *ptr, } static memcached_return_t dump_server_information(const memcached_st *ptr, - memcached_server_instance_st instance, + const memcached_instance_st * instance, void *context) { /* Do Nothing */ @@ -242,7 +243,7 @@ test_return_t server_sort2_test(memcached_st *ptr) size_t bigger= 0; /* Prime the value for the test_true in server_display_function */ memcached_server_fn callbacks[1]; memcached_st *local_memc; - memcached_server_instance_st instance; + const memcached_instance_st * instance; (void)ptr; local_memc= memcached_create(NULL); @@ -293,7 +294,7 @@ test_return_t memcached_server_remove_test(memcached_st*) } static memcached_return_t server_display_unsort_function(const memcached_st*, - memcached_server_instance_st server, + const memcached_instance_st * server, void *context) { /* Do Nothing */ @@ -598,7 +599,7 @@ test_return_t append_binary_test(memcached_st *memc) test_compare(value_length, sizeof(uint32_t) * count); test_compare(MEMCACHED_SUCCESS, rc); - for (uint32_t counter= count, *ptr= value; counter; counter--) + for (uint32_t counter= uint32_t(count), *ptr= value; counter; counter--) { test_compare(*ptr, store_list[count - counter]); ptr++; @@ -644,7 +645,7 @@ test_return_t memcached_mget_mixed_memcached_get_TEST(memcached_st *memc) } else { - int which_key= random() %keys.size(); + int which_key= random() % int(keys.size()); size_t value_length; uint32_t flags; memcached_return_t rc; @@ -823,6 +824,34 @@ test_return_t memcached_add_SUCCESS_TEST(memcached_st *memc) return TEST_SUCCESS; } +test_return_t regression_1067242_TEST(memcached_st *memc) +{ + test_compare(MEMCACHED_SUCCESS, memcached_set(memc, + test_literal_param(__func__), + test_literal_param("-2"), + 0, 0)); + + memcached_return_t rc; + char* value; + test_true((value= memcached_get(memc, test_literal_param(__func__), NULL, NULL, &rc))); + test_compare(MEMCACHED_SUCCESS, rc); + free(value); + + for (size_t x= 0; x < 10; x++) + { + uint64_t new_number; + test_compare(MEMCACHED_CLIENT_ERROR, + memcached_increment(memc, + test_literal_param(__func__), 1, &new_number)); + test_compare(MEMCACHED_CLIENT_ERROR, memcached_last_error(memc)); + test_true((value= memcached_get(memc, test_literal_param(__func__), NULL, NULL, &rc))); + test_compare(MEMCACHED_SUCCESS, rc); + free(value); + } + + return TEST_SUCCESS; +} + /* Set the value, then quit to make sure it is flushed. Come back in and test that add fails. @@ -926,7 +955,7 @@ test_return_t flush_test(memcached_st *memc) } static memcached_return_t server_function(const memcached_st *, - memcached_server_instance_st, + const memcached_instance_st *, void *) { /* Do Nothing */ @@ -1229,7 +1258,7 @@ test_return_t mget_end(memcached_st *memc) test_return_t stats_servername_test(memcached_st *memc) { memcached_stat_st memc_stat; - memcached_server_instance_st instance= + const memcached_instance_st * instance= memcached_server_instance_by_position(memc, 0); if (LIBMEMCACHED_WITH_SASL_SUPPORT and memcached_get_sasl_callbacks(memc)) @@ -1721,6 +1750,54 @@ test_return_t mget_execute(memcached_st *original_memc) return TEST_SUCCESS; } +test_return_t MEMCACHED_BEHAVIOR_IO_KEY_PREFETCH_TEST(memcached_st *original_memc) +{ + test_skip(true, memcached_behavior_get(original_memc, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL)); + + memcached_st *memc= create_single_instance_memcached(original_memc, "--BINARY-PROTOCOL"); + test_true(memc); + + test_skip(MEMCACHED_SUCCESS, memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_IO_KEY_PREFETCH, 8)); + + keys_st keys(20480); + + /* First add all of the items.. */ + char blob[1024] = {0}; + + for (size_t x= 0; x < keys.size(); ++x) + { + uint64_t query_id= memcached_query_id(memc); + memcached_return_t rc= memcached_add(memc, + keys.key_at(x), keys.length_at(x), + blob, sizeof(blob), + 0, 0); + test_true(rc == MEMCACHED_SUCCESS or rc == MEMCACHED_BUFFERED); + test_compare(query_id +1, memcached_query_id(memc)); + } + + /* Try to get all of them with a large multiget */ + size_t counter= 0; + memcached_execute_fn callbacks[]= { &callback_counter }; + test_compare(MEMCACHED_SUCCESS, + memcached_mget_execute(memc, + keys.keys_ptr(), keys.lengths_ptr(), + keys.size(), callbacks, &counter, 1)); + + { + uint64_t query_id= memcached_query_id(memc); + test_compare(MEMCACHED_SUCCESS, + memcached_fetch_execute(memc, callbacks, (void *)&counter, 1)); + test_compare(query_id, memcached_query_id(memc)); + + /* Verify that we got all of the items */ + test_compare(keys.size(), counter); + } + + memcached_free(memc); + + return TEST_SUCCESS; +} + #define REGRESSION_BINARY_VS_BLOCK_COUNT 20480 static pairs_st *global_pairs= NULL; @@ -1754,6 +1831,11 @@ test_return_t block_add_regression(memcached_st *memc) global_pairs[x].key, global_pairs[x].key_length, &blob[0], blob.size(), time_t(0), uint32_t(0)); + if (rc == MEMCACHED_MEMORY_ALLOCATION_FAILURE) + { + Error << memcached_last_error_message(memc); + return TEST_SKIPPED; + } test_compare(*memc, MEMCACHED_SUCCESS); test_compare(rc, MEMCACHED_SUCCESS); } @@ -1840,6 +1922,34 @@ test_return_t add_host_test(memcached_st *memc) return TEST_SUCCESS; } +test_return_t regression_1048945_TEST(memcached_st*) +{ + memcached_return status; + + memcached_server_st* list= memcached_server_list_append_with_weight(NULL, "a", 11211, 0, &status); + test_compare(status, MEMCACHED_SUCCESS); + + list= memcached_server_list_append_with_weight(list, "b", 11211, 0, &status); + test_compare(status, MEMCACHED_SUCCESS); + + list= memcached_server_list_append_with_weight(list, "c", 11211, 0, &status); + test_compare(status, MEMCACHED_SUCCESS); + + memcached_st* memc= memcached_create(NULL); + + status= memcached_server_push(memc, list); + memcached_server_list_free(list); + test_compare(status, MEMCACHED_SUCCESS); + + const memcached_instance_st * server= memcached_server_by_key(memc, test_literal_param(__func__), &status); + test_true(server); + test_compare(status, MEMCACHED_SUCCESS); + + memcached_free(memc); + + return TEST_SUCCESS; +} + test_return_t memcached_fetch_result_NOT_FOUND(memcached_st *memc) { memcached_return_t rc; @@ -2580,7 +2690,7 @@ test_return_t user_supplied_bug19(memcached_st *) memcached_st *memc= memcached(test_literal_param("--server=localhost:11311/?100 --server=localhost:11312/?100")); - memcached_server_instance_st server= memcached_server_by_key(memc, "a", 1, &res); + const memcached_instance_st * server= memcached_server_by_key(memc, "a", 1, &res); test_true(server); memcached_free(memc); @@ -2629,7 +2739,7 @@ test_return_t user_supplied_bug20(memcached_st *memc) */ /* sighandler_t function that always asserts false */ -static void fail(int) +static __attribute__((noreturn)) void fail(int) { fatal_assert(0); } @@ -2703,6 +2813,39 @@ test_return_t user_supplied_bug21(memcached_st *memc) return TEST_SUCCESS; } +test_return_t comparison_operator_memcached_st_and__memcached_return_t_TEST(memcached_st *) +{ + test::Memc memc_; + + memcached_st *memc= &memc_; + + ASSERT_EQ(memc, MEMCACHED_SUCCESS); + test_compare(memc, MEMCACHED_SUCCESS); + + ASSERT_NEQ(memc, MEMCACHED_FAILURE); + + return TEST_SUCCESS; +} + +test_return_t ketama_TEST(memcached_st *) +{ + test::Memc memc("--server=10.0.1.1:11211 --server=10.0.1.2:11211"); + + test_compare(MEMCACHED_SUCCESS, + memcached_behavior_set(&memc, MEMCACHED_BEHAVIOR_KETAMA_WEIGHTED, true)); + + test_compare(memcached_behavior_get(&memc, MEMCACHED_BEHAVIOR_KETAMA_WEIGHTED), uint64_t(1)); + + test_compare(memcached_behavior_set(&memc, MEMCACHED_BEHAVIOR_KETAMA_HASH, MEMCACHED_HASH_MD5), MEMCACHED_SUCCESS); + + test_compare(memcached_behavior_get(&memc, MEMCACHED_BEHAVIOR_KETAMA_HASH), MEMCACHED_HASH_MD5); + + test_compare(memcached_behavior_set_distribution(&memc, MEMCACHED_DISTRIBUTION_CONSISTENT_KETAMA_SPY), MEMCACHED_SUCCESS); + + + return TEST_SUCCESS; +} + test_return_t output_ketama_weighted_keys(memcached_st *) { memcached_st *memc= memcached_create(NULL); @@ -2748,7 +2891,7 @@ test_return_t output_ketama_weighted_keys(memcached_st *) char *hostname = memc->hosts[server_idx].hostname; in_port_t port = memc->hosts[server_idx].port; fprintf(fp, "key %s is on host /%s:%u\n", key, hostname, port); - memcached_server_instance_st instance= + const memcached_instance_st * instance= memcached_server_instance_by_position(memc, host_index); } fclose(fp); @@ -3121,7 +3264,7 @@ test_return_t check_for_1_2_3(memcached_st *memc) { memcached_version(memc); - memcached_server_instance_st instance= + const memcached_instance_st * instance= memcached_server_instance_by_position(memc, 0); if ((instance->major_version >= 1 && (instance->minor_version == 2 && instance->micro_version >= 4)) @@ -3162,7 +3305,7 @@ test_return_t noreply_test(memcached_st *memc) for (size_t x= 0; x < 100; ++x) { char key[MEMCACHED_MAXIMUM_INTEGER_DISPLAY_LENGTH +1]; - int check_length= (size_t)snprintf(key, sizeof(key), "%lu", (unsigned long)x); + int check_length= snprintf(key, sizeof(key), "%lu", (unsigned long)x); test_false((size_t)check_length >= sizeof(key) || check_length < 0); size_t len= (size_t)check_length; @@ -3201,7 +3344,7 @@ test_return_t noreply_test(memcached_st *memc) int no_msg=0; for (uint32_t x= 0; x < memcached_server_count(memc); ++x) { - memcached_server_instance_st instance= + const memcached_instance_st * instance= memcached_server_instance_by_position(memc, x); no_msg+=(int)(instance->cursor_active); } @@ -3217,7 +3360,7 @@ test_return_t noreply_test(memcached_st *memc) { char key[10]; - int check_length= (size_t)snprintf(key, sizeof(key), "%lu", (unsigned long)x); + int check_length= snprintf(key, sizeof(key), "%lu", (unsigned long)x); test_false((size_t)check_length >= sizeof(key) || check_length < 0); @@ -3312,7 +3455,7 @@ test_return_t analyzer_test(memcached_st *memc) test_return_t util_version_test(memcached_st *memc) { - test_compare(MEMCACHED_SUCCESS, memcached_version(memc)); + test_compare(memcached_version(memc), MEMCACHED_SUCCESS); test_true(libmemcached_util_version_check(memc, 0, 0, 0)); bool if_successful= libmemcached_util_version_check(memc, 9, 9, 9); @@ -3330,7 +3473,7 @@ test_return_t util_version_test(memcached_st *memc) } test_true(if_successful == false); - memcached_server_instance_st instance= + const memcached_instance_st * instance= memcached_server_instance_by_position(memc, 0); memcached_version(memc); @@ -3376,7 +3519,7 @@ test_return_t getpid_connection_failure_test(memcached_st *memc) { test_skip(memc->servers[0].type, MEMCACHED_CONNECTION_TCP); memcached_return_t rc; - memcached_server_instance_st instance= + const memcached_instance_st * instance= memcached_server_instance_by_position(memc, 0); // Test both the version that returns a code, and the one that does not. @@ -3394,7 +3537,7 @@ test_return_t getpid_connection_failure_test(memcached_st *memc) test_return_t getpid_test(memcached_st *memc) { memcached_return_t rc; - memcached_server_instance_st instance= + const memcached_instance_st * instance= memcached_server_instance_by_position(memc, 0); // Test both the version that returns a code, and the one that does not. @@ -3409,7 +3552,7 @@ test_return_t getpid_test(memcached_st *memc) } static memcached_return_t ping_each_server(const memcached_st*, - memcached_server_instance_st instance, + const memcached_instance_st * instance, void*) { // Test both the version that returns a code, and the one that does not. @@ -3622,6 +3765,27 @@ test_return_t murmur_run (memcached_st *) #endif } +test_return_t murmur3_TEST(hashkit_st *) +{ + test_skip(true, libhashkit_has_algorithm(HASHKIT_HASH_MURMUR3)); + +#ifdef WORDS_BIGENDIAN + (void)murmur3_values; + return TEST_SKIPPED; +#else + uint32_t x; + const char **ptr; + + for (ptr= list_to_hash, x= 0; *ptr; ptr++, x++) + { + test_compare(murmur3_values[x], + memcached_generate_hash_value(*ptr, strlen(*ptr), MEMCACHED_HASH_MURMUR3)); + } + + return TEST_SUCCESS; +#endif +} + test_return_t jenkins_run (memcached_st *) { uint32_t x; @@ -4042,8 +4206,8 @@ test_return_t regression_bug_447342(memcached_st *memc) * This is to verify correct behavior in the library. Fake that two servers * are dead.. */ - 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); + const memcached_instance_st * instance_one= memcached_server_instance_by_position(memc, 0); + const memcached_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(); @@ -4106,7 +4270,7 @@ test_return_t regression_bug_463297(memcached_st *memc) test_true(memc_clone); test_true(memcached_version(memc_clone) == MEMCACHED_SUCCESS); - memcached_server_instance_st instance= + const memcached_instance_st * instance= memcached_server_instance_by_position(memc_clone, 0); if (instance->major_version > 1 || @@ -4170,7 +4334,7 @@ test_return_t regression_bug_463297(memcached_st *memc) test_return_t test_get_last_disconnect(memcached_st *memc) { memcached_return_t rc; - memcached_server_instance_st disconnected_server; + const memcached_instance_st * disconnected_server; /* With the working set of server */ const char *key= "marmotte"; @@ -4237,7 +4401,7 @@ test_return_t test_multiple_get_last_disconnect(memcached_st *) memcached_return_t ret= memcached_set(memc, msg, strlen(msg), NULL, 0, (time_t)0, (uint32_t)0); 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); + const memcached_instance_st * disconnected_server= memcached_server_get_last_disconnect(memc); test_true(disconnected_server); test_strcmp("localhost", memcached_server_name(disconnected_server)); test_true(memcached_server_port(disconnected_server) >= 8888 and memcached_server_port(disconnected_server) <= 8892); @@ -4262,7 +4426,7 @@ test_return_t test_verbosity(memcached_st *memc) } -static memcached_return_t stat_printer(memcached_server_instance_st server, +static memcached_return_t stat_printer(const memcached_instance_st * server, const char *key, size_t key_length, const char *value, size_t value_length, void *context) @@ -4310,7 +4474,7 @@ test_return_t wrong_failure_counter_test(memcached_st *original_memc) test_true(rc == MEMCACHED_SUCCESS or rc == MEMCACHED_BUFFERED); - memcached_server_instance_st instance= memcached_server_instance_by_position(memc, 0); + const memcached_instance_st * instance= memcached_server_instance_by_position(memc, 0); /* The test is to see that the memcached_quit doesn't increase the * the server failure conter, so let's ensure that it is zero @@ -4474,13 +4638,34 @@ 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); test_true(memc); - test_compare(MEMCACHED_SUCCESS, memcached_server_add(memc, "10.2.3.4", 11211)); + test_compare(MEMCACHED_SUCCESS, memcached_server_add(memc, "10.2.251.4", 11211)); - memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_CONNECT_TIMEOUT, 1000); + memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_CONNECT_TIMEOUT, 3000); memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_RETRY_TIMEOUT, 1000); memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_SND_TIMEOUT, 1000); memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_RCV_TIMEOUT, 1000); @@ -4495,7 +4680,7 @@ test_return_t regression_bug_583031(memcached_st *) test_false(value); test_zero(length); - test_compare_got(MEMCACHED_TIMEOUT, rc, memcached_last_error_message(memc)); + test_compare(MEMCACHED_TIMEOUT, memc); memcached_free(memc); @@ -4657,6 +4842,10 @@ test_return_t regression_994772_TEST(memcached_st* memc) uint64_t cas_value= memcached_result_cas(results); test_true(cas_value); + char* take_value= memcached_result_take_value(results); + test_strcmp(__func__, take_value); + free(take_value); + memcached_result_free(results); // Bad cas value, sanity check @@ -4808,7 +4997,7 @@ test_return_t kill_HUP_TEST(memcached_st *original_memc) memcached_st *memc= create_single_instance_memcached(original_memc, 0); test_true(memc); - memcached_server_instance_st instance= memcached_server_instance_by_position(memc, 0); + const memcached_instance_st * instance= memcached_server_instance_by_position(memc, 0); pid_t pid; test_true((pid= libmemcached_util_getpid(memcached_server_name(instance), @@ -4822,11 +5011,12 @@ test_return_t kill_HUP_TEST(memcached_st *original_memc) 0, 0)); test_true_got(kill(pid, SIGHUP) == 0, strerror(errno)); - test_compare(MEMCACHED_CONNECTION_FAILURE, - memcached_set(memc, - test_literal_param(__func__), // Keys - test_literal_param(__func__), // Values - 0, 0)); + memcached_return_t ret= memcached_set(memc, + test_literal_param(__func__), // Keys + test_literal_param(__func__), // Values + 0, 0); + test_compare(ret, memc); + test_compare(MEMCACHED_CONNECTION_FAILURE, memc); memcached_free(memc);