static test_return_t pre_binary(memcached_st *memc);
-static test_return_t init_test(memcached_st *not_used __attribute__((unused)))
+static test_return_t init_test(memcached_st *not_used)
{
memcached_st memc;
+ (void)not_used;
(void)memcached_create(&memc);
memcached_free(&memc);
return TEST_SUCCESS;
}
-static test_return_t server_list_null_test(memcached_st *ptr __attribute__((unused)))
+static test_return_t server_list_null_test(memcached_st *ptr)
{
memcached_server_st *server_list;
memcached_return_t rc;
+ (void)ptr;
server_list= memcached_server_list_append_with_weight(NULL, NULL, 0, 0, NULL);
test_true(server_list == NULL);
#define TEST_PORT_COUNT 7
in_port_t test_ports[TEST_PORT_COUNT];
-static memcached_return_t server_display_function(const memcached_st *ptr __attribute__((unused)),
+static memcached_return_t server_display_function(const memcached_st *ptr,
const memcached_server_st *server,
void *context)
{
/* Do Nothing */
size_t bigger= *((size_t *)(context));
+ (void)ptr;
assert(bigger <= memcached_server_port(server));
*((size_t *)(context))= memcached_server_port(server);
return MEMCACHED_SUCCESS;
}
-static memcached_return_t dump_server_information(const memcached_st *ptr __attribute__((unused)),
+static memcached_return_t dump_server_information(const memcached_st *ptr,
const memcached_server_st *instance,
void *context)
{
/* Do Nothing */
FILE *stream= (FILE *)context;
+ (void)ptr;
- fprintf(stream, "Memcached Server: %s %u Version %u.%u.%u\n",
+ fprintf(stream, "Memcached Server: %s %u Version %u.%u.%u\n",
memcached_server_name(instance),
memcached_server_port(instance),
instance->major_version,
return MEMCACHED_SUCCESS;
}
-static test_return_t server_sort_test(memcached_st *ptr __attribute__((unused)))
+static test_return_t server_sort_test(memcached_st *ptr)
{
size_t bigger= 0; /* Prime the value for the test_true in server_display_function */
memcached_return_t rc;
memcached_server_fn callbacks[1];
memcached_st *local_memc;
+ (void)ptr;
local_memc= memcached_create(NULL);
test_true(local_memc);
return TEST_SUCCESS;
}
-static test_return_t server_sort2_test(memcached_st *ptr __attribute__((unused)))
+static test_return_t server_sort2_test(memcached_st *ptr)
{
size_t bigger= 0; /* Prime the value for the test_true in server_display_function */
memcached_return_t rc;
memcached_server_fn callbacks[1];
memcached_st *local_memc;
memcached_server_instance_st instance;
+ (void)ptr;
local_memc= memcached_create(NULL);
test_true(local_memc);
return TEST_SUCCESS;
}
-static memcached_return_t server_print_callback(const memcached_st *ptr __attribute__((unused)),
+static memcached_return_t server_print_callback(const memcached_st *ptr,
const memcached_server_st *server,
- void *context __attribute__((unused)))
+ void *context)
{
(void)server; // Just in case we aren't printing.
+ (void)ptr;
+ (void)context;
#if 0
fprintf(stderr, "%s(%d)", memcached_server_name(server), memcached_server_port(server));
return MEMCACHED_SUCCESS;
}
-static test_return_t memcached_server_remove_test(memcached_st *ptr __attribute__((unused)))
+static test_return_t memcached_server_remove_test(memcached_st *ptr)
{
memcached_return_t rc;
memcached_st local_memc;
memcached_server_fn callbacks[1];
const char *server_string= "localhost:4444, localhost:4445, localhost:4446, localhost:4447, localhost, 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";
+ (void)ptr;
memc= memcached_create(&local_memc);
return TEST_SUCCESS;
}
-static memcached_return_t server_display_unsort_function(const memcached_st *ptr __attribute__((unused)),
+static memcached_return_t server_display_unsort_function(const memcached_st *ptr,
const memcached_server_st *server,
void *context)
{
/* Do Nothing */
uint32_t x= *((uint32_t *)(context));
+ (void)ptr;
assert(test_ports[x] == server->port);
*((uint32_t *)(context))= ++x;
return MEMCACHED_SUCCESS;
}
-static test_return_t server_unsort_test(memcached_st *ptr __attribute__((unused)))
+static test_return_t server_unsort_test(memcached_st *ptr)
{
size_t counter= 0; /* Prime the value for the test_true in server_display_function */
size_t bigger= 0; /* Prime the value for the test_true in server_display_function */
memcached_return_t rc;
memcached_server_fn callbacks[1];
memcached_st *local_memc;
+ (void)ptr;
local_memc= memcached_create(NULL);
test_true(local_memc);
return TEST_SUCCESS;
}
-static test_return_t allocation_test(memcached_st *not_used __attribute__((unused)))
+static test_return_t allocation_test(memcached_st *not_used)
{
+ (void)not_used;
memcached_st *memc;
memc= memcached_create(NULL);
test_true(memc);
return TEST_SUCCESS;
}
-static memcached_return_t server_function(const memcached_st *ptr __attribute__((unused)),
- const memcached_server_st *server __attribute__((unused)),
- void *context __attribute__((unused)))
+static memcached_return_t server_function(const memcached_st *ptr,
+ const memcached_server_st *server,
+ void *context)
{
+ (void)ptr; (void)server; (void)context;
/* Do Nothing */
return MEMCACHED_SUCCESS;
}
#define READ_THROUGH_VALUE "set for me"
-static memcached_return_t read_through_trigger(memcached_st *memc __attribute__((unused)),
- char *key __attribute__((unused)),
- size_t key_length __attribute__((unused)),
+static memcached_return_t read_through_trigger(memcached_st *memc,
+ char *key,
+ size_t key_length,
memcached_result_st *result)
{
-
+ (void)memc;(void)key;(void)key_length;
return memcached_result_set_value(result, READ_THROUGH_VALUE, strlen(READ_THROUGH_VALUE));
}
return TEST_SUCCESS;
}
-static memcached_return_t delete_trigger(memcached_st *ptr __attribute__((unused)),
+static memcached_return_t delete_trigger(memcached_st *ptr,
const char *key,
- size_t key_length __attribute__((unused)))
+ size_t key_length)
{
+ (void)ptr;(void)key_length;
assert(key);
return MEMCACHED_SUCCESS;
{
char key[16];
- sprintf(key, "foo%u", x);
+ snprintf(key, sizeof(key), "foo%u", x);
rc= memcached_set(memc, key, strlen(key),
value, value_length,
}
/* Count the results */
-static memcached_return_t callback_counter(const memcached_st *ptr __attribute__((unused)),
- memcached_result_st *result __attribute__((unused)),
+static memcached_return_t callback_counter(const memcached_st *ptr,
+ memcached_result_st *result,
void *context)
{
+ (void)ptr; (void)result;
size_t *counter= (size_t *)context;
*counter= *counter + 1;
return TEST_SUCCESS;
}
-static test_return_t version_string_test(memcached_st *memc __attribute__((unused)))
+static test_return_t version_string_test(memcached_st *memc)
{
const char *version_string;
+ (void)memc;
version_string= memcached_lib_version();
return TEST_SUCCESS;
}
-static memcached_return_t clone_test_callback(memcached_st *parent __attribute__((unused)), memcached_st *memc_clone __attribute__((unused)))
+static memcached_return_t clone_test_callback(memcached_st *parent, memcached_st *memc_clone)
{
+ (void)parent;(void)memc_clone;
return MEMCACHED_SUCCESS;
}
-static memcached_return_t cleanup_test_callback(memcached_st *ptr __attribute__((unused)))
+static memcached_return_t cleanup_test_callback(memcached_st *ptr)
{
+ (void)ptr;
return MEMCACHED_SUCCESS;
}
return TEST_SUCCESS;
}
-static test_return_t fetch_all_results(memcached_st *memc)
+static test_return_t fetch_all_results(memcached_st *memc, size_t *keys_returned)
{
memcached_return_t rc= MEMCACHED_SUCCESS;
char return_key[MEMCACHED_MAX_KEY];
size_t return_value_length;
uint32_t flags;
+ *keys_returned= 0;
+
while ((return_value= memcached_fetch(memc, return_key, &return_key_length,
&return_value_length, &flags, &rc)))
{
test_true(return_value);
test_true(rc == MEMCACHED_SUCCESS);
free(return_value);
+ *keys_returned= *keys_returned +1;
}
test_true_got(rc == MEMCACHED_END || rc == MEMCACHED_SUCCESS, memcached_strerror(NULL, rc));
rc= memcached_mget(memc, (const char **)keys, key_lengths, KEY_COUNT);
test_true(rc == MEMCACHED_SUCCESS);
- test_true(fetch_all_results(memc) == TEST_SUCCESS);
+ size_t keys_returned;
+ test_true(fetch_all_results(memc, &keys_returned) == TEST_SUCCESS);
for (x= 0; x < KEY_COUNT; x++)
free(keys[x]);
return TEST_SUCCESS;
}
-static test_return_t user_supplied_bug8(memcached_st *memc __attribute__((unused)))
+static test_return_t user_supplied_bug8(memcached_st *memc)
{
memcached_return_t rc;
memcached_st *mine;
memcached_server_st *servers;
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";
+ (void)memc;
servers= memcached_servers_parse(server_list);
test_true(servers);
*/
/* sighandler_t function that always asserts false */
-static void fail(int unused __attribute__((unused)))
+static void fail(int unused)
{
+ (void)unused;
assert(0);
}
alarm(0);
signal(SIGALRM, oldalarm);
- test_true(fetch_all_results(memc) == TEST_SUCCESS);
+ size_t keys_returned;
+ test_true(fetch_all_results(memc, &keys_returned) == TEST_SUCCESS);
for (x= 0; x < key_count; x++)
free(keys[x]);
for (int x= 0; x < 10000; x++)
{
char key[10];
- sprintf(key, "%d", x);
+ snprintf(key, sizeof(key), "%d", x);
uint32_t server_idx = memcached_generate_hash(memc, key, strlen(key));
char *hostname = memc->hosts[server_idx].hostname;
return TEST_SUCCESS;
}
-static test_return_t cleanup_pairs(memcached_st *memc __attribute__((unused)))
+static test_return_t cleanup_pairs(memcached_st *memc)
{
+ (void)memc;
pairs_free(global_pairs);
return TEST_SUCCESS;
}
-static test_return_t generate_pairs(memcached_st *memc __attribute__((unused)))
+static test_return_t generate_pairs(memcached_st *memc)
{
+ (void)memc;
global_pairs= pairs_generate(GLOBAL_COUNT, 400);
global_count= GLOBAL_COUNT;
return TEST_SUCCESS;
}
-static test_return_t generate_large_pairs(memcached_st *memc __attribute__((unused)))
+static test_return_t generate_large_pairs(memcached_st *memc)
{
+ (void)memc;
global_pairs= pairs_generate(GLOBAL2_COUNT, MEMCACHED_MAX_BUFFER+10);
global_count= GLOBAL2_COUNT;
static test_return_t generate_data(memcached_st *memc)
{
- execute_set(memc, global_pairs, global_count);
+ unsigned int check_execute= execute_set(memc, global_pairs, global_count);
+
+ test_true(check_execute == global_count);
return TEST_SUCCESS;
}
memcached_stat_st *stat_p;
memcached_return_t rc;
uint32_t host_index= 0;
- execute_set(memc, global_pairs, global_count);
+ unsigned int check_execute= execute_set(memc, global_pairs, global_count);
+
+ test_true(check_execute == global_count);
//TODO: hosts used size stats
stat_p= memcached_stat(memc, NULL, &rc);
{
memcached_return_t rc;
+ if (! libmemcached_util_version_check(memc, 1, 4, 4))
+ return TEST_SKIPPED;
+
rc= memcached_mget(memc, global_keys, global_keys_length, global_count);
+
test_true_got(rc == MEMCACHED_SUCCESS, memcached_strerror(NULL, rc));
- test_true(fetch_all_results(memc) == TEST_SUCCESS);
+
+ // Go fetch the keys and test to see if all of them were returned
+ {
+ size_t keys_returned;
+ test_true(fetch_all_results(memc, &keys_returned) == TEST_SUCCESS);
+ char buffer[30];
+ snprintf(buffer, sizeof(buffer), "%lu", (unsigned long)keys_returned);
+ test_true_got(global_count == keys_returned, buffer);
+ }
+
return TEST_SUCCESS;
}
{
memcached_return_t rc;
+ if (! libmemcached_util_version_check(memc, 1, 4, 4))
+ return TEST_SKIPPED;
+
rc= memcached_mget(memc, global_keys, global_keys_length, global_count);
+
test_true_got(rc == MEMCACHED_SUCCESS, memcached_strerror(NULL, rc));
+
/* Turn this into a help function */
{
memcached_result_st results_obj;
size_t counter;
memcached_execute_fn callbacks[1];
+ if (! libmemcached_util_version_check(memc, 1, 4, 4))
+ return TEST_SKIPPED;
+
rc= memcached_mget(memc, global_keys, global_keys_length, global_count);
+
test_true_got(rc == MEMCACHED_SUCCESS, memcached_strerror(NULL, rc));
callbacks[0]= &callback_counter;
// will not toggle protocol on an connection.
memcached_version(memc_clone);
- if (libmemcached_util_version_check(memc_clone, 1, 3, 0))
+ if (libmemcached_util_version_check(memc_clone, 1, 4, 4))
{
memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_NO_BLOCK, 0);
rc = memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL, 1);
{
memcached_return_t rc= MEMCACHED_FAILURE;
- if (libmemcached_util_version_check(memc, 1, 3, 0))
+ if (libmemcached_util_version_check(memc, 1, 4, 4))
{
rc = memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL, 1);
test_true(rc == MEMCACHED_SUCCESS);
}
-static void my_free(const memcached_st *ptr __attribute__((unused)), void *mem, void *context)
+static void my_free(const memcached_st *ptr, void *mem, void *context)
{
- (void) context;
+ (void)context;
+ (void)ptr;
#ifdef HARD_MALLOC_TESTS
void *real_ptr= (mem == NULL) ? mem : (void*)((caddr_t)mem - 8);
free(real_ptr);
}
-static void *my_malloc(const memcached_st *ptr __attribute__((unused)), const size_t size, void *context)
+static void *my_malloc(const memcached_st *ptr, const size_t size, void *context)
{
(void)context;
+ (void)ptr;
#ifdef HARD_MALLOC_TESTS
void *ret= malloc(size + 8);
if (ret != NULL)
}
-static void *my_realloc(const memcached_st *ptr __attribute__((unused)), void *mem, const size_t size, void *context)
+static void *my_realloc(const memcached_st *ptr, void *mem, const size_t size, void *context)
{
(void)context;
#ifdef HARD_MALLOC_TESTS
return ret;
#else
+ (void)ptr;
return realloc(mem, size);
#endif
}
-static void *my_calloc(const memcached_st *ptr __attribute__((unused)), size_t nelem, const size_t size, void *context)
+static void *my_calloc(const memcached_st *ptr, size_t nelem, const size_t size, void *context)
{
(void)context;
#ifdef HARD_MALLOC_TESTS
return mem;
#else
+ (void)ptr;
return calloc(nelem, size);
#endif
}
}
/* Count the objects */
-static memcached_return_t callback_dump_counter(const memcached_st *ptr __attribute__((unused)),
- const char *key __attribute__((unused)),
- size_t key_length __attribute__((unused)),
+static memcached_return_t callback_dump_counter(const memcached_st *ptr,
+ const char *key,
+ size_t key_length,
void *context)
{
+ (void)ptr; (void)key; (void)key_length;
size_t *counter= (size_t *)context;
*counter= *counter + 1;
return TEST_SUCCESS;
}
-static test_return_t one_at_a_time_run (memcached_st *memc __attribute__((unused)))
+static test_return_t one_at_a_time_run (memcached_st *memc)
{
uint32_t x;
const char **ptr;
+ (void)memc;
for (ptr= list_to_hash, x= 0; *ptr; ptr++, x++)
{
return TEST_SUCCESS;
}
-static test_return_t md5_run (memcached_st *memc __attribute__((unused)))
+static test_return_t md5_run (memcached_st *memc)
{
uint32_t x;
const char **ptr;
+ (void)memc;
for (ptr= list_to_hash, x= 0; *ptr; ptr++, x++)
{
return TEST_SUCCESS;
}
-static test_return_t crc_run (memcached_st *memc __attribute__((unused)))
+static test_return_t crc_run (memcached_st *memc)
{
uint32_t x;
const char **ptr;
+ (void)memc;
for (ptr= list_to_hash, x= 0; *ptr; ptr++, x++)
{
return TEST_SUCCESS;
}
-static test_return_t fnv1_64_run (memcached_st *memc __attribute__((unused)))
+static test_return_t fnv1_64_run (memcached_st *memc)
{
uint32_t x;
const char **ptr;
+ (void)memc;
for (ptr= list_to_hash, x= 0; *ptr; ptr++, x++)
{
return TEST_SUCCESS;
}
-static test_return_t fnv1a_64_run (memcached_st *memc __attribute__((unused)))
+static test_return_t fnv1a_64_run (memcached_st *memc)
{
uint32_t x;
const char **ptr;
+ (void)memc;
for (ptr= list_to_hash, x= 0; *ptr; ptr++, x++)
{
return TEST_SUCCESS;
}
-static test_return_t fnv1_32_run (memcached_st *memc __attribute__((unused)))
+static test_return_t fnv1_32_run (memcached_st *memc)
{
uint32_t x;
const char **ptr;
-
+ (void)memc;
for (ptr= list_to_hash, x= 0; *ptr; ptr++, x++)
{
return TEST_SUCCESS;
}
-static test_return_t fnv1a_32_run (memcached_st *memc __attribute__((unused)))
+static test_return_t fnv1a_32_run (memcached_st *memc)
{
uint32_t x;
const char **ptr;
+ (void)memc;
for (ptr= list_to_hash, x= 0; *ptr; ptr++, x++)
{
return TEST_SUCCESS;
}
-static test_return_t hsieh_run (memcached_st *memc __attribute__((unused)))
+static test_return_t hsieh_run (memcached_st *memc)
{
uint32_t x;
const char **ptr;
+ (void)memc;
for (ptr= list_to_hash, x= 0; *ptr; ptr++, x++)
{
return TEST_SUCCESS;
}
-static test_return_t murmur_run (memcached_st *memc __attribute__((unused)))
+static test_return_t murmur_run (memcached_st *memc)
{
#ifdef WORDS_BIGENDIAN
return TEST_SKIPPED;
#else
uint32_t x;
const char **ptr;
+ (void)memc;
for (ptr= list_to_hash, x= 0; *ptr; ptr++, x++)
{
#endif
}
-static test_return_t jenkins_run (memcached_st *memc __attribute__((unused)))
+static test_return_t jenkins_run (memcached_st *memc)
{
uint32_t x;
const char **ptr;
-
+ (void)memc;
for (ptr= list_to_hash, x= 0; *ptr; ptr++, x++)
{
}
/*
- Test case adapted from John Gorman <johngorman2@gmail.com>
+ Test case adapted from John Gorman <johngorman2@gmail.com>
- We are testing the error condition when we connect to a server via memcached_get()
+ We are testing the error condition when we connect to a server via memcached_get()
but find that the server is not available.
*/
static test_return_t memcached_get_MEMCACHED_ERRNO(memcached_st *memc)
return TEST_SUCCESS;
}
-/*
+/*
We connect to a server which exists, but search for a key that does not exist.
*/
static test_return_t memcached_get_MEMCACHED_NOTFOUND(memcached_st *memc)
}
/*
- Test case adapted from John Gorman <johngorman2@gmail.com>
+ Test case adapted from John Gorman <johngorman2@gmail.com>
- We are testing the error condition when we connect to a server via memcached_get_by_key()
+ We are testing the error condition when we connect to a server via memcached_get_by_key()
but find that the server is not available.
*/
static test_return_t memcached_get_by_key_MEMCACHED_ERRNO(memcached_st *memc)
return TEST_SUCCESS;
}
-/*
+/*
We connect to a server which exists, but search for a key that does not exist.
*/
static test_return_t memcached_get_by_key_MEMCACHED_NOTFOUND(memcached_st *memc)
static test_return_t regression_bug_463297(memcached_st *memc)
{
- memcached_st *memc_clone= memcached_clone(NULL, memc);
- test_true(memc_clone != NULL);
- test_true(memcached_version(memc_clone) == MEMCACHED_SUCCESS);
+ memcached_st *memc_clone= memcached_clone(NULL, memc);
+ test_true(memc_clone != NULL);
+ test_true(memcached_version(memc_clone) == MEMCACHED_SUCCESS);
- memcached_server_instance_st instance=
- memcached_server_instance_by_position(memc_clone, 0);
+ memcached_server_instance_st instance=
+ memcached_server_instance_by_position(memc_clone, 0);
- if (instance->major_version > 1 ||
- (instance->major_version == 1 &&
- instance->minor_version > 2))
+ if (instance->major_version > 1 ||
+ (instance->major_version == 1 &&
+ instance->minor_version > 2))
{
/* Binary protocol doesn't support deferred delete */
memcached_st *bin_clone= memcached_clone(NULL, memc);
memcached_return_t rc= memcached_delete(memc, "foo", 3, 1);
/* but there is a bug in some of the memcached servers (1.4) that treats
- * the counter as noreply so it doesn't send the proper error message
+ * the counter as noreply so it doesn't send the proper error message
*/
test_true_got(rc == MEMCACHED_PROTOCOL_ERROR || rc == MEMCACHED_NOTFOUND || rc == MEMCACHED_CLIENT_ERROR || rc == MEMCACHED_INVALID_ARGUMENTS, memcached_strerror(NULL, rc));
(void)memcached_get(memc, "dsf", 3, &length, &flags, &rc);
- test_true(rc == MEMCACHED_TIMEOUT);
+ test_true_got(rc == MEMCACHED_TIMEOUT, memcached_strerror(NULL, rc));
memcached_free(memc);
return TEST_SKIPPED;
}
- for (uint32_t x= 0; x < TEST_CONSTANT_CREATION; x++)
+ for (uint32_t x= 0; x < TEST_CONSTANT_CREATION; x++)
{
memcached_st* mc= memcached_create(NULL);
memcached_return rc;
if (rc == MEMCACHED_SUCCESS)
{
- if (x > 0)
+ if (x > 0)
{
size_t get_value_len;
char *get_value;
projects / awesomized / libmemcached / blobdiff