#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"
{
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_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);
{
test_compare(query_id +1, memcached_query_id(memc_clone));
query_id= memcached_query_id(memc_clone);
- test_compare(MEMCACHED_BAD_KEY_PROVIDED,
+ // Grouping keys are not required to follow normal key behaviors
+ test_compare(MEMCACHED_SUCCESS,
memcached_mget_by_key(memc_clone, "foo daddy", 9, keys, key_lengths, 1));
test_compare(query_id +1, memcached_query_id(memc_clone));
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,
test_literal_param(__func__),
rc= memcached_delete(memc,
test_literal_param(__func__),
time_t(0));
- test_true_got(rc == MEMCACHED_BUFFERED || rc == MEMCACHED_NOTFOUND, memcached_last_error_message(memc));
+ 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,
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++)
{
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++)
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;
{
unsigned int check_execute= execute_set(memc, global_pairs, global_count);
- test_compare(global_count, check_execute);
+ 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;
}
{
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;
}
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},
+#if 0
+ {"memcached_dump() no data", true, (test_callback_fn*)memcached_dump_TEST },
+#endif
+ {"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},
{"mget", false, (test_callback_fn*)replication_mget_test },
{"delete", true, (test_callback_fn*)replication_delete_test },
{"rand_mget", false, (test_callback_fn*)replication_randomize_mget_test },
+ {"miss", false, (test_callback_fn*)replication_miss_test },
{"fail", false, (test_callback_fn*)replication_randomize_mget_fail_test },
{0, 0, (test_callback_fn*)0}
};
{"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