{
test_ports[x]= (uint32_t)random() % 64000;
rc= memcached_server_add_with_weight(local_memc, "localhost", test_ports[x], 0);
- test_truth(local_memc->number_of_hosts == x + 1);
- test_truth(local_memc->hosts[0].count == x+1);
+ test_truth(memcached_server_count(local_memc) == x + 1);
+ test_truth(memcached_servers_count(local_memc->hosts) == x+1);
test_truth(rc == MEMCACHED_SUCCESS);
}
{
test_ports[x]= (uint32_t)(random() % 64000);
rc= memcached_server_add_with_weight(local_memc, "localhost", test_ports[x], 0);
- test_truth(local_memc->number_of_hosts == x+1);
- test_truth(local_memc->hosts[0].count == x+1);
+ test_truth(memcached_server_count(local_memc) == x+1);
+ test_truth(memcached_servers_count(local_memc->hosts) == x+1);
test_truth(rc == 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)),
- memcached_result_st *result)
+static memcached_return_t read_through_trigger(memcached_st *memc __attribute__((unused)),
+ char *key __attribute__((unused)),
+ size_t key_length __attribute__((unused)),
+ memcached_result_st *result)
{
return memcached_result_set_value(result, READ_THROUGH_VALUE, strlen(READ_THROUGH_VALUE));
}
-static test_return_t read_through(memcached_st *memc)
+static test_return_t read_through(memcached_st *memc)
{
memcached_return_t rc;
const char *key= "foo";
&string_length, &flags, &rc);
test_truth(rc == MEMCACHED_NOTFOUND);
- test_truth(string_length == 0);
- test_truth(!string);
+ test_false(string_length);
+ test_false(string);
rc= memcached_callback_set(memc, MEMCACHED_CALLBACK_GET_FAILURE,
*(void **)&cb);
test_truth(rc == MEMCACHED_SUCCESS);
test_truth(string_length == strlen(READ_THROUGH_VALUE));
- test_truth(!strcmp(READ_THROUGH_VALUE, string));
+ test_strcmp(READ_THROUGH_VALUE, string);
free(string);
string= memcached_get(memc, key, strlen(key),
}
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);
&string_length, &flags, &rc);
test_truth(rc == MEMCACHED_NOTFOUND);
- test_truth(string_length == 0);
- test_truth(!string);
+ test_false(string_length);
+ test_false(string);
return TEST_SUCCESS;
}
memcached_return_t rc;
memcached_stat_st memc_stat;
rc= memcached_stat_servername(&memc_stat, NULL,
- memc->hosts[0].hostname,
- memc->hosts[0].port);
+ memc->hosts[0].hostname,
+ memc->hosts[0].port);
return TEST_SUCCESS;
}
test_truth(rc == MEMCACHED_SUCCESS);
for (ptr= stat_list; *ptr; ptr++)
test_truth(*ptr);
- fflush(stdout);
free(stat_list);
value= memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_NUMBER_OF_REPLICAS);
memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_NUMBER_OF_REPLICAS, value + 1);
test_truth((value + 1) == memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_NUMBER_OF_REPLICAS));
+
return TEST_SUCCESS;
}
size_t return_value_length;
/* Here we free everything before running a bunch of mget tests */
- {
- memcached_server_list_free(memc->hosts);
- memc->hosts= NULL;
- memc->number_of_hosts= 0;
- }
+ memcached_servers_reset(memc);
/* We need to empty the server before continueing test */
memcached_server_push(memc, server_pool);
/* verify that the server list was parsed okay. */
- test_truth(memc->number_of_hosts == 8);
+ test_truth(memcached_server_count(memc) == 8);
test_truth(strcmp(server_pool[0].hostname, "10.0.1.1") == 0);
test_truth(server_pool[0].port == 11211);
test_truth(server_pool[0].weight == 600);
memcached_server_push(memc, server_pool);
/* verify that the server list was parsed okay. */
- test_truth(memc->number_of_hosts == 8);
+ test_truth(memcached_server_count(memc) == 8);
test_truth(strcmp(server_pool[0].hostname, "10.0.1.1") == 0);
test_truth(server_pool[0].port == 11211);
test_truth(server_pool[0].weight == 600);
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
{
return rc == MEMCACHED_SUCCESS ? TEST_SUCCESS : TEST_SKIPPED;
}
+
static test_return_t pre_replication(memcached_st *memc)
{
test_return_t test_rc;
*/
memcached_return_t rc;
rc= memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_NUMBER_OF_REPLICAS,
- memc->number_of_hosts - 1);
+ memcached_server_count(memc) - 1);
test_truth(rc == MEMCACHED_SUCCESS);
- test_truth(memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_NUMBER_OF_REPLICAS) == memc->number_of_hosts - 1);
+ test_truth(memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_NUMBER_OF_REPLICAS) == memcached_server_count(memc) - 1);
return rc == MEMCACHED_SUCCESS ? TEST_SUCCESS : TEST_SKIPPED;
}
+
static test_return_t pre_replication_noblock(memcached_st *memc)
{
- test_return_t rc= MEMCACHED_FAILURE;
- if (pre_replication(memc) == TEST_SUCCESS &&
- pre_nonblock(memc) == TEST_SUCCESS)
- rc= TEST_SUCCESS;
+ test_return_t rc;
+
+ rc= pre_replication(memc);
+ if (rc != TEST_SUCCESS)
+ return rc;
+
+ rc= pre_nonblock(memc);
return rc;
}
+
static void my_free(memcached_st *ptr __attribute__((unused)), void *mem)
{
#ifdef HARD_MALLOC_TESTS
#endif
}
+
static void *my_malloc(memcached_st *ptr __attribute__((unused)), const size_t size)
{
#ifdef HARD_MALLOC_TESTS
return ret;
}
+
static void *my_realloc(memcached_st *ptr __attribute__((unused)), void *mem, const size_t size)
{
#ifdef HARD_MALLOC_TESTS
#endif
}
+
static void *my_calloc(memcached_st *ptr __attribute__((unused)), size_t nelem, const size_t size)
{
#ifdef HARD_MALLOC_TESTS
#endif
}
+
static test_return_t set_prefix(memcached_st *memc)
{
memcached_return_t rc;
return TEST_SUCCESS;
}
+
#ifdef MEMCACHED_ENABLE_DEPRECATED
static test_return_t deprecated_set_memory_alloc(memcached_st *memc)
{
}
#endif
+
static test_return_t set_memory_alloc(memcached_st *memc)
{
memcached_return_t rc;
memcached_return_t rc;
struct stat buf;
- memcached_server_list_free(memc->hosts);
- memc->hosts= NULL;
- memc->number_of_hosts= 0;
+ memcached_servers_reset(memc);
if (stat("/tmp/memcached.socket", &buf))
return TEST_SKIPPED;
** way it is supposed to do!!!!
*/
int no_msg=0;
- for (uint32_t x=0; x < memc->number_of_hosts; ++x)
+ for (uint32_t x=0; x < memcached_server_count(memc); ++x)
no_msg+=(int)(memc->hosts[x].cursor_active);
test_truth(no_msg == 0);
* within the library, and this is not a supported interface.
* This is to verify correct behavior in the library
*/
- for (uint32_t host= 0; host < memc->number_of_hosts; ++host)
+ for (uint32_t host= 0; host < memcached_server_count(memc); ++host)
{
memcached_st *memc_clone= memcached_clone(NULL, memc);
memc_clone->hosts[host].port= 0;
static uint16_t *get_udp_request_ids(memcached_st *memc)
{
- uint16_t *ids= malloc(sizeof(uint16_t) * memc->number_of_hosts);
+ uint16_t *ids= malloc(sizeof(uint16_t) * memcached_server_count(memc));
assert(ids != NULL);
unsigned int x;
- for (x= 0; x < memc->number_of_hosts; x++)
+ for (x= 0; x < memcached_server_count(memc); x++)
ids[x]= get_udp_datagram_request_id((struct udp_datagram_header_st *) memc->hosts[x].write_buffer);
return ids;
memcached_server_st *cur_server = memc->hosts;
uint16_t *cur_req_ids = get_udp_request_ids(memc);
- for (x= 0; x < memc->number_of_hosts; x++)
+ for (x= 0; x < memcached_server_count(memc); x++)
{
test_truth(cur_server[x].cursor_active == 0);
test_truth(cur_req_ids[x] == expected_req_ids[x]);
|| memc->hosts[0].micro_version < 6)
return TEST_SKIPPED;
- uint32_t num_hosts= memc->number_of_hosts;
+ uint32_t num_hosts= memcached_server_count(memc);
unsigned int x= 0;
memcached_server_st servers[num_hosts];
memcpy(servers, memc->hosts, sizeof(memcached_server_st) * num_hosts);
test_truth(memc->flags.use_udp);
test_truth(memc->flags.no_reply);
- test_truth(memc->number_of_hosts == 0);
+ test_truth(memcached_server_count(memc) == 0);
memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_USE_UDP,0);
test_truth(! (memc->flags.use_udp));
memcached_return_t rc;
uint16_t *expected_ids= get_udp_request_ids(memc);
unsigned int x;
- for (x= 0; x < memc->number_of_hosts;x++)
+ for (x= 0; x < memcached_server_count(memc); x++)
increment_request_id(&expected_ids[x]);
rc= memcached_verbosity(memc,3);
memcached_return_t rc;
uint16_t *expected_ids= get_udp_request_ids(memc);
unsigned int x;
- for (x= 0; x < memc->number_of_hosts;x++)
+ for (x= 0; x < memcached_server_count(memc);x++)
increment_request_id(&expected_ids[x]);
rc= memcached_flush(memc,0);
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(memcached_server_count(memc) == 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(memcached_server_count(memc) == 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;
* 1024 (that should satisfy most users don't you think?). Future versions
* will include a mget_execute function call if you need a higher number.
*/
- uint32_t number_of_hosts= memc->number_of_hosts;
+ uint32_t number_of_hosts= memcached_server_count(memc);
memc->number_of_hosts= 1;
const size_t max_keys= 1024;
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);
}
/*
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);
}
}
free(key_length);
memc->number_of_hosts= number_of_hosts;
+
return TEST_SUCCESS;
}
{
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;
+ uint32_t number_of_hosts= memcached_server_count(memc);
memc->number_of_hosts= 1;
char k[250];
{
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;
static test_return_t regression_bug_447342(memcached_st *memc)
{
- if (memc->number_of_hosts < 3 || pre_replication(memc) != MEMCACHED_SUCCESS)
+ if (memcached_server_count(memc) < 3 || pre_replication(memc) != MEMCACHED_SUCCESS)
return TEST_SKIPPED;
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);
* in a non-portable way and you shouldn't be doing this. I'm only
* doing this in order to verify that the library works the way it should
*/
- uint32_t number_of_hosts= memc->number_of_hosts;
+ uint32_t number_of_hosts= memcached_server_count(memc);
memc->number_of_hosts= 1;
/* Ensure that we are connected to the server by setting a value */
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;
{"clone_test", 0, (test_callback_fn)clone_test },
{"connection_test", 0, (test_callback_fn)connection_test},
{"callback_test", 0, (test_callback_fn)callback_test},
- {"behavior_test", 0, (test_callback_fn)behavior_test},
{"userdata_test", 0, (test_callback_fn)userdata_test},
{"error", 0, (test_callback_fn)error_test },
{"set", 0, (test_callback_fn)set_test },
{"add_host_test", 0, (test_callback_fn)add_host_test },
{"add_host_test_1", 0, (test_callback_fn)add_host_test1 },
{"get_stats_keys", 0, (test_callback_fn)get_stats_keys },
- {"behavior_test", 0, (test_callback_fn)get_stats_keys },
- {"callback_test", 0, (test_callback_fn)get_stats_keys },
{"version_string_test", 0, (test_callback_fn)version_string_test},
{"bad_key", 1, (test_callback_fn)bad_key_test },
{"memcached_server_cursor", 1, (test_callback_fn)memcached_server_cursor_test },
{0, 0, 0}
};
+test_st behavior_tests[] ={
+ {"behavior_test", 0, (test_callback_fn)behavior_test},
+ {0, 0, 0}
+};
+
test_st async_tests[] ={
{"add", 1, (test_callback_fn)add_wrapper },
{0, 0, 0}
{"replication", (test_callback_fn)pre_replication, 0, replication_tests},
{"replication_noblock", (test_callback_fn)pre_replication_noblock, 0, replication_tests},
{"regression", 0, 0, regression_tests},
+ {"behaviors", 0, 0, behavior_tests},
{0, 0, 0, 0}
};
void get_world(world_st *world)
{
world->collections= collection;
- world->collection_startup= (test_callback_fn)world_collection_startup;
- world->flush= (test_callback_fn)world_flush;
- world->pre_run= (test_callback_fn)world_pre_run;
+
world->create= (test_callback_create_fn)world_create;
- world->post_run= (test_callback_fn)world_post_run;
- world->on_error= (test_callback_error_fn)world_on_error;
world->destroy= (test_callback_fn)world_destroy;
+
+ world->test.startup= (test_callback_fn)world_test_startup;
+ world->test.flush= (test_callback_fn)world_flush;
+ world->test.pre_run= (test_callback_fn)world_pre_run;
+ world->test.post_run= (test_callback_fn)world_post_run;
+ world->test.on_error= (test_callback_error_fn)world_on_error;
+
world->runner= &defualt_libmemcached_runner;
}
projects / m6w6 / libmemcached / blobdiff