test_truth(memc_clone->flags.no_block == memc->flags.no_block);
test_truth(memc_clone->flags.tcp_nodelay == memc->flags.tcp_nodelay);
test_truth(memc_clone->flags.reuse_memory == memc->flags.reuse_memory);
- test_truth(memc_clone->flags.use_md5 == memc->flags.use_md5);
- test_truth(memc_clone->flags.use_crc == memc->flags.use_crc);
test_truth(memc_clone->flags.use_cache_lookups == memc->flags.use_cache_lookups);
test_truth(memc_clone->flags.support_cas == memc->flags.support_cas);
test_truth(memc_clone->flags.buffer_requests == memc->flags.buffer_requests);
}
test_truth(memc_clone->get_key_failure == memc->get_key_failure);
test_truth(memc_clone->hash == memc->hash);
- test_truth(memc_clone->hash_continuum == memc->hash_continuum);
+ test_truth(memc_clone->distribution_hash == memc->distribution_hash);
test_truth(memc_clone->io_bytes_watermark == memc->io_bytes_watermark);
test_truth(memc_clone->io_msg_watermark == memc->io_msg_watermark);
test_truth(memc_clone->io_key_prefetch == memc->io_key_prefetch);
unsigned int set= 1;
size_t max_keylen= 0xffff;
+ // Just skip if we are in binary mode.
+ if (memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL))
+ return TEST_SKIPPED;
+
memc_clone= memcached_clone(NULL, memc);
test_truth(memc_clone);
}
#define READ_THROUGH_VALUE "set for me"
-static memcached_return_t read_through_trigger(memcached_st *memc __attribute__((unused)),
- char *key __attribute__((unused)),
- size_t key_length __attribute__((unused)),
- memcached_result_st *result)
+static memcached_return_t read_through_trigger(memcached_st *memc __attribute__((unused)),
+ char *key __attribute__((unused)),
+ size_t key_length __attribute__((unused)),
+ memcached_result_st *result)
{
return memcached_result_set_value(result, READ_THROUGH_VALUE, strlen(READ_THROUGH_VALUE));
}
-static test_return_t read_through(memcached_st *memc)
+static test_return_t read_through(memcached_st *memc)
{
memcached_return_t rc;
const char *key= "foo";
&string_length, &flags, &rc);
test_truth(rc == MEMCACHED_NOTFOUND);
- test_truth(string_length == 0);
- test_truth(!string);
+ test_false(string_length);
+ test_false(string);
rc= memcached_callback_set(memc, MEMCACHED_CALLBACK_GET_FAILURE,
*(void **)&cb);
test_truth(rc == MEMCACHED_SUCCESS);
test_truth(string_length == strlen(READ_THROUGH_VALUE));
- test_truth(!strcmp(READ_THROUGH_VALUE, string));
+ test_strcmp(READ_THROUGH_VALUE, string);
free(string);
string= memcached_get(memc, key, strlen(key),
&string_length, &flags, &rc);
test_truth(rc == MEMCACHED_NOTFOUND);
- test_truth(string_length == 0);
- test_truth(!string);
+ test_false(string_length);
+ test_false(string);
return TEST_SUCCESS;
}
memcached_return_t rc;
memcached_stat_st memc_stat;
rc= memcached_stat_servername(&memc_stat, NULL,
- memc->hosts[0].hostname,
- memc->hosts[0].port);
+ memc->hosts[0].hostname,
+ memc->hosts[0].port);
return TEST_SUCCESS;
}
test_truth(rc == MEMCACHED_SUCCESS);
for (ptr= stat_list; *ptr; ptr++)
test_truth(*ptr);
- fflush(stdout);
free(stat_list);
value= memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_NUMBER_OF_REPLICAS);
memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_NUMBER_OF_REPLICAS, value + 1);
test_truth((value + 1) == memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_NUMBER_OF_REPLICAS));
+
return TEST_SUCCESS;
}
{
uint32_t server_idx = memcached_generate_hash(memc, ketama_test_cases[x].key, strlen(ketama_test_cases[x].key));
char *hostname = memc->hosts[server_idx].hostname;
- test_truth(strcmp(hostname, ketama_test_cases[x].server) == 0);
+ test_strcmp(hostname, ketama_test_cases[x].server);
}
memcached_server_list_free(server_pool);
static test_return_t user_supplied_bug21(memcached_st *memc)
{
- if (pre_binary(memc) != MEMCACHED_SUCCESS)
- return TEST_SKIPPED;
+ test_return_t test_rc;
+ test_rc= pre_binary(memc);
+
+ if (test_rc != TEST_SUCCESS)
+ return test_rc;
test_return_t rc;
test_truth(value == MEMCACHED_HASH_MD5);
- test_truth(memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_KETAMA_COMPAT_MODE,
- MEMCACHED_KETAMA_COMPAT_SPY) == MEMCACHED_SUCCESS);
+ test_truth(memcached_behavior_set_distribution(memc, MEMCACHED_DISTRIBUTION_CONSISTENT_KETAMA_SPY) == MEMCACHED_SUCCESS);
memcached_server_st *server_pool;
server_pool = memcached_servers_parse("10.0.1.1:11211,10.0.1.2:11211,10.0.1.3:11211,10.0.1.4:11211,10.0.1.5:11211,10.0.1.6:11211,10.0.1.7:11211,10.0.1.8:11211,192.168.1.1:11211,192.168.100.1:11211");
uint32_t server_idx = memcached_generate_hash(memc, key, strlen(key));
char *hostname = memc->hosts[server_idx].hostname;
- unsigned int port = memc->hosts[server_idx].port;
+ in_port_t port = memc->hosts[server_idx].port;
fprintf(fp, "key %s is on host /%s:%u\n", key, hostname, port);
}
fclose(fp);
return rc == MEMCACHED_SUCCESS ? TEST_SUCCESS : TEST_SKIPPED;
}
+
static test_return_t pre_replication(memcached_st *memc)
{
- if (pre_binary(memc) != TEST_SUCCESS)
- return TEST_FAILURE;
+ test_return_t test_rc;
+ test_rc= pre_binary(memc);
+
+ if (test_rc != TEST_SUCCESS)
+ return test_rc;
/*
* Make sure that we store the item on all servers
return rc == MEMCACHED_SUCCESS ? TEST_SUCCESS : TEST_SKIPPED;
}
+
static test_return_t pre_replication_noblock(memcached_st *memc)
{
- test_return_t rc= MEMCACHED_FAILURE;
- if (pre_replication(memc) == TEST_SUCCESS &&
- pre_nonblock(memc) == TEST_SUCCESS)
- rc= TEST_SUCCESS;
+ test_return_t rc;
+
+ rc= pre_replication(memc);
+ if (rc != TEST_SUCCESS)
+ return rc;
+
+ rc= pre_nonblock(memc);
return rc;
}
+
static void my_free(memcached_st *ptr __attribute__((unused)), void *mem)
{
+#ifdef HARD_MALLOC_TESTS
+ void *real_ptr= (mem == NULL) ? mem : (void*)((caddr_t)mem - 8);
+ free(real_ptr);
+#else
free(mem);
+#endif
}
+
static void *my_malloc(memcached_st *ptr __attribute__((unused)), const size_t size)
{
+#ifdef HARD_MALLOC_TESTS
+ void *ret= malloc(size + 8);
+ if (ret != NULL)
+ {
+ ret= (void*)((caddr_t)ret + 8);
+ }
+#else
void *ret= malloc(size);
+#endif
+
if (ret != NULL)
+ {
memset(ret, 0xff, size);
+ }
return ret;
}
+
static void *my_realloc(memcached_st *ptr __attribute__((unused)), void *mem, const size_t size)
{
+#ifdef HARD_MALLOC_TESTS
+ void *real_ptr= (mem == NULL) ? NULL : (void*)((caddr_t)mem - 8);
+ void *nmem= realloc(real_ptr, size + 8);
+
+ void *ret= NULL;
+ if (nmem != NULL)
+ {
+ ret= (void*)((caddr_t)nmem + 8);
+ }
+
+ return ret;
+#else
return realloc(mem, size);
+#endif
}
+
static void *my_calloc(memcached_st *ptr __attribute__((unused)), size_t nelem, const size_t size)
{
+#ifdef HARD_MALLOC_TESTS
+ void *mem= my_malloc(ptr, nelem * size);
+ if (mem)
+ {
+ memset(mem, 0, nelem * size);
+ }
+
+ return mem;
+#else
return calloc(nelem, size);
+#endif
}
+
static test_return_t set_prefix(memcached_st *memc)
{
memcached_return_t rc;
return TEST_SUCCESS;
}
+
#ifdef MEMCACHED_ENABLE_DEPRECATED
static test_return_t deprecated_set_memory_alloc(memcached_st *memc)
{
}
#endif
+
static test_return_t set_memory_alloc(memcached_st *memc)
{
memcached_return_t rc;
return TEST_SUCCESS;
}
-static test_return_t enable_consistent(memcached_st *memc)
+static test_return_t enable_consistent_crc(memcached_st *memc)
+{
+ test_return_t rc;
+ memcached_server_distribution_t value= MEMCACHED_DISTRIBUTION_CONSISTENT;
+ memcached_hash_t hash;
+ memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_DISTRIBUTION, value);
+ if ((rc= pre_crc(memc)) != TEST_SUCCESS)
+ return rc;
+
+ value= (memcached_server_distribution_t)memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_DISTRIBUTION);
+ test_truth(value == MEMCACHED_DISTRIBUTION_CONSISTENT);
+
+ hash= (memcached_hash_t)memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_HASH);
+
+ if (hash != MEMCACHED_HASH_CRC)
+ return TEST_SKIPPED;
+
+ return TEST_SUCCESS;
+}
+
+static test_return_t enable_consistent_hsieh(memcached_st *memc)
{
test_return_t rc;
memcached_server_distribution_t value= MEMCACHED_DISTRIBUTION_CONSISTENT;
static test_return_t binary_init_udp(memcached_st *memc)
{
- pre_binary(memc);
+ test_return_t test_rc;
+ test_rc= pre_binary(memc);
+
+ if (test_rc != TEST_SUCCESS)
+ return test_rc;
+
return init_udp(memc);
}
(void)trash;
memc= memcached_create(NULL);
- assert(memc);
+ test_truth(memc);
rc= memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_KETAMA_WEIGHTED, 1);
- assert(rc == MEMCACHED_SUCCESS);
+ test_truth(rc == MEMCACHED_SUCCESS);
value= memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_KETAMA_WEIGHTED);
- assert(value == 1);
+ test_truth(value == 1);
- assert(memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_KETAMA_COMPAT_MODE,
- MEMCACHED_KETAMA_COMPAT_LIBMEMCACHED) == MEMCACHED_SUCCESS);
+ test_truth(memcached_behavior_set_distribution(memc, MEMCACHED_DISTRIBUTION_CONSISTENT_KETAMA) == MEMCACHED_SUCCESS);
+ test_truth(memcached_behavior_get_distribution(memc) == MEMCACHED_DISTRIBUTION_CONSISTENT_KETAMA);
- assert(memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_KETAMA_COMPAT_MODE) ==
- MEMCACHED_KETAMA_COMPAT_LIBMEMCACHED);
server_pool = memcached_servers_parse("10.0.1.1:11211 600,10.0.1.2:11211 300,10.0.1.3:11211 200,10.0.1.4:11211 350,10.0.1.5:11211 1000,10.0.1.6:11211 800,10.0.1.7:11211 950,10.0.1.8:11211 100");
memcached_server_push(memc, server_pool);
(void)trash;
memc= memcached_create(NULL);
- assert(memc);
+ test_truth(memc);
rc= memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_KETAMA_WEIGHTED, 1);
- assert(rc == MEMCACHED_SUCCESS);
+ test_truth(rc == MEMCACHED_SUCCESS);
value= memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_KETAMA_WEIGHTED);
- assert(value == 1);
-
- assert(memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_KETAMA_COMPAT_MODE,
- MEMCACHED_KETAMA_COMPAT_SPY) == MEMCACHED_SUCCESS);
+ test_truth(value == 1);
- assert(memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_KETAMA_COMPAT_MODE) ==
- MEMCACHED_KETAMA_COMPAT_SPY);
+ test_truth(memcached_behavior_set_distribution(memc, MEMCACHED_DISTRIBUTION_CONSISTENT_KETAMA_SPY) == MEMCACHED_SUCCESS);
+ test_truth(memcached_behavior_get_distribution(memc) == MEMCACHED_DISTRIBUTION_CONSISTENT_KETAMA_SPY);
server_pool = memcached_servers_parse("10.0.1.1:11211 600,10.0.1.2:11211 300,10.0.1.3:11211 200,10.0.1.4:11211 350,10.0.1.5:11211 1000,10.0.1.6:11211 800,10.0.1.7:11211 950,10.0.1.8:11211 100");
memcached_server_push(memc, server_pool);
static test_return_t regression_bug_434484(memcached_st *memc)
{
- if (pre_binary(memc) != MEMCACHED_SUCCESS)
- return TEST_SKIPPED;
+ test_return_t test_rc;
+ test_rc= pre_binary(memc);
+
+ if (test_rc != TEST_SUCCESS)
+ return test_rc;
memcached_return_t ret;
const char *key= "regression_bug_434484";
static test_return_t regression_bug_434843(memcached_st *memc)
{
- if (pre_binary(memc) != MEMCACHED_SUCCESS)
- return TEST_SKIPPED;
+ test_return_t test_rc;
+ test_rc= pre_binary(memc);
+
+ if (test_rc != TEST_SUCCESS)
+ return test_rc;
memcached_return_t rc;
unsigned int counter= 0;
* This is to verify correct behavior in the library. Fake that two servers
* are dead..
*/
- unsigned int port0= memc->hosts[0].port;
- unsigned int port2= memc->hosts[2].port;
+ in_port_t port0= memc->hosts[0].port;
+ in_port_t port2= memc->hosts[2].port;
+
memc->hosts[0].port= 0;
memc->hosts[2].port= 0;
/* Remove half of the objects */
for (int x= 0; x < (int)max_keys; ++x)
+ {
if (x & 1)
{
rc= memcached_delete(memc, keys[x], key_length[x], 0);
assert(rc == MEMCACHED_SUCCESS);
}
+ }
memcached_quit(memc);
memc->hosts[0].port= 0;
/* restore the memc handle */
memc->hosts[0].port= port0;
memc->hosts[2].port= port2;
+
return TEST_SUCCESS;
}
{"clone_test", 0, (test_callback_fn)clone_test },
{"connection_test", 0, (test_callback_fn)connection_test},
{"callback_test", 0, (test_callback_fn)callback_test},
- {"behavior_test", 0, (test_callback_fn)behavior_test},
{"userdata_test", 0, (test_callback_fn)userdata_test},
{"error", 0, (test_callback_fn)error_test },
{"set", 0, (test_callback_fn)set_test },
{"add_host_test", 0, (test_callback_fn)add_host_test },
{"add_host_test_1", 0, (test_callback_fn)add_host_test1 },
{"get_stats_keys", 0, (test_callback_fn)get_stats_keys },
- {"behavior_test", 0, (test_callback_fn)get_stats_keys },
- {"callback_test", 0, (test_callback_fn)get_stats_keys },
{"version_string_test", 0, (test_callback_fn)version_string_test},
{"bad_key", 1, (test_callback_fn)bad_key_test },
{"memcached_server_cursor", 1, (test_callback_fn)memcached_server_cursor_test },
{0, 0, 0}
};
+test_st behavior_tests[] ={
+ {"behavior_test", 0, (test_callback_fn)behavior_test},
+ {0, 0, 0}
+};
+
test_st async_tests[] ={
{"add", 1, (test_callback_fn)add_wrapper },
{0, 0, 0}
{"unix_socket_nodelay", (test_callback_fn)pre_nodelay, 0, tests},
{"poll_timeout", (test_callback_fn)poll_timeout, 0, tests},
{"gets", (test_callback_fn)enable_cas, 0, tests},
- {"consistent", (test_callback_fn)enable_consistent, 0, tests},
+ {"consistent_crc", (test_callback_fn)enable_consistent_crc, 0, tests},
+ {"consistent_hsieh", (test_callback_fn)enable_consistent_hsieh, 0, tests},
#ifdef MEMCACHED_ENABLE_DEPRECATED
{"deprecated_memory_allocators", (test_callback_fn)deprecated_set_memory_alloc, 0, tests},
#endif
{"generate", 0, 0, generate_tests},
{"generate_hsieh", (test_callback_fn)pre_hsieh, 0, generate_tests},
{"generate_ketama", (test_callback_fn)pre_behavior_ketama, 0, generate_tests},
- {"generate_hsieh_consistent", (test_callback_fn)enable_consistent, 0, generate_tests},
+ {"generate_hsieh_consistent", (test_callback_fn)enable_consistent_hsieh, 0, generate_tests},
{"generate_md5", (test_callback_fn)pre_md5, 0, generate_tests},
{"generate_murmur", (test_callback_fn)pre_murmur, 0, generate_tests},
{"generate_jenkins", (test_callback_fn)pre_jenkins, 0, generate_tests},
{"replication", (test_callback_fn)pre_replication, 0, replication_tests},
{"replication_noblock", (test_callback_fn)pre_replication_noblock, 0, replication_tests},
{"regression", 0, 0, regression_tests},
+ {"behaviors", 0, 0, behavior_tests},
{0, 0, 0, 0}
};
projects / awesomized / libmemcached / blobdiff