From 9ccc920d86467ea463a07fd99e5ef4ea804c7800 Mon Sep 17 00:00:00 2001 From: Brian Aker Date: Thu, 9 Feb 2012 19:06:22 -0800 Subject: [PATCH] Split all mem_function out so that we can reuse the bulk of the tests at will. --- tests/libmemcached-1.0/all_tests.cc | 92 ++ tests/libmemcached-1.0/all_tests.h | 471 +++++++++ tests/libmemcached-1.0/include.am | 40 +- tests/libmemcached-1.0/mem_functions.cc | 982 +++--------------- tests/libmemcached-1.0/mem_functions.h | 180 ++++ tests/libmemcached-1.0/setup_and_teardowns.cc | 258 +++++ tests/libmemcached-1.0/setup_and_teardowns.h | 60 ++ tests/libmemcached_world.h | 50 +- tests/print.h | 9 - 9 files changed, 1271 insertions(+), 871 deletions(-) create mode 100644 tests/libmemcached-1.0/all_tests.cc create mode 100644 tests/libmemcached-1.0/all_tests.h create mode 100644 tests/libmemcached-1.0/mem_functions.h create mode 100644 tests/libmemcached-1.0/setup_and_teardowns.cc create mode 100644 tests/libmemcached-1.0/setup_and_teardowns.h diff --git a/tests/libmemcached-1.0/all_tests.cc b/tests/libmemcached-1.0/all_tests.cc new file mode 100644 index 00000000..5aa59f88 --- /dev/null +++ b/tests/libmemcached-1.0/all_tests.cc @@ -0,0 +1,92 @@ +/* vim:expandtab:shiftwidth=2:tabstop=2:smarttab: + * + * Libmemcached Client and Server + * + * Copyright (C) 2012 Data Differential, http://datadifferential.com/ + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are + * met: + * + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * + * * Redistributions in binary form must reproduce the above + * copyright notice, this list of conditions and the following disclaimer + * in the documentation and/or other materials provided with the + * distribution. + * + * * The names of its contributors may not be used to endorse or + * promote products derived from this software without specific prior + * written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR + * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT + * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, + * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT + * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE + * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + * + */ + +#define TEST_PORT_BASE MEMCACHED_DEFAULT_PORT +10 + +#include +#include + +#include "tests/basic.h" +#include "tests/debug.h" +#include "tests/deprecated.h" +#include "tests/error_conditions.h" +#include "tests/exist.h" +#include "tests/ketama.h" +#include "tests/namespace.h" +#include "tests/parser.h" +#include "tests/libmemcached-1.0/dump.h" +#include "tests/libmemcached-1.0/generate.h" +#include "tests/libmemcached-1.0/haldenbrand.h" +#include "tests/libmemcached-1.0/stat.h" +#include "tests/touch.h" +#include "tests/callbacks.h" +#include "tests/pool.h" +#include "tests/print.h" +#include "tests/replication.h" +#include "tests/server_add.h" +#include "tests/virtual_buckets.h" + +#include "tests/libmemcached-1.0/setup_and_teardowns.h" + + +#include "tests/libmemcached-1.0/mem_functions.h" + +/* Collections we are running */ +#include "tests/libmemcached-1.0/all_tests.h" + +#include "tests/libmemcached_world.h" + +void get_world(Framework *world) +{ + world->collections= collection; + + world->_create= (test_callback_create_fn*)world_create; + world->_destroy= (test_callback_destroy_fn*)world_destroy; + + world->item._startup= (test_callback_fn*)world_test_startup; + world->item.set_pre((test_callback_fn*)world_pre_run); + world->item.set_flush((test_callback_fn*)world_flush); + world->item.set_post((test_callback_fn*)world_post_run); + world->_on_error= (test_callback_error_fn*)world_on_error; + + world->collection_startup= (test_callback_fn*)world_container_startup; + world->collection_shutdown= (test_callback_fn*)world_container_shutdown; + + world->set_runner(&defualt_libmemcached_runner); + + world->set_socket(); +} diff --git a/tests/libmemcached-1.0/all_tests.h b/tests/libmemcached-1.0/all_tests.h new file mode 100644 index 00000000..a0103968 --- /dev/null +++ b/tests/libmemcached-1.0/all_tests.h @@ -0,0 +1,471 @@ +/* vim:expandtab:shiftwidth=2:tabstop=2:smarttab: + * + * Libmemcached Client and Server + * + * Copyright (C) 2012 Data Differential, http://datadifferential.com/ + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are + * met: + * + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * + * * Redistributions in binary form must reproduce the above + * copyright notice, this list of conditions and the following disclaimer + * in the documentation and/or other materials provided with the + * distribution. + * + * * The names of its contributors may not be used to endorse or + * promote products derived from this software without specific prior + * written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR + * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT + * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, + * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT + * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE + * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + * + */ + +#pragma once + + +/* Clean the server before beginning testing */ +test_st tests[] ={ + {"util_version", true, (test_callback_fn*)util_version_test }, + {"flush", false, (test_callback_fn*)flush_test }, + {"init", false, (test_callback_fn*)init_test }, + {"allocation", false, (test_callback_fn*)allocation_test }, + {"server_list_null_test", false, (test_callback_fn*)server_list_null_test}, + {"server_unsort", false, (test_callback_fn*)server_unsort_test}, + {"server_sort", false, (test_callback_fn*)server_sort_test}, + {"server_sort2", false, (test_callback_fn*)server_sort2_test}, + {"memcached_server_remove", false, (test_callback_fn*)memcached_server_remove_test}, + {"clone_test", false, (test_callback_fn*)clone_test }, + {"connection_test", false, (test_callback_fn*)connection_test}, + {"callback_test", false, (test_callback_fn*)callback_test}, + {"userdata_test", false, (test_callback_fn*)userdata_test}, + {"memcached_set()", false, (test_callback_fn*)set_test }, + {"memcached_set() 2", false, (test_callback_fn*)set_test2 }, + {"memcached_set() 3", false, (test_callback_fn*)set_test3 }, + {"add", true, (test_callback_fn*)add_test }, + {"memcached_fetch_result(MEMCACHED_NOTFOUND)", true, (test_callback_fn*)memcached_fetch_result_NOT_FOUND }, + {"replace", true, (test_callback_fn*)replace_test }, + {"delete", true, (test_callback_fn*)delete_test }, + {"get", true, (test_callback_fn*)get_test }, + {"get2", false, (test_callback_fn*)get_test2 }, + {"get3", false, (test_callback_fn*)get_test3 }, + {"get4", false, (test_callback_fn*)get_test4 }, + {"partial mget", false, (test_callback_fn*)get_test5 }, + {"stats_servername", false, (test_callback_fn*)stats_servername_test }, + {"increment", false, (test_callback_fn*)increment_test }, + {"increment_with_initial", true, (test_callback_fn*)increment_with_initial_test }, + {"decrement", false, (test_callback_fn*)decrement_test }, + {"decrement_with_initial", true, (test_callback_fn*)decrement_with_initial_test }, + {"increment_by_key", false, (test_callback_fn*)increment_by_key_test }, + {"increment_with_initial_by_key", true, (test_callback_fn*)increment_with_initial_by_key_test }, + {"decrement_by_key", false, (test_callback_fn*)decrement_by_key_test }, + {"decrement_with_initial_by_key", true, (test_callback_fn*)decrement_with_initial_by_key_test }, + {"binary_increment_with_prefix", true, (test_callback_fn*)binary_increment_with_prefix_test }, + {"quit", false, (test_callback_fn*)quit_test }, + {"mget", true, (test_callback_fn*)mget_test }, + {"mget_result", true, (test_callback_fn*)mget_result_test }, + {"mget_result_alloc", true, (test_callback_fn*)mget_result_alloc_test }, + {"mget_result_function", true, (test_callback_fn*)mget_result_function }, + {"mget_execute", true, (test_callback_fn*)mget_execute }, + {"mget_end", false, (test_callback_fn*)mget_end }, + {"get_stats", false, (test_callback_fn*)get_stats }, + {"add_host_test", false, (test_callback_fn*)add_host_test }, + {"add_host_test_1", false, (test_callback_fn*)add_host_test1 }, + {"get_stats_keys", false, (test_callback_fn*)get_stats_keys }, + {"version_string_test", true, (test_callback_fn*)version_string_test}, + {"memcached_mget() mixed memcached_get()", true, (test_callback_fn*)memcached_mget_mixed_memcached_get_TEST}, + {"bad_key", true, (test_callback_fn*)bad_key_test }, + {"memcached_server_cursor", true, (test_callback_fn*)memcached_server_cursor_test }, + {"read_through", true, (test_callback_fn*)read_through }, + {"delete_through", true, (test_callback_fn*)test_MEMCACHED_CALLBACK_DELETE_TRIGGER }, + {"noreply", true, (test_callback_fn*)noreply_test}, + {"analyzer", true, (test_callback_fn*)analyzer_test}, + {"memcached_pool_st", true, (test_callback_fn*)connection_pool_test }, + {"memcached_pool_st #2", true, (test_callback_fn*)connection_pool2_test }, +#if 0 + {"memcached_pool_st #3", true, (test_callback_fn*)connection_pool3_test }, +#endif + {"memcached_pool_test", true, (test_callback_fn*)memcached_pool_test }, + {"test_get_last_disconnect", true, (test_callback_fn*)test_get_last_disconnect}, + {"verbosity", true, (test_callback_fn*)test_verbosity}, + {"memcached_stat_execute", true, (test_callback_fn*)memcached_stat_execute_test}, + {"memcached_exist(MEMCACHED_NOTFOUND)", true, (test_callback_fn*)memcached_exist_NOTFOUND }, + {"memcached_exist(MEMCACHED_SUCCESS)", true, (test_callback_fn*)memcached_exist_SUCCESS }, + {"memcached_exist_by_key(MEMCACHED_NOTFOUND)", true, (test_callback_fn*)memcached_exist_by_key_NOTFOUND }, + {"memcached_exist_by_key(MEMCACHED_SUCCESS)", true, (test_callback_fn*)memcached_exist_by_key_SUCCESS }, + {"memcached_touch", 0, (test_callback_fn*)test_memcached_touch}, + {"memcached_touch_with_prefix", 0, (test_callback_fn*)test_memcached_touch_by_key}, +#if 0 + {"memcached_dump() no data", true, (test_callback_fn*)memcached_dump_TEST }, +#endif + {"memcached_dump() with data", true, (test_callback_fn*)memcached_dump_TEST2 }, + {0, 0, 0} +}; + +test_st touch_tests[] ={ + {"memcached_touch", 0, (test_callback_fn*)test_memcached_touch}, + {"memcached_touch_with_prefix", 0, (test_callback_fn*)test_memcached_touch_by_key}, + {0, 0, 0} +}; + +test_st memcached_stat_tests[] ={ + {"memcached_stat() INVALID ARG", 0, (test_callback_fn*)memcached_stat_TEST}, + {"memcached_stat()", 0, (test_callback_fn*)memcached_stat_TEST2}, + {0, 0, 0} +}; + +test_st behavior_tests[] ={ + {"libmemcached_string_behavior()", false, (test_callback_fn*)libmemcached_string_behavior_test}, + {"libmemcached_string_distribution()", false, (test_callback_fn*)libmemcached_string_distribution_test}, + {"behavior_test", false, (test_callback_fn*)behavior_test}, + {"MEMCACHED_BEHAVIOR_CORK", false, (test_callback_fn*)MEMCACHED_BEHAVIOR_CORK_test}, + {"MEMCACHED_BEHAVIOR_TCP_KEEPALIVE", false, (test_callback_fn*)MEMCACHED_BEHAVIOR_TCP_KEEPALIVE_test}, + {"MEMCACHED_BEHAVIOR_TCP_KEEPIDLE", false, (test_callback_fn*)MEMCACHED_BEHAVIOR_TCP_KEEPIDLE_test}, + {"MEMCACHED_BEHAVIOR_POLL_TIMEOUT", false, (test_callback_fn*)MEMCACHED_BEHAVIOR_POLL_TIMEOUT_test}, + {"MEMCACHED_CALLBACK_DELETE_TRIGGER_and_MEMCACHED_BEHAVIOR_NOREPLY", false, (test_callback_fn*)test_MEMCACHED_CALLBACK_DELETE_TRIGGER_and_MEMCACHED_BEHAVIOR_NOREPLY}, + {0, 0, 0} +}; + +test_st libmemcachedutil_tests[] ={ + {"libmemcached_util_ping()", true, (test_callback_fn*)ping_test }, + {"libmemcached_util_getpid()", true, (test_callback_fn*)getpid_test }, + {"libmemcached_util_getpid(MEMCACHED_CONNECTION_FAILURE)", true, (test_callback_fn*)getpid_connection_failure_test }, + {0, 0, 0} +}; + +test_st basic_tests[] ={ + {"init", true, (test_callback_fn*)basic_init_test}, + {"clone", true, (test_callback_fn*)basic_clone_test}, + {"reset", true, (test_callback_fn*)basic_reset_stack_test}, + {"reset heap", true, (test_callback_fn*)basic_reset_heap_test}, + {"reset stack clone", true, (test_callback_fn*)basic_reset_stack_clone_test}, + {"reset heap clone", true, (test_callback_fn*)basic_reset_heap_clone_test}, + {"memcached_return_t", false, (test_callback_fn*)memcached_return_t_TEST }, + {0, 0, 0} +}; + +test_st regression_binary_vs_block[] ={ + {"block add", true, (test_callback_fn*)block_add_regression}, + {"binary add", true, (test_callback_fn*)binary_add_regression}, + {0, 0, 0} +}; + +test_st async_tests[] ={ + {"add", true, (test_callback_fn*)add_wrapper }, + {0, 0, 0} +}; + +test_st memcached_server_get_last_disconnect_tests[] ={ + {"memcached_server_get_last_disconnect()", false, (test_callback_fn*)test_multiple_get_last_disconnect}, + {0, 0, (test_callback_fn*)0} +}; + + +test_st result_tests[] ={ + {"result static", false, (test_callback_fn*)result_static}, + {"result alloc", false, (test_callback_fn*)result_alloc}, + {0, 0, (test_callback_fn*)0} +}; + +test_st version_1_2_3[] ={ + {"append", false, (test_callback_fn*)append_test }, + {"prepend", false, (test_callback_fn*)prepend_test }, + {"cas", false, (test_callback_fn*)cas_test }, + {"cas2", false, (test_callback_fn*)cas2_test }, + {"append_binary", false, (test_callback_fn*)append_binary_test }, + {0, 0, (test_callback_fn*)0} +}; + +test_st haldenbrand_TESTS[] ={ + {"memcached_set", false, (test_callback_fn*)haldenbrand_TEST1 }, + {"memcached_get()", false, (test_callback_fn*)haldenbrand_TEST2 }, + {"memcached_mget()", false, (test_callback_fn*)haldenbrand_TEST3 }, + {0, 0, (test_callback_fn*)0} +}; + +test_st user_tests[] ={ + {"user_supplied_bug4", true, (test_callback_fn*)user_supplied_bug4 }, + {"user_supplied_bug5", true, (test_callback_fn*)user_supplied_bug5 }, + {"user_supplied_bug6", true, (test_callback_fn*)user_supplied_bug6 }, + {"user_supplied_bug7", true, (test_callback_fn*)user_supplied_bug7 }, + {"user_supplied_bug8", true, (test_callback_fn*)user_supplied_bug8 }, + {"user_supplied_bug9", true, (test_callback_fn*)user_supplied_bug9 }, + {"user_supplied_bug10", true, (test_callback_fn*)user_supplied_bug10 }, + {"user_supplied_bug11", true, (test_callback_fn*)user_supplied_bug11 }, + {"user_supplied_bug12", true, (test_callback_fn*)user_supplied_bug12 }, + {"user_supplied_bug13", true, (test_callback_fn*)user_supplied_bug13 }, + {"user_supplied_bug14", true, (test_callback_fn*)user_supplied_bug14 }, + {"user_supplied_bug15", true, (test_callback_fn*)user_supplied_bug15 }, + {"user_supplied_bug16", true, (test_callback_fn*)user_supplied_bug16 }, +#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 + ** guess I need to find out how this is supposed to work.. Perhaps I need + ** to run the test in a specific locale (I tried zh_CN.UTF-8 without success, + ** so just disable the code for now...). + */ + {"user_supplied_bug17", true, (test_callback_fn*)user_supplied_bug17 }, +#endif + {"user_supplied_bug18", true, (test_callback_fn*)user_supplied_bug18 }, + {"user_supplied_bug19", true, (test_callback_fn*)user_supplied_bug19 }, + {"user_supplied_bug20", true, (test_callback_fn*)user_supplied_bug20 }, + {"user_supplied_bug21", true, (test_callback_fn*)user_supplied_bug21 }, + {"wrong_failure_counter_test", true, (test_callback_fn*)wrong_failure_counter_test}, + {"wrong_failure_counter_two_test", true, (test_callback_fn*)wrong_failure_counter_two_test}, + {0, 0, (test_callback_fn*)0} +}; + +test_st replication_tests[]= { + {"set", true, (test_callback_fn*)replication_set_test }, + {"get", false, (test_callback_fn*)replication_get_test }, + {"mget", false, (test_callback_fn*)replication_mget_test }, + {"delete", true, (test_callback_fn*)replication_delete_test }, + {"rand_mget", false, (test_callback_fn*)replication_randomize_mget_test }, + {"miss", false, (test_callback_fn*)replication_miss_test }, + {"fail", false, (test_callback_fn*)replication_randomize_mget_fail_test }, + {0, 0, (test_callback_fn*)0} +}; + +/* + * The following test suite is used to verify that we don't introduce + * regression bugs. If you want more information about the bug / test, + * you should look in the bug report at + * http://bugs.launchpad.net/libmemcached + */ +test_st regression_tests[]= { + {"lp:434484", true, (test_callback_fn*)regression_bug_434484 }, + {"lp:434843", true, (test_callback_fn*)regression_bug_434843 }, + {"lp:434843-buffered", true, (test_callback_fn*)regression_bug_434843_buffered }, + {"lp:421108", true, (test_callback_fn*)regression_bug_421108 }, + {"lp:442914", true, (test_callback_fn*)regression_bug_442914 }, + {"lp:447342", true, (test_callback_fn*)regression_bug_447342 }, + {"lp:463297", true, (test_callback_fn*)regression_bug_463297 }, + {"lp:490486", true, (test_callback_fn*)regression_bug_490486 }, + {"lp:583031", true, (test_callback_fn*)regression_bug_583031 }, + {"lp:?", true, (test_callback_fn*)regression_bug_ }, + {"lp:728286", true, (test_callback_fn*)regression_bug_728286 }, + {"lp:581030", true, (test_callback_fn*)regression_bug_581030 }, + {"lp:71231153 connect()", true, (test_callback_fn*)regression_bug_71231153_connect }, + {"lp:71231153 poll()", true, (test_callback_fn*)regression_bug_71231153_poll }, + {"lp:655423", true, (test_callback_fn*)regression_bug_655423 }, + {"lp:490520", true, (test_callback_fn*)regression_bug_490520 }, + {"lp:854604", true, (test_callback_fn*)regression_bug_854604 }, + {0, false, (test_callback_fn*)0} +}; + +test_st ketama_compatibility[]= { + {"libmemcached", true, (test_callback_fn*)ketama_compatibility_libmemcached }, + {"spymemcached", true, (test_callback_fn*)ketama_compatibility_spymemcached }, + {0, 0, (test_callback_fn*)0} +}; + +test_st generate_tests[] ={ + {"generate_pairs", true, (test_callback_fn*)generate_pairs }, + {"generate_data", true, (test_callback_fn*)generate_data }, + {"get_read", false, (test_callback_fn*)get_read }, + {"delete_generate", false, (test_callback_fn*)delete_generate }, + {"generate_buffer_data", true, (test_callback_fn*)generate_buffer_data }, + {"delete_buffer", false, (test_callback_fn*)delete_buffer_generate}, + {"generate_data", true, (test_callback_fn*)generate_data }, + {"mget_read", false, (test_callback_fn*)mget_read }, + {"mget_read_result", false, (test_callback_fn*)mget_read_result }, + {"memcached_fetch_result() use internal result", false, (test_callback_fn*)mget_read_internal_result }, + {"memcached_fetch_result() partial read", false, (test_callback_fn*)mget_read_partial_result }, + {"mget_read_function", false, (test_callback_fn*)mget_read_function }, + {"cleanup", true, (test_callback_fn*)cleanup_pairs }, + {"generate_large_pairs", true, (test_callback_fn*)generate_large_pairs }, + {"generate_data", true, (test_callback_fn*)generate_data }, + {"generate_buffer_data", true, (test_callback_fn*)generate_buffer_data }, + {"cleanup", true, (test_callback_fn*)cleanup_pairs }, + {0, 0, (test_callback_fn*)0} +}; + +test_st consistent_tests[] ={ + {"generate_pairs", true, (test_callback_fn*)generate_pairs }, + {"generate_data", true, (test_callback_fn*)generate_data }, + {"get_read", 0, (test_callback_fn*)get_read_count }, + {"cleanup", true, (test_callback_fn*)cleanup_pairs }, + {0, 0, (test_callback_fn*)0} +}; + +test_st consistent_weighted_tests[] ={ + {"generate_pairs", true, (test_callback_fn*)generate_pairs }, + {"generate_data", true, (test_callback_fn*)generate_data_with_stats }, + {"get_read", false, (test_callback_fn*)get_read_count }, + {"cleanup", true, (test_callback_fn*)cleanup_pairs }, + {0, 0, (test_callback_fn*)0} +}; + +test_st hsieh_availability[] ={ + {"hsieh_avaibility_test", false, (test_callback_fn*)hsieh_avaibility_test}, + {0, 0, (test_callback_fn*)0} +}; + +test_st murmur_availability[] ={ + {"murmur_avaibility_test", false, (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}, + {0, 0, (test_callback_fn*)0} +}; +#endif + +test_st ketama_auto_eject_hosts[] ={ + {"auto_eject_hosts", true, (test_callback_fn*)auto_eject_hosts }, + {"output_ketama_weighted_keys", true, (test_callback_fn*)output_ketama_weighted_keys }, + {0, 0, (test_callback_fn*)0} +}; + +test_st hash_tests[] ={ + {"one_at_a_time_run", false, (test_callback_fn*)one_at_a_time_run }, + {"md5", false, (test_callback_fn*)md5_run }, + {"crc", false, (test_callback_fn*)crc_run }, + {"fnv1_64", false, (test_callback_fn*)fnv1_64_run }, + {"fnv1a_64", false, (test_callback_fn*)fnv1a_64_run }, + {"fnv1_32", false, (test_callback_fn*)fnv1_32_run }, + {"fnv1a_32", false, (test_callback_fn*)fnv1a_32_run }, + {"hsieh", false, (test_callback_fn*)hsieh_run }, + {"murmur", false, (test_callback_fn*)murmur_run }, + {"jenkis", false, (test_callback_fn*)jenkins_run }, + {"memcached_get_hashkit", false, (test_callback_fn*)memcached_get_hashkit_test }, + {0, 0, (test_callback_fn*)0} +}; + +test_st error_conditions[] ={ + {"memcached_get(MEMCACHED_ERRNO)", false, (test_callback_fn*)memcached_get_MEMCACHED_ERRNO }, + {"memcached_get(MEMCACHED_NOTFOUND)", false, (test_callback_fn*)memcached_get_MEMCACHED_NOTFOUND }, + {"memcached_get_by_key(MEMCACHED_ERRNO)", false, (test_callback_fn*)memcached_get_by_key_MEMCACHED_ERRNO }, + {"memcached_get_by_key(MEMCACHED_NOTFOUND)", false, (test_callback_fn*)memcached_get_by_key_MEMCACHED_NOTFOUND }, + {"memcached_get_by_key(MEMCACHED_NOTFOUND)", false, (test_callback_fn*)memcached_get_by_key_MEMCACHED_NOTFOUND }, + {"memcached_increment(MEMCACHED_NO_SERVERS)", false, (test_callback_fn*)memcached_increment_MEMCACHED_NO_SERVERS }, + {0, 0, (test_callback_fn*)0} +}; + +test_st parser_tests[] ={ + {"behavior", false, (test_callback_fn*)behavior_parser_test }, + {"boolean_options", false, (test_callback_fn*)parser_boolean_options_test }, + {"configure_file", false, (test_callback_fn*)memcached_create_with_options_with_filename }, + {"distribtions", false, (test_callback_fn*)parser_distribution_test }, + {"hash", false, (test_callback_fn*)parser_hash_test }, + {"libmemcached_check_configuration", false, (test_callback_fn*)libmemcached_check_configuration_test }, + {"libmemcached_check_configuration_with_filename", false, (test_callback_fn*)libmemcached_check_configuration_with_filename_test }, + {"number_options", false, (test_callback_fn*)parser_number_options_test }, + {"randomly generated options", false, (test_callback_fn*)random_statement_build_test }, + {"namespace", false, (test_callback_fn*)parser_key_prefix_test }, + {"server", false, (test_callback_fn*)server_test }, + {"bad server strings", false, (test_callback_fn*)servers_bad_test }, + {"server with weights", false, (test_callback_fn*)server_with_weight_test }, + {"parsing servername, port, and weight", false, (test_callback_fn*)test_hostname_port_weight }, + {"--socket=", false, (test_callback_fn*)test_parse_socket }, + {"--namespace=", false, (test_callback_fn*)test_namespace_keyword }, + {0, 0, (test_callback_fn*)0} +}; + +test_st virtual_bucket_tests[] ={ + {"basic", false, (test_callback_fn*)virtual_back_map }, + {0, 0, (test_callback_fn*)0} +}; + +test_st memcached_server_add_tests[] ={ + {"memcached_server_add(\"\")", false, (test_callback_fn*)memcached_server_add_empty_test }, + {"memcached_server_add(NULL)", false, (test_callback_fn*)memcached_server_add_null_test }, + {0, 0, (test_callback_fn*)0} +}; + +test_st namespace_tests[] ={ + {"basic tests", true, (test_callback_fn*)selection_of_namespace_tests }, + {"increment", true, (test_callback_fn*)memcached_increment_namespace }, + {0, 0, (test_callback_fn*)0} +}; + +collection_st collection[] ={ +#if 0 + {"hash_sanity", 0, 0, hash_sanity}, +#endif + {"libmemcachedutil", 0, 0, libmemcachedutil_tests}, + {"basic", 0, 0, basic_tests}, + {"hsieh_availability", 0, 0, hsieh_availability}, + {"murmur_availability", 0, 0, murmur_availability}, + {"memcached_server_add", 0, 0, memcached_server_add_tests}, + {"block", 0, 0, tests}, + {"binary", (test_callback_fn*)pre_binary, 0, tests}, + {"nonblock", (test_callback_fn*)pre_nonblock, 0, tests}, + {"nodelay", (test_callback_fn*)pre_nodelay, 0, tests}, + {"settimer", (test_callback_fn*)pre_settimer, 0, tests}, + {"md5", (test_callback_fn*)pre_md5, 0, tests}, + {"crc", (test_callback_fn*)pre_crc, 0, tests}, + {"hsieh", (test_callback_fn*)pre_hsieh, 0, tests}, + {"jenkins", (test_callback_fn*)pre_jenkins, 0, tests}, + {"fnv1_64", (test_callback_fn*)pre_hash_fnv1_64, 0, tests}, + {"fnv1a_64", (test_callback_fn*)pre_hash_fnv1a_64, 0, tests}, + {"fnv1_32", (test_callback_fn*)pre_hash_fnv1_32, 0, tests}, + {"fnv1a_32", (test_callback_fn*)pre_hash_fnv1a_32, 0, tests}, + {"ketama", (test_callback_fn*)pre_behavior_ketama, 0, tests}, + {"ketama_auto_eject_hosts", (test_callback_fn*)pre_behavior_ketama, 0, ketama_auto_eject_hosts}, + {"unix_socket", (test_callback_fn*)pre_unix_socket, 0, tests}, + {"unix_socket_nodelay", (test_callback_fn*)pre_nodelay, 0, tests}, + {"gets", (test_callback_fn*)enable_cas, 0, tests}, + {"consistent_crc", (test_callback_fn*)enable_consistent_crc, 0, tests}, + {"consistent_hsieh", (test_callback_fn*)enable_consistent_hsieh, 0, tests}, +#ifdef MEMCACHED_ENABLE_DEPRECATED + {"deprecated_memory_allocators", (test_callback_fn*)deprecated_set_memory_alloc, 0, tests}, +#endif + {"memory_allocators", (test_callback_fn*)set_memory_alloc, 0, tests}, + {"namespace", (test_callback_fn*)set_namespace, 0, tests}, + {"namespace(BINARY)", (test_callback_fn*)set_namespace_and_binary, 0, tests}, + {"specific namespace", 0, 0, namespace_tests}, + {"specific namespace(BINARY)", (test_callback_fn*)pre_binary, 0, namespace_tests}, + {"version_1_2_3", (test_callback_fn*)check_for_1_2_3, 0, version_1_2_3}, + {"result", 0, 0, result_tests}, + {"async", (test_callback_fn*)pre_nonblock, 0, async_tests}, + {"async(BINARY)", (test_callback_fn*)pre_nonblock_binary, 0, async_tests}, + {"Cal Haldenbrand's tests", 0, 0, haldenbrand_TESTS}, + {"user written tests", 0, 0, user_tests}, + {"generate", 0, 0, generate_tests}, + {"generate_hsieh", (test_callback_fn*)pre_hsieh, 0, generate_tests}, + {"generate_ketama", (test_callback_fn*)pre_behavior_ketama, 0, generate_tests}, + {"generate_hsieh_consistent", (test_callback_fn*)enable_consistent_hsieh, 0, generate_tests}, + {"generate_md5", (test_callback_fn*)pre_md5, 0, generate_tests}, + {"generate_murmur", (test_callback_fn*)pre_murmur, 0, generate_tests}, + {"generate_jenkins", (test_callback_fn*)pre_jenkins, 0, generate_tests}, + {"generate_nonblock", (test_callback_fn*)pre_nonblock, 0, generate_tests}, + // Too slow + {"generate_corked", (test_callback_fn*)pre_cork, 0, generate_tests}, + {"generate_corked_and_nonblock", (test_callback_fn*)pre_cork_and_nonblock, 0, generate_tests}, + {"consistent_not", 0, 0, consistent_tests}, + {"consistent_ketama", (test_callback_fn*)pre_behavior_ketama, 0, consistent_tests}, + {"consistent_ketama_weighted", (test_callback_fn*)pre_behavior_ketama_weighted, 0, consistent_weighted_tests}, + {"ketama_compat", 0, 0, ketama_compatibility}, + {"test_hashes", 0, 0, hash_tests}, + {"replication", (test_callback_fn*)pre_replication, 0, replication_tests}, + {"replication_noblock", (test_callback_fn*)pre_replication_noblock, 0, replication_tests}, + {"regression", 0, 0, regression_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}, + {"virtual buckets", 0, 0, virtual_bucket_tests}, + {"memcached_server_get_last_disconnect", 0, 0, memcached_server_get_last_disconnect_tests}, + {"touch", 0, 0, touch_tests}, + {"touch", (test_callback_fn*)pre_binary, 0, touch_tests}, + {"memcached_stat()", 0, 0, memcached_stat_tests}, + {0, 0, 0, 0} +}; diff --git a/tests/libmemcached-1.0/include.am b/tests/libmemcached-1.0/include.am index 32c99bbd..af5f5e7e 100644 --- a/tests/libmemcached-1.0/include.am +++ b/tests/libmemcached-1.0/include.am @@ -18,12 +18,14 @@ noinst_HEADERS+= \ tests/ketama.h \ tests/ketama_test_cases.h \ tests/ketama_test_cases_spy.h \ + tests/libmemcached-1.0/all_tests.h \ tests/libmemcached-1.0/callback_counter.h \ tests/libmemcached-1.0/dump.h \ tests/libmemcached-1.0/fetch_all_results.h \ tests/libmemcached-1.0/generate.h \ tests/libmemcached-1.0/haldenbrand.h \ tests/libmemcached-1.0/servers_to_create.h \ + tests/libmemcached-1.0/setup_and_teardowns.h \ tests/libmemcached-1.0/stat.h \ tests/namespace.h \ tests/parser.h \ @@ -51,28 +53,30 @@ noinst_PROGRAMS+= tests/libmemcached-1.0/internals tests_libmemcached_1_0_testapp_CXXFLAGS = $(AM_CXXFLAGS) ${PTHREAD_CFLAGS} tests_libmemcached_1_0_testapp_CFLAGS= $(AM_CFLAGS) $(NO_CONVERSION) $(NO_STRICT_ALIASING) tests_libmemcached_1_0_testapp_SOURCES= \ - tests/libmemcached-1.0/pool.cc \ - tests/libmemcached-1.0/print.cc \ - tests/libmemcached-1.0/replication.cc \ + tests/libmemcached-1.0/all_tests.cc \ + tests/libmemcached-1.0/basic.cc \ tests/libmemcached-1.0/callback_counter.cc \ + tests/libmemcached-1.0/callbacks.cc \ + tests/libmemcached-1.0/debug.cc \ + tests/libmemcached-1.0/deprecated.cc \ + tests/libmemcached-1.0/dump.cc \ + tests/libmemcached-1.0/error_conditions.cc \ + tests/libmemcached-1.0/exist.cc \ tests/libmemcached-1.0/fetch_all_results.cc \ tests/libmemcached-1.0/generate.cc \ - tests/libmemcached-1.0/basic.cc \ - tests/libmemcached-1.0/callbacks.cc \ - tests/libmemcached-1.0/debug.cc \ tests/libmemcached-1.0/haldenbrand.cc \ - tests/libmemcached-1.0/deprecated.cc \ - tests/libmemcached-1.0/dump.cc \ - tests/libmemcached-1.0/error_conditions.cc \ - tests/libmemcached-1.0/exist.cc \ - tests/libmemcached-1.0/ketama.cc \ - tests/libmemcached-1.0/mem_functions.cc \ - tests/libmemcached-1.0/namespace.cc \ - tests/libmemcached-1.0/parser.cc \ - tests/libmemcached-1.0/server_add.cc \ - tests/libmemcached-1.0/stat.cc \ - tests/libmemcached-1.0/touch.cc \ - tests/libmemcached-1.0/virtual_buckets.cc + tests/libmemcached-1.0/ketama.cc \ + tests/libmemcached-1.0/mem_functions.cc \ + tests/libmemcached-1.0/namespace.cc \ + tests/libmemcached-1.0/parser.cc \ + tests/libmemcached-1.0/pool.cc \ + tests/libmemcached-1.0/print.cc \ + tests/libmemcached-1.0/replication.cc \ + tests/libmemcached-1.0/server_add.cc \ + tests/libmemcached-1.0/setup_and_teardowns.cc \ + tests/libmemcached-1.0/stat.cc \ + tests/libmemcached-1.0/touch.cc \ + tests/libmemcached-1.0/virtual_buckets.cc tests_libmemcached_1_0_testapp_SOURCES+= clients/generator.cc clients/execute.cc tests_libmemcached_1_0_testapp_DEPENDENCIES= \ diff --git a/tests/libmemcached-1.0/mem_functions.cc b/tests/libmemcached-1.0/mem_functions.cc index caac4c06..902b1c82 100644 --- a/tests/libmemcached-1.0/mem_functions.cc +++ b/tests/libmemcached-1.0/mem_functions.cc @@ -73,28 +73,6 @@ #include -#include "tests/basic.h" -#include "tests/debug.h" -#include "tests/deprecated.h" -#include "tests/error_conditions.h" -#include "tests/exist.h" -#include "tests/ketama.h" -#include "tests/namespace.h" -#include "tests/parser.h" -#include "tests/libmemcached-1.0/callback_counter.h" -#include "tests/libmemcached-1.0/dump.h" -#include "tests/libmemcached-1.0/fetch_all_results.h" -#include "tests/libmemcached-1.0/generate.h" -#include "tests/libmemcached-1.0/haldenbrand.h" -#include "tests/libmemcached-1.0/stat.h" -#include "tests/touch.h" -#include "tests/callbacks.h" -#include "tests/pool.h" -#include "tests/print.h" -#include "tests/replication.h" -#include "tests/server_add.h" -#include "tests/virtual_buckets.h" - using namespace libtest; #include @@ -103,6 +81,13 @@ using namespace libtest; #include "tests/libmemcached-1.0/servers_to_create.h" +#include "tests/libmemcached-1.0/callback_counter.h" +#include "tests/libmemcached-1.0/fetch_all_results.h" +#include "tests/libmemcached-1.0/mem_functions.h" +#include "tests/libmemcached-1.0/setup_and_teardowns.h" +#include "tests/print.h" +#include "tests/debug.h" + #define UUID_STRING_MAXLENGTH 36 struct keys_st { @@ -208,17 +193,6 @@ private: std::vector _lengths; }; -/** - @note This should be testing to see if the server really supports the binary protocol. -*/ -static test_return_t pre_binary(memcached_st *memc) -{ - test_skip(true, libmemcached_util_version_check(memc, 1, 4, 4)); - test_skip(MEMCACHED_SUCCESS, memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL, true)); - - return TEST_SUCCESS; -} - static memcached_return_t return_value_based_on_buffering(memcached_st *memc) { if (memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_BUFFER_REQUESTS)) @@ -267,7 +241,7 @@ static memcached_st * create_single_instance_memcached(const memcached_st *origi } -static test_return_t init_test(memcached_st *not_used) +test_return_t init_test(memcached_st *not_used) { memcached_st memc; (void)not_used; @@ -312,7 +286,7 @@ static memcached_return_t dump_server_information(const memcached_st *ptr, return MEMCACHED_SUCCESS; } -static test_return_t server_sort_test(memcached_st *ptr) +test_return_t server_sort_test(memcached_st *ptr) { size_t bigger= 0; /* Prime the value for the test_true in server_display_function */ @@ -345,7 +319,7 @@ static test_return_t server_sort_test(memcached_st *ptr) return TEST_SUCCESS; } -static test_return_t server_sort2_test(memcached_st *ptr) +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_server_fn callbacks[1]; @@ -381,7 +355,7 @@ static test_return_t server_sort2_test(memcached_st *ptr) return TEST_SUCCESS; } -static test_return_t memcached_server_remove_test(memcached_st*) +test_return_t memcached_server_remove_test(memcached_st*) { const char *server_string= "--server=localhost:4444 --server=localhost:4445 --server=localhost:4446 --server=localhost:4447 --server=localhost --server=memcache1.memcache.bk.sapo.pt:11211 --server=memcache1.memcache.bk.sapo.pt:11212 --server=memcache1.memcache.bk.sapo.pt:11213 --server=memcache1.memcache.bk.sapo.pt:11214 --server=memcache2.memcache.bk.sapo.pt:11211 --server=memcache2.memcache.bk.sapo.pt:11212 --server=memcache2.memcache.bk.sapo.pt:11213 --server=memcache2.memcache.bk.sapo.pt:11214"; char buffer[BUFSIZ]; @@ -418,7 +392,7 @@ static memcached_return_t server_display_unsort_function(const memcached_st*, return MEMCACHED_SUCCESS; } -static test_return_t server_unsort_test(memcached_st *ptr) +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 */ @@ -454,7 +428,7 @@ static test_return_t server_unsort_test(memcached_st *ptr) return TEST_SUCCESS; } -static test_return_t allocation_test(memcached_st *not_used) +test_return_t allocation_test(memcached_st *not_used) { (void)not_used; memcached_st *memc; @@ -465,7 +439,7 @@ static test_return_t allocation_test(memcached_st *not_used) return TEST_SUCCESS; } -static test_return_t clone_test(memcached_st *memc) +test_return_t clone_test(memcached_st *memc) { /* All null? */ { @@ -548,7 +522,7 @@ static test_return_t clone_test(memcached_st *memc) return TEST_SUCCESS; } -static test_return_t userdata_test(memcached_st *memc) +test_return_t userdata_test(memcached_st *memc) { void* foo= NULL; test_false(memcached_set_user_data(memc, foo)); @@ -558,7 +532,7 @@ static test_return_t userdata_test(memcached_st *memc) return TEST_SUCCESS; } -static test_return_t connection_test(memcached_st *memc) +test_return_t connection_test(memcached_st *memc) { test_compare(MEMCACHED_SUCCESS, memcached_server_add_with_weight(memc, "localhost", 0, 0)); @@ -566,7 +540,7 @@ static test_return_t connection_test(memcached_st *memc) return TEST_SUCCESS; } -static test_return_t libmemcached_string_behavior_test(memcached_st *) +test_return_t libmemcached_string_behavior_test(memcached_st *) { for (int x= MEMCACHED_BEHAVIOR_NO_BLOCK; x < int(MEMCACHED_BEHAVIOR_MAX); ++x) { @@ -577,7 +551,7 @@ static test_return_t libmemcached_string_behavior_test(memcached_st *) return TEST_SUCCESS; } -static test_return_t libmemcached_string_distribution_test(memcached_st *) +test_return_t libmemcached_string_distribution_test(memcached_st *) { for (int x= MEMCACHED_DISTRIBUTION_MODULA; x < int(MEMCACHED_DISTRIBUTION_CONSISTENT_MAX); ++x) { @@ -588,7 +562,7 @@ static test_return_t libmemcached_string_distribution_test(memcached_st *) return TEST_SUCCESS; } -static test_return_t memcached_return_t_TEST(memcached_st *memc) +test_return_t memcached_return_t_TEST(memcached_st *memc) { uint32_t values[] = { 851992627U, 2337886783U, 4109241422U, 4001849190U, 982370485U, 1263635348U, 4242906218U, 3829656100U, @@ -623,7 +597,7 @@ static test_return_t memcached_return_t_TEST(memcached_st *memc) return TEST_SUCCESS; } -static test_return_t set_test(memcached_st *memc) +test_return_t set_test(memcached_st *memc) { memcached_return_t rc= memcached_set(memc, test_literal_param("foo"), @@ -634,7 +608,7 @@ static test_return_t set_test(memcached_st *memc) return TEST_SUCCESS; } -static test_return_t append_test(memcached_st *memc) +test_return_t append_test(memcached_st *memc) { memcached_return_t rc; const char *in_value= "we"; @@ -673,7 +647,7 @@ static test_return_t append_test(memcached_st *memc) return TEST_SUCCESS; } -static test_return_t append_binary_test(memcached_st *memc) +test_return_t append_binary_test(memcached_st *memc) { uint32_t store_list[] = { 23, 56, 499, 98, 32847, 0 }; @@ -716,7 +690,7 @@ static test_return_t append_binary_test(memcached_st *memc) return TEST_SUCCESS; } -static test_return_t memcached_mget_mixed_memcached_get_TEST(memcached_st *memc) +test_return_t memcached_mget_mixed_memcached_get_TEST(memcached_st *memc) { keys_st keys(200); @@ -767,7 +741,7 @@ static test_return_t memcached_mget_mixed_memcached_get_TEST(memcached_st *memc) return TEST_SUCCESS; } -static test_return_t cas2_test(memcached_st *memc) +test_return_t cas2_test(memcached_st *memc) { const char *keys[]= {"fudge", "son", "food"}; size_t key_length[]= {5, 3, 4}; @@ -808,7 +782,7 @@ static test_return_t cas2_test(memcached_st *memc) return TEST_SUCCESS; } -static test_return_t cas_test(memcached_st *memc) +test_return_t cas_test(memcached_st *memc) { const char* keys[2] = { __func__, NULL }; size_t keylengths[2] = { strlen(__func__), 0 }; @@ -869,7 +843,8 @@ static test_return_t cas_test(memcached_st *memc) return TEST_SUCCESS; } -static test_return_t prepend_test(memcached_st *memc) + +test_return_t prepend_test(memcached_st *memc) { const char *key= "fig"; const char *value= "people"; @@ -909,7 +884,7 @@ static test_return_t prepend_test(memcached_st *memc) Set the value, then quit to make sure it is flushed. Come back in and test that add fails. */ -static test_return_t add_test(memcached_st *memc) +test_return_t add_test(memcached_st *memc) { test_compare_hint(return_value_based_on_buffering(memc), memcached_set(memc, @@ -937,7 +912,7 @@ static test_return_t add_test(memcached_st *memc) ** because the connects starts to time out (the test doesn't do much ** anyway, so just loop 10 iterations) */ -static test_return_t add_wrapper(memcached_st *memc) +test_return_t add_wrapper(memcached_st *memc) { unsigned int max= 10000; #ifdef __sun @@ -953,7 +928,7 @@ static test_return_t add_wrapper(memcached_st *memc) return TEST_SUCCESS; } -static test_return_t replace_test(memcached_st *memc) +test_return_t replace_test(memcached_st *memc) { test_compare(return_value_based_on_buffering(memc), memcached_set(memc, @@ -970,7 +945,7 @@ static test_return_t replace_test(memcached_st *memc) return TEST_SUCCESS; } -static test_return_t delete_test(memcached_st *memc) +test_return_t delete_test(memcached_st *memc) { test_compare(return_value_based_on_buffering(memc), memcached_set(memc, @@ -987,7 +962,7 @@ static test_return_t delete_test(memcached_st *memc) return TEST_SUCCESS; } -static test_return_t flush_test(memcached_st *memc) +test_return_t flush_test(memcached_st *memc) { uint64_t query_id= memcached_query_id(memc); test_compare(MEMCACHED_SUCCESS, @@ -1005,7 +980,7 @@ static memcached_return_t server_function(const memcached_st *, return MEMCACHED_SUCCESS; } -static test_return_t memcached_server_cursor_test(memcached_st *memc) +test_return_t memcached_server_cursor_test(memcached_st *memc) { char context[10]; strncpy(context, "foo bad", sizeof(context)); @@ -1016,7 +991,7 @@ static test_return_t memcached_server_cursor_test(memcached_st *memc) return TEST_SUCCESS; } -static test_return_t bad_key_test(memcached_st *memc) +test_return_t bad_key_test(memcached_st *memc) { memcached_return_t rc; const char *key= "foo bad"; @@ -1141,7 +1116,7 @@ static memcached_return_t read_through_trigger(memcached_st *memc, #pragma GCC diagnostic ignored "-Wstrict-aliasing" #endif -static test_return_t read_through(memcached_st *memc) +test_return_t read_through(memcached_st *memc) { memcached_trigger_key_fn cb= (memcached_trigger_key_fn)read_through_trigger; @@ -1183,7 +1158,7 @@ static test_return_t read_through(memcached_st *memc) return TEST_SUCCESS; } -static test_return_t get_test(memcached_st *memc) +test_return_t get_test(memcached_st *memc) { memcached_return_t rc; char *string; @@ -1208,7 +1183,7 @@ static test_return_t get_test(memcached_st *memc) return TEST_SUCCESS; } -static test_return_t get_test2(memcached_st *memc) +test_return_t get_test2(memcached_st *memc) { const char *value= "when we sanitize"; @@ -1242,7 +1217,7 @@ static test_return_t get_test2(memcached_st *memc) return TEST_SUCCESS; } -static test_return_t set_test2(memcached_st *memc) +test_return_t set_test2(memcached_st *memc) { for (uint32_t x= 0; x < 10; x++) { @@ -1256,7 +1231,7 @@ static test_return_t set_test2(memcached_st *memc) return TEST_SUCCESS; } -static test_return_t set_test3(memcached_st *memc) +test_return_t set_test3(memcached_st *memc) { size_t value_length= 8191; @@ -1286,7 +1261,7 @@ static test_return_t set_test3(memcached_st *memc) return TEST_SUCCESS; } -static test_return_t get_test3(memcached_st *memc) +test_return_t get_test3(memcached_st *memc) { size_t value_length= 8191; @@ -1321,7 +1296,7 @@ static test_return_t get_test3(memcached_st *memc) return TEST_SUCCESS; } -static test_return_t get_test4(memcached_st *memc) +test_return_t get_test4(memcached_st *memc) { size_t value_length= 8191; @@ -1363,7 +1338,7 @@ static test_return_t get_test4(memcached_st *memc) * dereference a NIL-pointer if you issue a multi-get and don't read out all * responses before you execute a storage command. */ -static test_return_t get_test5(memcached_st *memc) +test_return_t get_test5(memcached_st *memc) { /* ** Request the same key twice, to ensure that we hash to the same server @@ -1406,7 +1381,7 @@ static test_return_t get_test5(memcached_st *memc) return TEST_SUCCESS; } -static test_return_t mget_end(memcached_st *memc) +test_return_t mget_end(memcached_st *memc) { const char *keys[]= { "foo", "foo2" }; size_t lengths[]= { 3, 4 }; @@ -1479,7 +1454,7 @@ static test_return_t mget_end(memcached_st *memc) } /* Do not copy the style of this code, I just access hosts to testthis function */ -static test_return_t stats_servername_test(memcached_st *memc) +test_return_t stats_servername_test(memcached_st *memc) { memcached_stat_st memc_stat; memcached_server_instance_st instance= @@ -1497,7 +1472,7 @@ static test_return_t stats_servername_test(memcached_st *memc) return TEST_SUCCESS; } -static test_return_t increment_test(memcached_st *memc) +test_return_t increment_test(memcached_st *memc) { uint64_t new_number; @@ -1518,7 +1493,7 @@ static test_return_t increment_test(memcached_st *memc) return TEST_SUCCESS; } -static test_return_t increment_with_initial_test(memcached_st *memc) +test_return_t increment_with_initial_test(memcached_st *memc) { test_skip(true, memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL)); @@ -1538,7 +1513,7 @@ static test_return_t increment_with_initial_test(memcached_st *memc) return TEST_SUCCESS; } -static test_return_t decrement_test(memcached_st *memc) +test_return_t decrement_test(memcached_st *memc) { test_compare(return_value_based_on_buffering(memc), memcached_set(memc, @@ -1564,7 +1539,7 @@ static test_return_t decrement_test(memcached_st *memc) return TEST_SUCCESS; } -static test_return_t decrement_with_initial_test(memcached_st *memc) +test_return_t decrement_with_initial_test(memcached_st *memc) { test_skip(true, memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL)); @@ -1590,7 +1565,7 @@ static test_return_t decrement_with_initial_test(memcached_st *memc) return TEST_SUCCESS; } -static test_return_t increment_by_key_test(memcached_st *memc) +test_return_t increment_by_key_test(memcached_st *memc) { const char *master_key= "foo"; const char *key= "number"; @@ -1619,7 +1594,7 @@ static test_return_t increment_by_key_test(memcached_st *memc) return TEST_SUCCESS; } -static test_return_t increment_with_initial_by_key_test(memcached_st *memc) +test_return_t increment_with_initial_by_key_test(memcached_st *memc) { test_skip(true, memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL)); @@ -1643,7 +1618,7 @@ static test_return_t increment_with_initial_by_key_test(memcached_st *memc) return TEST_SUCCESS; } -static test_return_t decrement_by_key_test(memcached_st *memc) +test_return_t decrement_by_key_test(memcached_st *memc) { uint64_t new_number; const char *value= "3"; @@ -1672,7 +1647,7 @@ static test_return_t decrement_by_key_test(memcached_st *memc) return TEST_SUCCESS; } -static test_return_t decrement_with_initial_by_key_test(memcached_st *memc) +test_return_t decrement_with_initial_by_key_test(memcached_st *memc) { test_skip(true, memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL)); @@ -1695,7 +1670,7 @@ static test_return_t decrement_with_initial_by_key_test(memcached_st *memc) return TEST_SUCCESS; } -static test_return_t binary_increment_with_prefix_test(memcached_st *memc) +test_return_t binary_increment_with_prefix_test(memcached_st *memc) { test_skip(true, memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL)); @@ -1721,7 +1696,7 @@ static test_return_t binary_increment_with_prefix_test(memcached_st *memc) return TEST_SUCCESS; } -static test_return_t quit_test(memcached_st *memc) +test_return_t quit_test(memcached_st *memc) { const char *value= "sanford and sun"; @@ -1741,7 +1716,7 @@ static test_return_t quit_test(memcached_st *memc) return TEST_SUCCESS; } -static test_return_t mget_result_test(memcached_st *memc) +test_return_t mget_result_test(memcached_st *memc) { const char *keys[]= {"fudge", "son", "food"}; size_t key_length[]= {5, 3, 4}; @@ -1797,7 +1772,7 @@ static test_return_t mget_result_test(memcached_st *memc) return TEST_SUCCESS; } -static test_return_t mget_result_alloc_test(memcached_st *memc) +test_return_t mget_result_alloc_test(memcached_st *memc) { const char *keys[]= {"fudge", "son", "food"}; size_t key_length[]= {5, 3, 4}; @@ -1846,7 +1821,7 @@ static test_return_t mget_result_alloc_test(memcached_st *memc) return TEST_SUCCESS; } -static test_return_t mget_result_function(memcached_st *memc) +test_return_t mget_result_function(memcached_st *memc) { const char *keys[]= {"fudge", "son", "food"}; size_t key_length[]= {5, 3, 4}; @@ -1877,7 +1852,7 @@ static test_return_t mget_result_function(memcached_st *memc) return TEST_SUCCESS; } -static test_return_t mget_test(memcached_st *memc) +test_return_t mget_test(memcached_st *memc) { const char *keys[]= {"fudge", "son", "food"}; size_t key_length[]= {5, 3, 4}; @@ -1929,7 +1904,7 @@ static test_return_t mget_test(memcached_st *memc) return TEST_SUCCESS; } -static test_return_t mget_execute(memcached_st *original_memc) +test_return_t mget_execute(memcached_st *original_memc) { test_skip(true, memcached_behavior_get(original_memc, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL)); @@ -1979,7 +1954,7 @@ static test_return_t mget_execute(memcached_st *original_memc) #define REGRESSION_BINARY_VS_BLOCK_COUNT 20480 static pairs_st *global_pairs; -static test_return_t key_setup(memcached_st *memc) +test_return_t key_setup(memcached_st *memc) { test_skip(TEST_SUCCESS, pre_binary(memc)); @@ -1988,14 +1963,14 @@ static test_return_t key_setup(memcached_st *memc) return TEST_SUCCESS; } -static test_return_t key_teardown(memcached_st *) +test_return_t key_teardown(memcached_st *) { pairs_free(global_pairs); return TEST_SUCCESS; } -static test_return_t block_add_regression(memcached_st *memc) +test_return_t block_add_regression(memcached_st *memc) { /* First add all of the items.. */ for (size_t x= 0; x < REGRESSION_BINARY_VS_BLOCK_COUNT; ++x) @@ -2009,7 +1984,7 @@ static test_return_t block_add_regression(memcached_st *memc) return TEST_SUCCESS; } -static test_return_t binary_add_regression(memcached_st *memc) +test_return_t binary_add_regression(memcached_st *memc) { test_skip(MEMCACHED_SUCCESS, memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL, true)); test_return_t rc= block_add_regression(memc); @@ -2017,7 +1992,7 @@ static test_return_t binary_add_regression(memcached_st *memc) return rc; } -static test_return_t get_stats_keys(memcached_st *memc) +test_return_t get_stats_keys(memcached_st *memc) { char **stat_list; char **ptr; @@ -2034,14 +2009,14 @@ static test_return_t get_stats_keys(memcached_st *memc) return TEST_SUCCESS; } -static test_return_t version_string_test(memcached_st *) +test_return_t version_string_test(memcached_st *) { test_strcmp(LIBMEMCACHED_VERSION_STRING, memcached_lib_version()); return TEST_SUCCESS; } -static test_return_t get_stats(memcached_st *memc) +test_return_t get_stats(memcached_st *memc) { memcached_return_t rc; @@ -2063,7 +2038,7 @@ static test_return_t get_stats(memcached_st *memc) return TEST_SUCCESS; } -static test_return_t add_host_test(memcached_st *memc) +test_return_t add_host_test(memcached_st *memc) { char servername[]= "0.example.com"; @@ -2090,7 +2065,7 @@ static test_return_t add_host_test(memcached_st *memc) return TEST_SUCCESS; } -static test_return_t memcached_fetch_result_NOT_FOUND(memcached_st *memc) +test_return_t memcached_fetch_result_NOT_FOUND(memcached_st *memc) { memcached_return_t rc; @@ -2119,7 +2094,7 @@ static memcached_return_t cleanup_test_callback(memcached_st *) return MEMCACHED_SUCCESS; } -static test_return_t callback_test(memcached_st *memc) +test_return_t callback_test(memcached_st *memc) { /* Test User Data */ { @@ -2161,7 +2136,7 @@ static test_return_t callback_test(memcached_st *memc) } /* We don't test the behavior itself, we test the switches */ -static test_return_t behavior_test(memcached_st *memc) +test_return_t behavior_test(memcached_st *memc) { memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_NO_BLOCK, 1); test_compare(true, memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_NO_BLOCK)); @@ -2195,7 +2170,7 @@ static test_return_t behavior_test(memcached_st *memc) return TEST_SUCCESS; } -static test_return_t MEMCACHED_BEHAVIOR_CORK_test(memcached_st *memc) +test_return_t MEMCACHED_BEHAVIOR_CORK_test(memcached_st *memc) { test_compare(MEMCACHED_DEPRECATED, memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_CORK, true)); @@ -2210,7 +2185,7 @@ static test_return_t MEMCACHED_BEHAVIOR_CORK_test(memcached_st *memc) } -static test_return_t MEMCACHED_BEHAVIOR_TCP_KEEPALIVE_test(memcached_st *memc) +test_return_t MEMCACHED_BEHAVIOR_TCP_KEEPALIVE_test(memcached_st *memc) { memcached_return_t rc= memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_TCP_KEEPALIVE, true); test_true(rc == MEMCACHED_SUCCESS || rc == MEMCACHED_NOT_SUPPORTED); @@ -2230,7 +2205,7 @@ static test_return_t MEMCACHED_BEHAVIOR_TCP_KEEPALIVE_test(memcached_st *memc) } -static test_return_t MEMCACHED_BEHAVIOR_TCP_KEEPIDLE_test(memcached_st *memc) +test_return_t MEMCACHED_BEHAVIOR_TCP_KEEPIDLE_test(memcached_st *memc) { memcached_return_t rc= memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_TCP_KEEPIDLE, true); test_true(rc == MEMCACHED_SUCCESS || rc == MEMCACHED_NOT_SUPPORTED); @@ -2250,7 +2225,7 @@ static test_return_t MEMCACHED_BEHAVIOR_TCP_KEEPIDLE_test(memcached_st *memc) } /* Make sure we behave properly if server list has no values */ -static test_return_t user_supplied_bug4(memcached_st *memc) +test_return_t user_supplied_bug4(memcached_st *memc) { const char *keys[]= {"fudge", "son", "food"}; size_t key_length[]= {5, 3, 4}; @@ -2309,7 +2284,7 @@ static test_return_t user_supplied_bug4(memcached_st *memc) } #define VALUE_SIZE_BUG5 1048064 -static test_return_t user_supplied_bug5(memcached_st *memc) +test_return_t user_supplied_bug5(memcached_st *memc) { const char *keys[]= {"036790384900", "036790384902", "036790384904", "036790384906"}; size_t key_length[]= {strlen("036790384900"), strlen("036790384902"), strlen("036790384904"), strlen("036790384906")}; @@ -2363,7 +2338,7 @@ static test_return_t user_supplied_bug5(memcached_st *memc) return TEST_SUCCESS; } -static test_return_t user_supplied_bug6(memcached_st *memc) +test_return_t user_supplied_bug6(memcached_st *memc) { const char *keys[]= {"036790384900", "036790384902", "036790384904", "036790384906"}; size_t key_length[]= {strlen("036790384900"), strlen("036790384902"), strlen("036790384904"), strlen("036790384906")}; @@ -2432,7 +2407,7 @@ static test_return_t user_supplied_bug6(memcached_st *memc) return TEST_SUCCESS; } -static test_return_t user_supplied_bug8(memcached_st *) +test_return_t user_supplied_bug8(memcached_st *) { memcached_return_t rc; memcached_st *mine; @@ -2463,7 +2438,7 @@ static test_return_t user_supplied_bug8(memcached_st *) } /* Test flag store/retrieve */ -static test_return_t user_supplied_bug7(memcached_st *memc) +test_return_t user_supplied_bug7(memcached_st *memc) { char *insert_data= new (std::nothrow) char[VALUE_SIZE_BUG5]; test_true(insert_data); @@ -2507,7 +2482,7 @@ static test_return_t user_supplied_bug7(memcached_st *memc) return TEST_SUCCESS; } -static test_return_t user_supplied_bug9(memcached_st *memc) +test_return_t user_supplied_bug9(memcached_st *memc) { const char *keys[]= {"UDATA:edevil@sapo.pt", "fudge&*@#", "for^#@&$not"}; size_t key_length[3]; @@ -2550,7 +2525,7 @@ static test_return_t user_supplied_bug9(memcached_st *memc) } /* We are testing with aggressive timeout to get failures */ -static test_return_t user_supplied_bug10(memcached_st *memc) +test_return_t user_supplied_bug10(memcached_st *memc) { size_t value_length= 512; unsigned int set= 1; @@ -2592,7 +2567,7 @@ static test_return_t user_supplied_bug10(memcached_st *memc) /* We are looking failures in the async protocol */ -static test_return_t user_supplied_bug11(memcached_st *memc) +test_return_t user_supplied_bug11(memcached_st *memc) { memcached_st *mclone= memcached_clone(NULL, memc); @@ -2624,7 +2599,7 @@ static test_return_t user_supplied_bug11(memcached_st *memc) /* Bug found where incr was not returning MEMCACHED_NOTFOUND when object did not exist. */ -static test_return_t user_supplied_bug12(memcached_st *memc) +test_return_t user_supplied_bug12(memcached_st *memc) { memcached_return_t rc; uint32_t flags; @@ -2668,7 +2643,7 @@ static test_return_t user_supplied_bug12(memcached_st *memc) Bug found where command total one more than MEMCACHED_MAX_BUFFER set key34567890 0 0 8169 \r\n is sent followed by buffer of size 8169, followed by 8169 */ -static test_return_t user_supplied_bug13(memcached_st *memc) +test_return_t user_supplied_bug13(memcached_st *memc) { char key[] = "key34567890"; @@ -2702,7 +2677,7 @@ static test_return_t user_supplied_bug13(memcached_st *memc) set key34567890 0 0 8169 \r\n is sent followed by buffer of size 8169, followed by 8169 */ -static test_return_t user_supplied_bug14(memcached_st *memc) +test_return_t user_supplied_bug14(memcached_st *memc) { memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_TCP_NODELAY, true); @@ -2738,7 +2713,7 @@ static test_return_t user_supplied_bug14(memcached_st *memc) /* Look for zero length value problems */ -static test_return_t user_supplied_bug15(memcached_st *memc) +test_return_t user_supplied_bug15(memcached_st *memc) { for (uint32_t x= 0; x < 2; x++) { @@ -2771,7 +2746,7 @@ static test_return_t user_supplied_bug15(memcached_st *memc) } /* Check the return sizes on FLAGS to make sure it stores 32bit unsigned values correctly */ -static test_return_t user_supplied_bug16(memcached_st *memc) +test_return_t user_supplied_bug16(memcached_st *memc) { test_compare_hint(MEMCACHED_SUCCESS, memcached_set(memc, test_literal_param("mykey"), NULL, 0, @@ -2795,7 +2770,7 @@ static test_return_t user_supplied_bug16(memcached_st *memc) #if !defined(__sun) && !defined(__OpenBSD__) /* Check the validity of chinese key*/ -static test_return_t user_supplied_bug17(memcached_st *memc) +test_return_t user_supplied_bug17(memcached_st *memc) { const char *key= "豆瓣"; const char *value="我们在炎热抑郁的夏天无法停止豆瓣"; @@ -2823,7 +2798,7 @@ static test_return_t user_supplied_bug17(memcached_st *memc) From Andrei on IRC */ -static test_return_t user_supplied_bug19(memcached_st *) +test_return_t user_supplied_bug19(memcached_st *) { memcached_return_t res; @@ -2838,7 +2813,7 @@ static test_return_t user_supplied_bug19(memcached_st *) } /* CAS test from Andei */ -static test_return_t user_supplied_bug20(memcached_st *memc) +test_return_t user_supplied_bug20(memcached_st *memc) { const char *key= "abc"; size_t key_len= strlen("abc"); @@ -2884,7 +2859,7 @@ static void fail(int) } -static test_return_t _user_supplied_bug21(memcached_st* memc, size_t key_count) +test_return_t _user_supplied_bug21(memcached_st* memc, size_t key_count) { #ifdef WIN32 (void)memc; @@ -2937,7 +2912,7 @@ static test_return_t _user_supplied_bug21(memcached_st* memc, size_t key_count) #endif } -static test_return_t user_supplied_bug21(memcached_st *memc) +test_return_t user_supplied_bug21(memcached_st *memc) { test_skip(TEST_SUCCESS, pre_binary(memc)); @@ -2952,7 +2927,7 @@ static test_return_t user_supplied_bug21(memcached_st *memc) return TEST_SUCCESS; } -static test_return_t output_ketama_weighted_keys(memcached_st *) +test_return_t output_ketama_weighted_keys(memcached_st *) { memcached_st *memc= memcached_create(NULL); test_true(memc); @@ -3009,7 +2984,7 @@ static test_return_t output_ketama_weighted_keys(memcached_st *) } -static test_return_t result_static(memcached_st *memc) +test_return_t result_static(memcached_st *memc) { memcached_result_st result; memcached_result_st *result_ptr= memcached_result_create(memc, &result); @@ -3026,7 +3001,7 @@ static test_return_t result_static(memcached_st *memc) return TEST_SUCCESS; } -static test_return_t result_alloc(memcached_st *memc) +test_return_t result_alloc(memcached_st *memc) { memcached_result_st *result_ptr= memcached_result_create(memc, NULL); test_true(result_ptr); @@ -3038,7 +3013,7 @@ static test_return_t result_alloc(memcached_st *memc) } -static test_return_t add_host_test1(memcached_st *memc) +test_return_t add_host_test1(memcached_st *memc) { memcached_return_t rc; char servername[]= "0.example.com"; @@ -3066,177 +3041,6 @@ static test_return_t add_host_test1(memcached_st *memc) return TEST_SUCCESS; } -static test_return_t pre_nonblock(memcached_st *memc) -{ - memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_NO_BLOCK, 0); - - return TEST_SUCCESS; -} - -static test_return_t pre_cork(memcached_st *memc) -{ -#ifdef __APPLE__ - return TEST_SKIPPED; -#endif - bool set= true; - if (memcached_success(memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_CORK, set))) - return TEST_SUCCESS; - - return TEST_SKIPPED; -} - -static test_return_t pre_cork_and_nonblock(memcached_st *memc) -{ -#ifdef __APPLE__ - return TEST_SKIPPED; -#endif - test_return_t test_rc; - if ((test_rc= pre_cork(memc)) != TEST_SUCCESS) - return test_rc; - - return pre_nonblock(memc); -} - -static test_return_t pre_nonblock_binary(memcached_st *memc) -{ - memcached_st *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); - - memcached_return_t rc= MEMCACHED_FAILURE; - if (libmemcached_util_version_check(memc_clone, 1, 4, 4)) - { - memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_NO_BLOCK, 0); - test_compare(MEMCACHED_SUCCESS, - memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL, 1)); - test_compare(uint64_t(1), memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL)); - } - else - { - memcached_free(memc_clone); - return TEST_SKIPPED; - } - - memcached_free(memc_clone); - - return rc == MEMCACHED_SUCCESS ? TEST_SUCCESS : TEST_SKIPPED; -} - -static test_return_t pre_murmur(memcached_st *memc) -{ - test_skip(MEMCACHED_SUCCESS, memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_HASH, (uint64_t)MEMCACHED_HASH_MURMUR)); - return TEST_SUCCESS; -} - -static test_return_t pre_jenkins(memcached_st *memc) -{ - memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_HASH, (uint64_t)MEMCACHED_HASH_JENKINS); - - return TEST_SKIPPED; -} - - -static test_return_t pre_md5(memcached_st *memc) -{ - memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_HASH, (uint64_t)MEMCACHED_HASH_MD5); - - return TEST_SUCCESS; -} - -static test_return_t pre_crc(memcached_st *memc) -{ - memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_HASH, (uint64_t)MEMCACHED_HASH_CRC); - - return TEST_SUCCESS; -} - -static test_return_t pre_hsieh(memcached_st *memc) -{ - test_skip(MEMCACHED_SUCCESS, memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_HASH, (uint64_t)MEMCACHED_HASH_HSIEH)); - return TEST_SUCCESS; -} - -static test_return_t pre_hash_fnv1_64(memcached_st *memc) -{ - test_skip(MEMCACHED_SUCCESS, memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_HASH, (uint64_t)MEMCACHED_HASH_MURMUR)); - - return TEST_SUCCESS; -} - -static test_return_t pre_hash_fnv1a_64(memcached_st *memc) -{ - test_skip(MEMCACHED_SUCCESS, memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_HASH, (uint64_t)MEMCACHED_HASH_FNV1A_64)); - - return TEST_SUCCESS; -} - -static test_return_t pre_hash_fnv1_32(memcached_st *memc) -{ - memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_HASH, (uint64_t)MEMCACHED_HASH_FNV1_32); - - return TEST_SUCCESS; -} - -static test_return_t pre_hash_fnv1a_32(memcached_st *memc) -{ - memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_HASH, (uint64_t)MEMCACHED_HASH_FNV1A_32); - - return TEST_SUCCESS; -} - -static test_return_t pre_behavior_ketama(memcached_st *memc) -{ - memcached_return_t rc= memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_KETAMA, 1); - test_compare(MEMCACHED_SUCCESS, rc); - - uint64_t value= memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_KETAMA); - test_compare(value, uint64_t(1)); - - return TEST_SUCCESS; -} - -static test_return_t pre_behavior_ketama_weighted(memcached_st *memc) -{ - memcached_return_t rc= memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_KETAMA_WEIGHTED, 1); - test_compare(MEMCACHED_SUCCESS, rc); - - uint64_t value= memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_KETAMA_WEIGHTED); - test_compare(value, uint64_t(1)); - - test_compare(MEMCACHED_SUCCESS, - memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_KETAMA_HASH, MEMCACHED_HASH_MD5)); - - value= memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_KETAMA_HASH); - test_compare(MEMCACHED_HASH_MD5, memcached_hash_t(value)); - - return TEST_SUCCESS; -} - -static test_return_t pre_replication(memcached_st *memc) -{ - test_skip(TEST_SUCCESS, pre_binary(memc)); - - /* - * Make sure that we store the item on all servers - * (master + replicas == number of servers) - */ - test_compare(MEMCACHED_SUCCESS, memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_NUMBER_OF_REPLICAS, memcached_server_count(memc) - 1)); - test_compare(memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_NUMBER_OF_REPLICAS), uint64_t(memcached_server_count(memc) - 1)); - - return TEST_SUCCESS; -} - - -static test_return_t pre_replication_noblock(memcached_st *memc) -{ - test_skip(TEST_SUCCESS, pre_replication(memc)); - - return pre_nonblock(memc); -} - static void my_free(const memcached_st *ptr, void *mem, void *context) { @@ -3310,7 +3114,7 @@ static void *my_calloc(const memcached_st *ptr, size_t nelem, const size_t size, #endif } -static test_return_t selection_of_namespace_tests(memcached_st *memc) +test_return_t selection_of_namespace_tests(memcached_st *memc) { memcached_return_t rc; const char *key= "mine"; @@ -3381,7 +3185,7 @@ static test_return_t selection_of_namespace_tests(memcached_st *memc) return TEST_SUCCESS; } -static test_return_t set_namespace(memcached_st *memc) +test_return_t set_namespace(memcached_st *memc) { memcached_return_t rc; const char *key= "mine"; @@ -3404,7 +3208,7 @@ static test_return_t set_namespace(memcached_st *memc) return TEST_SUCCESS; } -static test_return_t set_namespace_and_binary(memcached_st *memc) +test_return_t set_namespace_and_binary(memcached_st *memc) { test_return_if(pre_binary(memc)); test_return_if(set_namespace(memc)); @@ -3413,7 +3217,7 @@ static test_return_t set_namespace_and_binary(memcached_st *memc) } #ifdef MEMCACHED_ENABLE_DEPRECATED -static test_return_t deprecated_set_memory_alloc(memcached_st *memc) +test_return_t deprecated_set_memory_alloc(memcached_st *memc) { void *test_ptr= NULL; void *cb_ptr= NULL; @@ -3460,7 +3264,7 @@ static test_return_t deprecated_set_memory_alloc(memcached_st *memc) #endif -static test_return_t set_memory_alloc(memcached_st *memc) +test_return_t set_memory_alloc(memcached_st *memc) { test_compare(MEMCACHED_INVALID_ARGUMENTS, memcached_set_memory_allocators(memc, NULL, my_free, @@ -3485,7 +3289,7 @@ static test_return_t set_memory_alloc(memcached_st *memc) return TEST_SUCCESS; } -static test_return_t enable_consistent_crc(memcached_st *memc) +test_return_t enable_consistent_crc(memcached_st *memc) { test_return_t rc; memcached_server_distribution_t value= MEMCACHED_DISTRIBUTION_CONSISTENT; @@ -3505,7 +3309,7 @@ static test_return_t enable_consistent_crc(memcached_st *memc) return TEST_SUCCESS; } -static test_return_t enable_consistent_hsieh(memcached_st *memc) +test_return_t enable_consistent_hsieh(memcached_st *memc) { test_return_t rc; memcached_server_distribution_t value= MEMCACHED_DISTRIBUTION_CONSISTENT; @@ -3528,7 +3332,7 @@ static test_return_t enable_consistent_hsieh(memcached_st *memc) return TEST_SUCCESS; } -static test_return_t enable_cas(memcached_st *memc) +test_return_t enable_cas(memcached_st *memc) { unsigned int set= 1; @@ -3542,7 +3346,7 @@ static test_return_t enable_cas(memcached_st *memc) return TEST_SKIPPED; } -static test_return_t check_for_1_2_3(memcached_st *memc) +test_return_t check_for_1_2_3(memcached_st *memc) { memcached_version(memc); @@ -3558,38 +3362,7 @@ static test_return_t check_for_1_2_3(memcached_st *memc) return TEST_SKIPPED; } -static test_return_t pre_unix_socket(memcached_st *memc) -{ - struct stat buf; - - memcached_servers_reset(memc); - const char *socket_file= default_socket(); - - test_skip(0, stat(socket_file, &buf)); - - test_compare(MEMCACHED_SUCCESS, - memcached_server_add_unix_socket_with_weight(memc, socket_file, 0)); - - return TEST_SUCCESS; -} - -static test_return_t pre_nodelay(memcached_st *memc) -{ - memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_NO_BLOCK, 0); - memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_TCP_NODELAY, 0); - - return TEST_SUCCESS; -} - -static test_return_t pre_settimer(memcached_st *memc) -{ - memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_SND_TIMEOUT, 1000); - memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_RCV_TIMEOUT, 1000); - - return TEST_SUCCESS; -} - -static test_return_t MEMCACHED_BEHAVIOR_POLL_TIMEOUT_test(memcached_st *memc) +test_return_t MEMCACHED_BEHAVIOR_POLL_TIMEOUT_test(memcached_st *memc) { const uint64_t timeout= 100; // Not using, just checking that it sets @@ -3600,7 +3373,7 @@ static test_return_t MEMCACHED_BEHAVIOR_POLL_TIMEOUT_test(memcached_st *memc) return TEST_SUCCESS; } -static test_return_t noreply_test(memcached_st *memc) +test_return_t noreply_test(memcached_st *memc) { test_compare(MEMCACHED_SUCCESS, memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_NOREPLY, true)); @@ -3742,7 +3515,7 @@ static test_return_t noreply_test(memcached_st *memc) return TEST_SUCCESS; } -static test_return_t analyzer_test(memcached_st *memc) +test_return_t analyzer_test(memcached_st *memc) { memcached_analysis_st *report; memcached_return_t rc; @@ -3761,7 +3534,7 @@ static test_return_t analyzer_test(memcached_st *memc) return TEST_SUCCESS; } -static test_return_t util_version_test(memcached_st *memc) +test_return_t util_version_test(memcached_st *memc) { test_compare_hint(MEMCACHED_SUCCESS, memcached_version(memc), memcached_last_error_message(memc)); test_true(libmemcached_util_version_check(memc, 0, 0, 0)); @@ -3823,7 +3596,7 @@ static test_return_t util_version_test(memcached_st *memc) return TEST_SUCCESS; } -static test_return_t getpid_connection_failure_test(memcached_st *memc) +test_return_t getpid_connection_failure_test(memcached_st *memc) { memcached_return_t rc; memcached_server_instance_st instance= @@ -3841,7 +3614,7 @@ static test_return_t getpid_connection_failure_test(memcached_st *memc) } -static test_return_t getpid_test(memcached_st *memc) +test_return_t getpid_test(memcached_st *memc) { memcached_return_t rc; memcached_server_instance_st instance= @@ -3858,7 +3631,7 @@ static test_return_t getpid_test(memcached_st *memc) return TEST_SUCCESS; } -static test_return_t ping_test(memcached_st *memc) +test_return_t ping_test(memcached_st *memc) { memcached_return_t rc; memcached_server_instance_st instance= @@ -3878,7 +3651,7 @@ static test_return_t ping_test(memcached_st *memc) #if 0 -static test_return_t hash_sanity_test (memcached_st *memc) +test_return_t hash_sanity_test (memcached_st *memc) { (void)memc; @@ -3900,7 +3673,7 @@ static test_return_t hash_sanity_test (memcached_st *memc) } #endif -static test_return_t hsieh_avaibility_test (memcached_st *memc) +test_return_t hsieh_avaibility_test (memcached_st *memc) { test_skip(true, libhashkit_has_algorithm(HASHKIT_HASH_HSIEH)); @@ -3911,7 +3684,7 @@ static test_return_t hsieh_avaibility_test (memcached_st *memc) return TEST_SUCCESS; } -static test_return_t murmur_avaibility_test (memcached_st *memc) +test_return_t murmur_avaibility_test (memcached_st *memc) { test_skip(true, libhashkit_has_algorithm(HASHKIT_HASH_MURMUR)); @@ -3921,7 +3694,7 @@ static test_return_t murmur_avaibility_test (memcached_st *memc) return TEST_SUCCESS; } -static test_return_t one_at_a_time_run (memcached_st *) +test_return_t one_at_a_time_run (memcached_st *) { uint32_t x; const char **ptr; @@ -3935,7 +3708,7 @@ static test_return_t one_at_a_time_run (memcached_st *) return TEST_SUCCESS; } -static test_return_t md5_run (memcached_st *) +test_return_t md5_run (memcached_st *) { uint32_t x; const char **ptr; @@ -3949,7 +3722,7 @@ static test_return_t md5_run (memcached_st *) return TEST_SUCCESS; } -static test_return_t crc_run (memcached_st *) +test_return_t crc_run (memcached_st *) { uint32_t x; const char **ptr; @@ -3963,7 +3736,7 @@ static test_return_t crc_run (memcached_st *) return TEST_SUCCESS; } -static test_return_t fnv1_64_run (memcached_st *) +test_return_t fnv1_64_run (memcached_st *) { test_skip(true, libhashkit_has_algorithm(HASHKIT_HASH_FNV1_64)); @@ -3979,7 +3752,7 @@ static test_return_t fnv1_64_run (memcached_st *) return TEST_SUCCESS; } -static test_return_t fnv1a_64_run (memcached_st *) +test_return_t fnv1a_64_run (memcached_st *) { test_skip(true, libhashkit_has_algorithm(HASHKIT_HASH_FNV1A_64)); @@ -3995,7 +3768,7 @@ static test_return_t fnv1a_64_run (memcached_st *) return TEST_SUCCESS; } -static test_return_t fnv1_32_run (memcached_st *) +test_return_t fnv1_32_run (memcached_st *) { uint32_t x; const char **ptr; @@ -4009,7 +3782,7 @@ static test_return_t fnv1_32_run (memcached_st *) return TEST_SUCCESS; } -static test_return_t fnv1a_32_run (memcached_st *) +test_return_t fnv1a_32_run (memcached_st *) { uint32_t x; const char **ptr; @@ -4023,7 +3796,7 @@ static test_return_t fnv1a_32_run (memcached_st *) return TEST_SUCCESS; } -static test_return_t hsieh_run (memcached_st *) +test_return_t hsieh_run (memcached_st *) { test_skip(true, libhashkit_has_algorithm(HASHKIT_HASH_HSIEH)); @@ -4039,7 +3812,7 @@ static test_return_t hsieh_run (memcached_st *) return TEST_SUCCESS; } -static test_return_t murmur_run (memcached_st *) +test_return_t murmur_run (memcached_st *) { test_skip(true, libhashkit_has_algorithm(HASHKIT_HASH_MURMUR)); @@ -4060,7 +3833,7 @@ static test_return_t murmur_run (memcached_st *) #endif } -static test_return_t jenkins_run (memcached_st *) +test_return_t jenkins_run (memcached_st *) { uint32_t x; const char **ptr; @@ -4084,7 +3857,7 @@ static uint32_t hash_crc_test_function(const char *string, size_t string_length, return libhashkit_crc32(string, string_length); } -static test_return_t memcached_get_hashkit_test (memcached_st *) +test_return_t memcached_get_hashkit_test (memcached_st *) { uint32_t x; const char **ptr; @@ -4159,7 +3932,7 @@ static test_return_t memcached_get_hashkit_test (memcached_st *) 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 *) +test_return_t memcached_get_MEMCACHED_ERRNO(memcached_st *) { const char *key= "MemcachedLives"; size_t len; @@ -4184,7 +3957,7 @@ static test_return_t memcached_get_MEMCACHED_ERRNO(memcached_st *) /* 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) +test_return_t memcached_get_MEMCACHED_NOTFOUND(memcached_st *memc) { const char *key= "MemcachedKeyNotEXIST"; size_t len; @@ -4207,7 +3980,7 @@ static test_return_t memcached_get_MEMCACHED_NOTFOUND(memcached_st *memc) 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) +test_return_t memcached_get_by_key_MEMCACHED_ERRNO(memcached_st *memc) { (void)memc; memcached_st *tl_memc_h; @@ -4240,7 +4013,7 @@ static test_return_t memcached_get_by_key_MEMCACHED_ERRNO(memcached_st *memc) /* 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) +test_return_t memcached_get_by_key_MEMCACHED_NOTFOUND(memcached_st *memc) { const char *key= "MemcachedKeyNotEXIST"; size_t len; @@ -4258,7 +4031,7 @@ static test_return_t memcached_get_by_key_MEMCACHED_NOTFOUND(memcached_st *memc) return TEST_SUCCESS; } -static test_return_t regression_bug_434484(memcached_st *memc) +test_return_t regression_bug_434484(memcached_st *memc) { test_skip(TEST_SUCCESS, pre_binary(memc)); @@ -4278,7 +4051,7 @@ static test_return_t regression_bug_434484(memcached_st *memc) return TEST_SUCCESS; } -static test_return_t regression_bug_434843(memcached_st *original_memc) +test_return_t regression_bug_434843(memcached_st *original_memc) { test_skip(TEST_SUCCESS, pre_binary(original_memc)); @@ -4355,7 +4128,7 @@ static test_return_t regression_bug_434843(memcached_st *original_memc) return TEST_SUCCESS; } -static test_return_t regression_bug_434843_buffered(memcached_st *memc) +test_return_t regression_bug_434843_buffered(memcached_st *memc) { memcached_return_t rc; rc= memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_BUFFER_REQUESTS, 1); @@ -4364,7 +4137,7 @@ static test_return_t regression_bug_434843_buffered(memcached_st *memc) return regression_bug_434843(memc); } -static test_return_t regression_bug_421108(memcached_st *memc) +test_return_t regression_bug_421108(memcached_st *memc) { memcached_return_t rc; memcached_stat_st *memc_stat= memcached_stat(memc, NULL, &rc); @@ -4410,7 +4183,7 @@ static test_return_t regression_bug_421108(memcached_st *memc) * delete command or the watermarks, we need to update this * test.... */ -static test_return_t regression_bug_442914(memcached_st *memc) +test_return_t regression_bug_442914(memcached_st *memc) { test_skip(MEMCACHED_SUCCESS, memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_NOREPLY, 1)); memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_TCP_NODELAY, 1); @@ -4441,7 +4214,7 @@ static test_return_t regression_bug_442914(memcached_st *memc) return TEST_SUCCESS; } -static test_return_t regression_bug_447342(memcached_st *memc) +test_return_t regression_bug_447342(memcached_st *memc) { memcached_server_instance_st instance_one; memcached_server_instance_st instance_two; @@ -4563,7 +4336,7 @@ static test_return_t regression_bug_447342(memcached_st *memc) return TEST_SUCCESS; } -static test_return_t regression_bug_463297(memcached_st *memc) +test_return_t regression_bug_463297(memcached_st *memc) { test_compare(MEMCACHED_INVALID_ARGUMENTS, memcached_delete(memc, "foo", 3, 1)); @@ -4634,7 +4407,7 @@ static test_return_t regression_bug_463297(memcached_st *memc) * For a working server set, shall be NULL * For a set of non existing server, shall not be NULL */ -static test_return_t test_get_last_disconnect(memcached_st *memc) +test_return_t test_get_last_disconnect(memcached_st *memc) { memcached_return_t rc; memcached_server_instance_st disconnected_server; @@ -4683,7 +4456,7 @@ static test_return_t test_get_last_disconnect(memcached_st *memc) return TEST_SUCCESS; } -static test_return_t test_multiple_get_last_disconnect(memcached_st *) +test_return_t test_multiple_get_last_disconnect(memcached_st *) { const char *server_string= "--server=localhost:8888 --server=localhost:8889 --server=localhost:8890 --server=localhost:8891 --server=localhost:8892"; char buffer[BUFSIZ]; @@ -4721,7 +4494,7 @@ static test_return_t test_multiple_get_last_disconnect(memcached_st *) return TEST_SUCCESS; } -static test_return_t test_verbosity(memcached_st *memc) +test_return_t test_verbosity(memcached_st *memc) { memcached_verbosity(memc, 3); @@ -4744,7 +4517,7 @@ static memcached_return_t stat_printer(memcached_server_instance_st server, return MEMCACHED_SUCCESS; } -static test_return_t memcached_stat_execute_test(memcached_st *memc) +test_return_t memcached_stat_execute_test(memcached_st *memc) { memcached_return_t rc= memcached_stat_execute(memc, NULL, stat_printer, NULL); test_compare(MEMCACHED_SUCCESS, rc); @@ -4765,7 +4538,7 @@ static test_return_t memcached_stat_execute_test(memcached_st *memc) * This test ensures that the failure counter isn't incremented during * normal termination of the memcached instance. */ -static test_return_t wrong_failure_counter_test(memcached_st *memc) +test_return_t wrong_failure_counter_test(memcached_st *memc) { memcached_return_t rc; memcached_server_instance_st instance; @@ -4814,7 +4587,7 @@ static test_return_t wrong_failure_counter_test(memcached_st *memc) * 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) +test_return_t wrong_failure_counter_two_test(memcached_st *memc) { /* Set value to force connection to the server */ const char *key= "marmotte"; @@ -4858,7 +4631,7 @@ static test_return_t wrong_failure_counter_two_test(memcached_st *memc) /* * Test that ensures mget_execute does not end into recursive calls that finally fails */ -static test_return_t regression_bug_490486(memcached_st *original_memc) +test_return_t regression_bug_490486(memcached_st *original_memc) { #ifdef __APPLE__ @@ -4937,7 +4710,7 @@ static test_return_t regression_bug_490486(memcached_st *original_memc) return TEST_SUCCESS; } -static test_return_t regression_bug_583031(memcached_st *) +test_return_t regression_bug_583031(memcached_st *) { memcached_st *memc= memcached_create(NULL); test_true(memc); @@ -4965,7 +4738,7 @@ static test_return_t regression_bug_583031(memcached_st *) return TEST_SUCCESS; } -static test_return_t regression_bug_581030(memcached_st *) +test_return_t regression_bug_581030(memcached_st *) { #ifndef DEBUG memcached_stat_st *local_stat= memcached_stat(NULL, NULL, NULL); @@ -4978,7 +4751,7 @@ static test_return_t regression_bug_581030(memcached_st *) } #define regression_bug_655423_COUNT 6000 -static test_return_t regression_bug_655423(memcached_st *memc) +test_return_t regression_bug_655423(memcached_st *memc) { memcached_st *clone= memcached_clone(NULL, memc); memc= NULL; // Just to make sure it is not used @@ -5070,7 +4843,7 @@ static test_return_t regression_bug_655423(memcached_st *memc) * Test that ensures that buffered set to not trigger problems during io_flush */ #define regression_bug_490520_COUNT 200480 -static test_return_t regression_bug_490520(memcached_st *memc) +test_return_t regression_bug_490520(memcached_st *memc) { memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_NO_BLOCK,1); memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_BUFFER_REQUESTS,1); @@ -5107,7 +4880,7 @@ static test_return_t regression_bug_490520(memcached_st *memc) } -static test_return_t regression_bug_854604(memcached_st *) +test_return_t regression_bug_854604(memcached_st *) { char buffer[1024]; @@ -5145,7 +4918,7 @@ static void memcached_die(memcached_st* mc, memcached_return error, const char* #define TEST_CONSTANT_CREATION 200 -static test_return_t regression_bug_(memcached_st *memc) +test_return_t regression_bug_(memcached_st *memc) { const char *remote_server; (void)memc; @@ -5234,460 +5007,3 @@ static test_return_t regression_bug_(memcached_st *memc) return TEST_SUCCESS; } - -/* Clean the server before beginning testing */ -test_st tests[] ={ - {"util_version", true, (test_callback_fn*)util_version_test }, - {"flush", false, (test_callback_fn*)flush_test }, - {"init", false, (test_callback_fn*)init_test }, - {"allocation", false, (test_callback_fn*)allocation_test }, - {"server_list_null_test", false, (test_callback_fn*)server_list_null_test}, - {"server_unsort", false, (test_callback_fn*)server_unsort_test}, - {"server_sort", false, (test_callback_fn*)server_sort_test}, - {"server_sort2", false, (test_callback_fn*)server_sort2_test}, - {"memcached_server_remove", false, (test_callback_fn*)memcached_server_remove_test}, - {"clone_test", false, (test_callback_fn*)clone_test }, - {"connection_test", false, (test_callback_fn*)connection_test}, - {"callback_test", false, (test_callback_fn*)callback_test}, - {"userdata_test", false, (test_callback_fn*)userdata_test}, - {"memcached_set()", false, (test_callback_fn*)set_test }, - {"memcached_set() 2", false, (test_callback_fn*)set_test2 }, - {"memcached_set() 3", false, (test_callback_fn*)set_test3 }, - {"add", true, (test_callback_fn*)add_test }, - {"memcached_fetch_result(MEMCACHED_NOTFOUND)", true, (test_callback_fn*)memcached_fetch_result_NOT_FOUND }, - {"replace", true, (test_callback_fn*)replace_test }, - {"delete", true, (test_callback_fn*)delete_test }, - {"get", true, (test_callback_fn*)get_test }, - {"get2", false, (test_callback_fn*)get_test2 }, - {"get3", false, (test_callback_fn*)get_test3 }, - {"get4", false, (test_callback_fn*)get_test4 }, - {"partial mget", false, (test_callback_fn*)get_test5 }, - {"stats_servername", false, (test_callback_fn*)stats_servername_test }, - {"increment", false, (test_callback_fn*)increment_test }, - {"increment_with_initial", true, (test_callback_fn*)increment_with_initial_test }, - {"decrement", false, (test_callback_fn*)decrement_test }, - {"decrement_with_initial", true, (test_callback_fn*)decrement_with_initial_test }, - {"increment_by_key", false, (test_callback_fn*)increment_by_key_test }, - {"increment_with_initial_by_key", true, (test_callback_fn*)increment_with_initial_by_key_test }, - {"decrement_by_key", false, (test_callback_fn*)decrement_by_key_test }, - {"decrement_with_initial_by_key", true, (test_callback_fn*)decrement_with_initial_by_key_test }, - {"binary_increment_with_prefix", true, (test_callback_fn*)binary_increment_with_prefix_test }, - {"quit", false, (test_callback_fn*)quit_test }, - {"mget", true, (test_callback_fn*)mget_test }, - {"mget_result", true, (test_callback_fn*)mget_result_test }, - {"mget_result_alloc", true, (test_callback_fn*)mget_result_alloc_test }, - {"mget_result_function", true, (test_callback_fn*)mget_result_function }, - {"mget_execute", true, (test_callback_fn*)mget_execute }, - {"mget_end", false, (test_callback_fn*)mget_end }, - {"get_stats", false, (test_callback_fn*)get_stats }, - {"add_host_test", false, (test_callback_fn*)add_host_test }, - {"add_host_test_1", false, (test_callback_fn*)add_host_test1 }, - {"get_stats_keys", false, (test_callback_fn*)get_stats_keys }, - {"version_string_test", true, (test_callback_fn*)version_string_test}, - {"memcached_mget() mixed memcached_get()", true, (test_callback_fn*)memcached_mget_mixed_memcached_get_TEST}, - {"bad_key", true, (test_callback_fn*)bad_key_test }, - {"memcached_server_cursor", true, (test_callback_fn*)memcached_server_cursor_test }, - {"read_through", true, (test_callback_fn*)read_through }, - {"delete_through", true, (test_callback_fn*)test_MEMCACHED_CALLBACK_DELETE_TRIGGER }, - {"noreply", true, (test_callback_fn*)noreply_test}, - {"analyzer", true, (test_callback_fn*)analyzer_test}, - {"memcached_pool_st", true, (test_callback_fn*)connection_pool_test }, - {"memcached_pool_st #2", true, (test_callback_fn*)connection_pool2_test }, -#if 0 - {"memcached_pool_st #3", true, (test_callback_fn*)connection_pool3_test }, -#endif - {"memcached_pool_test", true, (test_callback_fn*)memcached_pool_test }, - {"test_get_last_disconnect", true, (test_callback_fn*)test_get_last_disconnect}, - {"verbosity", true, (test_callback_fn*)test_verbosity}, - {"memcached_stat_execute", true, (test_callback_fn*)memcached_stat_execute_test}, - {"memcached_exist(MEMCACHED_NOTFOUND)", true, (test_callback_fn*)memcached_exist_NOTFOUND }, - {"memcached_exist(MEMCACHED_SUCCESS)", true, (test_callback_fn*)memcached_exist_SUCCESS }, - {"memcached_exist_by_key(MEMCACHED_NOTFOUND)", true, (test_callback_fn*)memcached_exist_by_key_NOTFOUND }, - {"memcached_exist_by_key(MEMCACHED_SUCCESS)", true, (test_callback_fn*)memcached_exist_by_key_SUCCESS }, - {"memcached_touch", 0, (test_callback_fn*)test_memcached_touch}, - {"memcached_touch_with_prefix", 0, (test_callback_fn*)test_memcached_touch_by_key}, -#if 0 - {"memcached_dump() no data", true, (test_callback_fn*)memcached_dump_TEST }, -#endif - {"memcached_dump() with data", true, (test_callback_fn*)memcached_dump_TEST2 }, - {0, 0, 0} -}; - -test_st touch_tests[] ={ - {"memcached_touch", 0, (test_callback_fn*)test_memcached_touch}, - {"memcached_touch_with_prefix", 0, (test_callback_fn*)test_memcached_touch_by_key}, - {0, 0, 0} -}; - -test_st memcached_stat_tests[] ={ - {"memcached_stat() INVALID ARG", 0, (test_callback_fn*)memcached_stat_TEST}, - {"memcached_stat()", 0, (test_callback_fn*)memcached_stat_TEST2}, - {0, 0, 0} -}; - -test_st behavior_tests[] ={ - {"libmemcached_string_behavior()", false, (test_callback_fn*)libmemcached_string_behavior_test}, - {"libmemcached_string_distribution()", false, (test_callback_fn*)libmemcached_string_distribution_test}, - {"behavior_test", false, (test_callback_fn*)behavior_test}, - {"MEMCACHED_BEHAVIOR_CORK", false, (test_callback_fn*)MEMCACHED_BEHAVIOR_CORK_test}, - {"MEMCACHED_BEHAVIOR_TCP_KEEPALIVE", false, (test_callback_fn*)MEMCACHED_BEHAVIOR_TCP_KEEPALIVE_test}, - {"MEMCACHED_BEHAVIOR_TCP_KEEPIDLE", false, (test_callback_fn*)MEMCACHED_BEHAVIOR_TCP_KEEPIDLE_test}, - {"MEMCACHED_BEHAVIOR_POLL_TIMEOUT", false, (test_callback_fn*)MEMCACHED_BEHAVIOR_POLL_TIMEOUT_test}, - {"MEMCACHED_CALLBACK_DELETE_TRIGGER_and_MEMCACHED_BEHAVIOR_NOREPLY", false, (test_callback_fn*)test_MEMCACHED_CALLBACK_DELETE_TRIGGER_and_MEMCACHED_BEHAVIOR_NOREPLY}, - {0, 0, 0} -}; - -test_st libmemcachedutil_tests[] ={ - {"libmemcached_util_ping()", true, (test_callback_fn*)ping_test }, - {"libmemcached_util_getpid()", true, (test_callback_fn*)getpid_test }, - {"libmemcached_util_getpid(MEMCACHED_CONNECTION_FAILURE)", true, (test_callback_fn*)getpid_connection_failure_test }, - {0, 0, 0} -}; - -test_st basic_tests[] ={ - {"init", true, (test_callback_fn*)basic_init_test}, - {"clone", true, (test_callback_fn*)basic_clone_test}, - {"reset", true, (test_callback_fn*)basic_reset_stack_test}, - {"reset heap", true, (test_callback_fn*)basic_reset_heap_test}, - {"reset stack clone", true, (test_callback_fn*)basic_reset_stack_clone_test}, - {"reset heap clone", true, (test_callback_fn*)basic_reset_heap_clone_test}, - {"memcached_return_t", false, (test_callback_fn*)memcached_return_t_TEST }, - {0, 0, 0} -}; - -test_st regression_binary_vs_block[] ={ - {"block add", true, (test_callback_fn*)block_add_regression}, - {"binary add", true, (test_callback_fn*)binary_add_regression}, - {0, 0, 0} -}; - -test_st async_tests[] ={ - {"add", true, (test_callback_fn*)add_wrapper }, - {0, 0, 0} -}; - -test_st memcached_server_get_last_disconnect_tests[] ={ - {"memcached_server_get_last_disconnect()", false, (test_callback_fn*)test_multiple_get_last_disconnect}, - {0, 0, (test_callback_fn*)0} -}; - - -test_st result_tests[] ={ - {"result static", false, (test_callback_fn*)result_static}, - {"result alloc", false, (test_callback_fn*)result_alloc}, - {0, 0, (test_callback_fn*)0} -}; - -test_st version_1_2_3[] ={ - {"append", false, (test_callback_fn*)append_test }, - {"prepend", false, (test_callback_fn*)prepend_test }, - {"cas", false, (test_callback_fn*)cas_test }, - {"cas2", false, (test_callback_fn*)cas2_test }, - {"append_binary", false, (test_callback_fn*)append_binary_test }, - {0, 0, (test_callback_fn*)0} -}; - -test_st haldenbrand_TESTS[] ={ - {"memcached_set", false, (test_callback_fn*)haldenbrand_TEST1 }, - {"memcached_get()", false, (test_callback_fn*)haldenbrand_TEST2 }, - {"memcached_mget()", false, (test_callback_fn*)haldenbrand_TEST3 }, - {0, 0, (test_callback_fn*)0} -}; - -test_st user_tests[] ={ - {"user_supplied_bug4", true, (test_callback_fn*)user_supplied_bug4 }, - {"user_supplied_bug5", true, (test_callback_fn*)user_supplied_bug5 }, - {"user_supplied_bug6", true, (test_callback_fn*)user_supplied_bug6 }, - {"user_supplied_bug7", true, (test_callback_fn*)user_supplied_bug7 }, - {"user_supplied_bug8", true, (test_callback_fn*)user_supplied_bug8 }, - {"user_supplied_bug9", true, (test_callback_fn*)user_supplied_bug9 }, - {"user_supplied_bug10", true, (test_callback_fn*)user_supplied_bug10 }, - {"user_supplied_bug11", true, (test_callback_fn*)user_supplied_bug11 }, - {"user_supplied_bug12", true, (test_callback_fn*)user_supplied_bug12 }, - {"user_supplied_bug13", true, (test_callback_fn*)user_supplied_bug13 }, - {"user_supplied_bug14", true, (test_callback_fn*)user_supplied_bug14 }, - {"user_supplied_bug15", true, (test_callback_fn*)user_supplied_bug15 }, - {"user_supplied_bug16", true, (test_callback_fn*)user_supplied_bug16 }, -#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 - ** guess I need to find out how this is supposed to work.. Perhaps I need - ** to run the test in a specific locale (I tried zh_CN.UTF-8 without success, - ** so just disable the code for now...). - */ - {"user_supplied_bug17", true, (test_callback_fn*)user_supplied_bug17 }, -#endif - {"user_supplied_bug18", true, (test_callback_fn*)user_supplied_bug18 }, - {"user_supplied_bug19", true, (test_callback_fn*)user_supplied_bug19 }, - {"user_supplied_bug20", true, (test_callback_fn*)user_supplied_bug20 }, - {"user_supplied_bug21", true, (test_callback_fn*)user_supplied_bug21 }, - {"wrong_failure_counter_test", true, (test_callback_fn*)wrong_failure_counter_test}, - {"wrong_failure_counter_two_test", true, (test_callback_fn*)wrong_failure_counter_two_test}, - {0, 0, (test_callback_fn*)0} -}; - -test_st replication_tests[]= { - {"set", true, (test_callback_fn*)replication_set_test }, - {"get", false, (test_callback_fn*)replication_get_test }, - {"mget", false, (test_callback_fn*)replication_mget_test }, - {"delete", true, (test_callback_fn*)replication_delete_test }, - {"rand_mget", false, (test_callback_fn*)replication_randomize_mget_test }, - {"miss", false, (test_callback_fn*)replication_miss_test }, - {"fail", false, (test_callback_fn*)replication_randomize_mget_fail_test }, - {0, 0, (test_callback_fn*)0} -}; - -/* - * The following test suite is used to verify that we don't introduce - * regression bugs. If you want more information about the bug / test, - * you should look in the bug report at - * http://bugs.launchpad.net/libmemcached - */ -test_st regression_tests[]= { - {"lp:434484", true, (test_callback_fn*)regression_bug_434484 }, - {"lp:434843", true, (test_callback_fn*)regression_bug_434843 }, - {"lp:434843-buffered", true, (test_callback_fn*)regression_bug_434843_buffered }, - {"lp:421108", true, (test_callback_fn*)regression_bug_421108 }, - {"lp:442914", true, (test_callback_fn*)regression_bug_442914 }, - {"lp:447342", true, (test_callback_fn*)regression_bug_447342 }, - {"lp:463297", true, (test_callback_fn*)regression_bug_463297 }, - {"lp:490486", true, (test_callback_fn*)regression_bug_490486 }, - {"lp:583031", true, (test_callback_fn*)regression_bug_583031 }, - {"lp:?", true, (test_callback_fn*)regression_bug_ }, - {"lp:728286", true, (test_callback_fn*)regression_bug_728286 }, - {"lp:581030", true, (test_callback_fn*)regression_bug_581030 }, - {"lp:71231153 connect()", true, (test_callback_fn*)regression_bug_71231153_connect }, - {"lp:71231153 poll()", true, (test_callback_fn*)regression_bug_71231153_poll }, - {"lp:655423", true, (test_callback_fn*)regression_bug_655423 }, - {"lp:490520", true, (test_callback_fn*)regression_bug_490520 }, - {"lp:854604", true, (test_callback_fn*)regression_bug_854604 }, - {0, false, (test_callback_fn*)0} -}; - -test_st ketama_compatibility[]= { - {"libmemcached", true, (test_callback_fn*)ketama_compatibility_libmemcached }, - {"spymemcached", true, (test_callback_fn*)ketama_compatibility_spymemcached }, - {0, 0, (test_callback_fn*)0} -}; - -test_st generate_tests[] ={ - {"generate_pairs", true, (test_callback_fn*)generate_pairs }, - {"generate_data", true, (test_callback_fn*)generate_data }, - {"get_read", false, (test_callback_fn*)get_read }, - {"delete_generate", false, (test_callback_fn*)delete_generate }, - {"generate_buffer_data", true, (test_callback_fn*)generate_buffer_data }, - {"delete_buffer", false, (test_callback_fn*)delete_buffer_generate}, - {"generate_data", true, (test_callback_fn*)generate_data }, - {"mget_read", false, (test_callback_fn*)mget_read }, - {"mget_read_result", false, (test_callback_fn*)mget_read_result }, - {"memcached_fetch_result() use internal result", false, (test_callback_fn*)mget_read_internal_result }, - {"memcached_fetch_result() partial read", false, (test_callback_fn*)mget_read_partial_result }, - {"mget_read_function", false, (test_callback_fn*)mget_read_function }, - {"cleanup", true, (test_callback_fn*)cleanup_pairs }, - {"generate_large_pairs", true, (test_callback_fn*)generate_large_pairs }, - {"generate_data", true, (test_callback_fn*)generate_data }, - {"generate_buffer_data", true, (test_callback_fn*)generate_buffer_data }, - {"cleanup", true, (test_callback_fn*)cleanup_pairs }, - {0, 0, (test_callback_fn*)0} -}; - -test_st consistent_tests[] ={ - {"generate_pairs", true, (test_callback_fn*)generate_pairs }, - {"generate_data", true, (test_callback_fn*)generate_data }, - {"get_read", 0, (test_callback_fn*)get_read_count }, - {"cleanup", true, (test_callback_fn*)cleanup_pairs }, - {0, 0, (test_callback_fn*)0} -}; - -test_st consistent_weighted_tests[] ={ - {"generate_pairs", true, (test_callback_fn*)generate_pairs }, - {"generate_data", true, (test_callback_fn*)generate_data_with_stats }, - {"get_read", false, (test_callback_fn*)get_read_count }, - {"cleanup", true, (test_callback_fn*)cleanup_pairs }, - {0, 0, (test_callback_fn*)0} -}; - -test_st hsieh_availability[] ={ - {"hsieh_avaibility_test", false, (test_callback_fn*)hsieh_avaibility_test}, - {0, 0, (test_callback_fn*)0} -}; - -test_st murmur_availability[] ={ - {"murmur_avaibility_test", false, (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}, - {0, 0, (test_callback_fn*)0} -}; -#endif - -test_st ketama_auto_eject_hosts[] ={ - {"auto_eject_hosts", true, (test_callback_fn*)auto_eject_hosts }, - {"output_ketama_weighted_keys", true, (test_callback_fn*)output_ketama_weighted_keys }, - {0, 0, (test_callback_fn*)0} -}; - -test_st hash_tests[] ={ - {"one_at_a_time_run", false, (test_callback_fn*)one_at_a_time_run }, - {"md5", false, (test_callback_fn*)md5_run }, - {"crc", false, (test_callback_fn*)crc_run }, - {"fnv1_64", false, (test_callback_fn*)fnv1_64_run }, - {"fnv1a_64", false, (test_callback_fn*)fnv1a_64_run }, - {"fnv1_32", false, (test_callback_fn*)fnv1_32_run }, - {"fnv1a_32", false, (test_callback_fn*)fnv1a_32_run }, - {"hsieh", false, (test_callback_fn*)hsieh_run }, - {"murmur", false, (test_callback_fn*)murmur_run }, - {"jenkis", false, (test_callback_fn*)jenkins_run }, - {"memcached_get_hashkit", false, (test_callback_fn*)memcached_get_hashkit_test }, - {0, 0, (test_callback_fn*)0} -}; - -test_st error_conditions[] ={ - {"memcached_get(MEMCACHED_ERRNO)", false, (test_callback_fn*)memcached_get_MEMCACHED_ERRNO }, - {"memcached_get(MEMCACHED_NOTFOUND)", false, (test_callback_fn*)memcached_get_MEMCACHED_NOTFOUND }, - {"memcached_get_by_key(MEMCACHED_ERRNO)", false, (test_callback_fn*)memcached_get_by_key_MEMCACHED_ERRNO }, - {"memcached_get_by_key(MEMCACHED_NOTFOUND)", false, (test_callback_fn*)memcached_get_by_key_MEMCACHED_NOTFOUND }, - {"memcached_get_by_key(MEMCACHED_NOTFOUND)", false, (test_callback_fn*)memcached_get_by_key_MEMCACHED_NOTFOUND }, - {"memcached_increment(MEMCACHED_NO_SERVERS)", false, (test_callback_fn*)memcached_increment_MEMCACHED_NO_SERVERS }, - {0, 0, (test_callback_fn*)0} -}; - -test_st parser_tests[] ={ - {"behavior", false, (test_callback_fn*)behavior_parser_test }, - {"boolean_options", false, (test_callback_fn*)parser_boolean_options_test }, - {"configure_file", false, (test_callback_fn*)memcached_create_with_options_with_filename }, - {"distribtions", false, (test_callback_fn*)parser_distribution_test }, - {"hash", false, (test_callback_fn*)parser_hash_test }, - {"libmemcached_check_configuration", false, (test_callback_fn*)libmemcached_check_configuration_test }, - {"libmemcached_check_configuration_with_filename", false, (test_callback_fn*)libmemcached_check_configuration_with_filename_test }, - {"number_options", false, (test_callback_fn*)parser_number_options_test }, - {"randomly generated options", false, (test_callback_fn*)random_statement_build_test }, - {"namespace", false, (test_callback_fn*)parser_key_prefix_test }, - {"server", false, (test_callback_fn*)server_test }, - {"bad server strings", false, (test_callback_fn*)servers_bad_test }, - {"server with weights", false, (test_callback_fn*)server_with_weight_test }, - {"parsing servername, port, and weight", false, (test_callback_fn*)test_hostname_port_weight }, - {"--socket=", false, (test_callback_fn*)test_parse_socket }, - {"--namespace=", false, (test_callback_fn*)test_namespace_keyword }, - {0, 0, (test_callback_fn*)0} -}; - -test_st virtual_bucket_tests[] ={ - {"basic", false, (test_callback_fn*)virtual_back_map }, - {0, 0, (test_callback_fn*)0} -}; - -test_st memcached_server_add_tests[] ={ - {"memcached_server_add(\"\")", false, (test_callback_fn*)memcached_server_add_empty_test }, - {"memcached_server_add(NULL)", false, (test_callback_fn*)memcached_server_add_null_test }, - {0, 0, (test_callback_fn*)0} -}; - -test_st namespace_tests[] ={ - {"basic tests", true, (test_callback_fn*)selection_of_namespace_tests }, - {"increment", true, (test_callback_fn*)memcached_increment_namespace }, - {0, 0, (test_callback_fn*)0} -}; - -collection_st collection[] ={ -#if 0 - {"hash_sanity", 0, 0, hash_sanity}, -#endif - {"libmemcachedutil", 0, 0, libmemcachedutil_tests}, - {"basic", 0, 0, basic_tests}, - {"hsieh_availability", 0, 0, hsieh_availability}, - {"murmur_availability", 0, 0, murmur_availability}, - {"memcached_server_add", 0, 0, memcached_server_add_tests}, - {"block", 0, 0, tests}, - {"binary", (test_callback_fn*)pre_binary, 0, tests}, - {"nonblock", (test_callback_fn*)pre_nonblock, 0, tests}, - {"nodelay", (test_callback_fn*)pre_nodelay, 0, tests}, - {"settimer", (test_callback_fn*)pre_settimer, 0, tests}, - {"md5", (test_callback_fn*)pre_md5, 0, tests}, - {"crc", (test_callback_fn*)pre_crc, 0, tests}, - {"hsieh", (test_callback_fn*)pre_hsieh, 0, tests}, - {"jenkins", (test_callback_fn*)pre_jenkins, 0, tests}, - {"fnv1_64", (test_callback_fn*)pre_hash_fnv1_64, 0, tests}, - {"fnv1a_64", (test_callback_fn*)pre_hash_fnv1a_64, 0, tests}, - {"fnv1_32", (test_callback_fn*)pre_hash_fnv1_32, 0, tests}, - {"fnv1a_32", (test_callback_fn*)pre_hash_fnv1a_32, 0, tests}, - {"ketama", (test_callback_fn*)pre_behavior_ketama, 0, tests}, - {"ketama_auto_eject_hosts", (test_callback_fn*)pre_behavior_ketama, 0, ketama_auto_eject_hosts}, - {"unix_socket", (test_callback_fn*)pre_unix_socket, 0, tests}, - {"unix_socket_nodelay", (test_callback_fn*)pre_nodelay, 0, tests}, - {"gets", (test_callback_fn*)enable_cas, 0, tests}, - {"consistent_crc", (test_callback_fn*)enable_consistent_crc, 0, tests}, - {"consistent_hsieh", (test_callback_fn*)enable_consistent_hsieh, 0, tests}, -#ifdef MEMCACHED_ENABLE_DEPRECATED - {"deprecated_memory_allocators", (test_callback_fn*)deprecated_set_memory_alloc, 0, tests}, -#endif - {"memory_allocators", (test_callback_fn*)set_memory_alloc, 0, tests}, - {"namespace", (test_callback_fn*)set_namespace, 0, tests}, - {"namespace(BINARY)", (test_callback_fn*)set_namespace_and_binary, 0, tests}, - {"specific namespace", 0, 0, namespace_tests}, - {"specific namespace(BINARY)", (test_callback_fn*)pre_binary, 0, namespace_tests}, - {"version_1_2_3", (test_callback_fn*)check_for_1_2_3, 0, version_1_2_3}, - {"result", 0, 0, result_tests}, - {"async", (test_callback_fn*)pre_nonblock, 0, async_tests}, - {"async(BINARY)", (test_callback_fn*)pre_nonblock_binary, 0, async_tests}, - {"Cal Haldenbrand's tests", 0, 0, haldenbrand_TESTS}, - {"user written tests", 0, 0, user_tests}, - {"generate", 0, 0, generate_tests}, - {"generate_hsieh", (test_callback_fn*)pre_hsieh, 0, generate_tests}, - {"generate_ketama", (test_callback_fn*)pre_behavior_ketama, 0, generate_tests}, - {"generate_hsieh_consistent", (test_callback_fn*)enable_consistent_hsieh, 0, generate_tests}, - {"generate_md5", (test_callback_fn*)pre_md5, 0, generate_tests}, - {"generate_murmur", (test_callback_fn*)pre_murmur, 0, generate_tests}, - {"generate_jenkins", (test_callback_fn*)pre_jenkins, 0, generate_tests}, - {"generate_nonblock", (test_callback_fn*)pre_nonblock, 0, generate_tests}, - // Too slow - {"generate_corked", (test_callback_fn*)pre_cork, 0, generate_tests}, - {"generate_corked_and_nonblock", (test_callback_fn*)pre_cork_and_nonblock, 0, generate_tests}, - {"consistent_not", 0, 0, consistent_tests}, - {"consistent_ketama", (test_callback_fn*)pre_behavior_ketama, 0, consistent_tests}, - {"consistent_ketama_weighted", (test_callback_fn*)pre_behavior_ketama_weighted, 0, consistent_weighted_tests}, - {"ketama_compat", 0, 0, ketama_compatibility}, - {"test_hashes", 0, 0, hash_tests}, - {"replication", (test_callback_fn*)pre_replication, 0, replication_tests}, - {"replication_noblock", (test_callback_fn*)pre_replication_noblock, 0, replication_tests}, - {"regression", 0, 0, regression_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}, - {"virtual buckets", 0, 0, virtual_bucket_tests}, - {"memcached_server_get_last_disconnect", 0, 0, memcached_server_get_last_disconnect_tests}, - {"touch", 0, 0, touch_tests}, - {"touch", (test_callback_fn*)pre_binary, 0, touch_tests}, - {"memcached_stat()", 0, 0, memcached_stat_tests}, - {0, 0, 0, 0} -}; - -#define TEST_PORT_BASE MEMCACHED_DEFAULT_PORT +10 - -#include "tests/libmemcached_world.h" - -void get_world(Framework *world) -{ - world->collections= collection; - - world->_create= (test_callback_create_fn*)world_create; - world->_destroy= (test_callback_destroy_fn*)world_destroy; - - world->item._startup= (test_callback_fn*)world_test_startup; - world->item.set_pre((test_callback_fn*)world_pre_run); - world->item.set_flush((test_callback_fn*)world_flush); - world->item.set_post((test_callback_fn*)world_post_run); - world->_on_error= (test_callback_error_fn*)world_on_error; - - world->collection_startup= (test_callback_fn*)world_container_startup; - world->collection_shutdown= (test_callback_fn*)world_container_shutdown; - - world->set_runner(&defualt_libmemcached_runner); - - world->set_socket(); -} diff --git a/tests/libmemcached-1.0/mem_functions.h b/tests/libmemcached-1.0/mem_functions.h new file mode 100644 index 00000000..a8433743 --- /dev/null +++ b/tests/libmemcached-1.0/mem_functions.h @@ -0,0 +1,180 @@ +/* vim:expandtab:shiftwidth=2:tabstop=2:smarttab: + * + * Libmemcached Client and Server + * + * Copyright (C) 2012 Data Differential, http://datadifferential.com/ + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are + * met: + * + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * + * * Redistributions in binary form must reproduce the above + * copyright notice, this list of conditions and the following disclaimer + * in the documentation and/or other materials provided with the + * distribution. + * + * * The names of its contributors may not be used to endorse or + * promote products derived from this software without specific prior + * written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR + * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT + * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, + * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT + * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE + * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + * + */ + +#pragma once + +test_return_t MEMCACHED_BEHAVIOR_CORK_test(memcached_st *memc); +test_return_t MEMCACHED_BEHAVIOR_POLL_TIMEOUT_test(memcached_st *memc); +test_return_t MEMCACHED_BEHAVIOR_TCP_KEEPALIVE_test(memcached_st *memc); +test_return_t MEMCACHED_BEHAVIOR_TCP_KEEPIDLE_test(memcached_st *memc); +test_return_t _user_supplied_bug21(memcached_st* memc, size_t key_count); +test_return_t add_host_test(memcached_st *memc); +test_return_t add_host_test1(memcached_st *memc); +test_return_t add_test(memcached_st *memc); +test_return_t add_wrapper(memcached_st *memc); +test_return_t allocation_test(memcached_st *not_used); +test_return_t analyzer_test(memcached_st *memc); +test_return_t append_binary_test(memcached_st *memc); +test_return_t append_test(memcached_st *memc); +test_return_t bad_key_test(memcached_st *memc); +test_return_t behavior_test(memcached_st *memc); +test_return_t binary_add_regression(memcached_st *memc); +test_return_t binary_increment_with_prefix_test(memcached_st *memc); +test_return_t block_add_regression(memcached_st *memc); +test_return_t callback_test(memcached_st *memc); +test_return_t cas2_test(memcached_st *memc); +test_return_t cas_test(memcached_st *memc); +test_return_t check_for_1_2_3(memcached_st *memc); +test_return_t clone_test(memcached_st *memc); +test_return_t connection_test(memcached_st *memc); +test_return_t crc_run (memcached_st *); +test_return_t decrement_by_key_test(memcached_st *memc); +test_return_t decrement_test(memcached_st *memc); +test_return_t decrement_with_initial_by_key_test(memcached_st *memc); +test_return_t decrement_with_initial_test(memcached_st *memc); +test_return_t delete_test(memcached_st *memc); +test_return_t deprecated_set_memory_alloc(memcached_st *memc); +test_return_t enable_cas(memcached_st *memc); +test_return_t enable_consistent_crc(memcached_st *memc); +test_return_t enable_consistent_hsieh(memcached_st *memc); +test_return_t flush_test(memcached_st *memc); +test_return_t fnv1_32_run (memcached_st *); +test_return_t fnv1_64_run (memcached_st *); +test_return_t fnv1a_32_run (memcached_st *); +test_return_t fnv1a_64_run (memcached_st *); +test_return_t get_stats(memcached_st *memc); +test_return_t get_stats_keys(memcached_st *memc); +test_return_t get_test(memcached_st *memc); +test_return_t get_test2(memcached_st *memc); +test_return_t get_test3(memcached_st *memc); +test_return_t get_test4(memcached_st *memc); +test_return_t get_test5(memcached_st *memc); +test_return_t getpid_connection_failure_test(memcached_st *memc); +test_return_t getpid_test(memcached_st *memc); +test_return_t hash_sanity_test (memcached_st *memc); +test_return_t hsieh_avaibility_test (memcached_st *memc); +test_return_t hsieh_run (memcached_st *); +test_return_t increment_by_key_test(memcached_st *memc); +test_return_t increment_test(memcached_st *memc); +test_return_t increment_with_initial_by_key_test(memcached_st *memc); +test_return_t increment_with_initial_test(memcached_st *memc); +test_return_t init_test(memcached_st *not_used); +test_return_t jenkins_run (memcached_st *); +test_return_t key_setup(memcached_st *memc); +test_return_t key_teardown(memcached_st *); +test_return_t libmemcached_string_behavior_test(memcached_st *); +test_return_t libmemcached_string_distribution_test(memcached_st *); +test_return_t md5_run (memcached_st *); +test_return_t memcached_fetch_result_NOT_FOUND(memcached_st *memc); +test_return_t memcached_get_MEMCACHED_ERRNO(memcached_st *); +test_return_t memcached_get_MEMCACHED_NOTFOUND(memcached_st *memc); +test_return_t memcached_get_by_key_MEMCACHED_ERRNO(memcached_st *memc); +test_return_t memcached_get_by_key_MEMCACHED_NOTFOUND(memcached_st *memc); +test_return_t memcached_get_hashkit_test (memcached_st *); +test_return_t memcached_mget_mixed_memcached_get_TEST(memcached_st *memc); +test_return_t memcached_return_t_TEST(memcached_st *memc); +test_return_t memcached_server_cursor_test(memcached_st *memc); +test_return_t memcached_server_remove_test(memcached_st*); +test_return_t memcached_stat_execute_test(memcached_st *memc); +test_return_t mget_end(memcached_st *memc); +test_return_t mget_execute(memcached_st *original_memc); +test_return_t mget_result_alloc_test(memcached_st *memc); +test_return_t mget_result_function(memcached_st *memc); +test_return_t mget_result_test(memcached_st *memc); +test_return_t mget_test(memcached_st *memc); +test_return_t murmur_avaibility_test (memcached_st *memc); +test_return_t murmur_run (memcached_st *); +test_return_t noreply_test(memcached_st *memc); +test_return_t one_at_a_time_run (memcached_st *); +test_return_t output_ketama_weighted_keys(memcached_st *); +test_return_t ping_test(memcached_st *memc); +test_return_t prepend_test(memcached_st *memc); +test_return_t quit_test(memcached_st *memc); +test_return_t read_through(memcached_st *memc); +test_return_t regression_bug_(memcached_st *memc); +test_return_t regression_bug_421108(memcached_st *memc); +test_return_t regression_bug_434484(memcached_st *memc); +test_return_t regression_bug_434843(memcached_st *original_memc); +test_return_t regression_bug_434843_buffered(memcached_st *memc); +test_return_t regression_bug_442914(memcached_st *memc); +test_return_t regression_bug_447342(memcached_st *memc); +test_return_t regression_bug_463297(memcached_st *memc); +test_return_t regression_bug_490486(memcached_st *original_memc); +test_return_t regression_bug_490520(memcached_st *memc); +test_return_t regression_bug_581030(memcached_st *); +test_return_t regression_bug_583031(memcached_st *); +test_return_t regression_bug_655423(memcached_st *memc); +test_return_t regression_bug_854604(memcached_st *); +test_return_t replace_test(memcached_st *memc); +test_return_t result_alloc(memcached_st *memc); +test_return_t result_static(memcached_st *memc); +test_return_t selection_of_namespace_tests(memcached_st *memc); +test_return_t server_sort2_test(memcached_st *ptr); +test_return_t server_sort_test(memcached_st *ptr); +test_return_t server_unsort_test(memcached_st *ptr); +test_return_t set_memory_alloc(memcached_st *memc); +test_return_t set_namespace(memcached_st *memc); +test_return_t set_namespace_and_binary(memcached_st *memc); +test_return_t set_test(memcached_st *memc); +test_return_t set_test2(memcached_st *memc); +test_return_t set_test3(memcached_st *memc); +test_return_t stats_servername_test(memcached_st *memc); +test_return_t test_get_last_disconnect(memcached_st *memc); +test_return_t test_multiple_get_last_disconnect(memcached_st *); +test_return_t test_verbosity(memcached_st *memc); +test_return_t user_supplied_bug10(memcached_st *memc); +test_return_t user_supplied_bug11(memcached_st *memc); +test_return_t user_supplied_bug12(memcached_st *memc); +test_return_t user_supplied_bug13(memcached_st *memc); +test_return_t user_supplied_bug14(memcached_st *memc); +test_return_t user_supplied_bug15(memcached_st *memc); +test_return_t user_supplied_bug16(memcached_st *memc); +test_return_t user_supplied_bug17(memcached_st *memc); +test_return_t user_supplied_bug19(memcached_st *); +test_return_t user_supplied_bug20(memcached_st *memc); +test_return_t user_supplied_bug21(memcached_st *memc); +test_return_t user_supplied_bug4(memcached_st *memc); +test_return_t user_supplied_bug5(memcached_st *memc); +test_return_t user_supplied_bug6(memcached_st *memc); +test_return_t user_supplied_bug7(memcached_st *memc); +test_return_t user_supplied_bug8(memcached_st *); +test_return_t user_supplied_bug9(memcached_st *memc); +test_return_t userdata_test(memcached_st *memc); +test_return_t util_version_test(memcached_st *memc); +test_return_t version_string_test(memcached_st *); +test_return_t wrong_failure_counter_test(memcached_st *memc); +test_return_t wrong_failure_counter_two_test(memcached_st *memc); diff --git a/tests/libmemcached-1.0/setup_and_teardowns.cc b/tests/libmemcached-1.0/setup_and_teardowns.cc new file mode 100644 index 00000000..06a49252 --- /dev/null +++ b/tests/libmemcached-1.0/setup_and_teardowns.cc @@ -0,0 +1,258 @@ +/* vim:expandtab:shiftwidth=2:tabstop=2:smarttab: + * + * Libmemcached Client and Server + * + * Copyright (C) 2012 Data Differential, http://datadifferential.com/ + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are + * met: + * + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * + * * Redistributions in binary form must reproduce the above + * copyright notice, this list of conditions and the following disclaimer + * in the documentation and/or other materials provided with the + * distribution. + * + * * The names of its contributors may not be used to endorse or + * promote products derived from this software without specific prior + * written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR + * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT + * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, + * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT + * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE + * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + * + */ + +#include +#include + +#include + +#include "tests/libmemcached-1.0/setup_and_teardowns.h" + +#include + +/** + @note This should be testing to see if the server really supports the binary protocol. +*/ +test_return_t pre_binary(memcached_st *memc) +{ + test_skip(true, libmemcached_util_version_check(memc, 1, 4, 4)); + test_skip(MEMCACHED_SUCCESS, memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL, true)); + + return TEST_SUCCESS; +} + +test_return_t pre_unix_socket(memcached_st *memc) +{ + struct stat buf; + + memcached_servers_reset(memc); + const char *socket_file= libtest::default_socket(); + + test_skip(0, stat(socket_file, &buf)); + + test_compare(MEMCACHED_SUCCESS, + memcached_server_add_unix_socket_with_weight(memc, socket_file, 0)); + + return TEST_SUCCESS; +} + +test_return_t pre_nodelay(memcached_st *memc) +{ + memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_NO_BLOCK, 0); + memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_TCP_NODELAY, 0); + + return TEST_SUCCESS; +} + +test_return_t pre_settimer(memcached_st *memc) +{ + memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_SND_TIMEOUT, 1000); + memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_RCV_TIMEOUT, 1000); + + return TEST_SUCCESS; +} + +test_return_t pre_murmur(memcached_st *memc) +{ + test_skip(MEMCACHED_SUCCESS, memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_HASH, (uint64_t)MEMCACHED_HASH_MURMUR)); + return TEST_SUCCESS; +} + +test_return_t pre_jenkins(memcached_st *memc) +{ + memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_HASH, (uint64_t)MEMCACHED_HASH_JENKINS); + + return TEST_SKIPPED; +} + + +test_return_t pre_md5(memcached_st *memc) +{ + memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_HASH, (uint64_t)MEMCACHED_HASH_MD5); + + return TEST_SUCCESS; +} + +test_return_t pre_crc(memcached_st *memc) +{ + memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_HASH, (uint64_t)MEMCACHED_HASH_CRC); + + return TEST_SUCCESS; +} + +test_return_t pre_hsieh(memcached_st *memc) +{ + test_skip(MEMCACHED_SUCCESS, memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_HASH, (uint64_t)MEMCACHED_HASH_HSIEH)); + return TEST_SUCCESS; +} + +test_return_t pre_hash_fnv1_64(memcached_st *memc) +{ + test_skip(MEMCACHED_SUCCESS, memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_HASH, (uint64_t)MEMCACHED_HASH_MURMUR)); + + return TEST_SUCCESS; +} + +test_return_t pre_hash_fnv1a_64(memcached_st *memc) +{ + test_skip(MEMCACHED_SUCCESS, memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_HASH, (uint64_t)MEMCACHED_HASH_FNV1A_64)); + + return TEST_SUCCESS; +} + +test_return_t pre_hash_fnv1_32(memcached_st *memc) +{ + memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_HASH, (uint64_t)MEMCACHED_HASH_FNV1_32); + + return TEST_SUCCESS; +} + +test_return_t pre_hash_fnv1a_32(memcached_st *memc) +{ + memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_HASH, (uint64_t)MEMCACHED_HASH_FNV1A_32); + + return TEST_SUCCESS; +} + +test_return_t pre_behavior_ketama(memcached_st *memc) +{ + memcached_return_t rc= memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_KETAMA, 1); + test_compare(MEMCACHED_SUCCESS, rc); + + uint64_t value= memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_KETAMA); + test_compare(value, uint64_t(1)); + + return TEST_SUCCESS; +} + +test_return_t pre_behavior_ketama_weighted(memcached_st *memc) +{ + memcached_return_t rc= memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_KETAMA_WEIGHTED, 1); + test_compare(MEMCACHED_SUCCESS, rc); + + uint64_t value= memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_KETAMA_WEIGHTED); + test_compare(value, uint64_t(1)); + + test_compare(MEMCACHED_SUCCESS, + memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_KETAMA_HASH, MEMCACHED_HASH_MD5)); + + value= memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_KETAMA_HASH); + test_compare(MEMCACHED_HASH_MD5, memcached_hash_t(value)); + + return TEST_SUCCESS; +} + +test_return_t pre_replication(memcached_st *memc) +{ + test_skip(TEST_SUCCESS, pre_binary(memc)); + + /* + * Make sure that we store the item on all servers + * (master + replicas == number of servers) + */ + test_compare(MEMCACHED_SUCCESS, memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_NUMBER_OF_REPLICAS, memcached_server_count(memc) - 1)); + test_compare(memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_NUMBER_OF_REPLICAS), uint64_t(memcached_server_count(memc) - 1)); + + return TEST_SUCCESS; +} + + +test_return_t pre_replication_noblock(memcached_st *memc) +{ + test_skip(TEST_SUCCESS, pre_replication(memc)); + + return pre_nonblock(memc); +} + +test_return_t pre_nonblock(memcached_st *memc) +{ + memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_NO_BLOCK, 0); + + return TEST_SUCCESS; +} + +test_return_t pre_cork(memcached_st *memc) +{ +#ifdef __APPLE__ + return TEST_SKIPPED; +#endif + bool set= true; + if (memcached_success(memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_CORK, set))) + return TEST_SUCCESS; + + return TEST_SKIPPED; +} + +test_return_t pre_cork_and_nonblock(memcached_st *memc) +{ +#ifdef __APPLE__ + return TEST_SKIPPED; +#endif + test_return_t test_rc; + if ((test_rc= pre_cork(memc)) != TEST_SUCCESS) + return test_rc; + + return pre_nonblock(memc); +} + +test_return_t pre_nonblock_binary(memcached_st *memc) +{ + memcached_st *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); + + memcached_return_t rc= MEMCACHED_FAILURE; + if (libmemcached_util_version_check(memc_clone, 1, 4, 4)) + { + memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_NO_BLOCK, 0); + test_compare(MEMCACHED_SUCCESS, + memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL, 1)); + test_compare(uint64_t(1), memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL)); + } + else + { + memcached_free(memc_clone); + return TEST_SKIPPED; + } + + memcached_free(memc_clone); + + return rc == MEMCACHED_SUCCESS ? TEST_SUCCESS : TEST_SKIPPED; +} diff --git a/tests/libmemcached-1.0/setup_and_teardowns.h b/tests/libmemcached-1.0/setup_and_teardowns.h new file mode 100644 index 00000000..e141685f --- /dev/null +++ b/tests/libmemcached-1.0/setup_and_teardowns.h @@ -0,0 +1,60 @@ +/* vim:expandtab:shiftwidth=2:tabstop=2:smarttab: + * + * Libmemcached Client and Server + * + * Copyright (C) 2012 Data Differential, http://datadifferential.com/ + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are + * met: + * + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * + * * Redistributions in binary form must reproduce the above + * copyright notice, this list of conditions and the following disclaimer + * in the documentation and/or other materials provided with the + * distribution. + * + * * The names of its contributors may not be used to endorse or + * promote products derived from this software without specific prior + * written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR + * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT + * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, + * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT + * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE + * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + * + */ + +#pragma once + +test_return_t pre_behavior_ketama(memcached_st*); +test_return_t pre_behavior_ketama_weighted(memcached_st*); +test_return_t pre_binary(memcached_st*); +test_return_t pre_cork(memcached_st*); +test_return_t pre_cork_and_nonblock(memcached_st*); +test_return_t pre_crc(memcached_st*); +test_return_t pre_hash_fnv1_32(memcached_st*); +test_return_t pre_hash_fnv1_64(memcached_st*); +test_return_t pre_hash_fnv1a_32(memcached_st*); +test_return_t pre_hash_fnv1a_64(memcached_st*); +test_return_t pre_hsieh(memcached_st*); +test_return_t pre_jenkins(memcached_st*); +test_return_t pre_md5(memcached_st*); +test_return_t pre_murmur(memcached_st*); +test_return_t pre_nodelay(memcached_st*); +test_return_t pre_nonblock(memcached_st*); +test_return_t pre_nonblock_binary(memcached_st*); +test_return_t pre_replication(memcached_st*); +test_return_t pre_replication_noblock(memcached_st*); +test_return_t pre_settimer(memcached_st*); +test_return_t pre_unix_socket(memcached_st*); diff --git a/tests/libmemcached_world.h b/tests/libmemcached_world.h index 824aabe7..97a76c2f 100644 --- a/tests/libmemcached_world.h +++ b/tests/libmemcached_world.h @@ -1,14 +1,42 @@ -/* libMemcached Functions Test - * Copyright (C) 2006-2009 Brian Aker - * All rights reserved. +/* vim:expandtab:shiftwidth=2:tabstop=2:smarttab: + * + * Libmemcached Client and Server * - * Use and distribution licensed under the BSD license. See - * the COPYING file in the parent directory for full text. + * Copyright (C) 2012 Data Differential, http://datadifferential.com/ + * Copyright (C) 2006-2009 Brian Aker + * All rights reserved. * - * Description: This is the startup bits for any libmemcached test. + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are + * met: + * + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * + * * Redistributions in binary form must reproduce the above + * copyright notice, this list of conditions and the following disclaimer + * in the documentation and/or other materials provided with the + * distribution. + * + * * The names of its contributors may not be used to endorse or + * promote products derived from this software without specific prior + * written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR + * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT + * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, + * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT + * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE + * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. * */ + #pragma once #include @@ -16,18 +44,18 @@ /* The structure we use for the test system */ struct libmemcached_test_container_st { - server_startup_st& construct; + libtest::server_startup_st& construct; memcached_st *parent; memcached_st *memc; - libmemcached_test_container_st(server_startup_st &construct_arg) : + libmemcached_test_container_st(libtest::server_startup_st &construct_arg) : construct(construct_arg), parent(NULL), memc(NULL) { } }; -static void *world_create(server_startup_st& servers, test_return_t& error) +static void *world_create(libtest::server_startup_st& servers, test_return_t& error) { if (HAVE_MEMCACHED_BINARY == 0) { @@ -254,7 +282,7 @@ static test_return_t _runner_default(libmemcached_test_callback_fn func, libmemc } catch (std::exception& e) { - Error << e.what(); + libtest::Error << e.what(); return TEST_FAILURE; } @@ -284,7 +312,7 @@ static test_return_t _post_runner_default(libmemcached_test_callback_fn func, li return TEST_SUCCESS; } -class LibmemcachedRunner : public Runner { +class LibmemcachedRunner : public libtest::Runner { public: test_return_t run(test_callback_fn* func, void *object) { diff --git a/tests/print.h b/tests/print.h index 2b30143d..668daeed 100644 --- a/tests/print.h +++ b/tests/print.h @@ -37,15 +37,6 @@ #pragma once -#ifdef __cplusplus -extern "C" { -#endif - -LIBTEST_LOCAL memcached_return_t server_print_callback(const memcached_st *ptr, const memcached_server_st *server, void *context); - -#ifdef __cplusplus -} -#endif -- 2.30.2