X-Git-Url: https://git.m6w6.name/?a=blobdiff_plain;f=tests%2Ffunction.c;h=86a255ba326a3bd956fa6b839e7dd27399b45bcb;hb=276c3db8d1dc8e14949df2b408960a803bea5d53;hp=91c12f7a0d76dea85a43e3abe7d5a0887945f850;hpb=6bd49a94f43c6ffe3b679f9470d266031d809bf9;p=awesomized%2Flibmemcached diff --git a/tests/function.c b/tests/function.c index 91c12f7a..86a255ba 100644 --- a/tests/function.c +++ b/tests/function.c @@ -1,6 +1,8 @@ /* Sample test application. */ +#include "libmemcached/common.h" + #include #include #include @@ -11,8 +13,8 @@ #include #include #include "server.h" -#include "../clients/generator.h" -#include "../clients/execute.h" +#include "clients/generator.h" +#include "clients/execute.h" #ifndef INT64_MAX #define INT64_MAX LONG_MAX @@ -24,6 +26,11 @@ #include "test.h" +#ifdef HAVE_LIBMEMCACHEDUTIL +#include +#include "libmemcached/memcached_util.h" +#endif + #define GLOBAL_COUNT 10000 #define GLOBAL2_COUNT 100 #define SERVERS_TO_CREATE 5 @@ -204,6 +211,31 @@ static test_return clone_test(memcached_st *memc) memcached_st *clone; clone= memcached_clone(NULL, memc); assert(clone); + + assert(clone->call_free == memc->call_free); + assert(clone->call_malloc == memc->call_malloc); + assert(clone->call_realloc == memc->call_realloc); + assert(clone->connect_timeout == memc->connect_timeout); + assert(clone->delete_trigger == memc->delete_trigger); + assert(clone->distribution == memc->distribution); + assert(clone->flags == memc->flags); + assert(clone->get_key_failure == memc->get_key_failure); + assert(clone->hash == memc->hash); + assert(clone->hash_continuum == memc->hash_continuum); + assert(clone->io_bytes_watermark == memc->io_bytes_watermark); + assert(clone->io_msg_watermark == memc->io_msg_watermark); + assert(clone->io_key_prefetch == memc->io_key_prefetch); + assert(clone->on_cleanup == memc->on_cleanup); + assert(clone->on_clone == memc->on_clone); + assert(clone->poll_timeout == memc->poll_timeout); + assert(clone->rcv_timeout == memc->rcv_timeout); + assert(clone->recv_size == memc->recv_size); + assert(clone->retry_timeout == memc->retry_timeout); + assert(clone->send_size == memc->send_size); + assert(clone->server_failure_limit == memc->server_failure_limit); + assert(clone->snd_timeout == memc->snd_timeout); + assert(clone->user_data == memc->user_data); + memcached_free(clone); } @@ -519,11 +551,22 @@ static test_return add_test(memcached_st *memc) return 0; } +/* +** There was a problem of leaking filedescriptors in the initial release +** of MacOSX 10.5. This test case triggers the problem. On some Solaris +** systems it seems that the kernel is slow on reclaiming the resources +** because the connects starts to time out (the test doesn't do much +** anyway, so just loop 10 iterations) +*/ static test_return add_wrapper(memcached_st *memc) { unsigned int x; + unsigned int max= 10000; +#ifdef __sun + max= 10; +#endif - for (x= 0; x < 10000; x++) + for (x= 0; x < max; x++) add_test(memc); return 0; @@ -705,6 +748,7 @@ static test_return read_through(memcached_st *memc) char *string; size_t string_length; uint32_t flags; + memcached_trigger_key cb= (memcached_trigger_key)read_through_trigger; string= memcached_get(memc, key, strlen(key), &string_length, &flags, &rc); @@ -713,7 +757,8 @@ static test_return read_through(memcached_st *memc) assert(string_length == 0); assert(!string); - rc= memcached_callback_set(memc, MEMCACHED_CALLBACK_GET_FAILURE, (void *)read_through_trigger); + rc= memcached_callback_set(memc, MEMCACHED_CALLBACK_GET_FAILURE, + *(void **)&cb); assert(rc == MEMCACHED_SUCCESS); string= memcached_get(memc, key, strlen(key), @@ -749,9 +794,9 @@ static test_return delete_through(memcached_st *memc) memcached_trigger_delete_key callback; memcached_return rc; - callback= delete_trigger; + callback= (memcached_trigger_delete_key)delete_trigger; - rc= memcached_callback_set(memc, MEMCACHED_CALLBACK_DELETE_TRIGGER, (void*)callback); + rc= memcached_callback_set(memc, MEMCACHED_CALLBACK_DELETE_TRIGGER, *(void**)&callback); assert(rc == MEMCACHED_SUCCESS); return 0; @@ -926,6 +971,51 @@ static test_return get_test4(memcached_st *memc) return 0; } +/* + * 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. + */ +static test_return 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) ;-) + */ + char *keys[]= { "key", "key" }; + size_t lengths[]= { 3, 3 }; + uint32_t flags; + size_t rlen; + + memcached_return rc= memcached_set(memc, keys[0], lengths[0], + keys[0], lengths[0], 0, 0); + assert(rc == MEMCACHED_SUCCESS); + rc= memcached_mget(memc, keys, lengths, 2); + + memcached_result_st results_obj; + memcached_result_st *results; + results=memcached_result_create(memc, &results_obj); + assert(results); + results=memcached_fetch_result(memc, &results_obj, &rc); + assert(results); + memcached_result_free(&results_obj); + + /* Don't read out the second result, but issue a set instead.. */ + rc= memcached_set(memc, keys[0], lengths[0], keys[0], lengths[0], 0, 0); + assert(rc == MEMCACHED_SUCCESS); + + char *val= memcached_get_by_key(memc, keys[0], lengths[0], "yek", 3, + &rlen, &flags, &rc); + assert(val == NULL); + assert(rc == MEMCACHED_NOTFOUND); + val= memcached_get(memc, keys[0], lengths[0], &rlen, &flags, &rc); + assert(val != NULL); + assert(rc == MEMCACHED_SUCCESS); + free(val); + + return TEST_SUCCESS; +} + /* Do not copy the style of this code, I just access hosts to testthis function */ static test_return stats_servername_test(memcached_st *memc) { @@ -963,6 +1053,28 @@ static test_return increment_test(memcached_st *memc) return 0; } +static test_return increment_with_initial_test(memcached_st *memc) +{ + if (memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL) != 0) + { + uint64_t new_number; + memcached_return rc; + char *key= "number"; + uint64_t initial= 0; + + rc= memcached_increment_with_initial(memc, key, strlen(key), + 1, initial, 0, &new_number); + assert(rc == MEMCACHED_SUCCESS); + assert(new_number == initial); + + rc= memcached_increment_with_initial(memc, key, strlen(key), + 1, initial, 0, &new_number); + assert(rc == MEMCACHED_SUCCESS); + assert(new_number == (initial + 1)); + } + return 0; +} + static test_return decrement_test(memcached_st *memc) { uint64_t new_number; @@ -988,6 +1100,28 @@ static test_return decrement_test(memcached_st *memc) return 0; } +static test_return decrement_with_initial_test(memcached_st *memc) +{ + if (memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL) != 0) + { + uint64_t new_number; + memcached_return rc; + char *key= "number"; + uint64_t initial= 3; + + rc= memcached_decrement_with_initial(memc, key, strlen(key), + 1, initial, 0, &new_number); + assert(rc == MEMCACHED_SUCCESS); + assert(new_number == initial); + + rc= memcached_decrement_with_initial(memc, key, strlen(key), + 1, initial, 0, &new_number); + assert(rc == MEMCACHED_SUCCESS); + assert(new_number == (initial - 1)); + } + return 0; +} + static test_return quit_test(memcached_st *memc) { memcached_return rc; @@ -1328,24 +1462,31 @@ static test_return callback_test(memcached_st *memc) /* Test Clone Callback */ { - memcached_clone_func temp_function; + memcached_clone_func clone_cb= (memcached_clone_func)clone_test_callback; + void *clone_cb_ptr= *(void **)&clone_cb; + void *temp_function= NULL; memcached_return rc; - rc= memcached_callback_set(memc, MEMCACHED_CALLBACK_CLONE_FUNCTION, (void*)clone_test_callback); + rc= memcached_callback_set(memc, MEMCACHED_CALLBACK_CLONE_FUNCTION, + clone_cb_ptr); assert(rc == MEMCACHED_SUCCESS); - temp_function= (memcached_clone_func)memcached_callback_get(memc, MEMCACHED_CALLBACK_CLONE_FUNCTION, &rc); - assert(temp_function == clone_test_callback); + temp_function= memcached_callback_get(memc, MEMCACHED_CALLBACK_CLONE_FUNCTION, &rc); + assert(temp_function == clone_cb_ptr); } /* Test Cleanup Callback */ { - memcached_cleanup_func temp_function; + memcached_cleanup_func cleanup_cb= + (memcached_cleanup_func)cleanup_test_callback; + void *cleanup_cb_ptr= *(void **)&cleanup_cb; + void *temp_function= NULL; memcached_return rc; - rc= memcached_callback_set(memc, MEMCACHED_CALLBACK_CLONE_FUNCTION, (void*)cleanup_test_callback); + rc= memcached_callback_set(memc, MEMCACHED_CALLBACK_CLONE_FUNCTION, + cleanup_cb_ptr); assert(rc == MEMCACHED_SUCCESS); - temp_function= (memcached_cleanup_func)memcached_callback_get(memc, MEMCACHED_CALLBACK_CLONE_FUNCTION, &rc); - assert(temp_function == cleanup_test_callback); + temp_function= memcached_callback_get(memc, MEMCACHED_CALLBACK_CLONE_FUNCTION, &rc); + assert(temp_function == cleanup_cb_ptr); } return 0; @@ -1896,9 +2037,10 @@ static test_return user_supplied_bug10(memcached_st *memc) { rc= memcached_set(mclone, key, key_len,value, value_length, 0, 0); - assert(rc == MEMCACHED_SUCCESS || rc == MEMCACHED_WRITE_FAILURE || rc == MEMCACHED_BUFFERED); + assert(rc == MEMCACHED_SUCCESS || rc == MEMCACHED_WRITE_FAILURE || + rc == MEMCACHED_BUFFERED || rc == MEMCACHED_TIMEOUT); - if (rc == MEMCACHED_WRITE_FAILURE) + if (rc == MEMCACHED_WRITE_FAILURE || rc == MEMCACHED_TIMEOUT) x--; } @@ -2171,7 +2313,7 @@ static test_return user_supplied_bug17(memcached_st *memc) From Andrei on IRC */ -test_return user_supplied_bug19(memcached_st *memc) +static test_return user_supplied_bug19(memcached_st *memc) { memcached_st *m; memcached_server_st *s; @@ -2192,7 +2334,7 @@ test_return user_supplied_bug19(memcached_st *memc) } /* CAS test from Andei */ -test_return user_supplied_bug20(memcached_st *memc) +static test_return user_supplied_bug20(memcached_st *memc) { memcached_return status; memcached_result_st *result, result_obj; @@ -2224,7 +2366,7 @@ test_return user_supplied_bug20(memcached_st *memc) } #include "ketama_test_cases.h" -test_return user_supplied_bug18(memcached_st *trash) +static test_return user_supplied_bug18(memcached_st *trash) { memcached_return rc; int value; @@ -2283,6 +2425,75 @@ test_return user_supplied_bug18(memcached_st *trash) return 0; } +static test_return auto_eject_hosts(memcached_st *trash) +{ + (void) trash; + + memcached_return rc; + memcached_st *memc= memcached_create(NULL); + assert(memc); + + rc= memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_KETAMA_WEIGHTED, 1); + assert(rc == MEMCACHED_SUCCESS); + + uint64_t value= memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_KETAMA_WEIGHTED); + assert(value == 1); + + rc= memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_KETAMA_HASH, MEMCACHED_HASH_MD5); + assert(rc == MEMCACHED_SUCCESS); + + value= memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_KETAMA_HASH); + assert(value == MEMCACHED_HASH_MD5); + + /* server should be removed when in delay */ + rc= memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_AUTO_EJECT_HOSTS, 1); + assert(rc == MEMCACHED_SUCCESS); + + value= memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_AUTO_EJECT_HOSTS); + assert(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. */ + assert(memc->number_of_hosts == 8); + assert(strcmp(server_pool[0].hostname, "10.0.1.1") == 0); + assert(server_pool[0].port == 11211); + assert(server_pool[0].weight == 600); + assert(strcmp(server_pool[2].hostname, "10.0.1.3") == 0); + assert(server_pool[2].port == 11211); + assert(server_pool[2].weight == 200); + assert(strcmp(server_pool[7].hostname, "10.0.1.8") == 0); + assert(server_pool[7].port == 11211); + assert(server_pool[7].weight == 100); + + memc->hosts[2].next_retry = time(NULL) + 15; + memc->next_distribution_rebuild= time(NULL) - 1; + + for (int x= 0; x < 99; x++) + { + uint32_t server_idx = memcached_generate_hash(memc, test_cases[x].key, strlen(test_cases[x].key)); + assert(server_idx != 2); + } + + /* and re-added when it's back. */ + memc->hosts[2].next_retry = time(NULL) - 1; + memc->next_distribution_rebuild= time(NULL) - 1; + run_distribution(memc); + for (int x= 0; x < 99; x++) + { + uint32_t server_idx = memcached_generate_hash(memc, test_cases[x].key, strlen(test_cases[x].key)); + char *hostname = memc->hosts[server_idx].hostname; + assert(strcmp(hostname, test_cases[x].server) == 0); + } + + memcached_server_list_free(server_pool); + memcached_free(memc); + + return TEST_SUCCESS; +} + static test_return result_static(memcached_st *memc) { memcached_result_st result; @@ -2346,7 +2557,7 @@ static test_return string_alloc_with_size_toobig(memcached_st *memc) { memcached_string_st *string; - string= memcached_string_create(memc, NULL, INT64_MAX); + string= memcached_string_create(memc, NULL, SIZE_MAX); assert(string == NULL); return 0; @@ -2393,7 +2604,7 @@ static test_return string_alloc_append_toobig(memcached_st *memc) rc= memcached_string_append(string, buffer, SMALL_STRING_LEN); assert(rc == MEMCACHED_SUCCESS); } - rc= memcached_string_append(string, buffer, INT64_MAX); + rc= memcached_string_append(string, buffer, SIZE_MAX); assert(rc == MEMCACHED_MEMORY_ALLOCATION_FAILURE); memcached_string_free(string); @@ -2632,13 +2843,6 @@ static test_return delete_buffer_generate(memcached_st *memc) return 0; } -static test_return free_data(memcached_st *memc __attribute__((unused))) -{ - pairs_free(global_pairs); - - return 0; -} - static test_return add_host_test1(memcached_st *memc) { unsigned int x; @@ -2732,9 +2936,13 @@ static memcached_return pre_crc(memcached_st *memc) static memcached_return pre_hsieh(memcached_st *memc) { +#ifdef HAVE_HSIEH_HASH memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_HASH, (uint64_t)MEMCACHED_HASH_HSIEH); - return MEMCACHED_SUCCESS; +#else + (void) memc; + return MEMCACHED_FAILURE; +#endif } static memcached_return pre_hash_fnv1_64(memcached_st *memc) @@ -2827,7 +3035,7 @@ static void my_free(memcached_st *ptr __attribute__((unused)), void *mem) static void *my_malloc(memcached_st *ptr __attribute__((unused)), const size_t size) { - return malloc(size); + return calloc(1, size); } static void *my_realloc(memcached_st *ptr __attribute__((unused)), void *mem, const size_t size) @@ -2904,37 +3112,45 @@ static memcached_return set_prefix(memcached_st *memc) static memcached_return set_memory_alloc(memcached_st *memc) { + void *test_ptr= NULL; + void *cb_ptr= NULL; { - memcached_malloc_function test_ptr; + memcached_malloc_function malloc_cb= + (memcached_malloc_function)my_malloc; + cb_ptr= *(void **)&malloc_cb; memcached_return rc; - rc= memcached_callback_set(memc, MEMCACHED_CALLBACK_MALLOC_FUNCTION, (void*)&my_malloc); + rc= memcached_callback_set(memc, MEMCACHED_CALLBACK_MALLOC_FUNCTION, cb_ptr); assert(rc == MEMCACHED_SUCCESS); - test_ptr= (memcached_malloc_function)memcached_callback_get(memc, MEMCACHED_CALLBACK_MALLOC_FUNCTION, &rc); + test_ptr= memcached_callback_get(memc, MEMCACHED_CALLBACK_MALLOC_FUNCTION, &rc); assert(rc == MEMCACHED_SUCCESS); - assert(test_ptr == my_malloc); + assert(test_ptr == cb_ptr); } { - memcached_realloc_function test_ptr; + memcached_realloc_function realloc_cb= + (memcached_realloc_function)my_realloc; + cb_ptr= *(void **)&realloc_cb; memcached_return rc; - rc= memcached_callback_set(memc, MEMCACHED_CALLBACK_REALLOC_FUNCTION, (void*)&my_realloc); + rc= memcached_callback_set(memc, MEMCACHED_CALLBACK_REALLOC_FUNCTION, cb_ptr); assert(rc == MEMCACHED_SUCCESS); - test_ptr= (memcached_realloc_function)memcached_callback_get(memc, MEMCACHED_CALLBACK_REALLOC_FUNCTION, &rc); + test_ptr= memcached_callback_get(memc, MEMCACHED_CALLBACK_REALLOC_FUNCTION, &rc); assert(rc == MEMCACHED_SUCCESS); - assert(test_ptr == my_realloc); + assert(test_ptr == cb_ptr); } { - memcached_free_function test_ptr; + memcached_free_function free_cb= + (memcached_free_function)my_free; + cb_ptr= *(void **)&free_cb; memcached_return rc; - rc= memcached_callback_set(memc, MEMCACHED_CALLBACK_FREE_FUNCTION, (void*)my_free); + rc= memcached_callback_set(memc, MEMCACHED_CALLBACK_FREE_FUNCTION, cb_ptr); assert(rc == MEMCACHED_SUCCESS); - test_ptr= (memcached_free_function)memcached_callback_get(memc, MEMCACHED_CALLBACK_FREE_FUNCTION, &rc); + test_ptr= memcached_callback_get(memc, MEMCACHED_CALLBACK_FREE_FUNCTION, &rc); assert(rc == MEMCACHED_SUCCESS); - assert(test_ptr == my_free); + assert(test_ptr == cb_ptr); } return MEMCACHED_SUCCESS; @@ -2945,7 +3161,8 @@ static memcached_return enable_consistent(memcached_st *memc) memcached_server_distribution value= MEMCACHED_DISTRIBUTION_CONSISTENT; memcached_hash hash; memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_DISTRIBUTION, value); - pre_hsieh(memc); + if (pre_hsieh(memc) != MEMCACHED_SUCCESS) + return MEMCACHED_FAILURE; value= (memcached_server_distribution)memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_DISTRIBUTION); assert(value == MEMCACHED_DISTRIBUTION_CONSISTENT); @@ -3079,7 +3296,7 @@ static test_return noreply_test(memcached_st *memc) ** way it is supposed to do!!!! */ int no_msg=0; - for (int x=0; x < memc->number_of_hosts; ++x) + for (uint32_t x=0; x < memc->number_of_hosts; ++x) no_msg+=memc->hosts[x].cursor_active; assert(no_msg == 0); @@ -3173,6 +3390,67 @@ static test_return analyzer_test(memcached_st *memc) return TEST_SUCCESS; } +#ifdef HAVE_LIBMEMCACHEDUTIL +static void* connection_release(void *arg) { + struct { + memcached_pool_st* pool; + memcached_st* mmc; + } *resource= arg; + + usleep(250); + assert(memcached_pool_push(resource->pool, resource->mmc) == MEMCACHED_SUCCESS); + return arg; +} + +static test_return connection_pool_test(memcached_st *memc) +{ + memcached_pool_st* pool= memcached_pool_create(memc, 5, 10); + assert(pool != NULL); + memcached_st* mmc[10]; + memcached_return rc; + + for (int x= 0; x < 10; ++x) { + mmc[x]= memcached_pool_pop(pool, false, &rc); + assert(mmc[x] != NULL); + assert(rc == MEMCACHED_SUCCESS); + } + + assert(memcached_pool_pop(pool, false, &rc) == NULL); + assert(rc == MEMCACHED_SUCCESS); + + pthread_t tid; + struct { + memcached_pool_st* pool; + memcached_st* mmc; + } item= { .pool = pool, .mmc = mmc[9] }; + pthread_create(&tid, NULL, connection_release, &item); + mmc[9]= memcached_pool_pop(pool, true, &rc); + assert(rc == MEMCACHED_SUCCESS); + pthread_join(tid, NULL); + assert(mmc[9] == item.mmc); + const char *key= "key"; + size_t keylen= strlen(key); + + // verify that I can do ops with all connections + rc= memcached_set(mmc[0], key, keylen, "0", 1, 0, 0); + assert(rc == MEMCACHED_SUCCESS); + + for (unsigned int x= 0; x < 10; ++x) { + uint64_t number_value; + rc= memcached_increment(mmc[x], key, keylen, 1, &number_value); + assert(rc == MEMCACHED_SUCCESS); + assert(number_value == (x+1)); + } + + // Release them.. + for (int x= 0; x < 10; ++x) + assert(memcached_pool_push(pool, mmc[x]) == MEMCACHED_SUCCESS); + + assert(memcached_pool_destroy(pool) == memc); + return TEST_SUCCESS; +} +#endif + static void increment_request_id(uint16_t *id) { (*id)++; @@ -3222,6 +3500,8 @@ static memcached_return init_udp(memcached_st *memc) unsigned int x= 0; memcached_server_st servers[num_hosts]; memcpy(servers, memc->hosts, sizeof(memcached_server_st) * num_hosts); + for (x= 0; x < num_hosts; x++) + memcached_server_free(&memc->hosts[x]); memc->number_of_hosts= 0; memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_USE_UDP, 1); for (x= 0; x < num_hosts; x++) @@ -3337,7 +3617,7 @@ static test_return udp_set_too_big_test(memcached_st *memc) return post_udp_op_check(memc,expected_ids); } -test_return udp_delete_test(memcached_st *memc) +static test_return udp_delete_test(memcached_st *memc) { unsigned int x= 0; unsigned int num_iters= 1025; //request id rolls over at 1024 @@ -3370,7 +3650,7 @@ static test_return udp_buffered_delete_test(memcached_st *memc) return udp_delete_test(memc); } -test_return udp_verbosity_test(memcached_st *memc) +static test_return udp_verbosity_test(memcached_st *memc) { memcached_return rc; uint16_t *expected_ids= get_udp_request_ids(memc); @@ -3383,14 +3663,14 @@ test_return udp_verbosity_test(memcached_st *memc) return post_udp_op_check(memc,expected_ids); } -test_return udp_quit_test(memcached_st *memc) +static test_return udp_quit_test(memcached_st *memc) { uint16_t *expected_ids= get_udp_request_ids(memc); memcached_quit(memc); return post_udp_op_check(memc, expected_ids); } -test_return udp_flush_test(memcached_st *memc) +static test_return udp_flush_test(memcached_st *memc) { memcached_return rc; uint16_t *expected_ids= get_udp_request_ids(memc); @@ -3403,7 +3683,7 @@ test_return udp_flush_test(memcached_st *memc) return post_udp_op_check(memc,expected_ids); } -test_return udp_incr_test(memcached_st *memc) +static test_return udp_incr_test(memcached_st *memc) { memcached_return rc; char *key= "incr"; @@ -3422,7 +3702,7 @@ test_return udp_incr_test(memcached_st *memc) return post_udp_op_check(memc, expected_ids); } -test_return udp_decr_test(memcached_st *memc) +static test_return udp_decr_test(memcached_st *memc) { memcached_return rc; char *key= "decr"; @@ -3442,7 +3722,7 @@ test_return udp_decr_test(memcached_st *memc) } -test_return udp_stat_test(memcached_st *memc) +static test_return udp_stat_test(memcached_st *memc) { memcached_stat_st * rv= NULL; memcached_return rc; @@ -3454,7 +3734,7 @@ test_return udp_stat_test(memcached_st *memc) return post_udp_op_check(memc, expected_ids); } -test_return udp_version_test(memcached_st *memc) +static test_return udp_version_test(memcached_st *memc) { memcached_return rc; uint16_t *expected_ids = get_udp_request_ids(memc); @@ -3463,7 +3743,7 @@ test_return udp_version_test(memcached_st *memc) return post_udp_op_check(memc, expected_ids); } -test_return udp_get_test(memcached_st *memc) +static test_return udp_get_test(memcached_st *memc) { memcached_return rc; char *key= "foo"; @@ -3475,7 +3755,7 @@ test_return udp_get_test(memcached_st *memc) return post_udp_op_check(memc, expected_ids); } -test_return udp_mixed_io_test(memcached_st *memc) +static test_return udp_mixed_io_test(memcached_st *memc) { test_st current_op; test_st mixed_io_ops [] ={ @@ -3498,6 +3778,18 @@ test_return udp_mixed_io_test(memcached_st *memc) return TEST_SUCCESS; } +static test_return hsieh_avaibility_test (memcached_st *memc) +{ + memcached_return expected_rc= MEMCACHED_FAILURE; +#ifdef HAVE_HSIEH_HASH + expected_rc= MEMCACHED_SUCCESS; +#endif + memcached_return rc= memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_HASH, + (uint64_t)MEMCACHED_HASH_HSIEH); + assert(rc == expected_rc); + return TEST_SUCCESS; +} + test_st udp_setup_server_tests[] ={ {"set_udp_behavior_test", 0, set_udp_behavior_test}, {"add_tcp_server_udp_client_test", 0, add_tcp_server_udp_client_test}, @@ -3533,6 +3825,9 @@ test_st tests[] ={ {"server_sort", 0, server_sort_test}, {"server_sort2", 0, server_sort2_test}, {"clone_test", 0, clone_test }, + {"connection_test", 0, connection_test}, + {"callback_test", 0, callback_test}, + {"behavior_test", 0, behavior_test}, {"error", 0, error_test }, {"set", 0, set_test }, {"set2", 0, set_test2 }, @@ -3544,9 +3839,12 @@ test_st tests[] ={ {"get2", 0, get_test2 }, {"get3", 0, get_test3 }, {"get4", 0, get_test4 }, + {"partial mget", 0, get_test5 }, {"stats_servername", 0, stats_servername_test }, {"increment", 0, increment_test }, + {"increment_with_initial", 1, increment_with_initial_test }, {"decrement", 0, decrement_test }, + {"decrement_with_initial", 1, decrement_with_initial_test }, {"quit", 0, quit_test }, {"mget", 1, mget_test }, {"mget_result", 1, mget_result_test }, @@ -3565,6 +3863,9 @@ test_st tests[] ={ {"delete_through", 1, delete_through }, {"noreply", 1, noreply_test}, {"analyzer", 1, analyzer_test}, +#ifdef HAVE_LIBMEMCACHEDUTIL + {"connectionpool", 1, connection_pool_test }, +#endif {0, 0, 0} }; @@ -3666,7 +3967,18 @@ test_st consistent_weighted_tests[] ={ {0, 0, 0} }; +test_st hsieh_availability[] ={ + {"hsieh_avaibility_test",0,hsieh_avaibility_test}, + {0, 0, 0} +}; + +test_st ketama_auto_eject_hosts[] ={ + {"auto_eject_hosts", 1, auto_eject_hosts }, + {0, 0, 0} +}; + collection_st collection[] ={ + {"hsieh_availability",0,0,hsieh_availability}, {"udp_setup", init_udp, 0, udp_setup_server_tests}, {"udp_io", init_udp, 0, upd_io_tests}, {"udp_binary_io", binary_init_udp, 0, upd_io_tests}, @@ -3684,6 +3996,7 @@ collection_st collection[] ={ {"fnv1_32", pre_hash_fnv1_32, 0, tests}, {"fnv1a_32", pre_hash_fnv1a_32, 0, tests}, {"ketama", pre_behavior_ketama, 0, tests}, + {"ketama_auto_eject_hosts", pre_behavior_ketama, 0, ketama_auto_eject_hosts}, {"unix_socket", pre_unix_socket, 0, tests}, {"unix_socket_nodelay", pre_nodelay, 0, tests}, {"poll_timeout", poll_timeout, 0, tests},