+ rc= memcached_set(memc, key, strlen(key),
+ NULL, 0,
+ (time_t)0, UINT32_MAX);
+
+ assert(rc == MEMCACHED_SUCCESS);
+
+ value= memcached_get(memc, key, strlen(key),
+ &length, &flags, &rc);
+
+ assert(rc == MEMCACHED_SUCCESS);
+ assert(value == NULL);
+ assert(length == 0);
+ assert(flags == UINT32_MAX);
+
+ return 0;
+}
+
+/* Check the validity of chinese key*/
+static test_return user_supplied_bug17(memcached_st *memc)
+{
+ memcached_return rc;
+ char *key= "豆瓣";
+ char *value="我们在炎热抑郁的夏天无法停止豆瓣";
+ char *value2;
+ size_t length;
+ uint32_t flags;
+
+ rc= memcached_set(memc, key, strlen(key),
+ value, strlen(value),
+ (time_t)0, 0);
+
+ assert(rc == MEMCACHED_SUCCESS);
+
+ value2= memcached_get(memc, key, strlen(key),
+ &length, &flags, &rc);
+
+ assert(length==strlen(value));
+ assert(rc == MEMCACHED_SUCCESS);
+ assert(memcmp(value, value2, length)==0);
+ free(value2);
+
+ return 0;
+}
+
+#include "ketama_test_cases.h"
+test_return user_supplied_bug18(memcached_st *memc)
+{
+ memcached_return rc;
+ int value;
+ int i;
+ memcached_server_st *server_pool;
+
+ rc= memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_KETAMA_WEIGHTED, 1);
+ assert(rc == MEMCACHED_SUCCESS);
+
+ 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);
+
+ while (memc->number_of_hosts > 0)
+ {
+ memcached_server_remove(memc->hosts);
+ }
+ 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);
+
+ /* VDEAAAAA hashes to fffcd1b5, after the last continuum point, and lets
+ * us test the boundary wraparound.
+ */
+ assert(memcached_generate_hash(memc, (unsigned char *)"VDEAAAAA", 8) == memc->continuum[0].index);
+
+ /* verify the standard ketama set. */
+ for (i= 0; i < 99; i++)
+ {
+ uint32_t server_idx = memcached_generate_hash(memc, test_cases[i].key, strlen(test_cases[i].key));
+ char *hostname = memc->hosts[server_idx].hostname;
+ assert(strcmp(hostname, test_cases[i].server) == 0);
+ }
+ return 0;
+}
+
+static test_return result_static(memcached_st *memc)
+{
+ memcached_result_st result;
+ memcached_result_st *result_ptr;
+
+ result_ptr= memcached_result_create(memc, &result);
+ assert(result.is_allocated == MEMCACHED_NOT_ALLOCATED);
+ assert(result_ptr);
+ memcached_result_free(&result);
+
+ return 0;
+}
+
+static test_return result_alloc(memcached_st *memc)
+{
+ memcached_result_st *result;
+
+ result= memcached_result_create(memc, NULL);
+ assert(result);
+ memcached_result_free(result);
+
+ return 0;
+}
+
+static test_return string_static_null(memcached_st *memc)
+{
+ memcached_string_st string;
+ memcached_string_st *string_ptr;
+
+ string_ptr= memcached_string_create(memc, &string, 0);
+ assert(string.is_allocated == MEMCACHED_NOT_ALLOCATED);
+ assert(string_ptr);
+ memcached_string_free(&string);
+
+ return 0;
+}
+
+static test_return string_alloc_null(memcached_st *memc)
+{
+ memcached_string_st *string;
+
+ string= memcached_string_create(memc, NULL, 0);
+ assert(string);
+ memcached_string_free(string);
+
+ return 0;
+}
+
+static test_return string_alloc_with_size(memcached_st *memc)
+{
+ memcached_string_st *string;
+
+ string= memcached_string_create(memc, NULL, 1024);
+ assert(string);
+ memcached_string_free(string);
+
+ return 0;
+}
+
+static test_return string_alloc_with_size_toobig(memcached_st *memc)
+{
+ memcached_string_st *string;
+
+ string= memcached_string_create(memc, NULL, INT64_MAX);
+ assert(string == NULL);
+
+ return 0;
+}
+
+static test_return string_alloc_append(memcached_st *memc)
+{
+ unsigned int x;
+ char buffer[SMALL_STRING_LEN];
+ memcached_string_st *string;
+
+ /* Ring the bell! */
+ memset(buffer, 6, SMALL_STRING_LEN);
+
+ string= memcached_string_create(memc, NULL, 100);
+ assert(string);
+
+ for (x= 0; x < 1024; x++)
+ {
+ memcached_return rc;
+ rc= memcached_string_append(string, buffer, SMALL_STRING_LEN);
+ assert(rc == MEMCACHED_SUCCESS);
+ }
+ memcached_string_free(string);
+
+ return 0;
+}
+
+static test_return string_alloc_append_toobig(memcached_st *memc)
+{
+ memcached_return rc;
+ unsigned int x;
+ char buffer[SMALL_STRING_LEN];
+ memcached_string_st *string;
+
+ /* Ring the bell! */
+ memset(buffer, 6, SMALL_STRING_LEN);
+
+ string= memcached_string_create(memc, NULL, 100);
+ assert(string);
+
+ for (x= 0; x < 1024; x++)
+ {
+ rc= memcached_string_append(string, buffer, SMALL_STRING_LEN);
+ assert(rc == MEMCACHED_SUCCESS);
+ }
+ rc= memcached_string_append(string, buffer, INT64_MAX);
+ assert(rc == MEMCACHED_MEMORY_ALLOCATION_FAILURE);
+ memcached_string_free(string);
+
+ return 0;
+}
+
+static test_return cleanup_pairs(memcached_st *memc __attribute__((unused)))
+{
+ pairs_free(global_pairs);
+
+ return 0;
+}
+
+static test_return generate_pairs(memcached_st *memc __attribute__((unused)))
+{
+ unsigned long long x;
+ global_pairs= pairs_generate(GLOBAL_COUNT, 400);
+ global_count= GLOBAL_COUNT;
+
+ for (x= 0; x < global_count; x++)
+ {
+ global_keys[x]= global_pairs[x].key;
+ global_keys_length[x]= global_pairs[x].key_length;
+ }
+
+ return 0;
+}
+
+static test_return generate_large_pairs(memcached_st *memc __attribute__((unused)))
+{
+ unsigned long long x;
+ global_pairs= pairs_generate(GLOBAL2_COUNT, MEMCACHED_MAX_BUFFER+10);
+ global_count= GLOBAL2_COUNT;
+
+ for (x= 0; x < global_count; x++)
+ {
+ global_keys[x]= global_pairs[x].key;
+ global_keys_length[x]= global_pairs[x].key_length;
+ }
+
+ return 0;
+}
+
+static test_return generate_data(memcached_st *memc)
+{
+ execute_set(memc, global_pairs, global_count);
+
+ return 0;
+}
+
+static test_return generate_data_with_stats(memcached_st *memc)
+{
+ memcached_stat_st *stat_p;
+ memcached_return rc;
+ uint32_t host_index= 0;
+ execute_set(memc, global_pairs, global_count);
+
+ //TODO: hosts used size stats
+ stat_p= memcached_stat(memc, NULL, &rc);
+ assert(stat_p);
+
+ for (host_index= 0; host_index < SERVERS_TO_CREATE; host_index++)
+ {
+ printf("\nserver %u|%s|%u bytes: %llu\n", host_index, (memc->hosts)[host_index].hostname, (memc->hosts)[host_index].port, (unsigned long long)(stat_p + host_index)->bytes);
+ }
+
+ memcached_stat_free(NULL, stat_p);
+
+ return 0;
+}
+static test_return generate_buffer_data(memcached_st *memc)
+{
+ int latch= 0;
+
+ latch= 1;
+ memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_BUFFER_REQUESTS, latch);
+ generate_data(memc);
+
+ return 0;
+}
+
+static test_return get_read_count(memcached_st *memc)
+{
+ unsigned int x;
+ memcached_return rc;
+ memcached_st *clone;
+
+ clone= memcached_clone(NULL, memc);
+ assert(clone);
+
+ memcached_server_add_with_weight(clone, "localhost", 6666, 0);
+
+ {
+ char *return_value;
+ size_t return_value_length;
+ uint32_t flags;
+ uint32_t count;
+
+ for (x= count= 0; x < global_count; x++)
+ {
+ return_value= memcached_get(clone, global_keys[x], global_keys_length[x],
+ &return_value_length, &flags, &rc);
+ if (rc == MEMCACHED_SUCCESS)
+ {
+ count++;
+ if (return_value)
+ free(return_value);
+ }
+ }
+ fprintf(stderr, "\t%u -> %u", global_count, count);
+ }
+
+ memcached_free(clone);
+
+ return 0;
+}
+
+static test_return get_read(memcached_st *memc)
+{
+ unsigned int x;
+ memcached_return rc;
+
+ {
+ char *return_value;
+ size_t return_value_length;
+ uint32_t flags;
+
+ for (x= 0; x < global_count; x++)
+ {
+ return_value= memcached_get(memc, global_keys[x], global_keys_length[x],
+ &return_value_length, &flags, &rc);
+ /*
+ assert(return_value);
+ assert(rc == MEMCACHED_SUCCESS);
+ */
+ if (rc == MEMCACHED_SUCCESS && return_value)
+ free(return_value);
+ }
+ }
+
+ return 0;
+}
+
+static test_return mget_read(memcached_st *memc)
+{
+ memcached_return rc;
+
+ rc= memcached_mget(memc, global_keys, global_keys_length, global_count);
+ assert(rc == MEMCACHED_SUCCESS);
+ /* Turn this into a help function */
+ {
+ char return_key[MEMCACHED_MAX_KEY];
+ size_t return_key_length;
+ char *return_value;
+ size_t return_value_length;
+ uint32_t flags;
+
+ while ((return_value= memcached_fetch(memc, return_key, &return_key_length,
+ &return_value_length, &flags, &rc)))
+ {
+ assert(return_value);
+ assert(rc == MEMCACHED_SUCCESS);
+ free(return_value);
+ }
+ }
+
+ return 0;
+}
+
+static test_return mget_read_result(memcached_st *memc)
+{
+ memcached_return rc;
+
+ rc= memcached_mget(memc, global_keys, global_keys_length, global_count);