rc= memcached_set(memc, key, strlen(key),
value, strlen(value),
(time_t)0, (uint16_t)0);
+ WATCHPOINT_ERROR(rc);
assert(rc == MEMCACHED_SUCCESS);
return 0;
}
+uint8_t append_test(memcached_st *memc)
+{
+ memcached_return rc;
+ char *key= "fig";
+ char *value= "we";
+ size_t value_length;
+ uint16_t flags;
+
+ rc= memcached_flush(memc, 0);
+ assert(rc == MEMCACHED_SUCCESS);
+
+ rc= memcached_set(memc, key, strlen(key),
+ value, strlen(value),
+ (time_t)0, (uint16_t)0);
+ assert(rc == MEMCACHED_SUCCESS);
+
+ rc= memcached_append(memc, key, strlen(key),
+ " the", strlen(" the"),
+ (time_t)0, (uint16_t)0);
+ assert(rc == MEMCACHED_SUCCESS);
+
+ rc= memcached_append(memc, key, strlen(key),
+ " people", strlen(" people"),
+ (time_t)0, (uint16_t)0);
+ assert(rc == MEMCACHED_SUCCESS);
+
+ value= memcached_get(memc, key, strlen(key),
+ &value_length, &flags, &rc);
+ assert(!memcmp(value, "we the people", strlen("we the people")));
+ assert(strlen("we the people") == value_length);
+ assert(rc == MEMCACHED_SUCCESS);
+ free(value);
+
+ return 0;
+}
+
+uint8_t append_binary_test(memcached_st *memc)
+{
+ memcached_return rc;
+ char *key= "numbers";
+ unsigned int *store_ptr;
+ unsigned int store_list[] = { 23, 56, 499, 98, 32847, 0 };
+ char *value;
+ size_t value_length;
+ uint16_t flags;
+ unsigned int x;
+
+ rc= memcached_flush(memc, 0);
+ assert(rc == MEMCACHED_SUCCESS);
+
+ rc= memcached_set(memc,
+ key, strlen(key),
+ NULL, 0,
+ (time_t)0, (uint16_t)0);
+ assert(rc == MEMCACHED_SUCCESS);
+
+ for (x= 0; store_list[x] ; x++)
+ {
+ rc= memcached_append(memc,
+ key, strlen(key),
+ (char *)&store_list[x], sizeof(unsigned int),
+ (time_t)0, (uint16_t)0);
+ assert(rc == MEMCACHED_SUCCESS);
+ }
+
+ value= memcached_get(memc, key, strlen(key),
+ &value_length, &flags, &rc);
+ assert((value_length == (sizeof(unsigned int) * x)));
+ assert(rc == MEMCACHED_SUCCESS);
+
+ store_ptr= (unsigned int *)value;
+ x= 0;
+ while ((size_t)store_ptr < (size_t)(value + value_length))
+ {
+ assert(*store_ptr == store_list[x++]);
+ store_ptr++;
+ }
+ free(value);
+
+ return 0;
+}
+
+uint8_t cas2_test(memcached_st *memc)
+{
+ memcached_return rc;
+ char *keys[]= {"fudge", "son", "food"};
+ size_t key_length[]= {5, 3, 4};
+ char *value= "we the people";
+ size_t value_length= strlen("we the people");
+ unsigned int x;
+ memcached_result_st results_obj;
+ memcached_result_st *results;
+ unsigned int set= 1;
+
+ rc= memcached_flush(memc, 0);
+ assert(rc == MEMCACHED_SUCCESS);
+
+ memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_SUPPORT_CAS, &set);
+
+ for (x= 0; x < 3; x++)
+ {
+ rc= memcached_set(memc, keys[x], key_length[x],
+ keys[x], key_length[x],
+ (time_t)50, (uint16_t)9);
+ assert(rc == MEMCACHED_SUCCESS);
+ }
+
+ rc= memcached_mget(memc, keys, key_length, 3);
+
+ results= memcached_result_create(memc, &results_obj);
+
+ results= memcached_fetch_result(memc, &results_obj, &rc);
+ assert(results);
+ assert(results->cas);
+ assert(rc == MEMCACHED_SUCCESS);
+ WATCHPOINT_ASSERT(memcached_result_cas(results));
+
+ assert(!memcmp(value, "we the people", strlen("we the people")));
+ assert(strlen("we the people") == value_length);
+ assert(rc == MEMCACHED_SUCCESS);
+
+ memcached_result_free(&results_obj);
+
+ return 0;
+}
+
+uint8_t cas_test(memcached_st *memc)
+{
+ memcached_return rc;
+ char *key= "fun";
+ size_t key_length= strlen("fun");
+ char *value= "we the people";
+ size_t value_length= strlen("we the people");
+ memcached_result_st results_obj;
+ memcached_result_st *results;
+ unsigned int set= 1;
+
+ rc= memcached_flush(memc, 0);
+ assert(rc == MEMCACHED_SUCCESS);
+
+ memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_SUPPORT_CAS, &set);
+
+ rc= memcached_set(memc, key, strlen(key),
+ value, strlen(value),
+ (time_t)0, (uint16_t)0);
+ assert(rc == MEMCACHED_SUCCESS);
+
+ rc= memcached_mget(memc, &key, &key_length, 1);
+
+ results= memcached_result_create(memc, &results_obj);
+
+ results= memcached_fetch_result(memc, &results_obj, &rc);
+ assert(results);
+ assert(rc == MEMCACHED_SUCCESS);
+ WATCHPOINT_ASSERT(memcached_result_cas(results));
+
+ assert(!memcmp(value, "we the people", strlen("we the people")));
+ assert(strlen("we the people") == value_length);
+ assert(rc == MEMCACHED_SUCCESS);
+
+ memcached_result_free(&results_obj);
+
+ return 0;
+}
+
+uint8_t prepend_test(memcached_st *memc)
+{
+ memcached_return rc;
+ char *key= "fig";
+ char *value= "people";
+ size_t value_length;
+ uint16_t flags;
+
+ rc= memcached_flush(memc, 0);
+ assert(rc == MEMCACHED_SUCCESS);
+
+ rc= memcached_set(memc, key, strlen(key),
+ value, strlen(value),
+ (time_t)0, (uint16_t)0);
+ assert(rc == MEMCACHED_SUCCESS);
+
+ rc= memcached_prepend(memc, key, strlen(key),
+ "the ", strlen("the "),
+ (time_t)0, (uint16_t)0);
+ assert(rc == MEMCACHED_SUCCESS);
+
+ rc= memcached_prepend(memc, key, strlen(key),
+ "we ", strlen("we "),
+ (time_t)0, (uint16_t)0);
+ assert(rc == MEMCACHED_SUCCESS);
+
+ value= memcached_get(memc, key, strlen(key),
+ &value_length, &flags, &rc);
+ assert(!memcmp(value, "we the people", strlen("we the people")));
+ assert(strlen("we the people") == value_length);
+ assert(rc == MEMCACHED_SUCCESS);
+ free(value);
+
+ return 0;
+}
+
uint8_t add_test(memcached_st *memc)
{
memcached_return rc;
return 0;
}
+/* Do not copy the style of this code, I just access hosts to testthis function */
uint8_t stats_servername_test(memcached_st *memc)
{
memcached_return rc;
memcached_stat_st stat;
rc= memcached_stat_servername(&stat, NULL,
- "localhost",
- MEMCACHED_DEFAULT_PORT);
+ memc->hosts[0].hostname,
+ memc->hosts[0].port);
return 0;
}
{
assert(results);
}
+
while ((results= memcached_fetch_result(memc, &results_obj, &rc)) != NULL)
assert(!results);
assert(rc == MEMCACHED_NOTFOUND);
for (x= 0; x < memcached_server_count(memc); x++)
{
- list= memcached_stat_get_keys(memc, &stat[x], &rc);
+ list= memcached_stat_get_keys(memc, stat+x, &rc);
assert(rc == MEMCACHED_SUCCESS);
- for (ptr= list; *ptr; ptr++)
- printf("Found key %s\n", *ptr);
+ for (ptr= list; *ptr; ptr++);
free(list);
}
return 0;
}
+#define VALUE_SIZE_BUG5 1048064
+uint8_t user_supplied_bug5(memcached_st *memc)
+{
+ memcached_return rc;
+ char *keys[]= {"036790384900", "036790384902", "036790384904", "036790384906"};
+ size_t key_length[]= {strlen("036790384900"), strlen("036790384902"), strlen("036790384904"), strlen("036790384906")};
+ char return_key[MEMCACHED_MAX_KEY];
+ size_t return_key_length;
+ char *value;
+ size_t value_length;
+ uint16_t flags;
+ unsigned int count;
+ unsigned int x;
+ char insert_data[VALUE_SIZE_BUG5];
+
+ for (x= 0; x < VALUE_SIZE_BUG5; x++)
+ insert_data[x]= rand();
+
+ memcached_flush(memc, 0);
+ value= memcached_get(memc, keys[0], key_length[0],
+ &value_length, &flags, &rc);
+ assert(value == NULL);
+ rc= memcached_mget(memc, keys, key_length, 4);
+
+ count= 0;
+ while ((value= memcached_fetch(memc, return_key, &return_key_length,
+ &value_length, &flags, &rc)))
+ count++;
+ assert(count == 0);
+
+ for (x= 0; x < 4; x++)
+ {
+ rc= memcached_set(memc, keys[x], key_length[x],
+ insert_data, VALUE_SIZE_BUG5,
+ (time_t)0, (uint16_t)0);
+ assert(rc == MEMCACHED_SUCCESS);
+ }
+
+ for (x= 0; x < 10; x++)
+ {
+ value= memcached_get(memc, keys[0], key_length[0],
+ &value_length, &flags, &rc);
+ assert(value);
+ free(value);
+
+ rc= memcached_mget(memc, keys, key_length, 4);
+ count= 0;
+ while ((value= memcached_fetch(memc, return_key, &return_key_length,
+ &value_length, &flags, &rc)))
+ {
+ count++;
+ free(value);
+ }
+ assert(count == 4);
+ }
+
+ return 0;
+}
+
+uint8_t user_supplied_bug6(memcached_st *memc)
+{
+ memcached_return rc;
+ char *keys[]= {"036790384900", "036790384902", "036790384904", "036790384906"};
+ size_t key_length[]= {strlen("036790384900"), strlen("036790384902"), strlen("036790384904"), strlen("036790384906")};
+ char return_key[MEMCACHED_MAX_KEY];
+ size_t return_key_length;
+ char *value;
+ size_t value_length;
+ uint16_t flags;
+ unsigned int count;
+ unsigned int x;
+ char insert_data[VALUE_SIZE_BUG5];
+
+ for (x= 0; x < VALUE_SIZE_BUG5; x++)
+ insert_data[x]= rand();
+
+ memcached_flush(memc, 0);
+ value= memcached_get(memc, keys[0], key_length[0],
+ &value_length, &flags, &rc);
+ assert(value == NULL);
+ rc= memcached_mget(memc, keys, key_length, 4);
+
+ count= 0;
+ while ((value= memcached_fetch(memc, return_key, &return_key_length,
+ &value_length, &flags, &rc)))
+ count++;
+ assert(count == 0);
+
+ for (x= 0; x < 4; x++)
+ {
+ rc= memcached_set(memc, keys[x], key_length[x],
+ insert_data, VALUE_SIZE_BUG5,
+ (time_t)0, (uint16_t)0);
+ assert(rc == MEMCACHED_SUCCESS);
+ }
+
+ for (x= 0; x < 10; x++)
+ {
+ value= memcached_get(memc, keys[0], key_length[0],
+ &value_length, &flags, &rc);
+ assert(value);
+ free(value);
+
+ rc= memcached_mget(memc, keys, key_length, 4);
+ count= 3;
+ /* We test for purge of partial complete fetches */
+ for (count= 3; count; count--)
+ {
+ value= memcached_fetch(memc, return_key, &return_key_length,
+ &value_length, &flags, &rc);
+ free(value);
+ assert(rc == MEMCACHED_SUCCESS);
+ }
+ }
+
+ return 0;
+}
+
+uint8_t user_supplied_bug8(memcached_st *memc)
+{
+ memcached_return rc;
+ memcached_st *mine;
+ memcached_st *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";
+
+ servers= memcached_servers_parse(server_list);
+ assert(servers);
+
+ mine= memcached_create(NULL);
+ rc= memcached_server_push(mine, servers);
+ assert(rc == MEMCACHED_SUCCESS);
+ memcached_server_list_free(servers);
+
+ assert(mine);
+ clone= memcached_clone(NULL, mine);
+
+ memcached_quit(mine);
+ memcached_quit(clone);
+
+
+ memcached_free(mine);
+ memcached_free(clone);
+
+ return 0;
+}
+
+/* Test flag store/retrieve */
+uint8_t user_supplied_bug7(memcached_st *memc)
+{
+ memcached_return rc;
+ char *keys= "036790384900";
+ size_t key_length= strlen("036790384900");
+ char return_key[MEMCACHED_MAX_KEY];
+ size_t return_key_length;
+ char *value;
+ size_t value_length;
+ uint16_t flags;
+ unsigned int x;
+ char insert_data[VALUE_SIZE_BUG5];
+
+ for (x= 0; x < VALUE_SIZE_BUG5; x++)
+ insert_data[x]= rand();
+
+ memcached_flush(memc, 0);
+
+ flags= 245;
+ rc= memcached_set(memc, keys, key_length,
+ insert_data, VALUE_SIZE_BUG5,
+ (time_t)0, flags);
+ assert(rc == MEMCACHED_SUCCESS);
+
+ flags= 0;
+ value= memcached_get(memc, keys, key_length,
+ &value_length, &flags, &rc);
+ assert(flags == 245);
+ assert(value);
+ free(value);
+
+ rc= memcached_mget(memc, &keys, &key_length, 1);
+
+ flags= 0;
+ value= memcached_fetch(memc, return_key, &return_key_length,
+ &value_length, &flags, &rc);
+ assert(flags == 245);
+ assert(value);
+ free(value);
+
+
+ return 0;
+}
+
uint8_t result_static(memcached_st *memc)
{
memcached_result_st result;
return 0;
}
+uint8_t cleanup_pairs(memcached_st *memc)
+{
+ pairs_free(global_pairs);
+
+ return 0;
+}
+
uint8_t generate_data(memcached_st *memc)
{
unsigned long long x;
return MEMCACHED_SUCCESS;
}
+memcached_return pre_hsieh(memcached_st *memc)
+{
+ memcached_hash value= MEMCACHED_HASH_HSIEH;
+ memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_HASH, &value);
+
+ return MEMCACHED_SUCCESS;
+}
+
memcached_return pre_hash_fnv1_64(memcached_st *memc)
{
memcached_hash value= MEMCACHED_HASH_FNV1_64;
return MEMCACHED_SUCCESS;
}
+memcached_return enable_cas(memcached_st *memc)
+{
+ unsigned int set= 1;
+
+ memcached_version(memc);
+
+ if (memc->hosts[0].major_version >= 1 &&
+ memc->hosts[0].minor_version >= 2 &&
+ memc->hosts[0].micro_version >= 4)
+ {
+ memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_SUPPORT_CAS, &set);
+
+ return MEMCACHED_SUCCESS;
+ }
+
+ return MEMCACHED_FAILURE;
+}
+
+memcached_return check_for_1_2_3(memcached_st *memc)
+{
+ memcached_version(memc);
+
+ if (memc->hosts[0].major_version >= 1 &&
+ memc->hosts[0].minor_version >= 2 &&
+ memc->hosts[0].micro_version >= 4)
+ return MEMCACHED_SUCCESS;
+
+ return MEMCACHED_FAILURE;
+}
+
memcached_return pre_unix_socket(memcached_st *memc)
{
memcached_return rc;
return rc;
}
+memcached_return pre_udp(memcached_st *memc)
+{
+ memcached_return rc;
+
+ memcached_server_list_free(memc->hosts);
+ memc->hosts= NULL;
+ memc->number_of_hosts= 0;
+
+ if (0)
+ return MEMCACHED_FAILURE;
+
+ rc= memcached_server_add_udp(memc, "localhost", MEMCACHED_DEFAULT_PORT);
+
+ return rc;
+}
+
memcached_return pre_nodelay(memcached_st *memc)
{
memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_NO_BLOCK, NULL);
return MEMCACHED_SUCCESS;
}
+memcached_return poll_timeout(memcached_st *memc)
+{
+ int32_t timeout;
+
+ timeout= 100;
+
+ memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_POLL_TIMEOUT, &timeout);
+
+ timeout= (int32_t)memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_POLL_TIMEOUT);
+
+ assert(timeout == 100);
+
+ return MEMCACHED_SUCCESS;
+}
+
/* Clean the server before beginning testing */
test_st tests[] ={
{0, 0, 0}
};
+test_st version_1_2_3[] ={
+ {"append", 0, append_test },
+ {"prepend", 0, prepend_test },
+ {"cas", 0, cas_test },
+ {"cas2", 0, cas2_test },
+ {"append_binary", 0, append_binary_test },
+ {0, 0, 0}
+};
+
test_st user_tests[] ={
{"user_supplied_bug1", 0, user_supplied_bug1 },
{"user_supplied_bug2", 0, user_supplied_bug2 },
{"user_supplied_bug3", 0, user_supplied_bug3 },
{"user_supplied_bug4", 0, user_supplied_bug4 },
+ {"user_supplied_bug5", 1, user_supplied_bug5 },
+ {"user_supplied_bug6", 1, user_supplied_bug6 },
+ {"user_supplied_bug7", 1, user_supplied_bug7 },
+ {"user_supplied_bug8", 1, user_supplied_bug8 },
{0, 0, 0}
};
{"get_read", 0, get_read },
{"mget_read", 0, mget_read },
{"mget_read_result", 0, mget_read_result },
+ {"cleanup", 0, cleanup_pairs },
{0, 0, 0}
};
{"nodelay", pre_nodelay, 0, tests},
{"md5", pre_md5, 0, tests},
{"crc", pre_crc, 0, tests},
+ {"hsieh", pre_hsieh, 0, tests},
{"fnv1_64", pre_hash_fnv1_64, 0, tests},
{"fnv1a_64", pre_hash_fnv1a_64, 0, tests},
{"fnv1_32", pre_hash_fnv1_32, 0, tests},
{"ketama", pre_hash_ketama, 0, tests},
{"unix_socket", pre_unix_socket, 0, tests},
{"unix_socket_nodelay", pre_nodelay, 0, tests},
+ {"poll_timeout", poll_timeout, 0, tests},
+ {"gets", enable_cas, 0, tests},
+// {"udp", pre_udp, 0, tests},
+ {"version_1_2_3", check_for_1_2_3, 0, version_1_2_3},
{"string", 0, 0, string_tests},
{"result", 0, 0, result_tests},
{"user", 0, 0, user_tests},
{"generate", 0, 0, generate_tests},
+ {"generate_hsieh", pre_hsieh, 0, generate_tests},
+ {"generate_nonblock", pre_nonblock, 0, generate_tests},
{0, 0, 0, 0}
};
projects / awesomized / libmemcached / blobdiff