X-Git-Url: https://git.m6w6.name/?a=blobdiff_plain;ds=sidebyside;f=tests%2Fmem_functions.cc;h=d691cbc57dd5f6186c686d3bb211c776d152bb33;hb=79e0a4c923bdcfbd11060975811e058dae92e404;hp=835fc0c71b7fd3abc37b518294e7d16d3bc1509b;hpb=45fc4ad7cbf8d981f800eca27f24c8f758e92df1;p=m6w6%2Flibmemcached diff --git a/tests/mem_functions.cc b/tests/mem_functions.cc index 835fc0c7..d691cbc5 100644 --- a/tests/mem_functions.cc +++ b/tests/mem_functions.cc @@ -42,12 +42,16 @@ 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 @@ -64,24 +68,23 @@ #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/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" @@ -1287,10 +1290,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 +1497,34 @@ 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); + + return TEST_SUCCESS; +} static test_return_t quit_test(memcached_st *memc) { @@ -2931,69 +2963,6 @@ static test_return_t user_supplied_bug20(memcached_st *memc) 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 @@ -3098,85 +3067,6 @@ 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) { (void) trash; @@ -3768,32 +3658,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)); @@ -4041,7 +3905,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)); @@ -4951,110 +4815,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; @@ -5979,7 +5739,7 @@ static void memcached_die(memcached_st* mc, memcached_return error, const char* { 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 +5843,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 }, @@ -6154,6 +5881,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 }, @@ -6220,17 +5948,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} @@ -6328,11 +6045,6 @@ test_st regression_tests[]= { {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 +6162,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 +6182,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}, @@ -6493,10 +6212,7 @@ 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}, @@ -6530,6 +6246,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)