From: Brian Aker Date: Sat, 11 Feb 2012 19:43:49 +0000 (-0800) Subject: Update test so that socket and tcp are running the tests, but not interlaced (this... X-Git-Tag: 1.0.5~66 X-Git-Url: https://git.m6w6.name/?a=commitdiff_plain;h=a101fe771182e664d67a1609a6d9dee3d161dc81;p=m6w6%2Flibmemcached Update test so that socket and tcp are running the tests, but not interlaced (this will be allowing for the new upgraded multi-node tests). --- diff --git a/.bzrignore b/.bzrignore index 3b6a590f..6e39c494 100644 --- a/.bzrignore +++ b/.bzrignore @@ -142,3 +142,4 @@ tests/testudp tests/var/ tmp_chroot unittests/unittests +tests/libmemcached-1.0/testsocket diff --git a/libtest/socket.cc b/libtest/socket.cc index d4ab2970..21fade0b 100644 --- a/libtest/socket.cc +++ b/libtest/socket.cc @@ -21,13 +21,17 @@ #include -static char global_socket[1024]; +static char global_socket[1024]= { 0 }; namespace libtest { const char *default_socket() { - assert(global_socket[0]); + if (global_socket[0] == 0) + { + return NULL; + } + return global_socket; } diff --git a/tests/include.am b/tests/include.am index bfdb36b8..41ea2ec3 100644 --- a/tests/include.am +++ b/tests/include.am @@ -24,7 +24,8 @@ EXTRA_DIST+= \ noinst_HEADERS+= \ tests/exist.h \ tests/hash_results.h \ - tests/libmemcached_world.h + tests/libmemcached_world.h \ + tests/libmemcached_world_socket.h # Cycle should always run first tests_cycle_CFLAGS= $(AM_CFLAGS) $(NO_CONVERSION) $(NO_STRICT_ALIASING) diff --git a/tests/libmemcached-1.0/all_tests_socket.cc b/tests/libmemcached-1.0/all_tests_socket.cc new file mode 100644 index 00000000..9698cc75 --- /dev/null +++ b/tests/libmemcached-1.0/all_tests_socket.cc @@ -0,0 +1,90 @@ +/* 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_socket.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); +} diff --git a/tests/libmemcached-1.0/include.am b/tests/libmemcached-1.0/include.am index af5f5e7e..702d4a6f 100644 --- a/tests/libmemcached-1.0/include.am +++ b/tests/libmemcached-1.0/include.am @@ -96,6 +96,52 @@ tests_libmemcached_1_0_testapp_LDADD= \ check_PROGRAMS+= tests/libmemcached-1.0/testapp noinst_PROGRAMS+= tests/libmemcached-1.0/testapp +tests_libmemcached_1_0_testsocket_CXXFLAGS = $(AM_CXXFLAGS) ${PTHREAD_CFLAGS} +tests_libmemcached_1_0_testsocket_CFLAGS= $(AM_CFLAGS) $(NO_CONVERSION) $(NO_STRICT_ALIASING) +tests_libmemcached_1_0_testsocket_SOURCES= \ + tests/libmemcached-1.0/all_tests_socket.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/haldenbrand.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_testsocket_SOURCES+= clients/generator.cc clients/execute.cc +tests_libmemcached_1_0_testsocket_DEPENDENCIES= \ + libmemcached/libmemcached.la \ + libtest/libtest.la \ + libhashkit/libhashkit.la \ + libmemcached/libmemcachedutil.la + +tests_libmemcached_1_0_testsocket_LDADD= \ + $(LIBUUID_LDFLAGS) \ + ${PTHREAD_LIBS} \ + libmemcached/libmemcached.la \ + libmemcached/libmemcachedutil.la \ + libtest/libtest.la \ + libhashkit/libhashkit.la + +check_PROGRAMS+= tests/libmemcached-1.0/testsocket +noinst_PROGRAMS+= tests/libmemcached-1.0/testsocket + tests_libmemcached_1_0_sasl_CXXFLAGS = $(AM_CXXFLAGS) ${PTHREAD_CFLAGS} tests_libmemcached_1_0_sasl_CFLAGS= $(AM_CFLAGS) $(NO_CONVERSION) $(NO_STRICT_ALIASING) tests_libmemcached_1_0_sasl_SOURCES= \ diff --git a/tests/libmemcached-1.0/mem_functions.cc b/tests/libmemcached-1.0/mem_functions.cc index 902b1c82..ef7725e7 100644 --- a/tests/libmemcached-1.0/mem_functions.cc +++ b/tests/libmemcached-1.0/mem_functions.cc @@ -213,16 +213,32 @@ static memcached_st * create_single_instance_memcached(const memcached_st *origi char server_string[1024]; int server_string_length; - if (options) + if (instance->type == MEMCACHED_CONNECTION_UNIX_SOCKET) { - server_string_length= snprintf(server_string, sizeof(server_string), "--server=%s:%d %s", - memcached_server_name(instance), int(memcached_server_port(instance)), - options); + if (options) + { + server_string_length= snprintf(server_string, sizeof(server_string), "--SOCKET=\"%s\" %s", + memcached_server_name(instance), options); + } + else + { + server_string_length= snprintf(server_string, sizeof(server_string), "--SOCKET=\"%s\"", + memcached_server_name(instance)); + } } else { - server_string_length= snprintf(server_string, sizeof(server_string), "--server=%s:%d", - memcached_server_name(instance), int(memcached_server_port(instance))); + if (options) + { + server_string_length= snprintf(server_string, sizeof(server_string), "--server=%s:%d %s", + memcached_server_name(instance), int(memcached_server_port(instance)), + options); + } + else + { + server_string_length= snprintf(server_string, sizeof(server_string), "--server=%s:%d", + memcached_server_name(instance), int(memcached_server_port(instance))); + } } if (server_string_length <= 0) @@ -233,7 +249,7 @@ static memcached_st * create_single_instance_memcached(const memcached_st *origi char buffer[1024]; if (memcached_failed(libmemcached_check_configuration(server_string, server_string_length, buffer, sizeof(buffer)))) { - Error << "Failed to parse " << server_string_length; + Error << "Failed to parse (" << server_string << ") " << buffer; return NULL; } @@ -2527,6 +2543,8 @@ test_return_t user_supplied_bug9(memcached_st *memc) /* We are testing with aggressive timeout to get failures */ test_return_t user_supplied_bug10(memcached_st *memc) { + test_skip(memc->servers[0].type, MEMCACHED_CONNECTION_TCP); + size_t value_length= 512; unsigned int set= 1; memcached_st *mclone= memcached_clone(NULL, memc); @@ -3598,6 +3616,7 @@ test_return_t util_version_test(memcached_st *memc) test_return_t getpid_connection_failure_test(memcached_st *memc) { + test_skip(memc->servers[0].type, MEMCACHED_CONNECTION_TCP); memcached_return_t rc; memcached_server_instance_st instance= memcached_server_instance_by_position(memc, 0); diff --git a/tests/libmemcached-1.0/setup_and_teardowns.cc b/tests/libmemcached-1.0/setup_and_teardowns.cc index 06a49252..84f57abe 100644 --- a/tests/libmemcached-1.0/setup_and_teardowns.cc +++ b/tests/libmemcached-1.0/setup_and_teardowns.cc @@ -61,6 +61,7 @@ test_return_t pre_unix_socket(memcached_st *memc) memcached_servers_reset(memc); const char *socket_file= libtest::default_socket(); + test_skip(true, bool(socket_file)); test_skip(0, stat(socket_file, &buf)); diff --git a/tests/libmemcached_world.h b/tests/libmemcached_world.h index 97a76c2f..2e7aa25d 100644 --- a/tests/libmemcached_world.h +++ b/tests/libmemcached_world.h @@ -76,7 +76,6 @@ static void *world_create(libtest::server_startup_st& servers, test_return_t& er return NULL; } - in_port_t max_port= TEST_PORT_BASE; for (uint32_t x= 0; x < servers.count(); x++) { in_port_t port; @@ -94,7 +93,6 @@ static void *world_create(libtest::server_startup_st& servers, test_return_t& er port= in_port_t(TEST_PORT_BASE +x); } - max_port= port; const char *argv[1]= { "memcached" }; if (servers.sasl()) { @@ -114,29 +112,6 @@ static void *world_create(libtest::server_startup_st& servers, test_return_t& er } } - if (servers.socket()) - { - if (servers.sasl()) - { - const char *argv[1]= { "memcached" }; - if (not servers.start_socket_server("memcached-sasl", max_port +1, 1, argv)) - { - error= TEST_FATAL; - return NULL; - } - } - else - { - const char *argv[1]= { "memcached" }; - if (not servers.start_socket_server("memcached", max_port +1, 1, argv)) - { - error= TEST_FATAL; - return NULL; - } - } - } - - libmemcached_test_container_st *global_container= new libmemcached_test_container_st(servers); if (global_container == NULL) { diff --git a/tests/libmemcached_world_socket.h b/tests/libmemcached_world_socket.h new file mode 100644 index 00000000..b034ca61 --- /dev/null +++ b/tests/libmemcached_world_socket.h @@ -0,0 +1,271 @@ +/* vim:expandtab:shiftwidth=2:tabstop=2:smarttab: + * + * Libmemcached Client and Server + * + * Copyright (C) 2011-2012 Data Differential, http://datadifferential.com/ + * Copyright (C) 2006-2009 Brian Aker + * 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 + +#include + +/* The structure we use for the test system */ +struct libmemcached_test_container_st +{ + libtest::server_startup_st& construct; + memcached_st *parent; + memcached_st *memc; + + libmemcached_test_container_st(libtest::server_startup_st &construct_arg) : + construct(construct_arg), + parent(NULL), + memc(NULL) + { } +}; + +static void *world_create(libtest::server_startup_st& servers, test_return_t& error) +{ + if (HAVE_MEMCACHED_BINARY == 0) + { + error= TEST_SKIPPED; + return NULL; + } + + in_port_t max_port= TEST_PORT_BASE; + for (uint32_t x= 0; x < servers.count(); x++) + { + const char *argv[1]= { "memcached" }; + if (not servers.start_socket_server("memcached", max_port +1, 1, argv)) + { + error= TEST_FATAL; + 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; +#if defined(LIBMEMCACHED_WITH_SASL_SUPPORT) && LIBMEMCACHED_WITH_SASL_SUPPORT + if (LIBMEMCACHED_WITH_SASL_SUPPORT) + { + sasl_done(); + } +#endif + + delete container; + + return TEST_SUCCESS; +} + +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) + { + libtest::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 libtest::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;