X-Git-Url: https://git.m6w6.name/?a=blobdiff_plain;f=tests%2Ffunction.c;h=46cce5657299384decd5fe3814e0d8187758fcb5;hb=cf20666bf118c2b5ed24db49992238385de009d1;hp=d15c1a0ce16b5b4155a2d3621cee0d048947a341;hpb=d4886582d42895961f560636cb7ada741a271c16;p=m6w6%2Flibmemcached diff --git a/tests/function.c b/tests/function.c index d15c1a0c..46cce565 100644 --- a/tests/function.c +++ b/tests/function.c @@ -94,7 +94,7 @@ static test_return server_sort_test(memcached_st *ptr __attribute__((unused))) for (x= 0; x < TEST_PORT_COUNT; x++) { - test_ports[x]= random() % 64000; + test_ports[x]= (uint32_t)random() % 64000; rc= memcached_server_add_with_weight(local_memc, "localhost", test_ports[x], 0); assert(local_memc->number_of_hosts == x + 1); assert(local_memc->hosts[0].count == x+1); @@ -165,7 +165,7 @@ static test_return server_unsort_test(memcached_st *ptr __attribute__((unused)) for (x= 0; x < TEST_PORT_COUNT; x++) { - test_ports[x]= random() % 64000; + test_ports[x]= (uint32_t)(random() % 64000); rc= memcached_server_add_with_weight(local_memc, "localhost", test_ports[x], 0); assert(local_memc->number_of_hosts == x+1); assert(local_memc->hosts[0].count == x+1); @@ -200,68 +200,79 @@ static test_return clone_test(memcached_st *memc) { /* All null? */ { - memcached_st *clone; - clone= memcached_clone(NULL, NULL); - assert(clone); - memcached_free(clone); + memcached_st *memc_clone; + memc_clone= memcached_clone(NULL, NULL); + assert(memc_clone); + memcached_free(memc_clone); } /* Can we init from null? */ { - 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); + memcached_st *memc_clone; + memc_clone= memcached_clone(NULL, memc); + assert(memc_clone); + + assert(memc_clone->call_free == memc->call_free); + assert(memc_clone->call_malloc == memc->call_malloc); + assert(memc_clone->call_realloc == memc->call_realloc); + assert(memc_clone->call_calloc == memc->call_calloc); + assert(memc_clone->connect_timeout == memc->connect_timeout); + assert(memc_clone->delete_trigger == memc->delete_trigger); + assert(memc_clone->distribution == memc->distribution); + assert(memc_clone->flags == memc->flags); + assert(memc_clone->get_key_failure == memc->get_key_failure); + assert(memc_clone->hash == memc->hash); + assert(memc_clone->hash_continuum == memc->hash_continuum); + assert(memc_clone->io_bytes_watermark == memc->io_bytes_watermark); + assert(memc_clone->io_msg_watermark == memc->io_msg_watermark); + assert(memc_clone->io_key_prefetch == memc->io_key_prefetch); + assert(memc_clone->on_cleanup == memc->on_cleanup); + assert(memc_clone->on_clone == memc->on_clone); + assert(memc_clone->poll_timeout == memc->poll_timeout); + assert(memc_clone->rcv_timeout == memc->rcv_timeout); + assert(memc_clone->recv_size == memc->recv_size); + assert(memc_clone->retry_timeout == memc->retry_timeout); + assert(memc_clone->send_size == memc->send_size); + assert(memc_clone->server_failure_limit == memc->server_failure_limit); + assert(memc_clone->snd_timeout == memc->snd_timeout); + assert(memc_clone->user_data == memc->user_data); + + memcached_free(memc_clone); } /* Can we init from struct? */ { memcached_st declared_clone; - memcached_st *clone; + memcached_st *memc_clone; memset(&declared_clone, 0 , sizeof(memcached_st)); - clone= memcached_clone(&declared_clone, NULL); - assert(clone); - memcached_free(clone); + memc_clone= memcached_clone(&declared_clone, NULL); + assert(memc_clone); + memcached_free(memc_clone); } /* Can we init from struct? */ { memcached_st declared_clone; - memcached_st *clone; + memcached_st *memc_clone; memset(&declared_clone, 0 , sizeof(memcached_st)); - clone= memcached_clone(&declared_clone, memc); - assert(clone); - memcached_free(clone); + memc_clone= memcached_clone(&declared_clone, memc); + assert(memc_clone); + memcached_free(memc_clone); } return 0; } +static test_return userdata_test(memcached_st *memc) +{ + void* foo= NULL; + assert(memcached_set_user_data(memc, foo) == NULL); + assert(memcached_get_user_data(memc) == foo); + assert(memcached_set_user_data(memc, NULL) == foo); + + return TEST_SUCCESS; +} + static test_return connection_test(memcached_st *memc) { memcached_return rc; @@ -646,29 +657,29 @@ static test_return bad_key_test(memcached_st *memc) char *string; size_t string_length; uint32_t flags; - memcached_st *clone; + memcached_st *memc_clone; unsigned int set= 1; size_t max_keylen= 0xffff; - clone= memcached_clone(NULL, memc); - assert(clone); + memc_clone= memcached_clone(NULL, memc); + assert(memc_clone); - rc= memcached_behavior_set(clone, MEMCACHED_BEHAVIOR_VERIFY_KEY, set); + rc= memcached_behavior_set(memc_clone, MEMCACHED_BEHAVIOR_VERIFY_KEY, set); assert(rc == MEMCACHED_SUCCESS); /* All keys are valid in the binary protocol (except for length) */ - if (memcached_behavior_get(clone, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL) == 0) + if (memcached_behavior_get(memc_clone, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL) == 0) { - string= memcached_get(clone, key, strlen(key), + string= memcached_get(memc_clone, key, strlen(key), &string_length, &flags, &rc); assert(rc == MEMCACHED_BAD_KEY_PROVIDED); assert(string_length == 0); assert(!string); set= 0; - rc= memcached_behavior_set(clone, MEMCACHED_BEHAVIOR_VERIFY_KEY, set); + rc= memcached_behavior_set(memc_clone, MEMCACHED_BEHAVIOR_VERIFY_KEY, set); assert(rc == MEMCACHED_SUCCESS); - string= memcached_get(clone, key, strlen(key), + string= memcached_get(memc_clone, key, strlen(key), &string_length, &flags, &rc); assert(rc == MEMCACHED_NOTFOUND); assert(string_length == 0); @@ -678,13 +689,13 @@ static test_return bad_key_test(memcached_st *memc) char *keys[] = { "GoodKey", "Bad Key", "NotMine" }; size_t key_lengths[] = { 7, 7, 7 }; set= 1; - rc= memcached_behavior_set(clone, MEMCACHED_BEHAVIOR_VERIFY_KEY, set); + rc= memcached_behavior_set(memc_clone, MEMCACHED_BEHAVIOR_VERIFY_KEY, set); assert(rc == MEMCACHED_SUCCESS); - rc= memcached_mget(clone, keys, key_lengths, 3); + rc= memcached_mget(memc_clone, keys, key_lengths, 3); assert(rc == MEMCACHED_BAD_KEY_PROVIDED); - rc= memcached_mget_by_key(clone, "foo daddy", 9, keys, key_lengths, 1); + rc= memcached_mget_by_key(memc_clone, "foo daddy", 9, keys, key_lengths, 1); assert(rc == MEMCACHED_BAD_KEY_PROVIDED); max_keylen= 250; @@ -693,20 +704,20 @@ static test_return bad_key_test(memcached_st *memc) memcached server is updated to allow max size length of the keys in the binary protocol */ - rc= memcached_callback_set(clone, MEMCACHED_CALLBACK_PREFIX_KEY, NULL); + rc= memcached_callback_set(memc_clone, MEMCACHED_CALLBACK_PREFIX_KEY, NULL); assert(rc == MEMCACHED_SUCCESS); char *longkey= malloc(max_keylen + 1); if (longkey != NULL) { memset(longkey, 'a', max_keylen + 1); - string= memcached_get(clone, longkey, max_keylen, + string= memcached_get(memc_clone, longkey, max_keylen, &string_length, &flags, &rc); assert(rc == MEMCACHED_NOTFOUND); assert(string_length == 0); assert(!string); - string= memcached_get(clone, longkey, max_keylen + 1, + string= memcached_get(memc_clone, longkey, max_keylen + 1, &string_length, &flags, &rc); assert(rc == MEMCACHED_BAD_KEY_PROVIDED); assert(string_length == 0); @@ -718,15 +729,15 @@ static test_return bad_key_test(memcached_st *memc) /* Make sure zero length keys are marked as bad */ set= 1; - rc= memcached_behavior_set(clone, MEMCACHED_BEHAVIOR_VERIFY_KEY, set); + rc= memcached_behavior_set(memc_clone, MEMCACHED_BEHAVIOR_VERIFY_KEY, set); assert(rc == MEMCACHED_SUCCESS); - string= memcached_get(clone, key, 0, + string= memcached_get(memc_clone, key, 0, &string_length, &flags, &rc); assert(rc == MEMCACHED_BAD_KEY_PROVIDED); assert(string_length == 0); assert(!string); - memcached_free(clone); + memcached_free(memc_clone); return 0; } @@ -1024,8 +1035,8 @@ static test_return get_test5(memcached_st *memc) static test_return stats_servername_test(memcached_st *memc) { memcached_return rc; - memcached_stat_st stat; - rc= memcached_stat_servername(&stat, NULL, + memcached_stat_st memc_stat; + rc= memcached_stat_servername(&memc_stat, NULL, memc->hosts[0].hostname, memc->hosts[0].port); @@ -1355,10 +1366,10 @@ static test_return get_stats_keys(memcached_st *memc) { char **list; char **ptr; - memcached_stat_st stat; + memcached_stat_st memc_stat; memcached_return rc; - list= memcached_stat_get_keys(memc, &stat, &rc); + list= memcached_stat_get_keys(memc, &memc_stat, &rc); assert(rc == MEMCACHED_SUCCESS); for (ptr= list; *ptr; ptr++) assert(*ptr); @@ -1386,24 +1397,24 @@ static test_return get_stats(memcached_st *memc) char **list; char **ptr; memcached_return rc; - memcached_stat_st *stat; + memcached_stat_st *memc_stat; - stat= memcached_stat(memc, NULL, &rc); + memc_stat= memcached_stat(memc, NULL, &rc); assert(rc == MEMCACHED_SUCCESS); assert(rc == MEMCACHED_SUCCESS); - assert(stat); + assert(memc_stat); for (x= 0; x < memcached_server_count(memc); x++) { - list= memcached_stat_get_keys(memc, stat+x, &rc); + list= memcached_stat_get_keys(memc, memc_stat+x, &rc); assert(rc == MEMCACHED_SUCCESS); for (ptr= list; *ptr; ptr++); free(list); } - memcached_stat_free(NULL, stat); + memcached_stat_free(NULL, memc_stat); return 0; } @@ -1440,7 +1451,7 @@ static test_return add_host_test(memcached_st *memc) return 0; } -static memcached_return clone_test_callback(memcached_st *parent __attribute__((unused)), memcached_st *clone __attribute__((unused))) +static memcached_return clone_test_callback(memcached_st *parent __attribute__((unused)), memcached_st *memc_clone __attribute__((unused))) { return MEMCACHED_SUCCESS; } @@ -1541,6 +1552,9 @@ static test_return behavior_test(memcached_st *memc) value= memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_SOCKET_RECV_SIZE); assert(value > 0); + value= memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_NUMBER_OF_REPLICAS); + memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_NUMBER_OF_REPLICAS, value + 1); + assert((value + 1) == memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_NUMBER_OF_REPLICAS)); return 0; } @@ -1570,12 +1584,12 @@ static test_return user_supplied_bug1(memcached_st *memc) { unsigned int j= 0; - size= (rand() % ( 5 * 1024 ) ) + 400; + size= (uint32_t)(rand() % ( 5 * 1024 ) ) + 400; memset(randomstuff, 0, 6 * 1024); assert(size < 6 * 1024); /* Being safe here */ for (j= 0 ; j < size ;j++) - randomstuff[j] = (char) (rand() % 26) + 97; + randomstuff[j] = (signed char) ((rand() % 26) + 97); total += size; sprintf(key, "%d", x); @@ -1787,7 +1801,7 @@ static test_return user_supplied_bug5(memcached_st *memc) char insert_data[VALUE_SIZE_BUG5]; for (x= 0; x < VALUE_SIZE_BUG5; x++) - insert_data[x]= rand(); + insert_data[x]= (signed char)rand(); memcached_flush(memc, 0); value= memcached_get(memc, keys[0], key_length[0], @@ -1845,7 +1859,7 @@ static test_return user_supplied_bug6(memcached_st *memc) char insert_data[VALUE_SIZE_BUG5]; for (x= 0; x < VALUE_SIZE_BUG5; x++) - insert_data[x]= rand(); + insert_data[x]= (signed char)rand(); memcached_flush(memc, 0); value= memcached_get(memc, keys[0], key_length[0], @@ -1899,7 +1913,7 @@ static test_return user_supplied_bug8(memcached_st *memc __attribute__((unused) { memcached_return rc; memcached_st *mine; - memcached_st *clone; + memcached_st *memc_clone; memcached_server_st *servers; char *server_list= "memcache1.memcache.bk.sapo.pt:11211, memcache1.memcache.bk.sapo.pt:11212, memcache1.memcache.bk.sapo.pt:11213, memcache1.memcache.bk.sapo.pt:11214, memcache2.memcache.bk.sapo.pt:11211, memcache2.memcache.bk.sapo.pt:11212, memcache2.memcache.bk.sapo.pt:11213, memcache2.memcache.bk.sapo.pt:11214"; @@ -1913,14 +1927,14 @@ static test_return user_supplied_bug8(memcached_st *memc __attribute__((unused) memcached_server_list_free(servers); assert(mine); - clone= memcached_clone(NULL, mine); + memc_clone= memcached_clone(NULL, mine); memcached_quit(mine); - memcached_quit(clone); + memcached_quit(memc_clone); memcached_free(mine); - memcached_free(clone); + memcached_free(memc_clone); return 0; } @@ -1940,7 +1954,7 @@ static test_return user_supplied_bug7(memcached_st *memc) char insert_data[VALUE_SIZE_BUG5]; for (x= 0; x < VALUE_SIZE_BUG5; x++) - insert_data[x]= rand(); + insert_data[x]= (signed char)rand(); memcached_flush(memc, 0); @@ -2021,7 +2035,7 @@ static test_return user_supplied_bug10(memcached_st *memc) char *value; size_t value_length= 512; unsigned int x; - int key_len= 3; + size_t key_len= 3; memcached_return rc; unsigned int set= 1; memcached_st *mclone= memcached_clone(NULL, memc); @@ -2030,7 +2044,8 @@ static test_return user_supplied_bug10(memcached_st *memc) memcached_behavior_set(mclone, MEMCACHED_BEHAVIOR_NO_BLOCK, set); memcached_behavior_set(mclone, MEMCACHED_BEHAVIOR_TCP_NODELAY, set); timeout= 2; - memcached_behavior_set(mclone, MEMCACHED_BEHAVIOR_POLL_TIMEOUT, timeout); + memcached_behavior_set(mclone, MEMCACHED_BEHAVIOR_POLL_TIMEOUT, + (uint64_t)timeout); value = (char*)malloc(value_length * sizeof(char)); @@ -2063,7 +2078,7 @@ static test_return user_supplied_bug11(memcached_st *memc) char *value; size_t value_length= 512; unsigned int x; - int key_len= 3; + size_t key_len= 3; memcached_return rc; unsigned int set= 1; int32_t timeout; @@ -2072,7 +2087,8 @@ static test_return user_supplied_bug11(memcached_st *memc) memcached_behavior_set(mclone, MEMCACHED_BEHAVIOR_NO_BLOCK, set); memcached_behavior_set(mclone, MEMCACHED_BEHAVIOR_TCP_NODELAY, set); timeout= -1; - memcached_behavior_set(mclone, MEMCACHED_BEHAVIOR_POLL_TIMEOUT, timeout); + memcached_behavior_set(mclone, MEMCACHED_BEHAVIOR_POLL_TIMEOUT, + (size_t)timeout); timeout= (int32_t)memcached_behavior_get(mclone, MEMCACHED_BEHAVIOR_POLL_TIMEOUT); @@ -2180,7 +2196,7 @@ static test_return user_supplied_bug13(memcached_st *memc) */ static test_return user_supplied_bug14(memcached_st *memc) { - int setter= 1; + size_t setter= 1; memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_TCP_NODELAY, setter); memcached_return rc; char *key= "foo"; @@ -2373,7 +2389,7 @@ static test_return user_supplied_bug20(memcached_st *memc) static test_return user_supplied_bug18(memcached_st *trash) { memcached_return rc; - int value; + uint64_t value; int x; memcached_server_st *server_pool; memcached_st *memc; @@ -2685,7 +2701,7 @@ static test_return generate_data_with_stats(memcached_st *memc) } static test_return generate_buffer_data(memcached_st *memc) { - int latch= 0; + size_t latch= 0; latch= 1; memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_BUFFER_REQUESTS, latch); @@ -2698,12 +2714,12 @@ static test_return get_read_count(memcached_st *memc) { unsigned int x; memcached_return rc; - memcached_st *clone; + memcached_st *memc_clone; - clone= memcached_clone(NULL, memc); - assert(clone); + memc_clone= memcached_clone(NULL, memc); + assert(memc_clone); - memcached_server_add_with_weight(clone, "localhost", 6666, 0); + memcached_server_add_with_weight(memc_clone, "localhost", 6666, 0); { char *return_value; @@ -2713,7 +2729,7 @@ static test_return get_read_count(memcached_st *memc) for (x= count= 0; x < global_count; x++) { - return_value= memcached_get(clone, global_keys[x], global_keys_length[x], + return_value= memcached_get(memc_clone, global_keys[x], global_keys_length[x], &return_value_length, &flags, &rc); if (rc == MEMCACHED_SUCCESS) { @@ -2725,7 +2741,7 @@ static test_return get_read_count(memcached_st *memc) fprintf(stderr, "\t%u -> %u", global_count, count); } - memcached_free(clone); + memcached_free(memc_clone); return 0; } @@ -2837,7 +2853,7 @@ static test_return delete_generate(memcached_st *memc) static test_return delete_buffer_generate(memcached_st *memc) { - int latch= 0; + size_t latch= 0; unsigned int x; latch= 1; @@ -2893,15 +2909,15 @@ static memcached_return pre_nonblock(memcached_st *memc) static memcached_return pre_nonblock_binary(memcached_st *memc) { memcached_return rc= MEMCACHED_FAILURE; - memcached_st *clone; + memcached_st *memc_clone; - clone= memcached_clone(NULL, memc); - assert(clone); + memc_clone= memcached_clone(NULL, memc); + assert(memc_clone); // The memcached_version needs to be done on a clone, because the server // will not toggle protocol on an connection. - memcached_version(clone); + memcached_version(memc_clone); - if (clone->hosts[0].major_version >= 1 && clone->hosts[0].minor_version > 2) + if (memc_clone->hosts[0].major_version >= 1 && memc_clone->hosts[0].minor_version > 2) { memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_NO_BLOCK, 0); rc = memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL, 1); @@ -2909,7 +2925,7 @@ static memcached_return pre_nonblock_binary(memcached_st *memc) assert(memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL) == 1); } - memcached_free(clone); + memcached_free(memc_clone); return rc; } @@ -3017,22 +3033,40 @@ static memcached_return pre_behavior_ketama_weighted(memcached_st *memc) static memcached_return pre_binary(memcached_st *memc) { memcached_return rc= MEMCACHED_FAILURE; - memcached_st *clone; + memcached_st *memc_clone; - clone= memcached_clone(NULL, memc); - assert(clone); + memc_clone= memcached_clone(NULL, memc); + assert(memc_clone); // The memcached_version needs to be done on a clone, because the server // will not toggle protocol on an connection. - memcached_version(clone); + memcached_version(memc_clone); - if (clone->hosts[0].major_version >= 1 && clone->hosts[0].minor_version > 2) + if (memc_clone->hosts[0].major_version >= 1 && memc_clone->hosts[0].minor_version > 2) { rc = memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL, 1); assert(rc == MEMCACHED_SUCCESS); assert(memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL) == 1); } - memcached_free(clone); + memcached_free(memc_clone); + return rc; +} + +static memcached_return pre_replication(memcached_st *memc) +{ + memcached_return rc= MEMCACHED_FAILURE; + if (pre_binary(memc) == MEMCACHED_SUCCESS) + { + /* + * Make sure that we store the item on all servers + * (master + replicas == number of servers) + */ + rc= memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_NUMBER_OF_REPLICAS, + memc->number_of_hosts - 1); + assert(rc == MEMCACHED_SUCCESS); + assert(memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_NUMBER_OF_REPLICAS) == memc->number_of_hosts - 1); + } + return rc; } @@ -3043,7 +3077,11 @@ 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 calloc(1, size); + void *ret= malloc(size); + if (ret != NULL) + memset(ret, 0xff, size); + + return ret; } static void *my_realloc(memcached_st *ptr __attribute__((unused)), void *mem, const size_t size) @@ -3051,6 +3089,11 @@ static void *my_realloc(memcached_st *ptr __attribute__((unused)), void *mem, co return realloc(mem, size); } +static void *my_calloc(memcached_st *ptr __attribute__((unused)), size_t nelem, const size_t size) +{ + return calloc(nelem, size); +} + static memcached_return set_prefix(memcached_st *memc) { memcached_return rc; @@ -3118,7 +3161,8 @@ static memcached_return set_prefix(memcached_st *memc) return MEMCACHED_SUCCESS; } -static memcached_return set_memory_alloc(memcached_st *memc) +#ifdef MEMCACHED_ENABLE_DEPRECATED +static memcached_return deprecated_set_memory_alloc(memcached_st *memc) { void *test_ptr= NULL; void *cb_ptr= NULL; @@ -3160,6 +3204,31 @@ static memcached_return set_memory_alloc(memcached_st *memc) assert(rc == MEMCACHED_SUCCESS); assert(test_ptr == cb_ptr); } + return MEMCACHED_SUCCESS; +} +#endif + +static memcached_return set_memory_alloc(memcached_st *memc) +{ + memcached_return rc; + rc= memcached_set_memory_allocators(memc, NULL, my_free, + my_realloc, my_calloc); + assert(rc == MEMCACHED_FAILURE); + + rc= memcached_set_memory_allocators(memc, my_malloc, my_free, + my_realloc, my_calloc); + + memcached_malloc_function mem_malloc; + memcached_free_function mem_free; + memcached_realloc_function mem_realloc; + memcached_calloc_function mem_calloc; + memcached_get_memory_allocators(memc, &mem_malloc, &mem_free, + &mem_realloc, &mem_calloc); + + assert(mem_malloc == my_malloc); + assert(mem_realloc == my_realloc); + assert(mem_calloc == my_calloc); + assert(mem_free == my_free); return MEMCACHED_SUCCESS; } @@ -3245,13 +3314,13 @@ static memcached_return pre_settimer(memcached_st *memc) static memcached_return poll_timeout(memcached_st *memc) { - int32_t timeout; + size_t timeout; timeout= 100; memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_POLL_TIMEOUT, timeout); - timeout= (int32_t)memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_POLL_TIMEOUT); + timeout= memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_POLL_TIMEOUT); assert(timeout == 100); @@ -3276,7 +3345,7 @@ static test_return noreply_test(memcached_st *memc) for (int x=0; x < 100; ++x) { char key[10]; - size_t len= sprintf(key, "%d", x); + size_t len= (size_t)sprintf(key, "%d", x); switch (count) { case 0: @@ -3294,6 +3363,9 @@ static test_return noreply_test(memcached_st *memc) case 4: ret=memcached_prepend(memc, key, len, key, len, 0, 0); break; + default: + assert(count); + break; } assert(ret == MEMCACHED_SUCCESS || ret == MEMCACHED_BUFFERED); } @@ -3305,7 +3377,7 @@ static test_return noreply_test(memcached_st *memc) */ int no_msg=0; for (uint32_t x=0; x < memc->number_of_hosts; ++x) - no_msg+=memc->hosts[x].cursor_active; + no_msg+=(int)(memc->hosts[x].cursor_active); assert(no_msg == 0); assert(memcached_flush_buffers(memc) == MEMCACHED_SUCCESS); @@ -3316,7 +3388,7 @@ static test_return noreply_test(memcached_st *memc) for (int x=0; x < 100; ++x) { char key[10]; - size_t len= sprintf(key, "%d", x); + size_t len= (size_t)sprintf(key, "%d", x); size_t length; uint32_t flags; char* value=memcached_get(memc, key, strlen(key), @@ -3336,6 +3408,9 @@ static test_return noreply_test(memcached_st *memc) case 4: assert(length == len * 3); break; + default: + assert(count); + break; } free(value); } @@ -3381,19 +3456,19 @@ static test_return noreply_test(memcached_st *memc) static test_return analyzer_test(memcached_st *memc) { memcached_return rc; - memcached_stat_st *stat; + memcached_stat_st *memc_stat; memcached_analysis_st *report; - stat= memcached_stat(memc, NULL, &rc); + memc_stat= memcached_stat(memc, NULL, &rc); assert(rc == MEMCACHED_SUCCESS); - assert(stat); + assert(memc_stat); - report= memcached_analyze(memc, stat, &rc); + report= memcached_analyze(memc, memc_stat, &rc); assert(rc == MEMCACHED_SUCCESS); assert(report); free(report); - memcached_stat_free(NULL, stat); + memcached_stat_free(NULL, memc_stat); return TEST_SUCCESS; } @@ -3498,6 +3573,179 @@ static test_return connection_pool_test(memcached_st *memc) } #endif +static test_return replication_set_test(memcached_st *memc) +{ + memcached_return rc; + memcached_st *clone= memcached_clone(NULL, memc); + memcached_behavior_set(clone, MEMCACHED_BEHAVIOR_NUMBER_OF_REPLICAS, 0); + + rc= memcached_set(memc, "bubba", 5, "0", 1, 0, 0); + assert(rc == MEMCACHED_SUCCESS); + + /* + ** "bubba" should now be stored on all of our servers. We don't have an + ** easy to use API to address each individual server, so I'll just iterate + ** through a bunch of "master keys" and I should most likely hit all of the + ** servers... + */ + for (int x= 'a'; x <= 'z'; ++x) + { + char key[2]= { [0]= (char)x }; + size_t len; + uint32_t flags; + char *val= memcached_get_by_key(clone, key, 1, "bubba", 5, + &len, &flags, &rc); + assert(rc == MEMCACHED_SUCCESS); + assert(val != NULL); + free(val); + } + + memcached_free(clone); + + return TEST_SUCCESS; +} + +static test_return replication_get_test(memcached_st *memc) +{ + memcached_return rc; + + /* + * Don't do the following in your code. I am abusing the internal details + * within the library, and this is not a supported interface. + * This is to verify correct behavior in the library + */ + for (uint32_t host= 0; host < memc->number_of_hosts; ++host) + { + memcached_st *clone= memcached_clone(NULL, memc); + clone->hosts[host].port= 0; + + for (int x= 'a'; x <= 'z'; ++x) + { + char key[2]= { [0]= (char)x }; + size_t len; + uint32_t flags; + char *val= memcached_get_by_key(clone, key, 1, "bubba", 5, + &len, &flags, &rc); + assert(rc == MEMCACHED_SUCCESS); + assert(val != NULL); + free(val); + } + + memcached_free(clone); + } + + return TEST_SUCCESS; +} + +static test_return replication_mget_test(memcached_st *memc) +{ + memcached_return rc; + memcached_st *clone= memcached_clone(NULL, memc); + memcached_behavior_set(clone, MEMCACHED_BEHAVIOR_NUMBER_OF_REPLICAS, 0); + + char *keys[]= { "bubba", "key1", "key2", "key3" }; + size_t len[]= { 5, 4, 4, 4 }; + + for (int x=0; x< 4; ++x) + { + rc= memcached_set(memc, keys[x], len[x], "0", 1, 0, 0); + assert(rc == MEMCACHED_SUCCESS); + } + + /* + * Don't do the following in your code. I am abusing the internal details + * within the library, and this is not a supported interface. + * This is to verify correct behavior in the library + */ + memcached_result_st result_obj; + for (uint32_t host= 0; host < clone->number_of_hosts; host++) + { + memcached_st *new_clone= memcached_clone(NULL, memc); + new_clone->hosts[host].port= 0; + + for (int x= 'a'; x <= 'z'; ++x) + { + char key[2]= { [0]= (char)x }; + + rc= memcached_mget_by_key(new_clone, key, 1, keys, len, 4); + assert(rc == MEMCACHED_SUCCESS); + + memcached_result_st *results= memcached_result_create(new_clone, &result_obj); + assert(results); + + int hits= 0; + while ((results= memcached_fetch_result(new_clone, &result_obj, &rc)) != NULL) + { + hits++; + } + assert(hits == 4); + memcached_result_free(&result_obj); + } + + memcached_free(new_clone); + } + + return TEST_SUCCESS; +} + +static test_return replication_delete_test(memcached_st *memc) +{ + memcached_return rc; + memcached_st *clone= memcached_clone(NULL, memc); + /* Delete the items from all of the servers except 1 */ + uint64_t repl= memcached_behavior_get(memc, + MEMCACHED_BEHAVIOR_NUMBER_OF_REPLICAS); + memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_NUMBER_OF_REPLICAS, --repl); + + char *keys[]= { "bubba", "key1", "key2", "key3" }; + size_t len[]= { 5, 4, 4, 4 }; + + for (int x=0; x< 4; ++x) + { + rc= memcached_delete_by_key(memc, keys[0], len[0], keys[x], len[x], 0); + assert(rc == MEMCACHED_SUCCESS); + } + + /* + * Don't do the following in your code. I am abusing the internal details + * within the library, and this is not a supported interface. + * This is to verify correct behavior in the library + */ + uint32_t hash= memcached_generate_hash(memc, keys[0], len[0]); + for (uint32_t x= 0; x < (repl + 1); ++x) + { + clone->hosts[hash].port= 0; + if (++hash == clone->number_of_hosts) + hash= 0; + } + + memcached_result_st result_obj; + for (uint32_t host= 0; host < clone->number_of_hosts; ++host) + { + for (int x= 'a'; x <= 'z'; ++x) + { + char key[2]= { [0]= (char)x }; + + rc= memcached_mget_by_key(clone, key, 1, keys, len, 4); + assert(rc == MEMCACHED_SUCCESS); + + memcached_result_st *results= memcached_result_create(clone, &result_obj); + assert(results); + + int hits= 0; + while ((results= memcached_fetch_result(clone, &result_obj, &rc)) != NULL) + { + ++hits; + } + assert(hits == 4); + memcached_result_free(&result_obj); + } + } + memcached_free(clone); + + return TEST_SUCCESS; +} + static void increment_request_id(uint16_t *id) { (*id)++; @@ -3510,6 +3758,7 @@ static uint16_t *get_udp_request_ids(memcached_st *memc) uint16_t *ids= malloc(sizeof(uint16_t) * memc->number_of_hosts); assert(ids != NULL); unsigned int x; + for (x= 0; x < memc->number_of_hosts; x++) ids[x]= get_udp_datagram_request_id((struct udp_datagram_header_st *) memc->hosts[x].write_buffer); @@ -3521,6 +3770,7 @@ static test_return post_udp_op_check(memcached_st *memc, uint16_t *expected_req_ unsigned int x; memcached_server_st *cur_server = memc->hosts; uint16_t *cur_req_ids = get_udp_request_ids(memc); + for (x= 0; x < memc->number_of_hosts; x++) { assert(cur_server[x].cursor_active == 0); @@ -3528,6 +3778,7 @@ static test_return post_udp_op_check(memcached_st *memc, uint16_t *expected_req_ } free(expected_req_ids); free(cur_req_ids); + return TEST_SUCCESS; } @@ -3549,6 +3800,7 @@ static memcached_return init_udp(memcached_st *memc) 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++) @@ -3556,6 +3808,7 @@ static memcached_return init_udp(memcached_st *memc) assert(memcached_server_add_udp(memc, servers[x].hostname, servers[x].port) == MEMCACHED_SUCCESS); assert(memc->hosts[x].write_buffer_offset == UDP_DATAGRAM_HEADER_LENGTH); } + return MEMCACHED_SUCCESS; } @@ -3871,11 +4124,13 @@ static test_return md5_run (memcached_st *memc __attribute__((unused))) { uint32_t x; char **ptr; - uint32_t values[]= { 3195025439, 2556848621, 3724893440, 3332385401, 245758794, 2550894432, - 121710495, 3053817768, 1250994555, 1862072655, 2631955953, 2951528551, - 1451250070, 2820856945, 2060845566, 3646985608, 2138080750, 217675895, - 2230934345, 1234361223, 3968582726, 2455685270, 1293568479, 199067604, - 2042482093 }; + uint32_t values[]= { 3195025439U, 2556848621U, 3724893440U, 3332385401U, + 245758794U, 2550894432U, 121710495U, 3053817768U, + 1250994555U, 1862072655U, 2631955953U, 2951528551U, + 1451250070U, 2820856945U, 2060845566U, 3646985608U, + 2138080750U, 217675895U, 2230934345U, 1234361223U, + 3968582726U, 2455685270U, 1293568479U, 199067604U, + 2042482093U }; for (ptr= list, x= 0; *ptr; ptr++, x++) @@ -3893,9 +4148,10 @@ static test_return crc_run (memcached_st *memc __attribute__((unused))) { uint32_t x; char **ptr; - uint32_t values[]= { 10542, 22009, 14526, 19510, 19432, 10199, 20634, 9369, 11511, 10362, - 7893, 31289, 11313, 9354, 7621, 30628, 15218, 25967, 2695, 9380, - 17300, 28156, 9192, 20484, 16925 }; + uint32_t values[]= { 10542U, 22009U, 14526U, 19510U, 19432U, 10199U, 20634U, + 9369U, 11511U, 10362U, 7893U, 31289U, 11313U, 9354U, + 7621U, 30628U, 15218U, 25967U, 2695U, 9380U, + 17300U, 28156U, 9192U, 20484U, 16925U }; for (ptr= list, x= 0; *ptr; ptr++, x++) { @@ -3912,11 +4168,13 @@ static test_return fnv1_64_run (memcached_st *memc __attribute__((unused))) { uint32_t x; char **ptr; - uint32_t values[]= { 473199127, 4148981457, 3971873300, 3257986707, 1722477987, 2991193800, - 4147007314, 3633179701, 1805162104, 3503289120, 3395702895, 3325073042, - 2345265314, 3340346032, 2722964135, 1173398992, 2815549194, 2562818319, - 224996066, 2680194749, 3035305390, 246890365, 2395624193, 4145193337, - 1801941682 }; + uint32_t values[]= { 473199127U, 4148981457U, 3971873300U, 3257986707U, + 1722477987U, 2991193800U, 4147007314U, 3633179701U, + 1805162104U, 3503289120U, 3395702895U, 3325073042U, + 2345265314U, 3340346032U, 2722964135U, 1173398992U, + 2815549194U, 2562818319U, 224996066U, 2680194749U, + 3035305390U, 246890365U, 2395624193U, 4145193337U, + 1801941682U }; for (ptr= list, x= 0; *ptr; ptr++, x++) { @@ -3933,11 +4191,13 @@ static test_return fnv1a_64_run (memcached_st *memc __attribute__((unused))) { uint32_t x; char **ptr; - uint32_t values[]= { 1488911807, 2500855813, 1510099634, 1390325195, 3647689787, 3241528582, - 1669328060, 2604311949, 734810122, 1516407546, 560948863, 1767346780, - 561034892, 4156330026, 3716417003, 3475297030, 1518272172, 227211583, - 3938128828, 126112909, 3043416448, 3131561933, 1328739897, 2455664041, - 2272238452 }; + uint32_t values[]= { 1488911807U, 2500855813U, 1510099634U, 1390325195U, + 3647689787U, 3241528582U, 1669328060U, 2604311949U, + 734810122U, 1516407546U, 560948863U, 1767346780U, + 561034892U, 4156330026U, 3716417003U, 3475297030U, + 1518272172U, 227211583U, 3938128828U, 126112909U, + 3043416448U, 3131561933U, 1328739897U, 2455664041U, + 2272238452U }; for (ptr= list, x= 0; *ptr; ptr++, x++) { @@ -3954,10 +4214,13 @@ static test_return fnv1_32_run (memcached_st *memc __attribute__((unused))) { uint32_t x; char **ptr; - uint32_t values[]= { 67176023, 1190179409, 2043204404, 3221866419, 2567703427, 3787535528, 4147287986, - 3500475733, 344481048, 3865235296, 2181839183, 119581266, 510234242, 4248244304, - 1362796839, 103389328, 1449620010, 182962511, 3554262370, 3206747549, 1551306158, - 4127558461, 1889140833, 2774173721, 1180552018 }; + uint32_t values[]= { 67176023U, 1190179409U, 2043204404U, 3221866419U, + 2567703427U, 3787535528U, 4147287986U, 3500475733U, + 344481048U, 3865235296U, 2181839183U, 119581266U, + 510234242U, 4248244304U, 1362796839U, 103389328U, + 1449620010U, 182962511U, 3554262370U, 3206747549U, + 1551306158U, 4127558461U, 1889140833U, 2774173721U, + 1180552018U }; for (ptr= list, x= 0; *ptr; ptr++, x++) @@ -3975,10 +4238,13 @@ static test_return fnv1a_32_run (memcached_st *memc __attribute__((unused))) { uint32_t x; char **ptr; - uint32_t values[]= { 280767167, 2421315013, 3072375666, 855001899, 459261019, 3521085446, 18738364, - 1625305005, 2162232970, 777243802, 3323728671, 132336572, 3654473228, 260679466, - 1169454059, 2698319462, 1062177260, 235516991, 2218399068, 405302637, 1128467232, - 3579622413, 2138539289, 96429129, 2877453236 }; + uint32_t values[]= { 280767167U, 2421315013U, 3072375666U, 855001899U, + 459261019U, 3521085446U, 18738364U, 1625305005U, + 2162232970U, 777243802U, 3323728671U, 132336572U, + 3654473228U, 260679466U, 1169454059U, 2698319462U, + 1062177260U, 235516991U, 2218399068U, 405302637U, + 1128467232U, 3579622413U, 2138539289U, 96429129U, + 2877453236U }; for (ptr= list, x= 0; *ptr; ptr++, x++) { @@ -4020,11 +4286,13 @@ static test_return murmur_run (memcached_st *memc __attribute__((unused))) { uint32_t x; char **ptr; - uint32_t values[]= { 473199127, 4148981457, 3971873300, 3257986707, 1722477987, 2991193800, - 4147007314, 3633179701, 1805162104, 3503289120, 3395702895, 3325073042, - 2345265314, 3340346032, 2722964135, 1173398992, 2815549194, 2562818319, - 224996066, 2680194749, 3035305390, 246890365, 2395624193, 4145193337, - 1801941682 }; + uint32_t values[]= { 473199127U, 4148981457U, 3971873300U, 3257986707U, + 1722477987U, 2991193800U, 4147007314U, 3633179701U, + 1805162104U, 3503289120U, 3395702895U, 3325073042U, + 2345265314U, 3340346032U, 2722964135U, 1173398992U, + 2815549194U, 2562818319U, 224996066U, 2680194749U, + 3035305390U, 246890365U, 2395624193U, 4145193337U, + 1801941682U }; for (ptr= list, x= 0; *ptr; ptr++, x++) { @@ -4041,11 +4309,13 @@ static test_return jenkins_run (memcached_st *memc __attribute__((unused))) { uint32_t x; char **ptr; - uint32_t values[]= { 1442444624, 4253821186, 1885058256, 2120131735, 3261968576, 3515188778, - 4232909173, 4288625128, 1812047395, 3689182164, 2502979932, 1214050606, - 2415988847, 1494268927, 1025545760, 3920481083, 4153263658, 3824871822, - 3072759809, 798622255, 3065432577, 1453328165, 2691550971, 3408888387, - 2629893356 }; + uint32_t values[]= { 1442444624U, 4253821186U, 1885058256U, 2120131735U, + 3261968576U, 3515188778U, 4232909173U, 4288625128U, + 1812047395U, 3689182164U, 2502979932U, 1214050606U, + 2415988847U, 1494268927U, 1025545760U, 3920481083U, + 4153263658U, 3824871822U, 3072759809U, 798622255U, + 3065432577U, 1453328165U, 2691550971U, 3408888387U, + 2629893356U }; for (ptr= list, x= 0; *ptr; ptr++, x++) @@ -4097,6 +4367,7 @@ test_st tests[] ={ {"connection_test", 0, connection_test}, {"callback_test", 0, callback_test}, {"behavior_test", 0, behavior_test}, + {"userdata_test", 0, userdata_test}, {"error", 0, error_test }, {"set", 0, set_test }, {"set2", 0, set_test2 }, @@ -4202,6 +4473,14 @@ test_st user_tests[] ={ {0, 0, 0} }; +test_st replication_tests[]= { + {"set", 1, replication_set_test }, + {"get", 0, replication_get_test }, + {"mget", 0, replication_mget_test }, + {"delete", 0, replication_delete_test }, + {0, 0, 0} +}; + test_st generate_tests[] ={ {"generate_pairs", 1, generate_pairs }, {"generate_data", 1, generate_data }, @@ -4285,6 +4564,9 @@ collection_st collection[] ={ {"poll_timeout", poll_timeout, 0, tests}, {"gets", enable_cas, 0, tests}, {"consistent", enable_consistent, 0, tests}, +#ifdef MEMCACHED_ENABLE_DEPRECATED + {"deprecated_memory_allocators", deprecated_set_memory_alloc, 0, tests}, +#endif {"memory_allocators", set_memory_alloc, 0, tests}, {"prefix", set_prefix, 0, tests}, {"version_1_2_3", check_for_1_2_3, 0, version_1_2_3}, @@ -4305,6 +4587,7 @@ collection_st collection[] ={ {"consistent_ketama", pre_behavior_ketama, 0, consistent_tests}, {"consistent_ketama_weighted", pre_behavior_ketama_weighted, 0, consistent_weighted_tests}, {"test_hashes", 0, 0, hash_tests}, + {"replication", pre_replication, 0, replication_tests}, {0, 0, 0, 0} };