*
*/
-#include <libtest/common.h>
+#include <config.h>
+#include <libtest/test.hpp>
/*
Test cases
#include "tests/namespace.h"
#include "tests/string.h"
#include "tests/replication.h"
+#include "tests/debug.h"
#include "tests/basic.h"
#include "tests/error_conditions.h"
#include "tests/print.h"
#include "tests/virtual_buckets.h"
+using namespace libtest;
#ifdef HAVE_LIBMEMCACHEDUTIL
#include <pthread.h>
test_true(local_memc);
memcached_behavior_set(local_memc, MEMCACHED_BEHAVIOR_SORT_HOSTS, 1);
- for (size_t x= 0; x < TEST_PORT_COUNT; x++)
+ for (uint32_t x= 0; x < TEST_PORT_COUNT; x++)
{
test_ports[x]= (in_port_t)random() % 64000;
rc= memcached_server_add_with_weight(local_memc, "localhost", test_ports[x], 0);
test_compare(MEMCACHED_SUCCESS,
memcached_server_add_with_weight(local_memc, "MEMCACHED_BEHAVIOR_SORT_HOSTS", 43043, 0));
instance= memcached_server_instance_by_position(local_memc, 0);
- test_compare(43043, memcached_server_port(instance));
+ test_compare(in_port_t(43043), memcached_server_port(instance));
test_compare(MEMCACHED_SUCCESS,
memcached_server_add_with_weight(local_memc, "MEMCACHED_BEHAVIOR_SORT_HOSTS", 43042, 0));
instance= memcached_server_instance_by_position(local_memc, 0);
- test_compare(43042, memcached_server_port(instance));
+ test_compare(in_port_t(43042), memcached_server_port(instance));
instance= memcached_server_instance_by_position(local_memc, 1);
- test_compare(43043, memcached_server_port(instance));
+ test_compare(in_port_t(43043), memcached_server_port(instance));
callbacks[0]= server_display_function;
memcached_server_cursor(local_memc, callbacks, (void *)&bigger, 1);
const char *server_string= "--server=localhost:4444 --server=localhost:4445 --server=localhost:4446 --server=localhost:4447 --server=localhost --server=memcache1.memcache.bk.sapo.pt:11211 --server=memcache1.memcache.bk.sapo.pt:11212 --server=memcache1.memcache.bk.sapo.pt:11213 --server=memcache1.memcache.bk.sapo.pt:11214 --server=memcache2.memcache.bk.sapo.pt:11211 --server=memcache2.memcache.bk.sapo.pt:11212 --server=memcache2.memcache.bk.sapo.pt:11213 --server=memcache2.memcache.bk.sapo.pt:11214";
char buffer[BUFSIZ];
- memcached_return_t rc;
- test_compare_got(MEMCACHED_SUCCESS,
- rc= libmemcached_check_configuration(server_string, strlen(server_string), buffer, sizeof(buffer)),
- memcached_strerror(NULL, rc));
+ test_compare(MEMCACHED_SUCCESS,
+ libmemcached_check_configuration(server_string, strlen(server_string), buffer, sizeof(buffer)));
memcached_st *memc= memcached(server_string, strlen(server_string));
test_true(memc);
local_memc= memcached_create(NULL);
test_true(local_memc);
- for (size_t x= 0; x < TEST_PORT_COUNT; x++)
+ for (uint32_t x= 0; x < TEST_PORT_COUNT; x++)
{
test_ports[x]= (in_port_t)(random() % 64000);
test_compare(MEMCACHED_SUCCESS,
{
test_true(libmemcached_string_behavior(memcached_behavior_t(x)));
}
- test_compare(36, MEMCACHED_BEHAVIOR_MAX);
+ test_compare(36, int(MEMCACHED_BEHAVIOR_MAX));
return TEST_SUCCESS;
}
{
test_true(libmemcached_string_distribution(memcached_server_distribution_t(x)));
}
- test_compare(7, MEMCACHED_DISTRIBUTION_CONSISTENT_MAX);
+ test_compare(7, int(MEMCACHED_DISTRIBUTION_CONSISTENT_MAX));
return TEST_SUCCESS;
}
}
test_compare(values[rc], hash_val);
}
- test_compare(MEMCACHED_MAXIMUM_RETURN, 47);
+ test_compare(47, int(MEMCACHED_MAXIMUM_RETURN));
return TEST_SUCCESS;
}
test_compare(MEMCACHED_SUCCESS, rc);
out_value= memcached_get(memc, key, strlen(key),
- &value_length, &flags, &rc);
+ &value_length, &flags, &rc);
test_memcmp(out_value, "we the people", strlen("we the people"));
test_compare(strlen("we the people"), value_length);
test_compare(MEMCACHED_SUCCESS, rc);
}
value= (uint32_t *)memcached_get(memc, key, strlen(key),
- &value_length, &flags, &rc);
+ &value_length, &flags, &rc);
test_compare(value_length, sizeof(uint32_t) * x);
test_compare(MEMCACHED_SUCCESS, rc);
string= memcached_get(memc_clone, key, strlen(key),
&string_length, &flags, &rc);
test_compare(MEMCACHED_BAD_KEY_PROVIDED, rc);
- test_compare(0, string_length);
+ test_zero(string_length);
test_false(string);
set= 0;
string= memcached_get(memc_clone, key, strlen(key),
&string_length, &flags, &rc);
test_compare_got(MEMCACHED_NOTFOUND, rc, memcached_strerror(NULL, rc));
- test_compare(0, string_length);
+ test_zero(string_length);
test_false(string);
/* Test multi key for bad keys */
string= memcached_get(memc_clone, longkey, max_keylen,
&string_length, &flags, &rc);
test_compare(MEMCACHED_NOTFOUND, rc);
- test_compare(0, string_length);
+ test_zero(string_length);
test_false(string);
string= memcached_get(memc_clone, longkey, max_keylen + 1,
&string_length, &flags, &rc);
test_compare(MEMCACHED_BAD_KEY_PROVIDED, rc);
- test_compare(0, string_length);
+ test_zero(string_length);
test_false(string);
free(longkey);
string= memcached_get(memc_clone, key, 0,
&string_length, &flags, &rc);
test_compare(MEMCACHED_BAD_KEY_PROVIDED, rc);
- test_compare(0, string_length);
+ test_zero(string_length);
test_false(string);
memcached_free(memc_clone);
memcached_return_t rc= memcached_set(memc, keys[0], lengths[0],
keys[0], lengths[0], 0, 0);
- test_compare(MEMCACHED_SUCCESS, rc);
- rc= memcached_mget(memc, keys, lengths, 2);
+ test_compare(MEMCACHED_SUCCESS, memcached_mget(memc, keys, lengths, test_array_length(keys)));
memcached_result_st results_obj;
- memcached_result_st *results;
- results=memcached_result_create(memc, &results_obj);
+ memcached_result_st *results= memcached_result_create(memc, &results_obj);
test_true(results);
- results=memcached_fetch_result(memc, &results_obj, &rc);
+
+ results= memcached_fetch_result(memc, &results_obj, &rc);
test_true(results);
+
memcached_result_free(&results_obj);
/* Don't read out the second result, but issue a set instead.. */
- rc= memcached_set(memc, keys[0], lengths[0], keys[0], lengths[0], 0, 0);
- test_compare(MEMCACHED_SUCCESS, rc);
+ test_compare(MEMCACHED_SUCCESS, memcached_set(memc, keys[0], lengths[0], keys[0], lengths[0], 0, 0));
char *val= memcached_get_by_key(memc, keys[0], lengths[0], "yek", 3,
&rlen, &flags, &rc);
memcached_return_t rc;
// Set foo and foo2
- for (int i= 0; i < 2; i++)
+ for (size_t x= 0; x < test_array_length(keys); x++)
{
- rc= memcached_set(memc, keys[i], lengths[i], values[i], strlen(values[i]),
- (time_t)0, (uint32_t)0);
- test_compare(MEMCACHED_SUCCESS, rc);
+ test_compare(MEMCACHED_SUCCESS, memcached_set(memc, keys[x], lengths[x], values[x], strlen(values[x]), (time_t)0, (uint32_t)0));
}
char *string;
uint32_t flags;
// retrieve both via mget
- rc= memcached_mget(memc, keys, lengths, 2);
- test_compare(MEMCACHED_SUCCESS, rc);
+ test_compare(MEMCACHED_SUCCESS, memcached_mget(memc, keys, lengths, test_array_length(keys)));
char key[MEMCACHED_MAX_KEY];
size_t key_length;
// this should get both
- for (int i = 0; i < 2; i++)
+ for (size_t x= 0; x < test_array_length(keys); x++)
{
string= memcached_fetch(memc, key, &key_length, &string_length,
&flags, &rc);
test_literal_param("0"),
(time_t)0, (uint32_t)0));
- memcached_return_t rc;
- test_compare_got(MEMCACHED_SUCCESS,
- rc= memcached_increment(memc,
- test_literal_param("number"),
- 1, &new_number),
- memcached_strerror(NULL, rc));
- test_compare(1, new_number);
+ test_compare(MEMCACHED_SUCCESS,
+ memcached_increment(memc, test_literal_param("number"), 1, &new_number));
+ test_compare(uint64_t(1), new_number);
test_compare(MEMCACHED_SUCCESS,
- memcached_increment(memc,
- test_literal_param("number"),
- 1, &new_number));
- test_compare(2, new_number);
+ memcached_increment(memc, test_literal_param("number"), 1, &new_number));
+ test_compare(uint64_t(2), new_number);
return TEST_SUCCESS;
}
test_compare(MEMCACHED_SUCCESS, memcached_flush_buffers(memc));
- memcached_return_t rc;
- test_compare_got(MEMCACHED_SUCCESS,
- rc= memcached_increment_with_initial(memc,
- test_literal_param("number"),
- 1, initial, 0, &new_number),
- memcached_strerror(NULL, rc));
+ test_compare(MEMCACHED_SUCCESS,
+ memcached_increment_with_initial(memc, test_literal_param("number"), 1, initial, 0, &new_number));
test_compare(new_number, initial);
test_compare(MEMCACHED_SUCCESS,
- memcached_increment_with_initial(memc,
- test_literal_param("number"),
- 1, initial, 0, &new_number));
- test_compare(new_number, (initial + 1));
+ memcached_increment_with_initial(memc, test_literal_param("number"), 1, initial, 0, &new_number));
+ test_compare(new_number, (initial +1));
return TEST_SUCCESS;
}
test_literal_param("number"),
value, strlen(value),
(time_t)0, (uint32_t)0);
- test_true(rc == MEMCACHED_SUCCESS || rc == MEMCACHED_BUFFERED);
+ test_true(rc == MEMCACHED_SUCCESS or rc == MEMCACHED_BUFFERED);
test_compare(MEMCACHED_SUCCESS,
memcached_decrement(memc,
test_literal_param("number"),
1, &new_number));
- test_compare(new_number, 2);
+ test_compare(uint64_t(2), new_number);
test_compare(MEMCACHED_SUCCESS,
memcached_decrement(memc,
test_literal_param("number"),
1, &new_number));
- test_compare(new_number, 1);
+ test_compare(uint64_t(1), new_number);
return TEST_SUCCESS;
}
test_true(rc == MEMCACHED_SUCCESS or rc == MEMCACHED_BUFFERED);
test_compare(MEMCACHED_SUCCESS,
- memcached_increment_by_key(memc, master_key, strlen(master_key), key, strlen(key),
- 1, &new_number));
- test_compare(new_number, 1);
+ memcached_increment_by_key(memc, master_key, strlen(master_key), key, strlen(key), 1, &new_number));
+ test_compare(uint64_t(1), new_number);
test_compare(MEMCACHED_SUCCESS,
- memcached_increment_by_key(memc, master_key, strlen(master_key), key, strlen(key),
- 1, &new_number));
- test_compare(new_number, 2);
+ memcached_increment_by_key(memc, master_key, strlen(master_key), key, strlen(key), 1, &new_number));
+ test_compare(uint64_t(2), new_number);
return TEST_SUCCESS;
}
key, strlen(key),
1, initial, 0, &new_number);
test_compare(MEMCACHED_SUCCESS, rc);
- test_true(new_number == initial);
+ test_compare(new_number, initial);
rc= memcached_increment_with_initial_by_key(memc, master_key, strlen(master_key),
key, strlen(key),
1, initial, 0, &new_number);
test_compare(MEMCACHED_SUCCESS, rc);
- test_true(new_number == (initial + 1));
+ test_compare(new_number, (initial +1));
return TEST_SUCCESS;
}
test_literal_param("number"),
value, strlen(value),
(time_t)0, (uint32_t)0);
- test_true(rc == MEMCACHED_SUCCESS || rc == MEMCACHED_BUFFERED);
+ test_true(rc == MEMCACHED_SUCCESS or rc == MEMCACHED_BUFFERED);
test_compare(MEMCACHED_SUCCESS,
memcached_decrement_by_key(memc,
test_literal_param("foo"),
test_literal_param("number"),
1, &new_number));
- test_compare(new_number, 2);
+ test_compare(uint64_t(2), new_number);
test_compare(MEMCACHED_SUCCESS,
memcached_decrement_by_key(memc,
test_literal_param("foo"),
test_literal_param("number"),
1, &new_number));
- test_compare(new_number, 1);
+ test_compare(uint64_t(1), new_number);
return TEST_SUCCESS;
}
rc= memcached_set(memc, key, strlen(key),
value, strlen(value),
(time_t)10, (uint32_t)3);
- test_true(rc == MEMCACHED_SUCCESS || rc == MEMCACHED_BUFFERED);
+ test_true(rc == MEMCACHED_SUCCESS or rc == MEMCACHED_BUFFERED);
memcached_quit(memc);
rc= memcached_set(memc, key, strlen(key),
value, strlen(value),
(time_t)50, (uint32_t)9);
- test_true(rc == MEMCACHED_SUCCESS || rc == MEMCACHED_BUFFERED);
+ test_true(rc == MEMCACHED_SUCCESS or rc == MEMCACHED_BUFFERED);
return TEST_SUCCESS;
}
callbacks[0]= &callback_counter;
counter= 0;
- memcached_return_t rc;
- test_compare_got(MEMCACHED_SUCCESS,
- rc= memcached_fetch_execute(memc, callbacks, (void *)&counter, 1),
- memcached_strerror(NULL, rc));
+ test_compare(MEMCACHED_SUCCESS,
+ memcached_fetch_execute(memc, callbacks, (void *)&counter, 1));
- test_compare(counter, 3);
+ test_compare(size_t(3), counter);
return TEST_SUCCESS;
}
test_true(return_value);
}
test_false(return_value);
- test_compare(0, return_value_length);
- test_compare_got(MEMCACHED_NOTFOUND, rc, memcached_strerror(NULL, rc));
+ test_zero(return_value_length);
+ test_compare(MEMCACHED_NOTFOUND, rc);
for (uint32_t x= 0; x < 3; x++)
{
return TEST_SUCCESS;
}
-static test_return_t fetch_all_results(memcached_st *memc, size_t &keys_returned, const memcached_return_t expect)
+static test_return_t fetch_all_results(memcached_st *memc, unsigned int &keys_returned, const memcached_return_t expect)
{
memcached_return_t rc;
char return_key[MEMCACHED_MAX_KEY];
{
return TEST_SUCCESS;
}
- fprintf(stderr, "\n%s:%u %s(#%lu)\n", __FILE__, __LINE__, memcached_strerror(NULL, rc), (unsigned long)(keys_returned));
+ fprintf(stderr, "\n%s:%u %s(#%u)\n", __FILE__, __LINE__, memcached_strerror(NULL, rc), keys_returned);
return TEST_FAILURE;
}
/* Test case provided by Cal Haldenbrand */
-#define HALDENBRAND_KEY_COUNT 3000 // * 1024576
+#define HALDENBRAND_KEY_COUNT 3000U // * 1024576
#define HALDENBRAND_FLAG_KEY 99 // * 1024576
static test_return_t user_supplied_bug1(memcached_st *memc)
{
total+= size;
char key[22];
int key_length= snprintf(key, sizeof(key), "%u", x);
- memcached_return_t rc;
- test_compare_got(MEMCACHED_SUCCESS,
- rc= memcached_set(memc, key, key_length, randomstuff, strlen(randomstuff), time_t(0), HALDENBRAND_FLAG_KEY),
- memcached_strerror(NULL, rc));
+ test_compare(MEMCACHED_SUCCESS,
+ memcached_set(memc, key, key_length, randomstuff, strlen(randomstuff), time_t(0), HALDENBRAND_FLAG_KEY));
}
test_true(total > HALDENBRAND_KEY_COUNT);
continue;
}
- test_compare(HALDENBRAND_FLAG_KEY, flags);
+ test_compare(uint32_t(HALDENBRAND_FLAG_KEY), flags);
total_value_length+= val_len;
errors= 0;
test_compare(MEMCACHED_SUCCESS,
memcached_mget(memc, (const char **)keys, key_lengths, HALDENBRAND_KEY_COUNT));
- test_return_t foo;
- size_t keys_returned;
- test_compare_got(TEST_SUCCESS, foo= fetch_all_results(memc, keys_returned, MEMCACHED_SUCCESS), test_strerror(foo));
+ unsigned int keys_returned;
+ test_compare(TEST_SUCCESS, fetch_all_results(memc, keys_returned, MEMCACHED_SUCCESS));
test_compare(HALDENBRAND_KEY_COUNT, keys_returned);
for (uint32_t x= 0; x < HALDENBRAND_KEY_COUNT; x++)
test_compare(MEMCACHED_NO_SERVERS,
memcached_mget(memc, keys, key_length, 3));
- size_t keys_returned;
+ unsigned int keys_returned;
test_compare(TEST_SUCCESS, fetch_all_results(memc, keys_returned, MEMCACHED_NOTFOUND));
- test_compare(0, keys_returned);
+ test_zero(keys_returned);
for (uint32_t x= 0; x < 3; x++)
{
test_compare(MEMCACHED_SUCCESS,
memcached_mget(memc, keys, key_length, 4));
- size_t count;
+ unsigned int count;
test_compare(TEST_SUCCESS, fetch_all_results(memc, count, MEMCACHED_NOTFOUND));
- test_compare(0, count);
+ test_zero(count);
for (uint32_t x= 0; x < 4; x++)
{
memcached_mget(memc, keys, key_length, 4));
test_compare(TEST_SUCCESS, fetch_all_results(memc, count, MEMCACHED_SUCCESS));
- test_compare(4, count);
+ test_compare(4U, count);
}
delete [] insert_data;
insert_data[x]= (signed char)rand();
}
- test_compare(MEMCACHED_SUCCESS,
- memcached_flush(memc, 0));
+ test_compare(MEMCACHED_SUCCESS, memcached_flush(memc, 0));
- memcached_return_t rc;
- value= memcached_get(memc, keys[0], key_length[0],
- &value_length, &flags, &rc);
- test_false(value);
- test_compare(MEMCACHED_NOTFOUND, rc);
+ test_compare(TEST_SUCCESS, confirm_keys_dont_exist(memc, keys, test_array_length(keys)));
+ // We will now confirm that memcached_mget() returns success, but we will
+ // then check to make sure that no actual keys are returned.
test_compare(MEMCACHED_SUCCESS,
memcached_mget(memc, keys, key_length, 4));
+ memcached_return_t rc;
uint32_t count= 0;
while ((value= memcached_fetch(memc, return_key, &return_key_length,
&value_length, &flags, &rc)))
{
count++;
}
- test_compare(0, count);
+ test_zero(count);
test_compare_got(MEMCACHED_NOTFOUND, rc, memcached_strerror(NULL, rc));
- for (uint32_t x= 0; x < 4; x++)
+ for (uint32_t x= 0; x < test_array_length(keys); x++)
{
test_compare(MEMCACHED_SUCCESS,
memcached_set(memc, keys[x], key_length[x],
insert_data, VALUE_SIZE_BUG5,
(time_t)0, (uint32_t)0));
}
+ test_compare(TEST_SUCCESS, confirm_keys_exist(memc, keys, test_array_length(keys)));
for (uint32_t x= 0; x < 2; x++)
{
test_compare(MEMCACHED_SUCCESS,
memcached_mget(memc, keys, key_length, 4));
- count= 3;
/* We test for purge of partial complete fetches */
for (count= 3; count; count--)
{
flags= 0;
value= memcached_fetch(memc, return_key, &return_key_length,
&value_length, &flags, &rc);
- test_compare(245, flags);
+ test_compare(uint32_t(245), flags);
test_true(value);
free(value);
delete [] insert_data;
free(return_value);
count++;
}
- test_compare(3, count);
+ test_compare(3U, count);
return TEST_SUCCESS;
}
test_false(return_value); // There are no keys to fetch, so the value should never be returned
}
test_compare(MEMCACHED_NOTFOUND, rc);
- test_compare(0, return_value_length);
- test_compare(0, return_key_length);
+ test_zero(return_value_length);
+ test_zero(return_key_length);
test_false(return_key[0]);
test_false(return_value);
{
unsigned int check_execute= execute_set(memc, global_pairs, global_count);
- test_true(check_execute == global_count);
+ test_compare(check_execute, global_count);
return TEST_SUCCESS;
}
test_skip(true, bool(libmemcached_util_version_check(memc, 1, 4, 4)));
- memcached_return_t rc;
- test_compare_got(MEMCACHED_SUCCESS,
- rc= memcached_mget(memc, global_keys, global_keys_length, global_count),
- memcached_strerror(NULL, rc));
+ test_compare(MEMCACHED_SUCCESS,
+ memcached_mget(memc, global_keys, global_keys_length, global_count));
// Go fetch the keys and test to see if all of them were returned
{
- size_t keys_returned;
+ unsigned int keys_returned;
test_compare(TEST_SUCCESS, fetch_all_results(memc, keys_returned, MEMCACHED_SUCCESS));
test_true(keys_returned > 0);
- char buffer[30];
- snprintf(buffer, sizeof(buffer), "%lu", (unsigned long)keys_returned);
- test_compare_got(global_count, keys_returned, buffer);
+ test_compare(global_count, keys_returned);
}
return TEST_SUCCESS;
memcached_server_st *servers= memcached_server_list_append_with_weight(NULL, servername, 400, 0, &rc);
test_true(servers);
- test_compare(1, memcached_server_list_count(servers));
+ test_compare(1U, memcached_server_list_count(servers));
- for (size_t x= 2; x < 20; x++)
+ for (uint32_t x= 2; x < 20; x++)
{
char buffer[SMALL_STRING_LEN];
* Make sure that we store the item on all servers
* (master + replicas == number of servers)
*/
- memcached_return_t rc= memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_NUMBER_OF_REPLICAS,
- memcached_server_count(memc) - 1);
- test_compare(MEMCACHED_SUCCESS, rc);
- test_true(memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_NUMBER_OF_REPLICAS) == memcached_server_count(memc) - 1);
+ test_compare(MEMCACHED_SUCCESS, memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_NUMBER_OF_REPLICAS, memcached_server_count(memc) - 1));
+ test_compare(memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_NUMBER_OF_REPLICAS), uint64_t(memcached_server_count(memc) - 1));
- return rc == MEMCACHED_SUCCESS ? TEST_SUCCESS : TEST_SKIPPED;
+ return TEST_SUCCESS;
}
memcached_callback_set(memc, MEMCACHED_CALLBACK_NAMESPACE, long_key));
/* Test for a bad prefix, but with a short key */
- test_compare_got(memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL) ? MEMCACHED_INVALID_ARGUMENTS : MEMCACHED_SUCCESS,
- rc= memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_VERIFY_KEY, 1),
- memcached_strerror(NULL, rc));
+ test_compare(memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL) ? MEMCACHED_INVALID_ARGUMENTS : MEMCACHED_SUCCESS,
+ memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_VERIFY_KEY, 1));
test_compare(memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL) ? MEMCACHED_SUCCESS : MEMCACHED_BAD_KEY_PROVIDED,
memcached_callback_set(memc, MEMCACHED_CALLBACK_NAMESPACE, "dog cat"));
static test_return_t poll_timeout(memcached_st *memc)
{
- size_t timeout= 100; // Not using, just checking that it sets
+ const uint64_t timeout= 100; // Not using, just checking that it sets
memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_POLL_TIMEOUT, timeout);
- timeout= (size_t)memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_POLL_TIMEOUT);
- test_compare(100, timeout);
+ test_compare(timeout, memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_POLL_TIMEOUT));
return TEST_SUCCESS;
}
}
/* Count the objects */
-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 MEMCACHED_SUCCESS;
-}
static test_return_t dump_test(memcached_st *memc)
{
- size_t counter= 0;
- memcached_dump_fn callbacks[1];
-
- callbacks[0]= &callback_dump_counter;
-
/* No support for Binary protocol yet */
test_skip(false, memc->flags.binary_protocol);
test_compare(TEST_SUCCESS, set_test3(memc));
- test_compare(MEMCACHED_SUCCESS,
- memcached_dump(memc, callbacks, (void *)&counter, 1));
+ // confirm_key_count() call dump
+ size_t counter= confirm_key_count(memc);
/* We may have more then 32 if our previous flush has not completed */
test_true(counter >= 32);
mmc[1]= memcached_pool_pop(pool, false, &rc);
test_true(mmc[1]);
- test_compare(9999, memcached_behavior_get(mmc[1], MEMCACHED_BEHAVIOR_IO_MSG_WATERMARK));
+ test_compare(UINT64_C(9999), memcached_behavior_get(mmc[1], MEMCACHED_BEHAVIOR_IO_MSG_WATERMARK));
test_compare(MEMCACHED_SUCCESS, memcached_pool_push(pool, mmc[1]));
test_compare(MEMCACHED_SUCCESS, memcached_pool_push(pool, mmc[0]));
mmc[0]= memcached_pool_pop(pool, false, &rc);
- test_compare(9999, memcached_behavior_get(mmc[0], MEMCACHED_BEHAVIOR_IO_MSG_WATERMARK));
+ test_compare(UINT64_C(9999), memcached_behavior_get(mmc[0], MEMCACHED_BEHAVIOR_IO_MSG_WATERMARK));
test_compare(MEMCACHED_SUCCESS, memcached_pool_push(pool, mmc[0]));
test_true(memcached_pool_destroy(pool) == memc);
return TEST_SUCCESS;
}
-static test_return_t one_at_a_time_run (memcached_st *memc)
+static test_return_t one_at_a_time_run (memcached_st *)
{
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)
+static test_return_t md5_run (memcached_st *)
{
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)
+static test_return_t crc_run (memcached_st *)
{
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)
+static test_return_t fnv1_64_run (memcached_st *)
{
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)
+static test_return_t fnv1a_64_run (memcached_st *)
{
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)
+static test_return_t fnv1_32_run (memcached_st *)
{
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)
+static test_return_t fnv1a_32_run (memcached_st *)
{
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)
+static test_return_t hsieh_run (memcached_st *)
{
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)
+static test_return_t murmur_run (memcached_st *)
{
#ifdef WORDS_BIGENDIAN
(void)murmur_values;
#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)
+static test_return_t jenkins_run (memcached_st *)
{
uint32_t x;
const char **ptr;
- (void)memc;
for (ptr= list_to_hash, x= 0; *ptr; ptr++, x++)
{
return libhashkit_crc32(string, string_length);
}
-static test_return_t memcached_get_hashkit_test (memcached_st *memc)
+static test_return_t memcached_get_hashkit_test (memcached_st *)
{
uint32_t x;
const char **ptr;
- const hashkit_st *kit;
hashkit_st new_kit;
- hashkit_return_t hash_rc;
+
+ memcached_st *memc= memcached(test_literal_param("--server=localhost:1 --server=localhost:2 --server=localhost:3 --server=localhost:4 --server=localhost5"));
uint32_t md5_hosts[]= {4U, 1U, 0U, 1U, 4U, 2U, 0U, 3U, 0U, 0U, 3U, 1U, 0U, 0U, 1U, 3U, 0U, 0U, 0U, 3U, 1U, 0U, 4U, 4U, 3U};
uint32_t crc_hosts[]= {2U, 4U, 1U, 0U, 2U, 4U, 4U, 4U, 1U, 2U, 3U, 4U, 3U, 4U, 1U, 3U, 3U, 2U, 0U, 0U, 0U, 1U, 2U, 4U, 0U};
- kit= memcached_get_hashkit(memc);
+ const hashkit_st *kit= memcached_get_hashkit(memc);
hashkit_clone(&new_kit, kit);
- hash_rc= hashkit_set_custom_function(&new_kit, hash_md5_test_function, NULL);
- test_true(hash_rc == HASHKIT_SUCCESS);
+ test_compare(HASHKIT_SUCCESS, hashkit_set_custom_function(&new_kit, hash_md5_test_function, NULL));
memcached_set_hashkit(memc, &new_kit);
uint32_t hash_val;
hash_val= hashkit_digest(kit, *ptr, strlen(*ptr));
- test_true(md5_values[x] == hash_val);
+ test_compare_got(md5_values[x], hash_val, *ptr);
}
uint32_t hash_val;
hash_val= memcached_generate_hash(memc, *ptr, strlen(*ptr));
- test_true(md5_hosts[x] == hash_val);
+ test_compare_got(md5_hosts[x], hash_val, *ptr);
}
- hash_rc= hashkit_set_custom_function(&new_kit, hash_crc_test_function, NULL);
- test_true(hash_rc == HASHKIT_SUCCESS);
+ test_compare(HASHKIT_SUCCESS, hashkit_set_custom_function(&new_kit, hash_crc_test_function, NULL));
memcached_set_hashkit(memc, &new_kit);
uint32_t hash_val;
hash_val= memcached_generate_hash(memc, *ptr, strlen(*ptr));
- test_true(crc_hosts[x] == hash_val);
+ test_compare(crc_hosts[x], hash_val);
}
+ memcached_free(memc);
+
return TEST_SUCCESS;
}
char *value= memcached_get(tl_memc_h, key, strlen(key), &len, &flags, &rc);
test_false(value);
- test_compare(0, len);
+ test_zero(len);
test_true(memcached_failed(rc));
memcached_free(tl_memc_h);
value= memcached_get(memc, key, strlen(key), &len, &flags, &rc);
test_false(value);
- test_compare(0, len);
+ test_zero(len);
test_compare(MEMCACHED_NOTFOUND, rc);
return TEST_SUCCESS;
value= memcached_get_by_key(tl_memc_h, key, strlen(key), key, strlen(key), &len, &flags, &rc);
test_false(value);
- test_compare(0, len);
+ test_zero(len);
test_true(memcached_failed(rc));
memcached_free(tl_memc_h);
value= memcached_get_by_key(memc, key, strlen(key), key, strlen(key), &len, &flags, &rc);
test_false(value);
- test_compare(0, len);
+ test_zero(len);
test_compare(MEMCACHED_NOTFOUND, rc);
return TEST_SUCCESS;
test_compare(MEMCACHED_SUCCESS,
memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_KETAMA_WEIGHTED, 1));
- uint64_t value;
- test_compare(1, value= memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_KETAMA_WEIGHTED));
+ test_compare(1UL, memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_KETAMA_WEIGHTED));
test_compare(MEMCACHED_SUCCESS, memcached_behavior_set_distribution(memc, MEMCACHED_DISTRIBUTION_CONSISTENT_KETAMA));
test_compare(MEMCACHED_DISTRIBUTION_CONSISTENT_KETAMA, memcached_behavior_get_distribution(memc));
-
memcached_server_st *server_pool= memcached_servers_parse("10.0.1.1:11211 600,10.0.1.2:11211 300,10.0.1.3:11211 200,10.0.1.4:11211 350,10.0.1.5:11211 1000,10.0.1.6:11211 800,10.0.1.7:11211 950,10.0.1.8:11211 100");
memcached_server_push(memc, server_pool);
/* verify that the server list was parsed okay. */
- test_compare(8, memcached_server_count(memc));
+ test_compare(8U, memcached_server_count(memc));
test_strcmp(server_pool[0].hostname, "10.0.1.1");
- test_compare(11211, server_pool[0].port);
- test_compare(600, server_pool[0].weight);
+ test_compare(in_port_t(11211), server_pool[0].port);
+ test_compare(600U, server_pool[0].weight);
test_strcmp(server_pool[2].hostname, "10.0.1.3");
- test_compare(11211, server_pool[2].port);
- test_compare(200, server_pool[2].weight);
+ test_compare(in_port_t(11211), server_pool[2].port);
+ test_compare(200U, server_pool[2].weight);
test_strcmp(server_pool[7].hostname, "10.0.1.8");
- test_compare(11211, server_pool[7].port);
- test_compare(100, server_pool[7].weight);
+ test_compare(in_port_t(11211), server_pool[7].port);
+ test_compare(100U, server_pool[7].weight);
/* VDEAAAAA hashes to fffcd1b5, after the last continuum point, and lets
* us test the boundary wraparound.
static test_return_t ketama_compatibility_spymemcached(memcached_st *)
{
- uint64_t value;
-
memcached_st *memc= memcached_create(NULL);
test_true(memc);
test_compare(MEMCACHED_SUCCESS,
memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_KETAMA_WEIGHTED, 1));
- test_compare(1, value= memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_KETAMA_WEIGHTED));
+ test_compare(UINT64_C(1), memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_KETAMA_WEIGHTED));
test_compare(MEMCACHED_SUCCESS, memcached_behavior_set_distribution(memc, MEMCACHED_DISTRIBUTION_CONSISTENT_KETAMA_SPY));
test_compare(MEMCACHED_DISTRIBUTION_CONSISTENT_KETAMA_SPY, memcached_behavior_get_distribution(memc));
memcached_server_push(memc, server_pool);
/* verify that the server list was parsed okay. */
- test_compare(8, memcached_server_count(memc));
+ test_compare(8U, memcached_server_count(memc));
test_strcmp(server_pool[0].hostname, "10.0.1.1");
- test_compare(11211, server_pool[0].port);
- test_compare(600, server_pool[0].weight);
+ test_compare(in_port_t(11211), server_pool[0].port);
+ test_compare(600U, server_pool[0].weight);
test_strcmp(server_pool[2].hostname, "10.0.1.3");
- test_compare(11211, server_pool[2].port);
- test_compare(200, server_pool[2].weight);
+ test_compare(in_port_t(11211), server_pool[2].port);
+ test_compare(200U, server_pool[2].weight);
test_strcmp(server_pool[7].hostname, "10.0.1.8");
- test_compare(11211, server_pool[7].port);
- test_compare(100, server_pool[7].weight);
+ test_compare(in_port_t(11211), server_pool[7].port);
+ test_compare(100U, server_pool[7].weight);
/* VDEAAAAA hashes to fffcd1b5, after the last continuum point, and lets
* us test the boundary wraparound.
test_compare(MEMCACHED_SUCCESS,
memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_NUMBER_OF_REPLICAS, 2));
- const size_t max_keys= 100;
+ const unsigned int max_keys= 100;
char **keys= (char**)calloc(max_keys, sizeof(char*));
size_t *key_length= (size_t *)calloc(max_keys, sizeof(size_t));
- for (size_t x= 0; x < max_keys; ++x)
+ for (unsigned int x= 0; x < max_keys; ++x)
{
char k[251];
test_compare(MEMCACHED_SUCCESS,
memcached_mget(memc, (const char* const *)keys, key_length, max_keys));
- size_t counter= 0;
+ unsigned int counter= 0;
memcached_execute_fn callbacks[]= { &callback_counter };
- memcached_return_t rc;
- test_compare_got(MEMCACHED_SUCCESS,
- rc= memcached_fetch_execute(memc, callbacks, (void *)&counter, 1),
- memcached_strerror(NULL, rc));
+ test_compare(MEMCACHED_SUCCESS,
+ memcached_fetch_execute(memc, callbacks, (void *)&counter, 1));
/* Verify that we received all of the key/value pairs */
test_compare(counter, max_keys);
memcached_mget(memc, (const char* const *)keys, key_length, max_keys));
counter= 0;
- test_compare_got(MEMCACHED_SUCCESS,
- rc= memcached_fetch_execute(memc, callbacks, (void *)&counter, 1),
- memcached_strerror(NULL, rc));
+ test_compare(MEMCACHED_SUCCESS,
+ memcached_fetch_execute(memc, callbacks, (void *)&counter, 1));
test_compare(counter, (unsigned int)(max_keys >> 1));
/* Release allocated resources */
disconnected_server= memcached_server_get_last_disconnect(mine);
test_true_got(disconnected_server, memcached_strerror(mine, rc));
- test_compare(9, memcached_server_port(disconnected_server));
+ test_compare(in_port_t(9), memcached_server_port(disconnected_server));
test_false(strncmp(memcached_server_name(disconnected_server),"localhost",9));
memcached_quit(mine);
const char *server_string= "--server=localhost:8888 --server=localhost:8889 --server=localhost:8890 --server=localhost:8891 --server=localhost:8892";
char buffer[BUFSIZ];
- memcached_return_t rc;
- test_compare_got(MEMCACHED_SUCCESS,
- rc= libmemcached_check_configuration(server_string, strlen(server_string), buffer, sizeof(buffer)),
- memcached_strerror(NULL, rc));
+ test_compare(MEMCACHED_SUCCESS,
+ libmemcached_check_configuration(server_string, strlen(server_string), buffer, sizeof(buffer)));
memcached_st *memc= memcached(server_string, strlen(server_string));
test_true(memc);
memcached_behavior_set(local_memc, MEMCACHED_BEHAVIOR_SERVER_FAILURE_LIMIT, 2);
uint32_t server_count= memcached_server_count(local_memc);
- test_compare(1, server_count);
+ test_compare(1U, server_count);
// Disable the server
instance= memcached_server_instance_by_position(local_memc, 0);
memcached_last_error_message(local_memc));
((memcached_server_write_instance_st)instance)->server_failure_counter= 0;
- test_compare_got(MEMCACHED_SUCCESS,
- rc= memcached_set(local_memc, "foo", strlen("foo"), NULL, 0, (time_t)0, (uint32_t)0),
- memcached_strerror(NULL, rc));
+ test_compare(MEMCACHED_SUCCESS,
+ memcached_set(local_memc, "foo", strlen("foo"), NULL, 0, (time_t)0, (uint32_t)0));
#if 0
- memcached_last_error_message(local_memc));
+ memcached_last_error_message(local_memc));
#endif
* Please note that this isn't bullet proof, because an error could
* occur...
*/
- test_compare(0, instance->server_failure_counter);
+ test_zero(instance->server_failure_counter);
/* restore the instance */
memc->number_of_hosts= number_of_hosts;
const char *value= memcached_get(memc, "dsf", 3, &length, &flags, &rc);
test_false(value);
- test_compare(0, length);
+ test_zero(length);
test_compare_got(MEMCACHED_TIMEOUT, rc, memcached_strerror(memc, rc));
if (rc == MEMCACHED_NOTFOUND)
{
test_false(value);
- test_compare(0, value_length);
+ test_zero(value_length);
continue;
}
test_compare(MEMCACHED_SUCCESS, rc);
test_true(value);
- test_compare(100, value_length);
+ test_compare(100UL, value_length);
free(value);
}
test_true(key_length[x]);
}
- memcached_return_t rc;
- test_compare_got(MEMCACHED_SUCCESS,
- rc= memcached_mget(clone, (const char* const *)keys, key_length, regression_bug_655423_COUNT),
- memcached_strerror(NULL, rc));
+ test_compare(MEMCACHED_SUCCESS,
+ memcached_mget(clone, (const char* const *)keys, key_length, regression_bug_655423_COUNT));
uint32_t count= 0;
memcached_result_st *result= NULL;
while ((result= memcached_fetch_result(clone, result, NULL)))
{
- test_compare(100, memcached_result_length(result));
+ test_compare(size_t(100), memcached_result_length(result));
count++;
}
{"set", 1, (test_callback_fn*)replication_set_test },
{"get", 0, (test_callback_fn*)replication_get_test },
{"mget", 0, (test_callback_fn*)replication_mget_test },
- {"delete", 0, (test_callback_fn*)replication_delete_test },
+ {"delete", true, (test_callback_fn*)replication_delete_test },
{"rand_mget", 0, (test_callback_fn*)replication_randomize_mget_test },
{"fail", 0, (test_callback_fn*)replication_randomize_mget_fail_test },
{0, 0, (test_callback_fn*)0}
world->collections= collection;
world->_create= (test_callback_create_fn*)world_create;
- world->_destroy= (test_callback_fn*)world_destroy;
+ world->_destroy= (test_callback_destroy_fn*)world_destroy;
world->item._startup= (test_callback_fn*)world_test_startup;
- world->item._flush= (test_callback_fn*)world_flush;
world->item.set_pre((test_callback_fn*)world_pre_run);
+ world->item.set_flush((test_callback_fn*)world_flush);
world->item.set_post((test_callback_fn*)world_post_run);
world->_on_error= (test_callback_error_fn*)world_on_error;
world->collection_startup= (test_callback_fn*)world_container_startup;
world->collection_shutdown= (test_callback_fn*)world_container_shutdown;
- world->runner= &defualt_libmemcached_runner;
+ world->set_runner(&defualt_libmemcached_runner);
}
projects / m6w6 / libmemcached / blobdiff