rc= memcached_set(memc, key, strlen(key),
value, strlen(value),
- (time_t)0, (uint16_t)0);
+ (time_t)0, (uint32_t)0);
assert(rc == MEMCACHED_SUCCESS);
return 0;
char *key= "fig";
char *value= "we";
size_t value_length;
- uint16_t flags;
+ uint32_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);
+ (time_t)0, (uint32_t)0);
assert(rc == MEMCACHED_SUCCESS);
rc= memcached_append(memc, key, strlen(key),
" the", strlen(" the"),
- (time_t)0, (uint16_t)0);
+ (time_t)0, (uint32_t)0);
assert(rc == MEMCACHED_SUCCESS);
rc= memcached_append(memc, key, strlen(key),
" people", strlen(" people"),
- (time_t)0, (uint16_t)0);
+ (time_t)0, (uint32_t)0);
assert(rc == MEMCACHED_SUCCESS);
value= memcached_get(memc, key, strlen(key),
unsigned int store_list[] = { 23, 56, 499, 98, 32847, 0 };
char *value;
size_t value_length;
- uint16_t flags;
+ uint32_t flags;
unsigned int x;
rc= memcached_flush(memc, 0);
rc= memcached_set(memc,
key, strlen(key),
NULL, 0,
- (time_t)0, (uint16_t)0);
+ (time_t)0, (uint32_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);
+ (time_t)0, (uint32_t)0);
assert(rc == MEMCACHED_SUCCESS);
}
{
rc= memcached_set(memc, keys[x], key_length[x],
keys[x], key_length[x],
- (time_t)50, (uint16_t)9);
+ (time_t)50, (uint32_t)9);
assert(rc == MEMCACHED_SUCCESS);
}
rc= memcached_set(memc, key, strlen(key),
value, strlen(value),
- (time_t)0, (uint16_t)0);
+ (time_t)0, (uint32_t)0);
assert(rc == MEMCACHED_SUCCESS);
rc= memcached_mget(memc, &key, &key_length, 1);
char *key= "fig";
char *value= "people";
size_t value_length;
- uint16_t flags;
+ uint32_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);
+ (time_t)0, (uint32_t)0);
assert(rc == MEMCACHED_SUCCESS);
rc= memcached_prepend(memc, key, strlen(key),
"the ", strlen("the "),
- (time_t)0, (uint16_t)0);
+ (time_t)0, (uint32_t)0);
assert(rc == MEMCACHED_SUCCESS);
rc= memcached_prepend(memc, key, strlen(key),
"we ", strlen("we "),
- (time_t)0, (uint16_t)0);
+ (time_t)0, (uint32_t)0);
assert(rc == MEMCACHED_SUCCESS);
value= memcached_get(memc, key, strlen(key),
rc= memcached_set(memc, key, strlen(key),
value, strlen(value),
- (time_t)0, (uint16_t)0);
+ (time_t)0, (uint32_t)0);
assert(rc == MEMCACHED_SUCCESS);
memcached_quit(memc);
rc= memcached_add(memc, key, strlen(key),
value, strlen(value),
- (time_t)0, (uint16_t)0);
+ (time_t)0, (uint32_t)0);
assert(rc == MEMCACHED_NOTSTORED);
return 0;
}
+uint8_t add_wrapper(memcached_st *memc)
+{
+ unsigned int x;
+
+ for (x= 0; x < 10000; x++)
+ add_test(memc);
+
+ return 0;
+}
+
uint8_t replace_test(memcached_st *memc)
{
memcached_return rc;
rc= memcached_replace(memc, key, strlen(key),
value, strlen(value),
- (time_t)0, (uint16_t)0);
+ (time_t)0, (uint32_t)0);
assert(rc == MEMCACHED_SUCCESS);
return 0;
rc= memcached_set(memc, key, strlen(key),
value, strlen(value),
- (time_t)0, (uint16_t)0);
+ (time_t)0, (uint32_t)0);
assert(rc == MEMCACHED_SUCCESS);
rc= memcached_delete(memc, key, strlen(key), (time_t)0);
char *key= "foo";
char *string;
size_t string_length;
- uint16_t flags;
+ uint32_t flags;
rc= memcached_delete(memc, key, strlen(key), (time_t)0);
assert(rc == MEMCACHED_SUCCESS || rc == MEMCACHED_NOTFOUND);
char *value= "when we sanitize";
char *string;
size_t string_length;
- uint16_t flags;
+ uint32_t flags;
rc= memcached_set(memc, key, strlen(key),
value, strlen(value),
- (time_t)0, (uint16_t)0);
+ (time_t)0, (uint32_t)0);
assert(rc == MEMCACHED_SUCCESS);
string= memcached_get(memc, key, strlen(key),
{
rc= memcached_set(memc, key, strlen(key),
value, value_length,
- (time_t)0, (uint16_t)0);
+ (time_t)0, (uint32_t)0);
assert(rc == MEMCACHED_SUCCESS);
}
{
rc= memcached_set(memc, key, strlen(key),
value, value_length,
- (time_t)0, (uint16_t)0);
+ (time_t)0, (uint32_t)0);
assert(rc == MEMCACHED_SUCCESS);
}
size_t value_length= 8191;
char *string;
size_t string_length;
- uint16_t flags;
+ uint32_t flags;
int x;
value = (char*)malloc(value_length);
rc= memcached_set(memc, key, strlen(key),
value, value_length,
- (time_t)0, (uint16_t)0);
+ (time_t)0, (uint32_t)0);
assert(rc == MEMCACHED_SUCCESS);
string= memcached_get(memc, key, strlen(key),
size_t value_length= 8191;
char *string;
size_t string_length;
- uint16_t flags;
+ uint32_t flags;
int x;
value = (char*)malloc(value_length);
rc= memcached_set(memc, key, strlen(key),
value, value_length,
- (time_t)0, (uint16_t)0);
+ (time_t)0, (uint32_t)0);
assert(rc == MEMCACHED_SUCCESS);
for (x= 0; x < 10; x++)
rc= memcached_set(memc, key, strlen(key),
value, strlen(value),
- (time_t)0, (uint16_t)0);
+ (time_t)0, (uint32_t)0);
assert(rc == MEMCACHED_SUCCESS);
rc= memcached_increment(memc, key, strlen(key),
rc= memcached_set(memc, key, strlen(key),
value, strlen(value),
- (time_t)0, (uint16_t)0);
+ (time_t)0, (uint32_t)0);
assert(rc == MEMCACHED_SUCCESS);
rc= memcached_decrement(memc, key, strlen(key),
rc= memcached_set(memc, key, strlen(key),
value, strlen(value),
- (time_t)10, (uint16_t)3);
+ (time_t)10, (uint32_t)3);
assert(rc == MEMCACHED_SUCCESS);
memcached_quit(memc);
rc= memcached_set(memc, key, strlen(key),
value, strlen(value),
- (time_t)50, (uint16_t)9);
+ (time_t)50, (uint32_t)9);
assert(rc == MEMCACHED_SUCCESS);
return 0;
{
rc= memcached_set(memc, keys[x], key_length[x],
keys[x], key_length[x],
- (time_t)50, (uint16_t)9);
+ (time_t)50, (uint32_t)9);
assert(rc == MEMCACHED_SUCCESS);
}
{
rc= memcached_set(memc, keys[x], key_length[x],
keys[x], key_length[x],
- (time_t)50, (uint16_t)9);
+ (time_t)50, (uint32_t)9);
assert(rc == MEMCACHED_SUCCESS);
}
char *keys[]= {"fudge", "son", "food"};
size_t key_length[]= {5, 3, 4};
unsigned int x;
- uint16_t flags;
+ uint32_t flags;
char return_key[MEMCACHED_MAX_KEY];
size_t return_key_length;
{
rc= memcached_set(memc, keys[x], key_length[x],
keys[x], key_length[x],
- (time_t)50, (uint16_t)9);
+ (time_t)50, (uint32_t)9);
assert(rc == MEMCACHED_SUCCESS);
}
{
memcached_return rc= MEMCACHED_SUCCESS;
char buffer[SMALL_STRING_LEN];
- uint16_t flags= 0;
+ uint32_t flags= 0;
size_t val_len= 0;
char *getval;
size_t return_key_length;
char *return_value;
size_t return_value_length;
- uint16_t flags;
+ uint32_t flags;
while ((return_value= memcached_fetch(memc, return_key, &return_key_length,
&return_value_length, &flags, &rc)))
char *keys[]= {"fudge", "son", "food"};
size_t key_length[]= {5, 3, 4};
unsigned int x;
- uint16_t flags;
+ uint32_t flags;
/* Here we free everything before running a bunch of mget tests */
{
{
rc= memcached_set(memc, keys[x], key_length[x],
keys[x], key_length[x],
- (time_t)50, (uint16_t)9);
+ (time_t)50, (uint32_t)9);
assert(rc == MEMCACHED_NO_SERVERS);
}
size_t return_key_length;
char *value;
size_t value_length;
- uint16_t flags;
+ uint32_t flags;
unsigned int count;
unsigned int x;
char insert_data[VALUE_SIZE_BUG5];
{
rc= memcached_set(memc, keys[x], key_length[x],
insert_data, VALUE_SIZE_BUG5,
- (time_t)0, (uint16_t)0);
+ (time_t)0, (uint32_t)0);
assert(rc == MEMCACHED_SUCCESS);
}
size_t return_key_length;
char *value;
size_t value_length;
- uint16_t flags;
+ uint32_t flags;
unsigned int count;
unsigned int x;
char insert_data[VALUE_SIZE_BUG5];
{
rc= memcached_set(memc, keys[x], key_length[x],
insert_data, VALUE_SIZE_BUG5,
- (time_t)0, (uint16_t)0);
+ (time_t)0, (uint32_t)0);
assert(rc == MEMCACHED_SUCCESS);
}
size_t return_key_length;
char *value;
size_t value_length;
- uint16_t flags;
+ uint32_t flags;
unsigned int x;
char insert_data[VALUE_SIZE_BUG5];
char *keys[]= {"UDATA:edevil@sapo.pt", "fudge&*@#", "for^#@&$not"};
size_t key_length[3];
unsigned int x;
- uint16_t flags;
+ uint32_t flags;
unsigned count= 0;
char return_key[MEMCACHED_MAX_KEY];
{
rc= memcached_set(memc, keys[x], key_length[x],
keys[x], key_length[x],
- (time_t)50, (uint16_t)9);
+ (time_t)50, (uint32_t)9);
assert(rc == MEMCACHED_SUCCESS);
}
{
rc= memcached_set(mclone, key, key_len,value, value_length, 0, 0);
- assert(rc == MEMCACHED_SUCCESS);
+ WATCHPOINT_IFERROR(rc);
+ //assert(rc == MEMCACHED_SUCCESS);
}
free(value);
{
char *return_value;
size_t return_value_length;
- uint16_t flags;
+ uint32_t flags;
for (x= 0; x < GLOBAL_COUNT; x++)
{
size_t return_key_length;
char *return_value;
size_t return_value_length;
- uint16_t flags;
+ uint32_t flags;
while ((return_value= memcached_fetch(memc, return_key, &return_key_length,
&return_value_length, &flags, &rc)))
{0, 0, 0}
};
+test_st async_tests[] ={
+ {"add", 1, add_wrapper },
+ {0, 0, 0}
+};
+
test_st string_tests[] ={
{"string static with null", 0, string_static_null },
{"string alloc with null", 0, string_alloc_null },
{"version_1_2_3", check_for_1_2_3, 0, version_1_2_3},
{"string", 0, 0, string_tests},
{"result", 0, 0, result_tests},
+ {"async", pre_nonblock, 0, async_tests},
{"user", 0, 0, user_tests},
{"generate", 0, 0, generate_tests},
{"generate_hsieh", pre_hsieh, 0, generate_tests},