#include <libhashkit-1.0/hashkit.h>
-#include <cassert>
#include <cerrno>
#include <memory>
#include <pthread.h>
#define UUID_STRING_MAXLENGTH 36
-struct keys_st {
-public:
- keys_st(size_t arg)
- {
- init(arg, UUID_STRING_MAXLENGTH);
- }
-
- keys_st(size_t arg, size_t padding)
- {
- init(arg, padding);
- }
-
- void init(size_t arg, size_t padding)
- {
- _lengths.resize(arg);
- _keys.resize(arg);
-
- for (size_t x= 0; x < _keys.size(); x++)
- {
- libtest::vchar_t key_buffer;
- key_buffer.resize(padding +1);
- memset(&key_buffer[0], 'x', padding);
-
- if (HAVE_LIBUUID)
- {
-#if defined(HAVE_LIBUUID) && HAVE_LIBUUID
- uuid_t out;
- uuid_generate(out);
-
- uuid_unparse(out, &key_buffer[0]);
- _keys[x]= strdup(&key_buffer[0]);
- (_keys[x])[UUID_STRING_MAXLENGTH]= 'x';
-#endif
- }
- else // We just use a number and pad the string if UUID is not available
- {
- char int_buffer[MEMCACHED_MAXIMUM_INTEGER_DISPLAY_LENGTH +1];
- int key_length= snprintf(int_buffer, sizeof(int_buffer), "%u", uint32_t(x));
- memcpy(&key_buffer[0], int_buffer, key_length);
- _keys[x]= strdup(&key_buffer[0]);
- }
- _lengths[x]= padding;
- }
- }
-
- ~keys_st()
- {
- for (libtest::vchar_ptr_t::iterator iter= _keys.begin();
- iter != _keys.end();
- iter++)
- {
- ::free(*iter);
- }
- }
-
- libtest::vchar_ptr_t::iterator begin()
- {
- return _keys.begin();
- }
-
- libtest::vchar_ptr_t::iterator end()
- {
- return _keys.end();
- }
-
- size_t size() const
- {
- return _keys.size();
- }
-
- std::vector<size_t>& lengths()
- {
- return _lengths;
- }
-
- libtest::vchar_ptr_t& keys()
- {
- return _keys;
- }
-
- size_t* lengths_ptr()
- {
- return &_lengths[0];
- }
-
- char** keys_ptr()
- {
- return &_keys[0];
- }
-
- char* key_at(size_t arg)
- {
- return _keys[arg];
- }
-
- size_t length_at(size_t arg)
- {
- return _lengths[arg];
- }
-
-private:
- libtest::vchar_ptr_t _keys;
- std::vector<size_t> _lengths;
-};
-
-static memcached_return_t return_value_based_on_buffering(memcached_st *memc)
-{
- if (memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_BUFFER_REQUESTS))
- {
- return MEMCACHED_BUFFERED;
- }
-
- return MEMCACHED_SUCCESS;
-}
+#include "tests/keys.hpp"
static memcached_st * create_single_instance_memcached(const memcached_st *original_memc, const char *options)
{
/* Do Nothing */
size_t bigger= *((size_t *)(context));
(void)ptr;
- assert(bigger <= memcached_server_port(server));
+ fatal_assert(bigger <= memcached_server_port(server));
*((size_t *)(context))= memcached_server_port(server);
return MEMCACHED_SUCCESS;
test_literal_param("foo"),
test_literal_param("when we sanitize"),
time_t(0), (uint32_t)0);
- test_true_got(rc == MEMCACHED_SUCCESS or rc == MEMCACHED_BUFFERED, memcached_strerror(NULL, rc));
+ test_true_got(rc == MEMCACHED_SUCCESS or rc == MEMCACHED_BUFFERED, memcached_last_error_message(memc));
return TEST_SUCCESS;
}
iter != keys.end();
iter++)
{
- test_compare(MEMCACHED_SUCCESS,
- memcached_set(memc,
- (*iter), 36,
- NULL, 0,
- time_t(0), uint32_t(0)));
+ test_compare_hint(MEMCACHED_SUCCESS,
+ memcached_set(memc,
+ (*iter), 36,
+ NULL, 0,
+ time_t(0), uint32_t(0)),
+ memcached_last_error_message(memc));
}
for (ptrdiff_t loop= 0; loop < 20; loop++)
{
result_count++;
}
- test_compare(keys.size(), result_count);
+ test_true(keys.size() >= result_count);
}
else
{
memcached_return_t rc;
char *out_value= memcached_get(memc, keys.key_at(which_key), keys.length_at(which_key),
&value_length, &flags, &rc);
- test_compare(MEMCACHED_SUCCESS, rc);
+ if (rc == MEMCACHED_NOTFOUND)
+ { } // It is possible that the value has been purged.
+ else
+ {
+ test_compare_hint(MEMCACHED_SUCCESS, rc, memcached_last_error_message(memc));
+ }
test_null(out_value);
test_zero(value_length);
test_zero(flags);
test_return_t replace_test(memcached_st *memc)
{
- test_compare(return_value_based_on_buffering(memc),
- memcached_set(memc,
- test_literal_param(__func__),
- test_literal_param("when we sanitize"),
- time_t(0), uint32_t(0)));
+ test_compare_hint(return_value_based_on_buffering(memc),
+ memcached_set(memc,
+ test_literal_param(__func__),
+ test_literal_param("when we sanitize"),
+ time_t(0), uint32_t(0)),
+ memcached_last_error_message(memc));
- test_compare(MEMCACHED_SUCCESS,
- memcached_replace(memc,
- test_literal_param(__func__),
- test_literal_param("first we insert some data"),
- time_t(0), uint32_t(0)));
+ test_compare_hint(MEMCACHED_SUCCESS,
+ memcached_replace(memc,
+ test_literal_param(__func__),
+ test_literal_param("first we insert some data"),
+ time_t(0), uint32_t(0)),
+ memcached_last_error_message(memc));
return TEST_SUCCESS;
}
test_return_t delete_test(memcached_st *memc)
{
- test_compare(return_value_based_on_buffering(memc),
- memcached_set(memc,
- test_literal_param(__func__),
- test_literal_param("when we sanitize"),
- time_t(0), uint32_t(0)));
+ test_compare_hint(return_value_based_on_buffering(memc),
+ memcached_set(memc,
+ test_literal_param(__func__),
+ test_literal_param("when we sanitize"),
+ time_t(0), uint32_t(0)),
+ memcached_last_error_message(memc));
test_compare_hint(return_value_based_on_buffering(memc),
memcached_delete(memc,
size_t key_length,
memcached_result_st *result)
{
- (void)memc;(void)key;(void)key_length;
+ (void)memc;(void)key;(void)key_length;
return memcached_result_set_value(result, READ_THROUGH_VALUE, strlen(READ_THROUGH_VALUE));
}
return TEST_SUCCESS;
}
-test_return_t get_test(memcached_st *memc)
-{
- uint64_t query_id= memcached_query_id(memc);
- memcached_return_t rc= memcached_delete(memc,
- test_literal_param(__func__),
- time_t(0));
- test_true_hint(rc == MEMCACHED_BUFFERED or rc == MEMCACHED_NOTFOUND, memcached_last_error_message(memc));
- test_compare(query_id +1, memcached_query_id(memc));
-
- size_t string_length;
- uint32_t flags;
- char *string= memcached_get(memc,
- test_literal_param(__func__),
- &string_length, &flags, &rc);
-
- test_compare_got(MEMCACHED_NOTFOUND, rc, memcached_last_error_message(memc));
- test_false(string_length);
- test_false(string);
-
- return TEST_SUCCESS;
-}
-
-test_return_t get_test2(memcached_st *memc)
-{
- const char *value= "when we sanitize";
-
- uint64_t query_id= memcached_query_id(memc);
- test_compare(return_value_based_on_buffering(memc),
- memcached_set(memc,
- test_literal_param(__func__),
- value, strlen(value),
- time_t(0), uint32_t(0)));
- test_compare(query_id +1, memcached_query_id(memc));
-
- query_id= memcached_query_id(memc);
- test_true(query_id);
-
- uint32_t flags;
- size_t string_length;
- memcached_return_t rc;
- char *string= memcached_get(memc,
- test_literal_param(__func__),
- &string_length, &flags, &rc);
- test_compare(query_id +1, memcached_query_id(memc));
-
- test_compare_got(MEMCACHED_SUCCESS, rc, memcached_strerror(NULL, rc));
- test_compare_got(MEMCACHED_SUCCESS, memcached_last_error(memc), memcached_last_error_message(memc));
- test_true(string);
- test_compare(strlen(value), string_length);
- test_memcmp(string, value, string_length);
-
- free(string);
-
- return TEST_SUCCESS;
-}
-
test_return_t set_test2(memcached_st *memc)
{
for (uint32_t x= 0; x < 10; x++)
{
- test_compare(return_value_based_on_buffering(memc),
- memcached_set(memc,
- test_literal_param("foo"),
- test_literal_param("train in the brain"),
- time_t(0), uint32_t(0)));
+ test_compare_hint(return_value_based_on_buffering(memc),
+ memcached_set(memc,
+ test_literal_param("foo"),
+ test_literal_param("train in the brain"),
+ time_t(0), uint32_t(0)),
+ memcached_last_error_message(memc));
}
return TEST_SUCCESS;
return TEST_SUCCESS;
}
-test_return_t get_test3(memcached_st *memc)
-{
- size_t value_length= 8191;
-
- libtest::vchar_t value;
- value.reserve(value_length);
- for (uint32_t x= 0; x < value_length; x++)
- {
- value.push_back(char(x % 127));
- }
-
- test_compare_hint(return_value_based_on_buffering(memc),
- memcached_set(memc,
- test_literal_param(__func__),
- &value[0], value.size(),
- time_t(0), uint32_t(0)),
- memcached_last_error_message(memc));
-
- size_t string_length;
- uint32_t flags;
- memcached_return_t rc;
- char *string= memcached_get(memc,
- test_literal_param(__func__),
- &string_length, &flags, &rc);
-
- test_compare(MEMCACHED_SUCCESS, rc);
- test_true(string);
- test_compare(value.size(), string_length);
- test_memcmp(string, &value[0], string_length);
-
- free(string);
-
- return TEST_SUCCESS;
-}
-
-test_return_t get_test4(memcached_st *memc)
-{
- size_t value_length= 8191;
-
- libtest::vchar_t value;
- value.reserve(value_length);
- for (uint32_t x= 0; x < value_length; x++)
- {
- value.push_back(char(x % 127));
- }
-
- test_compare_hint(return_value_based_on_buffering(memc),
- memcached_set(memc,
- test_literal_param(__func__),
- &value[0], value.size(),
- time_t(0), uint32_t(0)),
- memcached_last_error_message(memc));
-
- for (uint32_t x= 0; x < 10; x++)
- {
- uint32_t flags;
- size_t string_length;
- memcached_return_t rc;
- char *string= memcached_get(memc,
- test_literal_param(__func__),
- &string_length, &flags, &rc);
-
- test_compare(MEMCACHED_SUCCESS, rc);
- test_true(string);
- test_compare(value.size(), string_length);
- test_memcmp(string, &value[0], string_length);
- free(string);
- }
-
- return TEST_SUCCESS;
-}
-
-/*
- * This test verifies that memcached_read_one_response doesn't try to
- * dereference a NIL-pointer if you issue a multi-get and don't read out all
- * responses before you execute a storage command.
- */
-test_return_t get_test5(memcached_st *memc)
-{
- /*
- ** Request the same key twice, to ensure that we hash to the same server
- ** (so that we have multiple response values queued up) ;-)
- */
- const char *keys[]= { "key", "key" };
- size_t lengths[]= { 3, 3 };
- uint32_t flags;
- size_t rlen;
-
- test_compare_hint(return_value_based_on_buffering(memc),
- memcached_set(memc, keys[0], lengths[0],
- keys[0], lengths[0],
- time_t(0), uint32_t(0)),
- memcached_last_error_message(memc));
- test_compare(MEMCACHED_SUCCESS, memcached_mget(memc, keys, lengths, test_array_length(keys)));
-
- memcached_result_st results_obj;
- memcached_result_st *results= memcached_result_create(memc, &results_obj);
- test_true(results);
-
- memcached_return_t rc;
- results= memcached_fetch_result(memc, &results_obj, &rc);
- test_true(results);
-
- memcached_result_free(&results_obj);
-
- /* Don't read out the second result, but issue a set instead.. */
- test_compare(MEMCACHED_SUCCESS, memcached_set(memc, keys[0], lengths[0], keys[0], lengths[0], 0, 0));
-
- char *val= memcached_get_by_key(memc, keys[0], lengths[0], "yek", 3,
- &rlen, &flags, &rc);
- test_false(val);
- test_compare(MEMCACHED_NOTFOUND, rc);
- val= memcached_get(memc, keys[0], lengths[0], &rlen, &flags, &rc);
- test_true(val);
- test_compare(MEMCACHED_SUCCESS, rc);
- free(val);
-
- return TEST_SUCCESS;
-}
-
test_return_t mget_end(memcached_st *memc)
{
const char *keys[]= { "foo", "foo2" };
{
const char *value= "sanford and sun";
- test_compare(return_value_based_on_buffering(memc),
- memcached_set(memc,
- test_literal_param(__func__),
- value, strlen(value),
- (time_t)10, (uint32_t)3));
+ test_compare_hint(return_value_based_on_buffering(memc),
+ memcached_set(memc,
+ test_literal_param(__func__),
+ value, strlen(value),
+ (time_t)10, (uint32_t)3),
+ memcached_last_error_message(memc));
memcached_quit(memc);
- test_compare(return_value_based_on_buffering(memc),
- memcached_set(memc,
- test_literal_param(__func__),
- value, strlen(value),
- (time_t)50, (uint32_t)9));
+ test_compare_hint(return_value_based_on_buffering(memc),
+ memcached_set(memc,
+ test_literal_param(__func__),
+ value, strlen(value),
+ (time_t)50, (uint32_t)9),
+ memcached_last_error_message(memc));
return TEST_SUCCESS;
}
blob, sizeof(blob),
0, 0);
test_true_got(rc == MEMCACHED_SUCCESS or rc == MEMCACHED_BUFFERED,
- memcached_strerror(NULL, rc));
+ memcached_last_error_message(memc));
test_compare(query_id +1, memcached_query_id(memc));
}
}
#define REGRESSION_BINARY_VS_BLOCK_COUNT 20480
-static pairs_st *global_pairs;
+static pairs_st *global_pairs= NULL;
test_return_t key_setup(memcached_st *memc)
{
test_return_t key_teardown(memcached_st *)
{
pairs_free(global_pairs);
+ global_pairs= NULL;
return TEST_SUCCESS;
}
/* First add all of the items.. */
for (ptrdiff_t x= 0; x < REGRESSION_BINARY_VS_BLOCK_COUNT; ++x)
{
- char blob[1024] = {0};
+ libtest::vchar_t blob;
+ libtest::vchar::make(blob, 1024);
- memcached_return_t rc= memcached_add_by_key(memc, "bob", 3, global_pairs[x].key, global_pairs[x].key_length, blob, sizeof(blob), 0, 0);
+ memcached_return_t rc= memcached_add_by_key(memc,
+ test_literal_param("bob"),
+ global_pairs[x].key, global_pairs[x].key_length,
+ &blob[0], blob.size(),
+ time_t(0), uint32_t(0));
test_true_got(rc == MEMCACHED_SUCCESS or rc == MEMCACHED_SERVER_MEMORY_ALLOCATION_FAILURE, memcached_strerror(NULL, rc));
}
/* sighandler_t function that always asserts false */
static void fail(int)
{
- assert(0);
+ fatal_assert(0);
}
uint32_t flags;
char* value=memcached_get(memc, key, strlen(key),
&length, &flags, &ret);
- test_true_got(ret == MEMCACHED_SUCCESS && value != NULL, memcached_strerror(NULL, ret));
+ // For the moment we will just go to the next key
+ if (MEMCACHED_TIMEOUT == ret)
+ {
+ continue;
+ }
+ test_true_hint(ret == MEMCACHED_SUCCESS and value != NULL, memcached_last_error_message(memc));
switch (count)
{
case 0: /* FALLTHROUGH */
return TEST_SUCCESS;
}
+test_return_t regression_996813_TEST(memcached_st *)
+{
+ memcached_st* memc= memcached_create(NULL);
+
+ test_compare(MEMCACHED_SUCCESS, memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_DISTRIBUTION, MEMCACHED_DISTRIBUTION_CONSISTENT_KETAMA));
+ test_compare(MEMCACHED_SUCCESS, memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_NO_BLOCK, 1));
+ test_compare(MEMCACHED_SUCCESS, memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_TCP_NODELAY, 1));
+ test_compare(MEMCACHED_SUCCESS, memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL, 1));
+ test_compare(MEMCACHED_SUCCESS, memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_POLL_TIMEOUT, 1));
+ test_compare(MEMCACHED_SUCCESS, memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_CONNECT_TIMEOUT, 300));
+ test_compare(MEMCACHED_SUCCESS, memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_RETRY_TIMEOUT, 30));
+
+ // We will never connect to these servers
+ in_port_t base_port= 11211;
+ for (size_t x= 0; x < 17; x++)
+ {
+ test_compare(MEMCACHED_SUCCESS, memcached_server_add(memc, "10.2.3.4", base_port +x));
+ }
+ test_compare(16U, memcached_generate_hash(memc, test_literal_param("SZ6hu0SHweFmpwpc0w2R")));
+ test_compare(1U, memcached_generate_hash(memc, test_literal_param("SQCK9eiCf53YxHWnYA.o")));
+ test_compare(10U, memcached_generate_hash(memc, test_literal_param("SUSDkGXuuZC9t9VhMwa.")));
+ test_compare(8U, memcached_generate_hash(memc, test_literal_param("SnnqnJARfaCNT679iAF_")));
+
+ memcached_free(memc);
+
+ return TEST_SUCCESS;
+}
+
/*
* Test that ensures mget_execute does not end into recursive calls that finally fails
}
+test_return_t regression_994772_TEST(memcached_st* memc)
+{
+ test_skip(MEMCACHED_SUCCESS, memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL, 1));
+
+ test_compare(MEMCACHED_SUCCESS,
+ memcached_set(memc,
+ test_literal_param(__func__), // Key
+ test_literal_param(__func__), // Value
+ time_t(0), uint32_t(0)));
+
+ const char *keys[] = { __func__ };
+ size_t key_length[]= { strlen(__func__) };
+ test_compare(MEMCACHED_SUCCESS,
+ memcached_mget(memc, keys, key_length, 1));
+
+ memcached_return_t rc;
+ memcached_result_st *results= memcached_fetch_result(memc, NULL, &rc);
+ test_true(results);
+ test_compare(MEMCACHED_SUCCESS, rc);
+
+ test_strcmp(__func__, memcached_result_value(results));
+ uint64_t cas_value= memcached_result_cas(results);
+ test_true(cas_value);
+
+ memcached_result_free(results);
+
+ // Bad cas value, sanity check
+ test_true(cas_value != 9999);
+ test_compare(MEMCACHED_END,
+ memcached_cas(memc,
+ test_literal_param(__func__), // Key
+ test_literal_param(__FILE__), // Value
+ time_t(0), uint32_t(0), 9999));
+
+ test_compare(MEMCACHED_SUCCESS, memcached_set(memc,
+ "different", strlen("different"), // Key
+ test_literal_param(__FILE__), // Value
+ time_t(0), uint32_t(0)));
+
+ return TEST_SUCCESS;
+}
+
test_return_t regression_bug_854604(memcached_st *)
{
char buffer[1024];
0, 0));
test_true_got(kill(pid, SIGHUP) == 0, strerror(errno));
- test_compare(MEMCACHED_SUCCESS,
+ test_compare(MEMCACHED_CONNECTION_FAILURE,
memcached_set(memc,
test_literal_param(__func__), // Keys
test_literal_param(__func__), // Values
projects / m6w6 / libmemcached / blobdiff