X-Git-Url: https://git.m6w6.name/?a=blobdiff_plain;f=tests%2Fmem_functions.c;h=c436b261cd7e63e243d6ab5eb06eb3ddef0e89d9;hb=897b7fadb5f628c794307f8a6caa7c992dd01ff4;hp=d2b59112693558879db547ef5c59ca8008fdd9d3;hpb=582ffd185904b349b5840880f85df75a773adcf7;p=awesomized%2Flibmemcached diff --git a/tests/mem_functions.c b/tests/mem_functions.c index d2b59112..c436b261 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" @@ -682,7 +681,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 +689,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; @@ -2783,7 +2781,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) { @@ -3599,7 +3597,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 +3722,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; } @@ -4432,24 +4421,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,15 +5028,12 @@ 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); + memcached_free(tl_memc_h); + return TEST_SUCCESS; } @@ -5065,12 +5051,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,15 +5085,12 @@ 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); + memcached_free(tl_memc_h); + return TEST_SUCCESS; } @@ -5130,12 +5108,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); @@ -5575,54 +5548,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(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(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(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(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(rc == MEMCACHED_PROTOCOL_ERROR || rc == MEMCACHED_NOTFOUND || rc == MEMCACHED_CLIENT_ERROR); - /* 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 +5725,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. @@ -6080,6 +6090,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 +6146,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 +6216,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