X-Git-Url: https://git.m6w6.name/?a=blobdiff_plain;f=tests%2Flibmemcached_world.h;h=ded47ada1ed66fb604a1ca2ccdde017101cab44c;hb=450a9f280cd5d5b83da7561ff0362854f5c8b204;hp=e2f0c27d2e4b9de3df69d6ce482c8c8b8bfc5d18;hpb=58c279d58e2a44562f729e93e301dfedf42f530b;p=m6w6%2Flibmemcached diff --git a/tests/libmemcached_world.h b/tests/libmemcached_world.h index e2f0c27d..ded47ada 100644 --- a/tests/libmemcached_world.h +++ b/tests/libmemcached_world.h @@ -1,119 +1,100 @@ -/* 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 +#pragma once /* 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) { } }; -#define SERVERS_TO_CREATE 5 - -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 (LIBMEMCACHED_WITH_SASL_SUPPORT == 0) + if (HAVE_MEMCACHED_BINARY == 0) { error= TEST_SKIPPED; return NULL; } - // Assume we are running under valgrind, and bail - if (servers.sasl() and getenv("TESTS_ENVIRONMENT")) + if (servers.sasl() and (LIBMEMCACHED_WITH_SASL_SUPPORT == 0 or MEMCACHED_SASL_BINARY == 0)) { error= TEST_SKIPPED; return NULL; } - - in_port_t max_port; - for (uint32_t x= 0; x < SERVERS_TO_CREATE; x++) + // Assume we are running under valgrind, and bail + if (servers.sasl() and getenv("TESTS_ENVIRONMENT")) { - in_port_t port; - - char variable_buffer[1024]; - snprintf(variable_buffer, sizeof(variable_buffer), "LIBMEMCACHED_PORT_%u", x); - - char *var; - if ((var= getenv(variable_buffer))) - { - port= in_port_t(atoi(var)); - } - else - { - port= in_port_t(TEST_PORT_BASE +x); - } - - max_port= port; - const char *argv[1]= { "memcached" }; - if (servers.sasl()) - { - if (not server_startup(servers, "memcached-sasl", port, 1, argv)) - { - error= TEST_FAILURE; - return NULL; - } - } - else - { - if (not server_startup(servers, "memcached", port, 1, argv)) - { - error= TEST_FAILURE; - return NULL; - } - } + error= TEST_SKIPPED; + return NULL; } - if (servers.socket()) + for (uint32_t x= 0; x < servers.servers_to_run(); x++) { + in_port_t port= libtest::get_free_port(); + if (servers.sasl()) { - const char *argv[1]= { "memcached" }; - if (not servers.start_socket_server("memcached-sasl", max_port +1, 1, argv)) + if (server_startup(servers, "memcached-sasl", port, 0, NULL) == false) { - error= TEST_FAILURE; - return NULL; + fatal_message("Could not start memcached-sasl"); } } else { - const char *argv[1]= { "memcached" }; - if (not servers.start_socket_server("memcached", max_port +1, 1, argv)) + if (server_startup(servers, "memcached", port, 0, NULL) == false) { - error= TEST_FAILURE; - return NULL; + fatal_message("Could not start memcached"); } } } - libmemcached_test_container_st *global_container= new libmemcached_test_container_st(servers); - if (global_container == NULL) - { - error= TEST_MEMORY_ALLOCATION_FAILURE; - return NULL; - } - - error= TEST_SUCCESS; return global_container; } @@ -127,9 +108,10 @@ static test_return_t world_container_startup(libmemcached_test_container_st *con buffer, sizeof(buffer)), container->construct.option_string().c_str()); - test_true(not container->parent); + test_null(container->parent); container->parent= memcached(container->construct.option_string().c_str(), container->construct.option_string().size()); test_true(container->parent); + test_compare(MEMCACHED_SUCCESS, memcached_version(container->parent)); if (container->construct.sasl()) { @@ -146,17 +128,6 @@ static test_return_t world_container_startup(libmemcached_test_container_st *con } } - for (uint32_t host= 0; host < memcached_server_count(container->parent); ++host) - { - memcached_server_instance_st instance= - memcached_server_instance_by_position(container->parent, host); - - if (instance->type == MEMCACHED_CONNECTION_TCP) - { - test_true_got(memcached_server_port(instance) >= TEST_PORT_BASE, memcached_server_port(instance)); - } - } - return TEST_SUCCESS; } @@ -171,7 +142,7 @@ static test_return_t world_container_shutdown(libmemcached_test_container_st *co static test_return_t world_test_startup(libmemcached_test_container_st *container) { test_true(container); - test_true(not container->memc); + test_null(container->memc); test_true(container->parent); container->memc= memcached_clone(NULL, container->parent); test_true(container->memc); @@ -189,32 +160,8 @@ test_return_t world_flush(libmemcached_test_container_st *container) return TEST_SUCCESS; } -static test_return_t world_pre_run(libmemcached_test_container_st *container) +static test_return_t world_on_error(test_return_t , libmemcached_test_container_st *container) { - test_true(container->memc); - for (uint32_t loop= 0; loop < memcached_server_list_count(container->memc->servers); loop++) - { - memcached_server_instance_st instance= - memcached_server_instance_by_position(container->memc, loop); - - test_compare(-1, instance->fd); - test_compare(0U, instance->cursor_active); - } - - return TEST_SUCCESS; -} - - -static test_return_t world_post_run(libmemcached_test_container_st *container) -{ - test_true(container->memc); - - return TEST_SUCCESS; -} - -static test_return_t world_on_error(test_return_t test_state, libmemcached_test_container_st *container) -{ - (void)test_state; test_true(container->memc); memcached_free(container->memc); container->memc= NULL; @@ -239,54 +186,4 @@ static bool world_destroy(void *object) typedef test_return_t (*libmemcached_test_callback_fn)(memcached_st *); -static test_return_t _runner_default(libmemcached_test_callback_fn func, libmemcached_test_container_st *container) -{ - if (func) - { - test_true(container); - test_true(container->memc); - return func(container->memc); - } - - return TEST_SUCCESS; -} - -static test_return_t _pre_runner_default(libmemcached_test_callback_fn func, libmemcached_test_container_st *container) -{ - if (func) - { - return func(container->parent); - } - - return TEST_SUCCESS; -} - -static test_return_t _post_runner_default(libmemcached_test_callback_fn func, libmemcached_test_container_st *container) -{ - if (func) - { - return func(container->parent); - } - - return TEST_SUCCESS; -} - -class LibmemcachedRunner : public Runner { -public: - test_return_t run(test_callback_fn* func, void *object) - { - return _runner_default(libmemcached_test_callback_fn(func), (libmemcached_test_container_st*)object); - } - - test_return_t pre(test_callback_fn* func, void *object) - { - return _pre_runner_default(libmemcached_test_callback_fn(func), (libmemcached_test_container_st*)object); - } - - test_return_t post(test_callback_fn* func, void *object) - { - return _post_runner_default(libmemcached_test_callback_fn(func), (libmemcached_test_container_st*)object); - } -}; - -static LibmemcachedRunner defualt_libmemcached_runner; +#include "tests/runner.h"