X-Git-Url: https://git.m6w6.name/?a=blobdiff_plain;f=tests%2Fmem_functions.cc;h=c2fbdc322e88f1279f91d30645c2dd53f0b38783;hb=5ed5a750b9ae6e4e577232ecf50dc333eb414298;hp=abf2ea45d5be1c0e64f4f8d9f5666106c28288fa;hpb=6063a17ebe3594f4e7334b3e8ac370782f9ea2ae;p=awesomized%2Flibmemcached diff --git a/tests/mem_functions.cc b/tests/mem_functions.cc index abf2ea45..c2fbdc32 100644 --- a/tests/mem_functions.cc +++ b/tests/mem_functions.cc @@ -106,16 +106,47 @@ static size_t global_keys_length[GLOBAL_COUNT]; */ static test_return_t pre_binary(memcached_st *memc) { - memcached_return_t rc= MEMCACHED_FAILURE; + test_skip(true, libmemcached_util_version_check(memc, 1, 4, 4)); + test_skip(MEMCACHED_SUCCESS, memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL, true)); + + return TEST_SUCCESS; +} + +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); - if (libmemcached_util_version_check(memc, 1, 4, 4)) + char server_string[1024]; + int server_string_length; + if (options) { - rc = memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL, 1); - test_compare(MEMCACHED_SUCCESS, rc); - test_true(memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL) == 1); + server_string_length= snprintf(server_string, sizeof(server_string), "--server=%s:%d %s", + memcached_server_name(instance), int(memcached_server_port(instance)), + options); + } + else + { + server_string_length= snprintf(server_string, sizeof(server_string), "--server=%s:%d", + memcached_server_name(instance), int(memcached_server_port(instance))); } - return rc == MEMCACHED_SUCCESS ? TEST_SUCCESS : TEST_SKIPPED; + if (server_string_length <= 0) + { + return NULL; + } + + char buffer[1024]; + if (memcached_failed(libmemcached_check_configuration(server_string, server_string_length, buffer, sizeof(buffer)))) + { + Error << "Failed to parse " << server_string_length; + return NULL; + } + + return memcached(server_string, server_string_length); } @@ -454,7 +485,7 @@ static test_return_t memcached_return_t_TEST(memcached_st *memc) 4159057246U, 3425930182U, 2593724503U, 1868899624U, 1769812374U, 2302537950U, 1110330676U, 3365377466U, 1336171666U, 3021258493U, 2334992265U, 3861994737U, - 3365377466U }; + 3582734124, 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) @@ -470,7 +501,7 @@ static test_return_t memcached_return_t_TEST(memcached_st *memc) } test_compare(values[rc], hash_val); } - test_compare(48, int(MEMCACHED_MAXIMUM_RETURN)); + test_compare(49, int(MEMCACHED_MAXIMUM_RETURN)); return TEST_SUCCESS; } @@ -910,7 +941,11 @@ static test_return_t bad_key_test(memcached_st *memc) memcached_callback_set(memc_clone, MEMCACHED_CALLBACK_NAMESPACE, NULL)); std::vector longkey; - longkey.insert(longkey.end(), MEMCACHED_MAX_KEY, 'a'); + { + std::vector::iterator it= longkey.begin(); + longkey.insert(it, MEMCACHED_MAX_KEY, 'a'); + } + test_compare(longkey.size(), size_t(MEMCACHED_MAX_KEY)); { size_t string_length; @@ -1054,15 +1089,12 @@ static test_return_t get_test2(memcached_st *memc) static test_return_t set_test2(memcached_st *memc) { - const char *key= "foo"; - const char *value= "train in the brain"; - size_t value_length= strlen(value); - for (uint32_t x= 0; x < 10; x++) { - memcached_return_t rc= memcached_set(memc, key, strlen(key), - value, value_length, - (time_t)0, (uint32_t)0); + memcached_return_t rc= memcached_set(memc, + test_literal_param("foo"), + test_literal_param("train in the brain"), + time_t(0), uint32_t(0)); test_true(rc == MEMCACHED_SUCCESS or rc == MEMCACHED_BUFFERED); } @@ -1073,12 +1105,11 @@ static test_return_t set_test3(memcached_st *memc) { size_t value_length= 8191; - char *value= (char*)malloc(value_length); - test_true(value); - + std::vector value; + value.reserve(value_length); for (uint32_t x= 0; x < value_length; x++) { - value[x] = (char) (x % 127); + value.push_back(char(x % 127)); } /* The dump test relies on there being at least 32 items in memcached */ @@ -1090,14 +1121,12 @@ static test_return_t set_test3(memcached_st *memc) uint64_t query_id= memcached_query_id(memc); memcached_return_t rc= memcached_set(memc, key, strlen(key), - value, value_length, + &value[0], value.size(), (time_t)0, (uint32_t)0); test_true_got(rc == MEMCACHED_SUCCESS or rc == MEMCACHED_BUFFERED, memcached_strerror(NULL, rc)); test_compare(query_id +1, memcached_query_id(memc)); } - free(value); - return TEST_SUCCESS; } @@ -1106,17 +1135,16 @@ static test_return_t get_test3(memcached_st *memc) const char *key= "foo"; size_t value_length= 8191; - char *value= (char*)malloc(value_length); - test_true(value); - + std::vector value; + value.reserve(value_length); for (uint32_t x= 0; x < value_length; x++) { - value[x] = (char) (x % 127); + value.push_back(char(x % 127)); } memcached_return_t rc; rc= memcached_set(memc, key, strlen(key), - value, value_length, + &value[0], value.size(), (time_t)0, (uint32_t)0); test_true(rc == MEMCACHED_SUCCESS or rc == MEMCACHED_BUFFERED); @@ -1128,10 +1156,9 @@ static test_return_t get_test3(memcached_st *memc) test_compare(MEMCACHED_SUCCESS, rc); test_true(string); test_compare(string_length, value_length); - test_memcmp(string, value, string_length); + test_memcmp(string, &value[0], string_length); free(string); - free(value); return TEST_SUCCESS; } @@ -1141,16 +1168,15 @@ static test_return_t get_test4(memcached_st *memc) const char *key= "foo"; size_t value_length= 8191; - char *value= (char*)malloc(value_length); - test_true(value); - + std::vector value; + value.reserve(value_length); for (uint32_t x= 0; x < value_length; x++) { - value[x] = (char) (x % 127); + value.push_back(char(x % 127)); } memcached_return_t rc= memcached_set(memc, key, strlen(key), - value, value_length, + &value[0], value.size(), (time_t)0, (uint32_t)0); test_true(rc == MEMCACHED_SUCCESS or rc == MEMCACHED_BUFFERED); @@ -1164,12 +1190,10 @@ static test_return_t get_test4(memcached_st *memc) test_compare(MEMCACHED_SUCCESS, rc); test_true(string); test_compare(string_length, value_length); - test_memcmp(string, value, string_length); + test_memcmp(string, &value[0], string_length); free(string); } - free(value); - return TEST_SUCCESS; } @@ -1750,19 +1774,12 @@ static test_return_t mget_test(memcached_st *memc) return TEST_SUCCESS; } -static test_return_t mget_execute(memcached_st *memc) +static test_return_t mget_execute(memcached_st *original_memc) { - bool binary= false; - - if (memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL) != 0) - binary= true; + test_skip(true, memcached_behavior_get(original_memc, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL)); - /* - * I only want to hit _one_ server so I know the number of requests I'm - * sending in the pipeline. - */ - uint32_t number_of_hosts= memc->number_of_hosts; - memc->number_of_hosts= 1; + memcached_st *memc= create_single_instance_memcached(original_memc, "--BINARY-PROTOCOL"); + test_true(memc); size_t max_keys= 20480; @@ -1772,7 +1789,6 @@ 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) { @@ -1782,7 +1798,7 @@ static test_return_t mget_execute(memcached_st *memc) keys[x]= strdup(k); test_true(keys[x] != NULL); uint64_t query_id= memcached_query_id(memc); - rc= memcached_add(memc, keys[x], key_length[x], blob, sizeof(blob), 0, 0); + memcached_return_t rc= memcached_add(memc, keys[x], key_length[x], blob, sizeof(blob), 0, 0); test_true_got(rc == MEMCACHED_SUCCESS or rc == MEMCACHED_BUFFERED, memcached_strerror(NULL, rc)); test_compare(query_id +1, memcached_query_id(memc)); } @@ -1790,12 +1806,11 @@ static test_return_t mget_execute(memcached_st *memc) /* Try to get all of them with a large multiget */ size_t counter= 0; memcached_execute_fn callbacks[]= { &callback_counter }; - rc= memcached_mget_execute(memc, (const char**)keys, key_length, - max_keys, callbacks, &counter, 1); + test_compare(MEMCACHED_SUCCESS, + memcached_mget_execute(memc, (const char**)keys, key_length, + max_keys, callbacks, &counter, 1)); - if (memcached_success(rc)) { - test_true(binary); uint64_t query_id= memcached_query_id(memc); test_compare(MEMCACHED_SUCCESS, memcached_fetch_execute(memc, callbacks, (void *)&counter, 1)); @@ -1804,14 +1819,6 @@ static test_return_t mget_execute(memcached_st *memc) /* Verify that we got all of the items */ test_true(counter == max_keys); } - else if (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) @@ -1821,7 +1828,8 @@ static test_return_t mget_execute(memcached_st *memc) free(keys); free(key_length); - memc->number_of_hosts= number_of_hosts; + memcached_free(memc); + return TEST_SUCCESS; } @@ -1849,11 +1857,10 @@ 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); + memcached_return_t rc= memcached_add_by_key(memc, "bob", 3, global_pairs[x].key, global_pairs[x].key_length, blob, sizeof(blob), 0, 0); + test_true_got(rc == MEMCACHED_SUCCESS or rc == MEMCACHED_SERVER_MEMORY_ALLOCATION_FAILURE, memcached_strerror(NULL, rc)); } return TEST_SUCCESS; @@ -1861,9 +1868,9 @@ static test_return_t block_add_regression(memcached_st *memc) static test_return_t binary_add_regression(memcached_st *memc) { - memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL, 1); + test_skip(MEMCACHED_SUCCESS, memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL, true)); test_return_t rc= block_add_regression(memc); - memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL, 0); + return rc; } @@ -1884,14 +1891,9 @@ static test_return_t get_stats_keys(memcached_st *memc) return TEST_SUCCESS; } -static test_return_t version_string_test(memcached_st *memc) +static test_return_t version_string_test(memcached_st *) { - const char *version_string; - (void)memc; - - version_string= memcached_lib_version(); - - test_strcmp(version_string, LIBMEMCACHED_VERSION_STRING); + test_strcmp(LIBMEMCACHED_VERSION_STRING, memcached_lib_version()); return TEST_SUCCESS; } @@ -1920,16 +1922,13 @@ static test_return_t get_stats(memcached_st *memc) static test_return_t add_host_test(memcached_st *memc) { - unsigned int x; - memcached_server_st *servers; - memcached_return_t rc; char servername[]= "0.example.com"; - servers= memcached_server_list_append_with_weight(NULL, servername, 400, 0, &rc); - test_true(servers); - test_true(1 == memcached_server_list_count(servers)); + memcached_return_t rc; + memcached_server_st *servers= memcached_server_list_append_with_weight(NULL, servername, 400, 0, &rc); + test_compare(1U, memcached_server_list_count(servers)); - for (x= 2; x < 20; x++) + for (unsigned int x= 2; x < 20; x++) { char buffer[SMALL_STRING_LEN]; @@ -1937,13 +1936,11 @@ static test_return_t add_host_test(memcached_st *memc) servers= memcached_server_list_append_with_weight(servers, buffer, 401, 0, &rc); test_compare(MEMCACHED_SUCCESS, rc); - test_true(x == memcached_server_list_count(servers)); + test_compare(x, memcached_server_list_count(servers)); } - rc= memcached_server_push(memc, servers); - test_compare(MEMCACHED_SUCCESS, rc); - rc= memcached_server_push(memc, servers); - test_compare(MEMCACHED_SUCCESS, rc); + test_compare(MEMCACHED_SUCCESS, memcached_server_push(memc, servers)); + test_compare(MEMCACHED_SUCCESS, memcached_server_push(memc, servers)); memcached_server_list_free(servers); @@ -1953,15 +1950,15 @@ static test_return_t add_host_test(memcached_st *memc) static test_return_t memcached_fetch_result_NOT_FOUND(memcached_st *memc) { memcached_return_t rc; + const char *key= "not_found"; - size_t key_len= strlen(key); + size_t key_length= test_literal_param_size("not_found"); test_compare(MEMCACHED_SUCCESS, - memcached_mget(memc, &key, &key_len, 1)); + memcached_mget(memc, &key, &key_length, 1)); - memcached_result_st *result= NULL; - result= memcached_fetch_result(memc, result, &rc); - test_false(result); + memcached_result_st *result= memcached_fetch_result(memc, NULL, &rc); + test_null(result); test_compare_got(MEMCACHED_NOTFOUND, rc, memcached_strerror(NULL, rc)); memcached_result_free(result); @@ -1969,15 +1966,13 @@ static test_return_t memcached_fetch_result_NOT_FOUND(memcached_st *memc) return TEST_SUCCESS; } -static memcached_return_t clone_test_callback(memcached_st *parent, memcached_st *memc_clone) +static memcached_return_t clone_test_callback(memcached_st *, memcached_st *) { - (void)parent;(void)memc_clone; return MEMCACHED_SUCCESS; } -static memcached_return_t cleanup_test_callback(memcached_st *ptr) +static memcached_return_t cleanup_test_callback(memcached_st *) { - (void)ptr; return MEMCACHED_SUCCESS; } @@ -1989,8 +1984,7 @@ static test_return_t callback_test(memcached_st *memc) int *test_ptr; memcached_return_t rc; - rc= memcached_callback_set(memc, MEMCACHED_CALLBACK_USER_DATA, &x); - test_compare(MEMCACHED_SUCCESS, rc); + test_compare(MEMCACHED_SUCCESS, memcached_callback_set(memc, MEMCACHED_CALLBACK_USER_DATA, &x)); test_ptr= (int *)memcached_callback_get(memc, MEMCACHED_CALLBACK_USER_DATA, &rc); test_true(*test_ptr == x); } @@ -2000,26 +1994,22 @@ static test_return_t callback_test(memcached_st *memc) memcached_clone_fn clone_cb= (memcached_clone_fn)clone_test_callback; void *clone_cb_ptr= *(void **)&clone_cb; void *temp_function= NULL; - memcached_return_t rc; - rc= memcached_callback_set(memc, MEMCACHED_CALLBACK_CLONE_FUNCTION, - clone_cb_ptr); - test_compare(MEMCACHED_SUCCESS, rc); + test_compare(MEMCACHED_SUCCESS, memcached_callback_set(memc, MEMCACHED_CALLBACK_CLONE_FUNCTION, clone_cb_ptr)); + memcached_return_t rc; temp_function= memcached_callback_get(memc, MEMCACHED_CALLBACK_CLONE_FUNCTION, &rc); test_true(temp_function == clone_cb_ptr); + test_compare(MEMCACHED_SUCCESS, rc); } /* Test Cleanup Callback */ { - memcached_cleanup_fn cleanup_cb= - (memcached_cleanup_fn)cleanup_test_callback; + memcached_cleanup_fn cleanup_cb= (memcached_cleanup_fn)cleanup_test_callback; void *cleanup_cb_ptr= *(void **)&cleanup_cb; void *temp_function= NULL; memcached_return_t rc; - rc= memcached_callback_set(memc, MEMCACHED_CALLBACK_CLONE_FUNCTION, - cleanup_cb_ptr); - test_compare(MEMCACHED_SUCCESS, rc); + test_compare(MEMCACHED_SUCCESS, memcached_callback_set(memc, MEMCACHED_CALLBACK_CLONE_FUNCTION, cleanup_cb_ptr)); temp_function= memcached_callback_get(memc, MEMCACHED_CALLBACK_CLONE_FUNCTION, &rc); test_true(temp_function == cleanup_cb_ptr); } @@ -2030,62 +2020,42 @@ static test_return_t callback_test(memcached_st *memc) /* We don't test the behavior itself, we test the switches */ static test_return_t behavior_test(memcached_st *memc) { - uint64_t value; - uint32_t set= 1; - - memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_NO_BLOCK, set); - value= memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_NO_BLOCK); - test_true(value == 1); - - memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_TCP_NODELAY, set); - value= memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_TCP_NODELAY); - test_true(value == 1); + memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_NO_BLOCK, 1); + test_compare(true, memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_NO_BLOCK)); - set= MEMCACHED_HASH_MD5; - memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_HASH, set); - value= memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_HASH); - test_true(value == MEMCACHED_HASH_MD5); + memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_TCP_NODELAY, 1); + test_compare(true, memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_TCP_NODELAY)); - set= 0; + memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_HASH, MEMCACHED_HASH_MD5); + test_compare(uint64_t(MEMCACHED_HASH_MD5), memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_HASH)); - memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_NO_BLOCK, set); - value= memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_NO_BLOCK); - test_true(value == 0); + memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_NO_BLOCK, 0); + test_zero(memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_NO_BLOCK)); - memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_TCP_NODELAY, set); - value= memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_TCP_NODELAY); - test_true(value == 0); + memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_TCP_NODELAY, 0); + test_zero(memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_TCP_NODELAY)); - set= MEMCACHED_HASH_DEFAULT; - memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_HASH, set); - value= memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_HASH); - test_true(value == MEMCACHED_HASH_DEFAULT); + memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_HASH, MEMCACHED_HASH_DEFAULT); + test_compare(uint64_t(MEMCACHED_HASH_DEFAULT), memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_HASH)); - set= MEMCACHED_HASH_CRC; - memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_HASH, set); - value= memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_HASH); - test_true(value == MEMCACHED_HASH_CRC); + memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_HASH, MEMCACHED_HASH_CRC); + test_compare(uint64_t(MEMCACHED_HASH_CRC), memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_HASH)); - value= memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_SOCKET_SEND_SIZE); - test_true(value > 0); + test_true(memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_SOCKET_SEND_SIZE)); - value= memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_SOCKET_RECV_SIZE); - test_true(value > 0); + test_true(memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_SOCKET_RECV_SIZE)); - value= memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_NUMBER_OF_REPLICAS); - memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_NUMBER_OF_REPLICAS, value + 1); - test_true((value + 1) == memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_NUMBER_OF_REPLICAS)); + uint64_t value= memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_NUMBER_OF_REPLICAS); + memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_NUMBER_OF_REPLICAS, value +1); + test_compare((value +1), memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_NUMBER_OF_REPLICAS)); return TEST_SUCCESS; } static test_return_t MEMCACHED_BEHAVIOR_CORK_test(memcached_st *memc) { - memcached_return_t rc; - bool set= true; - - rc= memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_CORK, set); - test_true(rc == MEMCACHED_DEPRECATED); + test_compare(MEMCACHED_DEPRECATED, + memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_CORK, true)); // Platform dependent #if 0 @@ -2099,22 +2069,18 @@ static test_return_t MEMCACHED_BEHAVIOR_CORK_test(memcached_st *memc) static test_return_t MEMCACHED_BEHAVIOR_TCP_KEEPALIVE_test(memcached_st *memc) { - memcached_return_t rc; - bool set= true; - bool value; - - rc= memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_TCP_KEEPALIVE, set); + memcached_return_t rc= memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_TCP_KEEPALIVE, true); test_true(rc == MEMCACHED_SUCCESS || rc == MEMCACHED_NOT_SUPPORTED); - value= (bool)memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_TCP_KEEPALIVE); + bool value= (bool)memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_TCP_KEEPALIVE); - if (rc == MEMCACHED_SUCCESS) + if (memcached_success(rc)) { - test_true((bool)value == set); + test_true(value); } else { - test_false((bool)value == set); + test_false(value); } return TEST_SUCCESS; @@ -2123,22 +2089,18 @@ static test_return_t MEMCACHED_BEHAVIOR_TCP_KEEPALIVE_test(memcached_st *memc) static test_return_t MEMCACHED_BEHAVIOR_TCP_KEEPIDLE_test(memcached_st *memc) { - memcached_return_t rc; - bool set= true; - bool value; - - rc= memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_TCP_KEEPIDLE, set); + memcached_return_t rc= memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_TCP_KEEPIDLE, true); test_true(rc == MEMCACHED_SUCCESS || rc == MEMCACHED_NOT_SUPPORTED); - value= (bool)memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_TCP_KEEPIDLE); + bool value= (bool)memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_TCP_KEEPIDLE); - if (rc == MEMCACHED_SUCCESS) + if (memcached_success(rc)) { - test_true((bool)value == set); + test_true(value); } else { - test_false((bool)value == set); + test_false(value); } return TEST_SUCCESS; @@ -2184,11 +2146,10 @@ static test_return_t user_supplied_bug1(memcached_st *memc) /* We just keep looking at the same values over and over */ srandom(10); - unsigned int setter= 1; test_compare(MEMCACHED_SUCCESS, - memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_NO_BLOCK, setter)); + memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_NO_BLOCK, true)); test_compare(MEMCACHED_SUCCESS, - memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_TCP_NODELAY, setter)); + memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_TCP_NODELAY, true)); /* add key */ @@ -2219,19 +2180,15 @@ static test_return_t user_supplied_bug1(memcached_st *memc) /* Test case provided by Cal Haldenbrand */ static test_return_t user_supplied_bug2(memcached_st *memc) { - unsigned int setter= 1; - test_compare(MEMCACHED_SUCCESS, - memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_NO_BLOCK, setter)); + memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_NO_BLOCK, true)); test_compare(MEMCACHED_SUCCESS, - memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_TCP_NODELAY, setter)); + memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_TCP_NODELAY, true)); #ifdef NOT_YET - setter = 20 * 1024576; - memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_SOCKET_SEND_SIZE, setter); - setter = 20 * 1024576; - memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_SOCKET_RECV_SIZE, setter); + test_compare(MEMCACHED_SUCCESS, memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_SOCKET_SEND_SIZE, 20 * 1024576)); + test_compare(MEMCACHED_SUCCESS, memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_SOCKET_RECV_SIZE, 20 * 1024576)); getter = memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_SOCKET_SEND_SIZE); getter = memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_SOCKET_RECV_SIZE); @@ -2275,43 +2232,42 @@ static test_return_t user_supplied_bug2(memcached_st *memc) /* Do a large mget() over all the keys we think exist */ static test_return_t user_supplied_bug3(memcached_st *memc) { - test_compare(true, memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_NO_BLOCK, 1)); - test_compare(true, memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_TCP_NODELAY, 1)); + test_compare(MEMCACHED_SUCCESS, memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_NO_BLOCK, 1)); + test_compare(MEMCACHED_SUCCESS, memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_TCP_NODELAY, 1)); + #ifdef NOT_YET - setter = 20 * 1024576; - memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_SOCKET_SEND_SIZE, setter); - setter = 20 * 1024576; - memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_SOCKET_RECV_SIZE, setter); + memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_SOCKET_SEND_SIZE, 20 * 1024576); + memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_SOCKET_RECV_SIZE, 20 * 1024576); getter = memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_SOCKET_SEND_SIZE); getter = memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_SOCKET_RECV_SIZE); #endif - size_t key_lengths[HALDENBRAND_KEY_COUNT]; - char **keys= static_cast(calloc(HALDENBRAND_KEY_COUNT, sizeof(char *))); - test_true(keys); - for (uint32_t x= 0; x < HALDENBRAND_KEY_COUNT; x++) + std::vector key_lengths; + key_lengths.resize(HALDENBRAND_KEY_COUNT); + std::vector keys; + keys.resize(key_lengths.size()); + for (uint32_t x= 0; x < key_lengths.size(); x++) { char key[MEMCACHED_MAXIMUM_INTEGER_DISPLAY_LENGTH +1]; int key_length= snprintf(key, sizeof(key), "%u", x); - test_true(key_length); + test_true(key_length > 0 and key_length < MEMCACHED_MAXIMUM_INTEGER_DISPLAY_LENGTH +1); keys[x]= strdup(key); - test_true(keys[x]); key_lengths[x]= key_length; - test_compare(size_t(key_length), strlen(keys[x])); } test_compare(MEMCACHED_SUCCESS, - memcached_mget(memc, (const char **)keys, key_lengths, HALDENBRAND_KEY_COUNT)); + memcached_mget(memc, &keys[0], &key_lengths[0], key_lengths.size())); unsigned int keys_returned; test_compare(TEST_SUCCESS, fetch_all_results(memc, keys_returned, MEMCACHED_SUCCESS)); test_compare(HALDENBRAND_KEY_COUNT, keys_returned); - for (uint32_t x= 0; x < HALDENBRAND_KEY_COUNT; x++) + for (std::vector::iterator iter= keys.begin(); + iter != keys.end(); + iter++) { - free(keys[x]); + free(*iter); } - free(keys); return TEST_SUCCESS; } @@ -2390,9 +2346,7 @@ static test_return_t user_supplied_bug5(memcached_st *memc) memcached_flush(memc, 0)); memcached_return_t rc; - value= memcached_get(memc, keys[0], key_length[0], - &value_length, &flags, &rc); - test_false(value); + test_null(memcached_get(memc, keys[0], key_length[0], &value_length, &flags, &rc)); test_compare(MEMCACHED_SUCCESS, memcached_mget(memc, keys, key_length, 4)); @@ -2539,24 +2493,26 @@ static test_return_t user_supplied_bug7(memcached_st *memc) char *insert_data= new (std::nothrow) char[VALUE_SIZE_BUG5]; for (unsigned int x= 0; x < VALUE_SIZE_BUG5; x++) + { insert_data[x]= (signed char)rand(); + } memcached_flush(memc, 0); flags= 245; - memcached_return_t rc= memcached_set(memc, keys, key_length, - insert_data, VALUE_SIZE_BUG5, - (time_t)0, flags); - test_compare(MEMCACHED_SUCCESS, rc); + test_compare(MEMCACHED_SUCCESS, memcached_set(memc, keys, key_length, + insert_data, VALUE_SIZE_BUG5, + (time_t)0, flags)); + memcached_return_t rc; flags= 0; value= memcached_get(memc, keys, key_length, &value_length, &flags, &rc); - test_true(flags == 245); + test_compare(245U, flags); test_true(value); free(value); - rc= memcached_mget(memc, &keys, &key_length, 1); + test_compare(MEMCACHED_SUCCESS, memcached_mget(memc, &keys, &key_length, 1)); flags= 0; value= memcached_fetch(memc, return_key, &return_key_length, @@ -2623,18 +2579,19 @@ static test_return_t user_supplied_bug10(memcached_st *memc) memcached_behavior_set(mclone, MEMCACHED_BEHAVIOR_TCP_NODELAY, set); memcached_behavior_set(mclone, MEMCACHED_BEHAVIOR_POLL_TIMEOUT, uint64_t(0)); - char *value= (char*)malloc(value_length * sizeof(char)); - - for (unsigned int x= 0; x < value_length; x++) + std::vector value; + value.reserve(value_length); + for (uint32_t x= 0; x < value_length; x++) { - value[x]= (char) (x % 127); + value.push_back(char(x % 127)); } for (unsigned int x= 1; x <= 100000; ++x) { memcached_return_t rc= memcached_set(mclone, test_literal_param("foo"), - value, value_length, 0, 0); + &value[0], value.size(), + 0, 0); test_true_got((rc == MEMCACHED_SUCCESS or rc == MEMCACHED_WRITE_FAILURE or rc == MEMCACHED_BUFFERED or rc == MEMCACHED_TIMEOUT or rc == MEMCACHED_CONNECTION_FAILURE or rc == MEMCACHED_SERVER_TEMPORARILY_DISABLED), @@ -2646,7 +2603,6 @@ static test_return_t user_supplied_bug10(memcached_st *memc) } } - free(value); memcached_free(mclone); return TEST_SUCCESS; @@ -2657,35 +2613,28 @@ static test_return_t user_supplied_bug10(memcached_st *memc) */ static test_return_t user_supplied_bug11(memcached_st *memc) { - const char *key= "foo"; - size_t value_length= 512; - size_t key_len= 3; - unsigned int set= 1; memcached_st *mclone= memcached_clone(NULL, memc); - memcached_behavior_set(mclone, MEMCACHED_BEHAVIOR_NO_BLOCK, set); - memcached_behavior_set(mclone, MEMCACHED_BEHAVIOR_TCP_NODELAY, set); - int32_t timeout= -1; - memcached_behavior_set(mclone, MEMCACHED_BEHAVIOR_POLL_TIMEOUT, (size_t)timeout); - - timeout= (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_true(timeout == -1); + test_compare(-1, int32_t(memcached_behavior_get(mclone, MEMCACHED_BEHAVIOR_POLL_TIMEOUT))); - char *value= (char*)malloc(value_length * sizeof(char)); - for (unsigned int x= 0; x < value_length; x++) + std::vector value; + value.reserve(512); + for (unsigned int x= 0; x < 512; x++) { - value[x]= (char) (x % 127); + value.push_back(char(x % 127)); } for (unsigned int x= 1; x <= 100000; ++x) { - memcached_return_t rc= memcached_set(mclone, key, key_len,value, value_length, 0, 0); + memcached_return_t rc= memcached_set(mclone, test_literal_param("foo"), &value[0], value.size(), 0, 0); (void)rc; } - free(value); memcached_free(mclone); return TEST_SUCCESS; @@ -2704,13 +2653,12 @@ static test_return_t user_supplied_bug12(memcached_st *memc) value= memcached_get(memc, "autoincrement", strlen("autoincrement"), &value_length, &flags, &rc); - test_true(value == NULL); + test_null(value); test_compare(MEMCACHED_NOTFOUND, rc); rc= memcached_increment(memc, "autoincrement", strlen("autoincrement"), 1, &number_value); - - test_true(value == NULL); + test_null(value); /* The binary protocol will set the key if it doesn't exist */ if (memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL) == 1) { @@ -2721,18 +2669,16 @@ static test_return_t user_supplied_bug12(memcached_st *memc) test_compare(MEMCACHED_NOTFOUND, rc); } - rc= memcached_set(memc, "autoincrement", strlen("autoincrement"), "1", 1, 0, 0); + test_compare(MEMCACHED_SUCCESS, + memcached_set(memc, "autoincrement", strlen("autoincrement"), "1", 1, 0, 0)); - value= memcached_get(memc, "autoincrement", strlen("autoincrement"), - &value_length, &flags, &rc); + value= memcached_get(memc, "autoincrement", strlen("autoincrement"), &value_length, &flags, &rc); test_true(value); - test_compare(MEMCACHED_SUCCESS, rc); free(value); - rc= memcached_increment(memc, "autoincrement", strlen("autoincrement"), - 1, &number_value); - test_true(number_value == 2); - test_compare(MEMCACHED_SUCCESS, rc); + test_compare(MEMCACHED_SUCCESS, + memcached_increment(memc, "autoincrement", strlen("autoincrement"), 1, &number_value)); + test_compare(2UL, number_value); return TEST_SUCCESS; } @@ -2783,6 +2729,7 @@ static test_return_t user_supplied_bug14(memcached_st *memc) memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_TCP_NODELAY, true); std::vector value; + value.reserve(18000); for (size_t x= 0; x < 18000; x++) { value.push_back((char) (x % 127)); @@ -2976,25 +2923,24 @@ static test_return_t _user_supplied_bug21(memcached_st* memc, size_t key_count) /* empty the cache to ensure misses (hence non-responses) */ test_compare(MEMCACHED_SUCCESS, memcached_flush(memc_clone, 0)); - size_t* key_lengths= new (std::nothrow) size_t[key_count]; - test_true(key_lengths); - char **keys= static_cast(calloc(key_count, sizeof(char *))); - test_true(keys); - for (unsigned int x= 0; x < key_count; x++) + std::vector key_lengths; + key_lengths.resize(key_count); + std::vector keys; + keys.resize(key_lengths.size()); + for (unsigned int x= 0; x < key_lengths.size(); x++) { - char buffer[30]; - - snprintf(buffer, 30, "%u", x); - keys[x]= strdup(buffer); - test_true(keys[x]); - key_lengths[x]= strlen(keys[x]); + char key[MEMCACHED_MAXIMUM_INTEGER_DISPLAY_LENGTH +1]; + int key_length= snprintf(key, sizeof(key), "%u", x); + test_true(key_length > 0 and key_length < MEMCACHED_MAXIMUM_INTEGER_DISPLAY_LENGTH +1); + keys[x]= strdup(key); + key_lengths[x]= key_length; } oldalarm= signal(SIGALRM, fail); alarm(5); test_compare_got(MEMCACHED_SUCCESS, - memcached_mget(memc_clone, (const char **)keys, key_lengths, key_count), memcached_last_error_message(memc_clone)); + memcached_mget(memc_clone, &keys[0], &key_lengths[0], key_count), memcached_last_error_message(memc_clone)); alarm(0); signal(SIGALRM, oldalarm); @@ -3016,12 +2962,12 @@ static test_return_t _user_supplied_bug21(memcached_st* memc, size_t key_count) test_false(return_key[0]); test_false(return_value); - for (unsigned int x= 0; x < key_count; x++) + for (std::vector::iterator iter= keys.begin(); + iter != keys.end(); + iter++) { - free(keys[x]); + free(*iter); } - free(keys); - delete [] key_lengths; memcached_free(memc_clone); @@ -3176,17 +3122,16 @@ static test_return_t generate_data(memcached_st *memc) static test_return_t generate_data_with_stats(memcached_st *memc) { - uint32_t host_index= 0; unsigned int check_execute= execute_set(memc, global_pairs, global_count); - test_true(check_execute == global_count); + test_compare(check_execute, global_count); // @todo hosts used size stats memcached_return_t rc; memcached_stat_st *stat_p= memcached_stat(memc, NULL, &rc); test_true(stat_p); - for (host_index= 0; host_index < SERVERS_TO_CREATE; host_index++) + for (uint32_t host_index= 0; host_index < SERVERS_TO_CREATE; host_index++) { /* This test was changes so that "make test" would work properlly */ if (DEBUG) @@ -3520,7 +3465,7 @@ static test_return_t pre_jenkins(memcached_st *memc) { memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_HASH, (uint64_t)MEMCACHED_HASH_JENKINS); - return TEST_SUCCESS; + return TEST_SKIPPED; } @@ -4491,7 +4436,7 @@ static test_return_t memcached_get_hashkit_test (memcached_st *) const char **ptr; hashkit_st new_kit; - memcached_st *memc= memcached(test_literal_param("--server=localhost:1 --server=localhost:2 --server=localhost:3 --server=localhost:4 --server=localhost5")); + memcached_st *memc= memcached(test_literal_param("--server=localhost:1 --server=localhost:2 --server=localhost:3 --server=localhost:4 --server=localhost5 --DISTRIBUTION=modula")); uint32_t md5_hosts[]= {4U, 1U, 0U, 1U, 4U, 2U, 0U, 3U, 0U, 0U, 3U, 1U, 0U, 0U, 1U, 3U, 0U, 0U, 0U, 3U, 1U, 0U, 4U, 4U, 3U}; uint32_t crc_hosts[]= {2U, 4U, 1U, 0U, 2U, 4U, 4U, 4U, 1U, 2U, 3U, 4U, 3U, 4U, 1U, 3U, 3U, 2U, 0U, 0U, 0U, 1U, 2U, 4U, 0U}; @@ -4679,9 +4624,9 @@ static test_return_t regression_bug_434484(memcached_st *memc) return TEST_SUCCESS; } -static test_return_t regression_bug_434843(memcached_st *memc) +static test_return_t regression_bug_434843(memcached_st *original_memc) { - test_skip(TEST_SUCCESS, pre_binary(memc)); + test_skip(TEST_SUCCESS, pre_binary(original_memc)); memcached_return_t rc; size_t counter= 0; @@ -4693,8 +4638,8 @@ static test_return_t regression_bug_434843(memcached_st *memc) * 1024 (that should satisfy most users don't you think?). Future versions * will include a mget_execute function call if you need a higher number. */ - uint32_t number_of_hosts= memcached_server_count(memc); - memc->number_of_hosts= 1; + memcached_st *memc= create_single_instance_memcached(original_memc, "--BINARY-PROTOCOL"); + const size_t max_keys= 1024; char **keys= (char**)calloc(max_keys, sizeof(char*)); size_t *key_length= (size_t *)calloc(max_keys, sizeof(size_t)); @@ -4749,7 +4694,7 @@ static test_return_t regression_bug_434843(memcached_st *memc) free(keys); free(key_length); - memc->number_of_hosts= number_of_hosts; + memcached_free(memc); return TEST_SUCCESS; } @@ -5260,26 +5205,23 @@ static test_return_t wrong_failure_counter_two_test(memcached_st *memc) /* * Test that ensures mget_execute does not end into recursive calls that finally fails */ -static test_return_t regression_bug_490486(memcached_st *memc) +static test_return_t regression_bug_490486(memcached_st *original_memc) { - memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL, 1); - memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_NO_BLOCK, 1); - memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_POLL_TIMEOUT, 1000); - 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 + test_skip(TEST_SUCCESS, pre_binary(original_memc)); + /* * I only want to hit _one_ server so I know the number of requests I'm * sending in the pipeline. */ - uint32_t number_of_hosts= memc->number_of_hosts; - memc->number_of_hosts= 1; - size_t max_keys= 20480; + memcached_st *memc= create_single_instance_memcached(original_memc, "--BINARY-PROTOCOL --POLL-TIMEOUT=1000 --REMOVE-FAILED-SERVERS=1 --RETRY-TIMEOUT=3600"); + test_true(memc); + size_t max_keys= 20480; char **keys= (char **)calloc(max_keys, sizeof(char*)); size_t *key_length= (size_t *)calloc(max_keys, sizeof(size_t)); @@ -5337,7 +5279,7 @@ static test_return_t regression_bug_490486(memcached_st *memc) free(keys); free(key_length); - memc->number_of_hosts= number_of_hosts; + memcached_free(memc); return TEST_SUCCESS; } @@ -5698,7 +5640,9 @@ test_st tests[] ={ {"analyzer", true, (test_callback_fn*)analyzer_test}, {"memcached_pool_st", true, (test_callback_fn*)connection_pool_test }, {"memcached_pool_st #2", true, (test_callback_fn*)connection_pool2_test }, +#if 0 {"memcached_pool_st #3", true, (test_callback_fn*)connection_pool3_test }, +#endif {"memcached_pool_test", true, (test_callback_fn*)memcached_pool_test }, {"test_get_last_disconnect", true, (test_callback_fn*)test_get_last_disconnect}, {"verbosity", true, (test_callback_fn*)test_verbosity},