Mergre 1.0 tree.

27 files changed, 414 insertions, 260 deletions

diff --git a/libtest/cmdline.cc b/libtest/cmdline.cc
index fd9e510d..94c41814 100644
--- a/libtest/cmdline.cc
+++ b/libtest/cmdline.cc
@@ -59,6 +59,7 @@ using namespace libtest;
 #include <unistd.h>
 
 #include <algorithm>
+#include <stdexcept>
 
 #ifndef __USE_GNU
 static char **environ= NULL;
@@ -408,7 +409,7 @@ bool Application::slurp()
 
 Application::error_t Application::join()
 {
-  pid_t waited_pid= waitpid(_pid, &_status, 0);
+  pid_t waited_pid= waitpid(_pid, &_status, WUNTRACED);
   slurp();
   if (waited_pid == _pid and WIFEXITED(_status) == false)
   {
diff --git a/libtest/collection.cc b/libtest/collection.cc
index 86e7f864..2f1cba31 100644
--- a/libtest/collection.cc
+++ b/libtest/collection.cc
@@ -51,6 +51,9 @@ static test_return_t runner_code(libtest::Framework* frame,
   try 
   {
     _timer.reset();
+    assert(frame);
+    assert(frame->runner());
+    assert(run->test_fn);
     return_code= frame->runner()->main(run->test_fn, frame->creators_ptr());
   }
   // Special case where check for the testing of the exception
diff --git a/libtest/dns.cc b/libtest/dns.cc
index 0becfc99..75a5bbfb 100644
--- a/libtest/dns.cc
+++ b/libtest/dns.cc
@@ -46,10 +46,14 @@ namespace libtest {
 bool lookup(const char* host)
 {
   bool success= false;
-  if (host)
+  assert(host and host[0]);
+  if (host and host[0])
   {
-    assert(host);
     struct addrinfo *addrinfo= NULL;
+    struct addrinfo hints;
+    memset(&hints, 0, sizeof(hints));
+    hints.ai_socktype= SOCK_STREAM;
+    hints.ai_protocol= IPPROTO_TCP;
 
     int limit= 5;
     while (--limit and success == false)
@@ -61,7 +65,7 @@ bool lookup(const char* host)
       }
 
       int ret;
-      if ((ret= getaddrinfo(host, NULL, NULL, &addrinfo)) == 0)
+      if ((ret= getaddrinfo(host, "echo", &hints, &addrinfo)) == 0)
       {
         success= true;
         break;
@@ -92,6 +96,11 @@ bool lookup(const char* host)
 
 bool check_dns()
 {
+  if (valgrind_is_caller())
+  {
+    return false;
+  }
+
   if (lookup("exist.gearman.info") == false)
   {
     return false;
diff --git a/libtest/exception.cc b/libtest/exception.cc
new file mode 100644
index 00000000..0b18f777
--- /dev/null
+++ b/libtest/exception.cc
@@ -0,0 +1,108 @@
+/*  vim:expandtab:shiftwidth=2:tabstop=2:smarttab:
+ *
+ *  Data Differential YATL (i.e. libtest)  library
+ *
+ *  Copyright (C) 2012-2013 Data Differential, http://datadifferential.com/
+ *
+ *  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.
+ *
+ */
+
+#include "libtest/yatlcon.h"
+#include <libtest/common.h>
+#include <cstdarg>
+
+namespace libtest {
+
+exception::exception(const char *file_arg, int line_arg, const char *func_arg):
+  std::exception(),
+  _line(line_arg),
+  _file(file_arg),
+  _func(func_arg),
+  _error_message(NULL),
+  _error_message_size(0)
+{
+}
+
+#ifndef __INTEL_COMPILER
+# pragma GCC diagnostic ignored "-Wformat-nonliteral"
+#endif
+void exception::init(va_list args_)
+{
+  const char *format= va_arg(args_, const char *);
+  int error_message_length= vasprintf(&_error_message, format, args_);
+  assert(error_message_length != -1);
+  if (error_message_length > 0)
+  {
+    _error_message_size= error_message_length +1;
+  }
+}
+
+exception::~exception() throw()
+{
+  if (_error_message)
+  {
+    free(_error_message);
+  }
+}
+
+void exception::what(size_t length_, const char* message_)
+{
+  if (length_ > 0 and message_)
+  {
+    char *ptr= (char*) realloc(_error_message, length_ +1);
+    if (ptr)
+    {
+      _error_message= ptr;
+      memcpy(_error_message, message_, length_);
+      _error_message[length_]= 0;
+    }
+  }
+}
+
+exception::exception(const exception& other) :
+  std::exception(),
+  _line(other._line),
+  _file(other._file),
+  _func(other._func),
+  _error_message_size(0)
+{
+  if (other.length() > 0)
+  {
+    _error_message= (char*) malloc(other.length() +1);
+    if (_error_message)
+    {
+      memcpy(_error_message, other._error_message, other.length());
+      _error_message_size= other.length();
+    }
+  }
+}
+
+} // namespace libtest
+
diff --git a/libtest/failed.h b/libtest/exception.hpp
index bc459660..3d20e8ba 100644
--- a/libtest/failed.h
+++ b/libtest/exception.hpp
@@ -2,7 +2,7 @@
  *
  *  Data Differential YATL (i.e. libtest)  library
  *
- *  Copyright (C) 2012 Data Differential, http://datadifferential.com/
+ *  Copyright (C) 2012-2013 Data Differential, http://datadifferential.com/
  *
  *  Redistribution and use in source and binary forms, with or without
  *  modification, are permitted provided that the following conditions are
@@ -36,16 +36,59 @@
 
 #pragma once
 
-#ifdef __cplusplus
-extern "C" {
-#endif
+namespace libtest {
 
-LIBTEST_INTERNAL_API
-  void push_failed_test(const char *collection, const char *test);
+class exception : public std::exception
+{
+public:
+  exception(const char *file, int line, const char *func);
 
-LIBTEST_INTERNAL_API
-  void print_failed_test(void);
+  exception( const exception& );
+
+  virtual ~exception() throw();
+
+  virtual const char* what() const throw()
+  {
+    if (_error_message)
+    {
+      return _error_message;
+    }
+
+    return "";
+  }
+
+  void what(size_t, const char*);
+
+  size_t length() const
+  {
+    return _error_message_size;
+  }
+
+  int line() const
+  {
+    return _line;
+  }
+
+  const char* file() const
+  {
+    return _file;
+  }
+
+  const char* func() const
+  {
+    return _func;
+  }
+
+protected:
+  void init(va_list);
+
+private:
+  int _line;
+  const char*  _file;
+  const char* _func;
+  char* _error_message;
+  size_t _error_message_size;
+};
+
+} // namespace libtest
 
-#ifdef __cplusplus
-}
-#endif
diff --git a/libtest/fatal.hpp b/libtest/exception/disconnected.hpp
index c679f9b0..fb3a2adb 100644
--- a/libtest/fatal.hpp
+++ b/libtest/exception/disconnected.hpp
@@ -2,7 +2,7 @@
  *
  *  Data Differential YATL (i.e. libtest)  library
  *
- *  Copyright (C) 2012 Data Differential, http://datadifferential.com/
+ *  Copyright (C) 2012-2013 Data Differential, http://datadifferential.com/
  *
  *  Redistribution and use in source and binary forms, with or without
  *  modification, are permitted provided that the following conditions are
@@ -36,20 +36,15 @@
 
 #pragma once
 
-#include <stdexcept>
+#include "libtest/exception.hpp"
 
 namespace libtest {
 
-class disconnected : public std::runtime_error
+class disconnected : public libtest::exception
 {
 public:
   disconnected(const char *file, int line, const char *func, const std::string&, const in_port_t port, ...);
 
-  const char* what() const throw()
-  {
-    return _error_message;
-  }
-
   disconnected(const disconnected&);
 
   // The following are just for unittesting the exception class
@@ -59,28 +54,9 @@ public:
   static uint32_t disabled_counter();
   static void increment_disabled_counter();
 
-  int line() const
-  {
-    return _line;
-  }
-
-  const char* file() const
-  {
-    return _file;
-  }
-
-  const char* func() const
-  {
-    return _func;
-  }
-
 private:
-  char _error_message[BUFSIZ];
   in_port_t _port;
   char _instance[BUFSIZ];
-  int _line;
-  const char*  _file;
-  const char* _func;
 };
 
 } // namespace libtest
diff --git a/libtest/fatal.cc b/libtest/exception/fatal.cc
index 0ed06c2c..21a8ca79 100644
--- a/libtest/fatal.cc
+++ b/libtest/exception/fatal.cc
@@ -36,6 +36,7 @@
 
 #include "libtest/yatlcon.h"
 #include <libtest/common.h>
+#include "libtest/exception.hpp"
 #include <cstdarg>
 
 namespace libtest {
@@ -43,7 +44,7 @@ namespace libtest {
 #pragma GCC diagnostic ignored "-Wformat-nonliteral"
 
 fatal::fatal(const char *file_arg, int line_arg, const char *func_arg, ...) :
-  __test_result(file_arg, line_arg, func_arg)
+  libtest::exception(file_arg, line_arg, func_arg)
 {
   va_list args;
   va_start(args, func_arg);
@@ -52,7 +53,7 @@ fatal::fatal(const char *file_arg, int line_arg, const char *func_arg, ...) :
 }
 
 fatal::fatal( const fatal& other ) :
-  __test_result(other)
+  libtest::exception(other)
 {
 }
 
@@ -89,11 +90,8 @@ void fatal::increment_disabled_counter() throw()
 #pragma GCC diagnostic ignored "-Wformat-nonliteral"
 disconnected::disconnected(const char *file_arg, int line_arg, const char *func_arg,
                            const std::string& instance, const in_port_t port, ...) :
-  std::runtime_error(func_arg),
-  _port(port),
-  _line(line_arg),
-  _file(file_arg),
-  _func(func_arg)
+  libtest::exception(file_arg, line_arg, func_arg),
+  _port(port)
 {
   va_list args;
   va_start(args, port);
@@ -102,17 +100,19 @@ disconnected::disconnected(const char *file_arg, int line_arg, const char *func_
   (void)vsnprintf(last_error, sizeof(last_error), format, args);
   va_end(args);
 
-  snprintf(_error_message, sizeof(_error_message), "%s:%u %s", instance.c_str(), uint32_t(port), last_error);
+  char buffer_error[BUFSIZ];
+  int error_length= snprintf(buffer_error, sizeof(buffer_error), "%s:%u %s", instance.c_str(), uint32_t(port), last_error);
+
+  if (error_length > 0)
+  {
+    what(size_t(error_length), buffer_error);
+  }
 }
 
 disconnected::disconnected(const disconnected& other):
-  std::runtime_error(other._func),
-  _port(other._port),
-  _line(other._line),
-  _file(other._file),
-  _func(other._func)
+  libtest::exception(other),
+  _port(other._port)
 {
-  strncpy(_error_message, other._error_message, BUFSIZ);
   strncpy(_instance, other._instance, BUFSIZ);
 }
 
diff --git a/libtest/result/fatal.hpp b/libtest/exception/fatal.hpp
index 8e6d1346..5ee1aac5 100644
--- a/libtest/result/fatal.hpp
+++ b/libtest/exception/fatal.hpp
@@ -38,7 +38,7 @@
 
 namespace libtest {
 
-class fatal : public __test_result
+class fatal : public libtest::exception
 {
 public:
   fatal(const char *file, int line, const char *func, ...);
@@ -52,7 +52,36 @@ public:
   static uint32_t disabled_counter() throw();
   static void increment_disabled_counter() throw();
 
+  test_return_t return_code() const
+  {
+    return TEST_SKIPPED;
+  }
+
 private:
 };
 
 } // namespace libtest
+
+#define FATAL(...) \
+do \
+{ \
+  throw libtest::fatal(LIBYATL_DEFAULT_PARAM, __VA_ARGS__); \
+} while (0)
+
+#define FATAL_IF(__expression, ...) \
+do \
+{ \
+  if ((__expression)) { \
+    throw libtest::fatal(LIBYATL_DEFAULT_PARAM, (#__expression)); \
+  } \
+} while (0)
+
+#define FATAL_IF_(__expression, ...) \
+do \
+{ \
+  if ((__expression)) { \
+    throw libtest::fatal(LIBYATL_DEFAULT_PARAM, __VA_ARGS__); \
+  } \
+} while (0)
+
+#define fatal_assert(__assert) if((__assert)) {} else { throw libtest::fatal(LIBYATL_DEFAULT_PARAM, #__assert); }
diff --git a/libtest/framework.cc b/libtest/framework.cc
index 92aacfee..2c9ba74b 100644
--- a/libtest/framework.cc
+++ b/libtest/framework.cc
@@ -107,47 +107,50 @@ void Framework::exec()
        iter != _collection.end() and (_signal.is_shutdown() == false);
        ++iter)
   {
-    if (_only_run.empty() == false and
-        fnmatch(_only_run.c_str(), (*iter)->name(), 0))
+    if (*iter)
     {
-      continue;
-    }
-
-    _total++;
+      if (_only_run.empty() == false and
+          fnmatch(_only_run.c_str(), (*iter)->name(), 0))
+      {
+        continue;
+      }
 
-    try {
-      switch ((*iter)->exec())
+      _total++;
+
+      try {
+        switch ((*iter)->exec())
+        {
+          case TEST_FAILURE:
+            _failed++;
+            break;
+
+          case TEST_SKIPPED:
+            _skipped++;
+            break;
+
+            // exec() can return SUCCESS, but that doesn't mean that some tests did
+            // not fail or get skipped.
+          case TEST_SUCCESS:
+            _success++;
+            break;
+        }
+      }
+      catch (const libtest::fatal& e)
       {
-      case TEST_FAILURE:
         _failed++;
-        break;
-
-      case TEST_SKIPPED:
-        _skipped++;
-        break;
-
-        // exec() can return SUCCESS, but that doesn't mean that some tests did
-        // not fail or get skipped.
-      case TEST_SUCCESS:
-        _success++;
-        break;
+        stream::cerr(e.file(), e.line(), e.func()) << e.what();
+      }
+      catch (const libtest::disconnected& e)
+      {
+        _failed++;
+        Error << "Unhandled disconnection occurred:" << e.what();
+        throw;
+      }
+      catch (...)
+      {
+        _failed++;
+        throw;
       }
-    }
-    catch (const libtest::fatal& e)
-    {
-      _failed++;
-      stream::cerr(e.file(), e.line(), e.func()) << e.what();
-    }
-    catch (const libtest::disconnected& e)
-    {
-      _failed++;
-      Error << "Unhandled disconnection occurred:" << e.what();
-      throw;
-    }
-    catch (...)
-    {
-      _failed++;
-      throw;
     }
   }
 
diff --git a/libtest/has.cc b/libtest/has.cc
index a7a09cb4..2d9abf6b 100644
--- a/libtest/has.cc
+++ b/libtest/has.cc
@@ -43,6 +43,11 @@
 
 namespace libtest {
 
+bool has_libmemcached_sasl(void)
+{
+  return false;
+}
+
 bool has_libmemcached(void)
 {
 #if defined(HAVE_LIBMEMCACHED) && HAVE_LIBMEMCACHED
@@ -85,7 +90,7 @@ bool has_postgres_support(void)
 
 bool has_gearmand()
 {
-#if defined(HAVE_GEARMAND_BINARY) && HAVE_GEARMAND_BINARY
+#if defined(GEARMAND_BINARY) && defined(HAVE_GEARMAND_BINARY) && HAVE_GEARMAND_BINARY
   if (HAVE_GEARMAND_BINARY)
   {
     std::stringstream arg_buffer;
@@ -111,7 +116,7 @@ bool has_gearmand()
 
 bool has_drizzled()
 {
-#if defined(HAVE_DRIZZLED_BINARY) && HAVE_DRIZZLED_BINARY
+#if defined(DRIZZLED_BINARY) && defined(HAVE_DRIZZLED_BINARY) && HAVE_DRIZZLED_BINARY
   if (HAVE_DRIZZLED_BINARY)
   {
     if (access(DRIZZLED_BINARY, X_OK) == 0)
@@ -126,7 +131,7 @@ bool has_drizzled()
 
 bool has_mysqld()
 {
-#if defined(HAVE_MYSQLD_BUILD) && HAVE_MYSQLD_BUILD
+#if defined(MYSQLD_BINARY) && defined(HAVE_MYSQLD_BUILD) && HAVE_MYSQLD_BUILD
   if (HAVE_MYSQLD_BUILD)
   {
     if (access(MYSQLD_BINARY, X_OK) == 0)
@@ -141,11 +146,11 @@ bool has_mysqld()
 
 static char memcached_binary_path[FILENAME_MAX];
 
-static void initialize_curl_startup()
+static void initialize_memcached_binary_path()
 {
-  memcached_binary_path[0]= NULL;
+  memcached_binary_path[0]= 0;
 
-#if defined(HAVE_MEMCACHED_BINARY) && HAVE_MEMCACHED_BINARY
+#if defined(MEMCACHED_BINARY) && defined(HAVE_MEMCACHED_BINARY) && HAVE_MEMCACHED_BINARY
   if (HAVE_MEMCACHED_BINARY)
   {
     std::stringstream arg_buffer;
@@ -170,7 +175,7 @@ static pthread_once_t memcached_binary_once= PTHREAD_ONCE_INIT;
 static void initialize_memcached_binary(void)
 {
   int ret;
-  if ((ret= pthread_once(&memcached_binary_once, initialize_curl_startup)) != 0)
+  if ((ret= pthread_once(&memcached_binary_once, initialize_memcached_binary_path)) != 0)
   {
     FATAL(strerror(ret));
   }
@@ -180,7 +185,7 @@ bool has_memcached()
 {
   initialize_memcached_binary();
 
-  if (memcached_binary_path[0])
+  if (memcached_binary_path[0] and (strlen(memcached_binary_path) > 0))
   {
     return true;
   }
@@ -200,29 +205,22 @@ const char* memcached_binary()
   return NULL;
 }
 
-bool has_memcached_sasl()
-{
-#if defined(HAVE_MEMCACHED_SASL_BINARY) && HAVE_MEMCACHED_SASL_BINARY
-  if (HAVE_MEMCACHED_SASL_BINARY)
-  {
-    if (access(MEMCACHED_SASL_BINARY, X_OK) == 0)
-    {
-      return true;
-    }
-  }
-#endif
-
-  return false;
-}
-
 const char *gearmand_binary() 
 {
+#if defined(GEARMAND_BINARY)
   return GEARMAND_BINARY;
+#else
+  return NULL;
+#endif
 }
 
 const char *drizzled_binary() 
 {
+#if defined(DRIZZLED_BINARY)
   return DRIZZLED_BINARY;
+#else
+  return NULL;
+#endif
 }
 
 } // namespace libtest
diff --git a/libtest/has.hpp b/libtest/has.hpp
index f38306d5..59ee88f9 100644
--- a/libtest/has.hpp
+++ b/libtest/has.hpp
@@ -39,6 +39,9 @@
 namespace libtest {
 
 LIBTEST_API
+bool has_libmemcached_sasl(void);
+
+LIBTEST_API
 bool has_libmemcached();
 
 LIBTEST_API
diff --git a/libtest/http.cc b/libtest/http.cc
index 621c714c..29873dc6 100644
--- a/libtest/http.cc
+++ b/libtest/http.cc
@@ -97,14 +97,14 @@ static void init(CURL *curl, const std::string& url)
   (void)http_get_result_callback;
   (void)curl;
   (void)url;
+#if defined(HAVE_LIBCURL) && HAVE_LIBCURL
   if (HAVE_LIBCURL)
   {
-#if defined(HAVE_LIBCURL) && HAVE_LIBCURL
     assert(curl);
     curl_easy_setopt(curl, CURLOPT_URL, url.c_str());
     curl_easy_setopt(curl, CURLOPT_USERAGENT, YATL_USERAGENT);
-#endif
   }
+#endif
 }
 
 HTTP::HTTP(const std::string& url_arg) :
@@ -118,9 +118,9 @@ bool GET::execute()
 {
   (void)init;
 
+#if defined(HAVE_LIBCURL) && HAVE_LIBCURL
   if (HAVE_LIBCURL)
   {
-#if defined(HAVE_LIBCURL) && HAVE_LIBCURL
     CURL *curl= curl_easy_init();
 
     init(curl, url());
@@ -134,17 +134,17 @@ bool GET::execute()
     curl_easy_cleanup(curl);
 
     return bool(retref == CURLE_OK);
-#endif
   }
+#endif
 
   return false;
 }
 
 bool POST::execute()
 {
+#if defined(HAVE_LIBCURL) && HAVE_LIBCURL
   if (HAVE_LIBCURL)
   {
-#if defined(HAVE_LIBCURL) && HAVE_LIBCURL
     CURL *curl= curl_easy_init();;
 
     init(curl, url());
@@ -158,17 +158,17 @@ bool POST::execute()
     curl_easy_cleanup(curl);
 
     return bool(retref == CURLE_OK);
-#endif
   }
+#endif
 
   return false;
 }
 
 bool TRACE::execute()
 {
+#if defined(HAVE_LIBCURL) && HAVE_LIBCURL
   if (HAVE_LIBCURL)
   {
-#if defined(HAVE_LIBCURL) && HAVE_LIBCURL
     CURL *curl= curl_easy_init();;
 
     init(curl, url());
@@ -183,18 +183,18 @@ bool TRACE::execute()
     curl_easy_cleanup(curl);
 
     return retref == CURLE_OK;
-#endif
   }
+#endif
 
   return false;
 }
 
 bool HEAD::execute()
 {
+#if defined(HAVE_LIBCURL) && HAVE_LIBCURL
   if (HAVE_LIBCURL)
   {
-#if defined(HAVE_LIBCURL) && HAVE_LIBCURL
-    CURL *curl= curl_easy_init();;
+    CURL *curl= curl_easy_init();
 
     init(curl, url());
 
@@ -207,8 +207,8 @@ bool HEAD::execute()
     curl_easy_cleanup(curl);
 
     return retref == CURLE_OK;
-#endif
   }
+#endif
 
   return false;
 }
diff --git a/libtest/include.am b/libtest/include.am
index c9368c4f..4d1d8428 100644
--- a/libtest/include.am
+++ b/libtest/include.am
@@ -9,7 +9,7 @@ VALGRIND_EXEC_COMMAND= $(LIBTOOL_COMMAND) valgrind --tool=memcheck --error-exitc
 SGCHECK_EXEC_COMMAND= $(LIBTOOL_COMMAND) valgrind --tool=exp-sgcheck --error-exitcode=1
 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 --error-exitcode=1
+DRD_COMMAND= $(LIBTOOL_COMMAND) valgrind --tool=drd --free-is-write=yes --error-exitcode=1
 SGCHECK_COMMAND= $(LIBTOOL_COMMAND) valgrind --tool=exp-sgcheck --error-exitcode=1
 MASSIF_COMMAND= $(LIBTOOL_COMMAND) valgrind --tool=massif
 GDB_COMMAND= $(LIBTOOL_COMMAND) gdb -f -x libtest/run.gdb
@@ -67,8 +67,9 @@ noinst_HEADERS+= libtest/comparison.hpp
 noinst_HEADERS+= libtest/core.h
 noinst_HEADERS+= libtest/dream.h
 noinst_HEADERS+= libtest/error.h
-noinst_HEADERS+= libtest/failed.h
-noinst_HEADERS+= libtest/fatal.hpp
+noinst_HEADERS+= libtest/exception.hpp
+noinst_HEADERS+= libtest/exception/disconnected.hpp
+noinst_HEADERS+= libtest/exception/fatal.hpp
 noinst_HEADERS+= libtest/framework.h
 noinst_HEADERS+= libtest/gearmand.h
 noinst_HEADERS+= libtest/drizzled.h
@@ -86,7 +87,6 @@ noinst_HEADERS+= libtest/port.h
 noinst_HEADERS+= libtest/result.hpp
 noinst_HEADERS+= libtest/result/base.hpp
 noinst_HEADERS+= libtest/result/fail.hpp
-noinst_HEADERS+= libtest/result/fatal.hpp
 noinst_HEADERS+= libtest/result/skip.hpp
 noinst_HEADERS+= libtest/result/success.hpp
 noinst_HEADERS+= libtest/runner.h
@@ -109,18 +109,12 @@ noinst_HEADERS+= libtest/visibility.h
 noinst_HEADERS+= libtest/wait.h
 noinst_HEADERS+= libtest/yatl.h
 
-noinst_LTLIBRARIES+= libtest/libtest.la
+check_LTLIBRARIES+= libtest/libtest.la
 
 libtest_libtest_la_CXXFLAGS=
 EXTRA_libtest_libtest_la_DEPENDENCIES=
 libtest_libtest_la_LIBADD=
 libtest_libtest_la_SOURCES=
-if BUILDING_LIBMEMCACHED
-libtest_libtest_la_LIBADD+= libmemcached/libmemcached.la
-else
-libtest_libtest_la_CXXFLAGS+= @LIBMEMCACHED_CFLAGS@
-libtest_libtest_la_LIBADD+= @LIBMEMCACHED_LIB@
-endif
 
 libtest_libtest_la_SOURCES+= libtest/alarm.cc
 libtest_libtest_la_SOURCES+= libtest/binaries.cc
@@ -132,7 +126,8 @@ libtest_libtest_la_SOURCES+= libtest/cpu.cc
 libtest_libtest_la_SOURCES+= libtest/dns.cc
 libtest_libtest_la_SOURCES+= libtest/dream.cc
 libtest_libtest_la_SOURCES+= libtest/drizzled.cc
-libtest_libtest_la_SOURCES+= libtest/fatal.cc
+libtest_libtest_la_SOURCES+= libtest/exception.cc
+libtest_libtest_la_SOURCES+= libtest/exception/fatal.cc
 libtest_libtest_la_SOURCES+= libtest/formatter.cc
 libtest_libtest_la_SOURCES+= libtest/client.cc
 libtest_libtest_la_SOURCES+= libtest/framework.cc
@@ -220,6 +215,18 @@ libtest_skiptest_SOURCES= libtest/skiptest.cc
 check_PROGRAMS+= libtest/skiptest
 noinst_PROGRAMS+= libtest/skiptest
 
+test-skiptest: libtest/skiptest
+	@libtest/skiptest
+
+valgrind-skiptest: libtest/skiptest
+	@$(VALGRIND_COMMAND) libtest/skiptest
+
+helgrind-skiptest: libtest/skiptest
+	@$(HELGRIND_COMMAND) libtest/skiptest
+
+drd-skiptest: libtest/skiptest
+	@$(DRD_COMMAND) libtest/skiptest
+
 libtest_wait_SOURCES=
 libtest_wait_SOURCES+= libtest/wait.cc
 libtest_wait_SOURCES+= libtest/dream.cc
diff --git a/libtest/lite.h b/libtest/lite.h
index 342be97d..36f873e8 100644
--- a/libtest/lite.h
+++ b/libtest/lite.h
@@ -140,6 +140,34 @@ do \
   } \
 } while (0)
 
+#define SKIP_UNLESS(__expression) \
+do \
+{ \
+  if (! (__expression)) { \
+    if (YATL_FULL) { \
+      SKIP(#__expression); \
+    } \
+    fprintf(stdout, "\n%s:%d: %s SKIP '(%s)'\n", __FILE__, __LINE__, __PRETTY_FUNCTION__, #__expression); \
+    exit(EXIT_SKIP); \
+  } \
+} while (0)
+
+#define SKIP_UNLESS_(__expression, ...) \
+do \
+{ \
+  if (! (__expression)) { \
+    size_t ask= snprintf(0, 0, __VA_ARGS__); \
+    ask++; \
+    char *buffer= (char*)alloca(sizeof(char) * ask); \
+    snprintf(buffer, ask, __VA_ARGS__); \
+    if (YATL_FULL) { \
+      SKIP(#__expression, buffer); \
+    } \
+    fprintf(stdout, "\n%s:%d: %s SKIP '%s' [ %s ]\n", __FILE__, __LINE__, __PRETTY_FUNCTION__, #__expression, buffer); \
+    exit(EXIT_SKIP); \
+  } \
+} while (0)
+
 #define ASSERT_TRUE(__expression) \
 do \
 { \
diff --git a/libtest/main.cc b/libtest/main.cc
index 2ceeac92..46429241 100644
--- a/libtest/main.cc
+++ b/libtest/main.cc
@@ -297,7 +297,6 @@ int main(int argc, char *argv[])
       std::auto_ptr<libtest::Framework> frame(new libtest::Framework(signal, binary_name, collection_to_run, wildcard));
 
       // Run create(), bail on error.
-      try
       {
         switch (frame->create())
         {
@@ -305,17 +304,14 @@ int main(int argc, char *argv[])
           break;
 
         case TEST_SKIPPED:
-          return EXIT_SKIP;
+          SKIP("SKIP was returned from framework create()");
+          break;
 
         case TEST_FAILURE:
           std::cerr << "Could not call frame->create()" << std::endl;
           return EXIT_FAILURE;
         }
       }
-      catch (const libtest::__skipped& e)
-      {
-        return EXIT_SKIP;
-      }
 
       frame->exec();
 
diff --git a/libtest/result.cc b/libtest/result.cc
index a102b4f7..3e4523d3 100644
--- a/libtest/result.cc
+++ b/libtest/result.cc
@@ -41,53 +41,9 @@
 namespace libtest {
 
 __test_result::__test_result(const char *file_arg, int line_arg, const char *func_arg):
-  _line(line_arg),
-  _file(file_arg),
-  _func(func_arg),
-  _error_message(NULL),
-  _error_message_size(0)
-{
-}
-
-#ifndef __INTEL_COMPILER
-# pragma GCC diagnostic ignored "-Wformat-nonliteral"
-#endif
-void __test_result::init(va_list args_)
-{
-  const char *format= va_arg(args_, const char *);
-  _error_message_size= vasprintf(&_error_message, format, args_);
-  assert(_error_message_size != -1);
-  if (_error_message_size > 0)
+  libtest::exception(file_arg, line_arg, func_arg)
   {
-    _error_message_size++;
   }
-}
-
-__test_result::~__test_result() throw()
-{
-  free(_error_message);
-}
-
-__test_result::__test_result(const __test_result& other) :
-  std::exception(),
-  _line(other._line),
-  _file(other._file),
-  _func(other._func),
-  _error_message_size(other._error_message_size)
-{
-  if (_error_message_size > 0)
-  {
-    _error_message= (char*) malloc(_error_message_size);
-    if (_error_message)
-    {
-      memcpy(_error_message, other._error_message, _error_message_size);
-    }
-    else
-    {
-      _error_message_size= -1;
-    }
-  }
-}
 
 __success::__success(const char *file_arg, int line_arg, const char *func_arg):
   __test_result(file_arg, line_arg, func_arg)
diff --git a/libtest/result.hpp b/libtest/result.hpp
index 0c78b998..79acbb40 100644
--- a/libtest/result.hpp
+++ b/libtest/result.hpp
@@ -36,10 +36,8 @@
 
 #pragma once
 
-#include <libtest/fatal.hpp>
 #include <libtest/result/base.hpp>
 #include <libtest/result/fail.hpp>
-#include <libtest/result/fatal.hpp>
 #include <libtest/result/skip.hpp>
 #include <libtest/result/success.hpp>
 
@@ -56,27 +54,3 @@ do \
 { \
   throw libtest::__failure(LIBYATL_DEFAULT_PARAM, __VA_ARGS__); \
 } while (0)
-
-#define FATAL(...) \
-do \
-{ \
-  throw libtest::fatal(LIBYATL_DEFAULT_PARAM, __VA_ARGS__); \
-} while (0)
-
-#define FATAL_IF(__expression, ...) \
-do \
-{ \
-  if ((__expression)) { \
-    throw libtest::fatal(LIBYATL_DEFAULT_PARAM, (#__expression)); \
-  } \
-} while (0)
-
-#define FATAL_IF_(__expression, ...) \
-do \
-{ \
-  if ((__expression)) { \
-    throw libtest::fatal(LIBYATL_DEFAULT_PARAM, __VA_ARGS__); \
-  } \
-} while (0)
-
-#define fatal_assert(__assert) if((__assert)) {} else { throw libtest::fatal(LIBYATL_DEFAULT_PARAM, #__assert); }
diff --git a/libtest/result/base.hpp b/libtest/result/base.hpp
index 51ee995d..5f093f83 100644
--- a/libtest/result/base.hpp
+++ b/libtest/result/base.hpp
@@ -36,51 +36,19 @@
 
 #pragma once
 
+#include "libtest/exception.hpp"
+#include "libtest/error.h"
+
 namespace libtest {
 
-class __test_result : public std::exception
+class __test_result : public libtest::exception
 {
 public:
   __test_result(const char *file, int line, const char *func);
 
-  __test_result( const __test_result& );
-
-  virtual ~__test_result() throw();
-
-  virtual const char* what() const throw()
-  {
-    if (_error_message)
-    {
-      return _error_message;
-    }
-
-    return "";
-  }
-
-  int line() const
-  {
-    return _line;
-  }
-
-  const char*  file() const
-  {
-    return _file;
-  }
-
-  const char* func() const
-  {
-    return _func;
-  }
-
-protected:
-  void init(va_list);
+  virtual test_return_t return_code() const= 0;
 
 private:
-  int _line;
-  const char*  _file;
-  const char* _func;
-  char* _error_message;
-  int _error_message_size;
 };
 
 } // namespace libtest
diff --git a/libtest/result/fail.hpp b/libtest/result/fail.hpp
index fd8766a9..3aec9c1e 100644
--- a/libtest/result/fail.hpp
+++ b/libtest/result/fail.hpp
@@ -45,6 +45,11 @@ public:
 
   __failure(const __failure&);
 
+  test_return_t return_code() const
+  {
+    return TEST_FAILURE;
+  }
+
 private:
 };
 
diff --git a/libtest/result/skip.hpp b/libtest/result/skip.hpp
index d0226e9f..7409d718 100644
--- a/libtest/result/skip.hpp
+++ b/libtest/result/skip.hpp
@@ -44,6 +44,11 @@ public:
   __skipped(const char *file, int line, const char *func, ...);
 
   __skipped(const __skipped&);
+
+  test_return_t return_code() const
+  {
+    return TEST_SKIPPED;
+  }
 };
 
 } // namespace libtest
diff --git a/libtest/result/success.hpp b/libtest/result/success.hpp
index 2931f2d0..a34e677e 100644
--- a/libtest/result/success.hpp
+++ b/libtest/result/success.hpp
@@ -48,6 +48,11 @@ public:
     return "SUCCESS";
   }
 
+  test_return_t return_code() const
+  {
+    return TEST_SUCCESS;
+  }
+
 private:
 };
 
diff --git a/libtest/run.gdb b/libtest/run.gdb
index 25dcdd53..c35ab767 100644
--- a/libtest/run.gdb
+++ b/libtest/run.gdb
@@ -2,5 +2,6 @@ set logging on
 set logging overwrite on
 set environment LIBTEST_IN_GDB=1
 #set ASAN_OPTIONS=abort_on_error=1
+handle SIGVTALRM stop
 run
 thread apply all bt
diff --git a/libtest/test.hpp b/libtest/test.hpp
index 7c18d6bc..d9040700 100644
--- a/libtest/test.hpp
+++ b/libtest/test.hpp
@@ -65,7 +65,10 @@
 #include <libtest/version.h>
 
 #include <libtest/vchar.hpp>
-#include <libtest/fatal.hpp>
+#include <libtest/error.h>
+#include <libtest/exception.hpp>
+#include <libtest/exception/disconnected.hpp>
+#include <libtest/exception/fatal.hpp>
 #include <libtest/result.hpp>
 
 #include <libtest/has.hpp>
diff --git a/libtest/tmpfile.cc b/libtest/tmpfile.cc
index a88c0ede..425a21e7 100644
--- a/libtest/tmpfile.cc
+++ b/libtest/tmpfile.cc
@@ -40,7 +40,7 @@
 
 namespace libtest {
 
-std::string create_tmpfile(const std::string& name)
+std::string create_tmpfile(const std::string& name, int& fd)
 {
   libtest::vchar_t file_buffer;
   file_buffer.resize(FILENAME_MAX);
@@ -49,15 +49,22 @@ std::string create_tmpfile(const std::string& name)
   int length= snprintf(&file_buffer[0], file_buffer.size(), "var/tmp/%s.XXXXXX", name.c_str());
   fatal_assert(length > 0);
 
-  int fd;
   if ((fd= mkstemp(&file_buffer[0])) == -1)
   {
     throw libtest::fatal(LIBYATL_DEFAULT_PARAM, "mkstemp() failed on %s with %s", &file_buffer[0], strerror(errno));
   }
-  close(fd);
-  unlink(&file_buffer[0]);
 
   return &file_buffer[0];
 }
 
+std::string create_tmpfile(const std::string& name)
+{
+  int fd;
+  std::string ret_file= create_tmpfile(name, fd);
+  close(fd);
+  unlink(ret_file.c_str());
+
+  return ret_file.c_str();
+}
+
 } // namespace libtest
diff --git a/libtest/tmpfile.hpp b/libtest/tmpfile.hpp
index 0eb8dca2..9283b84a 100644
--- a/libtest/tmpfile.hpp
+++ b/libtest/tmpfile.hpp
@@ -40,6 +40,7 @@
 
 namespace libtest {
 
+std::string create_tmpfile(const std::string&, int&);
 std::string create_tmpfile(const std::string&);
 
 } // namespace libtest
diff --git a/libtest/unittest.cc b/libtest/unittest.cc
index 1663e59a..bbb56c66 100644
--- a/libtest/unittest.cc
+++ b/libtest/unittest.cc
@@ -142,6 +142,25 @@ static test_return_t test_throw_skip_macro_TEST(void *)
   return TEST_FAILURE;
 }
 
+static test_return_t test_throw_skip_unless_macro_TEST(void *)
+{
+  try {
+    SKIP_UNLESS(false);
+  }
+  catch (const libtest::__skipped&)
+  {
+    return TEST_SUCCESS;
+  }
+  catch (...)
+  {
+    FAIL("SLIP_UNLESS() failed to throw libtest::_skipped");
+  }
+
+  FAIL("SLIP_UNLESS() failed to throw");
+
+  return TEST_FAILURE;
+}
+
 static test_return_t test_throw_skip_TEST(void *)
 {
   try {
@@ -941,6 +960,12 @@ static test_return_t default_port_TEST(void *)
   return TEST_SUCCESS;
 }
 
+static test_return_t check_for_VALGRIND(void *)
+{
+  test_skip_valgrind();
+  return TEST_SUCCESS;
+}
+
 static test_return_t check_for_gearman(void *)
 {
   test_skip(true, HAVE_LIBGEARMAN);
@@ -1043,6 +1068,7 @@ test_st tests_log[] ={
   {"SUCCESS", false, test_throw_success_TEST },
   {"libtest::__skipped", false, test_throw_skip_TEST },
   {"SKIP_IF", false, test_throw_skip_macro_TEST },
+  {"SKIP_UNLESS", false, test_throw_skip_unless_macro_TEST },
   {"FAIL", false, test_throw_fail_TEST },
   {"ASSERT_FALSE_", false, ASSERT_FALSE__TEST },
   {"ASSERT_FALSE", false, ASSERT_FALSE_TEST },
@@ -1186,7 +1212,7 @@ collection_st collection[] ={
   {"fatal", disable_fatal_exception, enable_fatal_exception, fatal_message_TESTS },
   {"number_of_cpus()", 0, 0, number_of_cpus_TESTS },
   {"create_tmpfile()", 0, 0, create_tmpfile_TESTS },
-  {"dns", 0, 0, dns_TESTS },
+  {"dns", check_for_VALGRIND, 0, dns_TESTS },
   {"libtest::Timer", 0, 0, timer_TESTS },
   {0, 0, 0, 0}
 };
diff --git a/libtest/yatl.m4 b/libtest/yatl.m4
index 61d1a2f0..0e88425d 100644
--- a/libtest/yatl.m4
+++ b/libtest/yatl.m4
@@ -7,7 +7,6 @@ AC_SUBST([LIBTEST_VERSION],[1.0])
 AC_CONFIG_FILES([libtest/version.h])
 
 m4_include([libtest/m4/mysql.m4])
-AC_DEFINE([HAVE_MEMCACHED_SASL_BINARY],[0],[If Memcached binary with sasl support is available])
 
 YATL_MYSQL