X-Git-Url: https://git.m6w6.name/?a=blobdiff_plain;f=tests%2Fmem_functions.c;h=11d7219b68f2b2e6bf0be1bf18351883ebfe2b06;hb=0f46c72f570994b6f9edc01925f25c3857d41b59;hp=701de4424c8d90c6ba8f2e7faa5a5010d0dc6e53;hpb=96c84d98b1b2db8419072eea960e8800c189586b;p=m6w6%2Flibmemcached diff --git a/tests/mem_functions.c b/tests/mem_functions.c index 701de442..11d7219b 100644 --- a/tests/mem_functions.c +++ b/tests/mem_functions.c @@ -52,6 +52,10 @@ static pairs_st *global_pairs; static const char *global_keys[GLOBAL_COUNT]; static size_t global_keys_length[GLOBAL_COUNT]; +// Prototype +static test_return_t pre_binary(memcached_st *memc); + + static test_return_t init_test(memcached_st *not_used __attribute__((unused))) { memcached_st memc; @@ -1667,7 +1671,7 @@ static test_return_t mget_execute(memcached_st *memc) uint32_t number_of_hosts= memc->number_of_hosts; memc->number_of_hosts= 1; - size_t max_keys= binary ? 20480 : 1; + size_t max_keys= 20480; char **keys= calloc(max_keys, sizeof(char*)); @@ -1676,6 +1680,7 @@ static test_return_t mget_execute(memcached_st *memc) /* First add all of the items.. */ char blob[1024] = {0}; memcached_return_t rc; + for (size_t x= 0; x < max_keys; ++x) { char k[251]; @@ -1693,21 +1698,23 @@ static test_return_t mget_execute(memcached_st *memc) rc= memcached_mget_execute(memc, (const char**)keys, key_length, max_keys, callbacks, &counter, 1); - if (binary) + if (rc == MEMCACHED_SUCCESS) { - test_true(rc == MEMCACHED_SUCCESS); - + test_true(binary); rc= memcached_fetch_execute(memc, callbacks, (void *)&counter, 1); test_true(rc == MEMCACHED_END); /* Verify that we got all of the items */ test_true(counter == max_keys); } - else + else if (rc == MEMCACHED_NOT_SUPPORTED) { - test_true(rc == MEMCACHED_NOT_SUPPORTED); test_true(counter == 0); } + else + { + test_fail("note: this test functions differently when in binary mode"); + } /* Release all allocated resources */ for (size_t x= 0; x < max_keys; ++x) @@ -1721,6 +1728,51 @@ static test_return_t mget_execute(memcached_st *memc) return TEST_SUCCESS; } +#define REGRESSION_BINARY_VS_BLOCK_COUNT 20480 + +static test_return_t key_setup(memcached_st *memc) +{ + (void)memc; + + if (pre_binary(memc) != TEST_SUCCESS) + return TEST_SKIPPED; + + global_pairs= pairs_generate(REGRESSION_BINARY_VS_BLOCK_COUNT, 0); + + return TEST_SUCCESS; +} + +static test_return_t key_teardown(memcached_st *memc) +{ + (void)memc; + pairs_free(global_pairs); + + return TEST_SUCCESS; +} + +static test_return_t block_add_regression(memcached_st *memc) +{ + /* First add all of the items.. */ + for (size_t x= 0; x < REGRESSION_BINARY_VS_BLOCK_COUNT; ++x) + { + memcached_return_t rc; + char blob[1024] = {0}; + + rc= memcached_add_by_key(memc, "bob", 3, global_pairs[x].key, global_pairs[x].key_length, blob, sizeof(blob), 0, 0); + test_true(rc == MEMCACHED_SUCCESS || rc == MEMCACHED_BUFFERED); + } + + return TEST_SUCCESS; +} + +static test_return_t binary_add_regression(memcached_st *memc) +{ + memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL, 1); + test_return_t rc= block_add_regression(memc); + memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL, 0); + return rc; +} + static test_return_t get_stats_keys(memcached_st *memc) { char **stat_list; @@ -2945,8 +2997,6 @@ static test_return_t _user_supplied_bug21(memcached_st* memc, size_t key_count) return TEST_SUCCESS; } -static test_return_t pre_binary(memcached_st *memc); - static test_return_t user_supplied_bug21(memcached_st *memc) { test_return_t test_rc; @@ -4912,6 +4962,136 @@ static test_return_t memcached_get_hashkit_test (memcached_st *memc) return TEST_SUCCESS; } +/* + Test case adapted from John Gorman + + We are testing the error condition when we connect to a server via memcached_get() + but find that the server is not available. +*/ +static test_return_t memcached_get_MEMCACHED_SOME_ERRORS(memcached_st *memc) +{ + (void)memc; + memcached_st *tl_memc_h; + memcached_server_st *servers; + + const char *key= "MemcachedLives"; + size_t len; + uint32_t flags; + memcached_return rc; + char *value; + + // Create a handle. + tl_memc_h= memcached_create(NULL); + servers= memcached_servers_parse("localhost:9898"); // This server should not exist + memcached_server_push(tl_memc_h, servers); + memcached_server_list_free(servers); + + // See if memcached is reachable. + value= memcached_get(tl_memc_h, key, strlen(key), &len, &flags, &rc); + + if (value) + { + free(value); + test_true(value); // Pointer won't be zero so this is fine. + } + + test_true(len == 0); + test_true(rc == MEMCACHED_SOME_ERRORS); + + return TEST_SUCCESS; +} + +/* + We connect to a server which exists, but search for a key that does not exist. +*/ +static test_return_t memcached_get_MEMCACHED_NOTFOUND(memcached_st *memc) +{ + const char *key= "MemcachedKeyNotEXIST"; + size_t len; + uint32_t flags; + memcached_return rc; + char *value; + + // See if memcached is reachable. + value= memcached_get(memc, key, strlen(key), &len, &flags, &rc); + + if (value) + { + free(value); + test_true(value); // Pointer won't be zero so this is fine. + } + + test_true(len == 0); + test_true(rc == MEMCACHED_NOTFOUND); + + return TEST_SUCCESS; +} + +/* + Test case adapted from John Gorman + + We are testing the error condition when we connect to a server via memcached_get_by_key() + but find that the server is not available. +*/ +static test_return_t memcached_get_by_key_MEMCACHED_SOME_ERRORS(memcached_st *memc) +{ + (void)memc; + memcached_st *tl_memc_h; + memcached_server_st *servers; + + const char *key= "MemcachedLives"; + size_t len; + uint32_t flags; + memcached_return rc; + char *value; + + // Create a handle. + tl_memc_h= memcached_create(NULL); + servers= memcached_servers_parse("localhost:9898"); // This server should not exist + memcached_server_push(tl_memc_h, servers); + memcached_server_list_free(servers); + + // See if memcached is reachable. + value= memcached_get_by_key(tl_memc_h, key, strlen(key), key, strlen(key), &len, &flags, &rc); + + if (value) + { + free(value); + test_true(value); // Pointer won't be zero so this is fine. + } + + test_true(len == 0); + test_true(rc == MEMCACHED_SOME_ERRORS); + + return TEST_SUCCESS; +} + +/* + We connect to a server which exists, but search for a key that does not exist. +*/ +static test_return_t memcached_get_by_key_MEMCACHED_NOTFOUND(memcached_st *memc) +{ + const char *key= "MemcachedKeyNotEXIST"; + size_t len; + uint32_t flags; + memcached_return rc; + char *value; + + // See if memcached is reachable. + value= memcached_get_by_key(memc, key, strlen(key), key, strlen(key), &len, &flags, &rc); + + if (value) + { + free(value); + test_true(value); // Pointer won't be zero so this is fine. + } + + test_true(len == 0); + test_true(rc == MEMCACHED_NOTFOUND); + + return TEST_SUCCESS; +} + static test_return_t ketama_compatibility_libmemcached(memcached_st *trash) { @@ -5585,6 +5765,10 @@ static test_return_t regression_bug_490486(memcached_st *memc) memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_SERVER_FAILURE_LIMIT, 1); memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_RETRY_TIMEOUT, 3600); +#ifdef __APPLE__ + return TEST_SKIPPED; // My MAC can't handle this test +#endif + /* * I only want to hit _one_ server so I know the number of requests I'm * sending in the pipeline. @@ -5598,6 +5782,7 @@ static test_return_t regression_bug_490486(memcached_st *memc) size_t *key_length=calloc(max_keys, sizeof(size_t)); /* First add all of the items.. */ + bool slept= false; char blob[1024]= { 0 }; memcached_return rc; for (size_t x= 0; x < max_keys; ++x) @@ -5607,38 +5792,60 @@ static test_return_t regression_bug_490486(memcached_st *memc) keys[x]= strdup(k); assert(keys[x] != NULL); rc= memcached_set(memc, keys[x], key_length[x], blob, sizeof(blob), 0, 0); - assert(rc == MEMCACHED_SUCCESS || rc == MEMCACHED_BUFFERED); +#ifdef __APPLE__ + if (rc == MEMCACHED_SERVER_MARKED_DEAD) + { + break; // We are out of business + } +#endif + test_true(rc == MEMCACHED_SUCCESS || rc == MEMCACHED_BUFFERED || rc == MEMCACHED_TIMEOUT); // MEMCACHED_TIMEOUT <-- only observed on OSX + + if (rc == MEMCACHED_TIMEOUT && slept == false) + { + x++; + sleep(1);// We will try to sleep + slept= true; + } + else if (rc == MEMCACHED_TIMEOUT && slept == true) + { + // We failed to send everything. + break; + } } - /* Try to get all of them with a large multiget */ - size_t counter= 0; - memcached_execute_function callbacks[1]= { [0]= &callback_counter }; - rc= memcached_mget_execute(memc, (const char**)keys, key_length, - (size_t)max_keys, callbacks, &counter, 1); + if (rc != MEMCACHED_SERVER_MARKED_DEAD) + { - assert(rc == MEMCACHED_SUCCESS); - char* the_value= NULL; - char the_key[MEMCACHED_MAX_KEY]; - size_t the_key_length; - size_t the_value_length; - uint32_t the_flags; + /* Try to get all of them with a large multiget */ + size_t counter= 0; + memcached_execute_function callbacks[1]= { [0]= &callback_counter }; + rc= memcached_mget_execute(memc, (const char**)keys, key_length, + (size_t)max_keys, callbacks, &counter, 1); - do { - the_value= memcached_fetch(memc, the_key, &the_key_length, &the_value_length, &the_flags, &rc); + assert(rc == MEMCACHED_SUCCESS); + char* the_value= NULL; + char the_key[MEMCACHED_MAX_KEY]; + size_t the_key_length; + size_t the_value_length; + uint32_t the_flags; - if ((the_value!= NULL) && (rc == MEMCACHED_SUCCESS)) - { - ++counter; - free(the_value); - } + do { + the_value= memcached_fetch(memc, the_key, &the_key_length, &the_value_length, &the_flags, &rc); - } while ( (the_value!= NULL) && (rc == MEMCACHED_SUCCESS)); + if ((the_value!= NULL) && (rc == MEMCACHED_SUCCESS)) + { + ++counter; + free(the_value); + } + } while ( (the_value!= NULL) && (rc == MEMCACHED_SUCCESS)); - assert(rc == MEMCACHED_END); - /* Verify that we got all of the items */ - assert(counter == max_keys); + assert(rc == MEMCACHED_END); + + /* Verify that we got all of the items */ + assert(counter == max_keys); + } /* Release all allocated resources */ for (size_t x= 0; x < max_keys; ++x) @@ -5758,7 +5965,7 @@ static test_return_t regression_bug_(memcached_st *memc) } } - return MEMCACHED_SUCCESS; + return TEST_SUCCESS; } /* @@ -5869,6 +6076,12 @@ test_st behavior_tests[] ={ {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}, + {0, 0, 0} +}; + test_st async_tests[] ={ {"add", 1, (test_callback_fn)add_wrapper }, {0, 0, 0} @@ -6041,6 +6254,14 @@ test_st hash_tests[] ={ {0, 0, (test_callback_fn)0} }; +test_st error_conditions[] ={ + {"memcached_get_MEMCACHED_SOME_ERRORS", 0, (test_callback_fn)memcached_get_MEMCACHED_SOME_ERRORS }, + {"memcached_get_MEMCACHED_NOTFOUND", 0, (test_callback_fn)memcached_get_MEMCACHED_NOTFOUND }, + {"memcached_get_by_key_MEMCACHED_SOME_ERRORS", 0, (test_callback_fn)memcached_get_by_key_MEMCACHED_SOME_ERRORS }, + {"memcached_get_by_key_MEMCACHED_NOTFOUND", 0, (test_callback_fn)memcached_get_by_key_MEMCACHED_NOTFOUND }, + {0, 0, (test_callback_fn)0} +}; + collection_st collection[] ={ #if 0 {"hash_sanity", 0, 0, hash_sanity}, @@ -6100,6 +6321,8 @@ collection_st collection[] ={ {"replication_noblock", (test_callback_fn)pre_replication_noblock, 0, replication_tests}, {"regression", 0, 0, regression_tests}, {"behaviors", 0, 0, behavior_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}, {0, 0, 0, 0} };