From: Brian Aker Date: Tue, 17 Apr 2012 16:55:40 +0000 (-0700) Subject: Update framework. X-Git-Tag: 1.0.7~7^2^2^2 X-Git-Url: https://git.m6w6.name/?a=commitdiff_plain;h=7933fa8f9217d7e744876773a4033b3cda4c3c16;p=awesomized%2Flibmemcached Update framework. --- diff --git a/configure.ac b/configure.ac index de2bc881..19c54d5c 100644 --- a/configure.ac +++ b/configure.ac @@ -71,6 +71,7 @@ m4_include([memcached/version.m4]) AM_CONDITIONAL(BUILDING_LIBMEMCACHED, true) AM_CONDITIONAL(HAVE_LIBMEMCACHED, false) +AM_CONDITIONAL(HAVE_LIBDRIZZLE, false) AC_DEFINE([HAVE_LIBMEMCACHED], [1], [Enables libmemcached Support]) AM_CONDITIONAL(BUILDING_GEARMAN, false) @@ -218,6 +219,7 @@ AS_IF([test "x$ac_cv_header_atomic_h" = "xyes"],[ AC_DEFINE([HAVE_LIBDRIZZLE], [0], [Support for libdrizzle]) AC_DEFINE([HAVE_DRIZZLED_BINARY], [0], [Support for DrizzleD]) +AC_DEFINE([DRIZZLED_BINARY], [0], [Support for DrizzleD]) AC_DEFINE([GEARMAND_BLOBSLAP_WORKER], [0], [Support for Gearman Blobslap worker]) AC_DEFINE([HAVE_LIBPQ], [0], [Support for Postgres]) AC_DEFINE([HAVE_LIBCURL], [0], [Support for libcurl]) diff --git a/example/t/memcached_light.cc b/example/t/memcached_light.cc index bcfce0a5..e24d31c2 100644 --- a/example/t/memcached_light.cc +++ b/example/t/memcached_light.cc @@ -166,8 +166,6 @@ public: } }; -static MemcachedLightRunner defualt_libmemcached_runner; - test_st cmdline_option_TESTS[] ={ {"--help", true, help_TEST }, {"--verbose", true, verbose_TEST }, @@ -238,6 +236,6 @@ void get_world(Framework *world) world->_create= world_create; world->_destroy= world_destroy; world->collections= collection; - world->set_runner(&defualt_libmemcached_runner); + world->set_runner(new MemcachedLightRunner); } diff --git a/libtest/binaries.cc b/libtest/binaries.cc index e437f969..2efde2f3 100644 --- a/libtest/binaries.cc +++ b/libtest/binaries.cc @@ -46,10 +46,22 @@ bool has_gearmand_binary() return false; } +bool has_drizzled_binary() +{ +#if defined(HAVE_DRIZZLED_BINARY) && HAVE_DRIZZLED_BINARY + if (access(DRIZZLED_BINARY, R_OK|X_OK) == 0) + { + return true; + } +#endif + + return false; +} + bool has_memcached_binary() { #if defined(HAVE_MEMCACHED_BINARY) && HAVE_MEMCACHED_BINARY - if (access(MEMCACHED_BINARY,R_OK|X_OK) == 0) + if (access(MEMCACHED_BINARY, R_OK|X_OK) == 0) { return true; } diff --git a/libtest/binaries.h b/libtest/binaries.h index e071016c..0b886872 100644 --- a/libtest/binaries.h +++ b/libtest/binaries.h @@ -32,5 +32,8 @@ bool has_memcached_sasl_binary(); LIBTEST_API bool has_gearmand_binary(); +LIBTEST_API +bool has_drizzled_binary(); + } // namespace libtest diff --git a/libtest/cmdline.cc b/libtest/cmdline.cc index de7c89d7..6b8205cb 100644 --- a/libtest/cmdline.cc +++ b/libtest/cmdline.cc @@ -113,6 +113,7 @@ Application::Application(const std::string& arg, const bool _use_libtool_arg) : _use_valgrind(false), _use_gdb(false), _use_ptrcheck(false), + _will_fail(false), _argc(0), _exectuble(arg), stdin_fd(STDIN_FILENO), @@ -252,7 +253,10 @@ Application::error_t Application::run(const char *args[]) if (spawn_ret != 0) { - Error << strerror(spawn_ret) << "(" << spawn_ret << ")"; + if (_will_fail == false) + { + Error << strerror(spawn_ret) << "(" << spawn_ret << ")"; + } _pid= -1; return Application::INVALID; } @@ -792,4 +796,9 @@ const char *gearmand_binary() return GEARMAND_BINARY; } +const char *drizzled_binary() +{ + return DRIZZLED_BINARY; +} + } // namespace exec_cmdline diff --git a/libtest/cmdline.h b/libtest/cmdline.h index 44fd17f9..a3d9cb25 100644 --- a/libtest/cmdline.h +++ b/libtest/cmdline.h @@ -134,6 +134,11 @@ public: return _pid; } + void will_fail() + { + _will_fail= true; + } + private: void create_argv(const char *args[]); void delete_argv(); @@ -143,6 +148,7 @@ private: bool _use_valgrind; bool _use_gdb; bool _use_ptrcheck; + bool _will_fail; size_t _argc; std::string _exectuble_name; std::string _exectuble; @@ -184,5 +190,6 @@ static inline std::ostream& operator<<(std::ostream& output, const enum Applicat int exec_cmdline(const std::string& executable, const char *args[], bool use_libtool= false); const char *gearmand_binary(); +const char *drizzled_binary(); } diff --git a/libtest/common.h b/libtest/common.h index 05f273a7..39b99c51 100644 --- a/libtest/common.h +++ b/libtest/common.h @@ -58,6 +58,7 @@ #include #include #include +#include #include #include diff --git a/libtest/drizzled.cc b/libtest/drizzled.cc new file mode 100644 index 00000000..c1241922 --- /dev/null +++ b/libtest/drizzled.cc @@ -0,0 +1,206 @@ +/* vim:expandtab:shiftwidth=2:tabstop=2:smarttab: + * + * libtest + * + * Copyright (C) 2011 Data Differential, http://datadifferential.com/ + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License as published by the Free Software Foundation; either + * version 3 of the License, or (at your option) any later version. + * + * This library is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this library; if not, write to the Free Software + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA + */ + + +#include +#include + +#include + +#include "util/instance.hpp" +#include "util/operation.hpp" + +using namespace datadifferential; +using namespace libtest; + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#ifndef __INTEL_COMPILER +#pragma GCC diagnostic ignored "-Wold-style-cast" +#endif + +#if defined(HAVE_LIBDRIZZLE) && HAVE_LIBDRIZZLE +#include +#endif + +using namespace libtest; + +namespace libtest { +bool ping_drizzled(const in_port_t _port) +{ +#if defined(HAVE_LIBDRIZZLE) && HAVE_LIBDRIZZLE + { + drizzle_st *drizzle= drizzle_create(NULL); + + if (drizzle == NULL) + { + return false; + } + + drizzle_con_st *con; + + if ((con= drizzle_con_create(drizzle, NULL)) == NULL) + { + drizzle_free(drizzle); + return false; + } + + drizzle_con_set_tcp(con, "localhost", _port); + drizzle_con_set_auth(con, "root", 0); + + bool success= false; + + drizzle_return_t rc; + if ((rc= drizzle_con_connect(con)) == DRIZZLE_RETURN_OK) + { + drizzle_result_st *result= drizzle_ping(con, NULL, &rc); + success= bool(result); + drizzle_result_free(result); + } + + if (success == true) + { } + else if (rc != DRIZZLE_RETURN_OK) + { + Error << drizzle_error(drizzle) << " localhost:" << _port; + } + + drizzle_con_free(con); + drizzle_free(drizzle); + + return success; + } +#endif + + return false; +} +} // namespace libtest + +class Drizzle : public libtest::Server +{ +private: +public: + Drizzle(const std::string& host_arg, in_port_t port_arg) : + libtest::Server(host_arg, port_arg, DRIZZLED_BINARY, false) + { + set_pid_file(); + } + + bool ping() + { + size_t limit= 5; + while (_app.check() and --limit) + { + if (ping_drizzled(_port)) + { + return true; + } + libtest::dream(1, 0); + } + + return false; + } + + const char *name() + { + return "drizzled"; + }; + + void log_file_option(Application& app, const std::string& arg) + { + } + + bool has_log_file_option() const + { + return true; + } + + bool broken_pid_file() + { + return true; + } + + bool is_libtool() + { + return false; + } + + bool has_syslog() const + { + return true; + } + + bool has_port_option() const + { + return true; + } + + void port_option(Application& app, in_port_t arg) + { + if (arg > 0) + { + char buffer[1024]; + snprintf(buffer, sizeof(buffer), "--drizzle-protocol.port=%d", int(arg)); + app.add_option(buffer); + } + } + + bool build(size_t argc, const char *argv[]); +}; + +bool Drizzle::build(size_t argc, const char *argv[]) +{ + if (getuid() == 0 or geteuid() == 0) + { + add_option("--user=root"); + } + + add_option("--verbose=INSPECT"); +#if 0 + add_option("--datadir=var/drizzle"); +#endif + + for (size_t x= 0 ; x < argc ; x++) + { + add_option(argv[x]); + } + + return true; +} + +namespace libtest { + +libtest::Server *build_drizzled(const char *hostname, in_port_t try_port) +{ + return new Drizzle(hostname, try_port); +} + +} diff --git a/libtest/drizzled.h b/libtest/drizzled.h new file mode 100644 index 00000000..496a2019 --- /dev/null +++ b/libtest/drizzled.h @@ -0,0 +1,36 @@ +/* vim:expandtab:shiftwidth=2:tabstop=2:smarttab: + * + * libtest + * + * Copyright (C) 2012 Data Differential, http://datadifferential.com/ + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License as published by the Free Software Foundation; either + * version 3 of the License, or (at your option) any later version. + * + * This library is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this library; if not, write to the Free Software + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA + */ + + +#pragma once + +#include + +namespace libtest { struct Server; } + +namespace libtest { + +libtest::Server *build_drizzled(const char *hostname, in_port_t try_port); + +bool ping_drizzled(const in_port_t); + +} + diff --git a/libtest/framework.cc b/libtest/framework.cc index 96918664..3a4d85d5 100644 --- a/libtest/framework.cc +++ b/libtest/framework.cc @@ -33,8 +33,6 @@ static test_return_t _default_callback(void *p) return TEST_SUCCESS; } -static Runner defualt_runners; - Framework::Framework() : collections(NULL), _create(NULL), @@ -56,6 +54,8 @@ Framework::~Framework() } _servers.shutdown(); + + delete _runner; } test_return_t Framework::Item::pre(void *arg) @@ -122,7 +122,7 @@ libtest::Runner *Framework::runner() { if (_runner == NULL) { - _runner= &defualt_runners; + _runner= new Runner; } _runner->set_servers(_servers); diff --git a/libtest/gearmand.cc b/libtest/gearmand.cc index 325582f6..7a33b4df 100644 --- a/libtest/gearmand.cc +++ b/libtest/gearmand.cc @@ -122,7 +122,7 @@ public: bool has_syslog() const { - return true; + return false; // --syslog.errmsg-enable } bool has_port_option() const diff --git a/libtest/include.am b/libtest/include.am index 59706ad8..58c7eb49 100644 --- a/libtest/include.am +++ b/libtest/include.am @@ -49,6 +49,7 @@ drd: EXTRA_DIST+= libtest/run.gdb CLEANFILES+= \ + tmp_chroot/var/drizzle/* \ tmp_chroot/var/log/* \ tmp_chroot/var/run/* \ tmp_chroot/var/tmp/* @@ -73,6 +74,7 @@ noinst_HEADERS+= \ libtest/fatal.hpp \ libtest/framework.h \ libtest/gearmand.h \ + libtest/drizzled.h \ libtest/get.h \ libtest/has.hpp \ libtest/http.hpp \ @@ -99,34 +101,36 @@ noinst_HEADERS+= \ libtest/wait.h noinst_LTLIBRARIES+= libtest/libtest.la -libtest_libtest_la_SOURCES= \ - libtest/binaries.cc \ - libtest/cmdline.cc \ - libtest/comparison.cc \ - libtest/core.cc \ - libtest/cpu.cc \ - libtest/dream.cc \ - libtest/fatal.cc \ - libtest/framework.cc \ - libtest/has.cc \ - libtest/http.cc \ - libtest/is_local.cc \ - libtest/killpid.cc \ - libtest/libtool.cc \ - libtest/port.cc \ - libtest/runner.cc \ - libtest/server.cc \ - libtest/server_container.cc \ - libtest/signal.cc \ - libtest/socket.cc \ - libtest/strerror.cc \ - libtest/test.cc \ - libtest/tmpfile.cc \ - libtest/vchar.cc libtest_libtest_la_CXXFLAGS= libtest_libtest_la_DEPENDENCIES= libtest_libtest_la_LIBADD= +libtest_libtest_la_SOURCES= + +libtest_libtest_la_SOURCES+= libtest/binaries.cc +libtest_libtest_la_SOURCES+= libtest/cmdline.cc +libtest_libtest_la_SOURCES+= libtest/comparison.cc +libtest_libtest_la_SOURCES+= libtest/core.cc +libtest_libtest_la_SOURCES+= libtest/cpu.cc +libtest_libtest_la_SOURCES+= libtest/dream.cc +libtest_libtest_la_SOURCES+= libtest/fatal.cc +libtest_libtest_la_SOURCES+= libtest/framework.cc +libtest_libtest_la_SOURCES+= libtest/has.cc +libtest_libtest_la_SOURCES+= libtest/drizzled.cc +libtest_libtest_la_SOURCES+= libtest/http.cc +libtest_libtest_la_SOURCES+= libtest/is_local.cc +libtest_libtest_la_SOURCES+= libtest/killpid.cc +libtest_libtest_la_SOURCES+= libtest/libtool.cc +libtest_libtest_la_SOURCES+= libtest/main.cc +libtest_libtest_la_SOURCES+= libtest/port.cc +libtest_libtest_la_SOURCES+= libtest/runner.cc +libtest_libtest_la_SOURCES+= libtest/server.cc +libtest_libtest_la_SOURCES+= libtest/server_container.cc +libtest_libtest_la_SOURCES+= libtest/signal.cc +libtest_libtest_la_SOURCES+= libtest/socket.cc +libtest_libtest_la_SOURCES+= libtest/strerror.cc +libtest_libtest_la_SOURCES+= libtest/tmpfile.cc +libtest_libtest_la_SOURCES+= libtest/vchar.cc libtest_libtest_la_CXXFLAGS+= ${NO_CONVERSION} libtest_libtest_la_CXXFLAGS+= -DBUILDING_LIBTEST @@ -170,6 +174,13 @@ libtest_unittest_CXXFLAGS+= -DHAVE_LIBMEMCACHED=0 endif endif +if HAVE_LIBDRIZZLE + +libtest_libtest_la_LIBADD+= $(libdrizzle_LIBS) +libtest_libtest_la_CXXFLAGS+= $(libdrizzle_CFLAGS) + +endif + if BUILDING_GEARMAN libtest_libtest_la_DEPENDENCIES+= libgearman/libgearman.la libtest_libtest_la_LIBADD+= libgearman/libgearman.la @@ -192,7 +203,7 @@ libtest_libtest_la_SOURCES+= util/operation.cc endif endif -libtest_tmp_dir: tmp_chroot/var/log tmp_chroot/var/tmp tmp_chroot/var/run +libtest_tmp_dir: tmp_chroot/var/log tmp_chroot/var/tmp tmp_chroot/var/run tmp_chroot/var/drizzle tmp_chroot: @$(mkdir_p) tmp_chroot @@ -206,6 +217,9 @@ tmp_chroot/var/log: tmp_chroot/var tmp_chroot/var/tmp: tmp_chroot/var @$(mkdir_p) tmp_chroot/var/tmp +tmp_chroot/var/drizzle: tmp_chroot/var + @$(mkdir_p) tmp_chroot/var/drizzle + tmp_chroot/var/run: tmp_chroot/var @$(mkdir_p) tmp_chroot/var/run diff --git a/libtest/main.cc b/libtest/main.cc new file mode 100644 index 00000000..ef10028c --- /dev/null +++ b/libtest/main.cc @@ -0,0 +1,479 @@ +/* vim:expandtab:shiftwidth=2:tabstop=2:smarttab: + * + * libtest + * + * Copyright (C) 2011 Data Differential, http://datadifferential.com/ + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License as published by the Free Software Foundation; either + * version 3 of the License, or (at your option) any later version. + * + * This library is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this library; if not, write to the Free Software + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA + */ + +#include +#include + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#include + +#ifndef __INTEL_COMPILER +#pragma GCC diagnostic ignored "-Wold-style-cast" +#endif + +using namespace libtest; + +static void stats_print(Stats *stats) +{ + if (stats->collection_failed == 0 and stats->collection_success == 0) + { + return; + } + + Out << "\tTotal Collections\t\t\t\t" << stats->collection_total; + Out << "\tFailed Collections\t\t\t\t" << stats->collection_failed; + Out << "\tSkipped Collections\t\t\t\t" << stats->collection_skipped; + Out << "\tSucceeded Collections\t\t\t\t" << stats->collection_success; + Outn(); + Out << "Total\t\t\t\t" << stats->total; + Out << "\tFailed\t\t\t" << stats->failed; + Out << "\tSkipped\t\t\t" << stats->skipped; + Out << "\tSucceeded\t\t" << stats->success; +} + +static long int timedif(struct timeval a, struct timeval b) +{ + long us, s; + + us = (long)(a.tv_usec - b.tv_usec); + us /= 1000; + s = (long)(a.tv_sec - b.tv_sec); + s *= 1000; + return s + us; +} + +#include +#include + +int main(int argc, char *argv[]) +{ + bool opt_massive= false; + unsigned long int opt_repeat= 1; // Run all tests once + bool opt_quiet= false; + std::string collection_to_run; + + // Options parsing + { + enum long_option_t { + OPT_LIBYATL_VERSION, + OPT_LIBYATL_MATCH_COLLECTION, + OPT_LIBYATL_MASSIVE, + OPT_LIBYATL_QUIET, + OPT_LIBYATL_REPEAT + }; + + static struct option long_options[]= + { + { "version", no_argument, NULL, OPT_LIBYATL_VERSION }, + { "quiet", no_argument, NULL, OPT_LIBYATL_QUIET }, + { "repeat", no_argument, NULL, OPT_LIBYATL_REPEAT }, + { "collection", required_argument, NULL, OPT_LIBYATL_MATCH_COLLECTION }, + { "massive", no_argument, NULL, OPT_LIBYATL_MASSIVE }, + { 0, 0, 0, 0 } + }; + + int option_index= 0; + while (1) + { + int option_rv= getopt_long(argc, argv, "", long_options, &option_index); + if (option_rv == -1) + { + break; + } + + switch (option_rv) + { + case OPT_LIBYATL_VERSION: + break; + + case OPT_LIBYATL_QUIET: + opt_quiet= true; + break; + + case OPT_LIBYATL_REPEAT: + opt_repeat= strtoul(optarg, (char **) NULL, 10); + break; + + case OPT_LIBYATL_MATCH_COLLECTION: + collection_to_run= optarg; + break; + + case OPT_LIBYATL_MASSIVE: + opt_massive= true; + break; + + case '?': + /* getopt_long already printed an error message. */ + Error << "unknown option to getopt_long()"; + exit(EXIT_FAILURE); + + default: + break; + } + } + } + + srandom((unsigned int)time(NULL)); + + if (bool(getenv("YATL_REPEAT")) and (strtoul(getenv("YATL_REPEAT"), (char **) NULL, 10) > 1)) + { + opt_repeat= strtoul(getenv("YATL_REPEAT"), (char **) NULL, 10); + } + + if ((bool(getenv("YATL_QUIET")) and (strcmp(getenv("YATL_QUIET"), "0") == 0)) or opt_quiet) + { + opt_quiet= true; + } + else if (getenv("JENKINS_URL")) + { + if (bool(getenv("YATL_QUIET")) and (strcmp(getenv("YATL_QUIET"), "1") == 0)) + { } + else + { + opt_quiet= true; + } + } + + if (opt_quiet) + { + close(STDOUT_FILENO); + } + + char buffer[1024]; + if (getenv("LIBTEST_TMP")) + { + snprintf(buffer, sizeof(buffer), "%s", getenv("LIBTEST_TMP")); + } + else + { + snprintf(buffer, sizeof(buffer), "%s", LIBTEST_TEMP); + } + + if (chdir(buffer) == -1) + { + char getcwd_buffer[1024]; + char *dir= getcwd(getcwd_buffer, sizeof(getcwd_buffer)); + + Error << "Unable to chdir() from " << dir << " to " << buffer << " errno:" << strerror(errno); + return EXIT_FAILURE; + } + + if (libtest::libtool() == NULL) + { + Error << "Failed to locate libtool"; + return EXIT_FAILURE; + } + + int exit_code; + + try { + do { + exit_code= EXIT_SUCCESS; + Framework world; + + fatal_assert(sigignore(SIGPIPE) == 0); + + libtest::SignalThread signal; + if (signal.setup() == false) + { + Error << "Failed to setup signals"; + return EXIT_FAILURE; + } + + Stats stats; + + get_world(&world); + + test_return_t error; + void *creators_ptr= world.create(error); + + switch (error) + { + case TEST_SUCCESS: + break; + + case TEST_SKIPPED: + Out << "SKIP " << argv[0]; + return EXIT_SUCCESS; + + case TEST_FAILURE: + return EXIT_FAILURE; + } + + if (getenv("YATL_COLLECTION_TO_RUN")) + { + if (strlen(getenv("YATL_COLLECTION_TO_RUN"))) + { + collection_to_run= getenv("YATL_COLLECTION_TO_RUN"); + } + } + + if (collection_to_run.compare("none") == 0) + { + return EXIT_SUCCESS; + } + + if (collection_to_run.empty() == false) + { + Out << "Only testing " << collection_to_run; + } + + char *wildcard= NULL; + if (argc == 3) + { + wildcard= argv[2]; + } + + for (collection_st *next= world.collections; next and next->name and (not signal.is_shutdown()); next++) + { + bool failed= false; + bool skipped= false; + + if (collection_to_run.empty() == false and fnmatch(collection_to_run.c_str(), next->name, 0)) + { + continue; + } + + stats.collection_total++; + + test_return_t collection_rc= world.startup(creators_ptr); + + if (collection_rc == TEST_SUCCESS and next->pre) + { + collection_rc= world.runner()->pre(next->pre, creators_ptr); + } + + switch (collection_rc) + { + case TEST_SUCCESS: + break; + + case TEST_FAILURE: + Out << next->name << " [ failed ]"; + failed= true; + signal.set_shutdown(SHUTDOWN_GRACEFUL); + goto cleanup; + + case TEST_SKIPPED: + Out << next->name << " [ skipping ]"; + skipped= true; + goto cleanup; + + default: + fatal_message("invalid return code"); + } + + Out << "Collection: " << next->name; + + for (test_st *run= next->tests; run->name; run++) + { + struct timeval start_time, end_time; + long int load_time= 0; + + if (wildcard && fnmatch(wildcard, run->name, 0)) + { + continue; + } + + test_return_t return_code; + try { + if (test_success(return_code= world.item.startup(creators_ptr))) + { + if (test_success(return_code= world.item.flush(creators_ptr, run))) + { + // @note pre will fail is SKIPPED is returned + if (test_success(return_code= world.item.pre(creators_ptr))) + { + { // Runner Code + gettimeofday(&start_time, NULL); + assert(world.runner()); + assert(run->test_fn); + try + { + return_code= world.runner()->run(run->test_fn, creators_ptr); + } + // Special case where check for the testing of the exception + // system. + catch (libtest::fatal &e) + { + if (fatal::is_disabled()) + { + fatal::increment_disabled_counter(); + return_code= TEST_SUCCESS; + } + else + { + throw; + } + } + + gettimeofday(&end_time, NULL); + load_time= timedif(end_time, start_time); + } + } + + // @todo do something if post fails + (void)world.item.post(creators_ptr); + } + else if (return_code == TEST_SKIPPED) + { } + else if (return_code == TEST_FAILURE) + { + Error << " item.flush(failure)"; + signal.set_shutdown(SHUTDOWN_GRACEFUL); + } + } + else if (return_code == TEST_SKIPPED) + { } + else if (return_code == TEST_FAILURE) + { + Error << " item.startup(failure)"; + signal.set_shutdown(SHUTDOWN_GRACEFUL); + } + } + + catch (libtest::fatal &e) + { + Error << "Fatal exception was thrown: " << e.what(); + return_code= TEST_FAILURE; + } + catch (std::exception &e) + { + Error << "Exception was thrown: " << e.what(); + return_code= TEST_FAILURE; + } + catch (...) + { + Error << "Unknown exception occurred"; + return_code= TEST_FAILURE; + } + + stats.total++; + + switch (return_code) + { + case TEST_SUCCESS: + Out << "\tTesting " << run->name << "\t\t\t\t\t" << load_time / 1000 << "." << load_time % 1000 << "[ " << test_strerror(return_code) << " ]"; + stats.success++; + break; + + case TEST_FAILURE: + stats.failed++; + failed= true; + Out << "\tTesting " << run->name << "\t\t\t\t\t" << "[ " << test_strerror(return_code) << " ]"; + break; + + case TEST_SKIPPED: + stats.skipped++; + skipped= true; + Out << "\tTesting " << run->name << "\t\t\t\t\t" << "[ " << test_strerror(return_code) << " ]"; + break; + + default: + fatal_message("invalid return code"); + } + + if (test_failed(world.on_error(return_code, creators_ptr))) + { + Error << "Failed while running on_error()"; + signal.set_shutdown(SHUTDOWN_GRACEFUL); + break; + } + } + + (void) world.runner()->post(next->post, creators_ptr); + +cleanup: + if (failed == false and skipped == false) + { + stats.collection_success++; + } + + if (failed) + { + stats.collection_failed++; + } + + if (skipped) + { + stats.collection_skipped++; + } + + world.shutdown(creators_ptr); + Outn(); + } + + if (not signal.is_shutdown()) + { + signal.set_shutdown(SHUTDOWN_GRACEFUL); + } + + shutdown_t status= signal.get_shutdown(); + if (status == SHUTDOWN_FORCED) + { + Out << "Tests were aborted."; + exit_code= EXIT_FAILURE; + } + else if (stats.collection_failed) + { + Out << "Some test failed."; + exit_code= EXIT_FAILURE; + } + else if (stats.collection_skipped and stats.collection_failed and stats.collection_success) + { + Out << "Some tests were skipped."; + } + else if (stats.collection_success and stats.collection_failed == 0) + { + Out << "All tests completed successfully."; + } + + stats_print(&stats); + + Outn(); // Generate a blank to break up the messages if make check/test has been run + } while (exit_code == EXIT_SUCCESS and --opt_repeat); + } + catch (libtest::fatal& e) + { + std::cerr << e.what() << std::endl; + } + catch (std::exception& e) + { + std::cerr << e.what() << std::endl; + } + catch (...) + { + std::cerr << "Unknown exception halted execution." << std::endl; + } + + return exit_code; +} diff --git a/libtest/server.cc b/libtest/server.cc index 99a9eeb9..41da231c 100644 --- a/libtest/server.cc +++ b/libtest/server.cc @@ -201,6 +201,7 @@ bool Server::start() { if (_app.check()) { + _app.slurp(); continue; } @@ -254,14 +255,18 @@ bool Server::start() } throw libtest::fatal(LIBYATL_DEFAULT_PARAM, - "Failed to ping(), waited: %u server started, having pid_file. exec: %s stderr:%s", + "Failed native ping(), pid: %d is alive: %s waited: %u server started, having pid_file. exec: %s stderr:%s", + int(_app.pid()), + _app.check() ? "true" : "false", this_wait, _running.c_str(), _app.stderr_c_str()); } else { throw libtest::fatal(LIBYATL_DEFAULT_PARAM, - "Failed to ping(), waited: %u server started. exec: %s stderr:%s", + "Failed native ping(), pid: %d is alive: %s waited: %u server started. exec: %s stderr:%s", + int(_app.pid()), + _app.check() ? "true" : "false", this_wait, _running.c_str(), _app.stderr_c_str()); @@ -371,7 +376,7 @@ bool Server::args(Application& app) { // Set a log file if it was requested (and we can) - if (false and has_log_file_option()) + if (has_log_file_option()) { set_log_file(); log_file_option(app, _log_file); diff --git a/libtest/server_container.cc b/libtest/server_container.cc index b63cfbb4..4fdfd414 100644 --- a/libtest/server_container.cc +++ b/libtest/server_container.cc @@ -179,6 +179,16 @@ bool server_startup(server_startup_st& construct, const std::string& server_type } } } + else if (server_type.compare("drizzled") == 0) + { + if (DRIZZLED_BINARY) + { + if (HAVE_LIBDRIZZLE) + { + server= build_drizzled("localhost", try_port); + } + } + } else if (server_type.compare("blobslap_worker") == 0) { if (GEARMAND_BINARY) diff --git a/libtest/test.cc b/libtest/test.cc deleted file mode 100644 index ef10028c..00000000 --- a/libtest/test.cc +++ /dev/null @@ -1,479 +0,0 @@ -/* vim:expandtab:shiftwidth=2:tabstop=2:smarttab: - * - * libtest - * - * Copyright (C) 2011 Data Differential, http://datadifferential.com/ - * - * This library is free software; you can redistribute it and/or - * modify it under the terms of the GNU Lesser General Public - * License as published by the Free Software Foundation; either - * version 3 of the License, or (at your option) any later version. - * - * This library is distributed in the hope that it will be useful, - * but WITHOUT ANY WARRANTY; without even the implied warranty of - * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU - * Lesser General Public License for more details. - * - * You should have received a copy of the GNU Lesser General Public - * License along with this library; if not, write to the Free Software - * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA - */ - -#include -#include - -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include - -#include - -#ifndef __INTEL_COMPILER -#pragma GCC diagnostic ignored "-Wold-style-cast" -#endif - -using namespace libtest; - -static void stats_print(Stats *stats) -{ - if (stats->collection_failed == 0 and stats->collection_success == 0) - { - return; - } - - Out << "\tTotal Collections\t\t\t\t" << stats->collection_total; - Out << "\tFailed Collections\t\t\t\t" << stats->collection_failed; - Out << "\tSkipped Collections\t\t\t\t" << stats->collection_skipped; - Out << "\tSucceeded Collections\t\t\t\t" << stats->collection_success; - Outn(); - Out << "Total\t\t\t\t" << stats->total; - Out << "\tFailed\t\t\t" << stats->failed; - Out << "\tSkipped\t\t\t" << stats->skipped; - Out << "\tSucceeded\t\t" << stats->success; -} - -static long int timedif(struct timeval a, struct timeval b) -{ - long us, s; - - us = (long)(a.tv_usec - b.tv_usec); - us /= 1000; - s = (long)(a.tv_sec - b.tv_sec); - s *= 1000; - return s + us; -} - -#include -#include - -int main(int argc, char *argv[]) -{ - bool opt_massive= false; - unsigned long int opt_repeat= 1; // Run all tests once - bool opt_quiet= false; - std::string collection_to_run; - - // Options parsing - { - enum long_option_t { - OPT_LIBYATL_VERSION, - OPT_LIBYATL_MATCH_COLLECTION, - OPT_LIBYATL_MASSIVE, - OPT_LIBYATL_QUIET, - OPT_LIBYATL_REPEAT - }; - - static struct option long_options[]= - { - { "version", no_argument, NULL, OPT_LIBYATL_VERSION }, - { "quiet", no_argument, NULL, OPT_LIBYATL_QUIET }, - { "repeat", no_argument, NULL, OPT_LIBYATL_REPEAT }, - { "collection", required_argument, NULL, OPT_LIBYATL_MATCH_COLLECTION }, - { "massive", no_argument, NULL, OPT_LIBYATL_MASSIVE }, - { 0, 0, 0, 0 } - }; - - int option_index= 0; - while (1) - { - int option_rv= getopt_long(argc, argv, "", long_options, &option_index); - if (option_rv == -1) - { - break; - } - - switch (option_rv) - { - case OPT_LIBYATL_VERSION: - break; - - case OPT_LIBYATL_QUIET: - opt_quiet= true; - break; - - case OPT_LIBYATL_REPEAT: - opt_repeat= strtoul(optarg, (char **) NULL, 10); - break; - - case OPT_LIBYATL_MATCH_COLLECTION: - collection_to_run= optarg; - break; - - case OPT_LIBYATL_MASSIVE: - opt_massive= true; - break; - - case '?': - /* getopt_long already printed an error message. */ - Error << "unknown option to getopt_long()"; - exit(EXIT_FAILURE); - - default: - break; - } - } - } - - srandom((unsigned int)time(NULL)); - - if (bool(getenv("YATL_REPEAT")) and (strtoul(getenv("YATL_REPEAT"), (char **) NULL, 10) > 1)) - { - opt_repeat= strtoul(getenv("YATL_REPEAT"), (char **) NULL, 10); - } - - if ((bool(getenv("YATL_QUIET")) and (strcmp(getenv("YATL_QUIET"), "0") == 0)) or opt_quiet) - { - opt_quiet= true; - } - else if (getenv("JENKINS_URL")) - { - if (bool(getenv("YATL_QUIET")) and (strcmp(getenv("YATL_QUIET"), "1") == 0)) - { } - else - { - opt_quiet= true; - } - } - - if (opt_quiet) - { - close(STDOUT_FILENO); - } - - char buffer[1024]; - if (getenv("LIBTEST_TMP")) - { - snprintf(buffer, sizeof(buffer), "%s", getenv("LIBTEST_TMP")); - } - else - { - snprintf(buffer, sizeof(buffer), "%s", LIBTEST_TEMP); - } - - if (chdir(buffer) == -1) - { - char getcwd_buffer[1024]; - char *dir= getcwd(getcwd_buffer, sizeof(getcwd_buffer)); - - Error << "Unable to chdir() from " << dir << " to " << buffer << " errno:" << strerror(errno); - return EXIT_FAILURE; - } - - if (libtest::libtool() == NULL) - { - Error << "Failed to locate libtool"; - return EXIT_FAILURE; - } - - int exit_code; - - try { - do { - exit_code= EXIT_SUCCESS; - Framework world; - - fatal_assert(sigignore(SIGPIPE) == 0); - - libtest::SignalThread signal; - if (signal.setup() == false) - { - Error << "Failed to setup signals"; - return EXIT_FAILURE; - } - - Stats stats; - - get_world(&world); - - test_return_t error; - void *creators_ptr= world.create(error); - - switch (error) - { - case TEST_SUCCESS: - break; - - case TEST_SKIPPED: - Out << "SKIP " << argv[0]; - return EXIT_SUCCESS; - - case TEST_FAILURE: - return EXIT_FAILURE; - } - - if (getenv("YATL_COLLECTION_TO_RUN")) - { - if (strlen(getenv("YATL_COLLECTION_TO_RUN"))) - { - collection_to_run= getenv("YATL_COLLECTION_TO_RUN"); - } - } - - if (collection_to_run.compare("none") == 0) - { - return EXIT_SUCCESS; - } - - if (collection_to_run.empty() == false) - { - Out << "Only testing " << collection_to_run; - } - - char *wildcard= NULL; - if (argc == 3) - { - wildcard= argv[2]; - } - - for (collection_st *next= world.collections; next and next->name and (not signal.is_shutdown()); next++) - { - bool failed= false; - bool skipped= false; - - if (collection_to_run.empty() == false and fnmatch(collection_to_run.c_str(), next->name, 0)) - { - continue; - } - - stats.collection_total++; - - test_return_t collection_rc= world.startup(creators_ptr); - - if (collection_rc == TEST_SUCCESS and next->pre) - { - collection_rc= world.runner()->pre(next->pre, creators_ptr); - } - - switch (collection_rc) - { - case TEST_SUCCESS: - break; - - case TEST_FAILURE: - Out << next->name << " [ failed ]"; - failed= true; - signal.set_shutdown(SHUTDOWN_GRACEFUL); - goto cleanup; - - case TEST_SKIPPED: - Out << next->name << " [ skipping ]"; - skipped= true; - goto cleanup; - - default: - fatal_message("invalid return code"); - } - - Out << "Collection: " << next->name; - - for (test_st *run= next->tests; run->name; run++) - { - struct timeval start_time, end_time; - long int load_time= 0; - - if (wildcard && fnmatch(wildcard, run->name, 0)) - { - continue; - } - - test_return_t return_code; - try { - if (test_success(return_code= world.item.startup(creators_ptr))) - { - if (test_success(return_code= world.item.flush(creators_ptr, run))) - { - // @note pre will fail is SKIPPED is returned - if (test_success(return_code= world.item.pre(creators_ptr))) - { - { // Runner Code - gettimeofday(&start_time, NULL); - assert(world.runner()); - assert(run->test_fn); - try - { - return_code= world.runner()->run(run->test_fn, creators_ptr); - } - // Special case where check for the testing of the exception - // system. - catch (libtest::fatal &e) - { - if (fatal::is_disabled()) - { - fatal::increment_disabled_counter(); - return_code= TEST_SUCCESS; - } - else - { - throw; - } - } - - gettimeofday(&end_time, NULL); - load_time= timedif(end_time, start_time); - } - } - - // @todo do something if post fails - (void)world.item.post(creators_ptr); - } - else if (return_code == TEST_SKIPPED) - { } - else if (return_code == TEST_FAILURE) - { - Error << " item.flush(failure)"; - signal.set_shutdown(SHUTDOWN_GRACEFUL); - } - } - else if (return_code == TEST_SKIPPED) - { } - else if (return_code == TEST_FAILURE) - { - Error << " item.startup(failure)"; - signal.set_shutdown(SHUTDOWN_GRACEFUL); - } - } - - catch (libtest::fatal &e) - { - Error << "Fatal exception was thrown: " << e.what(); - return_code= TEST_FAILURE; - } - catch (std::exception &e) - { - Error << "Exception was thrown: " << e.what(); - return_code= TEST_FAILURE; - } - catch (...) - { - Error << "Unknown exception occurred"; - return_code= TEST_FAILURE; - } - - stats.total++; - - switch (return_code) - { - case TEST_SUCCESS: - Out << "\tTesting " << run->name << "\t\t\t\t\t" << load_time / 1000 << "." << load_time % 1000 << "[ " << test_strerror(return_code) << " ]"; - stats.success++; - break; - - case TEST_FAILURE: - stats.failed++; - failed= true; - Out << "\tTesting " << run->name << "\t\t\t\t\t" << "[ " << test_strerror(return_code) << " ]"; - break; - - case TEST_SKIPPED: - stats.skipped++; - skipped= true; - Out << "\tTesting " << run->name << "\t\t\t\t\t" << "[ " << test_strerror(return_code) << " ]"; - break; - - default: - fatal_message("invalid return code"); - } - - if (test_failed(world.on_error(return_code, creators_ptr))) - { - Error << "Failed while running on_error()"; - signal.set_shutdown(SHUTDOWN_GRACEFUL); - break; - } - } - - (void) world.runner()->post(next->post, creators_ptr); - -cleanup: - if (failed == false and skipped == false) - { - stats.collection_success++; - } - - if (failed) - { - stats.collection_failed++; - } - - if (skipped) - { - stats.collection_skipped++; - } - - world.shutdown(creators_ptr); - Outn(); - } - - if (not signal.is_shutdown()) - { - signal.set_shutdown(SHUTDOWN_GRACEFUL); - } - - shutdown_t status= signal.get_shutdown(); - if (status == SHUTDOWN_FORCED) - { - Out << "Tests were aborted."; - exit_code= EXIT_FAILURE; - } - else if (stats.collection_failed) - { - Out << "Some test failed."; - exit_code= EXIT_FAILURE; - } - else if (stats.collection_skipped and stats.collection_failed and stats.collection_success) - { - Out << "Some tests were skipped."; - } - else if (stats.collection_success and stats.collection_failed == 0) - { - Out << "All tests completed successfully."; - } - - stats_print(&stats); - - Outn(); // Generate a blank to break up the messages if make check/test has been run - } while (exit_code == EXIT_SUCCESS and --opt_repeat); - } - catch (libtest::fatal& e) - { - std::cerr << e.what() << std::endl; - } - catch (std::exception& e) - { - std::cerr << e.what() << std::endl; - } - catch (...) - { - std::cerr << "Unknown exception halted execution." << std::endl; - } - - return exit_code; -} diff --git a/libtest/unittest.cc b/libtest/unittest.cc index de3e6f50..f884af33 100644 --- a/libtest/unittest.cc +++ b/libtest/unittest.cc @@ -154,6 +154,12 @@ static test_return_t var_log_exists_test(void *) return TEST_SUCCESS; } +static test_return_t var_drizzle_exists_test(void *) +{ + test_compare(0, access("var/drizzle", R_OK | W_OK | X_OK)); + return TEST_SUCCESS; +} + static test_return_t var_tmp_test(void *) { FILE *file= fopen("var/tmp/junk", "w+"); @@ -180,6 +186,14 @@ static test_return_t var_log_test(void *) return TEST_SUCCESS; } +static test_return_t var_drizzle_test(void *) +{ + FILE *file= fopen("var/drizzle/junk", "w+"); + test_true(file); + fclose(file); + return TEST_SUCCESS; +} + static test_return_t var_tmp_rm_test(void *) { test_true(unlink("var/tmp/junk") == 0); @@ -198,6 +212,12 @@ static test_return_t var_log_rm_test(void *) return TEST_SUCCESS; } +static test_return_t var_drizzle_rm_test(void *) +{ + test_true(unlink("var/drizzle/junk") == 0); + return TEST_SUCCESS; +} + static test_return_t _compare_test_return_t_test(void *) { test_compare(TEST_SUCCESS, TEST_SUCCESS); @@ -225,6 +245,22 @@ static test_return_t _compare_gearman_return_t_test(void *) return TEST_SUCCESS; } +static test_return_t drizzled_cycle_test(void *object) +{ + server_startup_st *servers= (server_startup_st*)object; + test_true(servers and servers->validate()); + +#if defined(HAVE_GEARMAND_BINARY) && HAVE_GEARMAND_BINARY + test_true(has_drizzled_binary()); +#endif + + test_skip(true, has_drizzled_binary()); + + test_true(server_startup(*servers, "drizzled", get_free_port(), 0, NULL)); + + return TEST_SUCCESS; +} + static test_return_t gearmand_cycle_test(void *object) { server_startup_st *servers= (server_startup_st*)object; @@ -384,6 +420,7 @@ static test_return_t application_doesnotexist_BINARY(void *) test_skip_valgrind(); Application true_app("doesnotexist"); + true_app.will_fail(); const char *args[]= { "--fubar", 0 }; #if defined(TARGET_OS_OSX) && TARGET_OS_OSX @@ -710,6 +747,18 @@ static test_return_t check_for_gearman(void *) return TEST_SUCCESS; } +static test_return_t check_for_drizzle(void *) +{ + test_skip(true, HAVE_LIBDRIZZLE); + test_skip(true, has_drizzled_binary()); + return TEST_SUCCESS; +} + + +test_st drizzled_tests[] ={ + {"drizzled startup-shutdown", 0, drizzled_cycle_test }, + {0, 0, 0} +}; test_st gearmand_tests[] ={ #if 0 @@ -768,12 +817,15 @@ test_st directories_tests[] ={ {"var/tmp exists", 0, var_tmp_exists_test }, {"var/run exists", 0, var_run_exists_test }, {"var/log exists", 0, var_log_exists_test }, + {"var/drizzle exists", 0, var_drizzle_exists_test }, {"var/tmp", 0, var_tmp_test }, {"var/run", 0, var_run_test }, {"var/log", 0, var_log_test }, + {"var/drizzle", 0, var_drizzle_test }, {"var/tmp rm", 0, var_tmp_rm_test }, {"var/run rm", 0, var_run_rm_test }, {"var/log rm", 0, var_log_rm_test }, + {"var/drizzle rm", 0, var_drizzle_rm_test }, {0, 0, 0} }; @@ -868,6 +920,7 @@ collection_st collection[] ={ {"comparison", 0, 0, comparison_tests}, {"gearmand", check_for_gearman, 0, gearmand_tests}, {"memcached", check_for_libmemcached, 0, memcached_tests}, + {"drizzled", check_for_drizzle, 0, drizzled_tests}, {"cmdline", 0, 0, cmdline_tests}, {"application", 0, 0, application_tests}, {"http", check_for_curl, 0, http_tests}, diff --git a/tests/failure.cc b/tests/failure.cc index ccc32f39..4d81ecd4 100644 --- a/tests/failure.cc +++ b/tests/failure.cc @@ -227,7 +227,7 @@ void get_world(Framework *world) 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_runner(new LibmemcachedRunner); global_framework= world; } diff --git a/tests/libmemcached-1.0/all_tests.cc b/tests/libmemcached-1.0/all_tests.cc index 6121e628..5e2882c6 100644 --- a/tests/libmemcached-1.0/all_tests.cc +++ b/tests/libmemcached-1.0/all_tests.cc @@ -96,7 +96,7 @@ void get_world(Framework *world) 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_runner(new LibmemcachedRunner); world->set_socket(); } diff --git a/tests/libmemcached-1.0/all_tests_socket.cc b/tests/libmemcached-1.0/all_tests_socket.cc index b9342cf3..6398c1eb 100644 --- a/tests/libmemcached-1.0/all_tests_socket.cc +++ b/tests/libmemcached-1.0/all_tests_socket.cc @@ -85,5 +85,5 @@ void get_world(Framework *world) 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_runner(new LibmemcachedRunner); } diff --git a/tests/libmemcached-1.0/atomsmasher.cc b/tests/libmemcached-1.0/atomsmasher.cc index ad4483ed..23d6dd23 100644 --- a/tests/libmemcached-1.0/atomsmasher.cc +++ b/tests/libmemcached-1.0/atomsmasher.cc @@ -293,5 +293,5 @@ void get_world(Framework *world) 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_runner(new LibmemcachedRunner); } diff --git a/tests/libmemcached-1.0/plus.cpp b/tests/libmemcached-1.0/plus.cpp index 5078f1f5..5b3f7e88 100644 --- a/tests/libmemcached-1.0/plus.cpp +++ b/tests/libmemcached-1.0/plus.cpp @@ -300,5 +300,5 @@ void get_world(Framework *world) world->collection_startup= reinterpret_cast(world_container_startup); world->collection_shutdown= reinterpret_cast(world_container_shutdown); - world->set_runner(&defualt_libmemcached_runner); + world->set_runner(new LibmemcachedRunner); } diff --git a/tests/libmemcached-1.0/sasl.cc b/tests/libmemcached-1.0/sasl.cc index ee8b5e67..bbf905d9 100644 --- a/tests/libmemcached-1.0/sasl.cc +++ b/tests/libmemcached-1.0/sasl.cc @@ -115,7 +115,7 @@ void get_world(Framework *world) 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_runner(new LibmemcachedRunner); world->set_sasl("memcached", "memcached"); } diff --git a/tests/libmemcached_world.h b/tests/libmemcached_world.h index 34722053..c31b303f 100644 --- a/tests/libmemcached_world.h +++ b/tests/libmemcached_world.h @@ -209,5 +209,3 @@ static bool world_destroy(void *object) typedef test_return_t (*libmemcached_test_callback_fn)(memcached_st *); #include "tests/runner.h" - -static LibmemcachedRunner defualt_libmemcached_runner; diff --git a/tests/libmemcached_world_socket.h b/tests/libmemcached_world_socket.h index e2ff7e1d..8016dba4 100644 --- a/tests/libmemcached_world_socket.h +++ b/tests/libmemcached_world_socket.h @@ -191,5 +191,3 @@ static bool world_destroy(void *object) typedef test_return_t (*libmemcached_test_callback_fn)(memcached_st *); #include "tests/runner.h" - -static LibmemcachedRunner defualt_libmemcached_runner; diff --git a/tests/mem_udp.cc b/tests/mem_udp.cc index 713885fd..3a97d849 100644 --- a/tests/mem_udp.cc +++ b/tests/mem_udp.cc @@ -580,5 +580,5 @@ void get_world(Framework *world) 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_runner(new LibmemcachedRunner); }