- test_compare_hint(return_value_based_on_buffering(memc),
- memcached_delete(memc,
- test_literal_param(__func__),
- time_t(0)),
- memcached_last_error_message(memc));
-
- return TEST_SUCCESS;
-}
-
-test_return_t flush_test(memcached_st *memc)
-{
- uint64_t query_id= memcached_query_id(memc);
- test_compare(MEMCACHED_SUCCESS,
- memcached_flush(memc, 0));
- test_compare(query_id +1, memcached_query_id(memc));
-
- return TEST_SUCCESS;
-}
-
-static memcached_return_t server_function(const memcached_st *,
- const memcached_server_st *,
- void *)
-{
- /* Do Nothing */
- return MEMCACHED_SUCCESS;
-}
-
-test_return_t memcached_server_cursor_test(memcached_st *memc)
-{
- char context[10];
- strncpy(context, "foo bad", sizeof(context));
- memcached_server_fn callbacks[1];
-
- callbacks[0]= server_function;
- memcached_server_cursor(memc, callbacks, context, 1);
- return TEST_SUCCESS;
-}
-
-test_return_t bad_key_test(memcached_st *memc)
-{
- memcached_return_t rc;
- const char *key= "foo bad";
- uint32_t flags;
-
- uint64_t query_id= memcached_query_id(memc);
-
- // Just skip if we are in binary mode.
- test_skip(false, memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL));
-
- test_compare(query_id, memcached_query_id(memc)); // We should not increase the query_id for memcached_behavior_get()
-
- memcached_st *memc_clone= memcached_clone(NULL, memc);
- test_true(memc_clone);
-
- query_id= memcached_query_id(memc_clone);
- test_compare(MEMCACHED_SUCCESS,
- memcached_behavior_set(memc_clone, MEMCACHED_BEHAVIOR_VERIFY_KEY, true));
- test_compare(query_id, memcached_query_id(memc_clone)); // We should not increase the query_id for memcached_behavior_set()
-
- /* All keys are valid in the binary protocol (except for length) */
- if (memcached_behavior_get(memc_clone, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL) == false)
- {
- uint64_t before_query_id= memcached_query_id(memc_clone);
- {
- size_t string_length;
- char *string= memcached_get(memc_clone, key, strlen(key),
- &string_length, &flags, &rc);
- test_compare(MEMCACHED_BAD_KEY_PROVIDED, rc);
- test_zero(string_length);
- test_false(string);
- }
- test_compare(before_query_id +1, memcached_query_id(memc_clone));
-
- query_id= memcached_query_id(memc_clone);
- test_compare(MEMCACHED_SUCCESS,
- memcached_behavior_set(memc_clone, MEMCACHED_BEHAVIOR_VERIFY_KEY, false));
- test_compare(query_id, memcached_query_id(memc_clone)); // We should not increase the query_id for memcached_behavior_set()
- {
- size_t string_length;
- char *string= memcached_get(memc_clone, key, strlen(key),
- &string_length, &flags, &rc);
- test_compare_got(MEMCACHED_NOTFOUND, rc, memcached_strerror(NULL, rc));
- test_zero(string_length);
- test_false(string);
- }
-
- /* Test multi key for bad keys */
- const char *keys[] = { "GoodKey", "Bad Key", "NotMine" };
- size_t key_lengths[] = { 7, 7, 7 };
- query_id= memcached_query_id(memc_clone);
- test_compare(MEMCACHED_SUCCESS,
- memcached_behavior_set(memc_clone, MEMCACHED_BEHAVIOR_VERIFY_KEY, true));
- test_compare(query_id, memcached_query_id(memc_clone));
-
- query_id= memcached_query_id(memc_clone);
- test_compare(MEMCACHED_BAD_KEY_PROVIDED,
- memcached_mget(memc_clone, keys, key_lengths, 3));
- test_compare(query_id +1, memcached_query_id(memc_clone));
-
- query_id= memcached_query_id(memc_clone);
- // Grouping keys are not required to follow normal key behaviors
- test_compare(MEMCACHED_SUCCESS,
- memcached_mget_by_key(memc_clone, "foo daddy", 9, keys, key_lengths, 1));
- test_compare(query_id +1, memcached_query_id(memc_clone));
-
- /* The following test should be moved to the end of this function when the
- memcached server is updated to allow max size length of the keys in the
- binary protocol
- */
- test_compare(MEMCACHED_SUCCESS,
- memcached_callback_set(memc_clone, MEMCACHED_CALLBACK_NAMESPACE, NULL));
-
- libtest::vchar_t longkey;
- {
- libtest::vchar_t::iterator it= longkey.begin();
- longkey.insert(it, MEMCACHED_MAX_KEY, 'a');
- }
-
- test_compare(longkey.size(), size_t(MEMCACHED_MAX_KEY));
- {
- size_t string_length;
- // We subtract 1
- test_null(memcached_get(memc_clone, &longkey[0], longkey.size() -1, &string_length, &flags, &rc));
- test_compare(MEMCACHED_NOTFOUND, rc);
- test_zero(string_length);
-
- test_null(memcached_get(memc_clone, &longkey[0], longkey.size(), &string_length, &flags, &rc));
- test_compare(MEMCACHED_BAD_KEY_PROVIDED, rc);
- test_zero(string_length);
- }
- }
-
- /* Make sure zero length keys are marked as bad */
- {
- test_compare(MEMCACHED_SUCCESS,
- memcached_behavior_set(memc_clone, MEMCACHED_BEHAVIOR_VERIFY_KEY, true));
- size_t string_length;
- char *string= memcached_get(memc_clone, key, 0,
- &string_length, &flags, &rc);
- test_compare(MEMCACHED_BAD_KEY_PROVIDED, rc);
- test_zero(string_length);
- test_false(string);
- }
-
- memcached_free(memc_clone);
-
- return TEST_SUCCESS;
-}
-
-#define READ_THROUGH_VALUE "set for me"
-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));
-}
-
-#ifndef __INTEL_COMPILER
-#pragma GCC diagnostic ignored "-Wstrict-aliasing"
-#endif
-
-test_return_t read_through(memcached_st *memc)
-{
- memcached_trigger_key_fn cb= (memcached_trigger_key_fn)read_through_trigger;
-
- size_t string_length;
- uint32_t flags;
- memcached_return_t rc;
- char *string= memcached_get(memc,
- test_literal_param(__func__),
- &string_length, &flags, &rc);
-
- test_compare(MEMCACHED_NOTFOUND, rc);
- test_false(string_length);
- test_false(string);
-
- test_compare(MEMCACHED_SUCCESS,
- memcached_callback_set(memc, MEMCACHED_CALLBACK_GET_FAILURE, *(void **)&cb));
-
- string= memcached_get(memc,
- test_literal_param(__func__),
- &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_strcmp(READ_THROUGH_VALUE, string);
- free(string);
-
- string= memcached_get(memc,
- test_literal_param(__func__),
- &string_length, &flags, &rc);
-
- test_compare(MEMCACHED_SUCCESS, rc);
- test_true(string);
- test_compare(string_length, sizeof(READ_THROUGH_VALUE) -1);
- test_true(string[sizeof(READ_THROUGH_VALUE) -1] == 0);
- test_strcmp(READ_THROUGH_VALUE, string);
- free(string);
-
- return TEST_SUCCESS;
-}
-
-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));
- }
-
- return TEST_SUCCESS;
-}
-
-test_return_t set_test3(memcached_st *memc)
-{
- size_t value_length= 8191;
-
- libtest::vchar_t value;
- value.reserve(value_length);
- for (uint32_t x= 0; x < value_length; x++)
- {
- value.push_back(char(x % 127));
- }
-
- /* The dump test relies on there being at least 32 items in memcached */
- for (uint32_t x= 0; x < 32; x++)
- {
- char key[16];
-
- 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(query_id +1, memcached_query_id(memc));
- }
-
- return TEST_SUCCESS;
-}
-
-test_return_t mget_end(memcached_st *memc)
-{
- const char *keys[]= { "foo", "foo2" };
- size_t lengths[]= { 3, 4 };
- const char *values[]= { "fjord", "41" };
-
- // Set foo and foo2
- for (size_t x= 0; x < test_array_length(keys); x++)
- {
- test_compare(MEMCACHED_SUCCESS,
- memcached_set(memc,
- keys[x], lengths[x],
- values[x], strlen(values[x]),
- time_t(0), uint32_t(0)));
- }
-
- char *string;
- size_t string_length;
- uint32_t flags;
-
- // retrieve both via mget
- test_compare(MEMCACHED_SUCCESS,
- memcached_mget(memc,
- keys, lengths,
- test_array_length(keys)));
-
- char key[MEMCACHED_MAX_KEY];
- size_t key_length;
- memcached_return_t rc;
-
- // this should get both
- for (size_t x= 0; x < test_array_length(keys); x++)
- {
- string= memcached_fetch(memc, key, &key_length, &string_length,
- &flags, &rc);
- test_compare(MEMCACHED_SUCCESS, rc);
- int val = 0;
- if (key_length == 4)
- {
- val= 1;
- }
-
- test_compare(string_length, strlen(values[val]));
- test_true(strncmp(values[val], string, string_length) == 0);
- free(string);
- }
-
- // this should indicate end
- string= memcached_fetch(memc, key, &key_length, &string_length, &flags, &rc);
- test_compare(MEMCACHED_END, rc);
- test_null(string);
-
- // now get just one
- test_compare(MEMCACHED_SUCCESS,
- memcached_mget(memc, keys, lengths, 1));
-
- string= memcached_fetch(memc, key, &key_length, &string_length, &flags, &rc);
- test_compare(key_length, lengths[0]);
- test_true(strncmp(keys[0], key, key_length) == 0);
- test_compare(string_length, strlen(values[0]));
- test_true(strncmp(values[0], string, string_length) == 0);
- test_compare(MEMCACHED_SUCCESS, rc);
- free(string);
-
- // this should indicate end
- string= memcached_fetch(memc, key, &key_length, &string_length, &flags, &rc);
- test_compare(MEMCACHED_END, rc);
- test_null(string);
-
- return TEST_SUCCESS;
-}
-
-/* Do not copy the style of this code, I just access hosts to testthis function */
-test_return_t stats_servername_test(memcached_st *memc)
-{
- memcached_stat_st memc_stat;
- memcached_server_instance_st instance=
- memcached_server_instance_by_position(memc, 0);
-
- if (LIBMEMCACHED_WITH_SASL_SUPPORT and memcached_get_sasl_callbacks(memc))
- {
- return TEST_SKIPPED;
- }
-
- test_compare(MEMCACHED_SUCCESS, memcached_stat_servername(&memc_stat, NULL,
- memcached_server_name(instance),
- memcached_server_port(instance)));
-
- return TEST_SUCCESS;
-}
-
-test_return_t increment_test(memcached_st *memc)
-{
- uint64_t new_number;
-
- test_compare(MEMCACHED_SUCCESS,
- memcached_set(memc,
- test_literal_param("number"),
- test_literal_param("0"),
- (time_t)0, (uint32_t)0));
-
- test_compare(MEMCACHED_SUCCESS,
- memcached_increment(memc, test_literal_param("number"), 1, &new_number));
- test_compare(uint64_t(1), new_number);
-
- test_compare(MEMCACHED_SUCCESS,
- memcached_increment(memc, test_literal_param("number"), 1, &new_number));
- test_compare(uint64_t(2), new_number);
-
- return TEST_SUCCESS;
-}
-
-test_return_t increment_with_initial_test(memcached_st *memc)
-{
- test_skip(true, memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL));
-
- uint64_t new_number;
- uint64_t initial= 0;
-
- test_compare(MEMCACHED_SUCCESS, memcached_flush_buffers(memc));
-
- test_compare(MEMCACHED_SUCCESS,
- memcached_increment_with_initial(memc, test_literal_param("number"), 1, initial, 0, &new_number));
- test_compare(new_number, initial);
-
- test_compare(MEMCACHED_SUCCESS,
- memcached_increment_with_initial(memc, test_literal_param("number"), 1, initial, 0, &new_number));
- test_compare(new_number, (initial +1));
-
- return TEST_SUCCESS;
-}
-
-test_return_t decrement_test(memcached_st *memc)
-{
- test_compare(return_value_based_on_buffering(memc),
- memcached_set(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));
-
- uint64_t new_number;
- test_compare(MEMCACHED_SUCCESS,
- memcached_decrement(memc,
- test_literal_param(__func__),
- 1, &new_number));
- test_compare(uint64_t(2), new_number);
-
- test_compare(MEMCACHED_SUCCESS,
- memcached_decrement(memc,
- test_literal_param(__func__),
- 1, &new_number));
- test_compare(uint64_t(1), new_number);
-
- return TEST_SUCCESS;
-}
-
-test_return_t decrement_with_initial_test(memcached_st *memc)
-{
- test_skip(true, memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL));
-
- uint64_t initial= 3;
-
- test_compare(MEMCACHED_SUCCESS, memcached_flush_buffers(memc));
-
- uint64_t new_number;
- test_compare(MEMCACHED_SUCCESS,
- memcached_decrement_with_initial(memc,
- test_literal_param(__func__),
- 1, initial,
- 0, &new_number));
- test_compare(new_number, initial);
-
- test_compare(MEMCACHED_SUCCESS,
- memcached_decrement_with_initial(memc,
- test_literal_param(__func__),
- 1, initial,
- 0, &new_number));
- test_compare(new_number, (initial - 1));
-
- return TEST_SUCCESS;
-}
-
-test_return_t increment_by_key_test(memcached_st *memc)
-{
- const char *master_key= "foo";
- const char *key= "number";
- const char *value= "0";
-
- test_compare(return_value_based_on_buffering(memc),
- memcached_set_by_key(memc, master_key, strlen(master_key),
- key, strlen(key),
- value, strlen(value),
- time_t(0), uint32_t(0)));
-
- // Make sure we flush the value we just set
- test_compare(MEMCACHED_SUCCESS, memcached_flush_buffers(memc));
-
- uint64_t new_number;
- test_compare(MEMCACHED_SUCCESS,
- memcached_increment_by_key(memc, master_key, strlen(master_key),
- key, strlen(key), 1, &new_number));
- test_compare(uint64_t(1), new_number);
-
- test_compare(MEMCACHED_SUCCESS,
- memcached_increment_by_key(memc, master_key, strlen(master_key),
- key, strlen(key), 1, &new_number));
- test_compare(uint64_t(2), new_number);
-
- return TEST_SUCCESS;
-}
-
-test_return_t increment_with_initial_by_key_test(memcached_st *memc)
-{
- test_skip(true, memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL));
-
- uint64_t new_number;
- const char *master_key= "foo";
- const char *key= "number";
- uint64_t initial= 0;
-
- test_compare(MEMCACHED_SUCCESS,
- memcached_increment_with_initial_by_key(memc, master_key, strlen(master_key),
- key, strlen(key),
- 1, initial, 0, &new_number));
- test_compare(new_number, initial);
-
- test_compare(MEMCACHED_SUCCESS,
- memcached_increment_with_initial_by_key(memc, master_key, strlen(master_key),
- key, strlen(key),
- 1, initial, 0, &new_number));
- test_compare(new_number, (initial +1));
-
- return TEST_SUCCESS;
-}
-
-test_return_t decrement_by_key_test(memcached_st *memc)
-{
- uint64_t new_number;
- const char *value= "3";
-
- test_compare(return_value_based_on_buffering(memc),
- memcached_set_by_key(memc,
- test_literal_param("foo"),
- test_literal_param("number"),
- value, strlen(value),
- (time_t)0, (uint32_t)0));
-
- test_compare(MEMCACHED_SUCCESS,
- memcached_decrement_by_key(memc,
- test_literal_param("foo"),
- test_literal_param("number"),
- 1, &new_number));
- test_compare(uint64_t(2), new_number);
-
- test_compare(MEMCACHED_SUCCESS,
- memcached_decrement_by_key(memc,
- test_literal_param("foo"),
- test_literal_param("number"),
- 1, &new_number));
- test_compare(uint64_t(1), new_number);
-
- return TEST_SUCCESS;
-}
-
-test_return_t decrement_with_initial_by_key_test(memcached_st *memc)
-{
- test_skip(true, memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL));
-
- uint64_t new_number;
- uint64_t initial= 3;
-
- test_compare(MEMCACHED_SUCCESS,
- memcached_decrement_with_initial_by_key(memc,
- test_literal_param("foo"),
- test_literal_param("number"),
- 1, initial, 0, &new_number));
- test_compare(new_number, initial);
-
- test_compare(MEMCACHED_SUCCESS,
- memcached_decrement_with_initial_by_key(memc,
- test_literal_param("foo"),
- test_literal_param("number"),
- 1, initial, 0, &new_number));
- test_compare(new_number, (initial - 1));
-
- return TEST_SUCCESS;
-}
-test_return_t binary_increment_with_prefix_test(memcached_st *memc)
-{
- test_skip(true, memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL));
-
- test_compare(MEMCACHED_SUCCESS, memcached_callback_set(memc, MEMCACHED_CALLBACK_PREFIX_KEY, (void *)"namespace:"));
-
- test_compare(return_value_based_on_buffering(memc),
- memcached_set(memc,
- test_literal_param("number"),
- test_literal_param("0"),
- (time_t)0, (uint32_t)0));
-
- uint64_t new_number;
- test_compare(MEMCACHED_SUCCESS, memcached_increment(memc,
- test_literal_param("number"),
- 1, &new_number));
- test_compare(uint64_t(1), new_number);
-
- test_compare(MEMCACHED_SUCCESS, memcached_increment(memc,
- test_literal_param("number"),
- 1, &new_number));
- test_compare(uint64_t(2), new_number);
-
- return TEST_SUCCESS;
-}
-
-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));
- 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));
-
- return TEST_SUCCESS;
-}
-
-test_return_t mget_result_test(memcached_st *memc)
-{
- const char *keys[]= {"fudge", "son", "food"};
- size_t key_length[]= {5, 3, 4};
-
- memcached_result_st results_obj;
- memcached_result_st *results;
-
- results= memcached_result_create(memc, &results_obj);
- test_true(results);
- test_true(&results_obj == results);
-
- /* We need to empty the server before continueing test */
- test_compare(MEMCACHED_SUCCESS,
- memcached_flush(memc, 0));
-
- test_compare(MEMCACHED_SUCCESS,
- memcached_mget(memc, keys, key_length, 3));
-
- memcached_return_t rc;
- while ((results= memcached_fetch_result(memc, &results_obj, &rc)))
- {
- test_true(results);
- }
-
- while ((results= memcached_fetch_result(memc, &results_obj, &rc))) { test_true(false); /* We should never see a value returned */ };
- test_false(results);
- test_compare_got(MEMCACHED_NOTFOUND, rc, memcached_strerror(NULL, rc));
-
- for (uint32_t x= 0; x < 3; x++)
- {
- rc= memcached_set(memc, keys[x], key_length[x],
- keys[x], key_length[x],
- (time_t)50, (uint32_t)9);
- test_true_got(rc == MEMCACHED_SUCCESS or rc == MEMCACHED_BUFFERED, memcached_strerror(NULL, rc));
- }
-
- test_compare(MEMCACHED_SUCCESS,
- memcached_mget(memc, keys, key_length, 3));
-
- while ((results= memcached_fetch_result(memc, &results_obj, &rc)))
- {
- test_true(results);
- test_true(&results_obj == results);
- test_compare(MEMCACHED_SUCCESS, rc);
- test_memcmp(memcached_result_key_value(results),
- memcached_result_value(results),
- memcached_result_length(results));
- test_compare(memcached_result_key_length(results), memcached_result_length(results));
- }
-
- memcached_result_free(&results_obj);
-
- return TEST_SUCCESS;
-}
-
-test_return_t mget_result_alloc_test(memcached_st *memc)
-{
- const char *keys[]= {"fudge", "son", "food"};
- size_t key_length[]= {5, 3, 4};
-
- memcached_result_st *results;
-
- /* We need to empty the server before continueing test */
- test_compare(MEMCACHED_SUCCESS,
- memcached_flush(memc, 0));
-
- test_compare(MEMCACHED_SUCCESS,
- memcached_mget(memc, keys, key_length, 3));
-
- memcached_return_t rc;
- while ((results= memcached_fetch_result(memc, NULL, &rc)))
- {
- test_true(results);
- }
- test_false(results);
- test_compare_got(MEMCACHED_NOTFOUND, rc, memcached_strerror(NULL, rc));
-
- for (uint32_t x= 0; x < 3; x++)
- {
- rc= memcached_set(memc, keys[x], key_length[x],
- keys[x], key_length[x],
- (time_t)50, (uint32_t)9);
- test_true_got(rc == MEMCACHED_SUCCESS or rc == MEMCACHED_BUFFERED, memcached_strerror(NULL, rc));
- }
-
- test_compare(MEMCACHED_SUCCESS,
- memcached_mget(memc, keys, key_length, 3));
-
- uint32_t x= 0;
- while ((results= memcached_fetch_result(memc, NULL, &rc)))
- {
- test_true(results);
- test_compare(MEMCACHED_SUCCESS, rc);
- test_compare(memcached_result_key_length(results), memcached_result_length(results));
- test_memcmp(memcached_result_key_value(results),
- memcached_result_value(results),
- memcached_result_length(results));
- memcached_result_free(results);
- x++;
- }
-
- return TEST_SUCCESS;
-}
-
-test_return_t mget_result_function(memcached_st *memc)
-{
- const char *keys[]= {"fudge", "son", "food"};
- size_t key_length[]= {5, 3, 4};
- size_t counter;
- memcached_execute_fn callbacks[1];
-
- for (uint32_t x= 0; x < 3; x++)
- {
- test_compare(return_value_based_on_buffering(memc),
- memcached_set(memc, keys[x], key_length[x],
- keys[x], key_length[x],
- time_t(50), uint32_t(9)));
- }
- test_compare(MEMCACHED_SUCCESS, memcached_flush_buffers(memc));
- memcached_quit(memc);
-
- test_compare(MEMCACHED_SUCCESS,
- memcached_mget(memc, keys, key_length, 3));
-
- callbacks[0]= &callback_counter;
- counter= 0;
-
- test_compare(MEMCACHED_SUCCESS,
- memcached_fetch_execute(memc, callbacks, (void *)&counter, 1));
-
- test_compare(size_t(3), counter);
-
- return TEST_SUCCESS;
-}
-
-test_return_t mget_test(memcached_st *memc)
-{
- const char *keys[]= {"fudge", "son", "food"};
- size_t key_length[]= {5, 3, 4};
-
- char return_key[MEMCACHED_MAX_KEY];
- size_t return_key_length;
- char *return_value;
- size_t return_value_length;
-
- test_compare(MEMCACHED_SUCCESS,
- memcached_mget(memc, keys, key_length, 3));
-
- uint32_t flags;
- memcached_return_t rc;
- while ((return_value= memcached_fetch(memc, return_key, &return_key_length,
- &return_value_length, &flags, &rc)))
- {
- test_true(return_value);
- }
- test_false(return_value);
- test_zero(return_value_length);
- test_compare(MEMCACHED_NOTFOUND, rc);
-
- for (uint32_t x= 0; x < 3; x++)
- {
- rc= memcached_set(memc, keys[x], key_length[x],
- keys[x], key_length[x],
- (time_t)50, (uint32_t)9);
- test_true_got(rc == MEMCACHED_SUCCESS or rc == MEMCACHED_BUFFERED, memcached_strerror(NULL, rc));
- }
- test_compare(MEMCACHED_SUCCESS,
- memcached_mget(memc, keys, key_length, 3));
-
- uint32_t x= 0;
- while ((return_value= memcached_fetch(memc, return_key, &return_key_length,
- &return_value_length, &flags, &rc)))
- {
- test_true(return_value);
- test_compare(MEMCACHED_SUCCESS, rc);
- if (not memc->_namespace)
- {
- test_compare(return_key_length, return_value_length);
- test_memcmp(return_value, return_key, return_value_length);
- }
- free(return_value);
- x++;
- }
-
- return TEST_SUCCESS;
-}
-
-test_return_t mget_execute(memcached_st *original_memc)
-{
- test_skip(true, memcached_behavior_get(original_memc, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL));
-
- memcached_st *memc= create_single_instance_memcached(original_memc, "--BINARY-PROTOCOL");
- test_true(memc);
-
- keys_st keys(20480);
-
- /* First add all of the items.. */
- char blob[1024] = {0};
-
- for (size_t x= 0; x < keys.size(); ++x)
- {
- uint64_t query_id= memcached_query_id(memc);
- memcached_return_t rc= memcached_add(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_compare(query_id +1, memcached_query_id(memc));
- }
-
- /* Try to get all of them with a large multiget */
- size_t counter= 0;
- memcached_execute_fn callbacks[]= { &callback_counter };
- test_compare(MEMCACHED_SUCCESS,
- memcached_mget_execute(memc,
- keys.keys_ptr(), keys.lengths_ptr(),
- keys.size(), callbacks, &counter, 1));
-
- {
- uint64_t query_id= memcached_query_id(memc);
- test_compare(MEMCACHED_SUCCESS,
- memcached_fetch_execute(memc, callbacks, (void *)&counter, 1));
- test_compare(query_id, memcached_query_id(memc));
-
- /* Verify that we got all of the items */
- test_compare(keys.size(), counter);
- }
-
- memcached_free(memc);
-
- return TEST_SUCCESS;
-}
-
-#define REGRESSION_BINARY_VS_BLOCK_COUNT 20480
-static pairs_st *global_pairs= NULL;
-
-test_return_t key_setup(memcached_st *memc)
-{
- test_skip(TEST_SUCCESS, pre_binary(memc));
-
- global_pairs= pairs_generate(REGRESSION_BINARY_VS_BLOCK_COUNT, 0);
-
- return TEST_SUCCESS;
-}
-
-test_return_t key_teardown(memcached_st *)
-{
- pairs_free(global_pairs);
- global_pairs= NULL;
-
- return TEST_SUCCESS;
-}
-
-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)
- {
- 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));
- }
-
- return TEST_SUCCESS;
-}
-
-test_return_t binary_add_regression(memcached_st *memc)
-{
- test_skip(MEMCACHED_SUCCESS, memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL, true));
- test_return_t rc= block_add_regression(memc);
-
- return rc;
-}
-
-test_return_t get_stats_keys(memcached_st *memc)
-{
- char **stat_list;
- char **ptr;
- memcached_stat_st memc_stat;
- memcached_return_t rc;
-
- stat_list= memcached_stat_get_keys(memc, &memc_stat, &rc);
- test_compare(MEMCACHED_SUCCESS, rc);
- for (ptr= stat_list; *ptr; ptr++)
- test_true(*ptr);
-
- free(stat_list);
-
- return TEST_SUCCESS;
-}
-
-test_return_t version_string_test(memcached_st *)
-{
- test_strcmp(LIBMEMCACHED_VERSION_STRING, memcached_lib_version());
-
- return TEST_SUCCESS;
-}
-
-test_return_t get_stats(memcached_st *memc)
-{
- memcached_return_t rc;
-
- memcached_stat_st *memc_stat= memcached_stat(memc, NULL, &rc);
- test_compare(MEMCACHED_SUCCESS, rc);
- test_true(memc_stat);
-
- for (uint32_t x= 0; x < memcached_server_count(memc); x++)
- {
- char **stat_list= memcached_stat_get_keys(memc, memc_stat+x, &rc);
- test_compare(MEMCACHED_SUCCESS, rc);
- for (char **ptr= stat_list; *ptr; ptr++) {};
-
- free(stat_list);
- }
-
- memcached_stat_free(NULL, memc_stat);
-
- return TEST_SUCCESS;
-}
-
-test_return_t add_host_test(memcached_st *memc)
-{
- char servername[]= "0.example.com";
-
- 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 (unsigned int x= 2; x < 20; x++)
- {
- char buffer[SMALL_STRING_LEN];
-
- snprintf(buffer, SMALL_STRING_LEN, "%u.example.com", 400+x);
- servers= memcached_server_list_append_with_weight(servers, buffer, 401, 0,
- &rc);
- test_compare(MEMCACHED_SUCCESS, rc);
- test_compare(x, memcached_server_list_count(servers));
- }
-
- test_compare(MEMCACHED_SUCCESS, memcached_server_push(memc, servers));
- test_compare(MEMCACHED_SUCCESS, memcached_server_push(memc, servers));
-
- memcached_server_list_free(servers);
-
- return TEST_SUCCESS;
-}
-
-test_return_t memcached_fetch_result_NOT_FOUND(memcached_st *memc)
-{
- memcached_return_t rc;
-
- const char *key= "not_found";
- size_t key_length= test_literal_param_size("not_found");
-
- test_compare(MEMCACHED_SUCCESS,
- memcached_mget(memc, &key, &key_length, 1));
-
- 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);
-
- return TEST_SUCCESS;
-}
-
-static memcached_return_t clone_test_callback(memcached_st *, memcached_st *)
-{
- return MEMCACHED_SUCCESS;
-}
-
-static memcached_return_t cleanup_test_callback(memcached_st *)
-{
- return MEMCACHED_SUCCESS;
-}
-
-test_return_t callback_test(memcached_st *memc)
-{
- /* Test User Data */
- {
- int x= 5;
- int *test_ptr;
- memcached_return_t 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);
- }
-
- /* Test Clone Callback */
- {
- memcached_clone_fn clone_cb= (memcached_clone_fn)clone_test_callback;
- void *clone_cb_ptr= *(void **)&clone_cb;
- void *temp_function= NULL;
-
- 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;
- void *cleanup_cb_ptr= *(void **)&cleanup_cb;
- void *temp_function= NULL;
- memcached_return_t 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);
- }
-
- return TEST_SUCCESS;
-}
-
-/* We don't test the behavior itself, we test the switches */
-test_return_t behavior_test(memcached_st *memc)
-{
- memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_NO_BLOCK, 1);
- test_compare(true, memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_NO_BLOCK));
-
- memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_TCP_NODELAY, 1);
- test_compare(true, memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_TCP_NODELAY));
-
- 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, 0);
- test_zero(memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_NO_BLOCK));
-
- memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_TCP_NODELAY, 0);
- test_zero(memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_TCP_NODELAY));
-
- memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_HASH, MEMCACHED_HASH_DEFAULT);
- test_compare(uint64_t(MEMCACHED_HASH_DEFAULT), memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_HASH));
-
- memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_HASH, MEMCACHED_HASH_CRC);
- test_compare(uint64_t(MEMCACHED_HASH_CRC), memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_HASH));
-
- test_true(memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_SOCKET_SEND_SIZE));
-
- test_true(memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_SOCKET_RECV_SIZE));
-
- 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;
-}
-
-test_return_t MEMCACHED_BEHAVIOR_CORK_test(memcached_st *memc)
-{
- test_compare(MEMCACHED_DEPRECATED,
- memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_CORK, true));
-
- // Platform dependent
-#if 0
- bool value= (bool)memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_CORK);
- test_false(value);
-#endif
-
- return TEST_SUCCESS;
-}
-
-
-test_return_t MEMCACHED_BEHAVIOR_TCP_KEEPALIVE_test(memcached_st *memc)
-{
- memcached_return_t rc= memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_TCP_KEEPALIVE, true);
- test_true(rc == MEMCACHED_SUCCESS || rc == MEMCACHED_NOT_SUPPORTED);
-
- bool value= (bool)memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_TCP_KEEPALIVE);
-
- if (memcached_success(rc))
- {
- test_true(value);
- }
- else
- {
- test_false(value);
- }
-
- return TEST_SUCCESS;
-}
-
-
-test_return_t MEMCACHED_BEHAVIOR_TCP_KEEPIDLE_test(memcached_st *memc)
-{
- memcached_return_t rc= memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_TCP_KEEPIDLE, true);
- test_true(rc == MEMCACHED_SUCCESS || rc == MEMCACHED_NOT_SUPPORTED);
-
- bool value= (bool)memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_TCP_KEEPIDLE);
-
- if (memcached_success(rc))
- {
- test_true(value);
- }
- else
- {
- test_false(value);
- }
-
- return TEST_SUCCESS;
-}
-
-/* Make sure we behave properly if server list has no values */
-test_return_t user_supplied_bug4(memcached_st *memc)
-{
- const char *keys[]= {"fudge", "son", "food"};
- size_t key_length[]= {5, 3, 4};
-
- /* Here we free everything before running a bunch of mget tests */
- memcached_servers_reset(memc);
-
-
- /* We need to empty the server before continueing test */
- test_compare(MEMCACHED_NO_SERVERS,
- memcached_flush(memc, 0));
-
- test_compare(MEMCACHED_NO_SERVERS,
- memcached_mget(memc, keys, key_length, 3));
-
- {
- unsigned int keys_returned;
- memcached_return_t rc;
- test_compare(TEST_SUCCESS, fetch_all_results(memc, keys_returned, rc));
- test_compare(MEMCACHED_NOTFOUND, rc);
- test_zero(keys_returned);
- }
-
- for (uint32_t x= 0; x < 3; x++)
- {
- test_compare(MEMCACHED_NO_SERVERS,
- memcached_set(memc, keys[x], key_length[x],
- keys[x], key_length[x],
- (time_t)50, (uint32_t)9));
- }
-
- test_compare(MEMCACHED_NO_SERVERS,
- memcached_mget(memc, keys, key_length, 3));
-
- {
- char *return_value;
- char return_key[MEMCACHED_MAX_KEY];
- memcached_return_t rc;
- size_t return_key_length;
- size_t return_value_length;
- uint32_t flags;
- uint32_t x= 0;
- while ((return_value= memcached_fetch(memc, return_key, &return_key_length,
- &return_value_length, &flags, &rc)))
- {
- test_true(return_value);
- test_compare(MEMCACHED_SUCCESS, rc);
- test_true(return_key_length == return_value_length);
- test_memcmp(return_value, return_key, return_value_length);
- free(return_value);
- x++;
- }
- }
-
- return TEST_SUCCESS;
-}
-
-#define VALUE_SIZE_BUG5 1048064
-test_return_t user_supplied_bug5(memcached_st *memc)
-{
- const char *keys[]= {"036790384900", "036790384902", "036790384904", "036790384906"};
- size_t key_length[]= {strlen("036790384900"), strlen("036790384902"), strlen("036790384904"), strlen("036790384906")};
- char *value;
- size_t value_length;
- uint32_t flags;
- char *insert_data= new (std::nothrow) char[VALUE_SIZE_BUG5];
-
- for (uint32_t x= 0; x < VALUE_SIZE_BUG5; x++)
- {
- insert_data[x]= (signed char)rand();
- }
-
- test_compare(MEMCACHED_SUCCESS,
- memcached_flush(memc, 0));
-
- memcached_return_t rc;
- 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));
-
- unsigned int count;
- test_compare(TEST_SUCCESS, fetch_all_results(memc, count, rc));
- test_compare(MEMCACHED_NOTFOUND, rc);
- test_zero(count);
-
- for (uint32_t x= 0; x < 4; x++)
- {
- test_compare(MEMCACHED_SUCCESS,
- memcached_set(memc, keys[x], key_length[x],
- insert_data, VALUE_SIZE_BUG5,
- (time_t)0, (uint32_t)0));
- }
-
- for (uint32_t x= 0; x < 10; x++)
- {
- value= memcached_get(memc, keys[0], key_length[0],
- &value_length, &flags, &rc);
- test_compare(rc, MEMCACHED_SUCCESS);
- test_true(value);
- ::free(value);
-
- test_compare(MEMCACHED_SUCCESS,
- memcached_mget(memc, keys, key_length, 4));
-
- test_compare(TEST_SUCCESS, fetch_all_results(memc, count));
- test_compare(4U, count);
- }
- delete [] insert_data;
-
- return TEST_SUCCESS;
-}
-
-test_return_t user_supplied_bug6(memcached_st *memc)
-{
- const char *keys[]= {"036790384900", "036790384902", "036790384904", "036790384906"};
- size_t key_length[]= {strlen("036790384900"), strlen("036790384902"), strlen("036790384904"), strlen("036790384906")};
- char return_key[MEMCACHED_MAX_KEY];
- size_t return_key_length;
- char *value;
- size_t value_length;
- uint32_t flags;
- char *insert_data= new (std::nothrow) char[VALUE_SIZE_BUG5];
-
- for (uint32_t x= 0; x < VALUE_SIZE_BUG5; x++)
- {
- insert_data[x]= (signed char)rand();
- }
-
- test_compare(MEMCACHED_SUCCESS, memcached_flush(memc, 0));
-
- test_compare(TEST_SUCCESS, confirm_keys_dont_exist(memc, keys, test_array_length(keys)));
-
- // We will now confirm that memcached_mget() returns success, but we will
- // then check to make sure that no actual keys are returned.
- test_compare(MEMCACHED_SUCCESS,
- memcached_mget(memc, keys, key_length, 4));
-
- memcached_return_t rc;
- uint32_t count= 0;
- while ((value= memcached_fetch(memc, return_key, &return_key_length,
- &value_length, &flags, &rc)))
- {
- count++;
- }
- test_zero(count);
- test_compare_got(MEMCACHED_NOTFOUND, rc, memcached_strerror(NULL, rc));
-
- for (uint32_t x= 0; x < test_array_length(keys); x++)
- {
- test_compare(MEMCACHED_SUCCESS,
- memcached_set(memc, keys[x], key_length[x],
- insert_data, VALUE_SIZE_BUG5,
- (time_t)0, (uint32_t)0));
- }
- test_compare(TEST_SUCCESS, confirm_keys_exist(memc, keys, test_array_length(keys)));
-
- for (uint32_t x= 0; x < 2; x++)
- {
- value= memcached_get(memc, keys[0], key_length[0],
- &value_length, &flags, &rc);
- test_true(value);
- free(value);
-
- test_compare(MEMCACHED_SUCCESS,
- memcached_mget(memc, keys, key_length, 4));
- /* We test for purge of partial complete fetches */
- for (count= 3; count; count--)
- {
- value= memcached_fetch(memc, return_key, &return_key_length,
- &value_length, &flags, &rc);
- test_compare(MEMCACHED_SUCCESS, rc);
- test_memcmp(value, insert_data, value_length);
- test_true(value_length);
- free(value);
- }
- }
- delete [] insert_data;
-
- return TEST_SUCCESS;
-}
-
-test_return_t user_supplied_bug8(memcached_st *)
-{
- memcached_return_t rc;
- memcached_st *mine;
- memcached_st *memc_clone;
-
- memcached_server_st *servers;
- const char *server_list= "memcache1.memcache.bk.sapo.pt:11211, memcache1.memcache.bk.sapo.pt:11212, memcache1.memcache.bk.sapo.pt:11213, memcache1.memcache.bk.sapo.pt:11214, memcache2.memcache.bk.sapo.pt:11211, memcache2.memcache.bk.sapo.pt:11212, memcache2.memcache.bk.sapo.pt:11213, memcache2.memcache.bk.sapo.pt:11214";
-
- servers= memcached_servers_parse(server_list);
- test_true(servers);
-
- mine= memcached_create(NULL);
- rc= memcached_server_push(mine, servers);
- test_compare(MEMCACHED_SUCCESS, rc);
- memcached_server_list_free(servers);
-
- test_true(mine);
- memc_clone= memcached_clone(NULL, mine);
-
- memcached_quit(mine);
- memcached_quit(memc_clone);
-
-
- memcached_free(mine);
- memcached_free(memc_clone);
-
- return TEST_SUCCESS;
-}
-
-/* Test flag store/retrieve */
-test_return_t user_supplied_bug7(memcached_st *memc)
-{
- char *insert_data= new (std::nothrow) char[VALUE_SIZE_BUG5];
- test_true(insert_data);
-
- for (size_t x= 0; x < VALUE_SIZE_BUG5; x++)
- {
- insert_data[x]= (signed char)rand();
- }
-
- memcached_flush(memc, 0);
-
- 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));
-
- memcached_return_t rc;
- size_t value_length;
- uint32_t flags= 0;
- char *value= memcached_get(memc, keys, key_length,
- &value_length, &flags, &rc);
- test_compare(245U, flags);
- test_true(value);
- free(value);
-
- test_compare(MEMCACHED_SUCCESS, memcached_mget(memc, &keys, &key_length, 1));
-
- char return_key[MEMCACHED_MAX_KEY];
- size_t return_key_length;
- flags= 0;
- value= memcached_fetch(memc, return_key, &return_key_length,
- &value_length, &flags, &rc);
- test_compare(uint32_t(245), flags);
- test_true(value);
- free(value);
- delete [] insert_data;
-
-
- return TEST_SUCCESS;
-}
-
-test_return_t user_supplied_bug9(memcached_st *memc)
-{
- const char *keys[]= {"UDATA:edevil@sapo.pt", "fudge&*@#", "for^#@&$not"};
- size_t key_length[3];
- uint32_t flags;
- unsigned count= 0;
-
- char return_key[MEMCACHED_MAX_KEY];
- size_t return_key_length;
- char *return_value;
- size_t return_value_length;
-
-
- key_length[0]= strlen("UDATA:edevil@sapo.pt");
- key_length[1]= strlen("fudge&*@#");
- key_length[2]= strlen("for^#@&$not");
-
-
- for (unsigned int x= 0; x < 3; x++)
- {
- memcached_return_t rc= memcached_set(memc, keys[x], key_length[x],
- keys[x], key_length[x],
- (time_t)50, (uint32_t)9);
- test_compare(MEMCACHED_SUCCESS, rc);
- }
-
- memcached_return_t rc= memcached_mget(memc, keys, key_length, 3);
- test_compare(MEMCACHED_SUCCESS, rc);
-
- /* We need to empty the server before continueing test */
- while ((return_value= memcached_fetch(memc, return_key, &return_key_length,
- &return_value_length, &flags, &rc)) != NULL)
- {
- test_true(return_value);
- free(return_value);
- count++;
- }
- test_compare(3U, count);
-
- return TEST_SUCCESS;
-}
-
-/* We are testing with aggressive timeout to get failures */
-test_return_t user_supplied_bug10(memcached_st *memc)
-{
- test_skip(memc->servers[0].type, MEMCACHED_CONNECTION_TCP);
-
- size_t value_length= 512;
- 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);
- memcached_behavior_set(mclone, MEMCACHED_BEHAVIOR_POLL_TIMEOUT, uint64_t(0));
-
- libtest::vchar_t value;
- value.reserve(value_length);
- for (uint32_t x= 0; x < value_length; x++)
- {
- 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[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),
- memcached_strerror(NULL, rc));
-
- if (rc == MEMCACHED_WRITE_FAILURE or rc == MEMCACHED_TIMEOUT)
- {
- x--;
- }
- }
-
- memcached_free(mclone);
-
- return TEST_SUCCESS;
-}
-
-/*
- We are looking failures in the async protocol
-*/
-test_return_t user_supplied_bug11(memcached_st *memc)
-{
- memcached_st *mclone= memcached_clone(NULL, memc);
-
- 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_compare(-1, int32_t(memcached_behavior_get(mclone, MEMCACHED_BEHAVIOR_POLL_TIMEOUT)));
-
-
- libtest::vchar_t value;
- value.reserve(512);
- for (unsigned int x= 0; x < 512; x++)
- {
- 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[0], value.size(), 0, 0);
- (void)rc;
- }
-
- memcached_free(mclone);
-
- return TEST_SUCCESS;
-}
-
-/*
- Bug found where incr was not returning MEMCACHED_NOTFOUND when object did not exist.
-*/
-test_return_t user_supplied_bug12(memcached_st *memc)
-{
- memcached_return_t rc;
- uint32_t flags;
- size_t value_length;
- char *value;
- uint64_t number_value;
-
- value= memcached_get(memc, "autoincrement", strlen("autoincrement"),
- &value_length, &flags, &rc);
- test_null(value);
- test_compare(MEMCACHED_NOTFOUND, rc);
-
- rc= memcached_increment(memc, "autoincrement", strlen("autoincrement"),
- 1, &number_value);
- 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)
- {
- test_compare(MEMCACHED_SUCCESS, rc);
- }
- else
- {
- test_compare(MEMCACHED_NOTFOUND, rc);
- }
-
- 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);
- test_true(value);
- free(value);
-
- test_compare(MEMCACHED_SUCCESS,
- memcached_increment(memc, "autoincrement", strlen("autoincrement"), 1, &number_value));
- test_compare(2UL, number_value);
-
- return TEST_SUCCESS;
-}
-
-/*
- Bug found where command total one more than MEMCACHED_MAX_BUFFER
- set key34567890 0 0 8169 \r\n is sent followed by buffer of size 8169, followed by 8169
-*/
-test_return_t user_supplied_bug13(memcached_st *memc)
-{
- char key[] = "key34567890";
-
- char commandFirst[]= "set key34567890 0 0 ";
- char commandLast[] = " \r\n"; /* first line of command sent to server */
- size_t commandLength;
-
- commandLength = strlen(commandFirst) + strlen(commandLast) + 4; /* 4 is number of characters in size, probably 8196 */
-
- size_t overflowSize = MEMCACHED_MAX_BUFFER - commandLength;
-
- for (size_t testSize= overflowSize - 1; testSize < overflowSize + 1; testSize++)
- {
- char *overflow= new (std::nothrow) char[testSize];
- test_true(overflow);
-
- memset(overflow, 'x', testSize);
- test_compare(MEMCACHED_SUCCESS,
- memcached_set(memc, key, strlen(key),
- overflow, testSize, 0, 0));
- delete [] overflow;
- }
-
- return TEST_SUCCESS;
-}
-
-
-/*
- Test values of many different sizes
- Bug found where command total one more than MEMCACHED_MAX_BUFFER
- set key34567890 0 0 8169 \r\n
- is sent followed by buffer of size 8169, followed by 8169
-*/
-test_return_t user_supplied_bug14(memcached_st *memc)
-{
- memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_TCP_NODELAY, true);
-
- libtest::vchar_t value;
- value.reserve(18000);
- for (ptrdiff_t x= 0; x < 18000; x++)
- {
- value.push_back((char) (x % 127));
- }
-
- for (size_t current_length= 1; current_length < value.size(); current_length++)
- {
- memcached_return_t rc= memcached_set(memc, test_literal_param("foo"),
- &value[0], current_length,
- (time_t)0, (uint32_t)0);
- test_true(rc == MEMCACHED_SUCCESS or rc == MEMCACHED_BUFFERED);
-
- size_t string_length;
- uint32_t flags;
- char *string= memcached_get(memc, test_literal_param("foo"),
- &string_length, &flags, &rc);
-
- test_compare(MEMCACHED_SUCCESS, rc);
- test_compare(string_length, current_length);
- char buffer[1024];
- snprintf(buffer, sizeof(buffer), "%u", uint32_t(string_length));
- test_memcmp_hint(string, &value[0], string_length, buffer);
-
- free(string);
- }
-
- return TEST_SUCCESS;
-}
-
-/*
- Look for zero length value problems
-*/
-test_return_t user_supplied_bug15(memcached_st *memc)
-{
- for (uint32_t x= 0; x < 2; x++)
- {
- memcached_return_t rc= memcached_set(memc, test_literal_param("mykey"),
- NULL, 0,
- (time_t)0, (uint32_t)0);
-
- test_compare(MEMCACHED_SUCCESS, rc);
-
- size_t length;
- uint32_t flags;
- char *value= memcached_get(memc, test_literal_param("mykey"),
- &length, &flags, &rc);
-
- test_compare(MEMCACHED_SUCCESS, rc);
- test_false(value);
- test_zero(length);
- test_zero(flags);
-
- value= memcached_get(memc, test_literal_param("mykey"),
- &length, &flags, &rc);
-
- test_compare(MEMCACHED_SUCCESS, rc);
- test_null(value);
- test_zero(length);
- test_zero(flags);
- }
-
- return TEST_SUCCESS;
-}
-
-/* Check the return sizes on FLAGS to make sure it stores 32bit unsigned values correctly */
-test_return_t user_supplied_bug16(memcached_st *memc)
-{
- test_compare_hint(MEMCACHED_SUCCESS, memcached_set(memc, test_literal_param("mykey"),
- NULL, 0,
- (time_t)0, UINT32_MAX),
- memcached_last_error_message(memc));
-
-
- size_t length;
- uint32_t flags;
- memcached_return_t rc;
- char *value= memcached_get(memc, test_literal_param("mykey"),
- &length, &flags, &rc);
-
- test_compare(MEMCACHED_SUCCESS, rc);
- test_null(value);
- test_zero(length);
- test_compare(flags, UINT32_MAX);
-
- return TEST_SUCCESS;
-}
-
-#if !defined(__sun) && !defined(__OpenBSD__)
-/* Check the validity of chinese key*/
-test_return_t user_supplied_bug17(memcached_st *memc)
-{
- const char *key= "豆瓣";
- const char *value="我们在炎热抑郁的夏天无法停止豆瓣";
- memcached_return_t rc= memcached_set(memc, key, strlen(key),
- value, strlen(value),
- (time_t)0, 0);
-
- test_compare(MEMCACHED_SUCCESS, rc);
-
- size_t length;
- uint32_t flags;
- char *value2= memcached_get(memc, key, strlen(key),
- &length, &flags, &rc);
-
- test_true(length==strlen(value));
- test_compare(MEMCACHED_SUCCESS, rc);
- test_memcmp(value, value2, length);
- free(value2);
-
- return TEST_SUCCESS;
-}
-#endif
-
-/*
- From Andrei on IRC
-*/
-
-test_return_t user_supplied_bug19(memcached_st *)
-{
- memcached_return_t res;
-
- memcached_st *memc= memcached(test_literal_param("--server=localhost:11311/?100 --server=localhost:11312/?100"));
-
- const memcached_server_st *server= memcached_server_by_key(memc, "a", 1, &res);
- test_true(server);
-
- memcached_free(memc);
-
- return TEST_SUCCESS;
-}
-
-/* CAS test from Andei */
-test_return_t user_supplied_bug20(memcached_st *memc)
-{
- const char *key= "abc";
- size_t key_len= strlen("abc");
-
- test_skip(MEMCACHED_SUCCESS, memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_SUPPORT_CAS, true));
-
- test_compare(MEMCACHED_SUCCESS,
- memcached_set(memc,
- test_literal_param("abc"),
- test_literal_param("foobar"),
- (time_t)0, (uint32_t)0));