Test cases
*/
-#define BUILDING_LIBMEMCACHED
-// !NEVER use common.h, always use memcached.h in your own apps
-#include <libmemcached/common.h>
+#include <libmemcached/memcached.h>
+#include <libmemcached/is.h>
+#include <libmemcached/server_instance.h>
+
+#include <libhashkit/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/callbacks.h"
#include "tests/pool.h"
-#include "tests/namespace.h"
-#include "tests/string.h"
-#include "tests/replication.h"
-#include "tests/debug.h"
-#include "tests/basic.h"
-#include "tests/error_conditions.h"
#include "tests/print.h"
+#include "tests/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/memcached_util.h>
#include "hash_results.h"
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(47, int(MEMCACHED_MAXIMUM_RETURN));
+ test_compare(48, int(MEMCACHED_MAXIMUM_RETURN));
return TEST_SUCCESS;
}
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_zero(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_zero(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.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_zero(string_length);
- test_false(string);
- 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_zero(string_length);
- test_false(string);
-
- free(longkey);
}
}
/* 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_zero(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;
memcached_return_t rc= memcached_set(memc, key, strlen(key),
value, value_length,
(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));
}
// 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;
}
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
+ }
+
test_compare(MEMCACHED_SUCCESS, memcached_stat_servername(&memc_stat, NULL,
memcached_server_name(instance),
memcached_server_port(instance)));
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 or 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),
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,
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(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));
}
/* 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);
+ memcached_behavior_set(mclone, MEMCACHED_BEHAVIOR_POLL_TIMEOUT, uint64_t(0));
char *value= (char*)malloc(value_length * sizeof(char));
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, value_length, 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)
*/
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;
+ 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;
}
*/
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),
+ 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;
-
- rc= memcached_set(memc, key, strlen(key),
- value, strlen(value),
- (time_t)0, 0);
+ memcached_return_t rc= memcached_set(memc, key, strlen(key),
+ value, strlen(value),
+ (time_t)0, 0);
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);
/* 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_rc= pre_binary(memc);
if (test_rc != TEST_SUCCESS)
+ {
return test_rc;
+ }
/* 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;
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;
unsigned int keys_returned;
test_compare(TEST_SUCCESS, fetch_all_results(memc, keys_returned, MEMCACHED_SUCCESS));
test_true(keys_returned > 0);
- test_compare(global_count, keys_returned);
+ 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)))
{
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++)
{
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;
}
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 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 */
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);
return TEST_SUCCESS;
}
-static test_return_t poll_timeout(memcached_st *memc)
+static test_return_t MEMCACHED_BEHAVIOR_POLL_TIMEOUT_test(memcached_st *memc)
{
const uint64_t timeout= 100; // Not using, just checking that it sets
memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_POLL_TIMEOUT, 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));
}
/*
}
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!
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 */
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);
return TEST_SUCCESS;
}
-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);
+ test_true(pool);
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);
+ memcached_return_t rc;
+ mmc[x]= memcached_pool_fetch(pool, NULL, &rc);
test_compare(MEMCACHED_SUCCESS, rc);
+ test_true(mmc[x]);
}
// All memc should be gone
- test_true(memcached_pool_pop(pool, false, &rc) == NULL);
- test_compare(MEMCACHED_SUCCESS, rc);
+ {
+ memcached_return_t rc;
+ test_null(memcached_pool_fetch(pool, NULL, &rc));
+ test_compare(MEMCACHED_NOTFOUND, rc);
+ }
- pthread_t tid;
- test_pool_context_st item= { pool, mmc[9] };
+ // Release them..
+ for (size_t x= 0; x < POOL_SIZE; ++x)
+ {
+ if (mmc[x])
+ {
+ test_compare(MEMCACHED_SUCCESS, memcached_pool_release(pool, mmc[x]));
+ }
+ }
+ test_true(memcached_pool_destroy(pool) == memc);
- 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);
+ return TEST_SUCCESS;
+}
+
+static test_return_t connection_pool2_test(memcached_st *memc)
+{
+ memcached_pool_st* pool= memcached_pool_create(memc, 5, POOL_SIZE);
+ test_true(pool);
+ memcached_st *mmc[POOL_SIZE];
+
+ // Fill up our array that we will store the memc that are in the pool
+ for (size_t x= 0; x < POOL_SIZE; ++x)
+ {
+ memcached_return_t rc;
+ mmc[x]= memcached_pool_fetch(pool, NULL, &rc);
+ test_compare(MEMCACHED_SUCCESS, rc);
+ test_true(mmc[x]);
+ }
+
+ // All memc should be gone
+ {
+ memcached_return_t rc;
+ test_null(memcached_pool_fetch(pool, NULL, &rc));
+ test_compare(MEMCACHED_NOTFOUND, rc);
+ }
// verify that I can do ops with all connections
test_compare(MEMCACHED_SUCCESS,
- memcached_set(mmc[0], key, keylen, "0", 1, 0, 0));
+ memcached_set(mmc[0],
+ test_literal_param("key"),
+ "0", 1, 0, 0));
for (uint64_t x= 0; x < POOL_SIZE; ++x)
{
uint64_t number_value;
test_compare(MEMCACHED_SUCCESS,
- memcached_increment(mmc[x], key, keylen, 1, &number_value));
+ memcached_increment(mmc[x],
+ test_literal_param("key"),
+ 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]));
+ test_compare(MEMCACHED_SUCCESS, memcached_pool_release(pool, mmc[x]));
}
* 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);
+ mmc[0]= memcached_pool_fetch(pool, NULL, NULL);
test_true(mmc[0]);
- rc= memcached_pool_behavior_set(pool, MEMCACHED_BEHAVIOR_IO_MSG_WATERMARK, 9999);
- test_compare(MEMCACHED_SUCCESS, rc);
+ test_compare(MEMCACHED_SUCCESS,
+ memcached_pool_behavior_set(pool, MEMCACHED_BEHAVIOR_IO_MSG_WATERMARK, 9999));
- mmc[1]= memcached_pool_pop(pool, false, &rc);
- test_true(mmc[1]);
+ {
+ memcached_return_t rc;
+ mmc[1]= memcached_pool_fetch(pool, NULL, &rc);
+ test_true(mmc[1]);
+ test_compare(MEMCACHED_SUCCESS, rc);
+ }
test_compare(UINT64_C(9999), memcached_behavior_get(mmc[1], MEMCACHED_BEHAVIOR_IO_MSG_WATERMARK));
- test_compare(MEMCACHED_SUCCESS, memcached_pool_push(pool, mmc[1]));
- test_compare(MEMCACHED_SUCCESS, memcached_pool_push(pool, mmc[0]));
+ test_compare(MEMCACHED_SUCCESS, memcached_pool_release(pool, mmc[1]));
+ test_compare(MEMCACHED_SUCCESS, memcached_pool_release(pool, mmc[0]));
+
+ {
+ memcached_return_t rc;
+ mmc[0]= memcached_pool_fetch(pool, NULL, &rc);
+ test_true(mmc[0]);
+ test_compare(MEMCACHED_SUCCESS, rc);
+ }
- mmc[0]= memcached_pool_pop(pool, false, &rc);
test_compare(UINT64_C(9999), memcached_behavior_get(mmc[0], MEMCACHED_BEHAVIOR_IO_MSG_WATERMARK));
- test_compare(MEMCACHED_SUCCESS, memcached_pool_push(pool, mmc[0]));
+ test_compare(MEMCACHED_SUCCESS, memcached_pool_release(pool, mmc[0]));
+
+ test_true(memcached_pool_destroy(pool) == memc);
+
+ return TEST_SUCCESS;
+}
+
+struct test_pool_context_st {
+ volatile memcached_return_t rc;
+ memcached_pool_st* pool;
+ memcached_st* mmc;
+ sem_t _lock;
+
+ test_pool_context_st(memcached_pool_st *pool_arg, memcached_st *memc_arg):
+ rc(MEMCACHED_FAILURE),
+ pool(pool_arg),
+ mmc(memc_arg)
+ {
+ sem_init(&_lock, 0, 0);
+ }
+
+ void wait()
+ {
+ sem_wait(&_lock);
+ }
+
+ void release()
+ {
+ sem_post(&_lock);
+ }
+
+ ~test_pool_context_st()
+ {
+ sem_destroy(&_lock);
+ }
+};
+
+static void* connection_release(void *arg)
+{
+ test_pool_context_st *resource= static_cast<test_pool_context_st *>(arg);
+ assert(resource);
+ if (resource == NULL)
+ {
+ abort();
+ }
+
+ // Release all of the memc we are holding
+ resource->rc= memcached_pool_release(resource->pool, resource->mmc);
+ resource->release();
+
+ pthread_exit(arg);
+}
+
+static test_return_t connection_pool3_test(memcached_st *memc)
+{
+#ifdef __APPLE__
+ return TEST_SKIPPED;
+#endif
+
+ memcached_pool_st* pool= memcached_pool_create(memc, 1, 1);
+ test_true(pool);
+
+ memcached_st *pool_memc;
+ {
+ memcached_return_t rc;
+ pool_memc= memcached_pool_fetch(pool, NULL, &rc);
+ test_compare(MEMCACHED_SUCCESS, rc);
+ test_true(pool_memc);
+ }
+
+ /*
+ @note This comment was written to describe what was believed to be the original authors intent.
+
+ This portion of the test creates a thread that will wait until told to free a memcached_st
+ that will be grabbed by the main thread.
+
+ It is believed that this tests whether or not we are handling ownership correctly.
+ */
+ pthread_t tid;
+ test_pool_context_st item(pool, pool_memc);
+
+ test_zero(pthread_create(&tid, NULL, connection_release, &item));
+ item.wait();
+
+ memcached_return_t rc;
+ memcached_st *pop_memc;
+ // We do a hard loop, and try N times
+ int counter= 5;
+ do
+ {
+ struct timespec relative_time= { 0, 0 };
+ pop_memc= memcached_pool_fetch(pool, &relative_time, &rc);
+
+ if (memcached_success(rc))
+ {
+ break;
+ }
+
+ if (memcached_failed(rc))
+ {
+ test_null(pop_memc);
+ test_true(rc != MEMCACHED_TIMEOUT); // As long as relative_time is zero, MEMCACHED_TIMEOUT is invalid
+ }
+ } while (--counter);
+
+ if (memcached_failed(rc)) // Cleanup thread since we will exit once we test.
+ {
+ pthread_join(tid, NULL);
+ test_compare(MEMCACHED_SUCCESS, rc);
+ }
+
+ {
+ int pthread_ret= pthread_join(tid, NULL);
+ test_true(pthread_ret == 0 or pthread_ret == ESRCH);
+ }
+ test_compare(MEMCACHED_SUCCESS, rc);
+ test_true(pool_memc == pop_memc);
test_true(memcached_pool_destroy(pool) == memc);
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 == 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);
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;
}
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;
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;
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 *)
{
+ test_skip(true, libhashkit_has_algorithm(HASHKIT_HASH_FNV1_64));
+
uint32_t x;
const char **ptr;
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 *)
{
+ test_skip(true, libhashkit_has_algorithm(HASHKIT_HASH_FNV1A_64));
+
uint32_t x;
const char **ptr;
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;
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;
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 *)
{
+ test_skip(true, libhashkit_has_algorithm(HASHKIT_HASH_HSIEH));
+
uint32_t x;
const char **ptr;
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 *)
{
+ test_skip(true, libhashkit_has_algorithm(HASHKIT_HASH_MURMUR));
+
#ifdef WORDS_BIGENDIAN
(void)murmur_values;
return TEST_SKIPPED;
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;
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);
}
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_zero(len);
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));
-
- test_compare(uint64_t(1), 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(8U, memcached_server_count(memc));
- test_strcmp(server_pool[0].hostname, "10.0.1.1");
- test_compare(in_port_t(11211), server_pool[0].port);
- test_compare(600U, server_pool[0].weight);
- test_strcmp(server_pool[2].hostname, "10.0.1.3");
- test_compare(in_port_t(11211), server_pool[2].port);
- test_compare(200U, server_pool[2].weight);
- test_strcmp(server_pool[7].hostname, "10.0.1.8");
- test_compare(in_port_t(11211), server_pool[7].port);
- test_compare(100U, server_pool[7].weight);
-
- /* VDEAAAAA hashes to fffcd1b5, after the last continuum point, and lets
- * us test the boundary wraparound.
- */
- test_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 *)
-{
- memcached_st *memc= memcached_create(NULL);
- test_true(memc);
-
- test_compare(MEMCACHED_SUCCESS,
- memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_KETAMA_WEIGHTED, 1));
-
- test_compare(UINT64_C(1), memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_KETAMA_WEIGHTED));
-
- test_compare(MEMCACHED_SUCCESS, memcached_behavior_set_distribution(memc, MEMCACHED_DISTRIBUTION_CONSISTENT_KETAMA_SPY));
- test_compare(MEMCACHED_DISTRIBUTION_CONSISTENT_KETAMA_SPY, memcached_behavior_get_distribution(memc));
-
- memcached_server_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(8U, memcached_server_count(memc));
- test_strcmp(server_pool[0].hostname, "10.0.1.1");
- test_compare(in_port_t(11211), server_pool[0].port);
- test_compare(600U, server_pool[0].weight);
- test_strcmp(server_pool[2].hostname, "10.0.1.3");
- test_compare(in_port_t(11211), server_pool[2].port);
- test_compare(200U, server_pool[2].weight);
- test_strcmp(server_pool[7].hostname, "10.0.1.8");
- test_compare(in_port_t(11211), server_pool[7].port);
- test_compare(100U, server_pool[7].weight);
-
- /* VDEAAAAA hashes to fffcd1b5, after the last continuum point, and lets
- * us test the boundary wraparound.
- */
- test_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;
{
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)
-{
- if (memcached_server_count(memc) < 2)
- return TEST_SKIPPED;
-
- 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(1U, 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(MEMCACHED_SUCCESS,
- memcached_set(local_memc, "foo", strlen("foo"), NULL, 0, (time_t)0, (uint32_t)0));
-#if 0
- memcached_last_error_message(local_memc));
-#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);
-
- if (count < 2)
- {
- return TEST_SKIPPED;
- }
-
- // 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,
test_compare(MEMCACHED_SUCCESS, rc);
test_true(value);
- test_compare(100UL, value_length);
+ test_compare(100LLU, value_length);
free(value);
}
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 },
- {"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 },
{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()", 1, (test_callback_fn*)ping_test },
- {"libmemcached_util_getpid()", 1, (test_callback_fn*)getpid_test },
- {"libmemcached_util_getpid(MEMCACHED_CONNECTION_FAILURE)", 1, (test_callback_fn*)getpid_connection_failure_test },
+ {"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..
** 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 },
+ {"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 },
+ {"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", 0, (test_callback_fn*)replication_randomize_mget_test },
- {"fail", 0, (test_callback_fn*)replication_randomize_mget_fail_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 },
- {"namespace", 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 },
- {"--socket=", 0, (test_callback_fn*)test_parse_socket },
- {"--namespace=", 0, (test_callback_fn*)test_namespace_keyword },
+ {"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}
};
{"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},
{0, 0, 0, 0}
};
+#define TEST_PORT_BASE MEMCACHED_DEFAULT_PORT +10
+
#include "tests/libmemcached_world.h"
void get_world(Framework *world)