Sample test application.
*/
-#include "libmemcached/common.h"
+#include "config.h"
#include <assert.h>
#include <stdio.h>
+#include <stdint.h>
#include <stdlib.h>
#include <string.h>
#include <sys/time.h>
#include <signal.h>
#include <unistd.h>
#include <time.h>
-#include "server.h"
+
+#include "libmemcached/common.h"
+
+#include <libtest/server.h>
+
#include "clients/generator.h"
#include "clients/execute.h"
-#ifndef INT64_MAX
-#define INT64_MAX LONG_MAX
-#endif
-#ifndef INT32_MAX
-#define INT32_MAX INT_MAX
-#endif
+#define SMALL_STRING_LEN 1024
+#include <libtest/test.h>
+#include "tests/parser.h"
+#include "tests/string.h"
+#include "tests/replication.h"
+#include "tests/basic.h"
+#include "tests/error_conditions.h"
+#include "tests/print.h"
-#include "test.h"
#ifdef HAVE_LIBMEMCACHEDUTIL
#include <pthread.h>
static test_return_t pre_binary(memcached_st *memc);
-static test_return_t init_test(memcached_st *not_used __attribute__((unused)))
+static test_return_t init_test(memcached_st *not_used)
{
memcached_st memc;
+ (void)not_used;
(void)memcached_create(&memc);
memcached_free(&memc);
return TEST_SUCCESS;
}
-static test_return_t server_list_null_test(memcached_st *ptr __attribute__((unused)))
+static test_return_t server_list_null_test(memcached_st *ptr)
{
memcached_server_st *server_list;
memcached_return_t rc;
+ (void)ptr;
server_list= memcached_server_list_append_with_weight(NULL, NULL, 0, 0, NULL);
test_true(server_list == NULL);
#define TEST_PORT_COUNT 7
in_port_t test_ports[TEST_PORT_COUNT];
-static memcached_return_t server_display_function(const memcached_st *ptr __attribute__((unused)),
+static memcached_return_t server_display_function(const memcached_st *ptr,
const memcached_server_st *server,
void *context)
{
/* Do Nothing */
size_t bigger= *((size_t *)(context));
+ (void)ptr;
assert(bigger <= memcached_server_port(server));
*((size_t *)(context))= memcached_server_port(server);
return MEMCACHED_SUCCESS;
}
-static test_return_t server_sort_test(memcached_st *ptr __attribute__((unused)))
+static memcached_return_t dump_server_information(const memcached_st *ptr,
+ const memcached_server_st *instance,
+ void *context)
+{
+ /* Do Nothing */
+ FILE *stream= (FILE *)context;
+ (void)ptr;
+
+ fprintf(stream, "Memcached Server: %s %u Version %u.%u.%u\n",
+ memcached_server_name(instance),
+ memcached_server_port(instance),
+ instance->major_version,
+ instance->minor_version,
+ instance->micro_version);
+
+ return MEMCACHED_SUCCESS;
+}
+
+static test_return_t server_sort_test(memcached_st *ptr)
{
size_t bigger= 0; /* Prime the value for the test_true in server_display_function */
memcached_return_t rc;
memcached_server_fn callbacks[1];
memcached_st *local_memc;
+ (void)ptr;
local_memc= memcached_create(NULL);
test_true(local_memc);
return TEST_SUCCESS;
}
-static test_return_t server_sort2_test(memcached_st *ptr __attribute__((unused)))
+static test_return_t server_sort2_test(memcached_st *ptr)
{
size_t bigger= 0; /* Prime the value for the test_true in server_display_function */
memcached_return_t rc;
memcached_server_fn callbacks[1];
memcached_st *local_memc;
memcached_server_instance_st instance;
+ (void)ptr;
local_memc= memcached_create(NULL);
test_true(local_memc);
return TEST_SUCCESS;
}
-static memcached_return_t server_print_callback(const memcached_st *ptr __attribute__((unused)),
- const memcached_server_st *server,
- void *context __attribute__((unused)))
-{
- (void)server; // Just in case we aren't printing.
-
-#if 0
- fprintf(stderr, "%s(%d)", memcached_server_name(server), memcached_server_port(server));
-#endif
-
- return MEMCACHED_SUCCESS;
-}
-
-static test_return_t memcached_server_remove_test(memcached_st *ptr __attribute__((unused)))
+static test_return_t memcached_server_remove_test(memcached_st *ptr)
{
memcached_return_t rc;
memcached_st local_memc;
memcached_server_fn callbacks[1];
const char *server_string= "localhost:4444, localhost:4445, localhost:4446, localhost:4447, localhost, 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";
+ (void)ptr;
memc= memcached_create(&local_memc);
return TEST_SUCCESS;
}
-static memcached_return_t server_display_unsort_function(const memcached_st *ptr __attribute__((unused)),
+static memcached_return_t server_display_unsort_function(const memcached_st *ptr,
const memcached_server_st *server,
void *context)
{
/* Do Nothing */
uint32_t x= *((uint32_t *)(context));
+ (void)ptr;
assert(test_ports[x] == server->port);
*((uint32_t *)(context))= ++x;
return MEMCACHED_SUCCESS;
}
-static test_return_t server_unsort_test(memcached_st *ptr __attribute__((unused)))
+static test_return_t server_unsort_test(memcached_st *ptr)
{
size_t counter= 0; /* Prime the value for the test_true in server_display_function */
size_t bigger= 0; /* Prime the value for the test_true in server_display_function */
memcached_return_t rc;
memcached_server_fn callbacks[1];
memcached_st *local_memc;
+ (void)ptr;
local_memc= memcached_create(NULL);
test_true(local_memc);
return TEST_SUCCESS;
}
-static test_return_t allocation_test(memcached_st *not_used __attribute__((unused)))
+static test_return_t allocation_test(memcached_st *not_used)
{
+ (void)not_used;
memcached_st *memc;
memc= memcached_create(NULL);
test_true(memc);
test_true(memc_clone->flags.buffer_requests == memc->flags.buffer_requests);
test_true(memc_clone->flags.use_sort_hosts == memc->flags.use_sort_hosts);
test_true(memc_clone->flags.verify_key == memc->flags.verify_key);
- test_true(memc_clone->flags.ketama_weighted == memc->flags.ketama_weighted);
+ test_true(memc_clone->ketama.weighted == memc->ketama.weighted);
test_true(memc_clone->flags.binary_protocol == memc->flags.binary_protocol);
test_true(memc_clone->flags.hash_with_prefix_key == memc->flags.hash_with_prefix_key);
test_true(memc_clone->flags.no_reply == memc->flags.no_reply);
2300930706U, 2943759320U, 674306647U, 2400528935U,
54481931U, 4186304426U, 1741088401U, 2979625118U,
4159057246U, 3425930182U, 2593724503U, 1868899624U,
- 1769812374U, 2302537950U, 1110330676U };
+ 1769812374U, 2302537950U, 1110330676U, 3365377466U,
+ 1336171666U, 3365377466U };
// You have updated the memcache_error messages but not updated docs/tests.
- test_true(MEMCACHED_MAXIMUM_RETURN == 43);
for (rc= MEMCACHED_SUCCESS; rc < MEMCACHED_MAXIMUM_RETURN; rc++)
{
uint32_t hash_val;
}
test_true(values[rc] == hash_val);
}
+ test_true(MEMCACHED_MAXIMUM_RETURN == 45);
return TEST_SUCCESS;
}
*/
static test_return_t add_wrapper(memcached_st *memc)
{
- unsigned int x;
unsigned int max= 10000;
#ifdef __sun
max= 10;
max= 10;
#endif
- for (x= 0; x < max; x++)
+ for (uint32_t x= 0; x < max; x++)
add_test(memc);
return TEST_SUCCESS;
return TEST_SUCCESS;
}
-static memcached_return_t server_function(const memcached_st *ptr __attribute__((unused)),
- const memcached_server_st *server __attribute__((unused)),
- void *context __attribute__((unused)))
+static memcached_return_t server_function(const memcached_st *ptr,
+ const memcached_server_st *server,
+ void *context)
{
+ (void)ptr; (void)server; (void)context;
/* Do Nothing */
return MEMCACHED_SUCCESS;
static test_return_t memcached_server_cursor_test(memcached_st *memc)
{
- char context[8];
- strcpy(context, "foo bad");
+ char context[10];
+ strncpy(context, "foo bad", sizeof(context));
memcached_server_fn callbacks[1];
callbacks[0]= server_function;
rc= memcached_callback_set(memc_clone, MEMCACHED_CALLBACK_PREFIX_KEY, NULL);
test_true(rc == MEMCACHED_SUCCESS);
- char *longkey= malloc(max_keylen + 1);
+ char *longkey= (char *)malloc(max_keylen + 1);
if (longkey != NULL)
{
memset(longkey, 'a', max_keylen + 1);
}
#define READ_THROUGH_VALUE "set for me"
-static memcached_return_t read_through_trigger(memcached_st *memc __attribute__((unused)),
- char *key __attribute__((unused)),
- size_t key_length __attribute__((unused)),
+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));
}
return TEST_SUCCESS;
}
-static memcached_return_t delete_trigger(memcached_st *ptr __attribute__((unused)),
+static memcached_return_t delete_trigger(memcached_st *ptr,
const char *key,
- size_t key_length __attribute__((unused)))
+ size_t key_length)
{
+ (void)ptr;(void)key_length;
assert(key);
return MEMCACHED_SUCCESS;
{
char key[16];
- sprintf(key, "foo%u", x);
+ snprintf(key, sizeof(key), "foo%u", x);
rc= memcached_set(memc, key, strlen(key),
value, value_length,
}
/* Count the results */
-static memcached_return_t callback_counter(const memcached_st *ptr __attribute__((unused)),
- memcached_result_st *result __attribute__((unused)),
+static memcached_return_t callback_counter(const memcached_st *ptr,
+ memcached_result_st *result,
void *context)
{
+ (void)ptr; (void)result;
size_t *counter= (size_t *)context;
*counter= *counter + 1;
{
char k[251];
- key_length[x]= (size_t)snprintf(k, sizeof(k), "0200%zu", x);
+ key_length[x]= (size_t)snprintf(k, sizeof(k), "0200%lu", (unsigned long)x);
keys[x]= strdup(k);
test_true(keys[x] != NULL);
rc= memcached_add(memc, keys[x], key_length[x], blob, sizeof(blob), 0, 0);
return TEST_SUCCESS;
}
-static test_return_t version_string_test(memcached_st *memc __attribute__((unused)))
+static test_return_t version_string_test(memcached_st *memc)
{
const char *version_string;
+ (void)memc;
version_string= memcached_lib_version();
return TEST_SUCCESS;
}
-static memcached_return_t clone_test_callback(memcached_st *parent __attribute__((unused)), memcached_st *memc_clone __attribute__((unused)))
+static memcached_return_t clone_test_callback(memcached_st *parent, memcached_st *memc_clone)
{
+ (void)parent;(void)memc_clone;
return MEMCACHED_SUCCESS;
}
-static memcached_return_t cleanup_test_callback(memcached_st *ptr __attribute__((unused)))
+static memcached_return_t cleanup_test_callback(memcached_st *ptr)
{
+ (void)ptr;
return MEMCACHED_SUCCESS;
}
return TEST_SUCCESS;
}
-static test_return_t fetch_all_results(memcached_st *memc)
+static test_return_t fetch_all_results(memcached_st *memc, size_t *keys_returned)
{
memcached_return_t rc= MEMCACHED_SUCCESS;
char return_key[MEMCACHED_MAX_KEY];
size_t return_value_length;
uint32_t flags;
+ *keys_returned= 0;
+
while ((return_value= memcached_fetch(memc, return_key, &return_key_length,
&return_value_length, &flags, &rc)))
{
test_true(return_value);
test_true(rc == MEMCACHED_SUCCESS);
free(return_value);
+ *keys_returned= *keys_returned +1;
}
- return ((rc == MEMCACHED_END) || (rc == MEMCACHED_SUCCESS)) ? TEST_SUCCESS : TEST_FAILURE;
+ test_true_got(rc == MEMCACHED_END || rc == MEMCACHED_SUCCESS, memcached_strerror(NULL, rc));
+
+ return TEST_SUCCESS;
}
/* Test case provided by Cal Haldenbrand */
rc= memcached_mget(memc, (const char **)keys, key_lengths, KEY_COUNT);
test_true(rc == MEMCACHED_SUCCESS);
- test_true(fetch_all_results(memc) == TEST_SUCCESS);
+ size_t keys_returned;
+ test_true(fetch_all_results(memc, &keys_returned) == TEST_SUCCESS);
for (x= 0; x < KEY_COUNT; x++)
free(keys[x]);
return TEST_SUCCESS;
}
-static test_return_t user_supplied_bug8(memcached_st *memc __attribute__((unused)))
+static test_return_t user_supplied_bug8(memcached_st *memc)
{
memcached_return_t rc;
memcached_st *mine;
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";
+ (void)memc;
servers= memcached_servers_parse(server_list);
test_true(servers);
return TEST_SUCCESS;
}
-#ifndef __sun
+#if !defined(__sun) && !defined(__OpenBSD__)
/* Check the validity of chinese key*/
static test_return_t user_supplied_bug17(memcached_st *memc)
{
/* VDEAAAAA hashes to fffcd1b5, after the last continuum point, and lets
* us test the boundary wraparound.
*/
- test_true(memcached_generate_hash(memc, (char *)"VDEAAAAA", 8) == memc->continuum[0].index);
+ test_true(memcached_generate_hash(memc, (char *)"VDEAAAAA", 8) == memc->ketama.continuum[0].index);
/* verify the standard ketama set. */
for (x= 0; x < 99; x++)
*/
/* sighandler_t function that always asserts false */
-static void fail(int unused __attribute__((unused)))
+static void fail(int unused)
{
+ (void)unused;
assert(0);
}
static test_return_t _user_supplied_bug21(memcached_st* memc, size_t key_count)
{
+#ifdef WIN32
+ (void)memc;
+ (void)key_count;
+ return TEST_SKIPPED;
+#else
memcached_return_t rc;
unsigned int x;
char **keys;
alarm(0);
signal(SIGALRM, oldalarm);
- test_true(fetch_all_results(memc) == TEST_SUCCESS);
+ size_t keys_returned;
+ test_true(fetch_all_results(memc, &keys_returned) == TEST_SUCCESS);
for (x= 0; x < key_count; x++)
free(keys[x]);
memcached_free(memc_clone);
return TEST_SUCCESS;
+#endif
}
static test_return_t user_supplied_bug21(memcached_st *memc)
instance= memcached_server_instance_by_position(memc, 2);
((memcached_server_write_instance_st)instance)->next_retry = time(NULL) + 15;
- memc->next_distribution_rebuild= time(NULL) - 1;
+ memc->ketama.next_distribution_rebuild= time(NULL) - 1;
/*
This would not work if there were only two hosts.
/* and re-added when it's back. */
((memcached_server_write_instance_st)instance)->next_retry = time(NULL) - 1;
- memc->next_distribution_rebuild= time(NULL) - 1;
+ memc->ketama.next_distribution_rebuild= time(NULL) - 1;
memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_DISTRIBUTION,
memc->distribution);
for (size_t x= 0; x < 99; x++)
for (int x= 0; x < 10000; x++)
{
char key[10];
- sprintf(key, "%d", x);
+ snprintf(key, sizeof(key), "%d", x);
uint32_t server_idx = memcached_generate_hash(memc, key, strlen(key));
char *hostname = memc->hosts[server_idx].hostname;
return TEST_SUCCESS;
}
-static test_return_t string_static_null(memcached_st *memc)
-{
- memcached_string_st string;
- memcached_string_st *string_ptr;
-
- string_ptr= memcached_string_create(memc, &string, 0);
- test_true(string.options.is_initialized == true);
- test_true(string_ptr);
-
- /* The following two better be the same! */
- test_true(memcached_is_allocated(string_ptr) == false);
- test_true(memcached_is_allocated(&string) == false);
- test_true(&string == string_ptr);
-
- test_true(string.options.is_initialized == true);
- test_true(memcached_is_initialized(&string) == true);
- memcached_string_free(&string);
- test_true(memcached_is_initialized(&string) == false);
-
- return TEST_SUCCESS;
-}
-
-static test_return_t string_alloc_null(memcached_st *memc)
-{
- memcached_string_st *string;
-
- string= memcached_string_create(memc, NULL, 0);
- test_true(string);
- test_true(memcached_is_allocated(string) == true);
- test_true(memcached_is_initialized(string) == true);
- memcached_string_free(string);
-
- return TEST_SUCCESS;
-}
-
-static test_return_t string_alloc_with_size(memcached_st *memc)
-{
- memcached_string_st *string;
-
- string= memcached_string_create(memc, NULL, 1024);
- test_true(string);
- test_true(memcached_is_allocated(string) == true);
- test_true(memcached_is_initialized(string) == true);
- memcached_string_free(string);
-
- return TEST_SUCCESS;
-}
-
-static test_return_t string_alloc_with_size_toobig(memcached_st *memc)
-{
- memcached_string_st *string;
-
- string= memcached_string_create(memc, NULL, SIZE_MAX);
- test_true(string == NULL);
-
- return TEST_SUCCESS;
-}
-
-static test_return_t string_alloc_append(memcached_st *memc)
-{
- unsigned int x;
- char buffer[SMALL_STRING_LEN];
- memcached_string_st *string;
-
- /* Ring the bell! */
- memset(buffer, 6, SMALL_STRING_LEN);
-
- string= memcached_string_create(memc, NULL, 100);
- test_true(string);
- test_true(memcached_is_allocated(string) == true);
- test_true(memcached_is_initialized(string) == true);
-
- for (x= 0; x < 1024; x++)
- {
- memcached_return_t rc;
- rc= memcached_string_append(string, buffer, SMALL_STRING_LEN);
- test_true(rc == MEMCACHED_SUCCESS);
- }
- test_true(memcached_is_allocated(string) == true);
- memcached_string_free(string);
-
- return TEST_SUCCESS;
-}
-
-static test_return_t string_alloc_append_toobig(memcached_st *memc)
-{
- memcached_return_t rc;
- unsigned int x;
- char buffer[SMALL_STRING_LEN];
- memcached_string_st *string;
-
- /* Ring the bell! */
- memset(buffer, 6, SMALL_STRING_LEN);
-
- string= memcached_string_create(memc, NULL, 100);
- test_true(string);
- test_true(memcached_is_allocated(string) == true);
- test_true(memcached_is_initialized(string) == true);
-
- for (x= 0; x < 1024; x++)
- {
- rc= memcached_string_append(string, buffer, SMALL_STRING_LEN);
- test_true(rc == MEMCACHED_SUCCESS);
- }
- rc= memcached_string_append(string, buffer, SIZE_MAX);
- test_true(rc == MEMCACHED_MEMORY_ALLOCATION_FAILURE);
- test_true(memcached_is_allocated(string) == true);
- memcached_string_free(string);
-
- return TEST_SUCCESS;
-}
-
-static test_return_t cleanup_pairs(memcached_st *memc __attribute__((unused)))
+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 *memc __attribute__((unused)))
+static test_return_t generate_pairs(memcached_st *memc)
{
+ (void)memc;
global_pairs= pairs_generate(GLOBAL_COUNT, 400);
global_count= GLOBAL_COUNT;
return TEST_SUCCESS;
}
-static test_return_t generate_large_pairs(memcached_st *memc __attribute__((unused)))
+static test_return_t generate_large_pairs(memcached_st *memc)
{
+ (void)memc;
global_pairs= pairs_generate(GLOBAL2_COUNT, MEMCACHED_MAX_BUFFER+10);
global_count= GLOBAL2_COUNT;
static test_return_t generate_data(memcached_st *memc)
{
- execute_set(memc, global_pairs, global_count);
+ unsigned int check_execute= execute_set(memc, global_pairs, global_count);
+
+ test_true(check_execute == global_count);
return TEST_SUCCESS;
}
memcached_stat_st *stat_p;
memcached_return_t rc;
uint32_t host_index= 0;
- execute_set(memc, global_pairs, global_count);
+ unsigned int check_execute= execute_set(memc, global_pairs, global_count);
+
+ test_true(check_execute == global_count);
//TODO: hosts used size stats
stat_p= memcached_stat(memc, NULL, &rc);
{
memcached_return_t rc;
+ if (! libmemcached_util_version_check(memc, 1, 4, 4))
+ return TEST_SKIPPED;
+
rc= memcached_mget(memc, global_keys, global_keys_length, global_count);
- test_true(rc == MEMCACHED_SUCCESS);
- test_true(fetch_all_results(memc) == TEST_SUCCESS);
+
+ test_true_got(rc == MEMCACHED_SUCCESS, memcached_strerror(NULL, rc));
+
+ // Go fetch the keys and test to see if all of them were returned
+ {
+ size_t keys_returned;
+ test_true(fetch_all_results(memc, &keys_returned) == TEST_SUCCESS);
+ char buffer[30];
+ snprintf(buffer, sizeof(buffer), "%lu", (unsigned long)keys_returned);
+ test_true_got(global_count == keys_returned, buffer);
+ }
+
return TEST_SUCCESS;
}
{
memcached_return_t rc;
+ if (! libmemcached_util_version_check(memc, 1, 4, 4))
+ return TEST_SKIPPED;
+
rc= memcached_mget(memc, global_keys, global_keys_length, global_count);
- test_true(rc == MEMCACHED_SUCCESS);
+
+ test_true_got(rc == MEMCACHED_SUCCESS, memcached_strerror(NULL, rc));
+
/* Turn this into a help function */
{
memcached_result_st results_obj;
size_t counter;
memcached_execute_fn callbacks[1];
+ if (! libmemcached_util_version_check(memc, 1, 4, 4))
+ return TEST_SKIPPED;
+
rc= memcached_mget(memc, global_keys, global_keys_length, global_count);
- test_true(rc == MEMCACHED_SUCCESS);
+
+ test_true_got(rc == MEMCACHED_SUCCESS, memcached_strerror(NULL, rc));
callbacks[0]= &callback_counter;
counter= 0;
{
char buffer[SMALL_STRING_LEN];
- snprintf(buffer, SMALL_STRING_LEN, "%zu.example.com", 400+x);
+ snprintf(buffer, SMALL_STRING_LEN, "%lu.example.com", (unsigned long)(400 +x));
servers= memcached_server_list_append_with_weight(servers, buffer, 401, 0,
&rc);
test_true(rc == MEMCACHED_SUCCESS);
// will not toggle protocol on an connection.
memcached_version(memc_clone);
- if (libmemcached_util_version_check(memc_clone, 1, 2, 0))
+ if (libmemcached_util_version_check(memc_clone, 1, 4, 4))
{
memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_NO_BLOCK, 0);
rc = memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL, 1);
static test_return_t pre_murmur(memcached_st *memc)
{
+#ifdef HAVE_MURMUR_HASH
memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_HASH, (uint64_t)MEMCACHED_HASH_MURMUR);
-
return TEST_SUCCESS;
+#else
+ (void) memc;
+ return TEST_SKIPPED;
+#endif
}
static test_return_t pre_jenkins(memcached_st *memc)
static test_return_t pre_binary(memcached_st *memc)
{
memcached_return_t rc= MEMCACHED_FAILURE;
- memcached_st *memc_clone;
-
- memc_clone= memcached_clone(NULL, memc);
- test_true(memc_clone);
- // The memcached_version needs to be done on a clone, because the server
- // will not toggle protocol on an connection.
- memcached_version(memc_clone);
- if (libmemcached_util_version_check(memc_clone, 1, 2, 0))
+ if (libmemcached_util_version_check(memc, 1, 4, 4))
{
rc = memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL, 1);
test_true(rc == MEMCACHED_SUCCESS);
test_true(memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL) == 1);
}
- memcached_free(memc_clone);
-
return rc == MEMCACHED_SUCCESS ? TEST_SUCCESS : TEST_SKIPPED;
}
}
-static void my_free(const memcached_st *ptr __attribute__((unused)), void *mem, void *context)
+static void my_free(const memcached_st *ptr, void *mem, void *context)
{
- (void) context;
+ (void)context;
+ (void)ptr;
#ifdef HARD_MALLOC_TESTS
void *real_ptr= (mem == NULL) ? mem : (void*)((caddr_t)mem - 8);
free(real_ptr);
}
-static void *my_malloc(const memcached_st *ptr __attribute__((unused)), const size_t size, void *context)
+static void *my_malloc(const memcached_st *ptr, const size_t size, void *context)
{
(void)context;
+ (void)ptr;
#ifdef HARD_MALLOC_TESTS
void *ret= malloc(size + 8);
if (ret != NULL)
}
-static void *my_realloc(const memcached_st *ptr __attribute__((unused)), void *mem, const size_t size, void *context)
+static void *my_realloc(const memcached_st *ptr, void *mem, const size_t size, void *context)
{
(void)context;
#ifdef HARD_MALLOC_TESTS
return ret;
#else
+ (void)ptr;
return realloc(mem, size);
#endif
}
-static void *my_calloc(const memcached_st *ptr __attribute__((unused)), size_t nelem, const size_t size, void *context)
+static void *my_calloc(const memcached_st *ptr, size_t nelem, const size_t size, void *context)
{
(void)context;
#ifdef HARD_MALLOC_TESTS
return mem;
#else
+ (void)ptr;
return calloc(nelem, size);
#endif
}
/* Test a clean set */
rc= memcached_callback_set(memc, MEMCACHED_CALLBACK_PREFIX_KEY, (void *)key);
- test_true(rc == MEMCACHED_SUCCESS);
+ test_true_got(rc == MEMCACHED_SUCCESS, memcached_last_error_message(memc));
value= memcached_callback_get(memc, MEMCACHED_CALLBACK_PREFIX_KEY, &rc);
+ test_true(value);
test_true(memcmp(value, key, 4) == 0);
test_true(rc == MEMCACHED_SUCCESS);
test_true(rc == MEMCACHED_SUCCESS);
value= memcached_callback_get(memc, MEMCACHED_CALLBACK_PREFIX_KEY, &rc);
+ test_false(value);
test_true(rc == MEMCACHED_FAILURE);
/* Now setup for main test */
test_true(rc == MEMCACHED_SUCCESS);
value= memcached_callback_get(memc, MEMCACHED_CALLBACK_PREFIX_KEY, &rc);
+ test_true(value);
test_true(rc == MEMCACHED_SUCCESS);
test_true(memcmp(value, key, 4) == 0);
test_true(rc == MEMCACHED_SUCCESS);
value= memcached_callback_get(memc, MEMCACHED_CALLBACK_PREFIX_KEY, &rc);
+ test_false(value);
test_true(rc == MEMCACHED_FAILURE);
test_true(value == NULL);
/* Test a long key for failure */
/* TODO, extend test to determine based on setting, what result should be */
- strcpy(long_key, "Thisismorethentheallottednumberofcharacters");
+ strncpy(long_key, "Thisismorethentheallottednumberofcharacters", sizeof(long_key));
rc= memcached_callback_set(memc, MEMCACHED_CALLBACK_PREFIX_KEY, long_key);
//test_true(rc == MEMCACHED_BAD_KEY_PROVIDED);
test_true(rc == MEMCACHED_SUCCESS);
/* Now test a key with spaces (which will fail from long key, since bad key is not set) */
- strcpy(long_key, "This is more then the allotted number of characters");
+ strncpy(long_key, "This is more then the allotted number of characters", sizeof(long_key));
rc= memcached_callback_set(memc, MEMCACHED_CALLBACK_PREFIX_KEY, long_key);
test_true(rc == MEMCACHED_BAD_KEY_PROVIDED);
rc= memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_VERIFY_KEY, 1);
test_true(rc == MEMCACHED_SUCCESS);
- strcpy(long_key, "dog cat");
+ strncpy(long_key, "dog cat", sizeof(long_key));
rc= memcached_callback_set(memc, MEMCACHED_CALLBACK_PREFIX_KEY, long_key);
test_true(rc == MEMCACHED_BAD_KEY_PROVIDED);
}
for (size_t x= 0; x < 100; ++x)
{
char key[10];
- size_t len= (size_t)sprintf(key, "%zu", x);
+ int check_length= (size_t)snprintf(key, sizeof(key), "%lu", (unsigned long)x);
+ test_false((size_t)check_length >= sizeof(key) || check_length < 0);
+
+ size_t len= (size_t)check_length;
+
switch (count)
{
case 0:
{
char key[10];
- size_t len= (size_t)sprintf(key, "%zu", x);
+ int check_length= (size_t)snprintf(key, sizeof(key), "%lu", (unsigned long)x);
+
+ test_false((size_t)check_length >= sizeof(key) || check_length < 0);
+
+ size_t len= (size_t)check_length;
size_t length;
uint32_t flags;
char* value=memcached_get(memc, key, strlen(key),
}
/* Count the objects */
-static memcached_return_t callback_dump_counter(const memcached_st *ptr __attribute__((unused)),
- const char *key __attribute__((unused)),
- size_t key_length __attribute__((unused)),
+static memcached_return_t callback_dump_counter(const memcached_st *ptr,
+ const char *key,
+ size_t key_length,
void *context)
{
+ (void)ptr; (void)key; (void)key_length;
size_t *counter= (size_t *)context;
*counter= *counter + 1;
return arg;
}
+#define POOL_SIZE 10
static test_return_t connection_pool_test(memcached_st *memc)
{
- memcached_pool_st* pool= memcached_pool_create(memc, 5, 10);
+ memcached_pool_st* pool= memcached_pool_create(memc, 5, POOL_SIZE);
test_true(pool != NULL);
- memcached_st* mmc[10];
+ memcached_st *mmc[POOL_SIZE];
memcached_return_t rc;
- for (size_t x= 0; x < 10; ++x)
+ for (size_t x= 0; x < POOL_SIZE; ++x)
{
mmc[x]= memcached_pool_pop(pool, false, &rc);
test_true(mmc[x] != NULL);
rc= memcached_set(mmc[0], key, keylen, "0", 1, 0, 0);
test_true(rc == MEMCACHED_SUCCESS);
- for (size_t x= 0; x < 10; ++x)
+ for (size_t x= 0; x < POOL_SIZE; ++x)
{
uint64_t number_value;
rc= memcached_increment(mmc[x], key, keylen, 1, &number_value);
}
// Release them..
- for (size_t x= 0; x < 10; ++x)
+ for (size_t x= 0; x < POOL_SIZE; ++x)
{
test_true(memcached_pool_push(pool, mmc[x]) == MEMCACHED_SUCCESS);
}
test_true(memcached_behavior_get(mmc[0], MEMCACHED_BEHAVIOR_IO_MSG_WATERMARK) == 9999);
test_true(memcached_pool_push(pool, mmc[0]) == MEMCACHED_SUCCESS);
-
test_true(memcached_pool_destroy(pool) == memc);
+
return TEST_SUCCESS;
}
test_true(if_successful == true);
if_successful= libmemcached_util_version_check(memc, 9, 9, 9);
+
+ // We expect failure
+ if (if_successful)
+ {
+ fprintf(stderr, "\n----------------------------------------------------------------------\n");
+ fprintf(stderr, "\nDumping Server Information\n\n");
+ memcached_server_fn callbacks[1];
+
+ callbacks[0]= dump_server_information;
+ memcached_server_cursor(memc, callbacks, (void *)stderr, 1);
+ fprintf(stderr, "\n----------------------------------------------------------------------\n");
+ }
test_true(if_successful == false);
memcached_server_instance_st instance=
memcached_version(memc);
// We only use one binary when we test, so this should be just fine.
- if_successful= libmemcached_util_version_check(memc, instance->major_version, instance->micro_version, instance->minor_version);
+ if_successful= libmemcached_util_version_check(memc, instance->major_version, instance->minor_version, instance->micro_version);
test_true(if_successful == true);
- if (instance->minor_version > 0)
- if_successful= libmemcached_util_version_check(memc, instance->major_version, instance->micro_version, instance->minor_version -1);
- else if (instance->micro_version > 0)
- if_successful= libmemcached_util_version_check(memc, instance->major_version, instance->micro_version - 1, instance->minor_version);
+ if (instance->micro_version > 0)
+ if_successful= libmemcached_util_version_check(memc, instance->major_version, instance->minor_version, (uint8_t)(instance->micro_version -1));
+ else if (instance->minor_version > 0)
+ if_successful= libmemcached_util_version_check(memc, instance->major_version, (uint8_t)(instance->minor_version - 1), instance->micro_version);
else if (instance->major_version > 0)
- if_successful= libmemcached_util_version_check(memc, instance->major_version -1, instance->micro_version, instance->minor_version);
+ if_successful= libmemcached_util_version_check(memc, (uint8_t)(instance->major_version -1), instance->minor_version, instance->micro_version);
test_true(if_successful == true);
- if (instance->minor_version > 0)
- if_successful= libmemcached_util_version_check(memc, instance->major_version, instance->micro_version, instance->minor_version +1);
- else if (instance->micro_version > 0)
- if_successful= libmemcached_util_version_check(memc, instance->major_version, instance->micro_version +1, instance->minor_version);
+ if (instance->micro_version > 0)
+ if_successful= libmemcached_util_version_check(memc, instance->major_version, instance->minor_version, (uint8_t)(instance->micro_version +1));
+ else if (instance->minor_version > 0)
+ if_successful= libmemcached_util_version_check(memc, instance->major_version, (uint8_t)(instance->minor_version +1), instance->micro_version);
else if (instance->major_version > 0)
- if_successful= libmemcached_util_version_check(memc, instance->major_version +1, instance->micro_version, instance->minor_version);
+ if_successful= libmemcached_util_version_check(memc, (uint8_t)(instance->major_version +1), instance->minor_version, instance->micro_version);
test_true(if_successful == false);
}
#endif
-static test_return_t replication_set_test(memcached_st *memc)
-{
- memcached_return_t rc;
- memcached_st *memc_clone= memcached_clone(NULL, memc);
- memcached_behavior_set(memc_clone, MEMCACHED_BEHAVIOR_NUMBER_OF_REPLICAS, 0);
-
- rc= memcached_set(memc, "bubba", 5, "0", 1, 0, 0);
- test_true(rc == MEMCACHED_SUCCESS);
-
- /*
- ** We are using the quiet commands to store the replicas, so we need
- ** to ensure that all of them are processed before we can continue.
- ** In the test we go directly from storing the object to trying to
- ** receive the object from all of the different servers, so we
- ** could end up in a race condition (the memcached server hasn't yet
- ** processed the quiet command from the replication set when it process
- ** the request from the other client (created by the clone)). As a
- ** workaround for that we call memcached_quit to send the quit command
- ** to the server and wait for the response ;-) If you use the test code
- ** as an example for your own code, please note that you shouldn't need
- ** to do this ;-)
- */
- memcached_quit(memc);
-
- /*
- ** "bubba" should now be stored on all of our servers. We don't have an
- ** easy to use API to address each individual server, so I'll just iterate
- ** through a bunch of "master keys" and I should most likely hit all of the
- ** servers...
- */
- for (int x= 'a'; x <= 'z'; ++x)
- {
- char key[2]= { [0]= (char)x };
- size_t len;
- uint32_t flags;
- char *val= memcached_get_by_key(memc_clone, key, 1, "bubba", 5,
- &len, &flags, &rc);
- test_true(rc == MEMCACHED_SUCCESS);
- test_true(val != NULL);
- free(val);
- }
-
- memcached_free(memc_clone);
-
- return TEST_SUCCESS;
-}
-
-static test_return_t replication_get_test(memcached_st *memc)
-{
- memcached_return_t rc;
-
- /*
- * Don't do the following in your code. I am abusing the internal details
- * within the library, and this is not a supported interface.
- * This is to verify correct behavior in the library
- */
- for (uint32_t host= 0; host < memcached_server_count(memc); ++host)
- {
- memcached_st *memc_clone= memcached_clone(NULL, memc);
- memcached_server_instance_st instance=
- memcached_server_instance_by_position(memc_clone, host);
-
- ((memcached_server_write_instance_st)instance)->port= 0;
-
- for (int x= 'a'; x <= 'z'; ++x)
- {
- char key[2]= { [0]= (char)x };
- size_t len;
- uint32_t flags;
- char *val= memcached_get_by_key(memc_clone, key, 1, "bubba", 5,
- &len, &flags, &rc);
- test_true(rc == MEMCACHED_SUCCESS);
- test_true(val != NULL);
- free(val);
- }
-
- memcached_free(memc_clone);
- }
-
- return TEST_SUCCESS;
-}
-
-static test_return_t replication_mget_test(memcached_st *memc)
-{
- memcached_return_t rc;
- memcached_st *memc_clone= memcached_clone(NULL, memc);
- memcached_behavior_set(memc_clone, MEMCACHED_BEHAVIOR_NUMBER_OF_REPLICAS, 0);
-
- const char *keys[]= { "bubba", "key1", "key2", "key3" };
- size_t len[]= { 5, 4, 4, 4 };
-
- for (size_t x= 0; x< 4; ++x)
- {
- rc= memcached_set(memc, keys[x], len[x], "0", 1, 0, 0);
- test_true(rc == MEMCACHED_SUCCESS);
- }
-
- /*
- ** We are using the quiet commands to store the replicas, so we need
- ** to ensure that all of them are processed before we can continue.
- ** In the test we go directly from storing the object to trying to
- ** receive the object from all of the different servers, so we
- ** could end up in a race condition (the memcached server hasn't yet
- ** processed the quiet command from the replication set when it process
- ** the request from the other client (created by the clone)). As a
- ** workaround for that we call memcached_quit to send the quit command
- ** to the server and wait for the response ;-) If you use the test code
- ** as an example for your own code, please note that you shouldn't need
- ** to do this ;-)
- */
- memcached_quit(memc);
-
- /*
- * Don't do the following in your code. I am abusing the internal details
- * within the library, and this is not a supported interface.
- * This is to verify correct behavior in the library
- */
- memcached_result_st result_obj;
- for (uint32_t host= 0; host < memc_clone->number_of_hosts; host++)
- {
- memcached_st *new_clone= memcached_clone(NULL, memc);
- memcached_server_instance_st instance=
- memcached_server_instance_by_position(new_clone, host);
- ((memcached_server_write_instance_st)instance)->port= 0;
-
- for (int x= 'a'; x <= 'z'; ++x)
- {
- char key[2]= { [0]= (char)x, [1]= 0 };
-
- rc= memcached_mget_by_key(new_clone, key, 1, keys, len, 4);
- test_true(rc == MEMCACHED_SUCCESS);
-
- memcached_result_st *results= memcached_result_create(new_clone, &result_obj);
- test_true(results);
-
- int hits= 0;
- while ((results= memcached_fetch_result(new_clone, &result_obj, &rc)) != NULL)
- {
- hits++;
- }
- test_true(hits == 4);
- memcached_result_free(&result_obj);
- }
-
- memcached_free(new_clone);
- }
-
- memcached_free(memc_clone);
-
- return TEST_SUCCESS;
-}
-
-static test_return_t replication_randomize_mget_test(memcached_st *memc)
-{
- memcached_result_st result_obj;
- memcached_return_t rc;
- memcached_st *memc_clone= memcached_clone(NULL, memc);
- memcached_behavior_set(memc_clone, MEMCACHED_BEHAVIOR_NUMBER_OF_REPLICAS, 3);
- memcached_behavior_set(memc_clone, MEMCACHED_BEHAVIOR_RANDOMIZE_REPLICA_READ, 1);
-
- const char *keys[]= { "key1", "key2", "key3", "key4", "key5", "key6", "key7" };
- size_t len[]= { 4, 4, 4, 4, 4, 4, 4 };
-
- for (size_t x= 0; x< 7; ++x)
- {
- rc= memcached_set(memc, keys[x], len[x], "1", 1, 0, 0);
- test_true(rc == MEMCACHED_SUCCESS);
- }
-
- memcached_quit(memc);
-
- for (size_t x= 0; x< 7; ++x)
- {
- const char key[2]= { [0]= (const char)x };
-
- rc= memcached_mget_by_key(memc_clone, key, 1, keys, len, 7);
- test_true(rc == MEMCACHED_SUCCESS);
-
- memcached_result_st *results= memcached_result_create(memc_clone, &result_obj);
- test_true(results);
-
- int hits= 0;
- while ((results= memcached_fetch_result(memc_clone, &result_obj, &rc)) != NULL)
- {
- ++hits;
- }
- test_true(hits == 7);
- memcached_result_free(&result_obj);
- }
- memcached_free(memc_clone);
- return TEST_SUCCESS;
-}
-
-static test_return_t replication_delete_test(memcached_st *memc)
-{
- memcached_return_t rc;
- memcached_st *memc_clone= memcached_clone(NULL, memc);
- /* Delete the items from all of the servers except 1 */
- uint64_t repl= memcached_behavior_get(memc,
- MEMCACHED_BEHAVIOR_NUMBER_OF_REPLICAS);
- memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_NUMBER_OF_REPLICAS, --repl);
-
- const char *keys[]= { "bubba", "key1", "key2", "key3" };
- size_t len[]= { 5, 4, 4, 4 };
-
- for (size_t x= 0; x< 4; ++x)
- {
- rc= memcached_delete_by_key(memc, keys[0], len[0], keys[x], len[x], 0);
- test_true(rc == MEMCACHED_SUCCESS);
- }
-
- /*
- * Don't do the following in your code. I am abusing the internal details
- * within the library, and this is not a supported interface.
- * This is to verify correct behavior in the library
- */
- uint32_t hash= memcached_generate_hash(memc, keys[0], len[0]);
- for (uint32_t x= 0; x < (repl + 1); ++x)
- {
- memcached_server_instance_st instance=
- memcached_server_instance_by_position(memc_clone, x);
-
- ((memcached_server_write_instance_st)instance)->port= 0;
- if (++hash == memc_clone->number_of_hosts)
- hash= 0;
- }
-
- memcached_result_st result_obj;
- for (uint32_t host= 0; host < memc_clone->number_of_hosts; ++host)
- {
- for (size_t x= 'a'; x <= 'z'; ++x)
- {
- const char key[2]= { [0]= (const char)x };
-
- rc= memcached_mget_by_key(memc_clone, key, 1, keys, len, 4);
- test_true(rc == MEMCACHED_SUCCESS);
-
- memcached_result_st *results= memcached_result_create(memc_clone, &result_obj);
- test_true(results);
-
- int hits= 0;
- while ((results= memcached_fetch_result(memc_clone, &result_obj, &rc)) != NULL)
- {
- ++hits;
- }
- test_true(hits == 4);
- memcached_result_free(&result_obj);
- }
- }
- memcached_free(memc_clone);
-
- return TEST_SUCCESS;
-}
#if 0
static test_return_t hash_sanity_test (memcached_st *memc)
static test_return_t hsieh_avaibility_test (memcached_st *memc)
{
- memcached_return_t expected_rc= MEMCACHED_FAILURE;
+ memcached_return_t expected_rc= MEMCACHED_INVALID_ARGUMENTS;
#ifdef HAVE_HSIEH_HASH
expected_rc= MEMCACHED_SUCCESS;
#endif
return TEST_SUCCESS;
}
-static test_return_t one_at_a_time_run (memcached_st *memc __attribute__((unused)))
+static test_return_t murmur_avaibility_test (memcached_st *memc)
+{
+ memcached_return_t expected_rc= MEMCACHED_INVALID_ARGUMENTS;
+#ifdef HAVE_MURMUR_HASH
+ expected_rc= MEMCACHED_SUCCESS;
+#endif
+ memcached_return_t rc= memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_HASH,
+ (uint64_t)MEMCACHED_HASH_MURMUR);
+ test_true(rc == expected_rc);
+
+ return TEST_SUCCESS;
+}
+
+static test_return_t one_at_a_time_run (memcached_st *memc)
{
uint32_t x;
const char **ptr;
+ (void)memc;
for (ptr= list_to_hash, x= 0; *ptr; ptr++, x++)
{
return TEST_SUCCESS;
}
-static test_return_t md5_run (memcached_st *memc __attribute__((unused)))
+static test_return_t md5_run (memcached_st *memc)
{
uint32_t x;
const char **ptr;
+ (void)memc;
for (ptr= list_to_hash, x= 0; *ptr; ptr++, x++)
{
return TEST_SUCCESS;
}
-static test_return_t crc_run (memcached_st *memc __attribute__((unused)))
+static test_return_t crc_run (memcached_st *memc)
{
uint32_t x;
const char **ptr;
+ (void)memc;
for (ptr= list_to_hash, x= 0; *ptr; ptr++, x++)
{
return TEST_SUCCESS;
}
-static test_return_t fnv1_64_run (memcached_st *memc __attribute__((unused)))
+static test_return_t fnv1_64_run (memcached_st *memc)
{
uint32_t x;
const char **ptr;
+ (void)memc;
for (ptr= list_to_hash, x= 0; *ptr; ptr++, x++)
{
return TEST_SUCCESS;
}
-static test_return_t fnv1a_64_run (memcached_st *memc __attribute__((unused)))
+static test_return_t fnv1a_64_run (memcached_st *memc)
{
uint32_t x;
const char **ptr;
+ (void)memc;
for (ptr= list_to_hash, x= 0; *ptr; ptr++, x++)
{
return TEST_SUCCESS;
}
-static test_return_t fnv1_32_run (memcached_st *memc __attribute__((unused)))
+static test_return_t fnv1_32_run (memcached_st *memc)
{
uint32_t x;
const char **ptr;
-
+ (void)memc;
for (ptr= list_to_hash, x= 0; *ptr; ptr++, x++)
{
return TEST_SUCCESS;
}
-static test_return_t fnv1a_32_run (memcached_st *memc __attribute__((unused)))
+static test_return_t fnv1a_32_run (memcached_st *memc)
{
uint32_t x;
const char **ptr;
+ (void)memc;
for (ptr= list_to_hash, x= 0; *ptr; ptr++, x++)
{
return TEST_SUCCESS;
}
-static test_return_t hsieh_run (memcached_st *memc __attribute__((unused)))
+static test_return_t hsieh_run (memcached_st *memc)
{
uint32_t x;
const char **ptr;
+ (void)memc;
for (ptr= list_to_hash, x= 0; *ptr; ptr++, x++)
{
return TEST_SUCCESS;
}
-static test_return_t murmur_run (memcached_st *memc __attribute__((unused)))
+static test_return_t murmur_run (memcached_st *memc)
{
#ifdef WORDS_BIGENDIAN
+ (void)murmur_values;
return TEST_SKIPPED;
#else
uint32_t x;
const char **ptr;
+ (void)memc;
for (ptr= list_to_hash, x= 0; *ptr; ptr++, x++)
{
#endif
}
-static test_return_t jenkins_run (memcached_st *memc __attribute__((unused)))
+static test_return_t jenkins_run (memcached_st *memc)
{
uint32_t x;
const char **ptr;
-
+ (void)memc;
for (ptr= list_to_hash, x= 0; *ptr; ptr++, x++)
{
}
/*
- Test case adapted from John Gorman <johngorman2@gmail.com>
+ Test case adapted from John Gorman <johngorman2@gmail.com>
- We are testing the error condition when we connect to a server via memcached_get()
+ We are testing the error condition when we connect to a server via memcached_get()
but find that the server is not available.
*/
static test_return_t memcached_get_MEMCACHED_ERRNO(memcached_st *memc)
// See if memcached is reachable.
value= memcached_get(tl_memc_h, key, strlen(key), &len, &flags, &rc);
- if (value)
- {
- free(value);
- test_true(value); // Pointer won't be zero so this is fine.
- }
-
+ test_false(value);
test_true(len == 0);
- test_true(rc == MEMCACHED_ERRNO);
+ test_false(rc == MEMCACHED_SUCCESS);
+
+ memcached_free(tl_memc_h);
return TEST_SUCCESS;
}
-/*
+/*
We connect to a server which exists, but search for a key that does not exist.
*/
static test_return_t memcached_get_MEMCACHED_NOTFOUND(memcached_st *memc)
// See if memcached is reachable.
value= memcached_get(memc, key, strlen(key), &len, &flags, &rc);
- if (value)
- {
- free(value);
- test_true(value); // Pointer won't be zero so this is fine.
- }
-
+ test_false(value);
test_true(len == 0);
test_true(rc == MEMCACHED_NOTFOUND);
}
/*
- Test case adapted from John Gorman <johngorman2@gmail.com>
+ Test case adapted from John Gorman <johngorman2@gmail.com>
- We are testing the error condition when we connect to a server via memcached_get_by_key()
+ We are testing the error condition when we connect to a server via memcached_get_by_key()
but find that the server is not available.
*/
static test_return_t memcached_get_by_key_MEMCACHED_ERRNO(memcached_st *memc)
// See if memcached is reachable.
value= memcached_get_by_key(tl_memc_h, key, strlen(key), key, strlen(key), &len, &flags, &rc);
- if (value)
- {
- free(value);
- test_true(value); // Pointer won't be zero so this is fine.
- }
-
+ test_false(value);
test_true(len == 0);
- test_true(rc == MEMCACHED_ERRNO);
+ test_false(rc == MEMCACHED_SUCCESS);
+
+ memcached_free(tl_memc_h);
return TEST_SUCCESS;
}
-/*
+/*
We connect to a server which exists, but search for a key that does not exist.
*/
static test_return_t memcached_get_by_key_MEMCACHED_NOTFOUND(memcached_st *memc)
// See if memcached is reachable.
value= memcached_get_by_key(memc, key, strlen(key), key, strlen(key), &len, &flags, &rc);
- if (value)
- {
- free(value);
- test_true(value); // Pointer won't be zero so this is fine.
- }
-
+ test_false(value);
test_true(len == 0);
test_true(rc == MEMCACHED_NOTFOUND);
/* VDEAAAAA hashes to fffcd1b5, after the last continuum point, and lets
* us test the boundary wraparound.
*/
- test_true(memcached_generate_hash(memc, (char *)"VDEAAAAA", 8) == memc->continuum[0].index);
+ test_true(memcached_generate_hash(memc, (char *)"VDEAAAAA", 8) == memc->ketama.continuum[0].index);
/* verify the standard ketama set. */
for (x= 0; x < 99; x++)
{
memcached_return_t rc;
uint64_t value;
- int x;
memcached_server_st *server_pool;
memcached_st *memc;
/* VDEAAAAA hashes to fffcd1b5, after the last continuum point, and lets
* us test the boundary wraparound.
*/
- test_true(memcached_generate_hash(memc, (char *)"VDEAAAAA", 8) == memc->continuum[0].index);
+ test_true(memcached_generate_hash(memc, (char *)"VDEAAAAA", 8) == memc->ketama.continuum[0].index);
/* verify the standard ketama set. */
- for (x= 0; x < 99; x++)
+ for (uint32_t x= 0; x < 99; x++)
{
uint32_t server_idx= memcached_generate_hash(memc, ketama_test_cases_spy[x].key, strlen(ketama_test_cases_spy[x].key));
{
char k[251];
- key_length[x]= (size_t)snprintf(k, sizeof(k), "0200%zu", x);
+ key_length[x]= (size_t)snprintf(k, sizeof(k), "0200%lu", (unsigned long)x);
keys[x]= strdup(k);
test_true(keys[x] != NULL);
}
memcached_server_instance_st instance_one;
memcached_server_instance_st instance_two;
- if (memcached_server_count(memc) < 3 || pre_replication(memc) != MEMCACHED_SUCCESS)
+ if (memcached_server_count(memc) < 3 || pre_replication(memc) != TEST_SUCCESS)
return TEST_SKIPPED;
memcached_return_t rc;
{
char k[251];
- key_length[x]= (size_t)snprintf(k, sizeof(k), "0200%zu", x);
+ key_length[x]= (size_t)snprintf(k, sizeof(k), "0200%lu", (unsigned long)x);
keys[x]= strdup(k);
test_true(keys[x] != NULL);
rc= memcached_set(memc, k, key_length[x], k, key_length[x], 0, 0);
test_true(memc_clone != NULL);
test_true(memcached_version(memc_clone) == MEMCACHED_SUCCESS);
+ memcached_server_instance_st instance=
+ memcached_server_instance_by_position(memc_clone, 0);
- if (libmemcached_util_version_check(memc_clone, 1, 1, 2))
+ if (instance->major_version > 1 ||
+ (instance->major_version == 1 &&
+ instance->minor_version > 2))
{
- /* Binary protocol doesn't support deferred delete */
- memcached_st *bin_clone= memcached_clone(NULL, memc);
- test_true(bin_clone != NULL);
- test_true(memcached_behavior_set(bin_clone, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL, 1) == MEMCACHED_SUCCESS);
- test_true(memcached_delete(bin_clone, "foo", 3, 1) == MEMCACHED_INVALID_ARGUMENTS);
- memcached_free(bin_clone);
+ /* Binary protocol doesn't support deferred delete */
+ memcached_st *bin_clone= memcached_clone(NULL, memc);
+ test_true(bin_clone != NULL);
+ test_true(memcached_behavior_set(bin_clone, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL, 1) == MEMCACHED_SUCCESS);
+ test_true(memcached_delete(bin_clone, "foo", 3, 1) == MEMCACHED_INVALID_ARGUMENTS);
+ memcached_free(bin_clone);
- memcached_quit(memc_clone);
+ memcached_quit(memc_clone);
- /* If we know the server version, deferred delete should fail
- * with invalid arguments */
- test_true(memcached_delete(memc_clone, "foo", 3, 1) == MEMCACHED_INVALID_ARGUMENTS);
+ /* If we know the server version, deferred delete should fail
+ * with invalid arguments */
+ test_true(memcached_delete(memc_clone, "foo", 3, 1) == MEMCACHED_INVALID_ARGUMENTS);
- /* If we don't know the server version, we should get a protocol error */
- memcached_return_t rc= memcached_delete(memc, "foo", 3, 1);
+ /* If we don't know the server version, we should get a protocol error */
+ memcached_return_t rc= memcached_delete(memc, "foo", 3, 1);
- /* but there is a bug in some of the memcached servers (1.4) that treats
- * the counter as noreply so it doesn't send the proper error message
- */
- test_true(rc == MEMCACHED_PROTOCOL_ERROR || rc == MEMCACHED_NOTFOUND || rc == MEMCACHED_CLIENT_ERROR);
+ /* but there is a bug in some of the memcached servers (1.4) that treats
+ * the counter as noreply so it doesn't send the proper error message
+ */
+ test_true_got(rc == MEMCACHED_PROTOCOL_ERROR || rc == MEMCACHED_NOTFOUND || rc == MEMCACHED_CLIENT_ERROR || rc == MEMCACHED_INVALID_ARGUMENTS, memcached_strerror(NULL, rc));
- /* And buffered mode should be disabled and we should get protocol error */
- test_true(memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_BUFFER_REQUESTS, 1) == MEMCACHED_SUCCESS);
- rc= memcached_delete(memc, "foo", 3, 1);
- test_true(rc == MEMCACHED_PROTOCOL_ERROR || rc == MEMCACHED_NOTFOUND || rc == MEMCACHED_CLIENT_ERROR);
+ /* And buffered mode should be disabled and we should get protocol error */
+ test_true(memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_BUFFER_REQUESTS, 1) == MEMCACHED_SUCCESS);
+ rc= memcached_delete(memc, "foo", 3, 1);
+ test_true_got(rc == MEMCACHED_PROTOCOL_ERROR || rc == MEMCACHED_NOTFOUND || rc == MEMCACHED_CLIENT_ERROR || rc == MEMCACHED_INVALID_ARGUMENTS, memcached_strerror(NULL, rc));
- /* Same goes for noreply... */
- test_true(memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_NOREPLY, 1) == MEMCACHED_SUCCESS);
- rc= memcached_delete(memc, "foo", 3, 1);
- test_true(rc == MEMCACHED_PROTOCOL_ERROR || rc == MEMCACHED_NOTFOUND || rc == MEMCACHED_CLIENT_ERROR);
+ /* Same goes for noreply... */
+ test_true(memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_NOREPLY, 1) == MEMCACHED_SUCCESS);
+ rc= memcached_delete(memc, "foo", 3, 1);
+ test_true_got(rc == MEMCACHED_PROTOCOL_ERROR || rc == MEMCACHED_NOTFOUND || rc == MEMCACHED_CLIENT_ERROR || rc == MEMCACHED_INVALID_ARGUMENTS, memcached_strerror(NULL, rc));
- /* but a normal request should go through (and be buffered) */
- test_true((rc= memcached_delete(memc, "foo", 3, 0)) == MEMCACHED_BUFFERED);
- test_true(memcached_flush_buffers(memc) == MEMCACHED_SUCCESS);
+ /* but a normal request should go through (and be buffered) */
+ test_true((rc= memcached_delete(memc, "foo", 3, 0)) == MEMCACHED_BUFFERED);
+ test_true(memcached_flush_buffers(memc) == MEMCACHED_SUCCESS);
- test_true(memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_BUFFER_REQUESTS, 0) == MEMCACHED_SUCCESS);
- /* unbuffered noreply should be success */
- test_true(memcached_delete(memc, "foo", 3, 0) == MEMCACHED_SUCCESS);
- /* unbuffered with reply should be not found... */
- test_true(memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_NOREPLY, 0) == MEMCACHED_SUCCESS);
- test_true(memcached_delete(memc, "foo", 3, 0) == MEMCACHED_NOTFOUND);
+ test_true(memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_BUFFER_REQUESTS, 0) == MEMCACHED_SUCCESS);
+ /* unbuffered noreply should be success */
+ test_true(memcached_delete(memc, "foo", 3, 0) == MEMCACHED_SUCCESS);
+ /* unbuffered with reply should be not found... */
+ test_true(memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_NOREPLY, 0) == MEMCACHED_SUCCESS);
+ test_true(memcached_delete(memc, "foo", 3, 0) == MEMCACHED_NOTFOUND);
}
memcached_free(memc_clone);
return TEST_SUCCESS;
}
+
+static memcached_return_t stat_printer(memcached_server_instance_st server,
+ const char *key, size_t key_length,
+ const char *value, size_t value_length,
+ void *context)
+{
+ (void)server;
+ (void)context;
+ (void)key;
+ (void)key_length;
+ (void)value;
+ (void)value_length;
+
+ return MEMCACHED_SUCCESS;
+}
+
+static test_return_t memcached_stat_execute_test(memcached_st *memc)
+{
+ memcached_return_t rc= memcached_stat_execute(memc, NULL, stat_printer, NULL);
+ test_true(rc == MEMCACHED_SUCCESS);
+
+ rc= memcached_stat_execute(memc, "slabs", stat_printer, NULL);
+ test_true(rc == MEMCACHED_SUCCESS);
+
+ rc= memcached_stat_execute(memc, "items", stat_printer, NULL);
+ test_true(rc == MEMCACHED_SUCCESS);
+
+ rc= memcached_stat_execute(memc, "sizes", stat_printer, NULL);
+ test_true(rc == MEMCACHED_SUCCESS);
+
+ return TEST_SUCCESS;
+}
+
/*
* This test ensures that the failure counter isn't incremented during
* normal termination of the memcached instance.
return TEST_SUCCESS;
}
+/*
+ * This tests ensures expected disconnections (for some behavior changes
+ * for instance) do not wrongly increase failure counter
+ */
+static test_return_t wrong_failure_counter_two_test(memcached_st *memc)
+{
+ memcached_return rc;
+
+ memcached_st *memc_clone;
+ memc_clone= memcached_clone(NULL, memc);
+ test_true(memc_clone);
+
+ /* Set value to force connection to the server */
+ const char *key= "marmotte";
+ const char *value= "milka";
+ char *string = NULL;
+ size_t string_length;
+ uint32_t flags;
+
+ rc= memcached_set(memc_clone, key, strlen(key),
+ value, strlen(value),
+ (time_t)0, (uint32_t)0);
+ test_true_got(rc == MEMCACHED_SUCCESS || rc == MEMCACHED_BUFFERED, memcached_strerror(NULL, rc));
+
+
+ /* put failure limit to 1 */
+ rc= memcached_behavior_set(memc_clone, MEMCACHED_BEHAVIOR_SERVER_FAILURE_LIMIT, 1);
+ assert(rc == MEMCACHED_SUCCESS);
+
+ /* Put a retry timeout to effectively activate failure_limit effect */
+ rc= memcached_behavior_set(memc_clone, MEMCACHED_BEHAVIOR_RETRY_TIMEOUT, 1);
+ assert(rc == MEMCACHED_SUCCESS);
+
+ /* change behavior that triggers memcached_quit()*/
+ rc= memcached_behavior_set(memc_clone, MEMCACHED_BEHAVIOR_TCP_NODELAY, 1);
+ assert(rc == MEMCACHED_SUCCESS);
+
+
+ /* Check if we still are connected */
+ string= memcached_get(memc_clone, key, strlen(key),
+ &string_length, &flags, &rc);
+
+ test_true_got(rc == MEMCACHED_SUCCESS, memcached_strerror(NULL, rc));
+ test_true(string);
+ free(string);
+ memcached_free(memc_clone);
+
+ return TEST_SUCCESS;
+}
+
for (size_t x= 0; x < max_keys; ++x)
{
char k[251];
- key_length[x]= (size_t)snprintf(k, sizeof(k), "0200%zu", x);
+ key_length[x]= (size_t)snprintf(k, sizeof(k), "0200%lu", (unsigned long)x);
keys[x]= strdup(k);
assert(keys[x] != NULL);
rc= memcached_set(memc, keys[x], key_length[x], blob, sizeof(blob), 0, 0);
(void)memcached_get(memc, "dsf", 3, &length, &flags, &rc);
- test_true(rc == MEMCACHED_TIMEOUT);
+ test_true_got(rc == MEMCACHED_TIMEOUT, memcached_strerror(NULL, rc));
memcached_free(memc);
return TEST_SUCCESS;
}
+// Look for memory leak
+static test_return_t regression_bug_728286(memcached_st *unused)
+{
+ (void)unused;
+ memcached_server_st *servers = memcached_servers_parse("1.2.3.4:99");
+ memcached_server_free(servers);
+
+ return TEST_SUCCESS;
+}
+
+static test_return_t regression_bug_581030(memcached_st *unused)
+{
+ (void)unused;
+
+#ifndef DEBUG
+ memcached_stat_st *local_stat= memcached_stat(NULL, NULL, NULL);
+ test_false(local_stat);
+
+ memcached_stat_free(NULL, NULL);
+#endif
+
+ return TEST_SUCCESS;
+}
+
static void memcached_die(memcached_st* mc, memcached_return error, const char* what, uint32_t it)
{
fprintf(stderr, "Iteration #%u: ", it);
return TEST_SKIPPED;
}
- for (uint32_t x= 0; x < TEST_CONSTANT_CREATION; x++)
+ for (uint32_t x= 0; x < TEST_CONSTANT_CREATION; x++)
{
memcached_st* mc= memcached_create(NULL);
memcached_return rc;
if (rc == MEMCACHED_SUCCESS)
{
- if (x > 0)
+ if (x > 0)
{
size_t get_value_len;
char *get_value;
/* Clean the server before beginning testing */
test_st tests[] ={
+ {"util_version", 1, (test_callback_fn)util_version_test },
{"flush", 0, (test_callback_fn)flush_test },
{"init", 0, (test_callback_fn)init_test },
{"allocation", 0, (test_callback_fn)allocation_test },
#ifdef HAVE_LIBMEMCACHEDUTIL
{"connectionpool", 1, (test_callback_fn)connection_pool_test },
{"ping", 1, (test_callback_fn)ping_test },
- {"util_version", 1, (test_callback_fn)util_version_test },
#endif
{"test_get_last_disconnect", 1, (test_callback_fn)test_get_last_disconnect},
{"verbosity", 1, (test_callback_fn)test_verbosity},
{"test_server_failure", 1, (test_callback_fn)test_server_failure},
{"cull_servers", 1, (test_callback_fn)test_cull_servers},
+ {"memcached_stat_execute", 1, (test_callback_fn)memcached_stat_execute_test},
{0, 0, 0}
};
{0, 0, 0}
};
+test_st basic_tests[] ={
+ {"init", 1, (test_callback_fn)basic_init_test},
+ {"clone", 1, (test_callback_fn)basic_clone_test},
+ {"reset", 1, (test_callback_fn)basic_reset_stack_test},
+ {"reset heap", 1, (test_callback_fn)basic_reset_heap_test},
+ {"reset stack clone", 1, (test_callback_fn)basic_reset_stack_clone_test},
+ {"reset heap clone", 1, (test_callback_fn)basic_reset_heap_clone_test},
+ {0, 0, 0}
+};
+
test_st regression_binary_vs_block[] ={
{"block add", 1, (test_callback_fn)block_add_regression},
{"binary add", 1, (test_callback_fn)binary_add_regression},
{"string alloc with malloc failure", 0, (test_callback_fn)string_alloc_with_size_toobig },
{"string append", 0, (test_callback_fn)string_alloc_append },
{"string append failure (too big)", 0, (test_callback_fn)string_alloc_append_toobig },
+ {"string_alloc_append_multiple", 0, (test_callback_fn)string_alloc_append_multiple },
{0, 0, (test_callback_fn)0}
};
{"user_supplied_bug14", 1, (test_callback_fn)user_supplied_bug14 },
{"user_supplied_bug15", 1, (test_callback_fn)user_supplied_bug15 },
{"user_supplied_bug16", 1, (test_callback_fn)user_supplied_bug16 },
-#ifndef __sun
+#if !defined(__sun) && !defined(__OpenBSD__)
/*
** It seems to be something weird with the character sets..
** value_fetch is unable to parse the value line (iscntrl "fails"), so I
{"user_supplied_bug20", 1, (test_callback_fn)user_supplied_bug20 },
{"user_supplied_bug21", 1, (test_callback_fn)user_supplied_bug21 },
{"wrong_failure_counter_test", 1, (test_callback_fn)wrong_failure_counter_test},
+ {"wrong_failure_counter_two_test", 1, (test_callback_fn)wrong_failure_counter_two_test},
{0, 0, (test_callback_fn)0}
};
{"lp:490486", 1, (test_callback_fn)regression_bug_490486 },
{"lp:583031", 1, (test_callback_fn)regression_bug_583031 },
{"lp:?", 1, (test_callback_fn)regression_bug_ },
+ {"lp:728286", 1, (test_callback_fn)regression_bug_728286 },
+ {"lp:581030", 1, (test_callback_fn)regression_bug_581030 },
{0, 0, (test_callback_fn)0}
};
{0, 0, (test_callback_fn)0}
};
+test_st murmur_availability[] ={
+ {"murmur_avaibility_test", 0, (test_callback_fn)murmur_avaibility_test},
+ {0, 0, (test_callback_fn)0}
+};
+
#if 0
test_st hash_sanity[] ={
{"hash sanity", 0, (test_callback_fn)hash_sanity_test},
};
test_st error_conditions[] ={
- {"memcached_get_MEMCACHED_ERRNO", 0, (test_callback_fn)memcached_get_MEMCACHED_ERRNO },
- {"memcached_get_MEMCACHED_NOTFOUND", 0, (test_callback_fn)memcached_get_MEMCACHED_NOTFOUND },
- {"memcached_get_by_key_MEMCACHED_ERRNO", 0, (test_callback_fn)memcached_get_by_key_MEMCACHED_ERRNO },
- {"memcached_get_by_key_MEMCACHED_NOTFOUND", 0, (test_callback_fn)memcached_get_by_key_MEMCACHED_NOTFOUND },
+ {"memcached_get(MEMCACHED_ERRNO)", 0, (test_callback_fn)memcached_get_MEMCACHED_ERRNO },
+ {"memcached_get(MEMCACHED_NOTFOUND)", 0, (test_callback_fn)memcached_get_MEMCACHED_NOTFOUND },
+ {"memcached_get_by_key(MEMCACHED_ERRNO)", 0, (test_callback_fn)memcached_get_by_key_MEMCACHED_ERRNO },
+ {"memcached_get_by_key(MEMCACHED_NOTFOUND)", 0, (test_callback_fn)memcached_get_by_key_MEMCACHED_NOTFOUND },
+ {"memcached_get_by_key(MEMCACHED_NOTFOUND)", 0, (test_callback_fn)memcached_get_by_key_MEMCACHED_NOTFOUND },
+ {"memcached_increment(MEMCACHED_NO_SERVERS)", 0, (test_callback_fn)memcached_increment_MEMCACHED_NO_SERVERS },
+ {0, 0, (test_callback_fn)0}
+};
+
+
+test_st parser_tests[] ={
+ {"behavior", 0, (test_callback_fn)behavior_parser_test },
+ {"boolean_options", 0, (test_callback_fn)parser_boolean_options_test },
+ {"configure_file", 0, (test_callback_fn)memcached_create_with_options_with_filename },
+ {"distribtions", 0, (test_callback_fn)parser_distribution_test },
+ {"hash", 0, (test_callback_fn)parser_hash_test },
+ {"libmemcached_check_configuration", 0, (test_callback_fn)libmemcached_check_configuration_test },
+ {"libmemcached_check_configuration_with_filename", 0, (test_callback_fn)libmemcached_check_configuration_with_filename_test },
+ {"memcached_parse_configure_file", 0, (test_callback_fn)memcached_parse_configure_file_test },
+ {"number_options", 0, (test_callback_fn)parser_number_options_test },
+ {"randomly generated options", 0, (test_callback_fn)random_statement_build_test },
+ {"prefix_key", 0, (test_callback_fn)parser_key_prefix_test },
+ {"server", 0, (test_callback_fn)server_test },
+ {"servers", 0, (test_callback_fn)servers_test },
{0, 0, (test_callback_fn)0}
};
#if 0
{"hash_sanity", 0, 0, hash_sanity},
#endif
+ {"basic", 0, 0, basic_tests},
{"hsieh_availability", 0, 0, hsieh_availability},
+ {"murmur_availability", 0, 0, murmur_availability},
{"block", 0, 0, tests},
{"binary", (test_callback_fn)pre_binary, 0, tests},
{"nonblock", (test_callback_fn)pre_nonblock, 0, tests},
{"behaviors", 0, 0, behavior_tests},
{"regression_binary_vs_block", (test_callback_fn)key_setup, (test_callback_fn)key_teardown, regression_binary_vs_block},
{"error_conditions", 0, 0, error_conditions},
+ {"parser", 0, 0, parser_tests},
{0, 0, 0, 0}
};
projects / m6w6 / libmemcached / blobdiff