*
*/
-#include <libtest/common.h>
+#include <config.h>
+#include <libtest/test.hpp>
/*
Test cases
*/
-#define BUILDING_LIBMEMCACHED
-// !NEVER use common.h, always use memcached.h in your own apps
-#include <libmemcached/common.h>
+#include <libmemcached-1.0/memcached.h>
+#include <libmemcached/is.h>
+#include <libmemcached/server_instance.h>
+
+#include <libhashkit-1.0/hashkit.h>
#include <cassert>
+#include <cerrno>
#include <memory>
+#include <pthread.h>
+#include <semaphore.h>
#include <signal.h>
#include <sys/stat.h>
#include <sys/time.h>
#define SMALL_STRING_LEN 1024
#include <libtest/test.hpp>
+
+#include "tests/basic.h"
+#include "tests/debug.h"
#include "tests/deprecated.h"
+#include "tests/error_conditions.h"
+#include "tests/exist.h"
+#include "tests/ketama.h"
+#include "tests/namespace.h"
#include "tests/parser.h"
+#include "tests/touch.h"
+#include "tests/callbacks.h"
#include "tests/pool.h"
-#include "tests/namespace.h"
-#include "tests/string.h"
-#include "tests/replication.h"
-#include "tests/basic.h"
-#include "tests/error_conditions.h"
#include "tests/print.h"
+#include "tests/replication.h"
+#include "tests/server_add.h"
#include "tests/virtual_buckets.h"
+using namespace libtest;
-#ifdef HAVE_LIBMEMCACHEDUTIL
-#include <pthread.h>
-#include "libmemcached/memcached_util.h"
-#endif
+#include <libmemcached/util.h>
#include "hash_results.h"
static const char *global_keys[GLOBAL_COUNT];
static size_t global_keys_length[GLOBAL_COUNT];
-// Prototype
-static test_return_t pre_binary(memcached_st *memc);
+/**
+ @note This should be testing to see if the server really supports the binary protocol.
+*/
+static test_return_t pre_binary(memcached_st *memc)
+{
+ memcached_return_t rc= MEMCACHED_FAILURE;
+
+ if (libmemcached_util_version_check(memc, 1, 4, 4))
+ {
+ rc = memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL, 1);
+ test_compare(MEMCACHED_SUCCESS, rc);
+ test_true(memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL) == 1);
+ }
+
+ return rc == MEMCACHED_SUCCESS ? TEST_SUCCESS : TEST_SKIPPED;
+}
static test_return_t init_test(memcached_st *not_used)
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(memc_clone->flags.verify_key == memc->flags.verify_key);
test_true(memc_clone->ketama.weighted == memc->ketama.weighted);
test_true(memc_clone->flags.binary_protocol == memc->flags.binary_protocol);
- test_true(memc_clone->flags.hash_with_prefix_key == memc->flags.hash_with_prefix_key);
+ test_true(memc_clone->flags.hash_with_namespace == memc->flags.hash_with_namespace);
test_true(memc_clone->flags.no_reply == memc->flags.no_reply);
test_true(memc_clone->flags.use_udp == memc->flags.use_udp);
test_true(memc_clone->flags.auto_eject_hosts == memc->flags.auto_eject_hosts);
{
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;
}
-static test_return_t error_test(memcached_st *memc)
+static test_return_t memcached_return_t_TEST(memcached_st *memc)
{
uint32_t values[] = { 851992627U, 2337886783U, 4109241422U, 4001849190U,
982370485U, 1263635348U, 4242906218U, 3829656100U,
54481931U, 4186304426U, 1741088401U, 2979625118U,
4159057246U, 3425930182U, 2593724503U, 1868899624U,
1769812374U, 2302537950U, 1110330676U, 3365377466U,
- 1336171666U, 3021258493U, 2334992265U, 3365377466U };
+ 1336171666U, 3021258493U, 2334992265U, 3861994737U,
+ 3365377466U };
// You have updated the memcache_error messages but not updated docs/tests.
for (int rc= int(MEMCACHED_SUCCESS); rc < int(MEMCACHED_MAXIMUM_RETURN); ++rc)
MEMCACHED_HASH_JENKINS);
if (values[rc] != hash_val)
{
- fprintf(stderr, "\n\nYou have updated memcached_return_t without updating the error_test\n");
+ fprintf(stderr, "\n\nYou have updated memcached_return_t without updating the memcached_return_t_TEST\n");
fprintf(stderr, "%u, %s, (%u)\n\n", (uint32_t)rc, memcached_strerror(memc, memcached_return_t(rc)), hash_val);
}
test_compare(values[rc], hash_val);
}
- test_compare(MEMCACHED_MAXIMUM_RETURN, 47);
+ test_compare(48, int(MEMCACHED_MAXIMUM_RETURN));
return TEST_SUCCESS;
}
static test_return_t set_test(memcached_st *memc)
{
memcached_return_t rc= memcached_set(memc,
- memcached_literal_param("foo"),
- memcached_literal_param("when we sanitize"),
+ test_literal_param("foo"),
+ test_literal_param("when we sanitize"),
time_t(0), (uint32_t)0);
test_true_got(rc == MEMCACHED_SUCCESS || rc == MEMCACHED_BUFFERED, memcached_strerror(NULL, rc));
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);
test_compare(MEMCACHED_SUCCESS, rc);
}
- rc= memcached_mget(memc, keys, key_length, 3);
+ test_compare(MEMCACHED_SUCCESS,
+ memcached_mget(memc, keys, key_length, 3));
results= memcached_result_create(memc, &results_obj);
+ test_true(results);
results= memcached_fetch_result(memc, &results_obj, &rc);
test_true(results);
(time_t)0, (uint32_t)0);
test_compare(MEMCACHED_SUCCESS, rc);
- rc= memcached_mget(memc, keys, keylengths, 1);
+ test_compare(MEMCACHED_SUCCESS,
+ memcached_mget(memc, keys, keylengths, 1));
results= memcached_result_create(memc, &results_obj);
+ test_true(results);
results= memcached_fetch_result(memc, &results_obj, &rc);
test_true(results);
{
memcached_return_t rc;
const char *key= "foo bad";
- char *string;
- size_t string_length;
uint32_t flags;
memcached_st *memc_clone;
- unsigned int set= 1;
- size_t max_keylen= 0xffff;
- // Just skip if we are in binary mode.
uint64_t query_id= memcached_query_id(memc);
- if (memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL))
- return TEST_SKIPPED;
+
+ // Just skip if we are in binary mode.
+ test_skip(false, memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL));
+
test_compare(query_id, memcached_query_id(memc)); // We should not increase the query_id for memcached_behavior_get()
memc_clone= memcached_clone(NULL, memc);
query_id= memcached_query_id(memc_clone);
test_compare(MEMCACHED_SUCCESS,
- memcached_behavior_set(memc_clone, MEMCACHED_BEHAVIOR_VERIFY_KEY, set));
+ memcached_behavior_set(memc_clone, MEMCACHED_BEHAVIOR_VERIFY_KEY, true));
test_compare(query_id, memcached_query_id(memc_clone)); // We should not increase the query_id for memcached_behavior_set()
/* All keys are valid in the binary protocol (except for length) */
if (not memcached_behavior_get(memc_clone, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL))
{
- query_id= memcached_query_id(memc_clone);
- 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_false(string);
+ uint64_t before_query_id= memcached_query_id(memc_clone);
+ {
+ size_t string_length;
+ char *string= memcached_get(memc_clone, key, strlen(key),
+ &string_length, &flags, &rc);
+ test_compare(MEMCACHED_BAD_KEY_PROVIDED, rc);
+ test_zero(string_length);
+ test_false(string);
+ }
+ test_compare(before_query_id +1, memcached_query_id(memc_clone));
- set= 0;
query_id= memcached_query_id(memc_clone);
test_compare(MEMCACHED_SUCCESS,
- memcached_behavior_set(memc_clone, MEMCACHED_BEHAVIOR_VERIFY_KEY, set));
+ memcached_behavior_set(memc_clone, MEMCACHED_BEHAVIOR_VERIFY_KEY, false));
test_compare(query_id, memcached_query_id(memc_clone)); // We should not increase the query_id for memcached_behavior_set()
- 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_false(string);
+ {
+ size_t string_length;
+ char *string= memcached_get(memc_clone, key, strlen(key),
+ &string_length, &flags, &rc);
+ test_compare_got(MEMCACHED_NOTFOUND, rc, memcached_strerror(NULL, rc));
+ test_zero(string_length);
+ test_false(string);
+ }
/* Test multi key for bad keys */
const char *keys[] = { "GoodKey", "Bad Key", "NotMine" };
size_t key_lengths[] = { 7, 7, 7 };
- set= 1;
query_id= memcached_query_id(memc_clone);
test_compare(MEMCACHED_SUCCESS,
- memcached_behavior_set(memc_clone, MEMCACHED_BEHAVIOR_VERIFY_KEY, set));
+ memcached_behavior_set(memc_clone, MEMCACHED_BEHAVIOR_VERIFY_KEY, true));
test_compare(query_id, memcached_query_id(memc_clone));
query_id= memcached_query_id(memc_clone);
memcached_mget_by_key(memc_clone, "foo daddy", 9, keys, key_lengths, 1));
test_compare(query_id +1, memcached_query_id(memc_clone));
- max_keylen= 250;
-
/* The following test should be moved to the end of this function when the
memcached server is updated to allow max size length of the keys in the
binary protocol
test_compare(MEMCACHED_SUCCESS,
memcached_callback_set(memc_clone, MEMCACHED_CALLBACK_NAMESPACE, NULL));
- char *longkey= (char *)malloc(max_keylen + 1);
- if (longkey)
+ std::vector <char> longkey;
+ longkey.reserve(MEMCACHED_MAX_KEY);
+ longkey.insert(longkey.end(), MEMCACHED_MAX_KEY, 'a');
+ test_compare(longkey.size(), size_t(MEMCACHED_MAX_KEY));
{
- memset(longkey, 'a', max_keylen + 1);
- string= memcached_get(memc_clone, longkey, max_keylen,
- &string_length, &flags, &rc);
+ size_t string_length;
+ // We subtract 1
+ test_null(memcached_get(memc_clone, &longkey[0], longkey.size() -1, &string_length, &flags, &rc));
test_compare(MEMCACHED_NOTFOUND, rc);
- test_compare(0, string_length);
- test_false(string);
+ test_zero(string_length);
- string= memcached_get(memc_clone, longkey, max_keylen + 1,
- &string_length, &flags, &rc);
+ test_null(memcached_get(memc_clone, &longkey[0], longkey.size(), &string_length, &flags, &rc));
test_compare(MEMCACHED_BAD_KEY_PROVIDED, rc);
- test_compare(0, string_length);
- test_false(string);
-
- free(longkey);
+ test_zero(string_length);
}
}
/* Make sure zero length keys are marked as bad */
- set= 1;
- test_compare(MEMCACHED_SUCCESS,
- memcached_behavior_set(memc_clone, MEMCACHED_BEHAVIOR_VERIFY_KEY, set));
- string= memcached_get(memc_clone, key, 0,
- &string_length, &flags, &rc);
- test_compare(MEMCACHED_BAD_KEY_PROVIDED, rc);
- test_compare(0, string_length);
- test_false(string);
+ {
+ test_compare(MEMCACHED_SUCCESS,
+ memcached_behavior_set(memc_clone, MEMCACHED_BEHAVIOR_VERIFY_KEY, true));
+ size_t string_length;
+ char *string= memcached_get(memc_clone, key, 0,
+ &string_length, &flags, &rc);
+ test_compare(MEMCACHED_BAD_KEY_PROVIDED, rc);
+ test_zero(string_length);
+ test_false(string);
+ }
memcached_free(memc_clone);
return TEST_SUCCESS;
}
-static memcached_return_t delete_trigger(memcached_st *,
- const char *key,
- size_t key_length)
-{
- assert(key);
- assert(key_length);
-
- return MEMCACHED_SUCCESS;
-}
-
-static test_return_t delete_through(memcached_st *memc)
-{
- memcached_trigger_delete_key_fn callback;
- memcached_return_t rc;
-
- callback= (memcached_trigger_delete_key_fn)delete_trigger;
-
- rc= memcached_callback_set(memc, MEMCACHED_CALLBACK_DELETE_TRIGGER, *(void**)&callback);
- test_compare(MEMCACHED_SUCCESS, rc);
-
- return TEST_SUCCESS;
-}
-
static test_return_t get_test(memcached_st *memc)
{
memcached_return_t rc;
static test_return_t set_test2(memcached_st *memc)
{
- const char *key= "foo";
- const char *value= "train in the brain";
- size_t value_length= strlen(value);
-
for (uint32_t x= 0; x < 10; x++)
{
- memcached_return_t rc= memcached_set(memc, key, strlen(key),
- value, value_length,
- (time_t)0, (uint32_t)0);
+ memcached_return_t rc= memcached_set(memc,
+ test_literal_param("foo"),
+ test_literal_param("train in the brain"),
+ time_t(0), uint32_t(0));
test_true(rc == MEMCACHED_SUCCESS or rc == MEMCACHED_BUFFERED);
}
{
size_t value_length= 8191;
- char *value= (char*)malloc(value_length);
- test_true(value);
-
+ std::vector<char> value;
+ value.reserve(value_length);
for (uint32_t x= 0; x < value_length; x++)
{
- value[x] = (char) (x % 127);
+ value.push_back(char(x % 127));
}
/* The dump test relies on there being at least 32 items in memcached */
uint64_t query_id= memcached_query_id(memc);
memcached_return_t rc= memcached_set(memc, key, strlen(key),
- value, value_length,
+ &value[0], value.size(),
(time_t)0, (uint32_t)0);
- test_true(rc == MEMCACHED_SUCCESS || rc == MEMCACHED_BUFFERED);
+ test_true_got(rc == MEMCACHED_SUCCESS or rc == MEMCACHED_BUFFERED, memcached_strerror(NULL, rc));
test_compare(query_id +1, memcached_query_id(memc));
}
- free(value);
-
return TEST_SUCCESS;
}
const char *key= "foo";
size_t value_length= 8191;
- char *value= (char*)malloc(value_length);
- test_true(value);
-
+ std::vector<char> value;
+ value.reserve(value_length);
for (uint32_t x= 0; x < value_length; x++)
{
- value[x] = (char) (x % 127);
+ value.push_back(char(x % 127));
}
memcached_return_t rc;
rc= memcached_set(memc, key, strlen(key),
- value, value_length,
+ &value[0], value.size(),
(time_t)0, (uint32_t)0);
test_true(rc == MEMCACHED_SUCCESS or rc == MEMCACHED_BUFFERED);
test_compare(MEMCACHED_SUCCESS, rc);
test_true(string);
test_compare(string_length, value_length);
- test_memcmp(string, value, string_length);
+ test_memcmp(string, &value[0], string_length);
free(string);
- free(value);
return TEST_SUCCESS;
}
static test_return_t get_test4(memcached_st *memc)
{
- memcached_return_t rc;
const char *key= "foo";
- char *value;
size_t value_length= 8191;
- char *string;
- size_t string_length;
- uint32_t flags;
- uint32_t x;
- value = (char*)malloc(value_length);
- test_true(value);
-
- for (x= 0; x < value_length; x++)
- value[x] = (char) (x % 127);
+ std::vector<char> value;
+ value.reserve(value_length);
+ for (uint32_t x= 0; x < value_length; x++)
+ {
+ value.push_back(char(x % 127));
+ }
- rc= memcached_set(memc, key, strlen(key),
- value, value_length,
- (time_t)0, (uint32_t)0);
- test_true(rc == MEMCACHED_SUCCESS || rc == MEMCACHED_BUFFERED);
+ memcached_return_t rc= memcached_set(memc, key, strlen(key),
+ &value[0], value.size(),
+ (time_t)0, (uint32_t)0);
+ test_true(rc == MEMCACHED_SUCCESS or rc == MEMCACHED_BUFFERED);
- for (x= 0; x < 10; x++)
+ for (uint32_t x= 0; x < 10; x++)
{
- string= memcached_get(memc, key, strlen(key),
- &string_length, &flags, &rc);
+ uint32_t flags;
+ size_t string_length;
+ char *string= memcached_get(memc, key, strlen(key),
+ &string_length, &flags, &rc);
test_compare(MEMCACHED_SUCCESS, rc);
test_true(string);
test_compare(string_length, value_length);
- test_memcmp(string, value, string_length);
+ test_memcmp(string, &value[0], string_length);
free(string);
}
- free(value);
-
return TEST_SUCCESS;
}
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);
// this should indicate end
string= memcached_fetch(memc, key, &key_length, &string_length, &flags, &rc);
test_compare(MEMCACHED_END, rc);
+ test_null(string);
// now get just one
rc= memcached_mget(memc, keys, lengths, 1);
// this should indicate end
string= memcached_fetch(memc, key, &key_length, &string_length, &flags, &rc);
- test_true(rc == MEMCACHED_END);
+ test_compare(MEMCACHED_END, rc);
+ test_null(string);
return TEST_SUCCESS;
}
/* Do not copy the style of this code, I just access hosts to testthis function */
static test_return_t stats_servername_test(memcached_st *memc)
{
- memcached_return_t rc;
memcached_stat_st memc_stat;
memcached_server_instance_st instance=
memcached_server_instance_by_position(memc, 0);
-#ifdef LIBMEMCACHED_WITH_SASL_SUPPORT
- if (memcached_get_sasl_callbacks(memc) != NULL)
+ if (LIBMEMCACHED_WITH_SASL_SUPPORT and memcached_get_sasl_callbacks(memc))
+ {
return TEST_SKIPPED;
-#endif
- rc= memcached_stat_servername(&memc_stat, NULL,
- memcached_server_name(instance),
- memcached_server_port(instance));
+ }
+
+ test_compare(MEMCACHED_SUCCESS, memcached_stat_servername(&memc_stat, NULL,
+ memcached_server_name(instance),
+ memcached_server_port(instance)));
return TEST_SUCCESS;
}
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;
}
return TEST_SUCCESS;
}
+static test_return_t binary_increment_with_prefix_test(memcached_st *orig_memc)
+{
+ memcached_st *memc= memcached_clone(NULL, orig_memc);
+
+ test_skip(TEST_SUCCESS, pre_binary(memc));
+
+ test_compare(MEMCACHED_SUCCESS, memcached_callback_set(memc, MEMCACHED_CALLBACK_PREFIX_KEY, (void *)"namespace:"));
+
+ memcached_return_t rc;
+ rc= memcached_set(memc,
+ test_literal_param("number"),
+ test_literal_param("0"),
+ (time_t)0, (uint32_t)0);
+ test_true(rc == MEMCACHED_SUCCESS || rc == MEMCACHED_BUFFERED);
+
+ uint64_t 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(uint64_t(2), new_number);
+ memcached_free(memc);
+
+ return TEST_SUCCESS;
+}
static test_return_t quit_test(memcached_st *memc)
{
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_got(rc == MEMCACHED_SUCCESS or rc == MEMCACHED_BUFFERED, memcached_strerror(NULL, rc));
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;
}
rc= memcached_set(memc, keys[x], key_length[x],
keys[x], key_length[x],
(time_t)50, (uint32_t)9);
- test_true(rc == MEMCACHED_SUCCESS || rc == MEMCACHED_BUFFERED);
+ test_true_got(rc == MEMCACHED_SUCCESS or rc == MEMCACHED_BUFFERED, memcached_strerror(NULL, rc));
}
test_compare(MEMCACHED_SUCCESS,
rc= memcached_set(memc, keys[x], key_length[x],
keys[x], key_length[x],
(time_t)50, (uint32_t)9);
- test_true(rc == MEMCACHED_SUCCESS || rc == MEMCACHED_BUFFERED);
+ test_true_got(rc == MEMCACHED_SUCCESS or rc == MEMCACHED_BUFFERED, memcached_strerror(NULL, rc));
}
test_compare(MEMCACHED_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++)
{
rc= memcached_set(memc, keys[x], key_length[x],
keys[x], key_length[x],
(time_t)50, (uint32_t)9);
- test_true(rc == MEMCACHED_SUCCESS || rc == MEMCACHED_BUFFERED);
+ test_true_got(rc == MEMCACHED_SUCCESS or rc == MEMCACHED_BUFFERED, memcached_strerror(NULL, rc));
}
test_compare(MEMCACHED_SUCCESS,
memcached_mget(memc, keys, key_length, 3));
{
test_true(return_value);
test_compare(MEMCACHED_SUCCESS, rc);
- if (not memc->prefix_key)
+ if (not memc->_namespace)
{
test_compare(return_key_length, return_value_length);
test_memcmp(return_value, return_key, return_value_length);
test_true(keys[x] != NULL);
uint64_t query_id= memcached_query_id(memc);
rc= memcached_add(memc, keys[x], key_length[x], blob, sizeof(blob), 0, 0);
- test_true(rc == MEMCACHED_SUCCESS || rc == MEMCACHED_BUFFERED);
+ test_true_got(rc == MEMCACHED_SUCCESS or rc == MEMCACHED_BUFFERED, memcached_strerror(NULL, rc));
test_compare(query_id +1, memcached_query_id(memc));
}
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;
/* Do a large mget() over all the keys we think exist */
static test_return_t user_supplied_bug3(memcached_st *memc)
{
- unsigned int setter= 1;
- memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_NO_BLOCK, setter);
- memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_TCP_NODELAY, setter);
+ test_compare(MEMCACHED_SUCCESS, memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_NO_BLOCK, 1));
+ test_compare(MEMCACHED_SUCCESS, memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_TCP_NODELAY, 1));
+
#ifdef NOT_YET
setter = 20 * 1024576;
memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_SOCKET_SEND_SIZE, setter);
{
char key[MEMCACHED_MAXIMUM_INTEGER_DISPLAY_LENGTH +1];
int key_length= snprintf(key, sizeof(key), "%u", x);
+ test_true(key_length);
keys[x]= strdup(key);
test_true(keys[x]);
key_lengths[x]= key_length;
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++)
{
memcached_return_t rc;
value= memcached_get(memc, keys[0], key_length[0],
- &value_length, &flags, &rc);
+ &value_length, &flags, &rc);
test_false(value);
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)))
+ &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_get(memc, keys, key_length,
- &value_length, &flags, &rc);
+ &value_length, &flags, &rc);
test_true(flags == 245);
test_true(value);
free(value);
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;
}
/* We are testing with aggressive timeout to get failures */
static test_return_t user_supplied_bug10(memcached_st *memc)
{
- const char *key= "foo";
size_t value_length= 512;
- size_t key_len= 3;
unsigned int set= 1;
memcached_st *mclone= memcached_clone(NULL, memc);
memcached_behavior_set(mclone, MEMCACHED_BEHAVIOR_NO_BLOCK, set);
memcached_behavior_set(mclone, MEMCACHED_BEHAVIOR_TCP_NODELAY, set);
- int32_t timeout= 0;
- memcached_behavior_set(mclone, MEMCACHED_BEHAVIOR_POLL_TIMEOUT, (uint64_t)timeout);
-
- char *value= (char*)malloc(value_length * sizeof(char));
+ memcached_behavior_set(mclone, MEMCACHED_BEHAVIOR_POLL_TIMEOUT, uint64_t(0));
- for (unsigned int x= 0; x < value_length; x++)
+ std::vector<char> value;
+ value.reserve(value_length);
+ for (uint32_t x= 0; x < value_length; x++)
{
- value[x]= (char) (x % 127);
+ value.push_back(char(x % 127));
}
for (unsigned int x= 1; x <= 100000; ++x)
{
- memcached_return_t rc= memcached_set(mclone, key, key_len,value, value_length, 0, 0);
+ memcached_return_t rc= memcached_set(mclone,
+ test_literal_param("foo"),
+ &value[0], value.size(),
+ 0, 0);
- test_true_got(rc == MEMCACHED_SUCCESS or rc == MEMCACHED_WRITE_FAILURE or rc == MEMCACHED_BUFFERED or rc == MEMCACHED_TIMEOUT or rc == MEMCACHED_CONNECTION_FAILURE,
+ test_true_got((rc == MEMCACHED_SUCCESS or rc == MEMCACHED_WRITE_FAILURE or rc == MEMCACHED_BUFFERED or rc == MEMCACHED_TIMEOUT or rc == MEMCACHED_CONNECTION_FAILURE
+ or rc == MEMCACHED_SERVER_TEMPORARILY_DISABLED),
memcached_strerror(NULL, rc));
if (rc == MEMCACHED_WRITE_FAILURE or rc == MEMCACHED_TIMEOUT)
}
}
- free(value);
memcached_free(mclone);
return TEST_SUCCESS;
*/
static test_return_t user_supplied_bug11(memcached_st *memc)
{
- const char *key= "foo";
- size_t value_length= 512;
- size_t key_len= 3;
- unsigned int set= 1;
memcached_st *mclone= memcached_clone(NULL, memc);
- memcached_behavior_set(mclone, MEMCACHED_BEHAVIOR_NO_BLOCK, set);
- memcached_behavior_set(mclone, MEMCACHED_BEHAVIOR_TCP_NODELAY, set);
- int32_t timeout= -1;
- memcached_behavior_set(mclone, MEMCACHED_BEHAVIOR_POLL_TIMEOUT, (size_t)timeout);
-
- timeout= (int32_t)memcached_behavior_get(mclone, MEMCACHED_BEHAVIOR_POLL_TIMEOUT);
+ memcached_behavior_set(mclone, MEMCACHED_BEHAVIOR_NO_BLOCK, true);
+ memcached_behavior_set(mclone, MEMCACHED_BEHAVIOR_TCP_NODELAY, true);
+ memcached_behavior_set(mclone, MEMCACHED_BEHAVIOR_POLL_TIMEOUT, size_t(-1));
- test_true(timeout == -1);
+ test_compare(-1, int32_t(memcached_behavior_get(mclone, MEMCACHED_BEHAVIOR_POLL_TIMEOUT)));
- char *value= (char*)malloc(value_length * sizeof(char));
- for (unsigned int x= 0; x < value_length; x++)
+ std::vector<char> value;
+ value.reserve(512);
+ for (unsigned int x= 0; x < 512; x++)
{
- value[x]= (char) (x % 127);
+ value.push_back(char(x % 127));
}
for (unsigned int x= 1; x <= 100000; ++x)
{
- memcached_return_t rc= memcached_set(mclone, key, key_len,value, value_length, 0, 0);
+ memcached_return_t rc= memcached_set(mclone, test_literal_param("foo"), &value[0], value.size(), 0, 0);
(void)rc;
}
- free(value);
memcached_free(mclone);
return TEST_SUCCESS;
uint64_t number_value;
value= memcached_get(memc, "autoincrement", strlen("autoincrement"),
- &value_length, &flags, &rc);
+ &value_length, &flags, &rc);
test_true(value == NULL);
test_compare(MEMCACHED_NOTFOUND, rc);
rc= memcached_increment(memc, "autoincrement", strlen("autoincrement"),
1, &number_value);
-
test_true(value == NULL);
/* The binary protocol will set the key if it doesn't exist */
if (memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL) == 1)
rc= memcached_set(memc, "autoincrement", strlen("autoincrement"), "1", 1, 0, 0);
value= memcached_get(memc, "autoincrement", strlen("autoincrement"),
- &value_length, &flags, &rc);
+ &value_length, &flags, &rc);
test_true(value);
test_compare(MEMCACHED_SUCCESS, rc);
free(value);
/*
Bug found where command total one more than MEMCACHED_MAX_BUFFER
set key34567890 0 0 8169 \r\n is sent followed by buffer of size 8169, followed by 8169
- */
+*/
static test_return_t user_supplied_bug13(memcached_st *memc)
{
char key[] = "key34567890";
Bug found where command total one more than MEMCACHED_MAX_BUFFER
set key34567890 0 0 8169 \r\n
is sent followed by buffer of size 8169, followed by 8169
- */
+*/
static test_return_t user_supplied_bug14(memcached_st *memc)
{
- size_t setter= 1;
- memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_TCP_NODELAY, setter);
- memcached_return_t rc;
- const char *key= "foo";
- char *value;
- size_t value_length= 18000;
- char *string;
- size_t string_length;
- uint32_t flags;
- unsigned int x;
- size_t current_length;
-
- value = (char*)malloc(value_length);
- test_true(value);
+ memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_TCP_NODELAY, true);
- for (x= 0; x < value_length; x++)
- value[x] = (char) (x % 127);
+ std::vector<char> value;
+ value.reserve(18000);
+ for (size_t x= 0; x < 18000; x++)
+ {
+ value.push_back((char) (x % 127));
+ }
- for (current_length= 0; current_length < value_length; current_length++)
+ for (size_t current_length= 0; current_length < value.size(); current_length++)
{
- rc= memcached_set(memc, key, strlen(key),
- value, current_length,
- (time_t)0, (uint32_t)0);
- test_true(rc == MEMCACHED_SUCCESS || rc == MEMCACHED_BUFFERED);
+ memcached_return_t rc= memcached_set(memc, test_literal_param("foo"),
+ &value[0], current_length,
+ (time_t)0, (uint32_t)0);
+ test_true(rc == MEMCACHED_SUCCESS or rc == MEMCACHED_BUFFERED);
- string= memcached_get(memc, key, strlen(key),
- &string_length, &flags, &rc);
+ size_t string_length;
+ uint32_t flags;
+ char *string= memcached_get(memc, test_literal_param("foo"),
+ &string_length, &flags, &rc);
test_compare(MEMCACHED_SUCCESS, rc);
- test_true(string_length == current_length);
- test_memcmp(string, value, string_length);
+ test_compare(string_length, current_length);
+ test_memcmp(string, &value[0], string_length);
free(string);
}
- free(value);
-
return TEST_SUCCESS;
}
/*
Look for zero length value problems
- */
+*/
static test_return_t user_supplied_bug15(memcached_st *memc)
{
- uint32_t x;
- memcached_return_t rc;
- const char *key= "mykey";
- size_t length;
- uint32_t flags;
-
- for (x= 0; x < 2; x++)
+ for (uint32_t x= 0; x < 2; x++)
{
- rc= memcached_set(memc, key, strlen(key),
- NULL, 0,
- (time_t)0, (uint32_t)0);
+ memcached_return_t rc= memcached_set(memc, test_literal_param("mykey"),
+ NULL, 0,
+ (time_t)0, (uint32_t)0);
test_compare(MEMCACHED_SUCCESS, rc);
- char *value= memcached_get(memc, key, strlen(key),
+ size_t length;
+ uint32_t flags;
+ char *value= memcached_get(memc, test_literal_param("mykey"),
&length, &flags, &rc);
test_compare(MEMCACHED_SUCCESS, rc);
test_false(value);
- test_false(length);
- test_false(flags);
+ test_zero(length);
+ test_zero(flags);
- value= memcached_get(memc, key, strlen(key),
+ value= memcached_get(memc, test_literal_param("mykey"),
&length, &flags, &rc);
test_compare(MEMCACHED_SUCCESS, rc);
test_true(value == NULL);
- test_true(length == 0);
- test_true(flags == 0);
+ test_zero(length);
+ test_zero(flags);
}
return TEST_SUCCESS;
/* Check the return sizes on FLAGS to make sure it stores 32bit unsigned values correctly */
static test_return_t user_supplied_bug16(memcached_st *memc)
{
- memcached_return_t rc;
- const char *key= "mykey";
- char *value;
- size_t length;
- uint32_t flags;
-
- rc= memcached_set(memc, key, strlen(key),
- NULL, 0,
- (time_t)0, UINT32_MAX);
+ memcached_return_t rc= memcached_set(memc, test_literal_param("mykey"),
+ NULL, 0,
+ (time_t)0, UINT32_MAX);
test_compare(MEMCACHED_SUCCESS, rc);
- value= memcached_get(memc, key, strlen(key),
- &length, &flags, &rc);
+ size_t length;
+ uint32_t flags;
+ char *value= memcached_get(memc, test_literal_param("mykey"),
+ &length, &flags, &rc);
test_compare(MEMCACHED_SUCCESS, rc);
test_true(value == NULL);
- test_true(length == 0);
- test_true(flags == UINT32_MAX);
+ test_zero(length);
+ test_compare(flags, UINT32_MAX);
return TEST_SUCCESS;
}
/* Check the validity of chinese key*/
static test_return_t user_supplied_bug17(memcached_st *memc)
{
- memcached_return_t rc;
- const char *key= "豆瓣";
- const char *value="我们在炎热抑郁的夏天无法停止豆瓣";
- char *value2;
- size_t length;
- uint32_t flags;
+ const char *key= "豆瓣";
+ const char *value="我们在炎热抑郁的夏天无法停止豆瓣";
+ memcached_return_t rc= memcached_set(memc, key, strlen(key),
+ value, strlen(value),
+ (time_t)0, 0);
- rc= memcached_set(memc, key, strlen(key),
- value, strlen(value),
- (time_t)0, 0);
+ test_compare(MEMCACHED_SUCCESS, rc);
- test_compare(MEMCACHED_SUCCESS, rc);
-
- value2= memcached_get(memc, key, strlen(key),
- &length, &flags, &rc);
+ size_t length;
+ uint32_t flags;
+ char *value2= memcached_get(memc, key, strlen(key),
+ &length, &flags, &rc);
- test_true(length==strlen(value));
- test_compare(MEMCACHED_SUCCESS, rc);
- test_memcmp(value, value2, length);
- free(value2);
+ test_true(length==strlen(value));
+ test_compare(MEMCACHED_SUCCESS, rc);
+ test_memcmp(value, value2, length);
+ free(value2);
- return TEST_SUCCESS;
+ return TEST_SUCCESS;
}
#endif
From Andrei on IRC
*/
-static test_return_t user_supplied_bug19(memcached_st *not_used)
+static test_return_t user_supplied_bug19(memcached_st *)
{
- memcached_st *memc;
- const memcached_server_st *server;
memcached_return_t res;
- (void)not_used;
-
- memc= memcached_create(NULL);
- memcached_server_add_with_weight(memc, "localhost", 11311, 100);
- memcached_server_add_with_weight(memc, "localhost", 11312, 100);
+ memcached_st *memc= memcached(test_literal_param("--server=localhost:11311/?100 --server=localhost:11312/?100"));
- server= memcached_server_by_key(memc, "a", 1, &res);
+ const memcached_server_st *server= memcached_server_by_key(memc, "a", 1, &res);
+ test_true(server);
memcached_free(memc);
/* CAS test from Andei */
static test_return_t user_supplied_bug20(memcached_st *memc)
{
- memcached_return_t status;
- memcached_result_st *result, result_obj;
- const char *key = "abc";
- size_t key_len = strlen("abc");
- const char *value = "foobar";
- size_t value_len = strlen(value);
+ const char *key= "abc";
+ size_t key_len= strlen("abc");
- memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_SUPPORT_CAS, 1);
+ test_skip(MEMCACHED_SUCCESS, memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_SUPPORT_CAS, true));
- status = memcached_set(memc, key, key_len, value, value_len, (time_t)0, (uint32_t)0);
- test_true(status == MEMCACHED_SUCCESS);
+ test_compare(MEMCACHED_SUCCESS,
+ memcached_set(memc,
+ test_literal_param("abc"),
+ test_literal_param("foobar"),
+ (time_t)0, (uint32_t)0));
- status = memcached_mget(memc, &key, &key_len, 1);
- test_true(status == MEMCACHED_SUCCESS);
+ test_compare(MEMCACHED_SUCCESS,
+ memcached_mget(memc, &key, &key_len, 1));
- result= memcached_result_create(memc, &result_obj);
+ memcached_result_st result_obj;
+ memcached_result_st *result= memcached_result_create(memc, &result_obj);
test_true(result);
memcached_result_create(memc, &result_obj);
+ memcached_return_t status;
result= memcached_fetch_result(memc, &result_obj, &status);
test_true(result);
- test_true(status == MEMCACHED_SUCCESS);
+ test_compare(MEMCACHED_SUCCESS, status);
memcached_result_free(result);
return TEST_SUCCESS;
}
-#include "ketama_test_cases.h"
-static test_return_t user_supplied_bug18(memcached_st *trash)
-{
- memcached_return_t rc;
- uint64_t value;
- int x;
- memcached_st *memc;
-
- (void)trash;
-
- memc= memcached_create(NULL);
- test_true(memc);
-
- rc= memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_KETAMA_WEIGHTED, 1);
- test_compare(MEMCACHED_SUCCESS, rc);
-
- value= memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_KETAMA_WEIGHTED);
- test_true(value == 1);
-
- rc= memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_KETAMA_HASH, MEMCACHED_HASH_MD5);
- test_compare(MEMCACHED_SUCCESS, rc);
-
- value= memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_KETAMA_HASH);
- test_true(value == MEMCACHED_HASH_MD5);
-
- 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_true(memcached_server_count(memc) == 8);
- test_strcmp(server_pool[0].hostname, "10.0.1.1");
- test_true(server_pool[0].port == 11211);
- test_true(server_pool[0].weight == 600);
- test_strcmp(server_pool[2].hostname, "10.0.1.3");
- test_true(server_pool[2].port == 11211);
- test_true(server_pool[2].weight == 200);
- test_strcmp(server_pool[7].hostname, "10.0.1.8");
- test_true(server_pool[7].port == 11211);
- test_true(server_pool[7].weight == 100);
-
- /* VDEAAAAA hashes to fffcd1b5, after the last continuum point, and lets
- * us test the boundary wraparound.
- */
- test_true(memcached_generate_hash(memc, (char *)"VDEAAAAA", 8) == memc->ketama.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));
-
- memcached_server_instance_st instance=
- memcached_server_instance_by_position(memc, server_idx);
-
- const char *hostname = memcached_server_name(instance);
- test_strcmp(hostname, ketama_test_cases[x].server);
- }
-
- memcached_server_list_free(server_pool);
- memcached_free(memc);
-
- return TEST_SUCCESS;
-}
-
/* Large mget() of missing keys with binary proto
*
* If many binary quiet commands (such as getq's in an mget) fill the output
test_true(memc_clone);
/* only binproto uses getq for mget */
- test_compare(MEMCACHED_SUCCESS, memcached_behavior_set(memc_clone, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL, 1));
+ test_compare(MEMCACHED_SUCCESS, memcached_behavior_set(memc_clone, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL, true));
/* empty the cache to ensure misses (hence non-responses) */
test_compare(MEMCACHED_SUCCESS, memcached_flush(memc_clone, 0));
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);
static test_return_t user_supplied_bug21(memcached_st *memc)
{
- test_return_t test_rc;
- test_rc= pre_binary(memc);
-
- if (test_rc != TEST_SUCCESS)
- return test_rc;
+ test_skip(TEST_SUCCESS, pre_binary(memc));
/* should work as of r580 */
test_compare(TEST_SUCCESS,
return TEST_SUCCESS;
}
-static test_return_t auto_eject_hosts(memcached_st *trash)
-{
- (void) trash;
- memcached_server_instance_st instance;
-
- memcached_return_t rc;
- memcached_st *memc= memcached_create(NULL);
- test_true(memc);
-
- rc= memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_KETAMA_WEIGHTED, 1);
- test_compare(MEMCACHED_SUCCESS, rc);
-
- uint64_t value= memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_KETAMA_WEIGHTED);
- test_true(value == 1);
-
- rc= memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_KETAMA_HASH, MEMCACHED_HASH_MD5);
- test_compare(MEMCACHED_SUCCESS, rc);
-
- value= memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_KETAMA_HASH);
- test_true(value == MEMCACHED_HASH_MD5);
-
- /* server should be removed when in delay */
- rc= memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_AUTO_EJECT_HOSTS, 1);
- test_compare(MEMCACHED_SUCCESS, rc);
-
- value= memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_AUTO_EJECT_HOSTS);
- test_true(value == 1);
-
- memcached_server_st *server_pool;
- 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_true(memcached_server_count(memc) == 8);
- test_strcmp(server_pool[0].hostname, "10.0.1.1");
- test_true(server_pool[0].port == 11211);
- test_true(server_pool[0].weight == 600);
- test_strcmp(server_pool[2].hostname, "10.0.1.3");
- test_true(server_pool[2].port == 11211);
- test_true(server_pool[2].weight == 200);
- test_strcmp(server_pool[7].hostname, "10.0.1.8");
- test_true(server_pool[7].port == 11211);
- test_true(server_pool[7].weight == 100);
-
- instance= memcached_server_instance_by_position(memc, 2);
- ((memcached_server_write_instance_st)instance)->next_retry = time(NULL) + 15;
- memc->ketama.next_distribution_rebuild= time(NULL) - 1;
-
- /*
- This would not work if there were only two hosts.
- */
- for (size_t x= 0; x < 99; x++)
- {
- memcached_autoeject(memc);
- uint32_t server_idx= memcached_generate_hash(memc, ketama_test_cases[x].key, strlen(ketama_test_cases[x].key));
- test_true(server_idx != 2);
- }
-
- /* and re-added when it's back. */
- ((memcached_server_write_instance_st)instance)->next_retry = time(NULL) - 1;
- memc->ketama.next_distribution_rebuild= time(NULL) - 1;
- memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_DISTRIBUTION,
- memc->distribution);
- for (size_t x= 0; x < 99; x++)
- {
- uint32_t server_idx = memcached_generate_hash(memc, ketama_test_cases[x].key, strlen(ketama_test_cases[x].key));
- // We re-use instance from above.
- instance=
- memcached_server_instance_by_position(memc, server_idx);
- const char *hostname = memcached_server_name(instance);
- test_strcmp(hostname, ketama_test_cases[x].server);
- }
-
- memcached_server_list_free(server_pool);
- memcached_free(memc);
-
- return TEST_SUCCESS;
-}
-
-static test_return_t output_ketama_weighted_keys(memcached_st *trash)
+static test_return_t output_ketama_weighted_keys(memcached_st *)
{
- (void) trash;
-
- memcached_return_t rc;
memcached_st *memc= memcached_create(NULL);
test_true(memc);
- rc= memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_KETAMA_WEIGHTED, 1);
- test_compare(MEMCACHED_SUCCESS, rc);
+ test_compare(MEMCACHED_SUCCESS,
+ memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_KETAMA_WEIGHTED, true));
uint64_t value= memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_KETAMA_WEIGHTED);
- test_true(value == 1);
+ test_compare(value, uint64_t(1));
- rc= memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_KETAMA_HASH, MEMCACHED_HASH_MD5);
- test_compare(MEMCACHED_SUCCESS, rc);
+ test_compare(MEMCACHED_SUCCESS,
+ memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_KETAMA_HASH, MEMCACHED_HASH_MD5));
value= memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_KETAMA_HASH);
test_true(value == MEMCACHED_HASH_MD5);
static test_return_t result_static(memcached_st *memc)
{
memcached_result_st result;
- memcached_result_st *result_ptr;
-
- result_ptr= memcached_result_create(memc, &result);
- test_true(result.options.is_allocated == false);
- test_true(memcached_is_initialized(&result) == true);
+ memcached_result_st *result_ptr= memcached_result_create(memc, &result);
+ test_false(result.options.is_allocated);
+ test_true(memcached_is_initialized(&result));
test_true(result_ptr);
test_true(result_ptr == &result);
memcached_result_free(&result);
- test_true(result.options.is_allocated == false);
- test_true(memcached_is_initialized(&result) == false);
+ test_false(result.options.is_allocated);
+ test_false(memcached_is_initialized(&result));
return TEST_SUCCESS;
}
static test_return_t result_alloc(memcached_st *memc)
{
- memcached_result_st *result_ptr;
-
- result_ptr= memcached_result_create(memc, NULL);
+ memcached_result_st *result_ptr= memcached_result_create(memc, NULL);
test_true(result_ptr);
- test_true(result_ptr->options.is_allocated == true);
- test_true(memcached_is_initialized(result_ptr) == true);
+ test_true(result_ptr->options.is_allocated);
+ test_true(memcached_is_initialized(result_ptr));
memcached_result_free(result_ptr);
return TEST_SUCCESS;
return TEST_SUCCESS;
}
-static test_return_t generate_pairs(memcached_st *memc)
+static test_return_t generate_pairs(memcached_st *)
{
- (void)memc;
global_pairs= pairs_generate(GLOBAL_COUNT, 400);
global_count= GLOBAL_COUNT;
{
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;
}
for (host_index= 0; host_index < SERVERS_TO_CREATE; host_index++)
{
/* This test was changes so that "make test" would work properlly */
-#ifdef DEBUG
- memcached_server_instance_st instance=
- memcached_server_instance_by_position(memc, host_index);
+ if (DEBUG)
+ {
+ memcached_server_instance_st instance=
+ memcached_server_instance_by_position(memc, host_index);
- printf("\nserver %u|%s|%u bytes: %llu\n", host_index, instance->hostname, instance->port, (unsigned long long)(stat_p + host_index)->bytes);
-#endif
+ printf("\nserver %u|%s|%u bytes: %llu\n", host_index, instance->hostname, instance->port, (unsigned long long)(stat_p + host_index)->bytes);
+ }
test_true((unsigned long long)(stat_p + host_index)->bytes);
}
}
static test_return_t generate_buffer_data(memcached_st *memc)
{
- size_t latch= 0;
-
- latch= 1;
- memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_BUFFER_REQUESTS, latch);
+ memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_BUFFER_REQUESTS, true);
generate_data(memc);
return TEST_SUCCESS;
{
count++;
if (return_value)
+ {
free(return_value);
+ }
}
}
}
test_compare(MEMCACHED_SUCCESS, rc);
*/
if (rc == MEMCACHED_SUCCESS && return_value)
+ {
free(return_value);
+ }
}
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_warn_hint(global_count, keys_returned, "Possible false, positive, memcached may have ejected key/value based on memory needs");
}
return TEST_SUCCESS;
{
memcached_result_st results_obj;
memcached_result_st *results= memcached_result_create(memc, &results_obj);
+ test_true(results);
memcached_return_t rc;
while ((results= memcached_fetch_result(memc, &results_obj, &rc)))
{
+ if (rc == MEMCACHED_IN_PROGRESS)
+ {
+ continue;
+ }
+
test_true(results);
test_compare(MEMCACHED_SUCCESS, rc);
}
{
memcached_result_st results_obj;
memcached_result_st *results= memcached_result_create(memc, &results_obj);
+ test_true(results);
+ test_false(memcached_is_allocated(results));
memcached_return_t rc;
while ((results= memcached_fetch_result(memc, &results_obj, &rc)))
static test_return_t delete_buffer_generate(memcached_st *memc)
{
- uint64_t latch= 1;
- memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_BUFFER_REQUESTS, latch);
+ memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_BUFFER_REQUESTS, true);
for (size_t x= 0; x < global_count; x++)
{
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];
snprintf(buffer, SMALL_STRING_LEN, "%lu.example.com", (unsigned long)(400 +x));
servers= memcached_server_list_append_with_weight(servers, buffer, 401, 0,
- &rc);
+ &rc);
test_compare(MEMCACHED_SUCCESS, rc);
test_compare(x, memcached_server_list_count(servers));
}
static test_return_t pre_nonblock_binary(memcached_st *memc)
{
- memcached_return_t rc= MEMCACHED_FAILURE;
- memcached_st *memc_clone;
-
- memc_clone= memcached_clone(NULL, memc);
+ memcached_st *memc_clone= memcached_clone(NULL, memc);
test_true(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_return_t rc= MEMCACHED_FAILURE;
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);
- test_compare(MEMCACHED_SUCCESS, rc);
- test_true(memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL) == 1);
+ test_compare(MEMCACHED_SUCCESS,
+ memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL, 1));
+ test_compare(uint64_t(1), memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL));
}
else
{
+ memcached_free(memc_clone);
return TEST_SKIPPED;
}
static test_return_t pre_murmur(memcached_st *memc)
{
-#ifdef HAVE_MURMUR_HASH
- memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_HASH, (uint64_t)MEMCACHED_HASH_MURMUR);
+ test_skip(MEMCACHED_SUCCESS, memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_HASH, (uint64_t)MEMCACHED_HASH_MURMUR));
return TEST_SUCCESS;
-#else
- (void) memc;
- return TEST_SKIPPED;
-#endif
}
static test_return_t pre_jenkins(memcached_st *memc)
static test_return_t pre_hsieh(memcached_st *memc)
{
-#ifdef HAVE_HSIEH_HASH
- memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_HASH, (uint64_t)MEMCACHED_HASH_HSIEH);
+ test_skip(MEMCACHED_SUCCESS, memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_HASH, (uint64_t)MEMCACHED_HASH_HSIEH));
return TEST_SUCCESS;
-#else
- (void) memc;
- return TEST_SKIPPED;
-#endif
}
static test_return_t pre_hash_fnv1_64(memcached_st *memc)
{
- memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_HASH, (uint64_t)MEMCACHED_HASH_MURMUR);
+ test_skip(MEMCACHED_SUCCESS, memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_HASH, (uint64_t)MEMCACHED_HASH_MURMUR));
return TEST_SUCCESS;
}
static test_return_t pre_hash_fnv1a_64(memcached_st *memc)
{
- memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_HASH, (uint64_t)MEMCACHED_HASH_FNV1A_64);
+ test_skip(MEMCACHED_SUCCESS, memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_HASH, (uint64_t)MEMCACHED_HASH_FNV1A_64));
return TEST_SUCCESS;
}
test_compare(MEMCACHED_SUCCESS, rc);
uint64_t value= memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_KETAMA);
- test_true(value == 1);
+ test_compare(value, uint64_t(1));
return TEST_SUCCESS;
}
test_compare(MEMCACHED_SUCCESS, rc);
uint64_t value= memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_KETAMA_WEIGHTED);
- test_true(value == 1);
+ test_compare(value, uint64_t(1));
- rc= memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_KETAMA_HASH, MEMCACHED_HASH_MD5);
- test_compare(MEMCACHED_SUCCESS, rc);
+ test_compare(MEMCACHED_SUCCESS,
+ memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_KETAMA_HASH, MEMCACHED_HASH_MD5));
value= memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_KETAMA_HASH);
- test_true(value == MEMCACHED_HASH_MD5);
+ test_compare(MEMCACHED_HASH_MD5, memcached_hash_t(value));
return TEST_SUCCESS;
}
-/**
- @note This should be testing to see if the server really supports the binary protocol.
-*/
-static test_return_t pre_binary(memcached_st *memc)
-{
- memcached_return_t rc= MEMCACHED_FAILURE;
-
- if (libmemcached_util_version_check(memc, 1, 4, 4))
- {
- rc = memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL, 1);
- test_compare(MEMCACHED_SUCCESS, rc);
- test_true(memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL) == 1);
- }
-
- return rc == MEMCACHED_SUCCESS ? TEST_SUCCESS : TEST_SKIPPED;
-}
-
-static test_return_t pre_sasl(memcached_st *memc)
-{
- memcached_return_t rc= MEMCACHED_FAILURE;
-
-#ifdef LIBMEMCACHED_WITH_SASL_SUPPORT
- const char *server= getenv("LIBMEMCACHED_TEST_SASL_SERVER");
- const char *user= getenv("LIBMEMCACHED_TEST_SASL_USERNAME");
- const char *pass= getenv("LIBMEMCACHED_TEST_SASL_PASSWORD");
-
- if (server and user and pass)
- {
- memcached_server_st *servers= memcached_servers_parse(server);
- test_true(servers);
- memcached_servers_reset(memc);
- test_true(memcached_server_push(memc, servers) == MEMCACHED_SUCCESS);
- memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL, 1);
- rc= memcached_set_sasl_auth_data(memc, user, pass);
- test_compare(MEMCACHED_SUCCESS, rc);
- }
-#else
- (void)memc;
-#endif
-
- return rc == MEMCACHED_SUCCESS ? TEST_SUCCESS : TEST_SKIPPED;
-}
-
static test_return_t pre_replication(memcached_st *memc)
{
test_skip(TEST_SUCCESS, pre_binary(memc));
/*
* 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;
}
/* Make sure be default none exists */
value= (char*)memcached_callback_get(memc, MEMCACHED_CALLBACK_NAMESPACE, &rc);
- test_compare_got(MEMCACHED_FAILURE, rc, memcached_strerror(NULL, rc));
+ test_null(value);
+ test_compare_got(MEMCACHED_SUCCESS, rc, memcached_strerror(NULL, rc));
/* Test a clean set */
test_compare(MEMCACHED_SUCCESS,
memcached_callback_set(memc, MEMCACHED_CALLBACK_NAMESPACE, NULL));
value= (char*)memcached_callback_get(memc, MEMCACHED_CALLBACK_NAMESPACE, &rc);
- test_false(value);
- test_compare_got(MEMCACHED_FAILURE, rc, memcached_strerror(NULL, rc));
+ test_null(value);
+ test_compare_got(MEMCACHED_SUCCESS, rc, memcached_strerror(NULL, rc));
/* Now setup for main test */
test_compare(MEMCACHED_SUCCESS,
memcached_callback_set(memc, MEMCACHED_CALLBACK_NAMESPACE, NULL));
value= (char*)memcached_callback_get(memc, MEMCACHED_CALLBACK_NAMESPACE, &rc);
- test_false(value);
- test_true(rc == MEMCACHED_FAILURE);
- test_true(value == NULL);
+ test_null(value);
+ test_compare(MEMCACHED_SUCCESS, rc);
/* Test a long key for failure */
/* TODO, extend test to determine based on setting, what result should be */
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"));
const char *key= "mine";
char *value;
- /* Make sure be default none exists */
+ // Make sure we default to a null namespace
value= (char*)memcached_callback_get(memc, MEMCACHED_CALLBACK_NAMESPACE, &rc);
- test_compare_got(MEMCACHED_FAILURE, rc, memcached_strerror(NULL, rc));
+ test_null(value);
+ test_compare_got(MEMCACHED_SUCCESS, rc, memcached_strerror(NULL, rc));
/* Test a clean set */
test_compare(MEMCACHED_SUCCESS,
static test_return_t set_memory_alloc(memcached_st *memc)
{
- test_compare(MEMCACHED_FAILURE,
+ test_compare(MEMCACHED_INVALID_ARGUMENTS,
memcached_set_memory_allocators(memc, NULL, my_free,
my_realloc, my_calloc, NULL));
memcached_hash_t hash;
memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_DISTRIBUTION, value);
if ((rc= pre_hsieh(memc)) != TEST_SUCCESS)
+ {
return rc;
+ }
value= (memcached_server_distribution_t)memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_DISTRIBUTION);
test_true(value == MEMCACHED_DISTRIBUTION_CONSISTENT);
memcached_server_instance_by_position(memc, 0);
if ((instance->major_version >= 1 && (instance->minor_version == 2 && instance->micro_version >= 4))
- || instance->minor_version > 2)
+ or instance->minor_version > 2)
{
return TEST_SUCCESS;
}
static test_return_t pre_unix_socket(memcached_st *memc)
{
- memcached_return_t rc;
struct stat buf;
memcached_servers_reset(memc);
+ const char *socket_file= default_socket();
- if (stat("/tmp/memcached.socket", &buf))
- return TEST_SKIPPED;
+ test_skip(0, stat(socket_file, &buf));
- rc= memcached_server_add_unix_socket_with_weight(memc, "/tmp/memcached.socket", 0);
+ test_compare(MEMCACHED_SUCCESS,
+ memcached_server_add_unix_socket_with_weight(memc, socket_file, 0));
- return ( rc == MEMCACHED_SUCCESS ? TEST_SUCCESS : TEST_FAILURE );
+ return TEST_SUCCESS;
}
static test_return_t pre_nodelay(memcached_st *memc)
return TEST_SUCCESS;
}
-static test_return_t poll_timeout(memcached_st *memc)
+static test_return_t MEMCACHED_BEHAVIOR_POLL_TIMEOUT_test(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;
}
static test_return_t noreply_test(memcached_st *memc)
{
+ test_compare(MEMCACHED_SUCCESS,
+ memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_NOREPLY, 1));
+ test_compare(MEMCACHED_SUCCESS,
+ memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_BUFFER_REQUESTS, 1));
+ test_compare(MEMCACHED_SUCCESS,
+ memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_SUPPORT_CAS, 1));
+ test_compare(1LLU, memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_NOREPLY));
+ test_compare(1LLU, memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_BUFFER_REQUESTS));
+ test_compare(1LLU, memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_SUPPORT_CAS));
+
memcached_return_t ret;
- ret= memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_NOREPLY, 1);
- test_true(ret == MEMCACHED_SUCCESS);
- ret= memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_BUFFER_REQUESTS, 1);
- test_true(ret == MEMCACHED_SUCCESS);
- ret= memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_SUPPORT_CAS, 1);
- test_true(ret == MEMCACHED_SUCCESS);
- test_true(memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_NOREPLY) == 1);
- test_true(memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_BUFFER_REQUESTS) == 1);
- test_true(memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_SUPPORT_CAS) == 1);
-
- for (int count=0; count < 5; ++count)
+ for (int count= 0; count < 5; ++count)
{
for (size_t x= 0; x < 100; ++x)
{
test_true(count);
break;
}
- test_true(ret == MEMCACHED_SUCCESS || ret == MEMCACHED_BUFFERED);
+ test_true_got(ret == MEMCACHED_SUCCESS or ret == MEMCACHED_BUFFERED, memcached_strerror(NULL, ret));
}
/*
- ** NOTE: Don't ever do this in your code! this is not a supported use of the
- ** API and is _ONLY_ done this way to verify that the library works the
- ** way it is supposed to do!!!!
- */
+ ** NOTE: Don't ever do this in your code! this is not a supported use of the
+ ** API and is _ONLY_ done this way to verify that the library works the
+ ** way it is supposed to do!!!!
+ */
int no_msg=0;
for (uint32_t x= 0; x < memcached_server_count(memc); ++x)
{
}
test_true(no_msg == 0);
- test_true(memcached_flush_buffers(memc) == MEMCACHED_SUCCESS);
+ test_compare(MEMCACHED_SUCCESS, memcached_flush_buffers(memc));
/*
** Now validate that all items was set properly!
- */
+ */
for (size_t x= 0; x < 100; ++x)
{
char key[10];
uint32_t flags;
char* value=memcached_get(memc, key, strlen(key),
&length, &flags, &ret);
- test_true(ret == MEMCACHED_SUCCESS && value != NULL);
+ test_true_got(ret == MEMCACHED_SUCCESS && value != NULL, memcached_strerror(NULL, ret));
switch (count)
{
case 0: /* FALLTHROUGH */
/* Try setting an illegal cas value (should not return an error to
* the caller (because we don't expect a return message from the server)
- */
+ */
const char* keys[]= {"0"};
size_t lengths[]= {1};
size_t length;
uint32_t flags;
memcached_result_st results_obj;
memcached_result_st *results;
- ret= memcached_mget(memc, keys, lengths, 1);
- test_true(ret == MEMCACHED_SUCCESS);
+ test_compare(MEMCACHED_SUCCESS,
+ memcached_mget(memc, keys, lengths, 1));
results= memcached_result_create(memc, &results_obj);
test_true(results);
results= memcached_fetch_result(memc, &results_obj, &ret);
test_true(results);
- test_true(ret == MEMCACHED_SUCCESS);
+ test_compare(MEMCACHED_SUCCESS, ret);
uint64_t cas= memcached_result_cas(results);
memcached_result_free(&results_obj);
- ret= memcached_cas(memc, keys[0], lengths[0], keys[0], lengths[0], 0, 0, cas);
- test_true(ret == MEMCACHED_SUCCESS);
+ test_compare(MEMCACHED_SUCCESS,
+ memcached_cas(memc, keys[0], lengths[0], keys[0], lengths[0], 0, 0, cas));
/*
* The item will have a new cas value, so try to set it again with the old
* value. This should fail!
- */
- ret= memcached_cas(memc, keys[0], lengths[0], keys[0], lengths[0], 0, 0, cas);
- test_true(ret == MEMCACHED_SUCCESS);
+ */
+ test_compare(MEMCACHED_SUCCESS,
+ memcached_cas(memc, keys[0], lengths[0], keys[0], lengths[0], 0, 0, cas));
test_true(memcached_flush_buffers(memc) == MEMCACHED_SUCCESS);
char* value=memcached_get(memc, keys[0], lengths[0], &length, &flags, &ret);
test_true(ret == MEMCACHED_SUCCESS && value != NULL);
static test_return_t analyzer_test(memcached_st *memc)
{
memcached_return_t rc;
- memcached_stat_st *memc_stat;
memcached_analysis_st *report;
- memc_stat= memcached_stat(memc, NULL, &rc);
+ memcached_stat_st *memc_stat= memcached_stat(memc, NULL, &rc);
test_compare(MEMCACHED_SUCCESS, rc);
test_true(memc_stat);
}
/* 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);
return TEST_SUCCESS;
}
-#ifdef HAVE_LIBMEMCACHEDUTIL
-
-struct test_pool_context_st {
- memcached_pool_st* pool;
- memcached_st* mmc;
-};
-
-static void* connection_release(void *arg)
-{
- test_pool_context_st *resource= static_cast<test_pool_context_st *>(arg);
-
- usleep(250);
- // Release all of the memc we are holding
- assert(memcached_success(memcached_pool_push(resource->pool, resource->mmc)));
- return arg;
-}
-
-#define POOL_SIZE 10
-static test_return_t connection_pool_test(memcached_st *memc)
-{
- memcached_pool_st* pool= memcached_pool_create(memc, 5, POOL_SIZE);
- test_true(pool != NULL);
- memcached_st *mmc[POOL_SIZE];
- memcached_return_t rc;
-
- // Fill up our array that we will store the memc that are in the pool
- for (size_t x= 0; x < POOL_SIZE; ++x)
- {
- mmc[x]= memcached_pool_pop(pool, false, &rc);
- test_true(mmc[x] != NULL);
- test_compare(MEMCACHED_SUCCESS, rc);
- }
-
- // All memc should be gone
- test_true(memcached_pool_pop(pool, false, &rc) == NULL);
- test_compare(MEMCACHED_SUCCESS, rc);
-
- pthread_t tid;
- test_pool_context_st item= { pool, mmc[9] };
-
- pthread_create(&tid, NULL, connection_release, &item);
- mmc[9]= memcached_pool_pop(pool, true, &rc);
- test_compare(MEMCACHED_SUCCESS, rc);
- pthread_join(tid, NULL);
- test_true(mmc[9]);
- const char *key= "key";
- size_t keylen= strlen(key);
-
- // verify that I can do ops with all connections
- test_compare(MEMCACHED_SUCCESS,
- memcached_set(mmc[0], key, keylen, "0", 1, 0, 0));
-
- for (size_t x= 0; x < POOL_SIZE; ++x)
- {
- uint64_t number_value;
- test_compare(MEMCACHED_SUCCESS,
- memcached_increment(mmc[x], key, keylen, 1, &number_value));
- test_compare(number_value, (x+1));
- }
-
- // Release them..
- for (size_t x= 0; x < POOL_SIZE; ++x)
- {
- test_compare(MEMCACHED_SUCCESS, memcached_pool_push(pool, mmc[x]));
- }
-
-
- /* verify that I can set behaviors on the pool when I don't have all
- * of the connections in the pool. It should however be enabled
- * when I push the item into the pool
- */
- mmc[0]= memcached_pool_pop(pool, false, &rc);
- test_true(mmc[0]);
-
- rc= memcached_pool_behavior_set(pool, MEMCACHED_BEHAVIOR_IO_MSG_WATERMARK, 9999);
- test_compare(MEMCACHED_SUCCESS, rc);
-
- 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(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(MEMCACHED_SUCCESS, memcached_pool_push(pool, mmc[0]));
-
- test_true(memcached_pool_destroy(pool) == memc);
-
- return TEST_SUCCESS;
-}
-
static test_return_t util_version_test(memcached_st *memc)
{
- bool if_successful= libmemcached_util_version_check(memc, 0, 0, 0);
- test_true(if_successful);
+ test_compare_hint(MEMCACHED_SUCCESS, memcached_version(memc), memcached_last_error_message(memc));
+ test_true(libmemcached_util_version_check(memc, 0, 0, 0));
- if_successful= libmemcached_util_version_check(memc, 9, 9, 9);
+ bool if_successful= libmemcached_util_version_check(memc, 9, 9, 9);
// We expect failure
if (if_successful)
if_successful= libmemcached_util_version_check(memc, instance->major_version, instance->minor_version, instance->micro_version);
test_true(if_successful == true);
- if (instance->micro_version > 0)
- if_successful= libmemcached_util_version_check(memc, instance->major_version, instance->minor_version, (uint8_t)(instance->micro_version -1));
- else if (instance->minor_version > 0)
- if_successful= libmemcached_util_version_check(memc, instance->major_version, (uint8_t)(instance->minor_version - 1), instance->micro_version);
- else if (instance->major_version > 0)
- if_successful= libmemcached_util_version_check(memc, (uint8_t)(instance->major_version -1), instance->minor_version, instance->micro_version);
+ if (instance->micro_version > 0)
+ {
+ if_successful= libmemcached_util_version_check(memc, instance->major_version, instance->minor_version, (uint8_t)(instance->micro_version -1));
+ }
+ else if (instance->minor_version > 0)
+ {
+ if_successful= libmemcached_util_version_check(memc, instance->major_version, (uint8_t)(instance->minor_version - 1), instance->micro_version);
+ }
+ else if (instance->major_version > 0)
+ {
+ if_successful= libmemcached_util_version_check(memc, (uint8_t)(instance->major_version -1), instance->minor_version, instance->micro_version);
+ }
+
+ test_true(if_successful == true);
+
+ if (instance->micro_version > 0)
+ {
+ if_successful= libmemcached_util_version_check(memc, instance->major_version, instance->minor_version, (uint8_t)(instance->micro_version +1));
+ }
+ else if (instance->minor_version > 0)
+ {
+ if_successful= libmemcached_util_version_check(memc, instance->major_version, (uint8_t)(instance->minor_version +1), instance->micro_version);
+ }
+ else if (instance->major_version > 0)
+ {
+ if_successful= libmemcached_util_version_check(memc, (uint8_t)(instance->major_version +1), instance->minor_version, instance->micro_version);
+ }
+
+ test_true(if_successful == false);
+
+ return TEST_SUCCESS;
+}
+
+static test_return_t getpid_connection_failure_test(memcached_st *memc)
+{
+ memcached_return_t rc;
+ memcached_server_instance_st instance=
+ memcached_server_instance_by_position(memc, 0);
+
+ // Test both the version that returns a code, and the one that does not.
+ test_true(libmemcached_util_getpid(memcached_server_name(instance),
+ memcached_server_port(instance) -1, NULL) == -1);
+
+ test_true(libmemcached_util_getpid(memcached_server_name(instance),
+ memcached_server_port(instance) -1, &rc) == -1);
+ test_compare_got(MEMCACHED_CONNECTION_FAILURE, rc, memcached_strerror(memc, rc));
+
+ return TEST_SUCCESS;
+}
- test_true(if_successful == true);
- if (instance->micro_version > 0)
- if_successful= libmemcached_util_version_check(memc, instance->major_version, instance->minor_version, (uint8_t)(instance->micro_version +1));
- else if (instance->minor_version > 0)
- if_successful= libmemcached_util_version_check(memc, instance->major_version, (uint8_t)(instance->minor_version +1), instance->micro_version);
- else if (instance->major_version > 0)
- if_successful= libmemcached_util_version_check(memc, (uint8_t)(instance->major_version +1), instance->minor_version, instance->micro_version);
+static test_return_t getpid_test(memcached_st *memc)
+{
+ memcached_return_t rc;
+ memcached_server_instance_st instance=
+ memcached_server_instance_by_position(memc, 0);
- test_true(if_successful == false);
+ // Test both the version that returns a code, and the one that does not.
+ test_true(libmemcached_util_getpid(memcached_server_name(instance),
+ memcached_server_port(instance), NULL) > -1);
+
+ test_true(libmemcached_util_getpid(memcached_server_name(instance),
+ memcached_server_port(instance), &rc) > -1);
+ test_compare(MEMCACHED_SUCCESS, rc);
return TEST_SUCCESS;
}
return TEST_SUCCESS;
}
-#endif
#if 0
static test_return_t hsieh_avaibility_test (memcached_st *memc)
{
- memcached_return_t expected_rc= MEMCACHED_INVALID_ARGUMENTS;
-#ifdef HAVE_HSIEH_HASH
- expected_rc= MEMCACHED_SUCCESS;
-#endif
- memcached_return_t rc= memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_HASH,
- (uint64_t)MEMCACHED_HASH_HSIEH);
- test_true(rc == expected_rc);
+ test_skip(true, libhashkit_has_algorithm(HASHKIT_HASH_HSIEH));
+
+ test_compare(MEMCACHED_SUCCESS,
+ memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_HASH,
+ (uint64_t)MEMCACHED_HASH_HSIEH));
return TEST_SUCCESS;
}
static test_return_t murmur_avaibility_test (memcached_st *memc)
{
- memcached_return_t expected_rc= MEMCACHED_INVALID_ARGUMENTS;
-#ifdef HAVE_MURMUR_HASH
- expected_rc= MEMCACHED_SUCCESS;
-#endif
- memcached_return_t rc= memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_HASH,
- (uint64_t)MEMCACHED_HASH_MURMUR);
- test_true(rc == expected_rc);
+ test_skip(true, libhashkit_has_algorithm(HASHKIT_HASH_MURMUR));
+
+ test_compare(MEMCACHED_SUCCESS,
+ memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_HASH, (uint64_t)MEMCACHED_HASH_MURMUR));
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++)
{
- uint32_t hash_val;
-
- hash_val= memcached_generate_hash_value(*ptr, strlen(*ptr), MEMCACHED_HASH_DEFAULT);
- test_true(one_at_a_time_values[x] == hash_val);
+ test_compare(one_at_a_time_values[x],
+ memcached_generate_hash_value(*ptr, strlen(*ptr), MEMCACHED_HASH_DEFAULT));
}
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++)
{
- uint32_t hash_val;
-
- hash_val= memcached_generate_hash_value(*ptr, strlen(*ptr), MEMCACHED_HASH_MD5);
- test_true(md5_values[x] == hash_val);
+ test_compare(md5_values[x],
+ memcached_generate_hash_value(*ptr, strlen(*ptr), MEMCACHED_HASH_MD5));
}
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++)
{
- uint32_t hash_val;
-
- hash_val= memcached_generate_hash_value(*ptr, strlen(*ptr), MEMCACHED_HASH_CRC);
- test_true(crc_values[x] == hash_val);
+ test_compare(crc_values[x],
+ memcached_generate_hash_value(*ptr, strlen(*ptr), MEMCACHED_HASH_CRC));
}
return TEST_SUCCESS;
}
-static test_return_t fnv1_64_run (memcached_st *memc)
+static test_return_t fnv1_64_run (memcached_st *)
{
+ test_skip(true, libhashkit_has_algorithm(HASHKIT_HASH_FNV1_64));
+
uint32_t x;
const char **ptr;
- (void)memc;
for (ptr= list_to_hash, x= 0; *ptr; ptr++, x++)
{
- uint32_t hash_val;
-
- hash_val= memcached_generate_hash_value(*ptr, strlen(*ptr), MEMCACHED_HASH_FNV1_64);
- test_true(fnv1_64_values[x] == hash_val);
+ test_compare(fnv1_64_values[x],
+ memcached_generate_hash_value(*ptr, strlen(*ptr), MEMCACHED_HASH_FNV1_64));
}
return TEST_SUCCESS;
}
-static test_return_t fnv1a_64_run (memcached_st *memc)
+static test_return_t fnv1a_64_run (memcached_st *)
{
+ test_skip(true, libhashkit_has_algorithm(HASHKIT_HASH_FNV1A_64));
+
uint32_t x;
const char **ptr;
- (void)memc;
for (ptr= list_to_hash, x= 0; *ptr; ptr++, x++)
{
- uint32_t hash_val;
-
- hash_val= memcached_generate_hash_value(*ptr, strlen(*ptr), MEMCACHED_HASH_FNV1A_64);
- test_true(fnv1a_64_values[x] == hash_val);
+ test_compare(fnv1a_64_values[x],
+ memcached_generate_hash_value(*ptr, strlen(*ptr), MEMCACHED_HASH_FNV1A_64));
}
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++)
{
- uint32_t hash_val;
-
- hash_val= memcached_generate_hash_value(*ptr, strlen(*ptr), MEMCACHED_HASH_FNV1_32);
- test_true(fnv1_32_values[x] == hash_val);
+ test_compare(fnv1_32_values[x],
+ memcached_generate_hash_value(*ptr, strlen(*ptr), MEMCACHED_HASH_FNV1_32));
}
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++)
{
- uint32_t hash_val;
-
- hash_val= memcached_generate_hash_value(*ptr, strlen(*ptr), MEMCACHED_HASH_FNV1A_32);
- test_true(fnv1a_32_values[x] == hash_val);
+ test_compare(fnv1a_32_values[x],
+ memcached_generate_hash_value(*ptr, strlen(*ptr), MEMCACHED_HASH_FNV1A_32));
}
return TEST_SUCCESS;
}
-static test_return_t hsieh_run (memcached_st *memc)
+static test_return_t hsieh_run (memcached_st *)
{
+ test_skip(true, libhashkit_has_algorithm(HASHKIT_HASH_HSIEH));
+
uint32_t x;
const char **ptr;
- (void)memc;
for (ptr= list_to_hash, x= 0; *ptr; ptr++, x++)
{
- uint32_t hash_val;
-
- hash_val= memcached_generate_hash_value(*ptr, strlen(*ptr), MEMCACHED_HASH_HSIEH);
- test_true(hsieh_values[x] == hash_val);
+ test_compare(hsieh_values[x],
+ memcached_generate_hash_value(*ptr, strlen(*ptr), MEMCACHED_HASH_HSIEH));
}
return TEST_SUCCESS;
}
-static test_return_t murmur_run (memcached_st *memc)
+static test_return_t murmur_run (memcached_st *)
{
+ test_skip(true, libhashkit_has_algorithm(HASHKIT_HASH_MURMUR));
+
#ifdef WORDS_BIGENDIAN
(void)murmur_values;
return TEST_SKIPPED;
#else
uint32_t x;
const char **ptr;
- (void)memc;
for (ptr= list_to_hash, x= 0; *ptr; ptr++, x++)
{
- uint32_t hash_val;
-
- hash_val= memcached_generate_hash_value(*ptr, strlen(*ptr), MEMCACHED_HASH_MURMUR);
- test_true(murmur_values[x] == hash_val);
+ test_compare(murmur_values[x],
+ memcached_generate_hash_value(*ptr, strlen(*ptr), MEMCACHED_HASH_MURMUR));
}
return TEST_SUCCESS;
#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++)
{
- uint32_t hash_val;
-
- hash_val= memcached_generate_hash_value(*ptr, strlen(*ptr), MEMCACHED_HASH_JENKINS);
- test_true(jenkins_values[x] == hash_val);
+ test_compare(jenkins_values[x],
+ memcached_generate_hash_value(*ptr, strlen(*ptr), MEMCACHED_HASH_JENKINS));
}
return TEST_SUCCESS;
}
-static uint32_t hash_md5_test_function(const char *string, size_t string_length, void *context)
+static uint32_t hash_md5_test_function(const char *string, size_t string_length, void *)
{
- (void)context;
return libhashkit_md5(string, string_length);
}
-static uint32_t hash_crc_test_function(const char *string, size_t string_length, void *context)
+static uint32_t hash_crc_test_function(const char *string, size_t string_length, void *)
{
- (void)context;
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;
}
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)
+static test_return_t memcached_get_MEMCACHED_ERRNO(memcached_st *)
{
- (void)memc;
- memcached_st *tl_memc_h;
-
const char *key= "MemcachedLives";
size_t len;
uint32_t flags;
memcached_return rc;
- char *value;
// Create a handle.
- tl_memc_h= memcached_create(NULL);
- memcached_server_st *servers= memcached_servers_parse("localhost:9898,localhost:9899"); // This server should not exist
- test_true(servers);
- memcached_server_push(tl_memc_h, servers);
- memcached_server_list_free(servers);
+ memcached_st *tl_memc_h= memcached(test_literal_param("--server=localhost:9898 --server=localhost:9899")); // This server should not exist
// See if memcached is reachable.
- value= memcached_get(tl_memc_h, key, strlen(key), &len, &flags, &rc);
+ 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);
size_t len;
uint32_t flags;
memcached_return rc;
- char *value;
// See if memcached is reachable.
- value= memcached_get(memc, key, strlen(key), &len, &flags, &rc);
+ char *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;
}
-
-static test_return_t ketama_compatibility_libmemcached(memcached_st *)
-{
- memcached_st *memc= memcached_create(NULL);
- test_true(memc);
-
- 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(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_strcmp(server_pool[0].hostname, "10.0.1.1");
- test_compare(11211, server_pool[0].port);
- test_compare(600, 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_strcmp(server_pool[7].hostname, "10.0.1.8");
- test_compare(11211, server_pool[7].port);
- test_compare(100, server_pool[7].weight);
-
- /* VDEAAAAA hashes to fffcd1b5, after the last continuum point, and lets
- * us test the boundary wraparound.
- */
- test_true(memcached_generate_hash(memc, (char *)"VDEAAAAA", 8) == memc->ketama.continuum[0].index);
-
- /* verify the standard ketama set. */
- for (uint32_t x= 0; x < 99; x++)
- {
- uint32_t server_idx = memcached_generate_hash(memc, ketama_test_cases[x].key, strlen(ketama_test_cases[x].key));
- memcached_server_instance_st instance=
- memcached_server_instance_by_position(memc, server_idx);
- const char *hostname = memcached_server_name(instance);
-
- test_strcmp(hostname, ketama_test_cases[x].server);
- }
-
- memcached_server_list_free(server_pool);
- memcached_free(memc);
-
- return TEST_SUCCESS;
-}
-
-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(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_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");
- test_true(server_pool);
- memcached_server_push(memc, server_pool);
-
- /* verify that the server list was parsed okay. */
- test_compare(8, 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_strcmp(server_pool[2].hostname, "10.0.1.3");
- test_compare(11211, server_pool[2].port);
- test_compare(200, 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);
-
- /* VDEAAAAA hashes to fffcd1b5, after the last continuum point, and lets
- * us test the boundary wraparound.
- */
- test_true(memcached_generate_hash(memc, (char *)"VDEAAAAA", 8) == memc->ketama.continuum[0].index);
-
- /* verify the standard ketama set. */
- for (uint32_t 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));
-
- memcached_server_instance_st instance=
- memcached_server_instance_by_position(memc, server_idx);
-
- const char *hostname= memcached_server_name(instance);
-
- test_strcmp(hostname, ketama_test_cases_spy[x].server);
- }
-
- memcached_server_list_free(server_pool);
- memcached_free(memc);
-
- return TEST_SUCCESS;
-}
-
static test_return_t regression_bug_434484(memcached_st *memc)
{
- test_return_t test_rc;
- test_rc= pre_binary(memc);
-
- if (test_rc != TEST_SUCCESS)
- return test_rc;
+ test_skip(TEST_SUCCESS, pre_binary(memc));
const char *key= "regression_bug_434484";
size_t keylen= strlen(key);
static test_return_t regression_bug_434843(memcached_st *memc)
{
- test_return_t test_rc;
- test_rc= pre_binary(memc);
-
- if (test_rc != TEST_SUCCESS)
- return test_rc;
+ test_skip(TEST_SUCCESS, pre_binary(memc));
memcached_return_t rc;
size_t counter= 0;
* sending in the pipleine to the server. Let's try to do a multiget of
* 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= memcached_server_count(memc);
memc->number_of_hosts= 1;
const size_t max_keys= 1024;
for (size_t x= 0; x < max_keys; ++x)
{
- char k[251];
+ char k[251];
- key_length[x]= (size_t)snprintf(k, sizeof(k), "0200%lu", (unsigned long)x);
- keys[x]= strdup(k);
- test_true(keys[x]);
+ key_length[x]= (size_t)snprintf(k, sizeof(k), "0200%lu", (unsigned long)x);
+ keys[x]= strdup(k);
+ test_true(keys[x]);
}
/*
* Run two times.. the first time we should have 100% cache miss,
* and the second time we should have 100% cache hits
- */
+ */
for (size_t y= 0; y < 2; y++)
{
test_compare(MEMCACHED_SUCCESS,
else
{
/* Verify that we received all of the key/value pairs */
- test_compare(counter, max_keys);
+ test_compare(counter, max_keys);
}
}
for (uint32_t x= 0; x < 250; ++x)
{
- len= (size_t)snprintf(k, sizeof(k), "%0250u", x);
- memcached_return_t rc= memcached_delete(memc, k, len, 0);
- test_true(rc == MEMCACHED_SUCCESS || rc == MEMCACHED_BUFFERED);
+ len= (size_t)snprintf(k, sizeof(k), "%0250u", x);
+ memcached_return_t rc= memcached_delete(memc, k, len, 0);
+ test_true(rc == MEMCACHED_SUCCESS || rc == MEMCACHED_BUFFERED);
}
(void)snprintf(k, sizeof(k), "%037u", 251U);
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];
}
/*
- ** We are using the quiet commands to store the replicas, so we need
- ** to ensure that all of them are processed before we can continue.
- ** In the test we go directly from storing the object to trying to
- ** receive the object from all of the different servers, so we
- ** could end up in a race condition (the memcached server hasn't yet
- ** processed the quiet command from the replication set when it process
- ** the request from the other client (created by the clone)). As a
- ** workaround for that we call memcached_quit to send the quit command
- ** to the server and wait for the response ;-) If you use the test code
- ** as an example for your own code, please note that you shouldn't need
- ** to do this ;-)
- */
+ ** We are using the quiet commands to store the replicas, so we need
+ ** to ensure that all of them are processed before we can continue.
+ ** In the test we go directly from storing the object to trying to
+ ** receive the object from all of the different servers, so we
+ ** could end up in a race condition (the memcached server hasn't yet
+ ** processed the quiet command from the replication set when it process
+ ** the request from the other client (created by the clone)). As a
+ ** workaround for that we call memcached_quit to send the quit command
+ ** to the server and wait for the response ;-) If you use the test code
+ ** as an example for your own code, please note that you shouldn't need
+ ** to do this ;-)
+ */
memcached_quit(memc);
/* Verify that all messages are stored, and we didn't stuff too much
* into the servers
- */
+ */
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);
* within the library, and this is not a supported interface.
* This is to verify correct behavior in the library. Fake that two servers
* are dead..
- */
+ */
instance_one= memcached_server_instance_by_position(memc, 0);
instance_two= memcached_server_instance_by_position(memc, 2);
in_port_t port0= instance_one->port;
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 */
/* 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
- */
+ */
test_true_got(rc == MEMCACHED_PROTOCOL_ERROR || rc == MEMCACHED_NOTFOUND || rc == MEMCACHED_CLIENT_ERROR || rc == MEMCACHED_INVALID_ARGUMENTS, memcached_strerror(NULL, rc));
/* And buffered mode should be disabled and we should get protocol error */
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);
{
const char *msg= memcached_strerror(memc, memcached_return_t(x));
memcached_return_t ret= memcached_set(memc, msg, strlen(msg), NULL, 0, (time_t)0, (uint32_t)0);
- test_compare_got(MEMCACHED_CONNECTION_FAILURE, ret, memcached_last_error_message(memc));
+ test_true_got((ret == MEMCACHED_CONNECTION_FAILURE or ret == MEMCACHED_SERVER_TEMPORARILY_DISABLED), memcached_last_error_message(memc));
memcached_server_instance_st disconnected_server= memcached_server_get_last_disconnect(memc);
test_true(disconnected_server);
return TEST_SUCCESS;
}
-static test_return_t test_server_failure(memcached_st *memc)
-{
- memcached_server_instance_st instance= memcached_server_instance_by_position(memc, 0);
-
- memcached_st *local_memc= memcached_create(NULL);
-
- memcached_server_add(local_memc, memcached_server_name(instance), memcached_server_port(instance));
- 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);
-
- // Disable the server
- instance= memcached_server_instance_by_position(local_memc, 0);
- ((memcached_server_write_instance_st)instance)->server_failure_counter= 2;
-
- memcached_return_t rc;
- test_compare_got(MEMCACHED_SERVER_MARKED_DEAD,
- rc= memcached_set(local_memc, "foo", strlen("foo"), NULL, 0, (time_t)0, (uint32_t)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));
-#if 0
- memcached_last_error_message(local_memc));
-#endif
-
-
- memcached_free(local_memc);
-
- return TEST_SUCCESS;
-}
-
-static test_return_t test_cull_servers(memcached_st *memc)
-{
- uint32_t count = memcached_server_count(memc);
-
- // Do not do this in your code, it is not supported.
- memc->servers[1].options.is_dead= true;
- memc->state.is_time_for_rebuild= true;
-
- uint32_t new_count= memcached_server_count(memc);
- test_compare(count, new_count);
-
-#if 0
- test_true(count == new_count + 1 );
-#endif
-
- return TEST_SUCCESS;
-}
-
static memcached_return_t stat_printer(memcached_server_instance_st server,
const char *key, size_t key_length,
* Please note that I'm abusing the internal structures in libmemcached
* 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= memcached_server_count(memc);
memc->number_of_hosts= 1;
/* The test is to see that the memcached_quit doesn't increase the
* the server failure conter, so let's ensure that it is zero
* before sending quit
- */
+ */
((memcached_server_write_instance_st)instance)->server_failure_counter= 0;
memcached_quit(memc);
/* Verify that it memcached_quit didn't increment the failure counter
* 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;
/*
* I only want to hit _one_ server so I know the number of requests I'm
* sending in the pipeline.
- */
+ */
uint32_t number_of_hosts= memc->number_of_hosts;
memc->number_of_hosts= 1;
size_t max_keys= 20480;
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));
+ test_compare_got(MEMCACHED_TIMEOUT, rc, memcached_last_error_message(memc));
memcached_free(memc);
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(100LLU, 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++;
}
return TEST_SUCCESS;
}
+
+static test_return_t regression_bug_854604(memcached_st *)
+{
+ char buffer[1024];
+
+ test_compare(MEMCACHED_INVALID_ARGUMENTS, libmemcached_check_configuration(0, 0, buffer, 0));
+
+ test_compare(MEMCACHED_PARSE_ERROR, libmemcached_check_configuration(test_literal_param("syntax error"), buffer, 0));
+
+ test_compare(MEMCACHED_PARSE_ERROR, libmemcached_check_configuration(test_literal_param("syntax error"), buffer, 1));
+ test_compare(buffer[0], 0);
+
+ test_compare(MEMCACHED_PARSE_ERROR, libmemcached_check_configuration(test_literal_param("syntax error"), buffer, 10));
+ test_true(strlen(buffer));
+
+ test_compare(MEMCACHED_PARSE_ERROR, libmemcached_check_configuration(test_literal_param("syntax error"), buffer, sizeof(buffer)));
+ test_true(strlen(buffer));
+
+ return TEST_SUCCESS;
+}
+
static void memcached_die(memcached_st* mc, memcached_return error, const char* what, uint32_t it)
{
fprintf(stderr, "Iteration #%u: ", it);
- if(error == MEMCACHED_ERRNO)
+ if (error == MEMCACHED_ERRNO)
{
fprintf(stderr, "system error %d from %s: %s\n",
errno, what, strerror(errno));
return TEST_SUCCESS;
}
-/*
- * Test that the sasl authentication works. We cannot use the default
- * pool of servers, because that would require that all servers we want
- * to test supports SASL authentication, and that they use the default
- * creds.
- */
-static test_return_t sasl_auth_test(memcached_st *memc)
-{
-#ifdef LIBMEMCACHED_WITH_SASL_SUPPORT
- test_compare(MEMCACHED_SUCCESS, memcached_set(memc, "foo", 3, "bar", 3, (time_t)0, (uint32_t)0));
- test_compare(MEMCACHED_SUCCESS, memcached_delete(memc, "foo", 3, 0));
- test_compare(MEMCACHED_SUCCESS, memcached_destroy_sasl_auth_data(memc));
- test_compare(MEMCACHED_FAILURE, memcached_destroy_sasl_auth_data(memc));
- test_compare(MEMCACHED_FAILURE, memcached_destroy_sasl_auth_data(NULL));
- memcached_quit(memc);
-
- test_compare(MEMCACHED_SUCCESS,
- memcached_set_sasl_auth_data(memc,
- getenv("LIBMEMCACHED_TEST_SASL_USERNAME"),
- getenv("LIBMEMCACHED_TEST_SASL_SERVER")));
-
- test_compare(MEMCACHED_AUTH_FAILURE,
- memcached_set(memc, "foo", 3, "bar", 3, (time_t)0, (uint32_t)0));
- test_compare(MEMCACHED_SUCCESS, memcached_destroy_sasl_auth_data(memc));
-
- memcached_quit(memc);
- return TEST_SUCCESS;
-#else
- (void)memc;
- return TEST_FAILURE;
-#endif
-}
-
/* Clean the server before beginning testing */
test_st tests[] ={
- {"util_version", 1, (test_callback_fn*)util_version_test },
- {"flush", 0, (test_callback_fn*)flush_test },
- {"init", 0, (test_callback_fn*)init_test },
- {"allocation", 0, (test_callback_fn*)allocation_test },
- {"server_list_null_test", 0, (test_callback_fn*)server_list_null_test},
- {"server_unsort", 0, (test_callback_fn*)server_unsort_test},
- {"server_sort", 0, (test_callback_fn*)server_sort_test},
- {"server_sort2", 0, (test_callback_fn*)server_sort2_test},
- {"memcached_server_remove", 0, (test_callback_fn*)memcached_server_remove_test},
- {"clone_test", 0, (test_callback_fn*)clone_test },
- {"connection_test", 0, (test_callback_fn*)connection_test},
- {"callback_test", 0, (test_callback_fn*)callback_test},
- {"userdata_test", 0, (test_callback_fn*)userdata_test},
- {"error", 0, (test_callback_fn*)error_test },
- {"set", 0, (test_callback_fn*)set_test },
- {"set2", 0, (test_callback_fn*)set_test2 },
- {"set3", 0, (test_callback_fn*)set_test3 },
- {"dump", 1, (test_callback_fn*)dump_test},
- {"add", 1, (test_callback_fn*)add_test },
- {"memcached_fetch_result(MEMCACHED_NOTFOUND)", 1, (test_callback_fn*)memcached_fetch_result_NOT_FOUND },
- {"replace", 1, (test_callback_fn*)replace_test },
- {"delete", 1, (test_callback_fn*)delete_test },
- {"get", 1, (test_callback_fn*)get_test },
- {"get2", 0, (test_callback_fn*)get_test2 },
- {"get3", 0, (test_callback_fn*)get_test3 },
- {"get4", 0, (test_callback_fn*)get_test4 },
- {"partial mget", 0, (test_callback_fn*)get_test5 },
- {"stats_servername", 0, (test_callback_fn*)stats_servername_test },
- {"increment", 0, (test_callback_fn*)increment_test },
- {"increment_with_initial", 1, (test_callback_fn*)increment_with_initial_test },
- {"decrement", 0, (test_callback_fn*)decrement_test },
- {"decrement_with_initial", 1, (test_callback_fn*)decrement_with_initial_test },
- {"increment_by_key", 0, (test_callback_fn*)increment_by_key_test },
- {"increment_with_initial_by_key", 1, (test_callback_fn*)increment_with_initial_by_key_test },
- {"decrement_by_key", 0, (test_callback_fn*)decrement_by_key_test },
- {"decrement_with_initial_by_key", 1, (test_callback_fn*)decrement_with_initial_by_key_test },
- {"quit", 0, (test_callback_fn*)quit_test },
- {"mget", 1, (test_callback_fn*)mget_test },
- {"mget_result", 1, (test_callback_fn*)mget_result_test },
- {"mget_result_alloc", 1, (test_callback_fn*)mget_result_alloc_test },
- {"mget_result_function", 1, (test_callback_fn*)mget_result_function },
- {"mget_execute", 1, (test_callback_fn*)mget_execute },
- {"mget_end", 0, (test_callback_fn*)mget_end },
- {"get_stats", 0, (test_callback_fn*)get_stats },
- {"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 },
- {"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 },
- {"read_through", 1, (test_callback_fn*)read_through },
- {"delete_through", 1, (test_callback_fn*)delete_through },
- {"noreply", 1, (test_callback_fn*)noreply_test},
- {"analyzer", 1, (test_callback_fn*)analyzer_test},
- {"connectionpool", 1, (test_callback_fn*)connection_pool_test },
- {"memcached_pool_test", 1, (test_callback_fn*)memcached_pool_test },
- {"ping", 1, (test_callback_fn*)ping_test },
- {"test_get_last_disconnect", 1, (test_callback_fn*)test_get_last_disconnect},
- {"verbosity", 1, (test_callback_fn*)test_verbosity},
- {"test_server_failure", 1, (test_callback_fn*)test_server_failure},
- {"cull_servers", 1, (test_callback_fn*)test_cull_servers},
- {"memcached_stat_execute", 1, (test_callback_fn*)memcached_stat_execute_test},
+ {"util_version", true, (test_callback_fn*)util_version_test },
+ {"flush", false, (test_callback_fn*)flush_test },
+ {"init", false, (test_callback_fn*)init_test },
+ {"allocation", false, (test_callback_fn*)allocation_test },
+ {"server_list_null_test", false, (test_callback_fn*)server_list_null_test},
+ {"server_unsort", false, (test_callback_fn*)server_unsort_test},
+ {"server_sort", false, (test_callback_fn*)server_sort_test},
+ {"server_sort2", false, (test_callback_fn*)server_sort2_test},
+ {"memcached_server_remove", false, (test_callback_fn*)memcached_server_remove_test},
+ {"clone_test", false, (test_callback_fn*)clone_test },
+ {"connection_test", false, (test_callback_fn*)connection_test},
+ {"callback_test", false, (test_callback_fn*)callback_test},
+ {"userdata_test", false, (test_callback_fn*)userdata_test},
+ {"set", false, (test_callback_fn*)set_test },
+ {"set2", false, (test_callback_fn*)set_test2 },
+ {"set3", false, (test_callback_fn*)set_test3 },
+ {"dump", true, (test_callback_fn*)dump_test},
+ {"add", true, (test_callback_fn*)add_test },
+ {"memcached_fetch_result(MEMCACHED_NOTFOUND)", true, (test_callback_fn*)memcached_fetch_result_NOT_FOUND },
+ {"replace", true, (test_callback_fn*)replace_test },
+ {"delete", true, (test_callback_fn*)delete_test },
+ {"get", true, (test_callback_fn*)get_test },
+ {"get2", false, (test_callback_fn*)get_test2 },
+ {"get3", false, (test_callback_fn*)get_test3 },
+ {"get4", false, (test_callback_fn*)get_test4 },
+ {"partial mget", false, (test_callback_fn*)get_test5 },
+ {"stats_servername", false, (test_callback_fn*)stats_servername_test },
+ {"increment", false, (test_callback_fn*)increment_test },
+ {"increment_with_initial", true, (test_callback_fn*)increment_with_initial_test },
+ {"decrement", false, (test_callback_fn*)decrement_test },
+ {"decrement_with_initial", true, (test_callback_fn*)decrement_with_initial_test },
+ {"increment_by_key", false, (test_callback_fn*)increment_by_key_test },
+ {"increment_with_initial_by_key", true, (test_callback_fn*)increment_with_initial_by_key_test },
+ {"decrement_by_key", false, (test_callback_fn*)decrement_by_key_test },
+ {"decrement_with_initial_by_key", true, (test_callback_fn*)decrement_with_initial_by_key_test },
+ {"binary_increment_with_prefix", 1, (test_callback_fn*)binary_increment_with_prefix_test },
+ {"quit", false, (test_callback_fn*)quit_test },
+ {"mget", true, (test_callback_fn*)mget_test },
+ {"mget_result", true, (test_callback_fn*)mget_result_test },
+ {"mget_result_alloc", true, (test_callback_fn*)mget_result_alloc_test },
+ {"mget_result_function", true, (test_callback_fn*)mget_result_function },
+ {"mget_execute", true, (test_callback_fn*)mget_execute },
+ {"mget_end", false, (test_callback_fn*)mget_end },
+ {"get_stats", false, (test_callback_fn*)get_stats },
+ {"add_host_test", false, (test_callback_fn*)add_host_test },
+ {"add_host_test_1", false, (test_callback_fn*)add_host_test1 },
+ {"get_stats_keys", false, (test_callback_fn*)get_stats_keys },
+ {"version_string_test", false, (test_callback_fn*)version_string_test},
+ {"bad_key", true, (test_callback_fn*)bad_key_test },
+ {"memcached_server_cursor", true, (test_callback_fn*)memcached_server_cursor_test },
+ {"read_through", true, (test_callback_fn*)read_through },
+ {"delete_through", true, (test_callback_fn*)test_MEMCACHED_CALLBACK_DELETE_TRIGGER },
+ {"noreply", true, (test_callback_fn*)noreply_test},
+ {"analyzer", true, (test_callback_fn*)analyzer_test},
+ {"memcached_pool_st", true, (test_callback_fn*)connection_pool_test },
+ {"memcached_pool_st #2", true, (test_callback_fn*)connection_pool2_test },
+ {"memcached_pool_st #3", true, (test_callback_fn*)connection_pool3_test },
+ {"memcached_pool_test", true, (test_callback_fn*)memcached_pool_test },
+ {"test_get_last_disconnect", true, (test_callback_fn*)test_get_last_disconnect},
+ {"verbosity", true, (test_callback_fn*)test_verbosity},
+ {"memcached_stat_execute", true, (test_callback_fn*)memcached_stat_execute_test},
+ {"memcached_exist(MEMCACHED_NOTFOUND)", true, (test_callback_fn*)memcached_exist_NOTFOUND },
+ {"memcached_exist(MEMCACHED_SUCCESS)", true, (test_callback_fn*)memcached_exist_SUCCESS },
+ {"memcached_exist_by_key(MEMCACHED_NOTFOUND)", true, (test_callback_fn*)memcached_exist_by_key_NOTFOUND },
+ {"memcached_exist_by_key(MEMCACHED_SUCCESS)", true, (test_callback_fn*)memcached_exist_by_key_SUCCESS },
+ {"memcached_touch", 0, (test_callback_fn*)test_memcached_touch},
+ {"memcached_touch_with_prefix", 0, (test_callback_fn*)test_memcached_touch_by_key},
+ {0, 0, 0}
+};
+
+test_st touch_tests[] ={
+ {"memcached_touch", 0, (test_callback_fn*)test_memcached_touch},
+ {"memcached_touch_with_prefix", 0, (test_callback_fn*)test_memcached_touch_by_key},
{0, 0, 0}
};
test_st behavior_tests[] ={
- {"libmemcached_string_behavior()", 0, (test_callback_fn*)libmemcached_string_behavior_test},
- {"libmemcached_string_distribution()", 0, (test_callback_fn*)libmemcached_string_distribution_test},
- {"behavior_test", 0, (test_callback_fn*)behavior_test},
- {"MEMCACHED_BEHAVIOR_CORK", 0, (test_callback_fn*)MEMCACHED_BEHAVIOR_CORK_test},
- {"MEMCACHED_BEHAVIOR_TCP_KEEPALIVE", 0, (test_callback_fn*)MEMCACHED_BEHAVIOR_TCP_KEEPALIVE_test},
- {"MEMCACHED_BEHAVIOR_TCP_KEEPIDLE", 0, (test_callback_fn*)MEMCACHED_BEHAVIOR_TCP_KEEPIDLE_test},
+ {"libmemcached_string_behavior()", false, (test_callback_fn*)libmemcached_string_behavior_test},
+ {"libmemcached_string_distribution()", false, (test_callback_fn*)libmemcached_string_distribution_test},
+ {"behavior_test", false, (test_callback_fn*)behavior_test},
+ {"MEMCACHED_BEHAVIOR_CORK", false, (test_callback_fn*)MEMCACHED_BEHAVIOR_CORK_test},
+ {"MEMCACHED_BEHAVIOR_TCP_KEEPALIVE", false, (test_callback_fn*)MEMCACHED_BEHAVIOR_TCP_KEEPALIVE_test},
+ {"MEMCACHED_BEHAVIOR_TCP_KEEPIDLE", false, (test_callback_fn*)MEMCACHED_BEHAVIOR_TCP_KEEPIDLE_test},
+ {"MEMCACHED_BEHAVIOR_POLL_TIMEOUT", false, (test_callback_fn*)MEMCACHED_BEHAVIOR_POLL_TIMEOUT_test},
+ {"MEMCACHED_CALLBACK_DELETE_TRIGGER_and_MEMCACHED_BEHAVIOR_NOREPLY", false, (test_callback_fn*)test_MEMCACHED_CALLBACK_DELETE_TRIGGER_and_MEMCACHED_BEHAVIOR_NOREPLY},
+ {0, 0, 0}
+};
+
+test_st libmemcachedutil_tests[] ={
+ {"libmemcached_util_ping()", true, (test_callback_fn*)ping_test },
+ {"libmemcached_util_getpid()", true, (test_callback_fn*)getpid_test },
+ {"libmemcached_util_getpid(MEMCACHED_CONNECTION_FAILURE)", true, (test_callback_fn*)getpid_connection_failure_test },
{0, 0, 0}
};
test_st basic_tests[] ={
- {"init", 1, (test_callback_fn*)basic_init_test},
- {"clone", 1, (test_callback_fn*)basic_clone_test},
- {"reset", 1, (test_callback_fn*)basic_reset_stack_test},
- {"reset heap", 1, (test_callback_fn*)basic_reset_heap_test},
- {"reset stack clone", 1, (test_callback_fn*)basic_reset_stack_clone_test},
- {"reset heap clone", 1, (test_callback_fn*)basic_reset_heap_clone_test},
+ {"init", true, (test_callback_fn*)basic_init_test},
+ {"clone", true, (test_callback_fn*)basic_clone_test},
+ {"reset", true, (test_callback_fn*)basic_reset_stack_test},
+ {"reset heap", true, (test_callback_fn*)basic_reset_heap_test},
+ {"reset stack clone", true, (test_callback_fn*)basic_reset_stack_clone_test},
+ {"reset heap clone", true, (test_callback_fn*)basic_reset_heap_clone_test},
+ {"memcached_return_t", false, (test_callback_fn*)memcached_return_t_TEST },
{0, 0, 0}
};
test_st regression_binary_vs_block[] ={
- {"block add", 1, (test_callback_fn*)block_add_regression},
- {"binary add", 1, (test_callback_fn*)binary_add_regression},
+ {"block add", true, (test_callback_fn*)block_add_regression},
+ {"binary add", true, (test_callback_fn*)binary_add_regression},
{0, 0, 0}
};
test_st async_tests[] ={
- {"add", 1, (test_callback_fn*)add_wrapper },
+ {"add", true, (test_callback_fn*)add_wrapper },
{0, 0, 0}
};
-test_st string_tests[] ={
- {"string static with null", 0, (test_callback_fn*)string_static_null },
- {"string alloc with null", 0, (test_callback_fn*)string_alloc_null },
- {"string alloc with 1K", 0, (test_callback_fn*)string_alloc_with_size },
- {"string alloc with malloc failure", 0, (test_callback_fn*)string_alloc_with_size_toobig },
- {"string append", 0, (test_callback_fn*)string_alloc_append },
- {"string append failure (too big)", 0, (test_callback_fn*)string_alloc_append_toobig },
- {"string_alloc_append_multiple", 0, (test_callback_fn*)string_alloc_append_multiple },
- {0, 0, (test_callback_fn*)0}
-};
-
test_st memcached_server_get_last_disconnect_tests[] ={
- {"memcached_server_get_last_disconnect()", 0, (test_callback_fn*)test_multiple_get_last_disconnect},
+ {"memcached_server_get_last_disconnect()", false, (test_callback_fn*)test_multiple_get_last_disconnect},
{0, 0, (test_callback_fn*)0}
};
test_st result_tests[] ={
- {"result static", 0, (test_callback_fn*)result_static},
- {"result alloc", 0, (test_callback_fn*)result_alloc},
+ {"result static", false, (test_callback_fn*)result_static},
+ {"result alloc", false, (test_callback_fn*)result_alloc},
{0, 0, (test_callback_fn*)0}
};
test_st version_1_2_3[] ={
- {"append", 0, (test_callback_fn*)append_test },
- {"prepend", 0, (test_callback_fn*)prepend_test },
- {"cas", 0, (test_callback_fn*)cas_test },
- {"cas2", 0, (test_callback_fn*)cas2_test },
- {"append_binary", 0, (test_callback_fn*)append_binary_test },
+ {"append", false, (test_callback_fn*)append_test },
+ {"prepend", false, (test_callback_fn*)prepend_test },
+ {"cas", false, (test_callback_fn*)cas_test },
+ {"cas2", false, (test_callback_fn*)cas2_test },
+ {"append_binary", false, (test_callback_fn*)append_binary_test },
{0, 0, (test_callback_fn*)0}
};
test_st haldenbrand_tests[] ={
- {"memcached_set", 0, (test_callback_fn*)user_supplied_bug1 },
- {"memcached_get()", 0, (test_callback_fn*)user_supplied_bug2 },
- {"memcached_mget()", 0, (test_callback_fn*)user_supplied_bug3 },
+ {"memcached_set", false, (test_callback_fn*)user_supplied_bug1 },
+ {"memcached_get()", false, (test_callback_fn*)user_supplied_bug2 },
+ {"memcached_mget()", false, (test_callback_fn*)user_supplied_bug3 },
{0, 0, (test_callback_fn*)0}
};
test_st user_tests[] ={
{"user_supplied_bug4", true, (test_callback_fn*)user_supplied_bug4 },
- {"user_supplied_bug5", 1, (test_callback_fn*)user_supplied_bug5 },
- {"user_supplied_bug6", 1, (test_callback_fn*)user_supplied_bug6 },
- {"user_supplied_bug7", 1, (test_callback_fn*)user_supplied_bug7 },
- {"user_supplied_bug8", 1, (test_callback_fn*)user_supplied_bug8 },
- {"user_supplied_bug9", 1, (test_callback_fn*)user_supplied_bug9 },
- {"user_supplied_bug10", 1, (test_callback_fn*)user_supplied_bug10 },
- {"user_supplied_bug11", 1, (test_callback_fn*)user_supplied_bug11 },
- {"user_supplied_bug12", 1, (test_callback_fn*)user_supplied_bug12 },
- {"user_supplied_bug13", 1, (test_callback_fn*)user_supplied_bug13 },
- {"user_supplied_bug14", 1, (test_callback_fn*)user_supplied_bug14 },
- {"user_supplied_bug15", 1, (test_callback_fn*)user_supplied_bug15 },
- {"user_supplied_bug16", 1, (test_callback_fn*)user_supplied_bug16 },
+ {"user_supplied_bug5", true, (test_callback_fn*)user_supplied_bug5 },
+ {"user_supplied_bug6", true, (test_callback_fn*)user_supplied_bug6 },
+ {"user_supplied_bug7", true, (test_callback_fn*)user_supplied_bug7 },
+ {"user_supplied_bug8", true, (test_callback_fn*)user_supplied_bug8 },
+ {"user_supplied_bug9", true, (test_callback_fn*)user_supplied_bug9 },
+ {"user_supplied_bug10", true, (test_callback_fn*)user_supplied_bug10 },
+ {"user_supplied_bug11", true, (test_callback_fn*)user_supplied_bug11 },
+ {"user_supplied_bug12", true, (test_callback_fn*)user_supplied_bug12 },
+ {"user_supplied_bug13", true, (test_callback_fn*)user_supplied_bug13 },
+ {"user_supplied_bug14", true, (test_callback_fn*)user_supplied_bug14 },
+ {"user_supplied_bug15", true, (test_callback_fn*)user_supplied_bug15 },
+ {"user_supplied_bug16", true, (test_callback_fn*)user_supplied_bug16 },
#if !defined(__sun) && !defined(__OpenBSD__)
/*
- ** It seems to be something weird with the character sets..
- ** value_fetch is unable to parse the value line (iscntrl "fails"), so I
- ** guess I need to find out how this is supposed to work.. Perhaps I need
- ** to run the test in a specific locale (I tried zh_CN.UTF-8 without success,
- ** so just disable the code for now...).
- */
- {"user_supplied_bug17", 1, (test_callback_fn*)user_supplied_bug17 },
+ ** It seems to be something weird with the character sets..
+ ** value_fetch is unable to parse the value line (iscntrl "fails"), so I
+ ** guess I need to find out how this is supposed to work.. Perhaps I need
+ ** to run the test in a specific locale (I tried zh_CN.UTF-8 without success,
+ ** so just disable the code for now...).
+ */
+ {"user_supplied_bug17", true, (test_callback_fn*)user_supplied_bug17 },
#endif
- {"user_supplied_bug18", 1, (test_callback_fn*)user_supplied_bug18 },
- {"user_supplied_bug19", 1, (test_callback_fn*)user_supplied_bug19 },
- {"user_supplied_bug20", 1, (test_callback_fn*)user_supplied_bug20 },
- {"user_supplied_bug21", 1, (test_callback_fn*)user_supplied_bug21 },
- {"wrong_failure_counter_test", 1, (test_callback_fn*)wrong_failure_counter_test},
- {"wrong_failure_counter_two_test", 1, (test_callback_fn*)wrong_failure_counter_two_test},
+ {"user_supplied_bug18", true, (test_callback_fn*)user_supplied_bug18 },
+ {"user_supplied_bug19", true, (test_callback_fn*)user_supplied_bug19 },
+ {"user_supplied_bug20", true, (test_callback_fn*)user_supplied_bug20 },
+ {"user_supplied_bug21", true, (test_callback_fn*)user_supplied_bug21 },
+ {"wrong_failure_counter_test", true, (test_callback_fn*)wrong_failure_counter_test},
+ {"wrong_failure_counter_two_test", true, (test_callback_fn*)wrong_failure_counter_two_test},
{0, 0, (test_callback_fn*)0}
};
test_st replication_tests[]= {
- {"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 },
- {"rand_mget", 0, (test_callback_fn*)replication_randomize_mget_test },
- {"fail", 0, (test_callback_fn*)replication_randomize_mget_fail_test },
+ {"set", true, (test_callback_fn*)replication_set_test },
+ {"get", false, (test_callback_fn*)replication_get_test },
+ {"mget", false, (test_callback_fn*)replication_mget_test },
+ {"delete", true, (test_callback_fn*)replication_delete_test },
+ {"rand_mget", false, (test_callback_fn*)replication_randomize_mget_test },
+ {"fail", false, (test_callback_fn*)replication_randomize_mget_fail_test },
{0, 0, (test_callback_fn*)0}
};
* http://bugs.launchpad.net/libmemcached
*/
test_st regression_tests[]= {
- {"lp:434484", 1, (test_callback_fn*)regression_bug_434484 },
- {"lp:434843", 1, (test_callback_fn*)regression_bug_434843 },
- {"lp:434843-buffered", 1, (test_callback_fn*)regression_bug_434843_buffered },
- {"lp:421108", 1, (test_callback_fn*)regression_bug_421108 },
- {"lp:442914", 1, (test_callback_fn*)regression_bug_442914 },
- {"lp:447342", 1, (test_callback_fn*)regression_bug_447342 },
- {"lp:463297", 1, (test_callback_fn*)regression_bug_463297 },
- {"lp:490486", 1, (test_callback_fn*)regression_bug_490486 },
- {"lp:583031", 1, (test_callback_fn*)regression_bug_583031 },
- {"lp:?", 1, (test_callback_fn*)regression_bug_ },
- {"lp:728286", 1, (test_callback_fn*)regression_bug_728286 },
- {"lp:581030", 1, (test_callback_fn*)regression_bug_581030 },
- {"lp:71231153 connect()", 1, (test_callback_fn*)regression_bug_71231153_connect },
- {"lp:71231153 poll()", 1, (test_callback_fn*)regression_bug_71231153_poll },
- {"lp:655423", 1, (test_callback_fn*)regression_bug_655423 },
- {"lp:490520", 1, (test_callback_fn*)regression_bug_490520 },
- {0, 0, (test_callback_fn*)0}
-};
-
-test_st sasl_auth_tests[]= {
- {"sasl_auth", 1, (test_callback_fn*)sasl_auth_test },
- {0, 0, (test_callback_fn*)0}
+ {"lp:434484", true, (test_callback_fn*)regression_bug_434484 },
+ {"lp:434843", true, (test_callback_fn*)regression_bug_434843 },
+ {"lp:434843-buffered", true, (test_callback_fn*)regression_bug_434843_buffered },
+ {"lp:421108", true, (test_callback_fn*)regression_bug_421108 },
+ {"lp:442914", true, (test_callback_fn*)regression_bug_442914 },
+ {"lp:447342", true, (test_callback_fn*)regression_bug_447342 },
+ {"lp:463297", true, (test_callback_fn*)regression_bug_463297 },
+ {"lp:490486", true, (test_callback_fn*)regression_bug_490486 },
+ {"lp:583031", true, (test_callback_fn*)regression_bug_583031 },
+ {"lp:?", true, (test_callback_fn*)regression_bug_ },
+ {"lp:728286", true, (test_callback_fn*)regression_bug_728286 },
+ {"lp:581030", true, (test_callback_fn*)regression_bug_581030 },
+ {"lp:71231153 connect()", true, (test_callback_fn*)regression_bug_71231153_connect },
+ {"lp:71231153 poll()", true, (test_callback_fn*)regression_bug_71231153_poll },
+ {"lp:655423", true, (test_callback_fn*)regression_bug_655423 },
+ {"lp:490520", true, (test_callback_fn*)regression_bug_490520 },
+ {"lp:854604", true, (test_callback_fn*)regression_bug_854604 },
+ {0, false, (test_callback_fn*)0}
};
test_st ketama_compatibility[]= {
- {"libmemcached", 1, (test_callback_fn*)ketama_compatibility_libmemcached },
- {"spymemcached", 1, (test_callback_fn*)ketama_compatibility_spymemcached },
+ {"libmemcached", true, (test_callback_fn*)ketama_compatibility_libmemcached },
+ {"spymemcached", true, (test_callback_fn*)ketama_compatibility_spymemcached },
{0, 0, (test_callback_fn*)0}
};
test_st generate_tests[] ={
- {"generate_pairs", 1, (test_callback_fn*)generate_pairs },
- {"generate_data", 1, (test_callback_fn*)generate_data },
- {"get_read", 0, (test_callback_fn*)get_read },
- {"delete_generate", 0, (test_callback_fn*)delete_generate },
- {"generate_buffer_data", 1, (test_callback_fn*)generate_buffer_data },
- {"delete_buffer", 0, (test_callback_fn*)delete_buffer_generate},
- {"generate_data", 1, (test_callback_fn*)generate_data },
- {"mget_read", 0, (test_callback_fn*)mget_read },
- {"mget_read_result", 0, (test_callback_fn*)mget_read_result },
- {"memcached_fetch_result() use internal result", 0, (test_callback_fn*)mget_read_internal_result },
- {"memcached_fetch_result() partial read", 0, (test_callback_fn*)mget_read_partial_result },
- {"mget_read_function", 0, (test_callback_fn*)mget_read_function },
- {"cleanup", 1, (test_callback_fn*)cleanup_pairs },
- {"generate_large_pairs", 1, (test_callback_fn*)generate_large_pairs },
- {"generate_data", 1, (test_callback_fn*)generate_data },
- {"generate_buffer_data", 1, (test_callback_fn*)generate_buffer_data },
- {"cleanup", 1, (test_callback_fn*)cleanup_pairs },
+ {"generate_pairs", true, (test_callback_fn*)generate_pairs },
+ {"generate_data", true, (test_callback_fn*)generate_data },
+ {"get_read", false, (test_callback_fn*)get_read },
+ {"delete_generate", false, (test_callback_fn*)delete_generate },
+ {"generate_buffer_data", true, (test_callback_fn*)generate_buffer_data },
+ {"delete_buffer", false, (test_callback_fn*)delete_buffer_generate},
+ {"generate_data", true, (test_callback_fn*)generate_data },
+ {"mget_read", false, (test_callback_fn*)mget_read },
+ {"mget_read_result", false, (test_callback_fn*)mget_read_result },
+ {"memcached_fetch_result() use internal result", false, (test_callback_fn*)mget_read_internal_result },
+ {"memcached_fetch_result() partial read", false, (test_callback_fn*)mget_read_partial_result },
+ {"mget_read_function", false, (test_callback_fn*)mget_read_function },
+ {"cleanup", true, (test_callback_fn*)cleanup_pairs },
+ {"generate_large_pairs", true, (test_callback_fn*)generate_large_pairs },
+ {"generate_data", true, (test_callback_fn*)generate_data },
+ {"generate_buffer_data", true, (test_callback_fn*)generate_buffer_data },
+ {"cleanup", true, (test_callback_fn*)cleanup_pairs },
{0, 0, (test_callback_fn*)0}
};
test_st consistent_tests[] ={
- {"generate_pairs", 1, (test_callback_fn*)generate_pairs },
- {"generate_data", 1, (test_callback_fn*)generate_data },
+ {"generate_pairs", true, (test_callback_fn*)generate_pairs },
+ {"generate_data", true, (test_callback_fn*)generate_data },
{"get_read", 0, (test_callback_fn*)get_read_count },
- {"cleanup", 1, (test_callback_fn*)cleanup_pairs },
+ {"cleanup", true, (test_callback_fn*)cleanup_pairs },
{0, 0, (test_callback_fn*)0}
};
test_st consistent_weighted_tests[] ={
- {"generate_pairs", 1, (test_callback_fn*)generate_pairs },
- {"generate_data", 1, (test_callback_fn*)generate_data_with_stats },
- {"get_read", 0, (test_callback_fn*)get_read_count },
- {"cleanup", 1, (test_callback_fn*)cleanup_pairs },
+ {"generate_pairs", true, (test_callback_fn*)generate_pairs },
+ {"generate_data", true, (test_callback_fn*)generate_data_with_stats },
+ {"get_read", false, (test_callback_fn*)get_read_count },
+ {"cleanup", true, (test_callback_fn*)cleanup_pairs },
{0, 0, (test_callback_fn*)0}
};
test_st hsieh_availability[] ={
- {"hsieh_avaibility_test", 0, (test_callback_fn*)hsieh_avaibility_test},
+ {"hsieh_avaibility_test", false, (test_callback_fn*)hsieh_avaibility_test},
{0, 0, (test_callback_fn*)0}
};
test_st murmur_availability[] ={
- {"murmur_avaibility_test", 0, (test_callback_fn*)murmur_avaibility_test},
+ {"murmur_avaibility_test", false, (test_callback_fn*)murmur_avaibility_test},
{0, 0, (test_callback_fn*)0}
};
#endif
test_st ketama_auto_eject_hosts[] ={
- {"auto_eject_hosts", 1, (test_callback_fn*)auto_eject_hosts },
- {"output_ketama_weighted_keys", 1, (test_callback_fn*)output_ketama_weighted_keys },
+ {"auto_eject_hosts", true, (test_callback_fn*)auto_eject_hosts },
+ {"output_ketama_weighted_keys", true, (test_callback_fn*)output_ketama_weighted_keys },
{0, 0, (test_callback_fn*)0}
};
test_st hash_tests[] ={
- {"one_at_a_time_run", 0, (test_callback_fn*)one_at_a_time_run },
- {"md5", 0, (test_callback_fn*)md5_run },
- {"crc", 0, (test_callback_fn*)crc_run },
- {"fnv1_64", 0, (test_callback_fn*)fnv1_64_run },
- {"fnv1a_64", 0, (test_callback_fn*)fnv1a_64_run },
- {"fnv1_32", 0, (test_callback_fn*)fnv1_32_run },
- {"fnv1a_32", 0, (test_callback_fn*)fnv1a_32_run },
- {"hsieh", 0, (test_callback_fn*)hsieh_run },
- {"murmur", 0, (test_callback_fn*)murmur_run },
- {"jenkis", 0, (test_callback_fn*)jenkins_run },
- {"memcached_get_hashkit", 0, (test_callback_fn*)memcached_get_hashkit_test },
+ {"one_at_a_time_run", false, (test_callback_fn*)one_at_a_time_run },
+ {"md5", false, (test_callback_fn*)md5_run },
+ {"crc", false, (test_callback_fn*)crc_run },
+ {"fnv1_64", false, (test_callback_fn*)fnv1_64_run },
+ {"fnv1a_64", false, (test_callback_fn*)fnv1a_64_run },
+ {"fnv1_32", false, (test_callback_fn*)fnv1_32_run },
+ {"fnv1a_32", false, (test_callback_fn*)fnv1a_32_run },
+ {"hsieh", false, (test_callback_fn*)hsieh_run },
+ {"murmur", false, (test_callback_fn*)murmur_run },
+ {"jenkis", false, (test_callback_fn*)jenkins_run },
+ {"memcached_get_hashkit", false, (test_callback_fn*)memcached_get_hashkit_test },
{0, 0, (test_callback_fn*)0}
};
test_st error_conditions[] ={
- {"memcached_get(MEMCACHED_ERRNO)", 0, (test_callback_fn*)memcached_get_MEMCACHED_ERRNO },
- {"memcached_get(MEMCACHED_NOTFOUND)", 0, (test_callback_fn*)memcached_get_MEMCACHED_NOTFOUND },
- {"memcached_get_by_key(MEMCACHED_ERRNO)", 0, (test_callback_fn*)memcached_get_by_key_MEMCACHED_ERRNO },
- {"memcached_get_by_key(MEMCACHED_NOTFOUND)", 0, (test_callback_fn*)memcached_get_by_key_MEMCACHED_NOTFOUND },
- {"memcached_get_by_key(MEMCACHED_NOTFOUND)", 0, (test_callback_fn*)memcached_get_by_key_MEMCACHED_NOTFOUND },
- {"memcached_increment(MEMCACHED_NO_SERVERS)", 0, (test_callback_fn*)memcached_increment_MEMCACHED_NO_SERVERS },
+ {"memcached_get(MEMCACHED_ERRNO)", false, (test_callback_fn*)memcached_get_MEMCACHED_ERRNO },
+ {"memcached_get(MEMCACHED_NOTFOUND)", false, (test_callback_fn*)memcached_get_MEMCACHED_NOTFOUND },
+ {"memcached_get_by_key(MEMCACHED_ERRNO)", false, (test_callback_fn*)memcached_get_by_key_MEMCACHED_ERRNO },
+ {"memcached_get_by_key(MEMCACHED_NOTFOUND)", false, (test_callback_fn*)memcached_get_by_key_MEMCACHED_NOTFOUND },
+ {"memcached_get_by_key(MEMCACHED_NOTFOUND)", false, (test_callback_fn*)memcached_get_by_key_MEMCACHED_NOTFOUND },
+ {"memcached_increment(MEMCACHED_NO_SERVERS)", false, (test_callback_fn*)memcached_increment_MEMCACHED_NO_SERVERS },
{0, 0, (test_callback_fn*)0}
};
-
test_st parser_tests[] ={
- {"behavior", 0, (test_callback_fn*)behavior_parser_test },
- {"boolean_options", 0, (test_callback_fn*)parser_boolean_options_test },
- {"configure_file", 0, (test_callback_fn*)memcached_create_with_options_with_filename },
- {"distribtions", 0, (test_callback_fn*)parser_distribution_test },
- {"hash", 0, (test_callback_fn*)parser_hash_test },
- {"libmemcached_check_configuration", 0, (test_callback_fn*)libmemcached_check_configuration_test },
- {"libmemcached_check_configuration_with_filename", 0, (test_callback_fn*)libmemcached_check_configuration_with_filename_test },
- {"number_options", 0, (test_callback_fn*)parser_number_options_test },
- {"randomly generated options", 0, (test_callback_fn*)random_statement_build_test },
- {"prefix_key", 0, (test_callback_fn*)parser_key_prefix_test },
- {"server", 0, (test_callback_fn*)server_test },
- {"bad server strings", 0, (test_callback_fn*)servers_bad_test },
- {"server with weights", 0, (test_callback_fn*)server_with_weight_test },
- {"parsing servername, port, and weight", 0, (test_callback_fn*)test_hostname_port_weight },
+ {"behavior", false, (test_callback_fn*)behavior_parser_test },
+ {"boolean_options", false, (test_callback_fn*)parser_boolean_options_test },
+ {"configure_file", false, (test_callback_fn*)memcached_create_with_options_with_filename },
+ {"distribtions", false, (test_callback_fn*)parser_distribution_test },
+ {"hash", false, (test_callback_fn*)parser_hash_test },
+ {"libmemcached_check_configuration", false, (test_callback_fn*)libmemcached_check_configuration_test },
+ {"libmemcached_check_configuration_with_filename", false, (test_callback_fn*)libmemcached_check_configuration_with_filename_test },
+ {"number_options", false, (test_callback_fn*)parser_number_options_test },
+ {"randomly generated options", false, (test_callback_fn*)random_statement_build_test },
+ {"namespace", false, (test_callback_fn*)parser_key_prefix_test },
+ {"server", false, (test_callback_fn*)server_test },
+ {"bad server strings", false, (test_callback_fn*)servers_bad_test },
+ {"server with weights", false, (test_callback_fn*)server_with_weight_test },
+ {"parsing servername, port, and weight", false, (test_callback_fn*)test_hostname_port_weight },
+ {"--socket=", false, (test_callback_fn*)test_parse_socket },
+ {"--namespace=", false, (test_callback_fn*)test_namespace_keyword },
{0, 0, (test_callback_fn*)0}
};
test_st virtual_bucket_tests[] ={
- {"basic", 0, (test_callback_fn*)virtual_back_map },
+ {"basic", false, (test_callback_fn*)virtual_back_map },
+ {0, 0, (test_callback_fn*)0}
+};
+
+test_st memcached_server_add_tests[] ={
+ {"memcached_server_add(\"\")", false, (test_callback_fn*)memcached_server_add_empty_test },
+ {"memcached_server_add(NULL)", false, (test_callback_fn*)memcached_server_add_null_test },
{0, 0, (test_callback_fn*)0}
};
#if 0
{"hash_sanity", 0, 0, hash_sanity},
#endif
+ {"libmemcachedutil", 0, 0, libmemcachedutil_tests},
{"basic", 0, 0, basic_tests},
{"hsieh_availability", 0, 0, hsieh_availability},
{"murmur_availability", 0, 0, murmur_availability},
+ {"memcached_server_add", 0, 0, memcached_server_add_tests},
{"block", 0, 0, tests},
{"binary", (test_callback_fn*)pre_binary, 0, tests},
{"nonblock", (test_callback_fn*)pre_nonblock, 0, tests},
{"ketama_auto_eject_hosts", (test_callback_fn*)pre_behavior_ketama, 0, ketama_auto_eject_hosts},
{"unix_socket", (test_callback_fn*)pre_unix_socket, 0, tests},
{"unix_socket_nodelay", (test_callback_fn*)pre_nodelay, 0, tests},
- {"poll_timeout", (test_callback_fn*)poll_timeout, 0, tests},
{"gets", (test_callback_fn*)enable_cas, 0, tests},
{"consistent_crc", (test_callback_fn*)enable_consistent_crc, 0, tests},
{"consistent_hsieh", (test_callback_fn*)enable_consistent_hsieh, 0, tests},
{"namespace(BINARY)", (test_callback_fn*)set_namespace_and_binary, 0, tests},
{"specific namespace", 0, 0, namespace_tests},
{"specific namespace(BINARY)", (test_callback_fn*)pre_binary, 0, namespace_tests},
- {"sasl_auth", (test_callback_fn*)pre_sasl, 0, sasl_auth_tests },
- {"sasl", (test_callback_fn*)pre_sasl, 0, tests },
{"version_1_2_3", (test_callback_fn*)check_for_1_2_3, 0, version_1_2_3},
- {"string", 0, 0, string_tests},
{"result", 0, 0, result_tests},
{"async", (test_callback_fn*)pre_nonblock, 0, async_tests},
{"async(BINARY)", (test_callback_fn*)pre_nonblock_binary, 0, async_tests},
{"Cal Haldenbrand's tests", 0, 0, haldenbrand_tests},
- {"user", 0, 0, user_tests},
+ {"user written tests", 0, 0, user_tests},
{"generate", 0, 0, generate_tests},
{"generate_hsieh", (test_callback_fn*)pre_hsieh, 0, generate_tests},
{"generate_ketama", (test_callback_fn*)pre_behavior_ketama, 0, generate_tests},
{"parser", 0, 0, parser_tests},
{"virtual buckets", 0, 0, virtual_bucket_tests},
{"memcached_server_get_last_disconnect", 0, 0, memcached_server_get_last_disconnect_tests},
+ {"touch", 0, 0, touch_tests},
{0, 0, 0, 0}
};
+#define TEST_PORT_BASE MEMCACHED_DEFAULT_PORT +10
+
#include "tests/libmemcached_world.h"
void get_world(Framework *world)
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);
+
+ world->set_socket();
}