X-Git-Url: https://git.m6w6.name/?a=blobdiff_plain;f=tests%2Flibmemcached_world.h;h=6bb0a8712f6edddda244413d4c5a553ab2586e8d;hb=a2d8823001195258acb3b7d1205f2502dd349ae4;hp=824aabe751adfa503384f780d83233d404f81db1;hpb=64e070cda2cc99513fdbaae770a473d5338c9378;p=awesomized%2Flibmemcached diff --git a/tests/libmemcached_world.h b/tests/libmemcached_world.h index 824aabe7..6bb0a871 100644 --- a/tests/libmemcached_world.h +++ b/tests/libmemcached_world.h @@ -1,41 +1,55 @@ -/* 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 -/* The structure we use for the test system */ -struct libmemcached_test_container_st -{ - server_startup_st& construct; - memcached_st *parent; - memcached_st *memc; +#pragma once - libmemcached_test_container_st(server_startup_st &construct_arg) : - construct(construct_arg), - parent(NULL), - memc(NULL) - { } -}; +#include "tests/libmemcached_test_container.h" -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) + if (libtest::has_memcached() == false) { error= TEST_SKIPPED; return NULL; } - if (servers.sasl() and (LIBMEMCACHED_WITH_SASL_SUPPORT == 0 or MEMCACHED_SASL_BINARY == 0)) + if (servers.sasl() and ((LIBMEMCACHED_WITH_SASL_SUPPORT == 0) or (MEMCACHED_SASL_BINARY == 0))) { error= TEST_SKIPPED; return NULL; @@ -48,183 +62,39 @@ static void *world_create(server_startup_st& servers, test_return_t& error) return NULL; } - in_port_t max_port= TEST_PORT_BASE; - for (uint32_t x= 0; x < servers.count(); x++) + for (uint32_t x= 0; x < servers.servers_to_run(); x++) { - 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_FATAL; - return NULL; - } - } - else - { - if (not server_startup(servers, "memcached", port, 1, argv)) - { - error= TEST_FATAL; - return NULL; - } - } - } + in_port_t port= libtest::get_free_port(); - if (servers.socket()) - { 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_FATAL; + error= TEST_SKIPPED; +#if 0 + fatal_message("Could not start memcached-sasl"); +#endif return NULL; } } 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_FATAL; + error= TEST_SKIPPED; +#if 0 + fatal_message("Could not start memcached"); +#endif return NULL; } } } - 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; } -static test_return_t world_container_startup(libmemcached_test_container_st *container) -{ - char buffer[BUFSIZ]; - - test_compare_got(MEMCACHED_SUCCESS, - libmemcached_check_configuration(container->construct.option_string().c_str(), container->construct.option_string().size(), - buffer, sizeof(buffer)), - container->construct.option_string().c_str()); - - 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()) - { - if (memcached_failed(memcached_behavior_set(container->parent, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL, 1))) - { - memcached_free(container->parent); - return TEST_FAILURE; - } - - if (memcached_failed(memcached_set_sasl_auth_data(container->parent, container->construct.username().c_str(), container->construct.password().c_str()))) - { - memcached_free(container->parent); - return TEST_FAILURE; - } - } - - 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; -} - -static test_return_t world_container_shutdown(libmemcached_test_container_st *container) -{ - memcached_free(container->parent); - container->parent= NULL; - - return TEST_SUCCESS; -} - -static test_return_t world_test_startup(libmemcached_test_container_st *container) -{ - test_true(container); - test_null(container->memc); - test_true(container->parent); - container->memc= memcached_clone(NULL, container->parent); - test_true(container->memc); - - return TEST_SUCCESS; -} - -test_return_t world_flush(libmemcached_test_container_st *container); -test_return_t world_flush(libmemcached_test_container_st *container) -{ - test_true(container->memc); - memcached_flush(container->memc, 0); - memcached_quit(container->memc); - - return TEST_SUCCESS; -} - -static test_return_t world_pre_run(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 , libmemcached_test_container_st *container) -{ - test_true(container->memc); - memcached_free(container->memc); - container->memc= NULL; - - return TEST_SUCCESS; -} - static bool world_destroy(void *object) { libmemcached_test_container_st *container= (libmemcached_test_container_st *)object; @@ -242,64 +112,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); - test_return_t ret; - try { - ret= func(container->memc); - } - catch (std::exception& e) - { - Error << e.what(); - return TEST_FAILURE; - } - - return ret; - } - - 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"