memcached_server_st *server_list;
memcached_return rc;
- server_list= memcached_server_list_append(NULL, NULL, 0, NULL);
+ server_list= memcached_server_list_append_with_weight(NULL, NULL, 0, 0, NULL);
assert(server_list == NULL);
- server_list= memcached_server_list_append(NULL, "localhost", 0, NULL);
+ server_list= memcached_server_list_append_with_weight(NULL, "localhost", 0, 0, NULL);
assert(server_list == NULL);
- server_list= memcached_server_list_append(NULL, NULL, 0, &rc);
+ server_list= memcached_server_list_append_with_weight(NULL, NULL, 0, 0, &rc);
assert(server_list == NULL);
return 0;
for (x= 0; x < TEST_PORT_COUNT; x++)
{
test_ports[x]= random() % 64000;
- rc= memcached_server_add(local_memc, "localhost", test_ports[x]);
+ 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);
assert(rc == MEMCACHED_SUCCESS);
rc= memcached_behavior_set(local_memc, MEMCACHED_BEHAVIOR_SORT_HOSTS, 1);
assert(rc == MEMCACHED_SUCCESS);
- rc= memcached_server_add(local_memc, "MEMCACHED_BEHAVIOR_SORT_HOSTS", 43043);
+ rc= memcached_server_add_with_weight(local_memc, "MEMCACHED_BEHAVIOR_SORT_HOSTS", 43043, 0);
assert(rc == MEMCACHED_SUCCESS);
assert(local_memc->hosts[0].port == 43043);
- rc= memcached_server_add(local_memc, "MEMCACHED_BEHAVIOR_SORT_HOSTS", 43042);
+ rc= memcached_server_add_with_weight(local_memc, "MEMCACHED_BEHAVIOR_SORT_HOSTS", 43042, 0);
assert(rc == MEMCACHED_SUCCESS);
assert(local_memc->hosts[0].port == 43042);
assert(local_memc->hosts[1].port == 43043);
for (x= 0; x < TEST_PORT_COUNT; x++)
{
test_ports[x]= random() % 64000;
- rc= memcached_server_add(local_memc, "localhost", test_ports[x]);
+ 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);
assert(rc == MEMCACHED_SUCCESS);
{
memcached_return rc;
- rc= memcached_server_add(memc, "localhost", 0);
+ rc= memcached_server_add_with_weight(memc, "localhost", 0, 0);
assert(rc == MEMCACHED_SUCCESS);
return 0;
static test_return 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");
+ const char *key= "fun";
+ size_t key_length= strlen(key);
+ const char *value= "we the people";
+ size_t value_length= strlen(value);
+ const char *value2= "change the value";
+ size_t value2_length= strlen(value2);
+
memcached_result_st results_obj;
memcached_result_st *results;
unsigned int set= 1;
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(!memcmp(value, memcached_result_value(results), value_length));
+ assert(strlen(memcached_result_value(results)) == value_length);
assert(rc == MEMCACHED_SUCCESS);
+ uint64_t cas = memcached_result_cas(results);
- rc= memcached_cas(memc, key, key_length,
- "change the value", strlen("change the value"),
- 0, 0, memcached_result_cas(results));
-
+ #if 0
+ results= memcached_fetch_result(memc, &results_obj, &rc);
+ assert(rc == MEMCACHED_END);
+ assert(results == NULL);
+#endif
+
+ rc= memcached_cas(memc, key, key_length, value2, value2_length, 0, 0, cas);
assert(rc == MEMCACHED_SUCCESS);
- rc= memcached_cas(memc, key, key_length,
- "change the value", strlen("change the value"),
- 0, 0, 23);
-
+ /*
+ * The item will have a new cas value, so try to set it again with the old
+ * value. This should fail!
+ */
+ rc= memcached_cas(memc, key, key_length, value2, value2_length, 0, 0, cas);
assert(rc == MEMCACHED_DATA_EXISTS);
-
memcached_result_free(&results_obj);
return 0;
memcached_return rc;
char servername[]= "0.example.com";
- servers= memcached_server_list_append(NULL, servername, 400, &rc);
+ servers= memcached_server_list_append_with_weight(NULL, servername, 400, 0, &rc);
assert(servers);
assert(1 == memcached_server_list_count(servers));
char buffer[SMALL_STRING_LEN];
snprintf(buffer, SMALL_STRING_LEN, "%u.example.com", 400+x);
- servers= memcached_server_list_append(servers, buffer, 401,
+ servers= memcached_server_list_append_with_weight(servers, buffer, 401, 0,
&rc);
assert(rc == MEMCACHED_SUCCESS);
assert(x == memcached_server_list_count(servers));
sprintf(key, "%d", x);
rc = memcached_set(memc, key, strlen(key),
randomstuff, strlen(randomstuff), 10, 0);
+ assert(rc == MEMCACHED_SUCCESS || rc == MEMCACHED_BUFFERED);
/* If we fail, lets try again */
if (rc != MEMCACHED_SUCCESS && rc != MEMCACHED_BUFFERED)
rc = memcached_set(memc, key, strlen(key),
1, &number_value);
assert(value == NULL);
- assert(rc == MEMCACHED_NOTFOUND);
+ /* The binary protocol will set the key if it doesn't exist */
+ if (memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL) == 1)
+ assert(rc == MEMCACHED_SUCCESS);
+ else
+ assert(rc == MEMCACHED_NOTFOUND);
rc= memcached_set(memc, "autoincrement", strlen("autoincrement"), "1", 1, 0, 0);
return 0;
}
+/*
+ From Andrei on IRC
+*/
+
+test_return user_supplied_bug19(memcached_st *memc)
+{
+ memcached_st *m;
+ memcached_server_st *s;
+ memcached_return res;
+
+ (void)memc;
+
+ m= memcached_create(NULL);
+ memcached_server_add_with_weight(m, "localhost", 11311, 100);
+ memcached_server_add_with_weight(m, "localhost", 11312, 100);
+
+ s= memcached_server_by_key(m, "a", 1, &res);
+ memcached_server_free(s);
+
+ memcached_free(m);
+
+ return 0;
+}
+
+/* CAS test from Andei */
+test_return user_supplied_bug20(memcached_st *memc)
+{
+ memcached_return status;
+ memcached_result_st *result, result_obj;
+ char *key = "abc";
+ size_t key_len = strlen("abc");
+ char *value = "foobar";
+ size_t value_len = strlen(value);
+
+ memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_SUPPORT_CAS, 1);
+
+ status = memcached_set(memc, key, key_len, value, value_len, (time_t)0, (uint32_t)0);
+ assert(status == MEMCACHED_SUCCESS);
+
+ status = memcached_mget(memc, &key, &key_len, 1);
+ assert(status == MEMCACHED_SUCCESS);
+
+ memcached_result_create(memc, &result_obj);
+ result= memcached_fetch_result(memc, &result_obj, &status);
+
+ assert(result);
+ assert(status == MEMCACHED_SUCCESS);
+
+ return 0;
+}
+
+#include "ketama_test_cases.h"
+test_return user_supplied_bug18(memcached_st *trash)
+{
+ memcached_return rc;
+ int value;
+ int i;
+ memcached_server_st *server_pool;
+ memcached_st *memc;
+
+ (void)trash;
+
+ memc= memcached_create(NULL);
+ assert(memc);
+
+ 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);
+
+ 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, (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);
+ }
+
+ memcached_server_list_free(server_pool);
+ memcached_free(memc);
+
+ return 0;
+}
static test_return result_static(memcached_st *memc)
{
memcached_result_st *result_ptr;
result_ptr= memcached_result_create(memc, &result);
- assert(result.is_allocated == MEMCACHED_NOT_ALLOCATED);
+ assert(result.is_allocated == false);
assert(result_ptr);
memcached_result_free(&result);
memcached_string_st *string_ptr;
string_ptr= memcached_string_create(memc, &string, 0);
- assert(string.is_allocated == MEMCACHED_NOT_ALLOCATED);
+ assert(string.is_allocated == false);
assert(string_ptr);
memcached_string_free(&string);
clone= memcached_clone(NULL, memc);
assert(clone);
- memcached_server_add(clone, "localhost", 6666);
+ memcached_server_add_with_weight(clone, "localhost", 6666, 0);
{
char *return_value;
char servername[]= "0.example.com";
memcached_server_st *servers;
- servers= memcached_server_list_append(NULL, servername, 400, &rc);
+ servers= memcached_server_list_append_with_weight(NULL, servername, 400, 0, &rc);
assert(servers);
assert(1 == memcached_server_list_count(servers));
char buffer[SMALL_STRING_LEN];
snprintf(buffer, SMALL_STRING_LEN, "%u.example.com", 400+x);
- servers= memcached_server_list_append(servers, buffer, 401,
+ servers= memcached_server_list_append_with_weight(servers, buffer, 401, 0,
&rc);
assert(rc == MEMCACHED_SUCCESS);
assert(x == memcached_server_list_count(servers));
return realloc(mem, size);
}
-static memcached_return set_prefix(memcached_st *memc)
+static memcached_return set_prefix(memcached_st *memc)
{
memcached_return rc;
const char *key= "mine";
assert(value == NULL);
/* Test a long key for failure */
+ /* TODO, extend test to determine based on setting, what result should be */
long_key= "Thisismorethentheallottednumberofcharacters";
rc= memcached_callback_set(memc, MEMCACHED_CALLBACK_PREFIX_KEY, long_key);
- assert(rc == MEMCACHED_BAD_KEY_PROVIDED);
+ //assert(rc == MEMCACHED_BAD_KEY_PROVIDED);
+ assert(rc == MEMCACHED_SUCCESS);
/* Now test a key with spaces (which will fail from long key, since bad key is not set) */
long_key= "This is more then the allotted number of characters";
if (stat("/tmp/memcached.socket", &buf))
return MEMCACHED_FAILURE;
- rc= memcached_server_add_unix_socket(memc, "/tmp/memcached.socket");
+ rc= memcached_server_add_unix_socket_with_weight(memc, "/tmp/memcached.socket", 0);
return rc;
}
{"user_supplied_bug15", 1, user_supplied_bug15 },
{"user_supplied_bug16", 1, user_supplied_bug16 },
{"user_supplied_bug17", 1, user_supplied_bug17 },
+ {"user_supplied_bug18", 1, user_supplied_bug18 },
+ {"user_supplied_bug19", 1, user_supplied_bug19 },
+ {"user_supplied_bug20", 1, user_supplied_bug20 },
{0, 0, 0}
};
projects / awesomized / libmemcached / blobdiff