X-Git-Url: https://git.m6w6.name/?a=blobdiff_plain;f=tests%2Ffunction.c;h=a580f396d1820e06ea532fa7689b130d423448d3;hb=98c99981e0ebe7f716bea2e4d95434d159103fcd;hp=b77786603ca22ddec8837dc8c74475157529ec19;hpb=fa11f4a5d1a9c92eda13f8a5aa11dcff542b8815;p=m6w6%2Flibmemcached diff --git a/tests/function.c b/tests/function.c index b7778660..a580f396 100644 --- a/tests/function.c +++ b/tests/function.c @@ -235,8 +235,6 @@ static test_return_t clone_test(memcached_st *memc) test_truth(memc_clone->flags.no_block == memc->flags.no_block); test_truth(memc_clone->flags.tcp_nodelay == memc->flags.tcp_nodelay); test_truth(memc_clone->flags.reuse_memory == memc->flags.reuse_memory); - test_truth(memc_clone->flags.use_md5 == memc->flags.use_md5); - test_truth(memc_clone->flags.use_crc == memc->flags.use_crc); test_truth(memc_clone->flags.use_cache_lookups == memc->flags.use_cache_lookups); test_truth(memc_clone->flags.support_cas == memc->flags.support_cas); test_truth(memc_clone->flags.buffer_requests == memc->flags.buffer_requests); @@ -252,7 +250,7 @@ static test_return_t clone_test(memcached_st *memc) } test_truth(memc_clone->get_key_failure == memc->get_key_failure); test_truth(memc_clone->hash == memc->hash); - test_truth(memc_clone->hash_continuum == memc->hash_continuum); + test_truth(memc_clone->distribution_hash == memc->distribution_hash); test_truth(memc_clone->io_bytes_watermark == memc->io_bytes_watermark); test_truth(memc_clone->io_msg_watermark == memc->io_msg_watermark); test_truth(memc_clone->io_key_prefetch == memc->io_key_prefetch); @@ -716,6 +714,10 @@ static test_return_t bad_key_test(memcached_st *memc) unsigned int set= 1; size_t max_keylen= 0xffff; + // Just skip if we are in binary mode. + if (memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL)) + return TEST_SKIPPED; + memc_clone= memcached_clone(NULL, memc); test_truth(memc_clone); @@ -798,16 +800,16 @@ static 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 __attribute__((unused)), - char *key __attribute__((unused)), - size_t key_length __attribute__((unused)), - memcached_result_st *result) +static memcached_return_t read_through_trigger(memcached_st *memc __attribute__((unused)), + char *key __attribute__((unused)), + size_t key_length __attribute__((unused)), + memcached_result_st *result) { return memcached_result_set_value(result, READ_THROUGH_VALUE, strlen(READ_THROUGH_VALUE)); } -static test_return_t read_through(memcached_st *memc) +static test_return_t read_through(memcached_st *memc) { memcached_return_t rc; const char *key= "foo"; @@ -820,8 +822,8 @@ static test_return_t read_through(memcached_st *memc) &string_length, &flags, &rc); test_truth(rc == MEMCACHED_NOTFOUND); - test_truth(string_length == 0); - test_truth(!string); + test_false(string_length); + test_false(string); rc= memcached_callback_set(memc, MEMCACHED_CALLBACK_GET_FAILURE, *(void **)&cb); @@ -832,7 +834,7 @@ static test_return_t read_through(memcached_st *memc) test_truth(rc == MEMCACHED_SUCCESS); test_truth(string_length == strlen(READ_THROUGH_VALUE)); - test_truth(!strcmp(READ_THROUGH_VALUE, string)); + test_strcmp(READ_THROUGH_VALUE, string); free(string); string= memcached_get(memc, key, strlen(key), @@ -883,8 +885,8 @@ static test_return_t get_test(memcached_st *memc) &string_length, &flags, &rc); test_truth(rc == MEMCACHED_NOTFOUND); - test_truth(string_length == 0); - test_truth(!string); + test_false(string_length); + test_false(string); return TEST_SUCCESS; } @@ -1156,8 +1158,8 @@ static test_return_t stats_servername_test(memcached_st *memc) memcached_return_t rc; memcached_stat_st memc_stat; rc= memcached_stat_servername(&memc_stat, NULL, - memc->hosts[0].hostname, - memc->hosts[0].port); + memc->hosts[0].hostname, + memc->hosts[0].port); return TEST_SUCCESS; } @@ -1662,7 +1664,6 @@ static test_return_t get_stats_keys(memcached_st *memc) test_truth(rc == MEMCACHED_SUCCESS); for (ptr= stat_list; *ptr; ptr++) test_truth(*ptr); - fflush(stdout); free(stat_list); @@ -2734,7 +2735,7 @@ static test_return_t user_supplied_bug18(memcached_st *trash) { uint32_t server_idx = memcached_generate_hash(memc, ketama_test_cases[x].key, strlen(ketama_test_cases[x].key)); char *hostname = memc->hosts[server_idx].hostname; - test_truth(strcmp(hostname, ketama_test_cases[x].server) == 0); + test_strcmp(hostname, ketama_test_cases[x].server); } memcached_server_list_free(server_pool); @@ -2813,8 +2814,11 @@ static test_return_t pre_binary(memcached_st *memc); static test_return_t user_supplied_bug21(memcached_st *memc) { - if (pre_binary(memc) != MEMCACHED_SUCCESS) - return TEST_SKIPPED; + test_return_t test_rc; + test_rc= pre_binary(memc); + + if (test_rc != TEST_SUCCESS) + return test_rc; test_return_t rc; @@ -2921,8 +2925,7 @@ static test_return_t output_ketama_weighted_keys(memcached_st *trash) test_truth(value == MEMCACHED_HASH_MD5); - test_truth(memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_KETAMA_COMPAT_MODE, - MEMCACHED_KETAMA_COMPAT_SPY) == MEMCACHED_SUCCESS); + test_truth(memcached_behavior_set_distribution(memc, MEMCACHED_DISTRIBUTION_CONSISTENT_KETAMA_SPY) == MEMCACHED_SUCCESS); memcached_server_st *server_pool; server_pool = memcached_servers_parse("10.0.1.1:11211,10.0.1.2:11211,10.0.1.3:11211,10.0.1.4:11211,10.0.1.5:11211,10.0.1.6:11211,10.0.1.7:11211,10.0.1.8:11211,192.168.1.1:11211,192.168.100.1:11211"); @@ -2946,7 +2949,7 @@ static test_return_t output_ketama_weighted_keys(memcached_st *trash) uint32_t server_idx = memcached_generate_hash(memc, key, strlen(key)); char *hostname = memc->hosts[server_idx].hostname; - unsigned int port = memc->hosts[server_idx].port; + in_port_t port = memc->hosts[server_idx].port; fprintf(fp, "key %s is on host /%s:%u\n", key, hostname, port); } fclose(fp); @@ -3519,8 +3522,11 @@ static test_return_t pre_binary(memcached_st *memc) static test_return_t pre_replication(memcached_st *memc) { - if (pre_binary(memc) != TEST_SUCCESS) - return TEST_FAILURE; + test_return_t test_rc; + test_rc= pre_binary(memc); + + if (test_rc != TEST_SUCCESS) + return test_rc; /* * Make sure that we store the item on all servers @@ -3547,26 +3553,65 @@ static test_return_t pre_replication_noblock(memcached_st *memc) static void my_free(memcached_st *ptr __attribute__((unused)), void *mem) { +#ifdef HARD_MALLOC_TESTS + void *real_ptr= (mem == NULL) ? mem : (void*)((caddr_t)mem - 8); + free(real_ptr); +#else free(mem); +#endif } static void *my_malloc(memcached_st *ptr __attribute__((unused)), const size_t size) { +#ifdef HARD_MALLOC_TESTS + void *ret= malloc(size + 8); + if (ret != NULL) + { + ret= (void*)((caddr_t)ret + 8); + } +#else void *ret= malloc(size); +#endif + if (ret != NULL) + { memset(ret, 0xff, size); + } return ret; } static void *my_realloc(memcached_st *ptr __attribute__((unused)), void *mem, const size_t size) { +#ifdef HARD_MALLOC_TESTS + void *real_ptr= (mem == NULL) ? NULL : (void*)((caddr_t)mem - 8); + void *nmem= realloc(real_ptr, size + 8); + + void *ret= NULL; + if (nmem != NULL) + { + ret= (void*)((caddr_t)nmem + 8); + } + + return ret; +#else return realloc(mem, size); +#endif } static void *my_calloc(memcached_st *ptr __attribute__((unused)), size_t nelem, const size_t size) { +#ifdef HARD_MALLOC_TESTS + void *mem= my_malloc(ptr, nelem * size); + if (mem) + { + memset(mem, 0, nelem * size); + } + + return mem; +#else return calloc(nelem, size); +#endif } static test_return_t set_prefix(memcached_st *memc) @@ -3711,7 +3756,27 @@ static test_return_t set_memory_alloc(memcached_st *memc) return TEST_SUCCESS; } -static test_return_t enable_consistent(memcached_st *memc) +static test_return_t enable_consistent_crc(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); + if ((rc= pre_crc(memc)) != TEST_SUCCESS) + return rc; + + value= (memcached_server_distribution_t)memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_DISTRIBUTION); + test_truth(value == MEMCACHED_DISTRIBUTION_CONSISTENT); + + hash= (memcached_hash_t)memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_HASH); + + if (hash != MEMCACHED_HASH_CRC) + return TEST_SKIPPED; + + return TEST_SUCCESS; +} + +static test_return_t enable_consistent_hsieh(memcached_st *memc) { test_return_t rc; memcached_server_distribution_t value= MEMCACHED_DISTRIBUTION_CONSISTENT; @@ -4391,7 +4456,12 @@ static test_return_t init_udp(memcached_st *memc) static test_return_t binary_init_udp(memcached_st *memc) { - pre_binary(memc); + test_return_t test_rc; + test_rc= pre_binary(memc); + + if (test_rc != TEST_SUCCESS) + return test_rc; + return init_udp(memc); } @@ -4865,19 +4935,17 @@ static test_return_t ketama_compatibility_libmemcached(memcached_st *trash) (void)trash; memc= memcached_create(NULL); - assert(memc); + test_truth(memc); rc= memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_KETAMA_WEIGHTED, 1); - assert(rc == MEMCACHED_SUCCESS); + test_truth(rc == MEMCACHED_SUCCESS); value= memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_KETAMA_WEIGHTED); - assert(value == 1); + test_truth(value == 1); - assert(memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_KETAMA_COMPAT_MODE, - MEMCACHED_KETAMA_COMPAT_LIBMEMCACHED) == MEMCACHED_SUCCESS); + test_truth(memcached_behavior_set_distribution(memc, MEMCACHED_DISTRIBUTION_CONSISTENT_KETAMA) == MEMCACHED_SUCCESS); + test_truth(memcached_behavior_get_distribution(memc) == MEMCACHED_DISTRIBUTION_CONSISTENT_KETAMA); - assert(memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_KETAMA_COMPAT_MODE) == - MEMCACHED_KETAMA_COMPAT_LIBMEMCACHED); 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); @@ -4924,19 +4992,16 @@ static test_return_t ketama_compatibility_spymemcached(memcached_st *trash) (void)trash; memc= memcached_create(NULL); - assert(memc); + test_truth(memc); rc= memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_KETAMA_WEIGHTED, 1); - assert(rc == MEMCACHED_SUCCESS); + test_truth(rc == MEMCACHED_SUCCESS); value= memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_KETAMA_WEIGHTED); - assert(value == 1); - - assert(memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_KETAMA_COMPAT_MODE, - MEMCACHED_KETAMA_COMPAT_SPY) == MEMCACHED_SUCCESS); + test_truth(value == 1); - assert(memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_KETAMA_COMPAT_MODE) == - MEMCACHED_KETAMA_COMPAT_SPY); + test_truth(memcached_behavior_set_distribution(memc, MEMCACHED_DISTRIBUTION_CONSISTENT_KETAMA_SPY) == MEMCACHED_SUCCESS); + test_truth(memcached_behavior_get_distribution(memc) == MEMCACHED_DISTRIBUTION_CONSISTENT_KETAMA_SPY); 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); @@ -4974,8 +5039,11 @@ static test_return_t ketama_compatibility_spymemcached(memcached_st *trash) static test_return_t regression_bug_434484(memcached_st *memc) { - if (pre_binary(memc) != MEMCACHED_SUCCESS) - return TEST_SKIPPED; + test_return_t test_rc; + test_rc= pre_binary(memc); + + if (test_rc != TEST_SUCCESS) + return test_rc; memcached_return_t ret; const char *key= "regression_bug_434484"; @@ -4996,8 +5064,11 @@ static test_return_t regression_bug_434484(memcached_st *memc) static test_return_t regression_bug_434843(memcached_st *memc) { - if (pre_binary(memc) != MEMCACHED_SUCCESS) - return TEST_SKIPPED; + test_return_t test_rc; + test_rc= pre_binary(memc); + + if (test_rc != TEST_SUCCESS) + return test_rc; memcached_return_t rc; unsigned int counter= 0; @@ -5203,8 +5274,9 @@ static test_return_t regression_bug_447342(memcached_st *memc) * This is to verify correct behavior in the library. Fake that two servers * are dead.. */ - unsigned int port0= memc->hosts[0].port; - unsigned int port2= memc->hosts[2].port; + in_port_t port0= memc->hosts[0].port; + in_port_t port2= memc->hosts[2].port; + memc->hosts[0].port= 0; memc->hosts[2].port= 0; @@ -5223,11 +5295,13 @@ static test_return_t regression_bug_447342(memcached_st *memc) /* Remove half of the objects */ for (int x= 0; x < (int)max_keys; ++x) + { if (x & 1) { rc= memcached_delete(memc, keys[x], key_length[x], 0); assert(rc == MEMCACHED_SUCCESS); } + } memcached_quit(memc); memc->hosts[0].port= 0; @@ -5250,6 +5324,7 @@ static test_return_t regression_bug_447342(memcached_st *memc) /* restore the memc handle */ memc->hosts[0].port= port0; memc->hosts[2].port= port2; + return TEST_SUCCESS; } @@ -5686,7 +5761,8 @@ collection_st collection[] ={ {"unix_socket_nodelay", (test_callback_fn)pre_nodelay, 0, tests}, {"poll_timeout", (test_callback_fn)poll_timeout, 0, tests}, {"gets", (test_callback_fn)enable_cas, 0, tests}, - {"consistent", (test_callback_fn)enable_consistent, 0, tests}, + {"consistent_crc", (test_callback_fn)enable_consistent_crc, 0, tests}, + {"consistent_hsieh", (test_callback_fn)enable_consistent_hsieh, 0, tests}, #ifdef MEMCACHED_ENABLE_DEPRECATED {"deprecated_memory_allocators", (test_callback_fn)deprecated_set_memory_alloc, 0, tests}, #endif @@ -5701,7 +5777,7 @@ collection_st collection[] ={ {"generate", 0, 0, generate_tests}, {"generate_hsieh", (test_callback_fn)pre_hsieh, 0, generate_tests}, {"generate_ketama", (test_callback_fn)pre_behavior_ketama, 0, generate_tests}, - {"generate_hsieh_consistent", (test_callback_fn)enable_consistent, 0, generate_tests}, + {"generate_hsieh_consistent", (test_callback_fn)enable_consistent_hsieh, 0, generate_tests}, {"generate_md5", (test_callback_fn)pre_md5, 0, generate_tests}, {"generate_murmur", (test_callback_fn)pre_murmur, 0, generate_tests}, {"generate_jenkins", (test_callback_fn)pre_jenkins, 0, generate_tests},