Sample test application.
*/
-/* TODO: I'm torn about this. The file seems like a functional test, which
- * should use only the exported API of the library. On the other hand,
- * something needs to test some of the internals - so we're going to turn on
- * internal symbols here... but I'd like to come up with another way to test
- * the internals
- */
-#define BUILDING_LIBMEMCACHED 1
#include "libmemcached/common.h"
#include <assert.h>
static uint32_t global_count;
static pairs_st *global_pairs;
-static char *global_keys[GLOBAL_COUNT];
+static const char *global_keys[GLOBAL_COUNT];
static size_t global_keys_length[GLOBAL_COUNT];
static test_return init_test(memcached_st *not_used __attribute__((unused)))
static test_return error_test(memcached_st *memc)
{
memcached_return rc;
-
+ uint32_t values[] = { 851992627U, 2337886783U, 3196981036U, 4001849190U,
+ 982370485U, 1263635348U, 4242906218U, 3829656100U,
+ 1891735253U, 334139633U, 2257084983U, 3088286104U,
+ 13199785U, 2542027183U, 1097051614U, 199566778U,
+ 2748246961U, 2465192557U, 1664094137U, 2405439045U,
+ 1842224848U, 692413798U, 3479807801U, 919913813U,
+ 4269430871U, 610793021U, 527273862U, 1437122909U,
+ 2300930706U, 2943759320U, 674306647U, 2400528935U,
+ 54481931U, 4186304426U, 1741088401U, 2979625118U,
+ 4159057246U, 3425930182U};
+
+ // You have updated the memcache_error messages but not updated docs/tests.
+ assert(MEMCACHED_MAXIMUM_RETURN == 38);
for (rc= MEMCACHED_SUCCESS; rc < MEMCACHED_MAXIMUM_RETURN; rc++)
{
- printf("Error %d -> %s\n", rc, memcached_strerror(memc, rc));
+ uint32_t hash_val;
+ const char *msg= memcached_strerror(memc, rc);
+ hash_val= memcached_generate_hash_value(msg, strlen(msg),
+ MEMCACHED_HASH_JENKINS);
+ assert(values[rc] == hash_val);
}
return 0;
static test_return set_test(memcached_st *memc)
{
memcached_return rc;
- char *key= "foo";
- char *value= "when we sanitize";
+ const char *key= "foo";
+ const char *value= "when we sanitize";
rc= memcached_set(memc, key, strlen(key),
value, strlen(value),
static test_return append_test(memcached_st *memc)
{
memcached_return rc;
- char *key= "fig";
- char *value= "we";
+ const char *key= "fig";
+ const char *in_value= "we";
+ char *out_value= NULL;
size_t value_length;
uint32_t flags;
assert(rc == MEMCACHED_SUCCESS);
rc= memcached_set(memc, key, strlen(key),
- value, strlen(value),
+ in_value, strlen(in_value),
(time_t)0, (uint32_t)0);
assert(rc == MEMCACHED_SUCCESS);
(time_t)0, (uint32_t)0);
assert(rc == MEMCACHED_SUCCESS);
- value= memcached_get(memc, key, strlen(key),
+ out_value= memcached_get(memc, key, strlen(key),
&value_length, &flags, &rc);
- assert(!memcmp(value, "we the people", strlen("we the people")));
+ assert(!memcmp(out_value, "we the people", strlen("we the people")));
assert(strlen("we the people") == value_length);
assert(rc == MEMCACHED_SUCCESS);
- free(value);
+ free(out_value);
return 0;
}
static test_return append_binary_test(memcached_st *memc)
{
memcached_return rc;
- char *key= "numbers";
+ const char *key= "numbers";
unsigned int *store_ptr;
unsigned int store_list[] = { 23, 56, 499, 98, 32847, 0 };
char *value;
static test_return cas2_test(memcached_st *memc)
{
memcached_return rc;
- char *keys[]= {"fudge", "son", "food"};
+ const char *keys[]= {"fudge", "son", "food"};
size_t key_length[]= {5, 3, 4};
- char *value= "we the people";
+ const char *value= "we the people";
size_t value_length= strlen("we the people");
unsigned int x;
memcached_result_st results_obj;
const char *key= "fun";
size_t key_length= strlen(key);
const char *value= "we the people";
- char* keys[2] = { (char*)key, NULL };
+ const char* keys[2] = { key, NULL };
size_t keylengths[2] = { strlen(key), 0 };
size_t value_length= strlen(value);
const char *value2= "change the value";
static test_return prepend_test(memcached_st *memc)
{
memcached_return rc;
- char *key= "fig";
- char *value= "people";
+ const char *key= "fig";
+ const char *value= "people";
+ char *out_value= NULL;
size_t value_length;
uint32_t flags;
(time_t)0, (uint32_t)0);
assert(rc == MEMCACHED_SUCCESS);
- value= memcached_get(memc, key, strlen(key),
+ out_value= memcached_get(memc, key, strlen(key),
&value_length, &flags, &rc);
- assert(!memcmp(value, "we the people", strlen("we the people")));
+ assert(!memcmp(out_value, "we the people", strlen("we the people")));
assert(strlen("we the people") == value_length);
assert(rc == MEMCACHED_SUCCESS);
- free(value);
+ free(out_value);
return 0;
}
static test_return add_test(memcached_st *memc)
{
memcached_return rc;
- char *key= "foo";
- char *value= "when we sanitize";
+ const char *key= "foo";
+ const char *value= "when we sanitize";
unsigned long long setting_value;
setting_value= memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_NO_BLOCK);
static test_return replace_test(memcached_st *memc)
{
memcached_return rc;
- char *key= "foo";
- char *value= "when we sanitize";
- char *original= "first we insert some data";
+ const char *key= "foo";
+ const char *value= "when we sanitize";
+ const char *original= "first we insert some data";
rc= memcached_set(memc, key, strlen(key),
original, strlen(original),
static test_return delete_test(memcached_st *memc)
{
memcached_return rc;
- char *key= "foo";
- char *value= "when we sanitize";
+ const char *key= "foo";
+ const char *value= "when we sanitize";
rc= memcached_set(memc, key, strlen(key),
value, strlen(value),
static test_return memcached_server_cursor_test(memcached_st *memc)
{
- char *context= "foo bad";
+ char context[8];
+ strcpy(context, "foo bad");
memcached_server_function callbacks[1];
callbacks[0]= server_function;
memcached_server_cursor(memc, callbacks, context, 1);
-
return 0;
}
static test_return bad_key_test(memcached_st *memc)
{
memcached_return rc;
- char *key= "foo bad";
+ const char *key= "foo bad";
char *string;
size_t string_length;
uint32_t flags;
assert(!string);
/* Test multi key for bad keys */
- char *keys[] = { "GoodKey", "Bad Key", "NotMine" };
+ const char *keys[] = { "GoodKey", "Bad Key", "NotMine" };
size_t key_lengths[] = { 7, 7, 7 };
set= 1;
rc= memcached_behavior_set(memc_clone, MEMCACHED_BEHAVIOR_VERIFY_KEY, set);
static test_return read_through(memcached_st *memc)
{
memcached_return rc;
- char *key= "foo";
+ const char *key= "foo";
char *string;
size_t string_length;
uint32_t flags;
static test_return get_test(memcached_st *memc)
{
memcached_return rc;
- char *key= "foo";
+ const char *key= "foo";
char *string;
size_t string_length;
uint32_t flags;
static test_return get_test2(memcached_st *memc)
{
memcached_return rc;
- char *key= "foo";
- char *value= "when we sanitize";
+ const char *key= "foo";
+ const char *value= "when we sanitize";
char *string;
size_t string_length;
uint32_t flags;
static test_return set_test2(memcached_st *memc)
{
memcached_return rc;
- char *key= "foo";
- char *value= "train in the brain";
+ const char *key= "foo";
+ const char *value= "train in the brain";
size_t value_length= strlen(value);
unsigned int x;
static test_return get_test3(memcached_st *memc)
{
memcached_return rc;
- char *key= "foo";
+ const char *key= "foo";
char *value;
size_t value_length= 8191;
char *string;
static test_return get_test4(memcached_st *memc)
{
memcached_return rc;
- char *key= "foo";
+ const char *key= "foo";
char *value;
size_t value_length= 8191;
char *string;
** 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" };
+ const char *keys[]= { "key", "key" };
size_t lengths[]= { 3, 3 };
uint32_t flags;
size_t rlen;
return TEST_SUCCESS;
}
+static test_return mget_end(memcached_st *memc)
+{
+ const char *keys[]= { "foo", "foo2" };
+ size_t lengths[]= { 3, 4 };
+ const char *values[]= { "fjord", "41" };
+
+ memcached_return rc;
+
+ // Set foo and foo2
+ for (int i= 0; i < 2; i++)
+ {
+ rc= memcached_set(memc, keys[i], lengths[i], values[i], strlen(values[i]),
+ (time_t)0, (uint32_t)0);
+ assert(rc == MEMCACHED_SUCCESS);
+ }
+
+ char *string;
+ size_t string_length;
+ uint32_t flags;
+
+ // retrieve both via mget
+ rc= memcached_mget(memc, keys, lengths, 2);
+ assert(rc == MEMCACHED_SUCCESS);
+
+ char key[MEMCACHED_MAX_KEY];
+ size_t key_length;
+
+ // this should get both
+ for (int i = 0; i < 2; i++)
+ {
+ string= memcached_fetch(memc, key, &key_length, &string_length,
+ &flags, &rc);
+ assert(rc == MEMCACHED_SUCCESS);
+ int val = 0;
+ if (key_length == 4)
+ val= 1;
+ assert(string_length == strlen(values[val]));
+ assert(strncmp(values[val], string, string_length) == 0);
+ free(string);
+ }
+
+ // this should indicate end
+ string= memcached_fetch(memc, key, &key_length, &string_length, &flags, &rc);
+ assert(rc == MEMCACHED_END);
+
+ // now get just one
+ rc= memcached_mget(memc, keys, lengths, 1);
+ assert(rc == MEMCACHED_SUCCESS);
+
+ string= memcached_fetch(memc, key, &key_length, &string_length, &flags, &rc);
+ assert(key_length == lengths[0]);
+ assert(strncmp(keys[0], key, key_length) == 0);
+ assert(string_length == strlen(values[0]));
+ assert(strncmp(values[0], string, string_length) == 0);
+ assert(rc == MEMCACHED_SUCCESS);
+ free(string);
+
+ // this should indicate end
+ string= memcached_fetch(memc, key, &key_length, &string_length, &flags, &rc);
+ assert(rc == MEMCACHED_END);
+
+ 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)
{
{
uint64_t new_number;
memcached_return rc;
- char *key= "number";
- char *value= "0";
+ const char *key= "number";
+ const char *value= "0";
rc= memcached_set(memc, key, strlen(key),
value, strlen(value),
{
uint64_t new_number;
memcached_return rc;
- char *key= "number";
+ const char *key= "number";
uint64_t initial= 0;
rc= memcached_increment_with_initial(memc, key, strlen(key),
{
uint64_t new_number;
memcached_return rc;
- char *key= "number";
- char *value= "3";
+ const char *key= "number";
+ const char *value= "3";
rc= memcached_set(memc, key, strlen(key),
value, strlen(value),
{
uint64_t new_number;
memcached_return rc;
- char *key= "number";
+ const char *key= "number";
uint64_t initial= 3;
rc= memcached_decrement_with_initial(memc, key, strlen(key),
static test_return quit_test(memcached_st *memc)
{
memcached_return rc;
- char *key= "fudge";
- char *value= "sanford and sun";
+ const char *key= "fudge";
+ const char *value= "sanford and sun";
rc= memcached_set(memc, key, strlen(key),
value, strlen(value),
static test_return mget_result_test(memcached_st *memc)
{
memcached_return rc;
- char *keys[]= {"fudge", "son", "food"};
+ const char *keys[]= {"fudge", "son", "food"};
size_t key_length[]= {5, 3, 4};
unsigned int x;
static test_return mget_result_alloc_test(memcached_st *memc)
{
memcached_return rc;
- char *keys[]= {"fudge", "son", "food"};
+ const char *keys[]= {"fudge", "son", "food"};
size_t key_length[]= {5, 3, 4};
unsigned int x;
static test_return mget_result_function(memcached_st *memc)
{
memcached_return rc;
- char *keys[]= {"fudge", "son", "food"};
+ const char *keys[]= {"fudge", "son", "food"};
size_t key_length[]= {5, 3, 4};
unsigned int x;
unsigned int counter;
static test_return mget_test(memcached_st *memc)
{
memcached_return rc;
- char *keys[]= {"fudge", "son", "food"};
+ const char *keys[]= {"fudge", "son", "food"};
size_t key_length[]= {5, 3, 4};
unsigned int x;
uint32_t flags;
key_lengths[x]= strlen(keys[x]);
}
- rc= memcached_mget(memc, keys, key_lengths, KEY_COUNT);
+ rc= memcached_mget(memc, (const char **)keys, key_lengths, KEY_COUNT);
assert(rc == MEMCACHED_SUCCESS);
/* Turn this into a help function */
static test_return user_supplied_bug4(memcached_st *memc)
{
memcached_return rc;
- char *keys[]= {"fudge", "son", "food"};
+ const char *keys[]= {"fudge", "son", "food"};
size_t key_length[]= {5, 3, 4};
unsigned int x;
uint32_t flags;
static test_return user_supplied_bug5(memcached_st *memc)
{
memcached_return rc;
- char *keys[]= {"036790384900", "036790384902", "036790384904", "036790384906"};
+ const 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;
static test_return user_supplied_bug6(memcached_st *memc)
{
memcached_return rc;
- char *keys[]= {"036790384900", "036790384902", "036790384904", "036790384906"};
+ const 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;
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";
+ const 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);
static test_return user_supplied_bug7(memcached_st *memc)
{
memcached_return rc;
- char *keys= "036790384900";
- size_t key_length= strlen("036790384900");
+ const char *keys= "036790384900";
+ size_t key_length= strlen(keys);
char return_key[MEMCACHED_MAX_KEY];
size_t return_key_length;
char *value;
static test_return user_supplied_bug9(memcached_st *memc)
{
memcached_return rc;
- char *keys[]= {"UDATA:edevil@sapo.pt", "fudge&*@#", "for^#@&$not"};
+ const char *keys[]= {"UDATA:edevil@sapo.pt", "fudge&*@#", "for^#@&$not"};
size_t key_length[3];
unsigned int x;
uint32_t flags;
/* We are testing with aggressive timeout to get failures */
static test_return user_supplied_bug10(memcached_st *memc)
{
- char *key= "foo";
+ const char *key= "foo";
char *value;
size_t value_length= 512;
unsigned int x;
*/
static test_return user_supplied_bug11(memcached_st *memc)
{
- char *key= "foo";
+ const char *key= "foo";
char *value;
size_t value_length= 512;
unsigned int x;
size_t setter= 1;
memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_TCP_NODELAY, setter);
memcached_return rc;
- char *key= "foo";
+ const char *key= "foo";
char *value;
size_t value_length= 18000;
char *string;
{
uint32_t x;
memcached_return rc;
- char *key= "mykey";
+ const char *key= "mykey";
char *value;
size_t length;
uint32_t flags;
static test_return user_supplied_bug16(memcached_st *memc)
{
memcached_return rc;
- char *key= "mykey";
+ const char *key= "mykey";
char *value;
size_t length;
uint32_t flags;
return 0;
}
+#ifndef __sun
/* Check the validity of chinese key*/
static test_return user_supplied_bug17(memcached_st *memc)
{
memcached_return rc;
- char *key= "豆瓣";
- char *value="我们在炎热抑郁的夏天无法停止豆瓣";
+ const char *key= "豆瓣";
+ const char *value="我们在炎热抑郁的夏天无法停止豆瓣";
char *value2;
size_t length;
uint32_t flags;
return 0;
}
+#endif
/*
From Andrei on IRC
{
memcached_return status;
memcached_result_st *result, result_obj;
- char *key = "abc";
+ const char *key = "abc";
size_t key_len = strlen("abc");
- char *value = "foobar";
+ const char *value = "foobar";
size_t value_len = strlen(value);
memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_SUPPORT_CAS, 1);
/* Set to Zero, and then Set to something too large */
{
- char *long_key;
+ char long_key[255];
+ memset(long_key, 0, 255);
+
rc= memcached_callback_set(memc, MEMCACHED_CALLBACK_PREFIX_KEY, NULL);
assert(rc == MEMCACHED_SUCCESS);
/* Test a long key for failure */
/* TODO, extend test to determine based on setting, what result should be */
- long_key= "Thisismorethentheallottednumberofcharacters";
+ strcpy(long_key, "Thisismorethentheallottednumberofcharacters");
rc= memcached_callback_set(memc, MEMCACHED_CALLBACK_PREFIX_KEY, long_key);
//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";
+ strcpy(long_key, "This is more then the allotted number of characters");
rc= memcached_callback_set(memc, MEMCACHED_CALLBACK_PREFIX_KEY, long_key);
assert(rc == MEMCACHED_BAD_KEY_PROVIDED);
rc= memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_VERIFY_KEY, 1);
assert(rc == MEMCACHED_SUCCESS);
- long_key= "dog cat";
+ strcpy(long_key, "dog cat");
rc= memcached_callback_set(memc, MEMCACHED_CALLBACK_PREFIX_KEY, long_key);
assert(rc == MEMCACHED_BAD_KEY_PROVIDED);
}
memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_POLL_TIMEOUT, timeout);
- timeout= memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_POLL_TIMEOUT);
+ timeout= (size_t)memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_POLL_TIMEOUT);
assert(timeout == 100);
/* Try setting an illegal cas value (should not return an error to
* the caller (because we don't expect a return message from the server)
*/
- char* keys[]= {"0"};
+ const char* keys[]= {"0"};
size_t lengths[]= {1};
size_t length;
uint32_t flags;
for (int x= 0; x < 10; ++x)
assert(memcached_pool_push(pool, mmc[x]) == MEMCACHED_SUCCESS);
+
+ /* verify that I can set behaviors on the pool when I don't have all
+ * of the connections in the pool. It should however be enabled
+ * when I push the item into the pool
+ */
+ mmc[0]= memcached_pool_pop(pool, false, &rc);
+ assert(mmc[0] != NULL);
+
+ rc= memcached_pool_behavior_set(pool, MEMCACHED_BEHAVIOR_IO_MSG_WATERMARK, 9999);
+ assert(rc == MEMCACHED_SUCCESS);
+
+ mmc[1]= memcached_pool_pop(pool, false, &rc);
+ assert(mmc[1] != NULL);
+
+ assert(memcached_behavior_get(mmc[1], MEMCACHED_BEHAVIOR_IO_MSG_WATERMARK) == 9999);
+ assert(memcached_pool_push(pool, mmc[1]) == MEMCACHED_SUCCESS);
+ assert(memcached_pool_push(pool, mmc[0]) == MEMCACHED_SUCCESS);
+
+ mmc[0]= memcached_pool_pop(pool, false, &rc);
+ assert(memcached_behavior_get(mmc[0], MEMCACHED_BEHAVIOR_IO_MSG_WATERMARK) == 9999);
+ assert(memcached_pool_push(pool, mmc[0]) == MEMCACHED_SUCCESS);
+
+
assert(memcached_pool_destroy(pool) == memc);
return TEST_SUCCESS;
}
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);
+ memcached_st *memc_clone= memcached_clone(NULL, memc);
+ memcached_behavior_set(memc_clone, MEMCACHED_BEHAVIOR_NUMBER_OF_REPLICAS, 0);
rc= memcached_set(memc, "bubba", 5, "0", 1, 0, 0);
assert(rc == MEMCACHED_SUCCESS);
char key[2]= { [0]= (char)x };
size_t len;
uint32_t flags;
- char *val= memcached_get_by_key(clone, key, 1, "bubba", 5,
+ char *val= memcached_get_by_key(memc_clone, key, 1, "bubba", 5,
&len, &flags, &rc);
assert(rc == MEMCACHED_SUCCESS);
assert(val != NULL);
free(val);
}
- memcached_free(clone);
+ memcached_free(memc_clone);
return TEST_SUCCESS;
}
*/
for (uint32_t host= 0; host < memc->number_of_hosts; ++host)
{
- memcached_st *clone= memcached_clone(NULL, memc);
- clone->hosts[host].port= 0;
+ memcached_st *memc_clone= memcached_clone(NULL, memc);
+ 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,
+ char *val= memcached_get_by_key(memc_clone, key, 1, "bubba", 5,
&len, &flags, &rc);
assert(rc == MEMCACHED_SUCCESS);
assert(val != NULL);
free(val);
}
- memcached_free(clone);
+ memcached_free(memc_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);
+ memcached_st *memc_clone= memcached_clone(NULL, memc);
+ memcached_behavior_set(memc_clone, MEMCACHED_BEHAVIOR_NUMBER_OF_REPLICAS, 0);
- char *keys[]= { "bubba", "key1", "key2", "key3" };
+ const char *keys[]= { "bubba", "key1", "key2", "key3" };
size_t len[]= { 5, 4, 4, 4 };
for (int x=0; x< 4; ++x)
* 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++)
+ for (uint32_t host= 0; host < memc_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 };
+ const char key[2]= { [0]= (const char)x };
rc= memcached_mget_by_key(new_clone, key, 1, keys, len, 4);
assert(rc == MEMCACHED_SUCCESS);
memcached_free(new_clone);
}
+ memcached_free(memc_clone);
+
return TEST_SUCCESS;
}
static test_return replication_delete_test(memcached_st *memc)
{
memcached_return rc;
- memcached_st *clone= memcached_clone(NULL, memc);
+ memcached_st *memc_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" };
+ const char *keys[]= { "bubba", "key1", "key2", "key3" };
size_t len[]= { 5, 4, 4, 4 };
for (int x=0; x< 4; ++x)
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)
+ memc_clone->hosts[hash].port= 0;
+ if (++hash == memc_clone->number_of_hosts)
hash= 0;
}
memcached_result_st result_obj;
- for (uint32_t host= 0; host < clone->number_of_hosts; ++host)
+ for (uint32_t host= 0; host < memc_clone->number_of_hosts; ++host)
{
for (int x= 'a'; x <= 'z'; ++x)
{
- char key[2]= { [0]= (char)x };
+ const char key[2]= { [0]= (const char)x };
- rc= memcached_mget_by_key(clone, key, 1, keys, len, 4);
+ rc= memcached_mget_by_key(memc_clone, key, 1, keys, len, 4);
assert(rc == MEMCACHED_SUCCESS);
- memcached_result_st *results= memcached_result_create(clone, &result_obj);
+ memcached_result_st *results= memcached_result_create(memc_clone, &result_obj);
assert(results);
int hits= 0;
- while ((results= memcached_fetch_result(clone, &result_obj, &rc)) != NULL)
+ while ((results= memcached_fetch_result(memc_clone, &result_obj, &rc)) != NULL)
{
++hits;
}
memcached_result_free(&result_obj);
}
}
- memcached_free(clone);
+ memcached_free(memc_clone);
return TEST_SUCCESS;
}
for (x= 0; x < num_iters;x++)
{
memcached_return rc;
- char *key= "foo";
- char *value= "when we sanitize";
+ const char *key= "foo";
+ const char *value= "when we sanitize";
uint16_t *expected_ids= get_udp_request_ids(memc);
unsigned int server_key= memcached_generate_hash(memc,key,strlen(key));
size_t init_offset= memc->hosts[server_key].write_buffer_offset;
static test_return udp_set_too_big_test(memcached_st *memc)
{
memcached_return rc;
- char *key= "bar";
+ const char *key= "bar";
char value[MAX_UDP_DATAGRAM_LENGTH];
uint16_t *expected_ids= get_udp_request_ids(memc);
rc= memcached_set(memc, key, strlen(key),
for (x= 0; x < num_iters;x++)
{
memcached_return rc;
- char *key= "foo";
+ const char *key= "foo";
uint16_t *expected_ids=get_udp_request_ids(memc);
unsigned int server_key= memcached_generate_hash(memc, key, strlen(key));
size_t init_offset= memc->hosts[server_key].write_buffer_offset;
static test_return udp_incr_test(memcached_st *memc)
{
memcached_return rc;
- char *key= "incr";
- char *value= "1";
+ const char *key= "incr";
+ const char *value= "1";
rc= memcached_set(memc, key, strlen(key),
value, strlen(value),
(time_t)0, (uint32_t)0);
static test_return udp_decr_test(memcached_st *memc)
{
memcached_return rc;
- char *key= "decr";
- char *value= "1";
+ const char *key= "decr";
+ const char *value= "1";
rc= memcached_set(memc, key, strlen(key),
value, strlen(value),
(time_t)0, (uint32_t)0);
static test_return udp_get_test(memcached_st *memc)
{
memcached_return rc;
- char *key= "foo";
+ const char *key= "foo";
size_t vlen;
uint16_t *expected_ids = get_udp_request_ids(memc);
char *val= memcached_get(memc, key, strlen(key), &vlen, (uint32_t)0, &rc);
return TEST_SUCCESS;
}
-static char *list[]=
+static const char *list[]=
{
"apple",
"beat",
static test_return md5_run (memcached_st *memc __attribute__((unused)))
{
uint32_t x;
- char **ptr;
+ const char **ptr;
uint32_t values[]= { 3195025439U, 2556848621U, 3724893440U, 3332385401U,
245758794U, 2550894432U, 121710495U, 3053817768U,
1250994555U, 1862072655U, 2631955953U, 2951528551U,
static test_return crc_run (memcached_st *memc __attribute__((unused)))
{
uint32_t x;
- char **ptr;
+ const char **ptr;
uint32_t values[]= { 10542U, 22009U, 14526U, 19510U, 19432U, 10199U, 20634U,
9369U, 11511U, 10362U, 7893U, 31289U, 11313U, 9354U,
7621U, 30628U, 15218U, 25967U, 2695U, 9380U,
static test_return fnv1_64_run (memcached_st *memc __attribute__((unused)))
{
uint32_t x;
- char **ptr;
+ const char **ptr;
uint32_t values[]= { 473199127U, 4148981457U, 3971873300U, 3257986707U,
1722477987U, 2991193800U, 4147007314U, 3633179701U,
1805162104U, 3503289120U, 3395702895U, 3325073042U,
static test_return fnv1a_64_run (memcached_st *memc __attribute__((unused)))
{
uint32_t x;
- char **ptr;
+ const char **ptr;
uint32_t values[]= { 1488911807U, 2500855813U, 1510099634U, 1390325195U,
3647689787U, 3241528582U, 1669328060U, 2604311949U,
734810122U, 1516407546U, 560948863U, 1767346780U,
static test_return fnv1_32_run (memcached_st *memc __attribute__((unused)))
{
uint32_t x;
- char **ptr;
+ const char **ptr;
uint32_t values[]= { 67176023U, 1190179409U, 2043204404U, 3221866419U,
2567703427U, 3787535528U, 4147287986U, 3500475733U,
344481048U, 3865235296U, 2181839183U, 119581266U,
static test_return fnv1a_32_run (memcached_st *memc __attribute__((unused)))
{
uint32_t x;
- char **ptr;
+ const char **ptr;
uint32_t values[]= { 280767167U, 2421315013U, 3072375666U, 855001899U,
459261019U, 3521085446U, 18738364U, 1625305005U,
2162232970U, 777243802U, 3323728671U, 132336572U,
static test_return hsieh_run (memcached_st *memc __attribute__((unused)))
{
uint32_t x;
- char **ptr;
+ const char **ptr;
#ifdef HAVE_HSIEH_HASH
uint32_t values[]= { 3738850110, 3636226060, 3821074029, 3489929160, 3485772682, 80540287,
1805464076, 1895033657, 409795758, 979934958, 3634096985, 1284445480,
static test_return murmur_run (memcached_st *memc __attribute__((unused)))
{
uint32_t x;
- char **ptr;
+ const char **ptr;
uint32_t values[]= { 473199127U, 4148981457U, 3971873300U, 3257986707U,
1722477987U, 2991193800U, 4147007314U, 3633179701U,
1805162104U, 3503289120U, 3395702895U, 3325073042U,
static test_return jenkins_run (memcached_st *memc __attribute__((unused)))
{
uint32_t x;
- char **ptr;
+ const char **ptr;
uint32_t values[]= { 1442444624U, 4253821186U, 1885058256U, 2120131735U,
3261968576U, 3515188778U, 4232909173U, 4288625128U,
1812047395U, 3689182164U, 2502979932U, 1214050606U,
return TEST_SUCCESS;
}
+static test_return regression_bug_434484(memcached_st *memc)
+{
+ if (pre_binary(memc) != TEST_SUCCESS)
+ return TEST_SUCCESS;
+
+ memcached_return ret;
+ const char *key= "regression_bug_434484";
+ size_t keylen= strlen(key);
+
+ ret= memcached_append(memc, key, keylen, key, keylen, 0, 0);
+ assert(ret == MEMCACHED_NOTSTORED);
+
+ size_t size= 2048 * 1024;
+ void *data= malloc(size);
+ assert(data != NULL);
+ ret= memcached_set(memc, key, keylen, data, size, 0, 0);
+ assert(ret == MEMCACHED_E2BIG);
+ free(data);
+
+ 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},
{"mget_result", 1, mget_result_test },
{"mget_result_alloc", 1, mget_result_alloc_test },
{"mget_result_function", 1, mget_result_function },
+ {"mget_end", 0, mget_end },
{"get_stats", 0, get_stats },
{"add_host_test", 0, add_host_test },
{"add_host_test_1", 0, add_host_test1 },
{0, 0, 0}
};
+/*
+ * The following test suite is used to verify that we don't introduce
+ * regression bugs. If you want more information about the bug / test,
+ * you should look in the bug report at
+ * http://bugs.launchpad.net/libmemcached
+ */
+test_st regression_tests[]= {
+ {"lp:434484", 1, regression_bug_434484 },
+ {0, 0, 0}
+};
+
test_st generate_tests[] ={
{"generate_pairs", 1, generate_pairs },
{"generate_data", 1, generate_data },
{"test_hashes", 0, 0, hash_tests},
{"replication", pre_replication, 0, replication_tests},
{"replication_noblock", pre_replication_noblock, 0, replication_tests},
+ {"regression", 0, 0, regression_tests},
{0, 0, 0, 0}
};
projects / awesomized / libmemcached / blobdiff