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 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;
{
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;
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;
{
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);
}
/* 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;
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)
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_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)
{
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(memc_clone, key, 1, keys, len, 4);
assert(rc == MEMCACHED_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,
projects / awesomized / libmemcached / commitdiff
