#include <libtest/test.hpp>
#if defined(HAVE_LIBUUID) && HAVE_LIBUUID
-#include <uuid/uuid.h>
+# include <uuid/uuid.h>
#endif
/*
*/
#include <libmemcached-1.0/memcached.h>
-#include <libmemcached/is.h>
-#include <libmemcached/server_instance.h>
+#include "libmemcached/is.h"
+#include "libmemcached/server_instance.h"
#include <libhashkit-1.0/hashkit.h>
#include "tests/keys.hpp"
-#include "libmemcached/instance.h"
+#include "libmemcached/instance.hpp"
static memcached_st * create_single_instance_memcached(const memcached_st *original_memc, const char *options)
{
* I only want to hit _one_ server so I know the number of requests I'm
* sending in the pipeline.
*/
- memcached_server_instance_st instance= memcached_server_instance_by_position(original_memc, 0);
+ const memcached_instance_st * instance= memcached_server_instance_by_position(original_memc, 0);
char server_string[1024];
int server_string_length;
in_port_t test_ports[TEST_PORT_COUNT];
static memcached_return_t server_display_function(const memcached_st *ptr,
- memcached_server_instance_st server,
+ const memcached_instance_st * server,
void *context)
{
/* Do Nothing */
}
static memcached_return_t dump_server_information(const memcached_st *ptr,
- memcached_server_instance_st instance,
+ const memcached_instance_st * instance,
void *context)
{
/* Do Nothing */
size_t bigger= 0; /* Prime the value for the test_true in server_display_function */
memcached_server_fn callbacks[1];
memcached_st *local_memc;
- memcached_server_instance_st instance;
+ const memcached_instance_st * instance;
(void)ptr;
local_memc= memcached_create(NULL);
}
static memcached_return_t server_display_unsort_function(const memcached_st*,
- memcached_server_instance_st server,
+ const memcached_instance_st * server,
void *context)
{
/* Do Nothing */
test_true(memc_clone->retry_timeout == memc->retry_timeout);
test_true(memc_clone->send_size == memc->send_size);
test_true(memc_clone->server_failure_limit == memc->server_failure_limit);
+ test_true(memc_clone->server_timeout_limit == memc->server_timeout_limit);
test_true(memc_clone->snd_timeout == memc->snd_timeout);
test_true(memc_clone->user_data == memc->user_data);
{
test_true(libmemcached_string_behavior(memcached_behavior_t(x)));
}
- test_compare(37, int(MEMCACHED_BEHAVIOR_MAX));
+ test_compare(38, int(MEMCACHED_BEHAVIOR_MAX));
return TEST_SUCCESS;
}
4159057246U, 3425930182U, 2593724503U, 1868899624U,
1769812374U, 2302537950U, 1110330676U, 3365377466U,
1336171666U, 3021258493U, 2334992265U, 3861994737U,
- 3582734124U, 3365377466U };
+ 3582734124U, 3889811103, 3365377466U };
// You have updated the memcache_error messages but not updated docs/tests.
for (int rc= int(MEMCACHED_SUCCESS); rc < int(MEMCACHED_MAXIMUM_RETURN); ++rc)
}
test_compare(values[rc], hash_val);
}
- test_compare(49, int(MEMCACHED_MAXIMUM_RETURN));
+ test_compare(50, int(MEMCACHED_MAXIMUM_RETURN));
return TEST_SUCCESS;
}
test_compare(MEMCACHED_SUCCESS, memcached_flush(memc, 0));
- test_skip(true, memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_SUPPORT_CAS, true));
+ test_compare(MEMCACHED_SUCCESS, memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_SUPPORT_CAS, true));
test_compare(MEMCACHED_SUCCESS,
memcached_set(memc,
}
static memcached_return_t server_function(const memcached_st *,
- memcached_server_instance_st,
+ const memcached_instance_st *,
void *)
{
/* Do Nothing */
test_compare(MEMCACHED_SUCCESS,
memcached_behavior_set(memc_clone, MEMCACHED_BEHAVIOR_VERIFY_KEY, true));
test_compare(query_id, memcached_query_id(memc_clone)); // We should not increase the query_id for memcached_behavior_set()
+ ASSERT_TRUE(memcached_behavior_get(memc_clone, MEMCACHED_BEHAVIOR_VERIFY_KEY));
/* All keys are valid in the binary protocol (except for length) */
if (memcached_behavior_get(memc_clone, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL) == false)
test_return_t stats_servername_test(memcached_st *memc)
{
memcached_stat_st memc_stat;
- memcached_server_instance_st instance=
+ const memcached_instance_st * instance=
memcached_server_instance_by_position(memc, 0);
if (LIBMEMCACHED_WITH_SASL_SUPPORT and memcached_get_sasl_callbacks(memc))
return TEST_SUCCESS;
}
-test_return_t increment_with_initial_test(memcached_st *memc)
+static test_return_t __increment_with_initial_test(memcached_st *memc, uint64_t initial)
{
- test_skip(true, memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL));
-
uint64_t new_number;
- uint64_t initial= 0;
test_compare(MEMCACHED_SUCCESS, memcached_flush_buffers(memc));
- test_compare(MEMCACHED_SUCCESS,
- memcached_increment_with_initial(memc, test_literal_param("number"), 1, initial, 0, &new_number));
- test_compare(new_number, initial);
+ if (memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL))
+ {
+ test_compare(MEMCACHED_SUCCESS,
+ memcached_increment_with_initial(memc, test_literal_param("number"), 1, initial, 0, &new_number));
+ test_compare(new_number, initial);
- test_compare(MEMCACHED_SUCCESS,
- memcached_increment_with_initial(memc, test_literal_param("number"), 1, initial, 0, &new_number));
- test_compare(new_number, (initial +1));
+ test_compare(MEMCACHED_SUCCESS,
+ memcached_increment_with_initial(memc, test_literal_param("number"), 1, initial, 0, &new_number));
+ test_compare(new_number, (initial +1));
+ }
+ else
+ {
+ test_compare(MEMCACHED_INVALID_ARGUMENTS,
+ memcached_increment_with_initial(memc, test_literal_param("number"), 1, initial, 0, &new_number));
+ }
return TEST_SUCCESS;
}
+test_return_t increment_with_initial_test(memcached_st *memc)
+{
+ return __increment_with_initial_test(memc, 0);
+}
+
+test_return_t increment_with_initial_999_test(memcached_st *memc)
+{
+ return __increment_with_initial_test(memc, 999);
+}
+
test_return_t decrement_test(memcached_st *memc)
{
test_compare(return_value_based_on_buffering(memc),
return TEST_SUCCESS;
}
-test_return_t decrement_with_initial_test(memcached_st *memc)
+static test_return_t __decrement_with_initial_test(memcached_st *memc, uint64_t initial)
{
test_skip(true, memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL));
- uint64_t initial= 3;
-
test_compare(MEMCACHED_SUCCESS, memcached_flush_buffers(memc));
uint64_t new_number;
return TEST_SUCCESS;
}
+test_return_t decrement_with_initial_test(memcached_st *memc)
+{
+ return __decrement_with_initial_test(memc, 3);
+}
+
+test_return_t decrement_with_initial_999_test(memcached_st *memc)
+{
+ return __decrement_with_initial_test(memc, 999);
+}
+
test_return_t increment_by_key_test(memcached_st *memc)
{
const char *master_key= "foo";
test_return_t increment_with_initial_by_key_test(memcached_st *memc)
{
- test_skip(true, memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL));
-
uint64_t new_number;
const char *master_key= "foo";
const char *key= "number";
uint64_t initial= 0;
- 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);
+ if (memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL))
+ {
+ 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);
- 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));
+ 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));
+ }
+ else
+ {
+ test_compare(MEMCACHED_INVALID_ARGUMENTS,
+ memcached_increment_with_initial_by_key(memc, master_key, strlen(master_key),
+ key, strlen(key),
+ 1, initial, 0, &new_number));
+ }
return TEST_SUCCESS;
}
uint64_t new_number;
uint64_t initial= 3;
- test_compare(MEMCACHED_SUCCESS,
- memcached_decrement_with_initial_by_key(memc,
- test_literal_param("foo"),
- test_literal_param("number"),
- 1, initial, 0, &new_number));
- test_compare(new_number, initial);
+ if (memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL))
+ {
+ test_compare(MEMCACHED_SUCCESS,
+ memcached_decrement_with_initial_by_key(memc,
+ test_literal_param("foo"),
+ test_literal_param("number"),
+ 1, initial, 0, &new_number));
+ test_compare(new_number, initial);
- test_compare(MEMCACHED_SUCCESS,
- memcached_decrement_with_initial_by_key(memc,
- test_literal_param("foo"),
- test_literal_param("number"),
- 1, initial, 0, &new_number));
- test_compare(new_number, (initial - 1));
+ test_compare(MEMCACHED_SUCCESS,
+ memcached_decrement_with_initial_by_key(memc,
+ test_literal_param("foo"),
+ test_literal_param("number"),
+ 1, initial, 0, &new_number));
+ test_compare(new_number, (initial - 1));
+ }
+ else
+ {
+ test_compare(MEMCACHED_INVALID_ARGUMENTS,
+ memcached_decrement_with_initial_by_key(memc,
+ test_literal_param("foo"),
+ test_literal_param("number"),
+ 1, initial, 0, &new_number));
+ }
return TEST_SUCCESS;
}
/* First add all of the items.. */
char blob[1024] = {0};
+ for (size_t x= 0; x < keys.size(); ++x)
+ {
+ uint64_t query_id= memcached_query_id(memc);
+ memcached_return_t rc= memcached_add(memc,
+ keys.key_at(x), keys.length_at(x),
+ blob, sizeof(blob),
+ 0, 0);
+ ASSERT_TRUE_(rc == MEMCACHED_SUCCESS or rc == MEMCACHED_BUFFERED, "Returned %s", memcached_strerror(NULL, rc));
+ test_compare(query_id +1, memcached_query_id(memc));
+ }
+
+ /* Try to get all of them with a large multiget */
+ size_t counter= 0;
+ memcached_execute_fn callbacks[]= { &callback_counter };
+ test_compare(MEMCACHED_SUCCESS,
+ memcached_mget_execute(memc,
+ keys.keys_ptr(), keys.lengths_ptr(),
+ keys.size(), callbacks, &counter, 1));
+
+ {
+ uint64_t query_id= memcached_query_id(memc);
+ test_compare(MEMCACHED_SUCCESS,
+ memcached_fetch_execute(memc, callbacks, (void *)&counter, 1));
+ test_compare(query_id, memcached_query_id(memc));
+
+ /* Verify that we got all of the items */
+ test_compare(keys.size(), counter);
+ }
+
+ memcached_free(memc);
+
+ return TEST_SUCCESS;
+}
+
+test_return_t MEMCACHED_BEHAVIOR_IO_KEY_PREFETCH_TEST(memcached_st *original_memc)
+{
+ test_skip(true, memcached_behavior_get(original_memc, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL));
+
+ memcached_st *memc= create_single_instance_memcached(original_memc, "--BINARY-PROTOCOL");
+ test_true(memc);
+
+ test_skip(MEMCACHED_SUCCESS, memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_IO_KEY_PREFETCH, 8));
+
+ keys_st keys(20480);
+
+ /* First add all of the items.. */
+ char blob[1024] = {0};
+
for (size_t x= 0; x < keys.size(); ++x)
{
uint64_t query_id= memcached_query_id(memc);
memcached_server_list_free(list);
test_compare(status, MEMCACHED_SUCCESS);
- memcached_server_instance_st server= memcached_server_by_key(memc, test_literal_param(__func__), &status);
+ const memcached_instance_st * server= memcached_server_by_key(memc, test_literal_param(__func__), &status);
test_true(server);
test_compare(status, MEMCACHED_SUCCESS);
*/
test_return_t user_supplied_bug11(memcached_st *memc)
{
- memcached_st *mclone= memcached_clone(NULL, memc);
-
- memcached_behavior_set(mclone, MEMCACHED_BEHAVIOR_NO_BLOCK, true);
- memcached_behavior_set(mclone, MEMCACHED_BEHAVIOR_TCP_NODELAY, true);
- memcached_behavior_set(mclone, MEMCACHED_BEHAVIOR_POLL_TIMEOUT, size_t(-1));
+ (void)memc;
+#ifndef __APPLE__
+ test::Memc mclone(memc);
- test_compare(-1, int32_t(memcached_behavior_get(mclone, MEMCACHED_BEHAVIOR_POLL_TIMEOUT)));
+ memcached_behavior_set(&mclone, MEMCACHED_BEHAVIOR_NO_BLOCK, true);
+ memcached_behavior_set(&mclone, MEMCACHED_BEHAVIOR_TCP_NODELAY, true);
+ memcached_behavior_set(&mclone, MEMCACHED_BEHAVIOR_POLL_TIMEOUT, size_t(-1));
+ test_compare(-1, int32_t(memcached_behavior_get(&mclone, MEMCACHED_BEHAVIOR_POLL_TIMEOUT)));
libtest::vchar_t value;
value.reserve(512);
for (unsigned int x= 1; x <= 100000; ++x)
{
- memcached_return_t rc= memcached_set(mclone, test_literal_param("foo"), &value[0], value.size(), 0, 0);
+ memcached_return_t rc= memcached_set(&mclone, test_literal_param("foo"), &value[0], value.size(), 0, 0);
(void)rc;
}
- memcached_free(mclone);
+#endif
return TEST_SUCCESS;
}
memcached_return_t rc= memcached_set(memc, test_literal_param("foo"),
&value[0], current_length,
(time_t)0, (uint32_t)0);
- test_true(rc == MEMCACHED_SUCCESS or rc == MEMCACHED_BUFFERED);
+ ASSERT_TRUE_(rc == MEMCACHED_SUCCESS or rc == MEMCACHED_BUFFERED, "Instead got %s", memcached_strerror(NULL, rc));
size_t string_length;
uint32_t flags;
memcached_st *memc= memcached(test_literal_param("--server=localhost:11311/?100 --server=localhost:11312/?100"));
- memcached_server_instance_st server= memcached_server_by_key(memc, "a", 1, &res);
+ const memcached_instance_st * server= memcached_server_by_key(memc, "a", 1, &res);
test_true(server);
memcached_free(memc);
return TEST_SUCCESS;
}
+test_return_t comparison_operator_memcached_st_and__memcached_return_t_TEST(memcached_st *)
+{
+ test::Memc memc_;
+
+ memcached_st *memc= &memc_;
+
+ ASSERT_EQ(memc, MEMCACHED_SUCCESS);
+ test_compare(memc, MEMCACHED_SUCCESS);
+
+ ASSERT_NEQ(memc, MEMCACHED_FAILURE);
+
+ return TEST_SUCCESS;
+}
+
test_return_t ketama_TEST(memcached_st *)
{
test::Memc memc("--server=10.0.1.1:11211 --server=10.0.1.2:11211");
test_compare(memcached_behavior_set(&memc, MEMCACHED_BEHAVIOR_KETAMA_HASH, MEMCACHED_HASH_MD5), MEMCACHED_SUCCESS);
- test_compare(memcached_behavior_get(&memc, MEMCACHED_BEHAVIOR_KETAMA_HASH), MEMCACHED_HASH_MD5);
+ test_compare(memcached_hash_t(memcached_behavior_get(&memc, MEMCACHED_BEHAVIOR_KETAMA_HASH)), MEMCACHED_HASH_MD5);
test_compare(memcached_behavior_set_distribution(&memc, MEMCACHED_DISTRIBUTION_CONSISTENT_KETAMA_SPY), MEMCACHED_SUCCESS);
char *hostname = memc->hosts[server_idx].hostname;
in_port_t port = memc->hosts[server_idx].port;
fprintf(fp, "key %s is on host /%s:%u\n", key, hostname, port);
- memcached_server_instance_st instance=
+ const memcached_instance_st * instance=
memcached_server_instance_by_position(memc, host_index);
}
fclose(fp);
const char *key= "mine";
char *value;
- /* Make sure be default none exists */
+ /* Make sure by default none exists */
value= (char*)memcached_callback_get(memc, MEMCACHED_CALLBACK_NAMESPACE, &rc);
test_null(value);
test_compare_got(MEMCACHED_SUCCESS, rc, memcached_strerror(NULL, rc));
value= (char*)memcached_callback_get(memc, MEMCACHED_CALLBACK_NAMESPACE, &rc);
test_true(value);
- test_memcmp(value, key, 4);
+ test_memcmp(value, key, strlen(key));
test_compare_got(MEMCACHED_SUCCESS, rc, memcached_strerror(NULL, rc));
/* Test that we can turn it off */
value= (char *)memcached_callback_get(memc, MEMCACHED_CALLBACK_NAMESPACE, &rc);
test_true(value);
test_compare_got(MEMCACHED_SUCCESS, rc, memcached_strerror(NULL, rc));
- test_memcmp(value, key, 4);
+ test_memcmp(value, key, strlen(key));
/* Set to Zero, and then Set to something too large */
{
test_compare(MEMCACHED_SUCCESS,
memcached_callback_set(memc, MEMCACHED_CALLBACK_NAMESPACE, NULL));
- value= (char*)memcached_callback_get(memc, MEMCACHED_CALLBACK_NAMESPACE, &rc);
- test_null(value);
- test_compare(MEMCACHED_SUCCESS, rc);
+ ASSERT_NULL_(memcached_callback_get(memc, MEMCACHED_CALLBACK_NAMESPACE, &rc), "Setting namespace to NULL did not work");
/* Test a long key for failure */
/* TODO, extend test to determine based on setting, what result should be */
{
memcached_return_t rc;
const char *key= "mine";
- char *value;
// Make sure we default to a null namespace
- value= (char*)memcached_callback_get(memc, MEMCACHED_CALLBACK_NAMESPACE, &rc);
- test_null(value);
+ char* value= (char*)memcached_callback_get(memc, MEMCACHED_CALLBACK_NAMESPACE, &rc);
+ ASSERT_NULL_(value, "memc had a value for namespace when none should exist");
test_compare_got(MEMCACHED_SUCCESS, rc, memcached_strerror(NULL, rc));
/* Test a clean set */
memcached_callback_set(memc, MEMCACHED_CALLBACK_NAMESPACE, (void *)key));
value= (char*)memcached_callback_get(memc, MEMCACHED_CALLBACK_NAMESPACE, &rc);
- test_true(value);
- test_memcmp(value, key, 4);
+ ASSERT_TRUE(value);
+ test_memcmp(value, key, strlen(key));
test_compare_got(MEMCACHED_SUCCESS, rc, memcached_strerror(NULL, rc));
return TEST_SUCCESS;
{
memcached_version(memc);
- memcached_server_instance_st instance=
+ const memcached_instance_st * instance=
memcached_server_instance_by_position(memc, 0);
if ((instance->major_version >= 1 && (instance->minor_version == 2 && instance->micro_version >= 4))
int no_msg=0;
for (uint32_t x= 0; x < memcached_server_count(memc); ++x)
{
- memcached_server_instance_st instance=
+ const memcached_instance_st * instance=
memcached_server_instance_by_position(memc, x);
no_msg+=(int)(instance->cursor_active);
}
}
test_true(if_successful == false);
- memcached_server_instance_st instance=
+ const memcached_instance_st * instance=
memcached_server_instance_by_position(memc, 0);
memcached_version(memc);
{
test_skip(memc->servers[0].type, MEMCACHED_CONNECTION_TCP);
memcached_return_t rc;
- memcached_server_instance_st instance=
+ const memcached_instance_st * instance=
memcached_server_instance_by_position(memc, 0);
// Test both the version that returns a code, and the one that does not.
test_return_t getpid_test(memcached_st *memc)
{
memcached_return_t rc;
- memcached_server_instance_st instance=
+ const memcached_instance_st * instance=
memcached_server_instance_by_position(memc, 0);
// Test both the version that returns a code, and the one that does not.
}
static memcached_return_t ping_each_server(const memcached_st*,
- memcached_server_instance_st instance,
+ const memcached_instance_st * instance,
void*)
{
// Test both the version that returns a code, and the one that does not.
for (uint32_t x= 0; x < 250; ++x)
{
- char key[250];
+ char key[251];
size_t len= (size_t)snprintf(key, sizeof(key), "%0250u", x);
memcached_return_t rc= memcached_delete(memc, key, len, 0);
char error_buffer[2048]= { 0 };
// Delete, and then delete again to look for not found
{
- char key[250];
+ char key[251];
size_t len= snprintf(key, sizeof(key), "%037u", 251U);
memcached_return_t rc= memcached_delete(memc, key, len, 0);
test_true(rc == MEMCACHED_SUCCESS or rc == MEMCACHED_BUFFERED);
* This is to verify correct behavior in the library. Fake that two servers
* are dead..
*/
- memcached_server_instance_st instance_one= memcached_server_instance_by_position(memc, 0);
- memcached_server_instance_st instance_two= memcached_server_instance_by_position(memc, 2);
+ const memcached_instance_st * instance_one= memcached_server_instance_by_position(memc, 0);
+ const memcached_instance_st * instance_two= memcached_server_instance_by_position(memc, 2);
in_port_t port0= instance_one->port();
in_port_t port2= instance_two->port();
test_true(memc_clone);
test_true(memcached_version(memc_clone) == MEMCACHED_SUCCESS);
- memcached_server_instance_st instance=
+ const memcached_instance_st * instance=
memcached_server_instance_by_position(memc_clone, 0);
if (instance->major_version > 1 ||
test_return_t test_get_last_disconnect(memcached_st *memc)
{
memcached_return_t rc;
- memcached_server_instance_st disconnected_server;
+ const memcached_instance_st * disconnected_server;
/* With the working set of server */
const char *key= "marmotte";
memcached_return_t ret= memcached_set(memc, msg, strlen(msg), NULL, 0, (time_t)0, (uint32_t)0);
test_true_got((ret == MEMCACHED_CONNECTION_FAILURE or ret == MEMCACHED_SERVER_TEMPORARILY_DISABLED), memcached_last_error_message(memc));
- memcached_server_instance_st disconnected_server= memcached_server_get_last_disconnect(memc);
+ const memcached_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);
}
-static memcached_return_t stat_printer(memcached_server_instance_st server,
+static memcached_return_t stat_printer(const memcached_instance_st * server,
const char *key, size_t key_length,
const char *value, size_t value_length,
void *context)
test_true(rc == MEMCACHED_SUCCESS or rc == MEMCACHED_BUFFERED);
- memcached_server_instance_st instance= memcached_server_instance_by_position(memc, 0);
+ const memcached_instance_st * instance= memcached_server_instance_by_position(memc, 0);
/* The test is to see that the memcached_quit doesn't increase the
* the server failure conter, so let's ensure that it is zero
/* Put a retry timeout to effectively activate failure_limit effect */
test_compare(MEMCACHED_SUCCESS,
- memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_RETRY_TIMEOUT, true));
+ memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_RETRY_TIMEOUT, 1));
/* change behavior that triggers memcached_quit()*/
test_compare(MEMCACHED_SUCCESS,
{
memcached_st *memc= memcached_create(NULL);
test_true(memc);
- test_compare(MEMCACHED_SUCCESS, memcached_server_add(memc, "10.2.3.4", 11211));
+ test_compare(MEMCACHED_SUCCESS, memcached_server_add(memc, "10.2.251.4", 11211));
- memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_CONNECT_TIMEOUT, 1000);
+ memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_CONNECT_TIMEOUT, 3000);
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);
test_false(value);
test_zero(length);
- test_compare_got(MEMCACHED_TIMEOUT, rc, memcached_last_error_message(memc));
+ test_compare(MEMCACHED_TIMEOUT, memc);
memcached_free(memc);
return TEST_SUCCESS;
}
+test_return_t regression_bug_1251482(memcached_st*)
+{
+ test::Memc memc("--server=localhost:5");
+
+ memcached_behavior_set(&memc, MEMCACHED_BEHAVIOR_RETRY_TIMEOUT, 0);
+
+ for (size_t x= 0; x < 5; ++x)
+ {
+ size_t value_length;
+ memcached_return_t rc;
+ char *value= memcached_get(&memc,
+ test_literal_param(__func__),
+ &value_length, NULL, &rc);
+
+ test_false(value);
+ test_compare(0LLU, value_length);
+ if (x) {
+ test_ne_compare(MEMCACHED_SUCCESS, rc);
+ } else {
+ test_compare(MEMCACHED_CONNECTION_FAILURE, rc);
+ }
+ }
+
+ return TEST_SUCCESS;
+}
+
test_return_t regression_1009493_TEST(memcached_st*)
{
memcached_st* memc= memcached_create(NULL);
memcached_st *memc= create_single_instance_memcached(original_memc, 0);
test_true(memc);
- memcached_server_instance_st instance= memcached_server_instance_by_position(memc, 0);
+ const memcached_instance_st * instance= memcached_server_instance_by_position(memc, 0);
pid_t pid;
test_true((pid= libmemcached_util_getpid(memcached_server_name(instance),
0, 0));
test_true_got(kill(pid, SIGHUP) == 0, strerror(errno));
- test_compare(MEMCACHED_CONNECTION_FAILURE,
- memcached_set(memc,
- test_literal_param(__func__), // Keys
- test_literal_param(__func__), // Values
- 0, 0));
+ memcached_return_t ret= memcached_set(memc,
+ test_literal_param(__func__), // Keys
+ test_literal_param(__func__), // Values
+ 0, 0);
+ if (ret == MEMCACHED_ERRNO) {
+ test_compare(EPIPE, memcached_last_error_errno(memc));
+ } else {
+ test_compare(MEMCACHED_CONNECTION_FAILURE, ret);
+ }
memcached_free(memc);
projects / awesomized / libmemcached / blobdiff