X-Git-Url: https://git.m6w6.name/?a=blobdiff_plain;f=tests%2Flibmemcached-1.0%2Fmem_functions.cc;h=2f6d56f36ed56cef7bc94815c9efd8456b81d20e;hb=728ffce13e3e3b78d0144ea1e304dee1c1055384;hp=e39c2a8bc8eccc134e4a30462f04637092eb7da4;hpb=9069819ac2940397e96210867e0666b801b97f60;p=m6w6%2Flibmemcached diff --git a/tests/libmemcached-1.0/mem_functions.cc b/tests/libmemcached-1.0/mem_functions.cc index e39c2a8b..2f6d56f3 100644 --- a/tests/libmemcached-1.0/mem_functions.cc +++ b/tests/libmemcached-1.0/mem_functions.cc @@ -650,7 +650,7 @@ test_return_t memcached_mget_mixed_memcached_get_TEST(memcached_st *memc) { } // It is possible that the value has been purged. else { - test_compare_hint(MEMCACHED_SUCCESS, rc, memcached_last_error_message(memc)); + test_compare(MEMCACHED_SUCCESS, rc); } test_null(out_value); test_zero(value_length); @@ -800,27 +800,55 @@ test_return_t prepend_test(memcached_st *memc) return TEST_SUCCESS; } +/* + Set the value, then quit to make sure it is flushed. + Come back in and test that add fails. +*/ +test_return_t memcached_add_SUCCESS_TEST(memcached_st *memc) +{ + memcached_return_t rc; + test_null(memcached_get(memc, test_literal_param(__func__), NULL, NULL, &rc)); + test_compare(MEMCACHED_NOTFOUND, rc); + + test_compare(MEMCACHED_SUCCESS, + memcached_add(memc, + test_literal_param(__func__), + test_literal_param("try something else"), + time_t(0), uint32_t(0))); + + return TEST_SUCCESS; +} + /* Set the value, then quit to make sure it is flushed. Come back in and test that add fails. */ test_return_t add_test(memcached_st *memc) { - test_compare_hint(return_value_based_on_buffering(memc), - memcached_set(memc, - test_literal_param(__func__), - test_literal_param("when we sanitize"), - time_t(0), uint32_t(0)), - memcached_last_error_message(memc)); + test_compare(return_value_based_on_buffering(memc), + memcached_set(memc, + test_literal_param(__func__), + test_literal_param("when we sanitize"), + time_t(0), uint32_t(0))); memcached_quit(memc); - test_compare_hint(memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL) ? MEMCACHED_DATA_EXISTS : MEMCACHED_NOTSTORED, - memcached_add(memc, - test_literal_param(__func__), - test_literal_param("try something else"), - time_t(0), uint32_t(0)), - memcached_last_error_message(memc)); + size_t value_length; + uint32_t flags; + memcached_return_t rc; + char *check_value= memcached_get(memc, + test_literal_param(__func__), + &value_length, &flags, &rc); + test_memcmp(check_value, "when we sanitize", strlen("when we sanitize")); + test_compare(test_literal_param_size("when we sanitize"), value_length); + test_compare(MEMCACHED_SUCCESS, rc); + free(check_value); + + test_compare(memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL) ? MEMCACHED_DATA_EXISTS : MEMCACHED_NOTSTORED, + memcached_add(memc, + test_literal_param(__func__), + test_literal_param("try something else"), + time_t(0), uint32_t(0))); return TEST_SUCCESS; } @@ -843,44 +871,42 @@ test_return_t add_wrapper(memcached_st *memc) #endif for (uint32_t x= 0; x < max; x++) + { add_test(memc); + } return TEST_SUCCESS; } test_return_t replace_test(memcached_st *memc) { - test_compare_hint(return_value_based_on_buffering(memc), - memcached_set(memc, - test_literal_param(__func__), - test_literal_param("when we sanitize"), - time_t(0), uint32_t(0)), - memcached_last_error_message(memc)); + test_compare(return_value_based_on_buffering(memc), + memcached_set(memc, + test_literal_param(__func__), + test_literal_param("when we sanitize"), + time_t(0), uint32_t(0))); - test_compare_hint(MEMCACHED_SUCCESS, - memcached_replace(memc, - test_literal_param(__func__), - test_literal_param("first we insert some data"), - time_t(0), uint32_t(0)), - memcached_last_error_message(memc)); + test_compare(MEMCACHED_SUCCESS, + memcached_replace(memc, + test_literal_param(__func__), + test_literal_param("first we insert some data"), + time_t(0), uint32_t(0))); return TEST_SUCCESS; } test_return_t delete_test(memcached_st *memc) { - test_compare_hint(return_value_based_on_buffering(memc), - memcached_set(memc, - test_literal_param(__func__), - test_literal_param("when we sanitize"), - time_t(0), uint32_t(0)), - memcached_last_error_message(memc)); + test_compare(return_value_based_on_buffering(memc), + memcached_set(memc, + test_literal_param(__func__), + test_literal_param("when we sanitize"), + time_t(0), uint32_t(0))); - test_compare_hint(return_value_based_on_buffering(memc), - memcached_delete(memc, - test_literal_param(__func__), - time_t(0)), - memcached_last_error_message(memc)); + test_compare(return_value_based_on_buffering(memc), + memcached_delete(memc, + test_literal_param(__func__), + time_t(0))); return TEST_SUCCESS; } @@ -1026,12 +1052,11 @@ test_return_t bad_key_test(memcached_st *memc) } #define READ_THROUGH_VALUE "set for me" -static memcached_return_t read_through_trigger(memcached_st *memc, - char *key, - size_t key_length, +static memcached_return_t read_through_trigger(memcached_st *, // memc + char *, // key + size_t, // key_length, memcached_result_st *result) { - (void)memc;(void)key;(void)key_length; return memcached_result_set_value(result, READ_THROUGH_VALUE, strlen(READ_THROUGH_VALUE)); } @@ -1062,8 +1087,8 @@ test_return_t read_through(memcached_st *memc) &string_length, &flags, &rc); test_compare(MEMCACHED_SUCCESS, rc); - test_compare(string_length, sizeof(READ_THROUGH_VALUE) -1); - test_true(string[sizeof(READ_THROUGH_VALUE) -1] == 0); + test_compare(sizeof(READ_THROUGH_VALUE) -1, string_length); + test_compare(0, string[sizeof(READ_THROUGH_VALUE) -1]); test_strcmp(READ_THROUGH_VALUE, string); free(string); @@ -1085,12 +1110,11 @@ test_return_t set_test2(memcached_st *memc) { for (uint32_t x= 0; x < 10; x++) { - test_compare_hint(return_value_based_on_buffering(memc), - memcached_set(memc, - test_literal_param("foo"), - test_literal_param("train in the brain"), - time_t(0), uint32_t(0)), - memcached_last_error_message(memc)); + test_compare(return_value_based_on_buffering(memc), + memcached_set(memc, + test_literal_param("foo"), + test_literal_param("train in the brain"), + time_t(0), uint32_t(0))); } return TEST_SUCCESS; @@ -1115,11 +1139,10 @@ test_return_t set_test3(memcached_st *memc) snprintf(key, sizeof(key), "foo%u", x); uint64_t query_id= memcached_query_id(memc); - test_compare_hint(return_value_based_on_buffering(memc), - memcached_set(memc, key, strlen(key), - &value[0], value.size(), - time_t(0), uint32_t(0)), - memcached_last_error_message(memc)); + test_compare(return_value_based_on_buffering(memc), + memcached_set(memc, key, strlen(key), + &value[0], value.size(), + time_t(0), uint32_t(0))); test_compare(query_id +1, memcached_query_id(memc)); } @@ -1265,6 +1288,7 @@ test_return_t decrement_test(memcached_st *memc) test_literal_param(__func__), test_literal_param("3"), time_t(0), uint32_t(0))); + // Make sure we flush the value we just set test_compare(MEMCACHED_SUCCESS, memcached_flush_buffers(memc)); @@ -1445,20 +1469,18 @@ test_return_t quit_test(memcached_st *memc) { const char *value= "sanford and sun"; - test_compare_hint(return_value_based_on_buffering(memc), - memcached_set(memc, - test_literal_param(__func__), - value, strlen(value), - (time_t)10, (uint32_t)3), - memcached_last_error_message(memc)); + test_compare(return_value_based_on_buffering(memc), + memcached_set(memc, + test_literal_param(__func__), + value, strlen(value), + time_t(10), uint32_t(3))); memcached_quit(memc); - test_compare_hint(return_value_based_on_buffering(memc), - memcached_set(memc, - test_literal_param(__func__), - value, strlen(value), - (time_t)50, (uint32_t)9), - memcached_last_error_message(memc)); + test_compare(return_value_based_on_buffering(memc), + memcached_set(memc, + test_literal_param(__func__), + value, strlen(value), + time_t(50), uint32_t(9))); return TEST_SUCCESS; } @@ -1469,9 +1491,7 @@ test_return_t mget_result_test(memcached_st *memc) size_t key_length[]= {5, 3, 4}; memcached_result_st results_obj; - memcached_result_st *results; - - results= memcached_result_create(memc, &results_obj); + memcached_result_st *results= memcached_result_create(memc, &results_obj); test_true(results); test_true(&results_obj == results); @@ -1670,8 +1690,7 @@ test_return_t mget_execute(memcached_st *original_memc) keys.key_at(x), keys.length_at(x), blob, sizeof(blob), 0, 0); - test_true_got(rc == MEMCACHED_SUCCESS or rc == MEMCACHED_BUFFERED, - memcached_last_error_message(memc)); + test_true(rc == MEMCACHED_SUCCESS or rc == MEMCACHED_BUFFERED); test_compare(query_id +1, memcached_query_id(memc)); } @@ -1699,7 +1718,7 @@ test_return_t mget_execute(memcached_st *original_memc) } #define REGRESSION_BINARY_VS_BLOCK_COUNT 20480 -static pairs_st *global_pairs; +static pairs_st *global_pairs= NULL; test_return_t key_setup(memcached_st *memc) { @@ -1713,6 +1732,7 @@ test_return_t key_setup(memcached_st *memc) test_return_t key_teardown(memcached_st *) { pairs_free(global_pairs); + global_pairs= NULL; return TEST_SUCCESS; } @@ -1722,9 +1742,14 @@ test_return_t block_add_regression(memcached_st *memc) /* First add all of the items.. */ for (ptrdiff_t x= 0; x < REGRESSION_BINARY_VS_BLOCK_COUNT; ++x) { - char blob[1024] = {0}; - - 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); + libtest::vchar_t blob; + libtest::vchar::make(blob, 1024); + + memcached_return_t rc= memcached_add_by_key(memc, + test_literal_param("bob"), + global_pairs[x].key, global_pairs[x].key_length, + &blob[0], blob.size(), + time_t(0), uint32_t(0)); test_true_got(rc == MEMCACHED_SUCCESS or rc == MEMCACHED_SERVER_MEMORY_ALLOCATION_FAILURE, memcached_strerror(NULL, rc)); } @@ -2199,10 +2224,9 @@ test_return_t user_supplied_bug7(memcached_st *memc) const char *keys= "036790384900"; size_t key_length= strlen(keys); - test_compare_hint(MEMCACHED_SUCCESS, memcached_set(memc, keys, key_length, - insert_data, VALUE_SIZE_BUG5, - time_t(0), 245U), - memcached_last_error_message(memc)); + test_compare(MEMCACHED_SUCCESS, memcached_set(memc, keys, key_length, + insert_data, VALUE_SIZE_BUG5, + time_t(0), 245U)); memcached_return_t rc; size_t value_length; @@ -2536,7 +2560,7 @@ test_return_t user_supplied_bug17(memcached_st *memc) char *value2= memcached_get(memc, key, strlen(key), &length, &flags, &rc); - test_true(length==strlen(value)); + test_compare(length, strlen(value)); test_compare(MEMCACHED_SUCCESS, rc); test_memcmp(value, value2, length); free(value2); @@ -3042,20 +3066,21 @@ test_return_t set_memory_alloc(memcached_st *memc) test_return_t enable_consistent_crc(memcached_st *memc) { + test_compare(MEMCACHED_SUCCESS, memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_DISTRIBUTION, MEMCACHED_DISTRIBUTION_CONSISTENT)); + test_compare(memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_DISTRIBUTION), uint64_t(MEMCACHED_DISTRIBUTION_CONSISTENT)); + 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_true(value == MEMCACHED_DISTRIBUTION_CONSISTENT); - - hash= (memcached_hash_t)memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_HASH); + test_compare(memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_DISTRIBUTION), uint64_t(MEMCACHED_DISTRIBUTION_CONSISTENT)); - if (hash != MEMCACHED_HASH_CRC) + if (memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_HASH) != MEMCACHED_HASH_CRC) + { return TEST_SKIPPED; + } return TEST_SUCCESS; } @@ -3063,22 +3088,18 @@ test_return_t enable_consistent_crc(memcached_st *memc) test_return_t enable_consistent_hsieh(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); + memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_DISTRIBUTION, MEMCACHED_DISTRIBUTION_CONSISTENT); if ((rc= pre_hsieh(memc)) != TEST_SUCCESS) { return rc; } - value= (memcached_server_distribution_t)memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_DISTRIBUTION); - test_true(value == MEMCACHED_DISTRIBUTION_CONSISTENT); - - hash= (memcached_hash_t)memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_HASH); + test_compare(memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_DISTRIBUTION), uint64_t(MEMCACHED_DISTRIBUTION_CONSISTENT)); - if (hash != MEMCACHED_HASH_HSIEH) + if (memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_HASH) != MEMCACHED_HASH_HSIEH) + { return TEST_SKIPPED; - + } return TEST_SUCCESS; } @@ -3211,7 +3232,7 @@ test_return_t noreply_test(memcached_st *memc) { continue; } - test_true_hint(ret == MEMCACHED_SUCCESS and value != NULL, memcached_last_error_message(memc)); + test_true(ret == MEMCACHED_SUCCESS and value != NULL); switch (count) { case 0: /* FALLTHROUGH */ @@ -3388,20 +3409,32 @@ test_return_t getpid_test(memcached_st *memc) return TEST_SUCCESS; } -test_return_t ping_test(memcached_st *memc) +static memcached_return_t ping_each_server(const memcached_st*, + const memcached_server_st *instance, + void*) { + // Test both the version that returns a code, and the one that does not. memcached_return_t rc; - memcached_server_instance_st instance= - memcached_server_instance_by_position(memc, 0); + if (libmemcached_util_ping(memcached_server_name(instance), + memcached_server_port(instance), &rc) == false) + { + throw libtest::fatal(LIBYATL_DEFAULT_PARAM, "%s:%d %s", memcached_server_name(instance), + memcached_server_port(instance), memcached_strerror(NULL, rc)); + } - // Test both the version that returns a code, and the one that does not. - test_true(libmemcached_util_ping(memcached_server_name(instance), - memcached_server_port(instance), NULL)); + if (libmemcached_util_ping(memcached_server_name(instance), + memcached_server_port(instance), NULL) == false) + { + throw libtest::fatal(LIBYATL_DEFAULT_PARAM, "%s:%d", memcached_server_name(instance), memcached_server_port(instance)); + } - test_true(libmemcached_util_ping(memcached_server_name(instance), - memcached_server_port(instance), &rc)); + return MEMCACHED_SUCCESS; +} - test_compare(MEMCACHED_SUCCESS, rc); +test_return_t libmemcached_util_ping_TEST(memcached_st *memc) +{ + memcached_server_fn callbacks[1]= { ping_each_server }; + memcached_server_cursor(memc, callbacks, NULL, 1); return TEST_SUCCESS; } @@ -4343,6 +4376,34 @@ test_return_t wrong_failure_counter_two_test(memcached_st *memc) return TEST_SUCCESS; } +test_return_t regression_996813_TEST(memcached_st *) +{ + memcached_st* memc= memcached_create(NULL); + + test_compare(MEMCACHED_SUCCESS, memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_DISTRIBUTION, MEMCACHED_DISTRIBUTION_CONSISTENT_KETAMA)); + 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)); + test_compare(MEMCACHED_SUCCESS, memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL, 1)); + test_compare(MEMCACHED_SUCCESS, memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_POLL_TIMEOUT, 1)); + test_compare(MEMCACHED_SUCCESS, memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_CONNECT_TIMEOUT, 300)); + test_compare(MEMCACHED_SUCCESS, memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_RETRY_TIMEOUT, 30)); + + // We will never connect to these servers + in_port_t base_port= 11211; + for (size_t x= 0; x < 17; x++) + { + test_compare(MEMCACHED_SUCCESS, memcached_server_add(memc, "10.2.3.4", base_port +x)); + } + test_compare(16U, memcached_generate_hash(memc, test_literal_param("SZ6hu0SHweFmpwpc0w2R"))); + test_compare(1U, memcached_generate_hash(memc, test_literal_param("SQCK9eiCf53YxHWnYA.o"))); + test_compare(10U, memcached_generate_hash(memc, test_literal_param("SUSDkGXuuZC9t9VhMwa."))); + test_compare(8U, memcached_generate_hash(memc, test_literal_param("SnnqnJARfaCNT679iAF_"))); + + memcached_free(memc); + + return TEST_SUCCESS; +} + /* * Test that ensures mget_execute does not end into recursive calls that finally fails @@ -4555,6 +4616,65 @@ test_return_t regression_bug_490520(memcached_st *original_memc) return TEST_SUCCESS; } +test_return_t regression_1009493_TEST(memcached_st*) +{ + memcached_st* memc= memcached_create(NULL); + test_true(memc); + test_compare(MEMCACHED_SUCCESS, memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_KETAMA, true)); + + memcached_st* clone= memcached_clone(NULL, memc); + test_true(clone); + + test_compare(memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_KETAMA_WEIGHTED), + memcached_behavior_get(clone, MEMCACHED_BEHAVIOR_KETAMA_WEIGHTED)); + + memcached_free(memc); + memcached_free(clone); + + return TEST_SUCCESS; +} + +test_return_t regression_994772_TEST(memcached_st* memc) +{ + test_skip(MEMCACHED_SUCCESS, memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL, 1)); + + test_compare(MEMCACHED_SUCCESS, + memcached_set(memc, + test_literal_param(__func__), // Key + test_literal_param(__func__), // Value + time_t(0), uint32_t(0))); + + const char *keys[] = { __func__ }; + size_t key_length[]= { strlen(__func__) }; + test_compare(MEMCACHED_SUCCESS, + memcached_mget(memc, keys, key_length, 1)); + + memcached_return_t rc; + memcached_result_st *results= memcached_fetch_result(memc, NULL, &rc); + test_true(results); + test_compare(MEMCACHED_SUCCESS, rc); + + test_strcmp(__func__, memcached_result_value(results)); + uint64_t cas_value= memcached_result_cas(results); + test_true(cas_value); + + memcached_result_free(results); + + // Bad cas value, sanity check + test_true(cas_value != 9999); + test_compare(MEMCACHED_END, + memcached_cas(memc, + test_literal_param(__func__), // Key + test_literal_param(__FILE__), // Value + time_t(0), uint32_t(0), 9999)); + + test_compare(MEMCACHED_SUCCESS, memcached_set(memc, + "different", strlen("different"), // Key + test_literal_param(__FILE__), // Value + time_t(0), uint32_t(0))); + + return TEST_SUCCESS; +} test_return_t regression_bug_854604(memcached_st *) { @@ -4576,7 +4696,7 @@ test_return_t regression_bug_854604(memcached_st *) return TEST_SUCCESS; } -static void memcached_die(memcached_st* mc, memcached_return error, const char* what, uint32_t it) +static void die_message(memcached_st* mc, memcached_return error, const char* what, uint32_t it) { fprintf(stderr, "Iteration #%u: ", it); @@ -4612,19 +4732,19 @@ test_return_t regression_bug_(memcached_st *memc) rc= memcached_behavior_set(mc, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL, 1); if (rc != MEMCACHED_SUCCESS) { - memcached_die(mc, rc, "memcached_behavior_set", x); + die_message(mc, rc, "memcached_behavior_set", x); } rc= memcached_behavior_set(mc, MEMCACHED_BEHAVIOR_CACHE_LOOKUPS, 1); if (rc != MEMCACHED_SUCCESS) { - memcached_die(mc, rc, "memcached_behavior_set", x); + die_message(mc, rc, "memcached_behavior_set", x); } rc= memcached_server_add(mc, remote_server, 0); if (rc != MEMCACHED_SUCCESS) { - memcached_die(mc, rc, "memcached_server_add", x); + die_message(mc, rc, "memcached_server_add", x); } const char *set_key= "akey"; @@ -4644,7 +4764,7 @@ test_return_t regression_bug_(memcached_st *memc) &get_value_flags, &rc); if (rc != MEMCACHED_SUCCESS) { - memcached_die(mc, rc, "memcached_get", x); + die_message(mc, rc, "memcached_get", x); } else { @@ -4668,7 +4788,7 @@ test_return_t regression_bug_(memcached_st *memc) ); if (rc != MEMCACHED_SUCCESS) { - memcached_die(mc, rc, "memcached_set", x); + die_message(mc, rc, "memcached_set", x); } }