(void)memcached_create(&memc);
memcached_free(&memc);
- return 0;
+ return TEST_SUCCESS;
}
static test_return server_list_null_test(memcached_st *ptr __attribute__((unused)))
server_list= memcached_server_list_append_with_weight(NULL, NULL, 0, 0, &rc);
assert(server_list == NULL);
- return 0;
+ return TEST_SUCCESS;
}
#define TEST_PORT_COUNT 7
memcached_free(local_memc);
- return 0;
+ return TEST_SUCCESS;
}
static test_return server_sort2_test(memcached_st *ptr __attribute__((unused)))
memcached_free(local_memc);
- return 0;
+ return TEST_SUCCESS;
}
static memcached_return server_display_unsort_function(memcached_st *ptr __attribute__((unused)), memcached_server_st *server, void *context)
memcached_free(local_memc);
- return 0;
+ return TEST_SUCCESS;
}
static test_return allocation_test(memcached_st *not_used __attribute__((unused)))
assert(memc);
memcached_free(memc);
- return 0;
+ return TEST_SUCCESS;
}
static test_return clone_test(memcached_st *memc)
memcached_free(memc_clone);
}
- return 0;
+ return TEST_SUCCESS;
}
static test_return userdata_test(memcached_st *memc)
rc= memcached_server_add_with_weight(memc, "localhost", 0, 0);
assert(rc == MEMCACHED_SUCCESS);
- return 0;
+ return TEST_SUCCESS;
}
static test_return error_test(memcached_st *memc)
assert(values[rc] == hash_val);
}
- return 0;
+ return TEST_SUCCESS;
}
static test_return set_test(memcached_st *memc)
(time_t)0, (uint32_t)0);
assert(rc == MEMCACHED_SUCCESS || rc == MEMCACHED_BUFFERED);
- return 0;
+ return TEST_SUCCESS;
}
static test_return append_test(memcached_st *memc)
assert(rc == MEMCACHED_SUCCESS);
free(out_value);
- return 0;
+ return TEST_SUCCESS;
}
static test_return append_binary_test(memcached_st *memc)
}
free(value);
- return 0;
+ return TEST_SUCCESS;
}
static test_return cas2_test(memcached_st *memc)
memcached_result_free(&results_obj);
- return 0;
+ return TEST_SUCCESS;
}
static test_return cas_test(memcached_st *memc)
memcached_result_free(&results_obj);
- return 0;
+ return TEST_SUCCESS;
}
static test_return prepend_test(memcached_st *memc)
assert(rc == MEMCACHED_SUCCESS);
free(out_value);
- return 0;
+ return TEST_SUCCESS;
}
/*
else
assert(rc == MEMCACHED_NOTSTORED || rc == MEMCACHED_DATA_EXISTS);
- return 0;
+ return TEST_SUCCESS;
}
/*
for (x= 0; x < max; x++)
add_test(memc);
- return 0;
+ return TEST_SUCCESS;
}
static test_return replace_test(memcached_st *memc)
(time_t)0, (uint32_t)0);
assert(rc == MEMCACHED_SUCCESS);
- return 0;
+ return TEST_SUCCESS;
}
static test_return delete_test(memcached_st *memc)
rc= memcached_delete(memc, key, strlen(key), (time_t)0);
assert(rc == MEMCACHED_SUCCESS || rc == MEMCACHED_BUFFERED);
- return 0;
+ return TEST_SUCCESS;
}
static test_return flush_test(memcached_st *memc)
rc= memcached_flush(memc, 0);
assert(rc == MEMCACHED_SUCCESS);
- return 0;
+ return TEST_SUCCESS;
}
static memcached_return server_function(memcached_st *ptr __attribute__((unused)),
callbacks[0]= server_function;
memcached_server_cursor(memc, callbacks, context, 1);
- return 0;
+ return TEST_SUCCESS;
}
static test_return bad_key_test(memcached_st *memc)
memcached_free(memc_clone);
- return 0;
+ return TEST_SUCCESS;
}
#define READ_THROUGH_VALUE "set for me"
assert(!strcmp(READ_THROUGH_VALUE, string));
free(string);
- return 0;
+ return TEST_SUCCESS;
}
static memcached_return delete_trigger(memcached_st *ptr __attribute__((unused)),
rc= memcached_callback_set(memc, MEMCACHED_CALLBACK_DELETE_TRIGGER, *(void**)&callback);
assert(rc == MEMCACHED_SUCCESS);
- return 0;
+ return TEST_SUCCESS;
}
static test_return get_test(memcached_st *memc)
assert(string_length == 0);
assert(!string);
- return 0;
+ return TEST_SUCCESS;
}
static test_return get_test2(memcached_st *memc)
free(string);
- return 0;
+ return TEST_SUCCESS;
}
static test_return set_test2(memcached_st *memc)
assert(rc == MEMCACHED_SUCCESS || rc == MEMCACHED_BUFFERED);
}
- return 0;
+ return TEST_SUCCESS;
}
static test_return set_test3(memcached_st *memc)
free(value);
- return 0;
+ return TEST_SUCCESS;
}
static test_return get_test3(memcached_st *memc)
free(string);
free(value);
- return 0;
+ return TEST_SUCCESS;
}
static test_return get_test4(memcached_st *memc)
free(value);
- return 0;
+ return TEST_SUCCESS;
}
/*
memc->hosts[0].hostname,
memc->hosts[0].port);
- return 0;
+ return TEST_SUCCESS;
}
static test_return increment_test(memcached_st *memc)
assert(rc == MEMCACHED_SUCCESS);
assert(new_number == 2);
- return 0;
+ return TEST_SUCCESS;
}
static test_return increment_with_initial_test(memcached_st *memc)
assert(rc == MEMCACHED_SUCCESS);
assert(new_number == (initial + 1));
}
- return 0;
+ return TEST_SUCCESS;
}
static test_return decrement_test(memcached_st *memc)
assert(rc == MEMCACHED_SUCCESS);
assert(new_number == 1);
- return 0;
+ return TEST_SUCCESS;
}
static test_return decrement_with_initial_test(memcached_st *memc)
assert(rc == MEMCACHED_SUCCESS);
assert(new_number == (initial - 1));
}
- return 0;
+ return TEST_SUCCESS;
}
static test_return quit_test(memcached_st *memc)
(time_t)50, (uint32_t)9);
assert(rc == MEMCACHED_SUCCESS || rc == MEMCACHED_BUFFERED);
- return 0;
+ return TEST_SUCCESS;
}
static test_return mget_result_test(memcached_st *memc)
memcached_result_free(&results_obj);
- return 0;
+ return TEST_SUCCESS;
}
static test_return mget_result_alloc_test(memcached_st *memc)
x++;
}
- return 0;
+ return TEST_SUCCESS;
}
/* Count the results */
assert(counter == 3);
- return 0;
+ return TEST_SUCCESS;
}
static test_return mget_test(memcached_st *memc)
x++;
}
- return 0;
+ return TEST_SUCCESS;
}
static test_return get_stats_keys(memcached_st *memc)
free(list);
- return 0;
+ return TEST_SUCCESS;
}
static test_return version_string_test(memcached_st *memc __attribute__((unused)))
assert(!strcmp(version_string, LIBMEMCACHED_VERSION_STRING));
- return 0;
+ return TEST_SUCCESS;
}
static test_return get_stats(memcached_st *memc)
memcached_stat_free(NULL, memc_stat);
- return 0;
+ return TEST_SUCCESS;
}
static test_return add_host_test(memcached_st *memc)
memcached_server_list_free(servers);
- return 0;
+ return TEST_SUCCESS;
}
static memcached_return clone_test_callback(memcached_st *parent __attribute__((unused)), memcached_st *memc_clone __attribute__((unused)))
assert(temp_function == cleanup_cb_ptr);
}
- return 0;
+ return TEST_SUCCESS;
}
/* We don't test the behavior itself, we test the switches */
value= memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_NUMBER_OF_REPLICAS);
memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_NUMBER_OF_REPLICAS, value + 1);
assert((value + 1) == memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_NUMBER_OF_REPLICAS));
- return 0;
+ return TEST_SUCCESS;
}
/* Test case provided by Cal Haldenbrand */
assert(rc == MEMCACHED_SUCCESS || rc == MEMCACHED_BUFFERED);
}
- return 0;
+ return TEST_SUCCESS;
}
/* Test case provided by Cal Haldenbrand */
free(getval);
}
- return 0;
+ return TEST_SUCCESS;
}
/* Do a large mget() over all the keys we think exist */
free(keys[x]);
free(keys);
- return 0;
+ return TEST_SUCCESS;
}
/* Make sure we behave properly if server list has no values */
x++;
}
- return 0;
+ return TEST_SUCCESS;
}
#define VALUE_SIZE_BUG5 1048064
assert(count == 4);
}
- return 0;
+ return TEST_SUCCESS;
}
static test_return user_supplied_bug6(memcached_st *memc)
}
}
- return 0;
+ return TEST_SUCCESS;
}
static test_return user_supplied_bug8(memcached_st *memc __attribute__((unused)))
memcached_free(mine);
memcached_free(memc_clone);
- return 0;
+ return TEST_SUCCESS;
}
/* Test flag store/retrieve */
free(value);
- return 0;
+ return TEST_SUCCESS;
}
static test_return user_supplied_bug9(memcached_st *memc)
}
assert(count == 3);
- return 0;
+ return TEST_SUCCESS;
}
/* We are testing with aggressive timeout to get failures */
free(value);
memcached_free(mclone);
- return 0;
+ return TEST_SUCCESS;
}
/*
free(value);
memcached_free(mclone);
- return 0;
+ return TEST_SUCCESS;
}
/*
assert(number_value == 2);
assert(rc == MEMCACHED_SUCCESS);
- return 0;
+ return TEST_SUCCESS;
}
/*
free(overflow);
}
- return 0;
+ return TEST_SUCCESS;
}
free(value);
- return 0;
+ return TEST_SUCCESS;
}
/*
assert(flags == 0);
}
- return 0;
+ return TEST_SUCCESS;
}
/* Check the return sizes on FLAGS to make sure it stores 32bit unsigned values correctly */
assert(length == 0);
assert(flags == UINT32_MAX);
- return 0;
+ return TEST_SUCCESS;
}
#ifndef __sun
assert(memcmp(value, value2, length)==0);
free(value2);
- return 0;
+ return TEST_SUCCESS;
}
#endif
memcached_free(m);
- return 0;
+ return TEST_SUCCESS;
}
/* CAS test from Andei */
memcached_result_free(result);
- return 0;
+ return TEST_SUCCESS;
}
#include "ketama_test_cases.h"
memcached_server_list_free(server_pool);
memcached_free(memc);
- return 0;
+ return TEST_SUCCESS;
}
static test_return auto_eject_hosts(memcached_st *trash)
assert(result_ptr);
memcached_result_free(&result);
- return 0;
+ return TEST_SUCCESS;
}
static test_return result_alloc(memcached_st *memc)
assert(result);
memcached_result_free(result);
- return 0;
+ return TEST_SUCCESS;
}
static test_return string_static_null(memcached_st *memc)
assert(string_ptr);
memcached_string_free(&string);
- return 0;
+ return TEST_SUCCESS;
}
static test_return string_alloc_null(memcached_st *memc)
assert(string);
memcached_string_free(string);
- return 0;
+ return TEST_SUCCESS;
}
static test_return string_alloc_with_size(memcached_st *memc)
assert(string);
memcached_string_free(string);
- return 0;
+ return TEST_SUCCESS;
}
static test_return string_alloc_with_size_toobig(memcached_st *memc)
string= memcached_string_create(memc, NULL, SIZE_MAX);
assert(string == NULL);
- return 0;
+ return TEST_SUCCESS;
}
static test_return string_alloc_append(memcached_st *memc)
}
memcached_string_free(string);
- return 0;
+ return TEST_SUCCESS;
}
static test_return string_alloc_append_toobig(memcached_st *memc)
assert(rc == MEMCACHED_MEMORY_ALLOCATION_FAILURE);
memcached_string_free(string);
- return 0;
+ return TEST_SUCCESS;
}
static test_return cleanup_pairs(memcached_st *memc __attribute__((unused)))
{
pairs_free(global_pairs);
- return 0;
+ return TEST_SUCCESS;
}
static test_return generate_pairs(memcached_st *memc __attribute__((unused)))
global_keys_length[x]= global_pairs[x].key_length;
}
- return 0;
+ return TEST_SUCCESS;
}
static test_return generate_large_pairs(memcached_st *memc __attribute__((unused)))
global_keys_length[x]= global_pairs[x].key_length;
}
- return 0;
+ return TEST_SUCCESS;
}
static test_return generate_data(memcached_st *memc)
{
execute_set(memc, global_pairs, global_count);
- return 0;
+ return TEST_SUCCESS;
}
static test_return generate_data_with_stats(memcached_st *memc)
memcached_stat_free(NULL, stat_p);
- return 0;
+ return TEST_SUCCESS;
}
static test_return generate_buffer_data(memcached_st *memc)
{
memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_BUFFER_REQUESTS, latch);
generate_data(memc);
- return 0;
+ return TEST_SUCCESS;
}
static test_return get_read_count(memcached_st *memc)
memcached_free(memc_clone);
- return 0;
+ return TEST_SUCCESS;
}
static test_return get_read(memcached_st *memc)
}
}
- return 0;
+ return TEST_SUCCESS;
}
static test_return mget_read(memcached_st *memc)
}
}
- return 0;
+ return TEST_SUCCESS;
}
static test_return mget_read_result(memcached_st *memc)
memcached_result_free(&results_obj);
}
- return 0;
+ return TEST_SUCCESS;
}
static test_return mget_read_function(memcached_st *memc)
counter= 0;
rc= memcached_fetch_execute(memc, callbacks, (void *)&counter, 1);
- return 0;
+ return TEST_SUCCESS;
}
static test_return delete_generate(memcached_st *memc)
(void)memcached_delete(memc, global_keys[x], global_keys_length[x], (time_t)0);
}
- return 0;
+ return TEST_SUCCESS;
}
static test_return delete_buffer_generate(memcached_st *memc)
(void)memcached_delete(memc, global_keys[x], global_keys_length[x], (time_t)0);
}
- return 0;
+ return TEST_SUCCESS;
}
static test_return add_host_test1(memcached_st *memc)
memcached_server_list_free(servers);
- return 0;
+ return TEST_SUCCESS;
}
static memcached_return pre_nonblock(memcached_st *memc)
return TEST_SUCCESS;
}
+static test_return regression_bug_434843(memcached_st *memc)
+{
+ if (pre_binary(memc) != TEST_SUCCESS)
+ return TEST_SUCCESS;
+
+ memcached_return rc;
+ unsigned int counter= 0;
+ memcached_execute_function callbacks[1]= { [0]= &callback_counter };
+
+ /*
+ * I only want to hit only _one_ server so I know the number of requests I'm
+ * sending in the pipleine to the server. Let's try to do a multiget of
+ * 10240 (that should satisfy most users don't you tink?)
+ */
+ uint32_t number_of_hosts= memc->number_of_hosts;
+ memc->number_of_hosts= 1;
+ const size_t max_keys= 10240;
+ char **keys= calloc(max_keys, sizeof(char*));
+ size_t *key_length=calloc(max_keys, sizeof(size_t));
+
+ for (int x= 0; x < (int)max_keys; ++x)
+ {
+ char k[251];
+ key_length[x]= (size_t)snprintf(k, sizeof(k), "0200%u", x);
+ keys[x]= strdup(k);
+ assert(keys[x] != NULL);
+ }
+
+ /*
+ * Run two times.. the first time we should have 100% cache miss,
+ * and the second time we should have 100% cache hits
+ */
+ for (int y= 0; y < 2; ++y)
+ {
+ rc= memcached_mget(memc, (const char**)keys, key_length, max_keys);
+ assert(rc == MEMCACHED_SUCCESS);
+ rc= memcached_fetch_execute(memc, callbacks, (void *)&counter, 1);
+ if (y == 0)
+ {
+ /* The first iteration should give me a 100% cache miss. verify that*/
+ assert(counter == 0);
+ char blob[1024];
+ for (int x= 0; x < (int)max_keys; ++x)
+ {
+ rc= memcached_add(memc, keys[x], key_length[x],
+ blob, sizeof(blob), 0, 0);
+ assert(rc == MEMCACHED_SUCCESS || rc == MEMCACHED_BUFFERED);
+ }
+ }
+ else
+ {
+ /* Verify that we received all of the key/value pairs */
+ assert(counter == (unsigned int)max_keys);
+ }
+ }
+
+ /* Release allocated resources */
+ for (size_t x= 0; x < max_keys; ++x)
+ free(keys[x]);
+ free(keys);
+ free(key_length);
+
+ memc->number_of_hosts= number_of_hosts;
+ return TEST_SUCCESS;
+}
+
+static test_return regression_bug_434843_buffered(memcached_st *memc)
+{
+ memcached_return rc;
+ rc= memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_BUFFER_REQUESTS, 1);
+ assert(rc == MEMCACHED_SUCCESS);
+
+ return regression_bug_434843(memc);
+}
+
+static test_return regression_bug_421108(memcached_st *memc)
+{
+ memcached_return rc;
+ memcached_stat_st *memc_stat= memcached_stat(memc, NULL, &rc);
+ assert(rc == MEMCACHED_SUCCESS);
+
+ char *bytes= memcached_stat_get_value(memc, memc_stat, "bytes", &rc);
+ assert(rc == MEMCACHED_SUCCESS);
+ assert(bytes != NULL);
+ char *bytes_read= memcached_stat_get_value(memc, memc_stat,
+ "bytes_read", &rc);
+ assert(rc == MEMCACHED_SUCCESS);
+ assert(bytes_read != NULL);
+
+ char *bytes_written= memcached_stat_get_value(memc, memc_stat,
+ "bytes_written", &rc);
+ assert(rc == MEMCACHED_SUCCESS);
+ assert(bytes_written != NULL);
+
+ assert(strcmp(bytes, bytes_read) != 0);
+ assert(strcmp(bytes, bytes_written) != 0);
+
+ /* Release allocated resources */
+ free(bytes);
+ free(bytes_read);
+ free(bytes_written);
+ memcached_stat_free(NULL, memc_stat);
+ return TEST_SUCCESS;
+}
+
test_st udp_setup_server_tests[] ={
{"set_udp_behavior_test", 0, set_udp_behavior_test},
{"add_tcp_server_udp_client_test", 0, add_tcp_server_udp_client_test},
*/
test_st regression_tests[]= {
{"lp:434484", 1, regression_bug_434484 },
+ {"lp:434843", 1, regression_bug_434843 },
+ {"lp:434843 buffered", 1, regression_bug_434843_buffered },
+ {"lp:421108", 1, regression_bug_421108 },
{0, 0, 0}
};