#include <libtest/test.h>
#include "tests/parser.h"
+#include "tests/pool.h"
+#include "tests/string.h"
#include "tests/replication.h"
+#include "tests/basic.h"
+#include "tests/error_conditions.h"
#include "tests/print.h"
+#include "tests/virtual_buckets.h"
#ifdef HAVE_LIBMEMCACHEDUTIL
memc= memcached_create(&local_memc);
servers= memcached_servers_parse(server_string);
+ assert(servers);
rc= memcached_server_push(memc, servers);
memcached_server_list_free(servers);
uint32_t x= *((uint32_t *)(context));
(void)ptr;
- assert(test_ports[x] == server->port);
+ if (! (test_ports[x] == server->port))
+ {
+ fprintf(stderr, "%lu -> %lu\n", (unsigned long)test_ports[x], (unsigned long)server->port);
+ return MEMCACHED_FAILURE;
+ }
+
*((uint32_t *)(context))= ++x;
return MEMCACHED_SUCCESS;
{ // Test all of the flags
test_true(memc_clone->flags.no_block == memc->flags.no_block);
test_true(memc_clone->flags.tcp_nodelay == memc->flags.tcp_nodelay);
- test_true(memc_clone->flags.reuse_memory == memc->flags.reuse_memory);
- test_true(memc_clone->flags.use_cache_lookups == memc->flags.use_cache_lookups);
test_true(memc_clone->flags.support_cas == memc->flags.support_cas);
test_true(memc_clone->flags.buffer_requests == memc->flags.buffer_requests);
test_true(memc_clone->flags.use_sort_hosts == memc->flags.use_sort_hosts);
test_true(memc_clone->flags.verify_key == memc->flags.verify_key);
- test_true(memc_clone->flags.ketama_weighted == memc->flags.ketama_weighted);
+ test_true(memc_clone->ketama.weighted == memc->ketama.weighted);
test_true(memc_clone->flags.binary_protocol == memc->flags.binary_protocol);
test_true(memc_clone->flags.hash_with_prefix_key == memc->flags.hash_with_prefix_key);
test_true(memc_clone->flags.no_reply == memc->flags.no_reply);
2300930706U, 2943759320U, 674306647U, 2400528935U,
54481931U, 4186304426U, 1741088401U, 2979625118U,
4159057246U, 3425930182U, 2593724503U, 1868899624U,
- 1769812374U, 2302537950U, 1110330676U };
+ 1769812374U, 2302537950U, 1110330676U, 3365377466U,
+ 1336171666U, 3021258493U, 3365377466U };
// You have updated the memcache_error messages but not updated docs/tests.
- test_true(MEMCACHED_MAXIMUM_RETURN == 43);
for (rc= MEMCACHED_SUCCESS; rc < MEMCACHED_MAXIMUM_RETURN; rc++)
{
uint32_t hash_val;
}
test_true(values[rc] == hash_val);
}
+ test_true(MEMCACHED_MAXIMUM_RETURN == 46);
return TEST_SUCCESS;
}
static test_return_t memcached_server_cursor_test(memcached_st *memc)
{
- char context[8];
- strcpy(context, "foo bad");
+ char context[10];
+ strncpy(context, "foo bad", sizeof(context));
memcached_server_fn callbacks[1];
callbacks[0]= server_function;
rc= memcached_callback_set(memc_clone, MEMCACHED_CALLBACK_PREFIX_KEY, NULL);
test_true(rc == MEMCACHED_SUCCESS);
- char *longkey= malloc(max_keylen + 1);
+ char *longkey= (char *)malloc(max_keylen + 1);
if (longkey != NULL)
{
memset(longkey, 'a', max_keylen + 1);
{
memcached_return_t rc;
bool set= true;
- bool value;
rc= memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_CORK, set);
- test_true(rc == MEMCACHED_SUCCESS || rc == MEMCACHED_NOT_SUPPORTED);
-
- value= (bool)memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_CORK);
+ test_true(rc == MEMCACHED_DEPRECATED);
- if (rc == MEMCACHED_SUCCESS)
- {
- test_true((bool)value == set);
- }
- else
- {
- test_false((bool)value == set);
- }
+ // Platform dependent
+#if 0
+ bool value= (bool)memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_CORK);
+ test_false(value);
+#endif
return TEST_SUCCESS;
}
/* VDEAAAAA hashes to fffcd1b5, after the last continuum point, and lets
* us test the boundary wraparound.
*/
- test_true(memcached_generate_hash(memc, (char *)"VDEAAAAA", 8) == memc->continuum[0].index);
+ test_true(memcached_generate_hash(memc, (char *)"VDEAAAAA", 8) == memc->ketama.continuum[0].index);
/* verify the standard ketama set. */
for (x= 0; x < 99; x++)
instance= memcached_server_instance_by_position(memc, 2);
((memcached_server_write_instance_st)instance)->next_retry = time(NULL) + 15;
- memc->next_distribution_rebuild= time(NULL) - 1;
+ memc->ketama.next_distribution_rebuild= time(NULL) - 1;
/*
This would not work if there were only two hosts.
/* and re-added when it's back. */
((memcached_server_write_instance_st)instance)->next_retry = time(NULL) - 1;
- memc->next_distribution_rebuild= time(NULL) - 1;
+ memc->ketama.next_distribution_rebuild= time(NULL) - 1;
memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_DISTRIBUTION,
memc->distribution);
for (size_t x= 0; x < 99; x++)
return TEST_SUCCESS;
}
-static test_return_t string_static_null(memcached_st *memc)
-{
- memcached_string_st string;
- memcached_string_st *string_ptr;
-
- string_ptr= memcached_string_create(memc, &string, 0);
- test_true(string.options.is_initialized == true);
- test_true(string_ptr);
-
- /* The following two better be the same! */
- test_true(memcached_is_allocated(string_ptr) == false);
- test_true(memcached_is_allocated(&string) == false);
- test_true(&string == string_ptr);
-
- test_true(string.options.is_initialized == true);
- test_true(memcached_is_initialized(&string) == true);
- memcached_string_free(&string);
- test_true(memcached_is_initialized(&string) == false);
-
- return TEST_SUCCESS;
-}
-
-static test_return_t string_alloc_null(memcached_st *memc)
-{
- memcached_string_st *string;
-
- string= memcached_string_create(memc, NULL, 0);
- test_true(string);
- test_true(memcached_is_allocated(string) == true);
- test_true(memcached_is_initialized(string) == true);
- memcached_string_free(string);
-
- return TEST_SUCCESS;
-}
-
-static test_return_t string_alloc_with_size(memcached_st *memc)
-{
- memcached_string_st *string;
-
- string= memcached_string_create(memc, NULL, 1024);
- test_true(string);
- test_true(memcached_is_allocated(string) == true);
- test_true(memcached_is_initialized(string) == true);
- memcached_string_free(string);
-
- return TEST_SUCCESS;
-}
-
-static test_return_t string_alloc_with_size_toobig(memcached_st *memc)
-{
- memcached_string_st *string;
-
- string= memcached_string_create(memc, NULL, SIZE_MAX);
- test_true(string == NULL);
-
- return TEST_SUCCESS;
-}
-
-static test_return_t string_alloc_append(memcached_st *memc)
-{
- unsigned int x;
- char buffer[SMALL_STRING_LEN];
- memcached_string_st *string;
-
- /* Ring the bell! */
- memset(buffer, 6, SMALL_STRING_LEN);
-
- string= memcached_string_create(memc, NULL, 100);
- test_true(string);
- test_true(memcached_is_allocated(string) == true);
- test_true(memcached_is_initialized(string) == true);
-
- for (x= 0; x < 1024; x++)
- {
- memcached_return_t rc;
- rc= memcached_string_append(string, buffer, SMALL_STRING_LEN);
- test_true(rc == MEMCACHED_SUCCESS);
- }
- test_true(memcached_is_allocated(string) == true);
- memcached_string_free(string);
-
- return TEST_SUCCESS;
-}
-
-static test_return_t string_alloc_append_toobig(memcached_st *memc)
-{
- memcached_return_t rc;
- unsigned int x;
- char buffer[SMALL_STRING_LEN];
- memcached_string_st *string;
-
- /* Ring the bell! */
- memset(buffer, 6, SMALL_STRING_LEN);
-
- string= memcached_string_create(memc, NULL, 100);
- test_true(string);
- test_true(memcached_is_allocated(string) == true);
- test_true(memcached_is_initialized(string) == true);
-
- for (x= 0; x < 1024; x++)
- {
- rc= memcached_string_append(string, buffer, SMALL_STRING_LEN);
- test_true(rc == MEMCACHED_SUCCESS);
- }
- rc= memcached_string_append(string, buffer, SIZE_MAX);
- test_true(rc == MEMCACHED_MEMORY_ALLOCATION_FAILURE);
- test_true(memcached_is_allocated(string) == true);
- memcached_string_free(string);
-
- return TEST_SUCCESS;
-}
-
static test_return_t cleanup_pairs(memcached_st *memc)
{
(void)memc;
/* Test a clean set */
rc= memcached_callback_set(memc, MEMCACHED_CALLBACK_PREFIX_KEY, (void *)key);
- test_true(rc == MEMCACHED_SUCCESS);
+ test_true_got(rc == MEMCACHED_SUCCESS, memcached_last_error_message(memc));
value= memcached_callback_get(memc, MEMCACHED_CALLBACK_PREFIX_KEY, &rc);
+ test_true(value);
test_true(memcmp(value, key, 4) == 0);
test_true(rc == MEMCACHED_SUCCESS);
test_true(rc == MEMCACHED_SUCCESS);
value= memcached_callback_get(memc, MEMCACHED_CALLBACK_PREFIX_KEY, &rc);
+ test_false(value);
test_true(rc == MEMCACHED_FAILURE);
/* Now setup for main test */
test_true(rc == MEMCACHED_SUCCESS);
value= memcached_callback_get(memc, MEMCACHED_CALLBACK_PREFIX_KEY, &rc);
+ test_true(value);
test_true(rc == MEMCACHED_SUCCESS);
test_true(memcmp(value, key, 4) == 0);
test_true(rc == MEMCACHED_SUCCESS);
value= memcached_callback_get(memc, MEMCACHED_CALLBACK_PREFIX_KEY, &rc);
+ test_false(value);
test_true(rc == MEMCACHED_FAILURE);
test_true(value == NULL);
/* Test a long key for failure */
/* TODO, extend test to determine based on setting, what result should be */
- strcpy(long_key, "Thisismorethentheallottednumberofcharacters");
+ strncpy(long_key, "Thisismorethentheallottednumberofcharacters", sizeof(long_key));
rc= memcached_callback_set(memc, MEMCACHED_CALLBACK_PREFIX_KEY, long_key);
//test_true(rc == MEMCACHED_BAD_KEY_PROVIDED);
test_true(rc == MEMCACHED_SUCCESS);
/* Now test a key with spaces (which will fail from long key, since bad key is not set) */
- strcpy(long_key, "This is more then the allotted number of characters");
+ strncpy(long_key, "This is more then the allotted number of characters", sizeof(long_key));
rc= memcached_callback_set(memc, MEMCACHED_CALLBACK_PREFIX_KEY, long_key);
test_true(rc == MEMCACHED_BAD_KEY_PROVIDED);
rc= memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_VERIFY_KEY, 1);
test_true(rc == MEMCACHED_SUCCESS);
- strcpy(long_key, "dog cat");
+ strncpy(long_key, "dog cat", sizeof(long_key));
rc= memcached_callback_set(memc, MEMCACHED_CALLBACK_PREFIX_KEY, long_key);
test_true(rc == MEMCACHED_BAD_KEY_PROVIDED);
}
static test_return_t hsieh_avaibility_test (memcached_st *memc)
{
- memcached_return_t expected_rc= MEMCACHED_FAILURE;
+ memcached_return_t expected_rc= MEMCACHED_INVALID_ARGUMENTS;
#ifdef HAVE_HSIEH_HASH
expected_rc= MEMCACHED_SUCCESS;
#endif
static test_return_t murmur_avaibility_test (memcached_st *memc)
{
- memcached_return_t expected_rc= MEMCACHED_FAILURE;
+ memcached_return_t expected_rc= MEMCACHED_INVALID_ARGUMENTS;
#ifdef HAVE_MURMUR_HASH
expected_rc= MEMCACHED_SUCCESS;
#endif
/* VDEAAAAA hashes to fffcd1b5, after the last continuum point, and lets
* us test the boundary wraparound.
*/
- test_true(memcached_generate_hash(memc, (char *)"VDEAAAAA", 8) == memc->continuum[0].index);
+ test_true(memcached_generate_hash(memc, (char *)"VDEAAAAA", 8) == memc->ketama.continuum[0].index);
/* verify the standard ketama set. */
for (x= 0; x < 99; x++)
{
memcached_return_t rc;
uint64_t value;
- int x;
memcached_server_st *server_pool;
memcached_st *memc;
test_true(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");
+ assert(server_pool);
memcached_server_push(memc, server_pool);
/* verify that the server list was parsed okay. */
/* VDEAAAAA hashes to fffcd1b5, after the last continuum point, and lets
* us test the boundary wraparound.
*/
- test_true(memcached_generate_hash(memc, (char *)"VDEAAAAA", 8) == memc->continuum[0].index);
+ test_true(memcached_generate_hash(memc, (char *)"VDEAAAAA", 8) == memc->ketama.continuum[0].index);
/* verify the standard ketama set. */
- for (x= 0; x < 99; x++)
+ for (uint32_t x= 0; x < 99; x++)
{
uint32_t server_idx= memcached_generate_hash(memc, ketama_test_cases_spy[x].key, strlen(ketama_test_cases_spy[x].key));
uint32_t count = memcached_server_count(memc);
// Do not do this in your code, it is not supported.
- memc->servers[1].state.is_dead= true;
+ memc->servers[1].options.is_dead= true;
memc->state.is_time_for_rebuild= true;
uint32_t new_count= memcached_server_count(memc);
/* put failure limit to 1 */
rc= memcached_behavior_set(memc_clone, MEMCACHED_BEHAVIOR_SERVER_FAILURE_LIMIT, 1);
assert(rc == MEMCACHED_SUCCESS);
+
/* Put a retry timeout to effectively activate failure_limit effect */
rc= memcached_behavior_set(memc_clone, MEMCACHED_BEHAVIOR_RETRY_TIMEOUT, 1);
assert(rc == MEMCACHED_SUCCESS);
+
/* change behavior that triggers memcached_quit()*/
rc= memcached_behavior_set(memc_clone, MEMCACHED_BEHAVIOR_TCP_NODELAY, 1);
assert(rc == MEMCACHED_SUCCESS);
test_true_got(rc == MEMCACHED_SUCCESS, memcached_strerror(NULL, rc));
test_true(string);
free(string);
+ memcached_free(memc_clone);
return TEST_SUCCESS;
}
(void)memcached_get(memc, "dsf", 3, &length, &flags, &rc);
- test_true_got(rc == MEMCACHED_TIMEOUT, memcached_strerror(NULL, rc));
+ test_true_got(rc == MEMCACHED_TIMEOUT || rc == MEMCACHED_ERRNO || rc == MEMCACHED_FAILURE, memcached_strerror(memc, rc));
memcached_free(memc);
{
(void)unused;
memcached_server_st *servers = memcached_servers_parse("1.2.3.4:99");
+ assert(servers);
memcached_server_free(servers);
return TEST_SUCCESS;
{"delete_through", 1, (test_callback_fn)delete_through },
{"noreply", 1, (test_callback_fn)noreply_test},
{"analyzer", 1, (test_callback_fn)analyzer_test},
-#ifdef HAVE_LIBMEMCACHEDUTIL
{"connectionpool", 1, (test_callback_fn)connection_pool_test },
+ {"memcached_pool_test", 1, (test_callback_fn)memcached_pool_test },
{"ping", 1, (test_callback_fn)ping_test },
-#endif
{"test_get_last_disconnect", 1, (test_callback_fn)test_get_last_disconnect},
{"verbosity", 1, (test_callback_fn)test_verbosity},
{"test_server_failure", 1, (test_callback_fn)test_server_failure},
{0, 0, 0}
};
+test_st basic_tests[] ={
+ {"init", 1, (test_callback_fn)basic_init_test},
+ {"clone", 1, (test_callback_fn)basic_clone_test},
+ {"reset", 1, (test_callback_fn)basic_reset_stack_test},
+ {"reset heap", 1, (test_callback_fn)basic_reset_heap_test},
+ {"reset stack clone", 1, (test_callback_fn)basic_reset_stack_clone_test},
+ {"reset heap clone", 1, (test_callback_fn)basic_reset_heap_clone_test},
+ {0, 0, 0}
+};
+
test_st regression_binary_vs_block[] ={
{"block add", 1, (test_callback_fn)block_add_regression},
{"binary add", 1, (test_callback_fn)binary_add_regression},
{"string alloc with malloc failure", 0, (test_callback_fn)string_alloc_with_size_toobig },
{"string append", 0, (test_callback_fn)string_alloc_append },
{"string append failure (too big)", 0, (test_callback_fn)string_alloc_append_toobig },
+ {"string_alloc_append_multiple", 0, (test_callback_fn)string_alloc_append_multiple },
{0, 0, (test_callback_fn)0}
};
};
test_st error_conditions[] ={
- {"memcached_get_MEMCACHED_ERRNO", 0, (test_callback_fn)memcached_get_MEMCACHED_ERRNO },
- {"memcached_get_MEMCACHED_NOTFOUND", 0, (test_callback_fn)memcached_get_MEMCACHED_NOTFOUND },
- {"memcached_get_by_key_MEMCACHED_ERRNO", 0, (test_callback_fn)memcached_get_by_key_MEMCACHED_ERRNO },
- {"memcached_get_by_key_MEMCACHED_NOTFOUND", 0, (test_callback_fn)memcached_get_by_key_MEMCACHED_NOTFOUND },
+ {"memcached_get(MEMCACHED_ERRNO)", 0, (test_callback_fn)memcached_get_MEMCACHED_ERRNO },
+ {"memcached_get(MEMCACHED_NOTFOUND)", 0, (test_callback_fn)memcached_get_MEMCACHED_NOTFOUND },
+ {"memcached_get_by_key(MEMCACHED_ERRNO)", 0, (test_callback_fn)memcached_get_by_key_MEMCACHED_ERRNO },
+ {"memcached_get_by_key(MEMCACHED_NOTFOUND)", 0, (test_callback_fn)memcached_get_by_key_MEMCACHED_NOTFOUND },
+ {"memcached_get_by_key(MEMCACHED_NOTFOUND)", 0, (test_callback_fn)memcached_get_by_key_MEMCACHED_NOTFOUND },
+ {"memcached_increment(MEMCACHED_NO_SERVERS)", 0, (test_callback_fn)memcached_increment_MEMCACHED_NO_SERVERS },
{0, 0, (test_callback_fn)0}
};
test_st parser_tests[] ={
+ {"behavior", 0, (test_callback_fn)behavior_parser_test },
+ {"boolean_options", 0, (test_callback_fn)parser_boolean_options_test },
+ {"configure_file", 0, (test_callback_fn)memcached_create_with_options_with_filename },
+ {"distribtions", 0, (test_callback_fn)parser_distribution_test },
+ {"hash", 0, (test_callback_fn)parser_hash_test },
+ {"libmemcached_check_configuration", 0, (test_callback_fn)libmemcached_check_configuration_test },
+ {"libmemcached_check_configuration_with_filename", 0, (test_callback_fn)libmemcached_check_configuration_with_filename_test },
+ {"number_options", 0, (test_callback_fn)parser_number_options_test },
+ {"randomly generated options", 0, (test_callback_fn)random_statement_build_test },
+ {"prefix_key", 0, (test_callback_fn)parser_key_prefix_test },
{"server", 0, (test_callback_fn)server_test },
- {"servers", 0, (test_callback_fn)servers_test },
+ {"bad server strings", 0, (test_callback_fn)servers_bad_test },
+ {"server with weights", 0, (test_callback_fn)server_with_weight_test },
+ {0, 0, (test_callback_fn)0}
+};
+
+test_st virtual_bucket_tests[] ={
+ {"basic", 0, (test_callback_fn)virtual_back_map },
{0, 0, (test_callback_fn)0}
};
#if 0
{"hash_sanity", 0, 0, hash_sanity},
#endif
+ {"basic", 0, 0, basic_tests},
{"hsieh_availability", 0, 0, hsieh_availability},
{"murmur_availability", 0, 0, murmur_availability},
{"block", 0, 0, tests},
{"regression_binary_vs_block", (test_callback_fn)key_setup, (test_callback_fn)key_teardown, regression_binary_vs_block},
{"error_conditions", 0, 0, error_conditions},
{"parser", 0, 0, parser_tests},
+ {"virtual buckets", 0, 0, virtual_bucket_tests},
{0, 0, 0, 0}
};
-#define SERVERS_TO_CREATE 5
-
#include "libmemcached_world.h"
void get_world(world_st *world)
projects / awesomized / libmemcached / blobdiff