}
#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;
}
return rc == MEMCACHED_SUCCESS ? TEST_SUCCESS : TEST_SKIPPED;
}
+
static test_return_t pre_replication(memcached_st *memc)
{
test_return_t test_rc;
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;
{"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}
};