1.0.5
-
-* Version is now parsed directly in the parser, which makes buffered
-operations now work with it..
-
-* memstat has been extended so that it can be used to find the version of the
-server.
+* Version is now parsed directly in the parser, which makes buffered operations now work with it..
+* memstat has been extended so that it can be used to find the version of the server.
+* Update documentation.
+* Fixes for compile issues on Debian and Ubuntu
1.0.4 Thu Jan 26 22:33:54 PST 2012
# Use and distribution licensed under the BSD license. See
# the COPYING file in this directory for full text.
-AC_INIT([libmemcached],[1.0.4],[http://libmemcached.org/])
+AC_INIT([libmemcached],[1.0.5],[http://libmemcached.org/])
AC_CONFIG_AUX_DIR(config)
*/
+#include <config.h>
#include <libtest/common.h>
namespace libtest {
*/
+#include <config.h>
#include <libtest/common.h>
#include <libtest/blobslap_worker.h>
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
*/
+#include <config.h>
#include <libtest/common.h>
using namespace libtest;
#include <cstdlib>
#include <cstring>
+#include <cerrno>
#include <fcntl.h>
#include <fstream>
#include <memory>
close(WRITE);
int ret;
- if ((ret= pipe(_fd)) < 0)
+ if (pipe(_fd) == -1)
{
- throw strerror(ret);
+ throw strerror(errno);
}
_open[0]= true;
_open[1]= true;
{
- ret= fcntl(_fd[0], F_GETFL, 0);
- if (ret == -1)
+ if ((ret= fcntl(_fd[0], F_GETFL, 0)) == -1)
{
- Error << "fcntl(F_GETFL) " << strerror(ret);
- throw strerror(ret);
+ Error << "fcntl(F_GETFL) " << strerror(errno);
+ throw strerror(errno);
}
- ret= fcntl(_fd[0], F_SETFL, ret | O_NONBLOCK);
- if (ret == -1)
+ if ((ret= fcntl(_fd[0], F_SETFL, ret | O_NONBLOCK)) == -1)
{
- Error << "fcntl(F_SETFL) " << strerror(ret);
- throw strerror(ret);
+ Error << "fcntl(F_SETFL) " << strerror(errno);
+ throw strerror(errno);
}
}
}
if (_open[type])
{
int ret;
- if ((ret= ::close(_fd[type])) < 0)
+ if (::close(_fd[type]) == -1)
{
- Error << "close(" << strerror(ret) << ")";
+ Error << "close(" << strerror(errno) << ")";
}
_open[type]= false;
+ _fd[type]= -1;
}
}
void Application::delete_argv()
{
- if (built_argv == NULL)
- {
- return;
- }
-
- for (size_t x= 0; x < _argc; x++)
+ if (built_argv)
{
- if (built_argv[x])
+ for (size_t x= 0; x < _argc; x++)
{
- ::free(built_argv[x]);
+ if (built_argv[x])
+ {
+ ::free(built_argv[x]);
+ }
}
+ delete[] built_argv;
+ built_argv= NULL;
+ _argc= 0;
}
- delete[] built_argv;
- built_argv= NULL;
- _argc= 0;
}
#pragma once
-#include <config.h>
-
#include <cassert>
#include <cerrno>
#include <cstdlib>
--- /dev/null
+/* 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
+ */
+
+#include <config.h>
+#include <libtest/common.h>
+
+namespace libtest {
+
+bool _in_valgrind(const char*, int, const char*)
+{
+ if (bool(getenv("TESTS_ENVIRONMENT")) and strstr(getenv("TESTS_ENVIRONMENT"), "valgrind"))
+ {
+ return true;
+ }
+
+ return TEST_SUCCESS;
+}
+
+} // namespace libtest
namespace libtest {
+bool _in_valgrind(const char *file, int line, const char *func);
+
template <class T_comparable, class T_hint>
bool _compare_truth_hint(const char *file, int line, const char *func, T_comparable __expected, const char *assertation_label, T_hint __hint)
{
}
template <class T1_comparable, class T2_comparable>
-bool _compare(const char *file, int line, const char *func, const T1_comparable& __expected, const T2_comparable& __actual)
+bool _compare(const char *file, int line, const char *func, const T1_comparable& __expected, const T2_comparable& __actual, bool use_io)
{
if (__expected != __actual)
{
- libtest::stream::make_cerr(file, line, func) << "Expected \"" << __expected << "\" got \"" << __actual << "\"";
+ if (use_io)
+ {
+ libtest::stream::make_cerr(file, line, func) << "Expected \"" << __expected << "\" got \"" << __actual << "\"";
+ }
+
return false;
}
}
template <class T1_comparable, class T2_comparable, class T_hint>
-bool _compare_hint(const char *file, int line, const char *func, T1_comparable __expected, T2_comparable __actual, T_hint __hint)
+bool _compare_hint(const char *file, int line, const char *func, T1_comparable __expected, T2_comparable __actual, T_hint __hint, bool io_error= true)
{
if (__expected != __actual)
{
- libtest::stream::make_cerr(file, line, func) << "Expected \"" << __expected << "\" got \"" << __actual << "\"" << " Additionally: \"" << __hint << "\"";
+ if (io_error)
+ {
+ libtest::stream::make_cerr(file, line, func) << "Expected \"" << __expected << "\" got \"" << __actual << "\"" << " Additionally: \"" << __hint << "\"";
+ }
return false;
}
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
*/
+#include <config.h>
#include <libtest/common.h>
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
*/
+#include <config.h>
#include <libtest/common.h>
#include <unistd.h>
*/
+#include <config.h>
#include <libtest/common.h>
namespace libtest {
*/
+#include <config.h>
#include <libtest/common.h>
#include <libtest/failed.h>
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
*/
+#include <config.h>
#include <libtest/common.h>
#include <cstdarg>
*/
+#include <config.h>
#include <libtest/common.h>
#include <iostream>
*/
+#include <config.h>
#include <libtest/common.h>
#include <libtest/gearmand.h>
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
*/
+#include <config.h>
+
#include <libtest/common.h>
#if defined(HAVE_CURL_CURL_H) && HAVE_CURL_CURL_H
class CURL;
#endif
+
+static void cleanup_curl(void)
+{
+#if defined(HAVE_CURL_CURL_H) && HAVE_CURL_CURL_H
+ curl_global_cleanup();
+#endif
+}
+
+static void initialize_curl_startup()
+{
+#if defined(HAVE_CURL_CURL_H) && HAVE_CURL_CURL_H
+ if (curl_global_init(CURL_GLOBAL_ALL))
+ {
+ fatal_message("curl_global_init(CURL_GLOBAL_ALL) failed");
+ }
+#endif
+
+ if (atexit(cleanup_curl))
+ {
+ fatal_message("atexit() failed");
+ }
+}
+
+static pthread_once_t start_key_once= PTHREAD_ONCE_INIT;
+void initialize_curl(void)
+{
+ int ret;
+ if (pthread_once(&start_key_once, initialize_curl_startup) != 0)
+ {
+ fatal_message(strerror(ret));
+ }
+}
+
namespace libtest {
namespace http {
}
}
+HTTP::HTTP(const std::string& url_arg) :
+ _url(url_arg),
+ _response(0)
+{
+ initialize_curl();
+}
+
bool GET::execute()
{
if (HAVE_LIBCURL)
class HTTP {
public:
- HTTP(const std::string& url_arg) :
- _url(url_arg),
- _response(0)
- { }
+ HTTP(const std::string& url_arg);
virtual bool execute()= 0;
#
LIBTOOL_COMMAND= ${abs_top_builddir}/libtool --mode=execute
-VALGRIND_COMMAND= $(LIBTOOL_COMMAND) valgrind --error-exitcode=1 --leak-check=yes --show-reachable=yes --track-fds=yes --malloc-fill=A5 --free-fill=DE
+VALGRIND_EXEC_COMMAND= $(LIBTOOL_COMMAND) valgrind --error-exitcode=1 --leak-check=yes --show-reachable=yes --track-fds=yes --malloc-fill=A5 --free-fill=DE
+VALGRIND_COMMAND= TESTS_ENVIRONMENT="valgrind" $(VALGRIND_EXEC_COMMAND)
HELGRIND_COMMAND= $(LIBTOOL_COMMAND) valgrind --tool=helgrind --read-var-info=yes --error-exitcode=1 --read-var-info=yes
DRD_COMMAND= $(LIBTOOL_COMMAND) valgrind --tool=drd
GDB_COMMAND= $(LIBTOOL_COMMAND) gdb -f -x libtest/run.gdb
export GDB_COMMAND
valgrind:
- @echo make check TESTS_ENVIRONMENT="\"$(VALGRIND_COMMAND)\""
+ @echo make check TESTS_ENVIRONMENT="\"$(VALGRIND_EXEC_COMMAND)\""
gdb:
@echo make check TESTS_ENVIRONMENT="\"$(GDB_COMMAND)\""
libtest_libtest_la_SOURCES= \
libtest/binaries.cc \
libtest/cmdline.cc \
+ libtest/comparison.cc \
libtest/core.cc \
libtest/cpu.cc \
libtest/dream.cc \
@libtest/unittest
valgrind-unittest: libtest/unittest
- @$(VALGRIND_COMMAND) libtest/unittest
+ @$(VALGRIND_COMMAND) libtest/unittest TESTS_ENVIRONMENT="valgrind"
gdb-unittest: libtest/unittest
@$(GDB_COMMAND) libtest/unittest
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
*/
+#include <config.h>
#include <libtest/common.h>
*/
+#include <config.h>
#include <libtest/common.h>
#include <cstdlib>
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
*/
+#include <config.h>
#include <libtest/common.h>
#include <string>
*/
+#include <config.h>
#include <libtest/common.h>
#include <libmemcached-1.0/memcached.h>
// Memcached is slow to start, so we need to do this
if (pid_file().empty() == false)
{
- if (error_is_ok and not wait_for_pidfile())
+ if (error_is_ok and
+ wait_for_pidfile() == false)
{
Error << "Pidfile was not found:" << pid_file();
return -1;
bool ping()
{
// Memcached is slow to start, so we need to do this
- if (not pid_file().empty())
+ if (pid_file().empty() == false)
{
if (wait_for_pidfile() == false)
{
if (has_socket())
{
- ret= libmemcached_util_ping(socket().c_str(), 0, &rc);
+ ret= libmemcached_util_ping(socket().c_str(), 0, &rc);
}
else
{
pid_t get_pid(bool error_is_ok)
{
// Memcached is slow to start, so we need to do this
- if (not pid_file().empty())
+ if (pid_file().empty() == false)
{
- if (error_is_ok and not wait_for_pidfile())
+ if (error_is_ok and wait_for_pidfile() == false)
{
Error << "Pidfile was not found:" << pid_file();
return -1;
class MemcachedSaSL : public Memcached
{
public:
- MemcachedSaSL(const std::string& host_arg, const in_port_t port_arg, const bool is_socket_arg, const std::string& username_arg, const std::string &password_arg) :
+ MemcachedSaSL(const std::string& host_arg,
+ const in_port_t port_arg,
+ const bool is_socket_arg,
+ const std::string& username_arg,
+ const std::string &password_arg) :
Memcached(host_arg, port_arg, is_socket_arg, username_arg, password_arg)
{ }
pid_t get_pid(bool error_is_ok)
{
// Memcached is slow to start, so we need to do this
- if (not pid_file().empty())
+ if (pid_file().empty() == false)
{
- if (error_is_ok and not wait_for_pidfile())
+ if (error_is_ok and
+ wait_for_pidfile() == false)
{
Error << "Pidfile was not found:" << pid_file();
return -1;
bool MemcachedLight::build(size_t argc, const char *argv[])
{
- for (int x= 0 ; x < argc ; x++)
+ for (size_t x= 0 ; x < argc ; x++)
{
add_option(argv[x]);
}
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
*/
+#include <config.h>
#include <libtest/common.h>
#include <cassert>
*/
+#include <config.h>
#include <libtest/common.h>
namespace libtest {
*/
+#include <config.h>
#include <libtest/common.h>
#include <cassert>
output << " Socket:" << arg.socket();
}
- if (not arg.running().empty())
+ if (arg.running().empty() == false)
{
output << " Exec:" << arg.running();
}
return output; // for multiple << operators
}
+#define MAGIC_MEMORY 123570
+
Server::Server(const std::string& host_arg, const in_port_t port_arg, bool is_socket_arg) :
+ _magic(MAGIC_MEMORY),
_is_socket(is_socket_arg),
_pid(-1),
_port(port_arg),
}
}
+bool Server::validate()
+{
+ return _magic == MAGIC_MEMORY;
+}
+
// If the server exists, kill it
bool Server::cycle()
{
// Try to ping, and kill the server #limit number of times
pid_t current_pid;
- while (--limit and is_pid_valid(current_pid= get_pid()))
+ while (--limit and
+ is_pid_valid(current_pid= get_pid()))
{
if (kill(current_pid))
{
if (Application::SUCCESS != (ret= app.wait()))
{
- Error << "Application::wait() " << app.print() << " " << ret;
+ Error << "Application::wait() " << _running << " " << ret;
return false;
}
{
Wait wait(pid_file(), 8);
- if (not wait.successful())
+ if (wait.successful() == false)
{
- Error << "Unable to open pidfile for: " << _running;
+ libtest::fatal(LIBYATL_DEFAULT_PARAM,
+ "Unable to open pidfile for: %s",
+ _running.c_str());
}
}
typedef std::vector< std::pair<std::string, std::string> > Options;
private:
+ uint64_t _magic;
bool _is_socket;
std::string _socket;
std::string _sasl;
bool start();
bool command(libtest::Application& app);
+ bool validate();
+
protected:
bool set_pid_file();
Options _options;
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
*/
+#include <config.h>
#include <libtest/common.h>
#include <cassert>
}
}
+#define MAGIC_MEMORY 123575
+server_startup_st::server_startup_st() :
+ _magic(MAGIC_MEMORY),
+ _socket(false),
+ _sasl(false),
+ _count(5),
+ udp(0)
+{ }
+
server_startup_st::~server_startup_st()
{
shutdown_and_remove();
}
+bool server_startup_st::validate()
+{
+ return _magic == MAGIC_MEMORY;
+}
+
+
bool server_startup_st::is_debug() const
{
return bool(getenv("LIBTEST_MANUAL_GDB"));
}
else if (server->start() == false)
{
- Error << "Failed to start " << *server;
delete server;
return false;
}
/*
We will now cycle the server we have created.
*/
- if (not server->cycle())
+ if (server->cycle() == false)
{
Error << "Could not start up server " << *server;
delete server;
class server_startup_st
{
private:
+ uint64_t _magic;
std::string server_list;
bool _socket;
bool _sasl;
uint8_t udp;
std::vector<Server *> servers;
- server_startup_st() :
- _socket(false),
- _sasl(false),
- _count(5),
- udp(0)
- { }
+ server_startup_st();
+ ~server_startup_st();
+
+ bool validate();
bool start_socket_server(const std::string& server_type, const in_port_t try_port, int argc, const char *argv[]);
void push_server(Server *);
Server *pop_server();
-
- ~server_startup_st();
};
bool server_startup(server_startup_st&, const std::string&, in_port_t try_port, int argc, const char *argv[]);
*/
+#include <config.h>
#include <libtest/common.h>
#include <csignal>
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
*/
+#include <config.h>
#include <libtest/common.h>
static char global_socket[1024]= { 0 };
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
*/
+#include <config.h>
#include <libtest/common.h>
namespace libtest {
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
*/
+#include <config.h>
#include <libtest/common.h>
#include <cassert>
#include <signal.h>
-#if defined(HAVE_CURL_CURL_H) && HAVE_CURL_CURL_H
-#include <curl/curl.h>
-#endif
-
#ifndef __INTEL_COMPILER
#pragma GCC diagnostic ignored "-Wold-style-cast"
#endif
return s + us;
}
-static void cleanup_curl(void)
-{
-#if defined(HAVE_CURL_CURL_H) && HAVE_CURL_CURL_H
- curl_global_cleanup();
-#endif
-}
-
#include <getopt.h>
#include <unistd.h>
int main(int argc, char *argv[])
{
-#if defined(HAVE_CURL_CURL_H) && HAVE_CURL_CURL_H
- if (curl_global_init(CURL_GLOBAL_ALL))
- {
- Error << "curl_global_init(CURL_GLOBAL_ALL) failed";
- return EXIT_FAILURE;
- }
-#endif
-
- if (atexit(cleanup_curl))
- {
- Error << "atexit() failed";
- return EXIT_FAILURE;
- }
-
bool opt_repeat= false;
std::string collection_to_run;
try {
do {
exit_code= EXIT_SUCCESS;
- Framework *world= new Framework();
+ Framework world;
- if (world == NULL)
- {
- Error << "Failed to create Framework()";
- return EXIT_FAILURE;
- }
-
- assert(sigignore(SIGPIPE) == 0);
+ fatal_assert(sigignore(SIGPIPE) == 0);
libtest::SignalThread signal;
if (not signal.setup())
Stats stats;
- get_world(world);
+ get_world(&world);
test_return_t error;
- void *creators_ptr= world->create(error);
+ void *creators_ptr= world.create(error);
switch (error)
{
case TEST_SKIPPED:
Out << "SKIP " << argv[0];
- delete world;
return EXIT_SUCCESS;
case TEST_FAILURE:
- delete world;
return EXIT_FAILURE;
}
wildcard= argv[2];
}
- for (collection_st *next= world->collections; next and next->name and (not signal.is_shutdown()); next++)
+ for (collection_st *next= world.collections; next and next->name and (not signal.is_shutdown()); next++)
{
bool failed= false;
bool skipped= false;
stats.collection_total++;
- test_return_t collection_rc= world->startup(creators_ptr);
+ 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);
+ collection_rc= world.runner()->pre(next->pre, creators_ptr);
}
switch (collection_rc)
test_return_t return_code;
try {
- if (test_success(return_code= world->item.startup(creators_ptr)))
+ if (test_success(return_code= world.item.startup(creators_ptr)))
{
- if (test_success(return_code= world->item.flush(creators_ptr, run)))
+ 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)))
+ if (test_success(return_code= world.item.pre(creators_ptr)))
{
{ // Runner Code
gettimeofday(&start_time, NULL);
- assert(world->runner());
+ assert(world.runner());
assert(run->test_fn);
try
{
- return_code= world->runner()->run(run->test_fn, creators_ptr);
+ return_code= world.runner()->run(run->test_fn, creators_ptr);
}
// Special case where check for the testing of the exception
// system.
}
// @todo do something if post fails
- (void)world->item.post(creators_ptr);
+ (void)world.item.post(creators_ptr);
}
else if (return_code == TEST_SKIPPED)
{ }
throw fatal_message("invalid return code");
}
- if (test_failed(world->on_error(return_code, creators_ptr)))
+ if (test_failed(world.on_error(return_code, creators_ptr)))
{
Error << "Failed while running on_error()";
signal.set_shutdown(SHUTDOWN_GRACEFUL);
}
}
- (void) world->runner()->post(next->post, creators_ptr);
+ (void) world.runner()->post(next->post, creators_ptr);
cleanup:
if (failed == false and skipped == false)
stats.collection_skipped++;
}
- world->shutdown(creators_ptr);
+ world.shutdown(creators_ptr);
Outn();
}
stats_print(&stats);
- delete world;
-
Outn(); // Generate a blank to break up the messages if make check/test has been run
} while (exit_code == EXIT_SUCCESS and opt_repeat);
}
{
std::cerr << e.what() << std::endl;
}
- catch (std::bad_alloc& e)
+ catch (std::exception& e)
{
std::cerr << e.what() << std::endl;
}
catch (...)
{
- std::cerr << "Unknown exception halted execution" << std::endl;
+ std::cerr << "Unknown exception halted execution." << std::endl;
}
return exit_code;
} while (0)
#define test_true_hint test_true_got
-#define test_skip(A,B) \
+#define test_skip(__expected, __actual) \
do \
{ \
- if ((A) != (B)) \
+ if (libtest::_compare(__FILE__, __LINE__, __func__, ((__expected)), ((__actual)), false) == false) \
+ { \
+ return TEST_SKIPPED; \
+ } \
+} while (0)
+
+#define test_skip_valgrind() \
+do \
+{ \
+ if (libtest::_in_valgrind(__FILE__, __LINE__, __func__)) \
{ \
return TEST_SKIPPED; \
} \
#define test_compare(__expected, __actual) \
do \
{ \
- if (not libtest::_compare(__FILE__, __LINE__, __func__, ((__expected)), ((__actual)))) \
+ if (libtest::_compare(__FILE__, __LINE__, __func__, ((__expected)), ((__actual)), true) == false) \
{ \
libtest::create_core(); \
return TEST_FAILURE; \
#define test_compare_warn(__expected, __actual) \
do \
{ \
- void(libtest::_compare(__FILE__, __LINE__, __func__, (__expected), (__actual))); \
+ void(libtest::_compare(__FILE__, __LINE__, __func__, (__expected), (__actual)), true); \
} while (0)
#define test_compare_warn_hint(__expected, __actual, __hint) \
static test_return_t test_success_equals_one_test(void *)
{
- test_skip(HAVE_LIBMEMCACHED, true);
+ test_skip(HAVE_LIBMEMCACHED, 1);
#if defined(HAVE_LIBMEMCACHED) && HAVE_LIBMEMCACHED
test_zero(MEMCACHED_SUCCESS);
#endif
}
// unsetenv() will cause issues with valgrind
- _compare(__FILE__, __LINE__, __func__, 0, unsetenv("LIBTEST_LOCAL"));
+ _compare(__FILE__, __LINE__, __func__, 0, unsetenv("LIBTEST_LOCAL"), true);
test_compare(0, unsetenv("LIBTEST_LOCAL"));
test_false(test_is_local());
static test_return_t gearmand_cycle_test(void *object)
{
server_startup_st *servers= (server_startup_st*)object;
- test_true(servers);
+ test_true(servers and servers->validate());
#if defined(HAVE_GEARMAND_BINARY) && HAVE_GEARMAND_BINARY
test_true(has_gearmand_binary());
-#else
- test_skip(true, has_gearmand_binary());
#endif
+ test_skip(true, has_gearmand_binary());
+
+ Error << " " << has_gearmand_binary();
+
test_true(server_startup(*servers, "gearmand", get_free_port(), 0, NULL));
return TEST_SUCCESS;
return TEST_SUCCESS;
}
+static test_return_t skip_shim(bool a, bool b)
+{
+ test_skip(a, b);
+ return TEST_SUCCESS;
+}
+
+static test_return_t test_skip_true_TEST(void *object)
+{
+ test_compare(true, true);
+ test_compare(false, false);
+ test_compare(TEST_SUCCESS, skip_shim(true, true));
+ test_compare(TEST_SUCCESS, skip_shim(false, false));
+
+ return TEST_SUCCESS;
+}
+
+static test_return_t test_skip_false_TEST(void *object)
+{
+ test_compare(TEST_SKIPPED, skip_shim(true, false));
+ test_compare(TEST_SKIPPED, skip_shim(false, true));
+ return TEST_SUCCESS;
+}
+
static test_return_t memcached_cycle_test(void *object)
{
server_startup_st *servers= (server_startup_st*)object;
server_startup_st *servers= (server_startup_st*)object;
test_true(servers);
- if (getenv("TESTS_ENVIRONMENT"))
- {
- return TEST_SKIPPED;
- }
+ test_skip(false, bool(getenv("TESTS_ENVIRONMENT")));
if (MEMCACHED_SASL_BINARY)
{
static test_return_t application_doesnotexist_BINARY(void *)
{
+ test_skip_valgrind();
+
Application true_app("doesnotexist");
const char *args[]= { "--fubar", 0 };
#if defined(TARGET_OS_OSX) && TARGET_OS_OSX
test_compare(Application::INVALID, true_app.run(args));
+ test_compare(Application::FAILURE, true_app.wait());
#else
test_compare(Application::SUCCESS, true_app.run(args));
+ test_compare(Application::INVALID, true_app.wait());
#endif
- // Behavior is different if we are running under valgrind
- if (getenv("TESTS_ENVIRONMENT") and strstr(getenv("TESTS_ENVIRONMENT"), "valgrind"))
- {
- test_compare(Application::FAILURE, true_app.wait());
- }
- else
- {
-#if defined(TARGET_OS_OSX) && TARGET_OS_OSX
- test_compare(Application::FAILURE, true_app.wait());
-#else
- test_compare(Application::INVALID, true_app.wait());
-#endif
- }
+
test_compare(0, true_app.stdout_result().size());
return TEST_SUCCESS;
{0, 0, 0}
};
+test_st test_skip_TESTS[] ={
+ {"true, true", 0, test_skip_true_TEST },
+ {"true, false", 0, test_skip_false_TEST },
+ {0, 0, 0}
+};
+
test_st environment_tests[] ={
{"LIBTOOL_COMMAND", 0, LIBTOOL_COMMAND_test },
{"VALGRIND_COMMAND", 0, VALGRIND_COMMAND_test },
collection_st collection[] ={
{"environment", 0, 0, environment_tests},
{"return values", 0, 0, tests_log},
+ {"test_skip()", 0, 0, test_skip_TESTS },
{"local", 0, 0, local_log},
{"directories", 0, 0, directories_tests},
{"comparison", 0, 0, comparison_tests},
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
*/
+#include <config.h>
#include <libtest/common.h>
namespace libtest {
#define GLOBAL_COUNT 10000
#define GLOBAL2_COUNT 100
+using namespace libtest;
+
static pairs_st *global_pairs;
static const char *global_keys[GLOBAL_COUNT];
static size_t global_keys_length[GLOBAL_COUNT];
#include <sys/stat.h>
+using namespace libtest;
memcached_return_t return_value_based_on_buffering(memcached_st *memc)
{
projects / m6w6 / libmemcached / commitdiff
