X-Git-Url: https://git.m6w6.name/?a=blobdiff_plain;f=tests%2Fmem_functions.c;h=740e34de1fbd98e57d0648bf9b74bb566b8dd12f;hb=b175c6025c67cb8fa756750d53fb96fd888076de;hp=d2b59112693558879db547ef5c59ca8008fdd9d3;hpb=09ef521d2c88955d04d6c91f7b5a1671a1955130;p=m6w6%2Flibmemcached diff --git a/tests/mem_functions.c b/tests/mem_functions.c index d2b59112..740e34de 100644 --- a/tests/mem_functions.c +++ b/tests/mem_functions.c @@ -10,10 +10,11 @@ Sample test application. */ -#include "libmemcached/common.h" +#include "config.h" #include #include +#include #include #include #include @@ -22,20 +23,18 @@ #include #include #include + +#include "libmemcached/common.h" + #include "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 "test.h" + #ifdef HAVE_LIBMEMCACHEDUTIL #include #include "libmemcached/memcached_util.h" @@ -98,6 +97,23 @@ static memcached_return_t server_display_function(const memcached_st *ptr __att return MEMCACHED_SUCCESS; } +static memcached_return_t dump_server_information(const memcached_st *ptr __attribute__((unused)), + const memcached_server_st *instance, + void *context) +{ + /* Do Nothing */ + FILE *stream= (FILE *)context; + + 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 __attribute__((unused))) { size_t bigger= 0; /* Prime the value for the test_true in server_display_function */ @@ -682,7 +698,6 @@ static test_return_t add_test(memcached_st *memc) */ static test_return_t add_wrapper(memcached_st *memc) { - unsigned int x; unsigned int max= 10000; #ifdef __sun max= 10; @@ -691,7 +706,7 @@ static test_return_t add_wrapper(memcached_st *memc) max= 10; #endif - for (x= 0; x < max; x++) + for (uint32_t x= 0; x < max; x++) add_test(memc); return TEST_SUCCESS; @@ -1685,7 +1700,7 @@ static test_return_t mget_execute(memcached_st *memc) { 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); @@ -2056,7 +2071,9 @@ static test_return_t fetch_all_results(memcached_st *memc) free(return_value); } - 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 */ @@ -2783,7 +2800,7 @@ static test_return_t user_supplied_bug16(memcached_st *memc) 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) { @@ -2947,6 +2964,11 @@ static void fail(int unused __attribute__((unused))) 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; @@ -2995,6 +3017,7 @@ static test_return_t _user_supplied_bug21(memcached_st* memc, size_t key_count) memcached_free(memc_clone); return TEST_SUCCESS; +#endif } static test_return_t user_supplied_bug21(memcached_st *memc) @@ -3445,7 +3468,7 @@ static test_return_t mget_read(memcached_st *memc) memcached_return_t rc; 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)); test_true(fetch_all_results(memc) == TEST_SUCCESS); return TEST_SUCCESS; @@ -3456,7 +3479,7 @@ static test_return_t mget_read_result(memcached_st *memc) memcached_return_t rc; 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; @@ -3483,7 +3506,7 @@ static test_return_t mget_read_function(memcached_st *memc) memcached_execute_fn callbacks[1]; 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; @@ -3531,7 +3554,7 @@ static test_return_t add_host_test1(memcached_st *memc) { 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); @@ -3599,7 +3622,7 @@ static test_return_t pre_nonblock_binary(memcached_st *memc) // 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, 3, 0)) { memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_NO_BLOCK, 0); rc = memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL, 1); @@ -3724,23 +3747,14 @@ static test_return_t pre_behavior_ketama_weighted(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, 3, 0)) { 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; } @@ -4156,7 +4170,11 @@ static test_return_t noreply_test(memcached_st *memc) 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: @@ -4204,7 +4222,11 @@ static test_return_t noreply_test(memcached_st *memc) { 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), @@ -4341,14 +4363,15 @@ static void* connection_release(void *arg) 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); @@ -4375,7 +4398,7 @@ static test_return_t connection_pool_test(memcached_st *memc) 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); @@ -4384,7 +4407,7 @@ static test_return_t connection_pool_test(memcached_st *memc) } // 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); } @@ -4411,8 +4434,8 @@ static test_return_t connection_pool_test(memcached_st *memc) 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; } @@ -4424,6 +4447,18 @@ static test_return_t util_version_test(memcached_st *memc) 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= @@ -4432,24 +4467,24 @@ static test_return_t util_version_test(memcached_st *memc) 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); @@ -5039,14 +5074,11 @@ 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; } @@ -5065,12 +5097,7 @@ 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); @@ -5104,14 +5131,11 @@ 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; } @@ -5130,12 +5154,7 @@ 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); @@ -5317,7 +5336,7 @@ static test_return_t regression_bug_434843(memcached_st *memc) { 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); } @@ -5458,7 +5477,7 @@ static test_return_t regression_bug_447342(memcached_st *memc) 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; @@ -5474,7 +5493,7 @@ static test_return_t regression_bug_447342(memcached_st *memc) { 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); @@ -5575,54 +5594,58 @@ static test_return_t regression_bug_447342(memcached_st *memc) static test_return_t regression_bug_463297(memcached_st *memc) { - memcached_st *memc_clone= memcached_clone(NULL, memc); - test_true(memc_clone != NULL); - test_true(memcached_version(memc_clone) == MEMCACHED_SUCCESS); + memcached_st *memc_clone= memcached_clone(NULL, memc); + 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); @@ -5748,6 +5771,39 @@ static test_return_t test_cull_servers(memcached_st *memc) 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. @@ -5834,7 +5890,7 @@ static test_return_t regression_bug_490486(memcached_st *memc) 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); @@ -6080,6 +6136,7 @@ static test_return_t sasl_auth_test(memcached_st *memc) /* 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 }, @@ -6135,12 +6192,12 @@ test_st tests[] ={ #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} }; @@ -6205,7 +6262,7 @@ test_st user_tests[] ={ {"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