#include <config.h>
#include <libtest/test.hpp>
+#if defined(HAVE_LIBUUID) && HAVE_LIBUUID
+#include <uuid/uuid.h>
+#endif
+
/*
Test cases
*/
#include <libtest/server.h>
#include "clients/generator.h"
-#include "clients/execute.h"
#define SMALL_STRING_LEN 1024
#include "tests/ketama.h"
#include "tests/namespace.h"
#include "tests/parser.h"
+#include "tests/libmemcached-1.0/callback_counter.h"
+#include "tests/libmemcached-1.0/dump.h"
+#include "tests/libmemcached-1.0/fetch_all_results.h"
+#include "tests/libmemcached-1.0/generate.h"
+#include "tests/libmemcached-1.0/haldenbrand.h"
+#include "tests/libmemcached-1.0/stat.h"
#include "tests/touch.h"
#include "tests/callbacks.h"
#include "tests/pool.h"
#include "tests/hash_results.h"
-#define GLOBAL_COUNT 10000
-#define GLOBAL2_COUNT 100
-#define SERVERS_TO_CREATE 5
-static uint32_t global_count= GLOBAL2_COUNT;
+#include "tests/libmemcached-1.0/servers_to_create.h"
-static pairs_st *global_pairs;
-static const char *global_keys[GLOBAL_COUNT];
-static size_t global_keys_length[GLOBAL_COUNT];
+#define UUID_STRING_MAXLENGTH 36
+
+struct keys_st {
+public:
+ keys_st(size_t arg)
+ {
+ init(arg, UUID_STRING_MAXLENGTH);
+ }
+
+ keys_st(size_t arg, size_t padding)
+ {
+ init(arg, padding);
+ }
+
+ void init(size_t arg, size_t padding)
+ {
+ _lengths.resize(arg);
+ _keys.resize(arg);
+
+ for (size_t x= 0; x < _keys.size(); x++)
+ {
+ libtest::vchar_t key_buffer;
+ key_buffer.resize(padding +1);
+ memset(&key_buffer[0], 'x', padding);
+
+ if (HAVE_LIBUUID)
+ {
+ uuid_t out;
+ uuid_generate(out);
+
+ uuid_unparse(out, &key_buffer[0]);
+ _keys[x]= strdup(&key_buffer[0]);
+ (_keys[x])[UUID_STRING_MAXLENGTH]= 'x';
+ }
+ else // We just use a number and pad the string if UUID is not available
+ {
+ char int_buffer[MEMCACHED_MAXIMUM_INTEGER_DISPLAY_LENGTH +1];
+ int key_length= snprintf(int_buffer, sizeof(int_buffer), "%u", uint32_t(x));
+ memcpy(&key_buffer[0], int_buffer, key_length);
+ _keys[x]= strdup(&key_buffer[0]);
+ }
+ _lengths[x]= padding;
+ }
+ }
+
+ ~keys_st()
+ {
+ for (libtest::vchar_ptr_t::iterator iter= _keys.begin();
+ iter != _keys.end();
+ iter++)
+ {
+ ::free(*iter);
+ }
+ }
+
+ libtest::vchar_ptr_t::iterator begin()
+ {
+ return _keys.begin();
+ }
+
+ libtest::vchar_ptr_t::iterator end()
+ {
+ return _keys.end();
+ }
+
+ size_t size() const
+ {
+ return _keys.size();
+ }
+
+ std::vector<size_t>& lengths()
+ {
+ return _lengths;
+ }
+
+ libtest::vchar_ptr_t& keys()
+ {
+ return _keys;
+ }
+
+ size_t* lengths_ptr()
+ {
+ return &_lengths[0];
+ }
+
+ char** keys_ptr()
+ {
+ return &_keys[0];
+ }
+
+ char* key_at(size_t arg)
+ {
+ return _keys[arg];
+ }
+
+ size_t length_at(size_t arg)
+ {
+ return _lengths[arg];
+ }
+
+private:
+ libtest::vchar_ptr_t _keys;
+ std::vector<size_t> _lengths;
+};
/**
@note This should be testing to see if the server really supports the binary protocol.
{
test_true(libmemcached_string_behavior(memcached_behavior_t(x)));
}
- test_compare(36, int(MEMCACHED_BEHAVIOR_MAX));
+ test_compare(37, int(MEMCACHED_BEHAVIOR_MAX));
return TEST_SUCCESS;
}
{
uint32_t values[] = { 851992627U, 2337886783U, 4109241422U, 4001849190U,
982370485U, 1263635348U, 4242906218U, 3829656100U,
- 1891735253U, 334139633U, 2257084983U, 3088286104U,
+ 1891735253U, 334139633U, 2257084983U, 3351789013U,
13199785U, 2542027183U, 1097051614U, 199566778U,
2748246961U, 2465192557U, 1664094137U, 2405439045U,
1842224848U, 692413798U, 3479807801U, 919913813U,
return TEST_SUCCESS;
}
+static test_return_t memcached_mget_mixed_memcached_get_TEST(memcached_st *memc)
+{
+ keys_st keys(200);
+
+ for (libtest::vchar_ptr_t::iterator iter= keys.begin();
+ iter != keys.end();
+ iter++)
+ {
+ test_compare(MEMCACHED_SUCCESS,
+ memcached_set(memc,
+ (*iter), 36,
+ NULL, 0,
+ time_t(0), uint32_t(0)));
+ }
+
+ for (size_t loop= 0; loop < 20; loop++)
+ {
+ if (random() %2)
+ {
+ test_compare(MEMCACHED_SUCCESS,
+ memcached_mget(memc, keys.keys_ptr(), keys.lengths_ptr(), keys.size()));
+
+ memcached_result_st *results= memcached_result_create(memc, NULL);
+ test_true(results);
+
+ size_t result_count= 0;
+ memcached_return_t rc;
+ while (memcached_fetch_result(memc, results, &rc))
+ {
+ result_count++;
+ }
+ test_compare(keys.size(), result_count);
+ }
+ else
+ {
+ int which_key= random() %keys.size();
+ size_t value_length;
+ uint32_t flags;
+ memcached_return_t rc;
+ char *out_value= memcached_get(memc, keys.key_at(which_key), keys.length_at(which_key),
+ &value_length, &flags, &rc);
+ test_compare(MEMCACHED_SUCCESS, rc);
+ test_null(out_value);
+ test_zero(value_length);
+ test_zero(flags);
+ }
+ }
+
+ return TEST_SUCCESS;
+}
+
static test_return_t cas2_test(memcached_st *memc)
{
const char *keys[]= {"fudge", "son", "food"};
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 (not memcached_behavior_get(memc_clone, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL))
+ if (memcached_behavior_get(memc_clone, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL) == false)
{
uint64_t before_query_id= memcached_query_id(memc_clone);
{
test_compare(query_id +1, memcached_query_id(memc_clone));
query_id= memcached_query_id(memc_clone);
- test_compare(MEMCACHED_BAD_KEY_PROVIDED,
+ // 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));
test_compare(MEMCACHED_SUCCESS,
memcached_callback_set(memc_clone, MEMCACHED_CALLBACK_NAMESPACE, NULL));
- std::vector <char> longkey;
+ libtest::vchar_t longkey;
{
- std::vector<char>::iterator it= longkey.begin();
+ libtest::vchar_t::iterator it= longkey.begin();
longkey.insert(it, MEMCACHED_MAX_KEY, 'a');
}
{
size_t value_length= 8191;
- std::vector<char> value;
+ libtest::vchar_t value;
value.reserve(value_length);
for (uint32_t x= 0; x < value_length; x++)
{
{
size_t value_length= 8191;
- std::vector<char> value;
+ libtest::vchar_t value;
value.reserve(value_length);
for (uint32_t x= 0; x < value_length; x++)
{
{
size_t value_length= 8191;
- std::vector<char> value;
+ libtest::vchar_t value;
value.reserve(value_length);
for (uint32_t x= 0; x < value_length; x++)
{
return TEST_SUCCESS;
}
-static test_return_t binary_increment_with_prefix_test(memcached_st *orig_memc)
+static test_return_t binary_increment_with_prefix_test(memcached_st *memc)
{
- memcached_st *memc= memcached_clone(NULL, orig_memc);
-
- test_skip(TEST_SUCCESS, pre_binary(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_literal_param("number"),
1, &new_number));
test_compare(uint64_t(2), new_number);
- memcached_free(memc);
return TEST_SUCCESS;
}
return TEST_SUCCESS;
}
-/* Count the results */
-static memcached_return_t callback_counter(const memcached_st*, memcached_result_st*, void *context)
-{
- size_t *counter= (size_t *)context;
-
- *counter= *counter + 1;
-
- return MEMCACHED_SUCCESS;
-}
-
static test_return_t mget_result_function(memcached_st *memc)
{
const char *keys[]= {"fudge", "son", "food"};
memcached_st *memc= create_single_instance_memcached(original_memc, "--BINARY-PROTOCOL");
test_true(memc);
- size_t max_keys= 20480;
-
-
- char **keys= static_cast<char **>(calloc(max_keys, sizeof(char*)));
- size_t *key_length=static_cast<size_t *>(calloc(max_keys, sizeof(size_t)));
+ keys_st keys(20480);
/* First add all of the items.. */
char blob[1024] = {0};
- for (size_t x= 0; x < max_keys; ++x)
+ for (size_t x= 0; x < keys.size(); ++x)
{
- char k[251];
-
- key_length[x]= (size_t)snprintf(k, sizeof(k), "0200%lu", (unsigned long)x);
- keys[x]= strdup(k);
- test_true(keys[x] != NULL);
uint64_t query_id= memcached_query_id(memc);
- 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));
+ 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_strerror(NULL, rc));
test_compare(query_id +1, memcached_query_id(memc));
}
size_t counter= 0;
memcached_execute_fn callbacks[]= { &callback_counter };
test_compare(MEMCACHED_SUCCESS,
- memcached_mget_execute(memc, (const char**)keys, key_length,
- max_keys, callbacks, &counter, 1));
+ 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(query_id, memcached_query_id(memc));
/* Verify that we got all of the items */
- test_true(counter == max_keys);
- }
-
- /* Release all allocated resources */
- for (size_t x= 0; x < max_keys; ++x)
- {
- free(keys[x]);
+ test_compare(keys.size(), counter);
}
- free(keys);
- free(key_length);
memcached_free(memc);
}
#define REGRESSION_BINARY_VS_BLOCK_COUNT 20480
+static pairs_st *global_pairs;
static test_return_t key_setup(memcached_st *memc)
{
return TEST_SUCCESS;
}
-static test_return_t key_teardown(memcached_st *memc)
+static test_return_t key_teardown(memcached_st *)
{
- (void)memc;
pairs_free(global_pairs);
return TEST_SUCCESS;
return TEST_SUCCESS;
}
-static test_return_t fetch_all_results(memcached_st *memc, unsigned int &keys_returned, memcached_return_t& rc)
-{
- keys_returned= 0;
-
- memcached_result_st* result;
- while ((result= memcached_fetch_result(memc, NULL, &rc)))
- {
- test_compare(MEMCACHED_SUCCESS, rc);
- keys_returned+= 1;
- }
-
- return TEST_SUCCESS;
-}
-
-static test_return_t fetch_all_results(memcached_st *memc, unsigned int &keys_returned)
-{
- memcached_return_t rc;
- return fetch_all_results(memc, keys_returned, rc);
-}
-
-/* Test case provided by Cal Haldenbrand */
-#define HALDENBRAND_KEY_COUNT 3000U // * 1024576
-#define HALDENBRAND_FLAG_KEY 99 // * 1024576
-static test_return_t user_supplied_bug1(memcached_st *memc)
-{
- /* We just keep looking at the same values over and over */
- srandom(10);
-
- test_compare(MEMCACHED_SUCCESS,
- memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_NO_BLOCK, true));
- test_compare(MEMCACHED_SUCCESS,
- memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_TCP_NODELAY, true));
-
-
- /* add key */
- unsigned long long total= 0;
- for (uint32_t x= 0 ; total < 20 * 1024576 ; x++ )
- {
- uint32_t size= (uint32_t)(rand() % ( 5 * 1024 ) ) + 400;
- char randomstuff[6 * 1024];
- memset(randomstuff, 0, 6 * 1024);
- test_true(size < 6 * 1024); /* Being safe here */
-
- for (uint32_t j= 0 ; j < size ;j++)
- {
- randomstuff[j] = (signed char) ((rand() % 26) + 97);
- }
-
- total+= size;
- char key[MEMCACHED_MAXIMUM_INTEGER_DISPLAY_LENGTH +1];
- int key_length= snprintf(key, sizeof(key), "%u", x);
- test_compare(MEMCACHED_SUCCESS,
- memcached_set(memc, key, key_length,
- randomstuff, strlen(randomstuff),
- time_t(0), HALDENBRAND_FLAG_KEY));
- }
- test_true(total > HALDENBRAND_KEY_COUNT);
-
- return TEST_SUCCESS;
-}
-
-/* Test case provided by Cal Haldenbrand */
-static test_return_t user_supplied_bug2(memcached_st *memc)
-{
- test_compare(MEMCACHED_SUCCESS,
- memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_NO_BLOCK, true));
-
- test_compare(MEMCACHED_SUCCESS,
- memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_TCP_NODELAY, true));
-
-#ifdef NOT_YET
- 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);
-
- for (x= 0, errors= 0; total < 20 * 1024576 ; x++)
-#endif
-
- size_t total_value_length= 0;
- for (uint32_t x= 0, errors= 0; total_value_length < 24576 ; x++)
- {
- uint32_t flags= 0;
- size_t val_len= 0;
-
- char key[MEMCACHED_MAXIMUM_INTEGER_DISPLAY_LENGTH +1];
- int key_length= snprintf(key, sizeof(key), "%u", x);
-
- memcached_return_t rc;
- char *getval= memcached_get(memc, key, key_length, &val_len, &flags, &rc);
- if (memcached_failed(rc))
- {
- if (rc == MEMCACHED_NOTFOUND)
- {
- errors++;
- }
- else
- {
- test_true(rc);
- }
-
- continue;
- }
- test_compare(uint32_t(HALDENBRAND_FLAG_KEY), flags);
- test_true(getval);
-
- total_value_length+= val_len;
- errors= 0;
- ::free(getval);
- }
-
- return TEST_SUCCESS;
-}
-
-/* Do a large mget() over all the keys we think exist */
-static test_return_t user_supplied_bug3(memcached_st *memc)
-{
- test_compare(MEMCACHED_SUCCESS, memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_NO_BLOCK, true));
- test_compare(MEMCACHED_SUCCESS, memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_TCP_NODELAY, true));
-
-#ifdef NOT_YET
- 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
-
- std::vector<size_t> key_lengths;
- key_lengths.resize(HALDENBRAND_KEY_COUNT);
- std::vector<char *> 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 > 0 and key_length < MEMCACHED_MAXIMUM_INTEGER_DISPLAY_LENGTH +1);
- keys[x]= strdup(key);
- key_lengths[x]= key_length;
- }
-
- test_compare(MEMCACHED_SUCCESS,
- 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));
- test_compare(HALDENBRAND_KEY_COUNT, keys_returned);
-
- for (std::vector<char *>::iterator iter= keys.begin();
- iter != keys.end();
- iter++)
- {
- ::free(*iter);
- }
-
- return TEST_SUCCESS;
-}
-
/* Make sure we behave properly if server list has no values */
static test_return_t user_supplied_bug4(memcached_st *memc)
{
memcached_behavior_set(mclone, MEMCACHED_BEHAVIOR_TCP_NODELAY, set);
memcached_behavior_set(mclone, MEMCACHED_BEHAVIOR_POLL_TIMEOUT, uint64_t(0));
- std::vector<char> value;
+ libtest::vchar_t value;
value.reserve(value_length);
for (uint32_t x= 0; x < value_length; x++)
{
test_compare(-1, int32_t(memcached_behavior_get(mclone, MEMCACHED_BEHAVIOR_POLL_TIMEOUT)));
- std::vector<char> value;
+ libtest::vchar_t value;
value.reserve(512);
for (unsigned int x= 0; x < 512; x++)
{
static test_return_t user_supplied_bug13(memcached_st *memc)
{
char key[] = "key34567890";
- memcached_return_t rc;
- size_t overflowSize;
char commandFirst[]= "set key34567890 0 0 ";
char commandLast[] = " \r\n"; /* first line of command sent to server */
size_t commandLength;
- size_t testSize;
commandLength = strlen(commandFirst) + strlen(commandLast) + 4; /* 4 is number of characters in size, probably 8196 */
- overflowSize = MEMCACHED_MAX_BUFFER - commandLength;
+ size_t overflowSize = MEMCACHED_MAX_BUFFER - commandLength;
- for (testSize= overflowSize - 1; testSize < overflowSize + 1; testSize++)
+ for (size_t testSize= overflowSize - 1; testSize < overflowSize + 1; testSize++)
{
char *overflow= new (std::nothrow) char[testSize];
test_true(overflow);
memset(overflow, 'x', testSize);
- rc= memcached_set(memc, key, strlen(key),
- overflow, testSize, 0, 0);
- test_compare(MEMCACHED_SUCCESS, rc);
+ test_compare(MEMCACHED_SUCCESS,
+ memcached_set(memc, key, strlen(key),
+ overflow, testSize, 0, 0));
delete [] overflow;
}
{
memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_TCP_NODELAY, true);
- std::vector<char> value;
+ libtest::vchar_t value;
value.reserve(18000);
for (size_t x= 0; x < 18000; x++)
{
&length, &flags, &rc);
test_compare(MEMCACHED_SUCCESS, rc);
- test_true(value == NULL);
+ test_null(value);
test_zero(length);
test_zero(flags);
}
/* empty the cache to ensure misses (hence non-responses) */
test_compare(MEMCACHED_SUCCESS, memcached_flush(memc_clone, 0));
- std::vector<size_t> key_lengths;
- key_lengths.resize(key_count);
- std::vector<char *> keys;
- keys.resize(key_lengths.size());
- for (unsigned int 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 > 0 and key_length < MEMCACHED_MAXIMUM_INTEGER_DISPLAY_LENGTH +1);
- keys[x]= strdup(key);
- key_lengths[x]= key_length;
- }
+ keys_st keys(key_count);
oldalarm= signal(SIGALRM, fail);
alarm(5);
test_compare_got(MEMCACHED_SUCCESS,
- memcached_mget(memc_clone, &keys[0], &key_lengths[0], key_count), memcached_last_error_message(memc_clone));
+ memcached_mget(memc_clone, keys.keys_ptr(), keys.lengths_ptr(), keys.size()),
+ memcached_last_error_message(memc_clone));
alarm(0);
signal(SIGALRM, oldalarm);
test_false(return_key[0]);
test_false(return_value);
- for (std::vector<char *>::iterator iter= keys.begin();
- iter != keys.end();
- iter++)
- {
- free(*iter);
- }
-
memcached_free(memc_clone);
return TEST_SUCCESS;
return TEST_SUCCESS;
}
-static test_return_t cleanup_pairs(memcached_st *memc)
-{
- (void)memc;
- pairs_free(global_pairs);
-
- return TEST_SUCCESS;
-}
-
-static test_return_t generate_pairs(memcached_st *)
-{
- global_pairs= pairs_generate(GLOBAL_COUNT, 400);
- global_count= GLOBAL_COUNT;
-
- for (size_t x= 0; x < global_count; x++)
- {
- global_keys[x]= global_pairs[x].key;
- global_keys_length[x]= global_pairs[x].key_length;
- }
-
- return TEST_SUCCESS;
-}
-
-static test_return_t generate_large_pairs(memcached_st *)
-{
- global_pairs= pairs_generate(GLOBAL2_COUNT, MEMCACHED_MAX_BUFFER+10);
- global_count= GLOBAL2_COUNT;
-
- for (size_t x= 0; x < global_count; x++)
- {
- global_keys[x]= global_pairs[x].key;
- global_keys_length[x]= global_pairs[x].key_length;
- }
-
- return TEST_SUCCESS;
-}
-
-static test_return_t generate_data(memcached_st *memc)
-{
- unsigned int check_execute= execute_set(memc, global_pairs, global_count);
-
- test_compare_warn_hint(global_count, check_execute, "Possible false, positive, memcached may have ejected key/value based on memory needs");
-
- return TEST_SUCCESS;
-}
-
-static test_return_t generate_data_with_stats(memcached_st *memc)
-{
- unsigned int check_execute= execute_set(memc, global_pairs, 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 (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)
- {
- memcached_server_instance_st instance=
- memcached_server_instance_by_position(memc, host_index);
-
- printf("\nserver %u|%s|%u bytes: %llu\n", host_index, instance->hostname, instance->port, (unsigned long long)(stat_p + host_index)->bytes);
- }
- test_true((unsigned long long)(stat_p + host_index)->bytes);
- }
-
- memcached_stat_free(NULL, stat_p);
-
- return TEST_SUCCESS;
-}
-static test_return_t generate_buffer_data(memcached_st *memc)
-{
- memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_BUFFER_REQUESTS, true);
- generate_data(memc);
-
- return TEST_SUCCESS;
-}
-
-static test_return_t get_read_count(memcached_st *memc)
-{
- memcached_st *memc_clone= memcached_clone(NULL, memc);
- test_true(memc_clone);
-
- memcached_server_add_with_weight(memc_clone, "localhost", 6666, 0);
-
- {
- char *return_value;
- size_t return_value_length;
- uint32_t flags;
- uint32_t count;
-
- for (size_t x= count= 0; x < global_count; x++)
- {
- memcached_return_t rc;
- return_value= memcached_get(memc_clone, global_keys[x], global_keys_length[x],
- &return_value_length, &flags, &rc);
- if (rc == MEMCACHED_SUCCESS)
- {
- count++;
- if (return_value)
- {
- free(return_value);
- }
- }
- }
- }
-
- memcached_free(memc_clone);
-
- return TEST_SUCCESS;
-}
-
-static test_return_t get_read(memcached_st *memc)
-{
- size_t keys_returned= 0;
- for (size_t x= 0; x < global_count; x++)
- {
- size_t return_value_length;
- uint32_t flags;
- memcached_return_t rc;
- char *return_value= memcached_get(memc, global_keys[x], global_keys_length[x],
- &return_value_length, &flags, &rc);
- /*
- test_true(return_value);
- test_compare(MEMCACHED_SUCCESS, rc);
- */
- if (rc == MEMCACHED_SUCCESS && return_value)
- {
- keys_returned++;
- free(return_value);
- }
- }
- test_compare_warn_hint(global_count, keys_returned, "Possible false, positive, memcached may have ejected key/value based on memory needs");
-
- return TEST_SUCCESS;
-}
-
-static test_return_t mget_read(memcached_st *memc)
-{
-
- test_skip(true, bool(libmemcached_util_version_check(memc, 1, 4, 4)));
-
- test_compare(MEMCACHED_SUCCESS,
- memcached_mget(memc, global_keys, global_keys_length, global_count));
-
- // Go fetch the keys and test to see if all of them were returned
- {
- unsigned int keys_returned;
- test_compare(TEST_SUCCESS, fetch_all_results(memc, keys_returned));
- test_true(keys_returned > 0);
- test_compare_warn_hint(global_count, keys_returned, "Possible false, positive, memcached may have ejected key/value based on memory needs");
- }
-
- return TEST_SUCCESS;
-}
-
-static test_return_t mget_read_result(memcached_st *memc)
-{
-
- test_skip(true, bool(libmemcached_util_version_check(memc, 1, 4, 4)));
-
- test_compare(MEMCACHED_SUCCESS,
- memcached_mget(memc, global_keys, global_keys_length, global_count));
-
- /* Turn this into a help function */
- {
- memcached_result_st results_obj;
- memcached_result_st *results= memcached_result_create(memc, &results_obj);
- test_true(results);
-
- memcached_return_t rc;
- while ((results= memcached_fetch_result(memc, &results_obj, &rc)))
- {
- if (rc == MEMCACHED_IN_PROGRESS)
- {
- continue;
- }
-
- test_true(results);
- test_compare(MEMCACHED_SUCCESS, rc);
- }
- test_compare(MEMCACHED_END, rc);
-
- memcached_result_free(&results_obj);
- }
-
- return TEST_SUCCESS;
-}
-
-static test_return_t mget_read_internal_result(memcached_st *memc)
-{
-
- test_skip(true, bool(libmemcached_util_version_check(memc, 1, 4, 4)));
-
- test_compare(MEMCACHED_SUCCESS,
- memcached_mget(memc, global_keys, global_keys_length, global_count));
- {
- memcached_result_st *results= NULL;
- memcached_return_t rc;
- while ((results= memcached_fetch_result(memc, results, &rc)))
- {
- test_true(results);
- test_compare(MEMCACHED_SUCCESS, rc);
- }
- test_compare(MEMCACHED_END, rc);
-
- memcached_result_free(results);
- }
-
- return TEST_SUCCESS;
-}
-
-static test_return_t mget_read_partial_result(memcached_st *memc)
-{
-
- test_skip(true, bool(libmemcached_util_version_check(memc, 1, 4, 4)));
-
- test_compare(MEMCACHED_SUCCESS,
- memcached_mget(memc, global_keys, global_keys_length, global_count));
-
- // We will scan for just one key
- {
- memcached_result_st results_obj;
- memcached_result_st *results= memcached_result_create(memc, &results_obj);
-
- memcached_return_t rc;
- results= memcached_fetch_result(memc, results, &rc);
- test_true(results);
- test_compare(MEMCACHED_SUCCESS, rc);
-
- memcached_result_free(&results_obj);
- }
-
- // We already have a read happening, lets start up another one.
- test_compare(MEMCACHED_SUCCESS,
- memcached_mget(memc, global_keys, global_keys_length, global_count));
- {
- memcached_result_st results_obj;
- memcached_result_st *results= memcached_result_create(memc, &results_obj);
- test_true(results);
- test_false(memcached_is_allocated(results));
-
- memcached_return_t rc;
- while ((results= memcached_fetch_result(memc, &results_obj, &rc)))
- {
- test_true(results);
- test_compare(MEMCACHED_SUCCESS, rc);
- }
- test_compare(MEMCACHED_END, rc);
-
- memcached_result_free(&results_obj);
- }
-
- return TEST_SUCCESS;
-}
-
-static test_return_t mget_read_function(memcached_st *memc)
-{
- test_skip(true, bool(libmemcached_util_version_check(memc, 1, 4, 4)));
-
- test_compare(MEMCACHED_SUCCESS,
- memcached_mget(memc, global_keys, global_keys_length, global_count));
-
- memcached_execute_fn callbacks[]= { &callback_counter };
- size_t counter= 0;
- test_compare(MEMCACHED_SUCCESS,
- memcached_fetch_execute(memc, callbacks, (void *)&counter, 1));
-
- return TEST_SUCCESS;
-}
-
-static test_return_t delete_generate(memcached_st *memc)
-{
- size_t total= 0;
- for (size_t x= 0; x < global_count; x++)
- {
- if (memcached_success(memcached_delete(memc, global_keys[x], global_keys_length[x], (time_t)0)))
- {
- total++;
- }
- }
- test_compare_warn_hint(global_count, total, "Possible false, positive, memcached may have ejected key/value based on memory needs");
-
- return TEST_SUCCESS;
-}
-
-static test_return_t delete_buffer_generate(memcached_st *memc)
-{
- memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_BUFFER_REQUESTS, true);
-
- size_t total= 0;
- for (size_t x= 0; x < global_count; x++)
- {
- if (memcached_success(memcached_delete(memc, global_keys[x], global_keys_length[x], (time_t)0)))
- {
- total++;
- }
- }
- test_compare_warn_hint(global_count, total, "Possible false, positive, memcached may have ejected key/value based on memory needs");
-
- return TEST_SUCCESS;
-}
static test_return_t add_host_test1(memcached_st *memc)
{
void *test_ptr= NULL;
void *cb_ptr= NULL;
{
- memcached_malloc_fn malloc_cb=
- (memcached_malloc_fn)my_malloc;
+ memcached_malloc_fn malloc_cb= (memcached_malloc_fn)my_malloc;
cb_ptr= *(void **)&malloc_cb;
memcached_return_t rc;
{
for (size_t x= 0; x < 100; ++x)
{
- char key[10];
+ char key[MEMCACHED_MAXIMUM_INTEGER_DISPLAY_LENGTH +1];
int check_length= (size_t)snprintf(key, sizeof(key), "%lu", (unsigned long)x);
test_false((size_t)check_length >= sizeof(key) || check_length < 0);
test_true(count);
break;
}
- test_true_got(ret == MEMCACHED_SUCCESS or ret == MEMCACHED_BUFFERED, memcached_strerror(NULL, ret));
+ test_true_got(ret == MEMCACHED_SUCCESS or ret == MEMCACHED_BUFFERED,
+ memcached_strerror(NULL, ret));
}
/*
** API and is _ONLY_ done this way to verify that the library works the
** way it is supposed to do!!!!
*/
+#if 0
int no_msg=0;
for (uint32_t x= 0; x < memcached_server_count(memc); ++x)
{
}
test_true(no_msg == 0);
+#endif
test_compare(MEMCACHED_SUCCESS, memcached_flush_buffers(memc));
/*
static test_return_t analyzer_test(memcached_st *memc)
{
- memcached_return_t rc;
memcached_analysis_st *report;
+ memcached_return_t rc;
memcached_stat_st *memc_stat= memcached_stat(memc, NULL, &rc);
test_compare(MEMCACHED_SUCCESS, rc);
return TEST_SUCCESS;
}
-/* Count the objects */
-
-static test_return_t dump_test(memcached_st *memc)
-{
- /* No support for Binary protocol yet */
- test_skip(false, memc->flags.binary_protocol);
-
- test_compare(TEST_SUCCESS, set_test3(memc));
-
- // confirm_key_count() call dump
- size_t counter= confirm_key_count(memc);
-
- /* We may have more then 32 if our previous flush has not completed */
- test_true(counter >= 32);
-
- return TEST_SUCCESS;
-}
-
static test_return_t util_version_test(memcached_st *memc)
{
test_compare_hint(MEMCACHED_SUCCESS, memcached_version(memc), memcached_last_error_message(memc));
test_compare(MEMCACHED_SUCCESS,
memcached_mget(memc, (const char**)keys, key_length, max_keys));
+ // One the first run we should get a NOT_FOUND, but on the second some data
+ // should be returned.
test_compare(y ? MEMCACHED_SUCCESS : MEMCACHED_NOTFOUND,
memcached_fetch_execute(memc, callbacks, (void *)&counter, 1));
test_true(rc == MEMCACHED_SUCCESS || rc == MEMCACHED_BUFFERED);
}
- (void)snprintf(k, sizeof(k), "%037u", 251U);
- len= strlen(k);
+ len= snprintf(k, sizeof(k), "%037u", 251U);
memcached_return_t rc= memcached_delete(memc, k, len, 0);
test_true(rc == MEMCACHED_SUCCESS || rc == MEMCACHED_BUFFERED);
static test_return_t regression_bug_463297(memcached_st *memc)
{
+ test_compare(MEMCACHED_INVALID_ARGUMENTS, memcached_delete(memc, "foo", 3, 1));
+
+ // Since we blocked timed delete, this test is no longer valid.
+#if 0
memcached_st *memc_clone= memcached_clone(NULL, memc);
test_true(memc_clone);
test_true(memcached_version(memc_clone) == MEMCACHED_SUCCESS);
}
memcached_free(memc_clone);
+#endif
+
return TEST_SUCCESS;
}
test_true(keys[x]);
memcached_return rc= memcached_set(memc, keys[x], key_length[x], blob, sizeof(blob), 0, 0);
- test_true(rc == MEMCACHED_SUCCESS or rc == MEMCACHED_BUFFERED);
+ test_true_got(rc == MEMCACHED_SUCCESS or rc == MEMCACHED_BUFFERED, memcached_last_error_message(memc));
}
for (uint32_t x= 0; x < regression_bug_490520_COUNT; ++x)
{"connection_test", false, (test_callback_fn*)connection_test},
{"callback_test", false, (test_callback_fn*)callback_test},
{"userdata_test", false, (test_callback_fn*)userdata_test},
- {"set", false, (test_callback_fn*)set_test },
- {"set2", false, (test_callback_fn*)set_test2 },
- {"set3", false, (test_callback_fn*)set_test3 },
- {"dump", true, (test_callback_fn*)dump_test},
+ {"memcached_set()", false, (test_callback_fn*)set_test },
+ {"memcached_set() 2", false, (test_callback_fn*)set_test2 },
+ {"memcached_set() 3", false, (test_callback_fn*)set_test3 },
{"add", true, (test_callback_fn*)add_test },
{"memcached_fetch_result(MEMCACHED_NOTFOUND)", true, (test_callback_fn*)memcached_fetch_result_NOT_FOUND },
{"replace", true, (test_callback_fn*)replace_test },
{"increment_with_initial_by_key", true, (test_callback_fn*)increment_with_initial_by_key_test },
{"decrement_by_key", false, (test_callback_fn*)decrement_by_key_test },
{"decrement_with_initial_by_key", true, (test_callback_fn*)decrement_with_initial_by_key_test },
- {"binary_increment_with_prefix", 1, (test_callback_fn*)binary_increment_with_prefix_test },
+ {"binary_increment_with_prefix", true, (test_callback_fn*)binary_increment_with_prefix_test },
{"quit", false, (test_callback_fn*)quit_test },
{"mget", true, (test_callback_fn*)mget_test },
{"mget_result", true, (test_callback_fn*)mget_result_test },
{"add_host_test", false, (test_callback_fn*)add_host_test },
{"add_host_test_1", false, (test_callback_fn*)add_host_test1 },
{"get_stats_keys", false, (test_callback_fn*)get_stats_keys },
- {"version_string_test", false, (test_callback_fn*)version_string_test},
+ {"version_string_test", true, (test_callback_fn*)version_string_test},
+ {"memcached_mget() mixed memcached_get()", true, (test_callback_fn*)memcached_mget_mixed_memcached_get_TEST},
{"bad_key", true, (test_callback_fn*)bad_key_test },
{"memcached_server_cursor", true, (test_callback_fn*)memcached_server_cursor_test },
{"read_through", true, (test_callback_fn*)read_through },
{"memcached_exist_by_key(MEMCACHED_SUCCESS)", true, (test_callback_fn*)memcached_exist_by_key_SUCCESS },
{"memcached_touch", 0, (test_callback_fn*)test_memcached_touch},
{"memcached_touch_with_prefix", 0, (test_callback_fn*)test_memcached_touch_by_key},
+#if 0
+ {"memcached_dump() no data", true, (test_callback_fn*)memcached_dump_TEST },
+#endif
+ {"memcached_dump() with data", true, (test_callback_fn*)memcached_dump_TEST2 },
{0, 0, 0}
};
{0, 0, 0}
};
+test_st memcached_stat_tests[] ={
+ {"memcached_stat() INVALID ARG", 0, (test_callback_fn*)memcached_stat_TEST},
+ {"memcached_stat()", 0, (test_callback_fn*)memcached_stat_TEST2},
+ {0, 0, 0}
+};
+
test_st behavior_tests[] ={
{"libmemcached_string_behavior()", false, (test_callback_fn*)libmemcached_string_behavior_test},
{"libmemcached_string_distribution()", false, (test_callback_fn*)libmemcached_string_distribution_test},
{0, 0, (test_callback_fn*)0}
};
-test_st haldenbrand_tests[] ={
- {"memcached_set", false, (test_callback_fn*)user_supplied_bug1 },
- {"memcached_get()", false, (test_callback_fn*)user_supplied_bug2 },
- {"memcached_mget()", false, (test_callback_fn*)user_supplied_bug3 },
+test_st haldenbrand_TESTS[] ={
+ {"memcached_set", false, (test_callback_fn*)haldenbrand_TEST1 },
+ {"memcached_get()", false, (test_callback_fn*)haldenbrand_TEST2 },
+ {"memcached_mget()", false, (test_callback_fn*)haldenbrand_TEST3 },
{0, 0, (test_callback_fn*)0}
};
{"mget", false, (test_callback_fn*)replication_mget_test },
{"delete", true, (test_callback_fn*)replication_delete_test },
{"rand_mget", false, (test_callback_fn*)replication_randomize_mget_test },
+ {"miss", false, (test_callback_fn*)replication_miss_test },
{"fail", false, (test_callback_fn*)replication_randomize_mget_fail_test },
{0, 0, (test_callback_fn*)0}
};
{"result", 0, 0, result_tests},
{"async", (test_callback_fn*)pre_nonblock, 0, async_tests},
{"async(BINARY)", (test_callback_fn*)pre_nonblock_binary, 0, async_tests},
- {"Cal Haldenbrand's tests", 0, 0, haldenbrand_tests},
+ {"Cal Haldenbrand's tests", 0, 0, haldenbrand_TESTS},
{"user written tests", 0, 0, user_tests},
{"generate", 0, 0, generate_tests},
{"generate_hsieh", (test_callback_fn*)pre_hsieh, 0, generate_tests},
{"virtual buckets", 0, 0, virtual_bucket_tests},
{"memcached_server_get_last_disconnect", 0, 0, memcached_server_get_last_disconnect_tests},
{"touch", 0, 0, touch_tests},
+ {"touch", (test_callback_fn*)pre_binary, 0, touch_tests},
+ {"memcached_stat()", 0, 0, memcached_stat_tests},
{0, 0, 0, 0}
};