#include "tests/ketama.h"
#include "tests/namespace.h"
#include "tests/parser.h"
+#include "tests/libmemcached-1.0/dump.h"
+#include "tests/libmemcached-1.0/stat.h"
#include "tests/touch.h"
#include "tests/callbacks.h"
#include "tests/pool.h"
#define GLOBAL_COUNT 10000
#define GLOBAL2_COUNT 100
#define SERVERS_TO_CREATE 5
-static uint32_t global_count;
+static uint32_t global_count= GLOBAL2_COUNT;
static pairs_st *global_pairs;
static const char *global_keys[GLOBAL_COUNT];
return TEST_SUCCESS;
}
+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;
+}
+
static memcached_st * create_single_instance_memcached(const memcached_st *original_memc, const char *options)
{
/*
test_true(memc_clone->ketama.weighted == memc->ketama.weighted);
test_true(memc_clone->flags.binary_protocol == memc->flags.binary_protocol);
test_true(memc_clone->flags.hash_with_namespace == memc->flags.hash_with_namespace);
- test_true(memc_clone->flags.no_reply == memc->flags.no_reply);
+ test_true(memc_clone->flags.reply == memc->flags.reply);
test_true(memc_clone->flags.use_udp == memc->flags.use_udp);
test_true(memc_clone->flags.auto_eject_hosts == memc->flags.auto_eject_hosts);
test_true(memc_clone->flags.randomize_replica_read == memc->flags.randomize_replica_read);
{
test_true(libmemcached_string_behavior(memcached_behavior_t(x)));
}
- test_compare(36, int(MEMCACHED_BEHAVIOR_MAX));
+ test_compare(37, int(MEMCACHED_BEHAVIOR_MAX));
return TEST_SUCCESS;
}
{
uint32_t values[] = { 851992627U, 2337886783U, 4109241422U, 4001849190U,
982370485U, 1263635348U, 4242906218U, 3829656100U,
- 1891735253U, 334139633U, 2257084983U, 3088286104U,
+ 1891735253U, 334139633U, 2257084983U, 3351789013U,
13199785U, 2542027183U, 1097051614U, 199566778U,
2748246961U, 2465192557U, 1664094137U, 2405439045U,
1842224848U, 692413798U, 3479807801U, 919913813U,
test_literal_param("foo"),
test_literal_param("when we sanitize"),
time_t(0), (uint32_t)0);
- test_true_got(rc == MEMCACHED_SUCCESS || rc == MEMCACHED_BUFFERED, memcached_strerror(NULL, rc));
+ test_true_got(rc == MEMCACHED_SUCCESS or rc == MEMCACHED_BUFFERED, memcached_strerror(NULL, rc));
return TEST_SUCCESS;
}
static test_return_t append_test(memcached_st *memc)
{
memcached_return_t rc;
- const char *key= "fig";
const char *in_value= "we";
- char *out_value= NULL;
size_t value_length;
uint32_t flags;
- rc= memcached_flush(memc, 0);
- test_compare(MEMCACHED_SUCCESS, rc);
-
- rc= memcached_set(memc, key, strlen(key),
- in_value, strlen(in_value),
- (time_t)0, (uint32_t)0);
- test_compare(MEMCACHED_SUCCESS, rc);
+ test_compare(MEMCACHED_SUCCESS,
+ memcached_flush(memc, 0));
- rc= memcached_append(memc, key, strlen(key),
- " the", strlen(" the"),
- (time_t)0, (uint32_t)0);
- test_compare(MEMCACHED_SUCCESS, rc);
+ test_compare(MEMCACHED_SUCCESS,
+ memcached_set(memc,
+ test_literal_param(__func__),
+ in_value, strlen(in_value),
+ time_t(0), uint32_t(0)));
- rc= memcached_append(memc, key, strlen(key),
- " people", strlen(" people"),
- (time_t)0, (uint32_t)0);
- test_compare(MEMCACHED_SUCCESS, rc);
+ test_compare(MEMCACHED_SUCCESS,
+ memcached_append(memc,
+ test_literal_param(__func__),
+ " the", strlen(" the"),
+ time_t(0), uint32_t(0)));
- out_value= memcached_get(memc, key, strlen(key),
- &value_length, &flags, &rc);
+ test_compare(MEMCACHED_SUCCESS,
+ memcached_append(memc,
+ test_literal_param(__func__),
+ " people", strlen(" people"),
+ time_t(0), uint32_t(0)));
+
+ char *out_value= memcached_get(memc,
+ test_literal_param(__func__),
+ &value_length, &flags, &rc);
test_memcmp(out_value, "we the people", strlen("we the people"));
test_compare(strlen("we the people"), value_length);
test_compare(MEMCACHED_SUCCESS, rc);
static test_return_t append_binary_test(memcached_st *memc)
{
- memcached_return_t rc;
- const char *key= "numbers";
uint32_t store_list[] = { 23, 56, 499, 98, 32847, 0 };
- uint32_t *value;
- size_t value_length;
- uint32_t flags;
- uint32_t x;
- rc= memcached_flush(memc, 0);
- test_compare(MEMCACHED_SUCCESS, rc);
+ test_compare(MEMCACHED_SUCCESS,
+ memcached_flush(memc, 0));
- rc= memcached_set(memc,
- key, strlen(key),
- NULL, 0,
- (time_t)0, (uint32_t)0);
- test_compare_got(MEMCACHED_SUCCESS, rc, memcached_strerror(NULL, rc));
+ test_compare(MEMCACHED_SUCCESS,
+ memcached_set(memc,
+ test_literal_param(__func__),
+ NULL, 0,
+ time_t(0), uint32_t(0)));
- for (x= 0; store_list[x] ; x++)
+ size_t count= 0;
+ for (uint32_t x= 0; store_list[x] ; x++)
{
- rc= memcached_append(memc,
- key, strlen(key),
+ test_compare(MEMCACHED_SUCCESS,
+ memcached_append(memc,
+ test_literal_param(__func__),
(char *)&store_list[x], sizeof(uint32_t),
- (time_t)0, (uint32_t)0);
- test_compare(MEMCACHED_SUCCESS, rc);
+ time_t(0), uint32_t(0)));
+ count++;
}
- value= (uint32_t *)memcached_get(memc, key, strlen(key),
- &value_length, &flags, &rc);
- test_compare(value_length, sizeof(uint32_t) * x);
+ size_t value_length;
+ uint32_t flags;
+ memcached_return_t rc;
+ uint32_t *value= (uint32_t *)memcached_get(memc,
+ test_literal_param(__func__),
+ &value_length, &flags, &rc);
+ test_compare(value_length, sizeof(uint32_t) * count);
test_compare(MEMCACHED_SUCCESS, rc);
- for (uint32_t counter= x, *ptr= value; counter; counter--)
+ for (uint32_t counter= count, *ptr= value; counter; counter--)
{
- test_compare(*ptr, store_list[x - counter]);
+ test_compare(*ptr, store_list[count - counter]);
ptr++;
}
free(value);
static test_return_t cas2_test(memcached_st *memc)
{
- memcached_return_t rc;
const char *keys[]= {"fudge", "son", "food"};
size_t key_length[]= {5, 3, 4};
const char *value= "we the people";
size_t value_length= strlen("we the people");
- memcached_result_st results_obj;
- memcached_result_st *results;
- unsigned int set= 1;
test_compare(MEMCACHED_SUCCESS, memcached_flush(memc, 0));
- memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_SUPPORT_CAS, set);
+ test_compare(MEMCACHED_SUCCESS, memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_SUPPORT_CAS, true));
for (uint32_t x= 0; x < 3; x++)
{
- rc= memcached_set(memc, keys[x], key_length[x],
- keys[x], key_length[x],
- (time_t)50, (uint32_t)9);
- test_compare(MEMCACHED_SUCCESS, rc);
+ test_compare(MEMCACHED_SUCCESS,
+ memcached_set(memc, keys[x], key_length[x],
+ keys[x], key_length[x],
+ time_t(50), uint32_t(9)));
}
test_compare(MEMCACHED_SUCCESS,
memcached_mget(memc, keys, key_length, 3));
- results= memcached_result_create(memc, &results_obj);
+ memcached_result_st *results= memcached_result_create(memc, NULL);
test_true(results);
- results= memcached_fetch_result(memc, &results_obj, &rc);
+ memcached_return_t rc;
+ results= memcached_fetch_result(memc, results, &rc);
test_true(results);
test_true(results->item_cas);
test_compare(MEMCACHED_SUCCESS, rc);
test_compare(strlen("we the people"), value_length);
test_compare(MEMCACHED_SUCCESS, rc);
- memcached_result_free(&results_obj);
+ memcached_result_free(results);
return TEST_SUCCESS;
}
static test_return_t cas_test(memcached_st *memc)
{
- memcached_return_t rc;
- const char *key= "fun";
- size_t key_length= strlen(key);
- const char *value= "we the people";
- const char* keys[2] = { key, NULL };
- size_t keylengths[2] = { strlen(key), 0 };
- size_t value_length= strlen(value);
- const char *value2= "change the value";
- size_t value2_length= strlen(value2);
+ const char* keys[2] = { __func__, NULL };
+ size_t keylengths[2] = { strlen(__func__), 0 };
memcached_result_st results_obj;
- memcached_result_st *results;
- unsigned int set= 1;
- rc= memcached_flush(memc, 0);
- test_compare(MEMCACHED_SUCCESS, rc);
+ test_compare(MEMCACHED_SUCCESS, memcached_flush(memc, 0));
- memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_SUPPORT_CAS, set);
+ test_skip(true, memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_SUPPORT_CAS, true));
- rc= memcached_set(memc, key, strlen(key),
- value, strlen(value),
- (time_t)0, (uint32_t)0);
- test_compare(MEMCACHED_SUCCESS, rc);
+ test_compare(MEMCACHED_SUCCESS,
+ memcached_set(memc,
+ test_literal_param(__func__),
+ test_literal_param("we the people"),
+ (time_t)0, (uint32_t)0));
test_compare(MEMCACHED_SUCCESS,
memcached_mget(memc, keys, keylengths, 1));
- results= memcached_result_create(memc, &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);
test_compare(MEMCACHED_SUCCESS, rc);
test_true(memcached_result_cas(results));
- test_memcmp(value, memcached_result_value(results), value_length);
- test_compare(strlen(memcached_result_value(results)), value_length);
- test_compare(MEMCACHED_SUCCESS, rc);
- uint64_t cas = memcached_result_cas(results);
+ test_memcmp("we the people", memcached_result_value(results), test_literal_param_size("we the people"));
+ test_compare(test_literal_param_size("we the people"),
+ strlen(memcached_result_value(results)));
+
+ uint64_t cas= memcached_result_cas(results);
#if 0
results= memcached_fetch_result(memc, &results_obj, &rc);
test_true(results == NULL);
#endif
- rc= memcached_cas(memc, key, key_length, value2, value2_length, 0, 0, cas);
- test_compare(MEMCACHED_SUCCESS, rc);
+ test_compare(MEMCACHED_SUCCESS,
+ memcached_cas(memc,
+ test_literal_param(__func__),
+ test_literal_param("change the value"),
+ 0, 0, cas));
/*
* The item will have a new cas value, so try to set it again with the old
* value. This should fail!
*/
- rc= memcached_cas(memc, key, key_length, value2, value2_length, 0, 0, cas);
- test_compare(MEMCACHED_DATA_EXISTS, rc);
+ test_compare(MEMCACHED_DATA_EXISTS,
+ memcached_cas(memc,
+ test_literal_param(__func__),
+ test_literal_param("change the value"),
+ 0, 0, cas));
memcached_result_free(&results_obj);
static test_return_t prepend_test(memcached_st *memc)
{
- memcached_return_t rc;
const char *key= "fig";
const char *value= "people";
- char *out_value= NULL;
- size_t value_length;
- uint32_t flags;
- rc= memcached_flush(memc, 0);
- test_compare(MEMCACHED_SUCCESS, rc);
+ test_compare(MEMCACHED_SUCCESS,
+ memcached_flush(memc, 0));
- rc= memcached_set(memc, key, strlen(key),
- value, strlen(value),
- (time_t)0, (uint32_t)0);
- test_compare(MEMCACHED_SUCCESS, rc);
+ test_compare(MEMCACHED_SUCCESS,
+ memcached_set(memc, key, strlen(key),
+ value, strlen(value),
+ time_t(0), uint32_t(0)));
- rc= memcached_prepend(memc, key, strlen(key),
- "the ", strlen("the "),
- (time_t)0, (uint32_t)0);
- test_compare(MEMCACHED_SUCCESS, rc);
+ test_compare(MEMCACHED_SUCCESS,
+ memcached_prepend(memc, key, strlen(key),
+ "the ", strlen("the "),
+ time_t(0), uint32_t(0)));
- rc= memcached_prepend(memc, key, strlen(key),
- "we ", strlen("we "),
- (time_t)0, (uint32_t)0);
- test_compare(MEMCACHED_SUCCESS, rc);
+ test_compare(MEMCACHED_SUCCESS,
+ memcached_prepend(memc, key, strlen(key),
+ "we ", strlen("we "),
+ time_t(0), uint32_t(0)));
- out_value= memcached_get(memc, key, strlen(key),
+ size_t value_length;
+ uint32_t flags;
+ memcached_return_t rc;
+ char *out_value= memcached_get(memc, key, strlen(key),
&value_length, &flags, &rc);
test_memcmp(out_value, "we the people", strlen("we the people"));
test_compare(strlen("we the people"), value_length);
*/
static test_return_t add_test(memcached_st *memc)
{
- memcached_return_t rc;
- const char *key= "foo";
- const char *value= "when we sanitize";
- unsigned long long setting_value;
+ 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));
- setting_value= memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_NO_BLOCK);
-
- rc= memcached_set(memc, key, strlen(key),
- value, strlen(value),
- (time_t)0, (uint32_t)0);
- test_true(rc == MEMCACHED_SUCCESS || rc == MEMCACHED_BUFFERED);
memcached_quit(memc);
- rc= memcached_add(memc, key, strlen(key),
- value, strlen(value),
- (time_t)0, (uint32_t)0);
- /* Too many broken OS'es have broken loopback in async, so we can't be sure of the result */
- if (setting_value)
- {
- test_true(rc == MEMCACHED_NOTSTORED || rc == MEMCACHED_STORED);
- }
- else
- {
- test_true(rc == MEMCACHED_NOTSTORED || rc == MEMCACHED_DATA_EXISTS);
- }
+ test_compare_hint(memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL) ? MEMCACHED_DATA_EXISTS : MEMCACHED_NOTSTORED,
+ memcached_add(memc,
+ test_literal_param(__func__),
+ test_literal_param("try something else"),
+ time_t(0), uint32_t(0)),
+ memcached_last_error_message(memc));
return TEST_SUCCESS;
}
static test_return_t replace_test(memcached_st *memc)
{
- memcached_return_t rc;
- const char *key= "foo";
- const char *value= "when we sanitize";
- const char *original= "first we insert some data";
-
- rc= memcached_set(memc, key, strlen(key),
- original, strlen(original),
- (time_t)0, (uint32_t)0);
- test_true(rc == MEMCACHED_SUCCESS || rc == MEMCACHED_BUFFERED);
+ 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(MEMCACHED_SUCCESS,
- memcached_replace(memc, key, strlen(key),
- value, strlen(value),
- (time_t)0, (uint32_t)0));
+ memcached_replace(memc,
+ test_literal_param(__func__),
+ test_literal_param("first we insert some data"),
+ time_t(0), uint32_t(0)));
return TEST_SUCCESS;
}
static test_return_t delete_test(memcached_st *memc)
{
- memcached_return_t rc;
- const char *key= "foo";
- const char *value= "when we sanitize";
-
- rc= memcached_set(memc, key, strlen(key),
- value, strlen(value),
- (time_t)0, (uint32_t)0);
- test_true(rc == MEMCACHED_SUCCESS || rc == MEMCACHED_BUFFERED);
+ 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)));
- rc= memcached_delete(memc, key, strlen(key), (time_t)0);
- test_true(rc == MEMCACHED_SUCCESS || rc == MEMCACHED_BUFFERED);
+ test_compare_hint(return_value_based_on_buffering(memc),
+ memcached_delete(memc,
+ test_literal_param(__func__),
+ time_t(0)),
+ memcached_last_error_message(memc));
return TEST_SUCCESS;
}
return TEST_SUCCESS;
}
-static memcached_return_t server_function(const memcached_st *ptr,
- const memcached_server_st *server,
- void *context)
+static memcached_return_t server_function(const memcached_st *,
+ const memcached_server_st *,
+ void *)
{
- (void)ptr; (void)server; (void)context;
/* Do Nothing */
-
return MEMCACHED_SUCCESS;
}
memcached_return_t rc;
const char *key= "foo bad";
uint32_t flags;
- memcached_st *memc_clone;
uint64_t query_id= memcached_query_id(memc);
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);
+ memcached_st *memc_clone= memcached_clone(NULL, memc);
test_true(memc_clone);
query_id= memcached_query_id(memc_clone);
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))
+ if (memcached_behavior_get(memc_clone, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL) == false)
{
uint64_t before_query_id= memcached_query_id(memc_clone);
{
static test_return_t read_through(memcached_st *memc)
{
- memcached_return_t rc;
- const char *key= "foo";
- char *string;
- size_t string_length;
- uint32_t flags;
memcached_trigger_key_fn cb= (memcached_trigger_key_fn)read_through_trigger;
- string= memcached_get(memc, key, strlen(key),
- &string_length, &flags, &rc);
+ 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_NOTFOUND, rc);
test_false(string_length);
test_false(string);
- rc= memcached_callback_set(memc, MEMCACHED_CALLBACK_GET_FAILURE, *(void **)&cb);
- test_compare(MEMCACHED_SUCCESS, rc);
+ test_compare(MEMCACHED_SUCCESS,
+ memcached_callback_set(memc, MEMCACHED_CALLBACK_GET_FAILURE, *(void **)&cb));
- string= memcached_get(memc, key, strlen(key),
+ string= memcached_get(memc,
+ test_literal_param(__func__),
&string_length, &flags, &rc);
test_compare(MEMCACHED_SUCCESS, rc);
test_strcmp(READ_THROUGH_VALUE, string);
free(string);
- string= memcached_get(memc, key, strlen(key),
+ string= memcached_get(memc,
+ test_literal_param(__func__),
&string_length, &flags, &rc);
test_compare(MEMCACHED_SUCCESS, rc);
static test_return_t get_test(memcached_st *memc)
{
memcached_return_t rc;
- const char *key= "foo";
char *string;
size_t string_length;
uint32_t flags;
uint64_t query_id= memcached_query_id(memc);
- rc= memcached_delete(memc, key, strlen(key), (time_t)0);
- test_true(rc == MEMCACHED_BUFFERED || rc == MEMCACHED_NOTFOUND);
+ rc= memcached_delete(memc,
+ test_literal_param(__func__),
+ time_t(0));
+ test_true_got(rc == MEMCACHED_BUFFERED or rc == MEMCACHED_NOTFOUND, memcached_last_error_message(memc));
test_compare(query_id +1, memcached_query_id(memc));
- string= memcached_get(memc, key, strlen(key),
+ string= memcached_get(memc,
+ test_literal_param(__func__),
&string_length, &flags, &rc);
test_compare_got(MEMCACHED_NOTFOUND, rc, memcached_strerror(NULL, rc));
static test_return_t get_test2(memcached_st *memc)
{
- const char *key= "foo";
const char *value= "when we sanitize";
uint64_t query_id= memcached_query_id(memc);
- memcached_return_t rc= memcached_set(memc, key, strlen(key),
- value, strlen(value),
- (time_t)0, (uint32_t)0);
- test_true(rc == MEMCACHED_SUCCESS or rc == MEMCACHED_BUFFERED);
+ 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);
uint32_t flags;
size_t string_length;
- char *string= memcached_get(memc, key, strlen(key),
+ 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));
{
for (uint32_t x= 0; x < 10; x++)
{
- memcached_return_t rc= memcached_set(memc,
- test_literal_param("foo"),
- test_literal_param("train in the brain"),
- time_t(0), uint32_t(0));
- test_true(rc == MEMCACHED_SUCCESS or rc == MEMCACHED_BUFFERED);
+ 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)));
}
return TEST_SUCCESS;
snprintf(key, sizeof(key), "foo%u", x);
uint64_t query_id= memcached_query_id(memc);
- memcached_return_t rc= memcached_set(memc, key, strlen(key),
- &value[0], value.size(),
- (time_t)0, (uint32_t)0);
- test_true_got(rc == MEMCACHED_SUCCESS or rc == MEMCACHED_BUFFERED, memcached_strerror(NULL, rc));
+ test_compare_hint(return_value_based_on_buffering(memc),
+ memcached_set(memc, key, strlen(key),
+ &value[0], value.size(),
+ time_t(0), uint32_t(0)),
+ memcached_last_error_message(memc));
test_compare(query_id +1, memcached_query_id(memc));
}
static test_return_t get_test3(memcached_st *memc)
{
- const char *key= "foo";
size_t value_length= 8191;
std::vector<char> value;
value.push_back(char(x % 127));
}
- memcached_return_t rc;
- rc= memcached_set(memc, key, strlen(key),
- &value[0], value.size(),
- (time_t)0, (uint32_t)0);
- test_true(rc == MEMCACHED_SUCCESS or rc == MEMCACHED_BUFFERED);
+ 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;
- char *string= memcached_get(memc, key, strlen(key),
+ 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(string_length, value_length);
+ test_compare(value.size(), string_length);
test_memcmp(string, &value[0], string_length);
free(string);
static test_return_t get_test4(memcached_st *memc)
{
- const char *key= "foo";
size_t value_length= 8191;
std::vector<char> value;
value.push_back(char(x % 127));
}
- memcached_return_t rc= memcached_set(memc, key, strlen(key),
- &value[0], value.size(),
- (time_t)0, (uint32_t)0);
- test_true(rc == MEMCACHED_SUCCESS or rc == MEMCACHED_BUFFERED);
+ 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;
- char *string= memcached_get(memc, key, strlen(key),
+ 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(string_length, value_length);
+ test_compare(value.size(), string_length);
test_memcmp(string, &value[0], string_length);
free(string);
}
uint32_t flags;
size_t rlen;
- memcached_return_t rc= memcached_set(memc, keys[0], lengths[0],
- keys[0], lengths[0], 0, 0);
+ 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);
size_t lengths[]= { 3, 4 };
const char *values[]= { "fjord", "41" };
- memcached_return_t rc;
-
// Set foo and foo2
for (size_t x= 0; x < test_array_length(keys); x++)
{
- test_compare(MEMCACHED_SUCCESS, memcached_set(memc, keys[x], lengths[x], values[x], strlen(values[x]), (time_t)0, (uint32_t)0));
+ test_compare(MEMCACHED_SUCCESS,
+ memcached_set(memc,
+ keys[x], lengths[x],
+ values[x], strlen(values[x]),
+ time_t(0), uint32_t(0)));
}
char *string;
uint32_t flags;
// retrieve both via mget
- test_compare(MEMCACHED_SUCCESS, memcached_mget(memc, keys, lengths, test_array_length(keys)));
+ test_compare(MEMCACHED_SUCCESS,
+ memcached_mget(memc,
+ keys, lengths,
+ test_array_length(keys)));
char key[MEMCACHED_MAX_KEY];
size_t key_length;
+ memcached_return_t rc;
// this should get both
for (size_t x= 0; x < test_array_length(keys); x++)
test_null(string);
// now get just one
- rc= memcached_mget(memc, keys, lengths, 1);
- test_compare(MEMCACHED_SUCCESS, rc);
+ test_compare(MEMCACHED_SUCCESS,
+ memcached_mget(memc, keys, lengths, 1));
string= memcached_fetch(memc, key, &key_length, &string_length, &flags, &rc);
test_compare(key_length, lengths[0]);
static test_return_t decrement_test(memcached_st *memc)
{
- uint64_t new_number;
- memcached_return_t rc;
- const char *value= "3";
-
- rc= memcached_set(memc,
- test_literal_param("number"),
- value, strlen(value),
- (time_t)0, (uint32_t)0);
- test_true(rc == MEMCACHED_SUCCESS or rc == MEMCACHED_BUFFERED);
+ test_compare(return_value_based_on_buffering(memc),
+ memcached_set(memc,
+ test_literal_param(__func__),
+ test_literal_param("3"),
+ time_t(0), uint32_t(0)));
+ // Make sure we flush the value we just set
+ test_compare(MEMCACHED_SUCCESS, memcached_flush_buffers(memc));
+ uint64_t new_number;
test_compare(MEMCACHED_SUCCESS,
memcached_decrement(memc,
- test_literal_param("number"),
+ test_literal_param(__func__),
1, &new_number));
test_compare(uint64_t(2), new_number);
test_compare(MEMCACHED_SUCCESS,
memcached_decrement(memc,
- test_literal_param("number"),
+ test_literal_param(__func__),
1, &new_number));
test_compare(uint64_t(1), new_number);
{
test_skip(true, memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL));
- uint64_t new_number;
uint64_t initial= 3;
test_compare(MEMCACHED_SUCCESS, memcached_flush_buffers(memc));
+ uint64_t new_number;
test_compare(MEMCACHED_SUCCESS,
memcached_decrement_with_initial(memc,
- test_literal_param("number"),
- 1, initial, 0, &new_number));
+ test_literal_param(__func__),
+ 1, initial,
+ 0, &new_number));
test_compare(new_number, initial);
test_compare(MEMCACHED_SUCCESS,
memcached_decrement_with_initial(memc,
- test_literal_param("number"),
- 1, initial, 0, &new_number));
+ test_literal_param(__func__),
+ 1, initial,
+ 0, &new_number));
test_compare(new_number, (initial - 1));
return TEST_SUCCESS;
static test_return_t increment_by_key_test(memcached_st *memc)
{
- uint64_t new_number;
- memcached_return_t rc;
const char *master_key= "foo";
const char *key= "number";
const char *value= "0";
- rc= memcached_set_by_key(memc, master_key, strlen(master_key),
- key, strlen(key),
- value, strlen(value),
- (time_t)0, (uint32_t)0);
- test_true(rc == MEMCACHED_SUCCESS or rc == MEMCACHED_BUFFERED);
+ test_compare(return_value_based_on_buffering(memc),
+ memcached_set_by_key(memc, master_key, strlen(master_key),
+ key, strlen(key),
+ value, strlen(value),
+ time_t(0), uint32_t(0)));
+
+ // Make sure we flush the value we just set
+ test_compare(MEMCACHED_SUCCESS, memcached_flush_buffers(memc));
+ uint64_t new_number;
test_compare(MEMCACHED_SUCCESS,
- memcached_increment_by_key(memc, master_key, strlen(master_key), key, strlen(key), 1, &new_number));
+ memcached_increment_by_key(memc, master_key, strlen(master_key),
+ key, strlen(key), 1, &new_number));
test_compare(uint64_t(1), new_number);
test_compare(MEMCACHED_SUCCESS,
- memcached_increment_by_key(memc, master_key, strlen(master_key), key, strlen(key), 1, &new_number));
+ memcached_increment_by_key(memc, master_key, strlen(master_key),
+ key, strlen(key), 1, &new_number));
test_compare(uint64_t(2), new_number);
return TEST_SUCCESS;
test_skip(true, memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL));
uint64_t new_number;
- memcached_return_t rc;
const char *master_key= "foo";
const char *key= "number";
uint64_t initial= 0;
- rc= memcached_increment_with_initial_by_key(memc, master_key, strlen(master_key),
- key, strlen(key),
- 1, initial, 0, &new_number);
- test_compare(MEMCACHED_SUCCESS, rc);
+ test_compare(MEMCACHED_SUCCESS,
+ memcached_increment_with_initial_by_key(memc, master_key, strlen(master_key),
+ key, strlen(key),
+ 1, initial, 0, &new_number));
test_compare(new_number, initial);
- rc= memcached_increment_with_initial_by_key(memc, master_key, strlen(master_key),
- key, strlen(key),
- 1, initial, 0, &new_number);
- test_compare(MEMCACHED_SUCCESS, rc);
+ test_compare(MEMCACHED_SUCCESS,
+ memcached_increment_with_initial_by_key(memc, master_key, strlen(master_key),
+ key, strlen(key),
+ 1, initial, 0, &new_number));
test_compare(new_number, (initial +1));
return TEST_SUCCESS;
static test_return_t decrement_by_key_test(memcached_st *memc)
{
uint64_t new_number;
- memcached_return_t rc;
const char *value= "3";
- rc= memcached_set_by_key(memc,
- test_literal_param("foo"),
- test_literal_param("number"),
- value, strlen(value),
- (time_t)0, (uint32_t)0);
- test_true(rc == MEMCACHED_SUCCESS or rc == MEMCACHED_BUFFERED);
+ test_compare(return_value_based_on_buffering(memc),
+ memcached_set_by_key(memc,
+ test_literal_param("foo"),
+ test_literal_param("number"),
+ value, strlen(value),
+ (time_t)0, (uint32_t)0));
test_compare(MEMCACHED_SUCCESS,
memcached_decrement_by_key(memc,
return TEST_SUCCESS;
}
-static test_return_t binary_increment_with_prefix_test(memcached_st *orig_memc)
+static test_return_t binary_increment_with_prefix_test(memcached_st *memc)
{
- memcached_st *memc= memcached_clone(NULL, orig_memc);
-
- test_skip(TEST_SUCCESS, pre_binary(memc));
+ test_skip(true, memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL));
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);
+ test_compare(return_value_based_on_buffering(memc),
+ memcached_set(memc,
+ test_literal_param("number"),
+ test_literal_param("0"),
+ (time_t)0, (uint32_t)0));
uint64_t 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)
{
- memcached_return_t rc;
- const char *key= "fudge";
const char *value= "sanford and sun";
- rc= memcached_set(memc, key, strlen(key),
- value, strlen(value),
- (time_t)10, (uint32_t)3);
- test_true_got(rc == MEMCACHED_SUCCESS or rc == MEMCACHED_BUFFERED, memcached_strerror(NULL, rc));
+ test_compare(return_value_based_on_buffering(memc),
+ memcached_set(memc,
+ test_literal_param(__func__),
+ value, strlen(value),
+ (time_t)10, (uint32_t)3));
memcached_quit(memc);
- rc= memcached_set(memc, key, strlen(key),
- value, strlen(value),
- (time_t)50, (uint32_t)9);
- test_true(rc == MEMCACHED_SUCCESS or rc == MEMCACHED_BUFFERED);
+ test_compare(return_value_based_on_buffering(memc),
+ memcached_set(memc,
+ test_literal_param(__func__),
+ value, strlen(value),
+ (time_t)50, (uint32_t)9));
return TEST_SUCCESS;
}
size_t counter;
memcached_execute_fn callbacks[1];
- /* We need to empty the server before continueing test */
- test_compare(MEMCACHED_SUCCESS,
- memcached_flush(memc, 0));
for (uint32_t x= 0; x < 3; x++)
{
- memcached_return_t 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_compare(return_value_based_on_buffering(memc),
+ memcached_set(memc, keys[x], key_length[x],
+ keys[x], key_length[x],
+ time_t(50), uint32_t(9)));
}
+ test_compare(MEMCACHED_SUCCESS, memcached_flush_buffers(memc));
+ memcached_quit(memc);
test_compare(MEMCACHED_SUCCESS,
memcached_mget(memc, keys, key_length, 3));
char *return_value;
size_t return_value_length;
- /* We need to empty the server before continueing test */
- test_compare(MEMCACHED_SUCCESS,
- memcached_flush(memc, 0));
-
test_compare(MEMCACHED_SUCCESS,
memcached_mget(memc, keys, key_length, 3));
return TEST_SUCCESS;
}
-static test_return_t fetch_all_results(memcached_st *memc, unsigned int &keys_returned, const memcached_return_t expect)
+static test_return_t fetch_all_results(memcached_st *memc, unsigned int &keys_returned, memcached_return_t& rc)
{
- memcached_return_t rc;
- char return_key[MEMCACHED_MAX_KEY];
- size_t return_key_length;
- char *return_value;
- size_t return_value_length;
- uint32_t flags;
-
keys_returned= 0;
- while ((return_value= memcached_fetch(memc, return_key, &return_key_length,
- &return_value_length, &flags, &rc)))
+
+ memcached_result_st* result= NULL;
+ while ((result= memcached_fetch_result(memc, result, &rc)))
{
- test_true(return_value);
- test_compare_got(MEMCACHED_SUCCESS, rc, memcached_strerror(NULL, rc));
- free(return_value);
+ test_compare(MEMCACHED_SUCCESS, rc);
keys_returned+= 1;
}
+ memcached_result_free(result);
- if (memcached_success(expect) and memcached_success(rc))
- {
- return TEST_SUCCESS;
- }
- else if (expect == rc)
- {
- return TEST_SUCCESS;
- }
- fprintf(stderr, "\n%s:%u %s(#%u)\n", __FILE__, __LINE__, memcached_strerror(NULL, rc), keys_returned);
+ return TEST_SUCCESS;
+}
- return TEST_FAILURE;
+static test_return_t fetch_all_results(memcached_st *memc, unsigned int &keys_returned)
+{
+ memcached_return_t rc;
+ return fetch_all_results(memc, keys_returned, rc);
}
/* Test case provided by Cal Haldenbrand */
}
total+= size;
- char key[22];
+ char key[MEMCACHED_MAXIMUM_INTEGER_DISPLAY_LENGTH +1];
int key_length= snprintf(key, sizeof(key), "%u", x);
test_compare(MEMCACHED_SUCCESS,
- memcached_set(memc, key, key_length, randomstuff, strlen(randomstuff), time_t(0), HALDENBRAND_FLAG_KEY));
+ memcached_set(memc, key, key_length,
+ randomstuff, strlen(randomstuff),
+ time_t(0), HALDENBRAND_FLAG_KEY));
}
test_true(total > HALDENBRAND_KEY_COUNT);
continue;
}
test_compare(uint32_t(HALDENBRAND_FLAG_KEY), flags);
+ test_true(getval);
total_value_length+= val_len;
errors= 0;
- free(getval);
+ ::free(getval);
}
return TEST_SUCCESS;
/* Do a large mget() over all the keys we think exist */
static test_return_t user_supplied_bug3(memcached_st *memc)
{
- 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_NO_BLOCK, true));
+ test_compare(MEMCACHED_SUCCESS, memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_TCP_NODELAY, true));
#ifdef NOT_YET
memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_SOCKET_SEND_SIZE, 20 * 1024576);
memcached_mget(memc, &keys[0], &key_lengths[0], key_lengths.size()));
unsigned int keys_returned;
- test_compare(TEST_SUCCESS, fetch_all_results(memc, keys_returned, MEMCACHED_SUCCESS));
+ test_compare(TEST_SUCCESS, fetch_all_results(memc, keys_returned));
test_compare(HALDENBRAND_KEY_COUNT, keys_returned);
for (std::vector<char *>::iterator iter= keys.begin();
iter != keys.end();
iter++)
{
- free(*iter);
+ ::free(*iter);
}
return TEST_SUCCESS;
test_compare(MEMCACHED_NO_SERVERS,
memcached_mget(memc, keys, key_length, 3));
- unsigned int keys_returned;
- test_compare(TEST_SUCCESS, fetch_all_results(memc, keys_returned, MEMCACHED_NOTFOUND));
- test_zero(keys_returned);
+ {
+ unsigned int keys_returned;
+ memcached_return_t rc;
+ test_compare(TEST_SUCCESS, fetch_all_results(memc, keys_returned, rc));
+ test_compare(MEMCACHED_NOTFOUND, rc);
+ test_zero(keys_returned);
+ }
for (uint32_t x= 0; x < 3; x++)
{
memcached_mget(memc, keys, key_length, 4));
unsigned int count;
- test_compare(TEST_SUCCESS, fetch_all_results(memc, count, MEMCACHED_NOTFOUND));
+ test_compare(TEST_SUCCESS, fetch_all_results(memc, count, rc));
+ test_compare(MEMCACHED_NOTFOUND, rc);
test_zero(count);
for (uint32_t x= 0; x < 4; x++)
&value_length, &flags, &rc);
test_compare(rc, MEMCACHED_SUCCESS);
test_true(value);
- free(value);
+ ::free(value);
test_compare(MEMCACHED_SUCCESS,
memcached_mget(memc, keys, key_length, 4));
- test_compare(TEST_SUCCESS, fetch_all_results(memc, count, MEMCACHED_SUCCESS));
+ test_compare(TEST_SUCCESS, fetch_all_results(memc, count));
test_compare(4U, count);
}
delete [] insert_data;
/* Test flag store/retrieve */
static test_return_t user_supplied_bug7(memcached_st *memc)
{
- const char *keys= "036790384900";
- size_t key_length= strlen(keys);
- char return_key[MEMCACHED_MAX_KEY];
- size_t return_key_length;
- char *value;
- size_t value_length;
- uint32_t flags;
char *insert_data= new (std::nothrow) char[VALUE_SIZE_BUG5];
+ test_true(insert_data);
- for (unsigned int x= 0; x < VALUE_SIZE_BUG5; x++)
+ for (size_t x= 0; x < VALUE_SIZE_BUG5; x++)
{
insert_data[x]= (signed char)rand();
}
memcached_flush(memc, 0);
- flags= 245;
- test_compare(MEMCACHED_SUCCESS, memcached_set(memc, keys, key_length,
- insert_data, VALUE_SIZE_BUG5,
- (time_t)0, flags));
+ const char *keys= "036790384900";
+ size_t key_length= strlen(keys);
+ test_compare_hint(MEMCACHED_SUCCESS, memcached_set(memc, keys, key_length,
+ insert_data, VALUE_SIZE_BUG5,
+ time_t(0), 245U),
+ memcached_last_error_message(memc));
memcached_return_t rc;
- flags= 0;
- value= memcached_get(memc, keys, key_length,
- &value_length, &flags, &rc);
+ size_t value_length;
+ uint32_t flags= 0;
+ char *value= memcached_get(memc, keys, key_length,
+ &value_length, &flags, &rc);
test_compare(245U, flags);
test_true(value);
free(value);
test_compare(MEMCACHED_SUCCESS, memcached_mget(memc, &keys, &key_length, 1));
+ char return_key[MEMCACHED_MAX_KEY];
+ size_t return_key_length;
flags= 0;
value= memcached_fetch(memc, return_key, &return_key_length,
&value_length, &flags, &rc);
/* 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= memcached_set(memc, test_literal_param("mykey"),
- NULL, 0,
- (time_t)0, UINT32_MAX);
+ test_compare_hint(MEMCACHED_SUCCESS, memcached_set(memc, test_literal_param("mykey"),
+ NULL, 0,
+ (time_t)0, UINT32_MAX),
+ memcached_last_error_message(memc));
- test_compare(MEMCACHED_SUCCESS, rc);
size_t length;
uint32_t flags;
+ memcached_return_t rc;
char *value= memcached_get(memc, test_literal_param("mykey"),
&length, &flags, &rc);
test_compare(MEMCACHED_SUCCESS, rc);
- test_true(value == NULL);
+ test_null(value);
test_zero(length);
test_compare(flags, UINT32_MAX);
{
unsigned int check_execute= execute_set(memc, global_pairs, global_count);
- test_compare(check_execute, global_count);
+ test_compare_warn_hint(global_count, check_execute, "Possible false, positive, memcached may have ejected key/value based on memory needs");
return TEST_SUCCESS;
}
static test_return_t get_read(memcached_st *memc)
{
+ size_t keys_returned= 0;
for (size_t x= 0; x < global_count; x++)
{
size_t return_value_length;
*/
if (rc == MEMCACHED_SUCCESS && return_value)
{
+ keys_returned++;
free(return_value);
}
}
+ test_compare_warn_hint(global_count, keys_returned, "Possible false, positive, memcached may have ejected key/value based on memory needs");
return TEST_SUCCESS;
}
// Go fetch the keys and test to see if all of them were returned
{
unsigned int keys_returned;
- test_compare(TEST_SUCCESS, fetch_all_results(memc, keys_returned, MEMCACHED_SUCCESS));
+ test_compare(TEST_SUCCESS, fetch_all_results(memc, keys_returned));
test_true(keys_returned > 0);
test_compare_warn_hint(global_count, keys_returned, "Possible false, positive, memcached may have ejected key/value based on memory needs");
}
static test_return_t delete_generate(memcached_st *memc)
{
+ size_t total= 0;
for (size_t x= 0; x < global_count; x++)
{
- (void)memcached_delete(memc, global_keys[x], global_keys_length[x], (time_t)0);
+ if (memcached_success(memcached_delete(memc, global_keys[x], global_keys_length[x], (time_t)0)))
+ {
+ total++;
+ }
}
+ test_compare_warn_hint(global_count, total, "Possible false, positive, memcached may have ejected key/value based on memory needs");
return TEST_SUCCESS;
}
{
memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_BUFFER_REQUESTS, true);
+ size_t total= 0;
for (size_t x= 0; x < global_count; x++)
{
- (void)memcached_delete(memc, global_keys[x], global_keys_length[x], (time_t)0);
+ if (memcached_success(memcached_delete(memc, global_keys[x], global_keys_length[x], (time_t)0)))
+ {
+ total++;
+ }
}
+ test_compare_warn_hint(global_count, total, "Possible false, positive, memcached may have ejected key/value based on memory needs");
return TEST_SUCCESS;
}
static test_return_t noreply_test(memcached_st *memc)
{
test_compare(MEMCACHED_SUCCESS,
- memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_NOREPLY, 1));
+ memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_NOREPLY, true));
test_compare(MEMCACHED_SUCCESS,
- memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_BUFFER_REQUESTS, 1));
+ memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_BUFFER_REQUESTS, true));
test_compare(MEMCACHED_SUCCESS,
- memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_SUPPORT_CAS, 1));
+ memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_SUPPORT_CAS, true));
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));
{
for (size_t x= 0; x < 100; ++x)
{
- char key[10];
+ char key[MEMCACHED_MAXIMUM_INTEGER_DISPLAY_LENGTH +1];
int check_length= (size_t)snprintf(key, sizeof(key), "%lu", (unsigned long)x);
test_false((size_t)check_length >= sizeof(key) || check_length < 0);
static test_return_t analyzer_test(memcached_st *memc)
{
- memcached_return_t rc;
memcached_analysis_st *report;
+ memcached_return_t rc;
memcached_stat_st *memc_stat= memcached_stat(memc, NULL, &rc);
test_compare(MEMCACHED_SUCCESS, rc);
return TEST_SUCCESS;
}
-/* Count the objects */
-
-static test_return_t dump_test(memcached_st *memc)
-{
- /* No support for Binary protocol yet */
- test_skip(false, memc->flags.binary_protocol);
-
- test_compare(TEST_SUCCESS, set_test3(memc));
-
- // confirm_key_count() call dump
- size_t counter= confirm_key_count(memc);
-
- /* We may have more then 32 if our previous flush has not completed */
- test_true(counter >= 32);
-
- return TEST_SUCCESS;
-}
-
static test_return_t util_version_test(memcached_st *memc)
{
test_compare_hint(MEMCACHED_SUCCESS, memcached_version(memc), memcached_last_error_message(memc));
test_compare(MEMCACHED_SUCCESS,
memcached_mget(memc, (const char**)keys, key_length, max_keys));
+ // One the first run we should get a NOT_FOUND, but on the second some data
+ // should be returned.
test_compare(y ? MEMCACHED_SUCCESS : MEMCACHED_NOTFOUND,
memcached_fetch_execute(memc, callbacks, (void *)&counter, 1));
test_true(rc == MEMCACHED_SUCCESS || rc == MEMCACHED_BUFFERED);
}
- (void)snprintf(k, sizeof(k), "%037u", 251U);
- len= strlen(k);
+ len= snprintf(k, sizeof(k), "%037u", 251U);
memcached_return_t rc= memcached_delete(memc, k, len, 0);
test_true(rc == MEMCACHED_SUCCESS || rc == MEMCACHED_BUFFERED);
static test_return_t regression_bug_463297(memcached_st *memc)
{
+ test_compare(MEMCACHED_INVALID_ARGUMENTS, memcached_delete(memc, "foo", 3, 1));
+
+ // Since we blocked timed delete, this test is no longer valid.
+#if 0
memcached_st *memc_clone= memcached_clone(NULL, memc);
test_true(memc_clone);
test_true(memcached_version(memc_clone) == MEMCACHED_SUCCESS);
}
memcached_free(memc_clone);
+#endif
+
return TEST_SUCCESS;
}
memcached_return_t rc= memcached_stat_execute(memc, NULL, stat_printer, NULL);
test_compare(MEMCACHED_SUCCESS, rc);
- rc= memcached_stat_execute(memc, "slabs", stat_printer, NULL);
- test_compare(MEMCACHED_SUCCESS, rc);
+ test_compare(MEMCACHED_SUCCESS,
+ memcached_stat_execute(memc, "slabs", stat_printer, NULL));
- rc= memcached_stat_execute(memc, "items", stat_printer, NULL);
- test_compare(MEMCACHED_SUCCESS, rc);
+ test_compare(MEMCACHED_SUCCESS,
+ memcached_stat_execute(memc, "items", stat_printer, NULL));
- rc= memcached_stat_execute(memc, "sizes", stat_printer, NULL);
- test_compare(MEMCACHED_SUCCESS, rc);
+ test_compare(MEMCACHED_SUCCESS,
+ memcached_stat_execute(memc, "sizes", stat_printer, NULL));
return TEST_SUCCESS;
}
rc= memcached_set(memc, key, strlen(key),
value, strlen(value),
(time_t)0, (uint32_t)0);
- test_true(rc == MEMCACHED_SUCCESS || rc == MEMCACHED_BUFFERED);
+ test_true(rc == MEMCACHED_SUCCESS or rc == MEMCACHED_BUFFERED);
instance= memcached_server_instance_by_position(memc, 0);
*/
static test_return_t wrong_failure_counter_two_test(memcached_st *memc)
{
- memcached_return rc;
-
- memcached_st *memc_clone;
- memc_clone= memcached_clone(NULL, memc);
- test_true(memc_clone);
-
/* Set value to force connection to the server */
const char *key= "marmotte";
const char *value= "milka";
- char *string = NULL;
- size_t string_length;
- uint32_t flags;
- rc= memcached_set(memc_clone, key, strlen(key),
- value, strlen(value),
- (time_t)0, (uint32_t)0);
- test_true_got(rc == MEMCACHED_SUCCESS || rc == MEMCACHED_BUFFERED, memcached_strerror(NULL, rc));
+ test_compare_hint(MEMCACHED_SUCCESS,
+ memcached_set(memc, key, strlen(key),
+ value, strlen(value),
+ (time_t)0, (uint32_t)0),
+ memcached_last_error_message(memc));
/* put failure limit to 1 */
test_compare(MEMCACHED_SUCCESS,
- memcached_behavior_set(memc_clone, MEMCACHED_BEHAVIOR_SERVER_FAILURE_LIMIT, 1));
+ memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_SERVER_FAILURE_LIMIT, true));
/* Put a retry timeout to effectively activate failure_limit effect */
test_compare(MEMCACHED_SUCCESS,
- memcached_behavior_set(memc_clone, MEMCACHED_BEHAVIOR_RETRY_TIMEOUT, 1));
+ memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_RETRY_TIMEOUT, true));
/* change behavior that triggers memcached_quit()*/
test_compare(MEMCACHED_SUCCESS,
- memcached_behavior_set(memc_clone, MEMCACHED_BEHAVIOR_TCP_NODELAY, 1));
+ memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_TCP_NODELAY, true));
/* Check if we still are connected */
- string= memcached_get(memc_clone, key, strlen(key),
- &string_length, &flags, &rc);
+ uint32_t flags;
+ size_t string_length;
+ memcached_return rc;
+ char *string= memcached_get(memc, key, strlen(key),
+ &string_length, &flags, &rc);
test_compare_got(MEMCACHED_SUCCESS, rc, memcached_strerror(NULL, rc));
test_true(string);
free(string);
- memcached_free(memc_clone);
return TEST_SUCCESS;
}
-
-
/*
* Test that ensures mget_execute does not end into recursive calls that finally fails
*/
test_true(keys[x]);
memcached_return rc= memcached_set(memc, keys[x], key_length[x], blob, sizeof(blob), 0, 0);
- test_true(rc == MEMCACHED_SUCCESS or rc == MEMCACHED_BUFFERED);
+ test_true_got(rc == MEMCACHED_SUCCESS or rc == MEMCACHED_BUFFERED, memcached_last_error_message(memc));
}
for (uint32_t x= 0; x < regression_bug_490520_COUNT; ++x)
{"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},
+ {"memcached_set()", false, (test_callback_fn*)set_test },
+ {"memcached_set() 2", false, (test_callback_fn*)set_test2 },
+ {"memcached_set() 3", false, (test_callback_fn*)set_test3 },
{"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 },
{"memcached_exist_by_key(MEMCACHED_SUCCESS)", true, (test_callback_fn*)memcached_exist_by_key_SUCCESS },
{"memcached_touch", 0, (test_callback_fn*)test_memcached_touch},
{"memcached_touch_with_prefix", 0, (test_callback_fn*)test_memcached_touch_by_key},
+ {"memcached_dump() no data", true, (test_callback_fn*)memcached_dump_TEST },
+ {"memcached_dump() with data", true, (test_callback_fn*)memcached_dump_TEST2 },
{0, 0, 0}
};
{0, 0, 0}
};
+test_st memcached_stat_tests[] ={
+ {"memcached_stat() INVALID ARG", 0, (test_callback_fn*)memcached_stat_TEST},
+ {"memcached_stat()", 0, (test_callback_fn*)memcached_stat_TEST2},
+ {0, 0, 0}
+};
+
test_st behavior_tests[] ={
{"libmemcached_string_behavior()", false, (test_callback_fn*)libmemcached_string_behavior_test},
{"libmemcached_string_distribution()", false, (test_callback_fn*)libmemcached_string_distribution_test},
{"virtual buckets", 0, 0, virtual_bucket_tests},
{"memcached_server_get_last_disconnect", 0, 0, memcached_server_get_last_disconnect_tests},
{"touch", 0, 0, touch_tests},
+ {"touch", (test_callback_fn*)pre_binary, 0, touch_tests},
+ {"memcached_stat()", 0, 0, memcached_stat_tests},
{0, 0, 0, 0}
};
projects / m6w6 / libmemcached / blobdiff