/*
- Sample test application.
+ Test cases
*/
-#include "config.h"
+#define BUILDING_LIBMEMCACHED
+// !NEVER use common.h, always use memcached.h in your own apps
+#include <libmemcached/common.h>
#include <stdint.h>
#include <cassert>
-#include <cstdio>
-#include <cstdlib>
-#include <cstring>
-#include <ctime>
#include <memory>
#include <signal.h>
#include <sys/stat.h>
#include <sys/types.h>
#include <unistd.h>
-#include "libmemcached/common.h"
-
#include <libtest/server.h>
#include "clients/generator.h"
return TEST_SUCCESS;
}
-static test_return_t memcached_server_remove_test(memcached_st *ptr)
+static test_return_t memcached_server_remove_test(memcached_st*)
{
const char *server_string= "--server=localhost:4444 --server=localhost:4445 --server=localhost:4446 --server=localhost:4447 --server=localhost --server=memcache1.memcache.bk.sapo.pt:11211 --server=memcache1.memcache.bk.sapo.pt:11212 --server=memcache1.memcache.bk.sapo.pt:11213 --server=memcache1.memcache.bk.sapo.pt:11214 --server=memcache2.memcache.bk.sapo.pt:11211 --server=memcache2.memcache.bk.sapo.pt:11212 --server=memcache2.memcache.bk.sapo.pt:11213 --server=memcache2.memcache.bk.sapo.pt:11214";
- (void)ptr;
+ char buffer[BUFSIZ];
+ memcached_return_t rc;
+ test_compare_got(MEMCACHED_SUCCESS,
+ rc= libmemcached_check_configuration(server_string, strlen(server_string), buffer, sizeof(buffer)),
+ memcached_strerror(NULL, rc));
memcached_st *memc= memcached(server_string, strlen(server_string));
test_true(memc);
return TEST_SUCCESS;
}
-static memcached_return_t server_display_unsort_function(const memcached_st *ptr,
+static memcached_return_t server_display_unsort_function(const memcached_st*,
const memcached_server_st *server,
void *context)
{
/* Do Nothing */
uint32_t x= *((uint32_t *)(context));
- (void)ptr;
if (! (test_ports[x] == server->port))
{
return TEST_SUCCESS;
}
+static test_return_t libmemcached_string_behavior_test(memcached_st *)
+{
+ for (int x= MEMCACHED_BEHAVIOR_NO_BLOCK; x < int(MEMCACHED_BEHAVIOR_MAX); ++x)
+ {
+ test_true(libmemcached_string_behavior(memcached_behavior_t(x)));
+ }
+ test_compare(36, MEMCACHED_BEHAVIOR_MAX);
+
+ return TEST_SUCCESS;
+}
+
+static test_return_t libmemcached_string_distribution_test(memcached_st *)
+{
+ for (int x= MEMCACHED_DISTRIBUTION_MODULA; x < int(MEMCACHED_DISTRIBUTION_CONSISTENT_MAX); ++x)
+ {
+ test_true(libmemcached_string_distribution(memcached_server_distribution_t(x)));
+ }
+ test_compare(7, MEMCACHED_DISTRIBUTION_CONSISTENT_MAX);
+
+ return TEST_SUCCESS;
+}
+
static test_return_t error_test(memcached_st *memc)
{
- uint32_t values[] = { 851992627U, 2337886783U, 3196981036U, 4001849190U,
+ uint32_t values[] = { 851992627U, 2337886783U, 646418395U, 4001849190U,
982370485U, 1263635348U, 4242906218U, 3829656100U,
1891735253U, 334139633U, 2257084983U, 3088286104U,
13199785U, 2542027183U, 1097051614U, 199566778U,
static test_return_t set_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);
+ memcached_return_t rc= memcached_set(memc,
+ memcached_literal_param("foo"),
+ memcached_literal_param("when we sanitize"),
+ time_t(0), (uint32_t)0);
test_true(rc == MEMCACHED_SUCCESS || rc == MEMCACHED_BUFFERED);
return TEST_SUCCESS;
*keys_returned= *keys_returned +1;
}
- test_true_got(rc == MEMCACHED_END || rc == MEMCACHED_SUCCESS, memcached_strerror(NULL, rc));
+ test_true_got(rc == MEMCACHED_END || memcached_success(rc), memcached_strerror(NULL, rc));
return TEST_SUCCESS;
}
for (unsigned int x= 0; x < 3; x++)
{
- memcached_return_t rc;
- rc= memcached_set(memc, keys[x], key_length[x],
- keys[x], key_length[x],
- (time_t)50, (uint32_t)9);
+ 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);
}
/* We need to empty the server before continueing test */
while ((return_value= memcached_fetch(memc, return_key, &return_key_length,
- &return_value_length, &flags, &rc)) != NULL)
+ &return_value_length, &flags, &rc)) != NULL)
{
test_true(return_value);
free(return_value);
count++;
}
- test_true(count == 3);
+ test_compare(3, count);
return TEST_SUCCESS;
}
rc= memcached_set(memc, key, strlen(key),
overflow, testSize, 0, 0);
test_true(rc == MEMCACHED_SUCCESS);
- delete overflow;
+ delete [] overflow;
}
return TEST_SUCCESS;
(void)key_count;
return TEST_SKIPPED;
#else
- memcached_return_t rc;
- unsigned int x;
- char **keys;
- size_t* key_lengths;
void (*oldalarm)(int);
- memcached_st *memc_clone;
- memc_clone= memcached_clone(NULL, memc);
+ memcached_st *memc_clone= memcached_clone(NULL, memc);
test_true(memc_clone);
/* only binproto uses getq for mget */
memcached_behavior_set(memc_clone, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL, 1);
/* empty the cache to ensure misses (hence non-responses) */
- rc= memcached_flush(memc_clone, 0);
+ memcached_return_t rc= memcached_flush(memc_clone, 0);
test_true(rc == MEMCACHED_SUCCESS);
- key_lengths= new (std::nothrow) size_t[key_count];
+ size_t* key_lengths= new (std::nothrow) size_t[key_count];
test_true(key_lengths);
- keys= static_cast<char **>(calloc(key_count, sizeof(char *)));
+ char **keys= static_cast<char **>(calloc(key_count, sizeof(char *)));
test_true(keys);
- for (x= 0; x < key_count; x++)
+ for (unsigned int x= 0; x < key_count; x++)
{
char buffer[30];
oldalarm= signal(SIGALRM, fail);
alarm(5);
- rc= memcached_mget(memc_clone, (const char **)keys, key_lengths, key_count);
- test_true(rc == MEMCACHED_SUCCESS);
+ test_true_got(memcached_success(memcached_mget(memc_clone, (const char **)keys, key_lengths, key_count)), memcached_last_error_message(memc_clone));
alarm(0);
signal(SIGALRM, oldalarm);
size_t keys_returned;
test_true(fetch_all_results(memc, &keys_returned) == TEST_SUCCESS);
- for (x= 0; x < key_count; x++)
+ for (unsigned int x= 0; x < key_count; x++)
+ {
free(keys[x]);
+ }
free(keys);
- delete key_lengths;
+ delete [] key_lengths;
memcached_free(memc_clone);
return TEST_SUCCESS;
}
-static test_return_t generate_large_pairs(memcached_st *memc)
+static test_return_t generate_large_pairs(memcached_st *)
{
- (void)memc;
global_pairs= pairs_generate(GLOBAL2_COUNT, MEMCACHED_MAX_BUFFER+10);
global_count= GLOBAL2_COUNT;
static test_return_t generate_data_with_stats(memcached_st *memc)
{
- memcached_stat_st *stat_p;
- memcached_return_t rc;
uint32_t host_index= 0;
unsigned int check_execute= execute_set(memc, global_pairs, global_count);
test_true(check_execute == global_count);
- //TODO: hosts used size stats
- stat_p= memcached_stat(memc, NULL, &rc);
+ // @todo hosts used size stats
+ memcached_return_t rc;
+ memcached_stat_st *stat_p= memcached_stat(memc, NULL, &rc);
test_true(stat_p);
for (host_index= 0; host_index < SERVERS_TO_CREATE; host_index++)
static test_return_t get_read_count(memcached_st *memc)
{
- memcached_return_t rc;
- memcached_st *memc_clone;
-
- memc_clone= memcached_clone(NULL, memc);
+ memcached_st *memc_clone= memcached_clone(NULL, memc);
test_true(memc_clone);
memcached_server_add_with_weight(memc_clone, "localhost", 6666, 0);
for (size_t x= count= 0; x < global_count; x++)
{
+ memcached_return_t rc;
return_value= memcached_get(memc_clone, global_keys[x], global_keys_length[x],
&return_value_length, &flags, &rc);
if (rc == MEMCACHED_SUCCESS)
static test_return_t get_read(memcached_st *memc)
{
- memcached_return_t rc;
-
+ for (size_t x= 0; x < global_count; x++)
{
- char *return_value;
size_t return_value_length;
uint32_t flags;
-
- for (size_t x= 0; x < global_count; x++)
- {
- return_value= memcached_get(memc, global_keys[x], global_keys_length[x],
- &return_value_length, &flags, &rc);
- /*
+ memcached_return_t rc;
+ char *return_value= memcached_get(memc, global_keys[x], global_keys_length[x],
+ &return_value_length, &flags, &rc);
+ /*
test_true(return_value);
test_true(rc == MEMCACHED_SUCCESS);
*/
- if (rc == MEMCACHED_SUCCESS && return_value)
- free(return_value);
- }
+ if (rc == MEMCACHED_SUCCESS && return_value)
+ free(return_value);
}
return TEST_SUCCESS;
static test_return_t mget_read(memcached_st *memc)
{
- memcached_return_t rc;
- if (! libmemcached_util_version_check(memc, 1, 4, 4))
+ if (not libmemcached_util_version_check(memc, 1, 4, 4))
return TEST_SKIPPED;
- rc= memcached_mget(memc, global_keys, global_keys_length, global_count);
+ memcached_return_t rc= memcached_mget(memc, global_keys, global_keys_length, global_count);
- test_true_got(rc == MEMCACHED_SUCCESS, memcached_strerror(NULL, rc));
+ test_true_got(memcached_success(rc), memcached_strerror(NULL, rc));
// Go fetch the keys and test to see if all of them were returned
{
static test_return_t mget_read_result(memcached_st *memc)
{
- memcached_return_t rc;
- if (! libmemcached_util_version_check(memc, 1, 4, 4))
+ if (not libmemcached_util_version_check(memc, 1, 4, 4))
return TEST_SKIPPED;
- rc= memcached_mget(memc, global_keys, global_keys_length, global_count);
+ memcached_return_t rc= memcached_mget(memc, global_keys, global_keys_length, global_count);
- test_true_got(rc == MEMCACHED_SUCCESS, memcached_strerror(NULL, rc));
+ test_true_got(memcached_success(rc), memcached_strerror(NULL, rc));
/* Turn this into a help function */
{
memcached_result_st results_obj;
- memcached_result_st *results;
-
- results= memcached_result_create(memc, &results_obj);
+ memcached_result_st *results= memcached_result_create(memc, &results_obj);
while ((results= memcached_fetch_result(memc, &results_obj, &rc)))
{
static test_return_t mget_read_function(memcached_st *memc)
{
- memcached_return_t rc;
- size_t counter;
- memcached_execute_fn callbacks[1];
- if (! libmemcached_util_version_check(memc, 1, 4, 4))
+ if (not libmemcached_util_version_check(memc, 1, 4, 4))
return TEST_SKIPPED;
- rc= memcached_mget(memc, global_keys, global_keys_length, global_count);
+ memcached_return_t rc= memcached_mget(memc, global_keys, global_keys_length, global_count);
- test_true_got(rc == MEMCACHED_SUCCESS, memcached_strerror(NULL, rc));
+ test_true_got(memcached_success(rc), memcached_strerror(NULL, rc));
- callbacks[0]= &callback_counter;
- counter= 0;
+ memcached_execute_fn callbacks[]= { &callback_counter };
+ size_t counter= 0;
rc= memcached_fetch_execute(memc, callbacks, (void *)&counter, 1);
return TEST_SUCCESS;
static test_return_t delete_buffer_generate(memcached_st *memc)
{
- uint64_t latch= 0;
-
- latch= 1;
+ uint64_t latch= 1;
memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_BUFFER_REQUESTS, latch);
for (size_t x= 0; x < global_count; x++)
{
memcached_return_t rc;
char servername[]= "0.example.com";
- memcached_server_st *servers;
- servers= memcached_server_list_append_with_weight(NULL, servername, 400, 0, &rc);
+ memcached_server_st *servers= memcached_server_list_append_with_weight(NULL, servername, 400, 0, &rc);
test_true(servers);
- test_true(1 == memcached_server_list_count(servers));
+ test_compare(1, memcached_server_list_count(servers));
for (size_t x= 2; x < 20; x++)
{
snprintf(buffer, SMALL_STRING_LEN, "%lu.example.com", (unsigned long)(400 +x));
servers= memcached_server_list_append_with_weight(servers, buffer, 401, 0,
&rc);
- test_true(rc == MEMCACHED_SUCCESS);
- test_true(x == memcached_server_list_count(servers));
+ test_compare(MEMCACHED_SUCCESS, rc);
+ test_compare(x, memcached_server_list_count(servers));
}
- rc= memcached_server_push(memc, servers);
- test_true(rc == MEMCACHED_SUCCESS);
- rc= memcached_server_push(memc, servers);
- test_true(rc == MEMCACHED_SUCCESS);
+ test_compare(MEMCACHED_SUCCESS, memcached_server_push(memc, servers));
+ test_compare(MEMCACHED_SUCCESS, memcached_server_push(memc, servers));
memcached_server_list_free(servers);
static test_return_t pre_cork(memcached_st *memc)
{
- memcached_return_t rc;
- bool set= true;
-
- rc= memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_CORK, set);
-
#ifdef __APPLE__
return TEST_SKIPPED;
#endif
-
- if (rc == MEMCACHED_SUCCESS)
+ bool set= true;
+ if (memcached_success(memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_CORK, set)))
return TEST_SUCCESS;
return TEST_SKIPPED;
static test_return_t pre_cork_and_nonblock(memcached_st *memc)
{
- test_return_t rc;
-
- rc= pre_cork(memc);
-
#ifdef __APPLE__
return TEST_SKIPPED;
#endif
-
- if (rc != TEST_SUCCESS)
- return rc;
+ test_return_t test_rc;
+ if ((test_rc= pre_cork(memc)) != TEST_SUCCESS)
+ return test_rc;
return pre_nonblock(memc);
}
static test_return_t pre_behavior_ketama(memcached_st *memc)
{
- memcached_return_t rc;
- uint64_t value;
-
- rc= memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_KETAMA, 1);
+ memcached_return_t rc= memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_KETAMA, 1);
test_true(rc == MEMCACHED_SUCCESS);
- value= memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_KETAMA);
+ uint64_t value= memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_KETAMA);
test_true(value == 1);
return TEST_SUCCESS;
static test_return_t pre_behavior_ketama_weighted(memcached_st *memc)
{
- memcached_return_t rc;
- uint64_t value;
-
- rc= memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_KETAMA_WEIGHTED, 1);
+ memcached_return_t rc= memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_KETAMA_WEIGHTED, 1);
test_true(rc == MEMCACHED_SUCCESS);
- value= memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_KETAMA_WEIGHTED);
+ 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);
const char *user= getenv("LIBMEMCACHED_TEST_SASL_USERNAME");
const char *pass= getenv("LIBMEMCACHED_TEST_SASL_PASSWORD");
- if (server != NULL && user != NULL && pass != NULL)
+ if (server and user and pass)
{
memcached_server_st *servers= memcached_servers_parse(server);
- test_true(servers != NULL);
+ 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);
static test_return_t pre_replication(memcached_st *memc)
{
- test_return_t test_rc;
- test_rc= pre_binary(memc);
-
- if (test_rc != TEST_SUCCESS)
- return test_rc;
+ test_true(TEST_SUCCESS == pre_binary(memc));
/*
* Make sure that we store the item on all servers
* (master + replicas == number of servers)
*/
- memcached_return_t rc;
- rc= memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_NUMBER_OF_REPLICAS,
- memcached_server_count(memc) - 1);
+ memcached_return_t rc= memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_NUMBER_OF_REPLICAS,
+ memcached_server_count(memc) - 1);
test_true(rc == MEMCACHED_SUCCESS);
test_true(memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_NUMBER_OF_REPLICAS) == memcached_server_count(memc) - 1);
static test_return_t pre_replication_noblock(memcached_st *memc)
{
- test_return_t rc;
-
- rc= pre_replication(memc);
- if (rc != TEST_SUCCESS)
- return rc;
-
- rc= pre_nonblock(memc);
+ test_compare(TEST_SUCCESS, pre_replication(memc));
- return rc;
+ return pre_nonblock(memc);
}
}
-static void *my_realloc(const memcached_st *ptr, void *mem, const size_t size, void *context)
+static void *my_realloc(const memcached_st *ptr, void *mem, const size_t size, void *)
{
- (void)context;
#ifdef HARD_MALLOC_TESTS
void *real_ptr= (mem == NULL) ? NULL : (void*)((caddr_t)mem - 8);
void *nmem= realloc(real_ptr, size + 8);
}
-static void *my_calloc(const memcached_st *ptr, size_t nelem, const size_t size, void *context)
+static void *my_calloc(const memcached_st *ptr, size_t nelem, const size_t size, void *)
{
- (void)context;
#ifdef HARD_MALLOC_TESTS
void *mem= my_malloc(ptr, nelem * size);
if (mem)
static test_return_t dump_test(memcached_st *memc)
{
- memcached_return_t rc;
size_t counter= 0;
memcached_dump_fn callbacks[1];
test_return_t main_rc;
test_true (main_rc == TEST_SUCCESS);
- rc= memcached_dump(memc, callbacks, (void *)&counter, 1);
+ memcached_return_t rc= memcached_dump(memc, callbacks, (void *)&counter, 1);
test_true(rc == MEMCACHED_SUCCESS);
/* We may have more then 32 if our previous flush has not completed */
const char *value= "milka";
memcached_reset_last_disconnected_server(memc);
+ test_false(memc->last_disconnected_server);
rc= memcached_set(memc, key, strlen(key),
value, strlen(value),
(time_t)0, (uint32_t)0);
test_true(rc == MEMCACHED_SUCCESS || rc == MEMCACHED_BUFFERED);
disconnected_server = memcached_server_get_last_disconnect(memc);
- test_true(disconnected_server == NULL);
+ test_false(disconnected_server);
/* With a non existing server */
memcached_st *mine;
rc= memcached_set(mine, key, strlen(key),
value, strlen(value),
(time_t)0, (uint32_t)0);
- test_true(rc != MEMCACHED_SUCCESS);
+ test_true(memcached_failed(rc));
disconnected_server= memcached_server_get_last_disconnect(mine);
- if (disconnected_server == NULL)
- {
- fprintf(stderr, "RC %s\n", memcached_strerror(mine, rc));
- abort();
- }
- test_true(disconnected_server != NULL);
- test_true(memcached_server_port(disconnected_server)== 9);
+ test_true_got(disconnected_server, memcached_strerror(mine, rc));
+ test_compare(9, memcached_server_port(disconnected_server));
test_true(strncmp(memcached_server_name(disconnected_server),"localhost",9) == 0);
memcached_quit(mine);
return TEST_SUCCESS;
}
+static test_return_t test_multiple_get_last_disconnect(memcached_st *)
+{
+ const char *server_string= "--server=localhost:8888 --server=localhost:8889 --server=localhost:8890 --server=localhost:8891 --server=localhost:8892";
+ char buffer[BUFSIZ];
+
+ memcached_return_t rc;
+ test_compare_got(MEMCACHED_SUCCESS,
+ rc= libmemcached_check_configuration(server_string, strlen(server_string), buffer, sizeof(buffer)),
+ memcached_strerror(NULL, rc));
+
+ memcached_st *memc= memcached(server_string, strlen(server_string));
+ test_true(memc);
+
+ // We will just use the error strings as our keys
+ uint32_t counter= 100;
+ while (--counter)
+ {
+ for (int x= int(MEMCACHED_SUCCESS); x < int(MEMCACHED_MAXIMUM_RETURN); ++x)
+ {
+ 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_WRITE_FAILURE, ret, memcached_strerror(NULL, ret));
+
+ memcached_server_instance_st disconnected_server= memcached_server_get_last_disconnect(memc);
+ test_true(disconnected_server);
+ test_strcmp("localhost", memcached_server_name(disconnected_server));
+ test_true(memcached_server_port(disconnected_server) >= 8888 and memcached_server_port(disconnected_server) <= 8892);
+
+ if (random() % 2)
+ {
+ memcached_reset_last_disconnected_server(memc);
+ }
+ }
+ }
+
+ memcached_free(memc);
+
+ return TEST_SUCCESS;
+}
+
static test_return_t test_verbosity(memcached_st *memc)
{
memcached_verbosity(memc, 3);
return TEST_SUCCESS;
}
-static test_return_t regression_bug_583031(memcached_st *unused)
+static test_return_t regression_bug_583031(memcached_st *)
{
- (void)unused;
-
- memcached_st *memc= memcached_create(NULL);
- assert(memc);
- memcached_server_add(memc, "10.2.3.4", 11211);
+ memcached_st *memc= memcached_create(NULL);
+ test_true(memc);
+ test_true(memcached_success(memcached_server_add(memc, "10.2.3.4", 11211)));
- memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_CONNECT_TIMEOUT, 1000);
- memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_RETRY_TIMEOUT, 1000);
- memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_SND_TIMEOUT, 1000);
- memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_RCV_TIMEOUT, 1000);
- memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_POLL_TIMEOUT, 1000);
- memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_SERVER_FAILURE_LIMIT, 3);
+ memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_CONNECT_TIMEOUT, 1000);
+ memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_RETRY_TIMEOUT, 1000);
+ memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_SND_TIMEOUT, 1000);
+ memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_RCV_TIMEOUT, 1000);
+ memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_POLL_TIMEOUT, 1000);
+ memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_SERVER_FAILURE_LIMIT, 3);
- memcached_return_t rc;
- size_t length;
- uint32_t flags;
+ memcached_return_t rc;
+ size_t length;
+ uint32_t flags;
- (void)memcached_get(memc, "dsf", 3, &length, &flags, &rc);
+ const char *value= memcached_get(memc, "dsf", 3, &length, &flags, &rc);
+ test_false(value);
+ test_compare(0, length);
- test_true_got(rc == MEMCACHED_TIMEOUT || rc == MEMCACHED_ERRNO || rc == MEMCACHED_FAILURE, memcached_strerror(memc, rc));
+ test_true_got(rc == MEMCACHED_TIMEOUT || rc == MEMCACHED_ERRNO || rc == MEMCACHED_FAILURE, memcached_strerror(memc, rc));
- memcached_free(memc);
+ memcached_free(memc);
- return TEST_SUCCESS;
+ return TEST_SUCCESS;
}
-static test_return_t regression_bug_581030(memcached_st *unused)
+static test_return_t regression_bug_581030(memcached_st *)
{
- (void)unused;
-
#ifndef DEBUG
memcached_stat_st *local_stat= memcached_stat(NULL, NULL, NULL);
test_false(local_stat);
};
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},
{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},
+ {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},
{"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 },
{0, 0, (test_callback_fn)0}
};
{"error_conditions", 0, 0, error_conditions},
{"parser", 0, 0, parser_tests},
{"virtual buckets", 0, 0, virtual_bucket_tests},
+ {"memcached_server_get_last_disconnect", 0, 0, memcached_server_get_last_disconnect_tests},
{0, 0, 0, 0}
};
projects / awesomized / libmemcached / blobdiff