}
static memcached_return_t delete_trigger(memcached_st *ptr __attribute__((unused)),
- const char *key,
- size_t key_length __attribute__((unused)))
+ const char *key,
+ size_t key_length __attribute__((unused)))
{
assert(key);
memcached_st *memc_clone;
memc_clone= memcached_clone(NULL, memc);
- assert(memc_clone);
+ test_truth(memc_clone);
// The memcached_version needs to be done on a clone, because the server
// will not toggle protocol on an connection.
memcached_version(memc_clone);
memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_NO_BLOCK, 0);
rc = memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL, 1);
test_truth(rc == MEMCACHED_SUCCESS);
- assert(memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL) == 1);
+ test_truth(memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL) == 1);
}
else
{
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);
+ test_truth(memc->number_of_hosts == 8);
+ test_strcmp(server_pool[0].hostname, "10.0.1.1");
+ test_truth(server_pool[0].port == 11211);
+ test_truth(server_pool[0].weight == 600);
+ test_strcmp(server_pool[2].hostname, "10.0.1.3");
+ test_truth(server_pool[2].port == 11211);
+ test_truth(server_pool[2].weight == 200);
+ test_strcmp(server_pool[7].hostname, "10.0.1.8");
+ test_truth(server_pool[7].port == 11211);
+ test_truth(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);
+ test_truth(memcached_generate_hash(memc, (char *)"VDEAAAAA", 8) == memc->continuum[0].index);
/* verify the standard ketama set. */
for (x= 0; x < 99; x++)
{
uint32_t server_idx = memcached_generate_hash(memc, ketama_test_cases[x].key, strlen(ketama_test_cases[x].key));
char *hostname = memc->hosts[server_idx].hostname;
- assert(strcmp(hostname, ketama_test_cases[x].server) == 0);
+
+ test_strcmp(hostname, ketama_test_cases[x].server);
}
memcached_server_list_free(server_pool);
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);
+ test_truth(memc->number_of_hosts == 8);
+ test_strcmp(server_pool[0].hostname, "10.0.1.1");
+ test_truth(server_pool[0].port == 11211);
+ test_truth(server_pool[0].weight == 600);
+ test_strcmp(server_pool[2].hostname, "10.0.1.3");
+ test_truth(server_pool[2].port == 11211);
+ test_truth(server_pool[2].weight == 200);
+ test_strcmp(server_pool[7].hostname, "10.0.1.8");
+ test_truth(server_pool[7].port == 11211);
+ test_truth(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);
+ test_truth(memcached_generate_hash(memc, (char *)"VDEAAAAA", 8) == memc->continuum[0].index);
/* verify the standard ketama set. */
for (x= 0; x < 99; x++)
{
uint32_t server_idx = memcached_generate_hash(memc, ketama_test_cases_spy[x].key, strlen(ketama_test_cases_spy[x].key));
char *hostname = memc->hosts[server_idx].hostname;
- assert(strcmp(hostname, ketama_test_cases_spy[x].server) == 0);
+ test_strcmp(hostname, ketama_test_cases_spy[x].server);
}
memcached_server_list_free(server_pool);
size_t keylen= strlen(key);
ret= memcached_append(memc, key, keylen, key, keylen, 0, 0);
- assert(ret == MEMCACHED_NOTSTORED);
+ test_truth(ret == MEMCACHED_NOTSTORED);
size_t size= 2048 * 1024;
void *data= calloc(1, size);
- assert(data != NULL);
+ test_truth(data != NULL);
ret= memcached_set(memc, key, keylen, data, size, 0, 0);
- assert(ret == MEMCACHED_E2BIG);
+ test_truth(ret == MEMCACHED_E2BIG);
free(data);
return TEST_SUCCESS;
char k[251];
key_length[x]= (size_t)snprintf(k, sizeof(k), "0200%u", x);
keys[x]= strdup(k);
- assert(keys[x] != NULL);
+ test_truth(keys[x] != NULL);
}
/*
for (int y= 0; y < 2; ++y)
{
rc= memcached_mget(memc, (const char**)keys, key_length, max_keys);
- assert(rc == MEMCACHED_SUCCESS);
+ test_truth(rc == MEMCACHED_SUCCESS);
rc= memcached_fetch_execute(memc, callbacks, (void *)&counter, 1);
if (y == 0)
{
/* The first iteration should give me a 100% cache miss. verify that*/
- assert(counter == 0);
+ test_truth(counter == 0);
char blob[1024]= { 0 };
for (int x= 0; x < (int)max_keys; ++x)
{
rc= memcached_add(memc, keys[x], key_length[x],
blob, sizeof(blob), 0, 0);
- assert(rc == MEMCACHED_SUCCESS || rc == MEMCACHED_BUFFERED);
+ test_truth(rc == MEMCACHED_SUCCESS || rc == MEMCACHED_BUFFERED);
}
}
else
{
/* Verify that we received all of the key/value pairs */
- assert(counter == (unsigned int)max_keys);
+ test_truth(counter == (unsigned int)max_keys);
}
}
{
memcached_return_t rc;
rc= memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_BUFFER_REQUESTS, 1);
- assert(rc == MEMCACHED_SUCCESS);
+ test_truth(rc == MEMCACHED_SUCCESS);
return regression_bug_434843(memc);
}
{
memcached_return_t rc;
memcached_stat_st *memc_stat= memcached_stat(memc, NULL, &rc);
- assert(rc == MEMCACHED_SUCCESS);
+ test_truth(rc == MEMCACHED_SUCCESS);
char *bytes= memcached_stat_get_value(memc, memc_stat, "bytes", &rc);
- assert(rc == MEMCACHED_SUCCESS);
- assert(bytes != NULL);
+ test_truth(rc == MEMCACHED_SUCCESS);
+ test_truth(bytes != NULL);
char *bytes_read= memcached_stat_get_value(memc, memc_stat,
"bytes_read", &rc);
- assert(rc == MEMCACHED_SUCCESS);
- assert(bytes_read != NULL);
+ test_truth(rc == MEMCACHED_SUCCESS);
+ test_truth(bytes_read != NULL);
char *bytes_written= memcached_stat_get_value(memc, memc_stat,
"bytes_written", &rc);
- assert(rc == MEMCACHED_SUCCESS);
- assert(bytes_written != NULL);
+ test_truth(rc == MEMCACHED_SUCCESS);
+ test_truth(bytes_written != NULL);
- assert(strcmp(bytes, bytes_read) != 0);
- assert(strcmp(bytes, bytes_written) != 0);
+ test_truth(strcmp(bytes, bytes_read) != 0);
+ test_truth(strcmp(bytes, bytes_written) != 0);
/* Release allocated resources */
free(bytes);
free(bytes_read);
free(bytes_written);
memcached_stat_free(NULL, memc_stat);
+
return TEST_SUCCESS;
}
{
memcached_return_t rc;
rc= memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_NOREPLY, 1);
- assert(rc == MEMCACHED_SUCCESS);
+ test_truth(rc == MEMCACHED_SUCCESS);
memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_TCP_NODELAY, 1);
uint32_t number_of_hosts= memc->number_of_hosts;
{
len= (size_t)snprintf(k, sizeof(k), "%0250u", x);
rc= memcached_delete(memc, k, len, 0);
- assert(rc == MEMCACHED_SUCCESS || rc == MEMCACHED_BUFFERED);
+ test_truth(rc == MEMCACHED_SUCCESS || rc == MEMCACHED_BUFFERED);
}
len= (size_t)snprintf(k, sizeof(k), "%037u", 251);
rc= memcached_delete(memc, k, len, 0);
- assert(rc == MEMCACHED_SUCCESS || rc == MEMCACHED_BUFFERED);
+ test_truth(rc == MEMCACHED_SUCCESS || rc == MEMCACHED_BUFFERED);
rc= memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_NOREPLY, 0);
- assert(rc == MEMCACHED_SUCCESS);
+ test_truth(rc == MEMCACHED_SUCCESS);
rc= memcached_delete(memc, k, len, 0);
- assert(rc == MEMCACHED_NOTFOUND);
+ test_truth(rc == MEMCACHED_NOTFOUND);
memc->number_of_hosts= number_of_hosts;
memcached_return_t rc;
rc= memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_NUMBER_OF_REPLICAS, 2);
- assert(rc == MEMCACHED_SUCCESS);
+ test_truth(rc == MEMCACHED_SUCCESS);
const size_t max_keys= 100;
char **keys= calloc(max_keys, sizeof(char*));
char k[251];
key_length[x]= (size_t)snprintf(k, sizeof(k), "0200%u", x);
keys[x]= strdup(k);
- assert(keys[x] != NULL);
+ test_truth(keys[x] != NULL);
rc= memcached_set(memc, k, key_length[x], k, key_length[x], 0, 0);
- assert(rc == MEMCACHED_SUCCESS);
+ test_truth(rc == MEMCACHED_SUCCESS);
}
/*
* into the servers
*/
rc= memcached_mget(memc, (const char* const *)keys, key_length, max_keys);
- assert(rc == MEMCACHED_SUCCESS);
+ test_truth(rc == MEMCACHED_SUCCESS);
unsigned int counter= 0;
memcached_execute_fn callbacks[1]= { [0]= &callback_counter };
rc= memcached_fetch_execute(memc, callbacks, (void *)&counter, 1);
/* Verify that we received all of the key/value pairs */
- assert(counter == (unsigned int)max_keys);
+ test_truth(counter == (unsigned int)max_keys);
memcached_quit(memc);
/*
memc->hosts[2].port= 0;
rc= memcached_mget(memc, (const char* const *)keys, key_length, max_keys);
- assert(rc == MEMCACHED_SUCCESS);
+ test_truth(rc == MEMCACHED_SUCCESS);
counter= 0;
rc= memcached_fetch_execute(memc, callbacks, (void *)&counter, 1);
- assert(counter == (unsigned int)max_keys);
+ test_truth(counter == (unsigned int)max_keys);
/* restore the memc handle */
memc->hosts[0].port= port0;
if (x & 1)
{
rc= memcached_delete(memc, keys[x], key_length[x], 0);
- assert(rc == MEMCACHED_SUCCESS);
+ test_truth(rc == MEMCACHED_SUCCESS);
}
}
/* now retry the command, this time we should have cache misses */
rc= memcached_mget(memc, (const char* const *)keys, key_length, max_keys);
- assert(rc == MEMCACHED_SUCCESS);
+ test_truth(rc == MEMCACHED_SUCCESS);
counter= 0;
rc= memcached_fetch_execute(memc, callbacks, (void *)&counter, 1);
- assert(counter == (unsigned int)(max_keys >> 1));
+ test_truth(counter == (unsigned int)(max_keys >> 1));
/* Release allocated resources */
for (size_t x= 0; x < max_keys; ++x)
static test_return_t regression_bug_463297(memcached_st *memc)
{
memcached_st *memc_clone= memcached_clone(NULL, memc);
- assert(memc_clone != NULL);
- assert(memcached_version(memc_clone) == MEMCACHED_SUCCESS);
+ test_truth(memc_clone != NULL);
+ test_truth(memcached_version(memc_clone) == MEMCACHED_SUCCESS);
if (memc_clone->hosts[0].major_version > 1 ||
(memc_clone->hosts[0].major_version == 1 &&
{
/* Binary protocol doesn't support deferred delete */
memcached_st *bin_clone= memcached_clone(NULL, memc);
- assert(bin_clone != NULL);
- assert(memcached_behavior_set(bin_clone, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL, 1) == MEMCACHED_SUCCESS);
- assert(memcached_delete(bin_clone, "foo", 3, 1) == MEMCACHED_INVALID_ARGUMENTS);
+ test_truth(bin_clone != NULL);
+ test_truth(memcached_behavior_set(bin_clone, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL, 1) == MEMCACHED_SUCCESS);
+ test_truth(memcached_delete(bin_clone, "foo", 3, 1) == MEMCACHED_INVALID_ARGUMENTS);
memcached_free(bin_clone);
memcached_quit(memc_clone);
/* If we know the server version, deferred delete should fail
* with invalid arguments */
- assert(memcached_delete(memc_clone, "foo", 3, 1) == MEMCACHED_INVALID_ARGUMENTS);
+ test_truth(memcached_delete(memc_clone, "foo", 3, 1) == MEMCACHED_INVALID_ARGUMENTS);
/* If we don't know the server version, we should get a protocol error */
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
*/
- assert(rc == MEMCACHED_PROTOCOL_ERROR || rc == MEMCACHED_NOTFOUND || rc == MEMCACHED_CLIENT_ERROR);
+ test_truth(rc == MEMCACHED_PROTOCOL_ERROR || rc == MEMCACHED_NOTFOUND || rc == MEMCACHED_CLIENT_ERROR);
/* And buffered mode should be disabled and we should get protocol error */
- assert(memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_BUFFER_REQUESTS, 1) == MEMCACHED_SUCCESS);
+ test_truth(memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_BUFFER_REQUESTS, 1) == MEMCACHED_SUCCESS);
rc= memcached_delete(memc, "foo", 3, 1);
- assert(rc == MEMCACHED_PROTOCOL_ERROR || rc == MEMCACHED_NOTFOUND || rc == MEMCACHED_CLIENT_ERROR);
+ test_truth(rc == MEMCACHED_PROTOCOL_ERROR || rc == MEMCACHED_NOTFOUND || rc == MEMCACHED_CLIENT_ERROR);
/* Same goes for noreply... */
- assert(memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_NOREPLY, 1) == MEMCACHED_SUCCESS);
+ test_truth(memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_NOREPLY, 1) == MEMCACHED_SUCCESS);
rc= memcached_delete(memc, "foo", 3, 1);
- assert(rc == MEMCACHED_PROTOCOL_ERROR || rc == MEMCACHED_NOTFOUND || rc == MEMCACHED_CLIENT_ERROR);
+ test_truth(rc == MEMCACHED_PROTOCOL_ERROR || rc == MEMCACHED_NOTFOUND || rc == MEMCACHED_CLIENT_ERROR);
/* but a normal request should go through (and be buffered) */
- assert((rc= memcached_delete(memc, "foo", 3, 0)) == MEMCACHED_BUFFERED);
- assert(memcached_flush_buffers(memc) == MEMCACHED_SUCCESS);
+ test_truth((rc= memcached_delete(memc, "foo", 3, 0)) == MEMCACHED_BUFFERED);
+ test_truth(memcached_flush_buffers(memc) == MEMCACHED_SUCCESS);
- assert(memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_BUFFER_REQUESTS, 0) == MEMCACHED_SUCCESS);
+ test_truth(memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_BUFFER_REQUESTS, 0) == MEMCACHED_SUCCESS);
/* unbuffered noreply should be success */
- assert(memcached_delete(memc, "foo", 3, 0) == MEMCACHED_SUCCESS);
+ test_truth(memcached_delete(memc, "foo", 3, 0) == MEMCACHED_SUCCESS);
/* unbuffered with reply should be not found... */
- assert(memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_NOREPLY, 0) == MEMCACHED_SUCCESS);
- assert(memcached_delete(memc, "foo", 3, 0) == MEMCACHED_NOTFOUND);
+ test_truth(memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_NOREPLY, 0) == MEMCACHED_SUCCESS);
+ test_truth(memcached_delete(memc, "foo", 3, 0) == MEMCACHED_NOTFOUND);
}
memcached_free(memc_clone);
rc= memcached_set(memc, key, strlen(key),
value, strlen(value),
(time_t)0, (uint32_t)0);
- assert(rc == MEMCACHED_SUCCESS || rc == MEMCACHED_BUFFERED);
+ test_truth(rc == MEMCACHED_SUCCESS || rc == MEMCACHED_BUFFERED);
disconnected_server = memcached_server_get_last_disconnect(memc);
- assert(disconnected_server == NULL);
+ test_truth(disconnected_server == NULL);
/* With a non existing server */
memcached_st *mine;
const char *server_list= "localhost:9";
servers= memcached_servers_parse(server_list);
- assert(servers);
+ test_truth(servers);
mine= memcached_create(NULL);
rc= memcached_server_push(mine, servers);
- assert(rc == MEMCACHED_SUCCESS);
+ test_truth(rc == MEMCACHED_SUCCESS);
memcached_server_list_free(servers);
- assert(mine);
+ test_truth(mine);
rc= memcached_set(mine, key, strlen(key),
value, strlen(value),
(time_t)0, (uint32_t)0);
- assert(rc != MEMCACHED_SUCCESS);
+ test_truth(rc != MEMCACHED_SUCCESS);
disconnected_server = memcached_server_get_last_disconnect(mine);
- assert(disconnected_server != NULL);
- assert(disconnected_server->port == 9);
- assert(strncmp(disconnected_server->hostname,"localhost",9) == 0);
+ test_truth(disconnected_server != NULL);
+ test_truth(disconnected_server->port == 9);
+ test_truth(strncmp(disconnected_server->hostname,"localhost",9) == 0);
memcached_quit(mine);
memcached_free(mine);
rc= memcached_set(memc, key, strlen(key),
value, strlen(value),
(time_t)0, (uint32_t)0);
- assert(rc == MEMCACHED_SUCCESS || rc == MEMCACHED_BUFFERED);
+ test_truth(rc == MEMCACHED_SUCCESS || rc == MEMCACHED_BUFFERED);
/* The test is to see that the memcached_quit doesn't increase the
* Please note that this isn't bullet proof, because an error could
* occur...
*/
- assert(memc->hosts[0].server_failure_counter == 0);
+ test_truth(memc->hosts[0].server_failure_counter == 0);
/* restore the instance */
memc->number_of_hosts= number_of_hosts;
projects / awesomized / libmemcached / commitdiff
