Update tests for assert, and fix the sqlite test hang issue.

libtest/client.cc

@@ -176,6 +176,22 @@ bool SimpleClient::instance_connect()
         {
           if (connect(sock_fd, address_info_next->ai_addr, address_info_next->ai_addrlen) == SOCKET_ERROR)
           {
+            switch (errno)
+            {
+            case EINTR:
+              close_socket();
+              continue;
+
+            case EINPROGRESS: // nonblocking mode - first return
+            case EALREADY: // nonblocking mode - subsequent returns
+              continue; // Jump to while() and continue on
+
+
+            case ECONNREFUSED:
+            default:
+              break;
+            }
+
             close_socket();
             _error= strerror(errno);
           }

libtest/cmdline.cc

@@ -687,8 +687,8 @@ void Application::create_argv(const char *args[])
   if (_use_libtool)
   {
     assert(libtool());
-    built_argv.push_back(strdup(libtool()));
-    built_argv.push_back(strdup("--mode=execute"));
+    vchar::append(built_argv, libtool());
+    vchar::append(built_argv, "--mode=execute");
   }
 
   if (_use_valgrind)
@@ -696,54 +696,54 @@ void Application::create_argv(const char *args[])
     /*
       valgrind --error-exitcode=1 --leak-check=yes --track-fds=yes --malloc-fill=A5 --free-fill=DE
     */
-    built_argv.push_back(strdup("valgrind"));
-    built_argv.push_back(strdup("--error-exitcode=1"));
-    built_argv.push_back(strdup("--leak-check=yes"));
+    vchar::append(built_argv, "valgrind");
+    vchar::append(built_argv, "--error-exitcode=1");
+    vchar::append(built_argv, "--leak-check=yes");
 #if 0
-    built_argv.push_back(strdup("--show-reachable=yes"));
+    vchar::append(built_argv, "--show-reachable=yes"));
 #endif
-    built_argv.push_back(strdup("--track-fds=yes"));
+    vchar::append(built_argv, "--track-fds=yes");
 #if 0
     built_argv[x++]= strdup("--track-origin=yes");
 #endif
-    built_argv.push_back(strdup("--malloc-fill=A5"));
-    built_argv.push_back(strdup("--free-fill=DE"));
+    vchar::append(built_argv, "--malloc-fill=A5");
+    vchar::append(built_argv, "--free-fill=DE");
 
     std::string log_file= create_tmpfile("valgrind");
     libtest::vchar_t buffer;
     buffer.resize(1024);
     int length= snprintf(&buffer[0], buffer.size(), "--log-file=%s", log_file.c_str());
     fatal_assert(length > 0 and size_t(length) < buffer.size());
-    built_argv.push_back(strdup(&buffer[0]));
+    vchar::append(built_argv, &buffer[0]);
   }
   else if (_use_ptrcheck)
   {
     /*
       valgrind --error-exitcode=1 --tool=exp-ptrcheck --log-file= 
     */
-    built_argv.push_back(strdup("valgrind"));
-    built_argv.push_back(strdup("--error-exitcode=1"));
-    built_argv.push_back(strdup("--tool=exp-ptrcheck"));
+    vchar::append(built_argv, "valgrind");
+    vchar::append(built_argv, "--error-exitcode=1");
+    vchar::append(built_argv, "--tool=exp-ptrcheck");
     std::string log_file= create_tmpfile("ptrcheck");
     libtest::vchar_t buffer;
     buffer.resize(1024);
     int length= snprintf(&buffer[0], buffer.size(), "--log-file=%s", log_file.c_str());
     fatal_assert(length > 0 and size_t(length) < buffer.size());
-    built_argv.push_back(strdup(&buffer[0]));
+    vchar::append(built_argv, &buffer[0]);
   }
   else if (_use_gdb)
   {
-    built_argv.push_back(strdup("gdb"));
+    vchar::append(built_argv, "gdb");
   }
 
-  built_argv.push_back(strdup(_exectuble_with_path.c_str()));
+  vchar::append(built_argv, _exectuble_with_path.c_str());
 
   for (Options::const_iterator iter= _options.begin(); iter != _options.end(); ++iter)
   {
-    built_argv.push_back(strdup((*iter).first.c_str()));
+    vchar::append(built_argv, (*iter).first.c_str());
     if ((*iter).second.empty() == false)
     {
-      built_argv.push_back(strdup((*iter).second.c_str()));
+      vchar::append(built_argv, (*iter).second.c_str());
     }
   }
 
@@ -751,7 +751,7 @@ void Application::create_argv(const char *args[])
   {
     for (const char **ptr= args; *ptr; ++ptr)
     {
-      built_argv.push_back(strdup(*ptr));
+      vchar::append(built_argv, *ptr);
     }
   }
   built_argv.push_back(NULL);
@@ -766,7 +766,7 @@ std::string Application::arguments()
 {
   std::stringstream arg_buffer;
 
-  for (size_t x= (1 +_use_libtool) ? 2 : 0;
+  for (size_t x= _use_libtool ? 2 : 0;
        x < _argc and built_argv[x];
        ++x)
   {
@@ -776,21 +776,9 @@ std::string Application::arguments()
   return arg_buffer.str();
 }
 
-struct DeleteFromVector
-{
-  template <class T>
-    void operator() ( T* ptr) const
-    {
-      if (ptr)
-      {
-        free(ptr);
-      }
-    }
-};
-
 void Application::delete_argv()
 {
-  std::for_each(built_argv.begin(), built_argv.end(), DeleteFromVector());
+  std::for_each(built_argv.begin(), built_argv.end(), FreeFromVector());
 
   built_argv.clear();
   _argc= 0;

libtest/cmdline.h

@@ -207,6 +207,7 @@ public:
 private:
   void create_argv(const char *args[]);
   void delete_argv();
+  void add_to_build_argv(const char*);
 
 private:
   const bool _use_libtool;

libtest/common.h

@@ -97,3 +97,25 @@
 #include <libtest/dns.hpp>
 #include <libtest/formatter.hpp>
 
+struct FreeFromVector
+{
+  template <class T>
+    void operator() ( T* ptr) const
+    {
+      if (ptr)
+      {
+        free(ptr);
+        ptr= NULL;
+      }
+    }
+};
+
+struct DeleteFromVector
+{
+  template <class T>
+    void operator() ( T* ptr) const
+    {
+      delete ptr;
+      ptr= NULL;
+    }
+};

libtest/main.cc

@@ -132,7 +132,7 @@ int main(int argc, char *argv[])
     {
       { "version", no_argument, NULL, OPT_LIBYATL_VERSION },
       { "quiet", no_argument, NULL, OPT_LIBYATL_QUIET },
-      { "repeat", no_argument, NULL, OPT_LIBYATL_REPEAT },
+      { "repeat", required_argument, NULL, OPT_LIBYATL_REPEAT },
       { "collection", required_argument, NULL, OPT_LIBYATL_MATCH_COLLECTION },
       { "wildcard", required_argument, NULL, OPT_LIBYATL_MATCH_WILDCARD },
       { "massive", no_argument, NULL, OPT_LIBYATL_MASSIVE },

libtest/port.cc

@@ -142,10 +142,10 @@ in_port_t get_free_port()
   {
     ret_port= default_port;
     int sd;
-    if ((sd= socket(AF_INET, SOCK_STREAM, 0)) != -1)
+    if ((sd= socket(AF_INET, SOCK_STREAM, 0)) != SOCKET_ERROR)
     {
       int optval= 1;
-      if (setsockopt(sd, SOL_SOCKET, SO_REUSEADDR, &optval, sizeof(optval)) != -1)
+      if (setsockopt(sd, SOL_SOCKET, SO_REUSEADDR, &optval, sizeof(optval)) != SOCKET_ERROR)
       { 
         struct sockaddr_in sin;
         sin.sin_port= 0;
@@ -156,7 +156,7 @@ in_port_t get_free_port()
         int bind_ret;
         do
         {
-          if ((bind_ret= bind(sd, (struct sockaddr *)&sin, sizeof(struct sockaddr_in) )) != -1)
+          if ((bind_ret= bind(sd, (struct sockaddr *)&sin, sizeof(struct sockaddr_in) )) != SOCKET_ERROR)
           {
             socklen_t addrlen= sizeof(sin);
 

libtest/server_container.cc

@@ -118,10 +118,7 @@ bool server_startup_st::shutdown(uint32_t host_to_shutdown)
 
 void server_startup_st::clear()
 {
-  for (std::vector<Server *>::iterator iter= servers.begin(); iter != servers.end(); ++iter)
-  {
-    delete *iter;
-  }
+  std::for_each(servers.begin(), servers.end(), DeleteFromVector());
   servers.clear();
 }
 
@@ -167,7 +164,6 @@ server_startup_st::server_startup_st() :
   _magic(MAGIC_MEMORY),
   _socket(false),
   _sasl(false),
-  _count(0),
   udp(0),
   _servers_to_run(5)
 { }

libtest/server_container.h

@@ -54,7 +54,6 @@ private:
   std::string server_list;
   bool _socket;
   bool _sasl;
-  uint32_t _count;
   std::string _username;
   std::string _password;
 

libtest/unittest.cc

@@ -200,7 +200,7 @@ static test_return_t test_failure_test(void *)
 {
   return TEST_SKIPPED; // Only run this when debugging
 
-  test_compare(1, 2);
+  ASSERT_EQ(1, 2);
   return TEST_SUCCESS;
 }
 
@@ -232,20 +232,20 @@ static test_return_t local_not_test(void *)
 
   // unsetenv() will cause issues with valgrind
   _compare(__FILE__, __LINE__, __func__, 0, unsetenv("LIBTEST_LOCAL"), true);
-  test_compare(0, unsetenv("LIBTEST_LOCAL"));
+  ASSERT_EQ(0, unsetenv("LIBTEST_LOCAL"));
   test_false(test_is_local());
 
-  test_compare(0, setenv("LIBTEST_LOCAL", "1", 1));
+  ASSERT_EQ(0, setenv("LIBTEST_LOCAL", "1", 1));
   test_true(test_is_local());
 
   if (temp.empty())
   {
-    test_compare(0, unsetenv("LIBTEST_LOCAL"));
+    ASSERT_EQ(0, unsetenv("LIBTEST_LOCAL"));
   }
   else
   {
     char *old_string= strdup(temp.c_str());
-    test_compare(0, setenv("LIBTEST_LOCAL", old_string, 1));
+    ASSERT_EQ(0, setenv("LIBTEST_LOCAL", old_string, 1));
   }
 
   return TEST_SUCCESS;
@@ -253,31 +253,31 @@ static test_return_t local_not_test(void *)
 
 static test_return_t var_exists_test(void *)
 {
-  test_compare(0, access("var", R_OK | W_OK | X_OK));
+  ASSERT_EQ(0, access("var", R_OK | W_OK | X_OK));
   return TEST_SUCCESS;
 }
 
 static test_return_t var_tmp_exists_test(void *)
 {
-  test_compare(0, access("var/tmp", R_OK | W_OK | X_OK));
+  ASSERT_EQ(0, access("var/tmp", R_OK | W_OK | X_OK));
   return TEST_SUCCESS;
 }
 
 static test_return_t var_run_exists_test(void *)
 {
-  test_compare(0, access("var/run", R_OK | W_OK | X_OK));
+  ASSERT_EQ(0, access("var/run", R_OK | W_OK | X_OK));
   return TEST_SUCCESS;
 }
 
 static test_return_t var_log_exists_test(void *)
 {
-  test_compare(0, access("var/log", R_OK | W_OK | X_OK));
+  ASSERT_EQ(0, access("var/log", R_OK | W_OK | X_OK));
   return TEST_SUCCESS;
 }
 
 static test_return_t var_drizzle_exists_test(void *)
 {
-  test_compare(0, access("var/drizzle", R_OK | W_OK | X_OK));
+  ASSERT_EQ(0, access("var/drizzle", R_OK | W_OK | X_OK));
   return TEST_SUCCESS;
 }
 
@@ -339,7 +339,7 @@ static test_return_t var_drizzle_rm_test(void *)
 
 static test_return_t _compare_test_return_t_test(void *)
 {
-  test_compare(TEST_SUCCESS, TEST_SUCCESS);
+  ASSERT_EQ(TEST_SUCCESS, TEST_SUCCESS);
 
   return TEST_SUCCESS;
 }
@@ -348,7 +348,7 @@ static test_return_t _compare_memcached_return_t_test(void *)
 {
   test_skip(HAVE_LIBMEMCACHED, true);
 #if defined(HAVE_LIBMEMCACHED_1_0_TYPES_RETURN_H) && HAVE_LIBMEMCACHED_1_0_TYPES_RETURN_H
-  test_compare(MEMCACHED_SUCCESS, MEMCACHED_SUCCESS);
+  ASSERT_EQ(MEMCACHED_SUCCESS, MEMCACHED_SUCCESS);
 #endif
 
   return TEST_SUCCESS;
@@ -358,7 +358,7 @@ static test_return_t _compare_gearman_return_t_test(void *)
 {
   test_skip(HAVE_LIBGEARMAN, true);
 #if defined(HAVE_LIBGEARMAN_1_0_RETURN_H) && HAVE_LIBGEARMAN_1_0_RETURN_H
-  test_compare(GEARMAN_SUCCESS, GEARMAN_SUCCESS);
+  ASSERT_EQ(GEARMAN_SUCCESS, GEARMAN_SUCCESS);
 #endif
 
   return TEST_SUCCESS;
@@ -400,18 +400,18 @@ static test_return_t skip_shim(bool a, bool b)
 
 static test_return_t test_skip_true_TEST(void*)
 {
-  test_compare(true, true);
-  test_compare(false, false);
-  test_compare(TEST_SUCCESS, skip_shim(true, true));
-  test_compare(TEST_SUCCESS, skip_shim(false, false));
+  ASSERT_EQ(true, true);
+  ASSERT_EQ(false, false);
+  ASSERT_EQ(TEST_SUCCESS, skip_shim(true, true));
+  ASSERT_EQ(TEST_SUCCESS, skip_shim(false, false));
 
   return TEST_SUCCESS;
 }
 
 static test_return_t test_skip_false_TEST(void*)
 {
-  test_compare(TEST_SKIPPED, skip_shim(true, false));
-  test_compare(TEST_SKIPPED, skip_shim(false, true));
+  ASSERT_EQ(TEST_SKIPPED, skip_shim(true, false));
+  ASSERT_EQ(TEST_SKIPPED, skip_shim(false, true));
   return TEST_SUCCESS;
 }
 
@@ -421,7 +421,7 @@ static test_return_t server_startup_fail_TEST(void *object)
   test_true(servers);
 
   fatal::disable();
-  test_compare(servers->start_server(testing_service, LIBTEST_FAIL_PORT, 0, NULL, false), true);
+  ASSERT_EQ(servers->start_server(testing_service, LIBTEST_FAIL_PORT, 0, NULL, false), true);
   fatal::enable();
 
   return TEST_SUCCESS;
@@ -432,19 +432,19 @@ static test_return_t server_startup_TEST(void *object)
   server_startup_st *servers= (server_startup_st*)object;
   test_true(servers);
 
-  test_compare(servers->start_server(testing_service, get_free_port(), 0, NULL, false), true);
+  ASSERT_EQ(servers->start_server(testing_service, get_free_port(), 0, NULL, false), true);
 
   test_true(servers->last());
   pid_t last_pid= servers->last()->pid();
 
-  test_compare(servers->last()->pid(), last_pid);
+  ASSERT_EQ(servers->last()->pid(), last_pid);
   test_true(last_pid > 1);
-  test_compare(kill(last_pid, 0), 0);
+  ASSERT_EQ(kill(last_pid, 0), 0);
 
   test_true(servers->shutdown());
 #if 0
-  test_compare(servers->last()->pid(), -1);
-  test_compare(kill(last_pid, 0), -1);
+  ASSERT_EQ(servers->last()->pid(), -1);
+  ASSERT_EQ(kill(last_pid, 0), -1);
 #endif
 
   return TEST_SUCCESS;
@@ -488,8 +488,8 @@ static test_return_t application_true_BINARY(void *)
   test_skip(0, access("/usr/bin/true", X_OK ));
   Application true_app("/usr/bin/true");
 
-  test_compare(Application::SUCCESS, true_app.run());
-  test_compare(Application::SUCCESS, true_app.join());
+  ASSERT_EQ(Application::SUCCESS, true_app.run());
+  ASSERT_EQ(Application::SUCCESS, true_app.join());
 
   return TEST_SUCCESS;
 }
@@ -502,8 +502,8 @@ static test_return_t application_gdb_true_BINARY2(void *)
   Application true_app("/usr/bin/true");
   true_app.use_gdb(true);
 
-  test_compare(Application::SUCCESS, true_app.run());
-  test_compare(Application::SUCCESS, true_app.join());
+  ASSERT_EQ(Application::SUCCESS, true_app.run());
+  ASSERT_EQ(Application::SUCCESS, true_app.join());
 
   return TEST_SUCCESS;
 }
@@ -517,8 +517,8 @@ static test_return_t application_gdb_true_BINARY(void *)
   true_app.use_gdb(true);
 
   const char *args[]= { "--fubar", 0 };
-  test_compare(Application::SUCCESS, true_app.run(args));
-  test_compare(Application::SUCCESS, true_app.join());
+  ASSERT_EQ(Application::SUCCESS, true_app.run(args));
+  ASSERT_EQ(Application::SUCCESS, true_app.join());
 
   return TEST_SUCCESS;
 }
@@ -529,8 +529,8 @@ static test_return_t application_true_fubar_BINARY(void *)
   Application true_app("/usr/bin/true");
 
   const char *args[]= { "--fubar", 0 };
-  test_compare(Application::SUCCESS, true_app.run(args));
-  test_compare(Application::SUCCESS, true_app.join());
+  ASSERT_EQ(Application::SUCCESS, true_app.run(args));
+  ASSERT_EQ(Application::SUCCESS, true_app.join());
   test_zero(true_app.stdout_result().size());
 
   return TEST_SUCCESS;
@@ -545,12 +545,12 @@ static test_return_t application_doesnotexist_BINARY(void *)
 
   const char *args[]= { "--fubar", 0 };
 #if defined(TARGET_OS_OSX) && TARGET_OS_OSX
-  test_compare(Application::INVALID_POSIX_SPAWN, true_app.run(args));
+  ASSERT_EQ(Application::INVALID_POSIX_SPAWN, true_app.run(args));
 #elif defined(TARGET_OS_FREEBSD) && TARGET_OS_FREEBSD
-  test_compare(Application::INVALID_POSIX_SPAWN, true_app.run(args));
+  ASSERT_EQ(Application::INVALID_POSIX_SPAWN, true_app.run(args));
 #else
-  test_compare(Application::SUCCESS, true_app.run(args));
-  test_compare(Application::INVALID_POSIX_SPAWN, true_app.join());
+  ASSERT_EQ(Application::SUCCESS, true_app.run(args));
+  ASSERT_EQ(Application::INVALID_POSIX_SPAWN, true_app.join());
 #endif
 
   test_zero(true_app.stdout_result().size());
@@ -562,7 +562,7 @@ static test_return_t GET_TEST(void *)
 {
   libtest::http::GET get("http://foo.example.com/");
 
-  test_compare(false, get.execute());
+  ASSERT_EQ(false, get.execute());
 
   return TEST_SUCCESS;
 }
@@ -572,7 +572,7 @@ static test_return_t POST_TEST(void *)
   libtest::vchar_t body;
   libtest::http::POST post("http://foo.example.com/", body);
 
-  test_compare(false, post.execute());
+  ASSERT_EQ(false, post.execute());
 
   return TEST_SUCCESS;
 }
@@ -582,7 +582,7 @@ static test_return_t TRACE_TEST(void *)
   libtest::vchar_t body;
   libtest::http::TRACE trace("http://foo.example.com/", body);
 
-  test_compare(false, trace.execute());
+  ASSERT_EQ(false, trace.execute());
 
   return TEST_SUCCESS;
 }
@@ -592,7 +592,7 @@ static test_return_t vchar_t_TEST(void *)
 {
   libtest::vchar_t response;
   libtest::make_vector(response, test_literal_param("fubar\n"));
-  test_compare(response, response);
+  ASSERT_EQ(response, response);
 
   return TEST_SUCCESS;
 }
@@ -616,13 +616,13 @@ static test_return_t application_echo_fubar_BINARY(void *)
     Application true_app("/bin/echo");
 
     const char *args[]= { "fubar", 0 };
-    test_compare(Application::SUCCESS, true_app.run(args));
+    ASSERT_EQ(Application::SUCCESS, true_app.run(args));
 
     while (true_app.slurp() == false) {} ;
 
     libtest::vchar_t response;
     make_vector(response, test_literal_param("fubar\n"));
-    test_compare(response, true_app.stdout_result());
+    ASSERT_EQ(response, true_app.stdout_result());
   }
 
   return TEST_SUCCESS;
@@ -637,12 +637,12 @@ static test_return_t application_echo_fubar_BINARY2(void *)
 
     true_app.add_option("fubar");
 
-    test_compare(Application::SUCCESS, true_app.run());
-    test_compare(Application::SUCCESS, true_app.join());
+    ASSERT_EQ(Application::SUCCESS, true_app.run());
+    ASSERT_EQ(Application::SUCCESS, true_app.join());
 
     libtest::vchar_t response;
     make_vector(response, test_literal_param("fubar\n"));
-    test_compare(response, true_app.stdout_result());
+    ASSERT_EQ(response, true_app.stdout_result());
   }
 
   return TEST_SUCCESS;
@@ -651,7 +651,7 @@ static test_return_t application_echo_fubar_BINARY2(void *)
 static test_return_t echo_fubar_BINARY(void *)
 {
   const char *args[]= { "fubar", 0 };
-  test_compare(EXIT_SUCCESS, exec_cmdline("/bin/echo", args));
+  ASSERT_EQ(EXIT_SUCCESS, exec_cmdline("/bin/echo", args));
 
   return TEST_SUCCESS;
 }
@@ -660,7 +660,7 @@ static test_return_t core_count_BINARY(void *)
 {
   const char *args[]= { 0 };
 
-  test_compare(EXIT_SUCCESS, exec_cmdline("libtest/core-count", args, true));
+  ASSERT_EQ(EXIT_SUCCESS, exec_cmdline("libtest/core-count", args, true));
 
   return TEST_SUCCESS;
 }
@@ -669,7 +669,7 @@ static test_return_t wait_BINARY(void *)
 {
   const char *args[]= { "--quiet", 0 };
 
-  test_compare(EXIT_FAILURE, exec_cmdline("libtest/wait", args, true));
+  ASSERT_EQ(EXIT_FAILURE, exec_cmdline("libtest/wait", args, true));
 
   return TEST_SUCCESS;
 }
@@ -678,7 +678,7 @@ static test_return_t wait_help_BINARY(void *)
 {
   const char *args[]= { "--quiet", "--help", 0 };
 
-  test_compare(EXIT_SUCCESS, exec_cmdline("libtest/wait", args, true));
+  ASSERT_EQ(EXIT_SUCCESS, exec_cmdline("libtest/wait", args, true));
 
   return TEST_SUCCESS;
 }
@@ -687,7 +687,7 @@ static test_return_t wait_version_BINARY(void *)
 {
   const char *args[]= { "--quiet", "--version", 0 };
 
-  test_compare(EXIT_SUCCESS, exec_cmdline("libtest/wait", args, true));
+  ASSERT_EQ(EXIT_SUCCESS, exec_cmdline("libtest/wait", args, true));
 
   return TEST_SUCCESS;
 }
@@ -698,7 +698,7 @@ static test_return_t wait_services_BINARY(void *)
 
   const char *args[]= { "--quiet", "/etc/services", 0 };
 
-  test_compare(EXIT_SUCCESS, exec_cmdline("libtest/wait", args, true));
+  ASSERT_EQ(EXIT_SUCCESS, exec_cmdline("libtest/wait", args, true));
 
   return TEST_SUCCESS;
 }
@@ -709,7 +709,7 @@ static test_return_t wait_services_BINARY2(void *)
 
   const char *args[]= { "/etc/services", 0 };
 
-  test_compare(EXIT_SUCCESS, exec_cmdline("libtest/wait", args, true));
+  ASSERT_EQ(EXIT_SUCCESS, exec_cmdline("libtest/wait", args, true));
 
   return TEST_SUCCESS;
 }
@@ -724,8 +724,8 @@ static test_return_t wait_services_appliction_TEST(void *)
   wait_app.use_gdb(true);
 
   const char *args[]= { "/etc/services", 0 };
-  test_compare(Application::SUCCESS, wait_app.run(args));
-  test_compare(Application::SUCCESS, wait_app.join());
+  ASSERT_EQ(Application::SUCCESS, wait_app.run(args));
+  ASSERT_EQ(Application::SUCCESS, wait_app.join());
 
   return TEST_SUCCESS;
 }
@@ -745,8 +745,8 @@ static test_return_t gdb_wait_services_appliction_TEST(void *)
   wait_app.use_gdb(true);
 
   const char *args[]= { "/etc/services", 0 };
-  test_compare(Application::SUCCESS, wait_app.run(args));
-  test_compare(Application::SUCCESS, wait_app.join());
+  ASSERT_EQ(Application::SUCCESS, wait_app.run(args));
+  ASSERT_EQ(Application::SUCCESS, wait_app.join());
 
   return TEST_SUCCESS;
 }
@@ -764,17 +764,17 @@ static test_return_t gdb_abort_services_appliction_TEST(void *)
   libtest::Application abort_app("libtest/abort", true);
   abort_app.use_gdb(true);
 
-  test_compare(Application::SUCCESS, abort_app.run());
-  test_compare(Application::SUCCESS, abort_app.join());
+  ASSERT_EQ(Application::SUCCESS, abort_app.run());
+  ASSERT_EQ(Application::SUCCESS, abort_app.join());
 
   std::string gdb_filename= abort_app.gdb_filename();
   test_skip(0, access(gdb_filename.c_str(), R_OK ));
   const char *args[]= { "SIGABRT", gdb_filename.c_str(), 0 };
-  test_compare(EXIT_SUCCESS, exec_cmdline("grep", args));
+  ASSERT_EQ(EXIT_SUCCESS, exec_cmdline("grep", args));
 
   // Sanity test
   args[0]= "THIS_WILL_NOT_BE_FOUND";
-  test_compare(EXIT_FAILURE, exec_cmdline("grep", args));
+  ASSERT_EQ(EXIT_FAILURE, exec_cmdline("grep", args));
 
   return TEST_SUCCESS;
 }
@@ -791,7 +791,7 @@ static test_return_t get_free_port_TEST(void *)
 
 static test_return_t fatal_TEST(void *)
 {
-  test_compare(fatal_calls++, fatal::disabled_counter());
+  ASSERT_EQ(fatal_calls++, fatal::disabled_counter());
   throw libtest::fatal(LIBYATL_DEFAULT_PARAM, "Testing va_args based fatal(): %d", 10); 
 
   return TEST_SUCCESS;
@@ -821,7 +821,7 @@ static test_return_t Timer_TEST(void *)
   check.reset();
   check.offset(minutes, 2, 200);
 
-  test_compare(check.minutes(), minutes);
+  ASSERT_EQ(check.minutes(), minutes);
 
   return TEST_SUCCESS;
 }
@@ -847,23 +847,23 @@ static test_return_t create_tmpfile_TEST(void *)
 {
   test_skip(0, access("/usr/bin/touch", X_OK ));
   std::string tmp= create_tmpfile(__func__);
-  test_compare(-1, access(tmp.c_str(), R_OK));
-  test_compare(-1, access(tmp.c_str(), F_OK));
+  ASSERT_EQ(-1, access(tmp.c_str(), R_OK));
+  ASSERT_EQ(-1, access(tmp.c_str(), F_OK));
 
   Application touch_app("/usr/bin/touch");
   const char *args[]= { tmp.c_str(), 0 };
-  test_compare(Application::SUCCESS, touch_app.run(args));
-  test_compare(Application::SUCCESS, touch_app.join());
+  ASSERT_EQ(Application::SUCCESS, touch_app.run(args));
+  ASSERT_EQ(Application::SUCCESS, touch_app.join());
 
-  test_compare(0, access(tmp.c_str(), R_OK));
-  test_compare(0, unlink(tmp.c_str()));
+  ASSERT_EQ(0, access(tmp.c_str(), R_OK));
+  ASSERT_EQ(0, unlink(tmp.c_str()));
 
   return TEST_SUCCESS;
 }
 
 static test_return_t fatal_message_TEST(void *)
 {
-  test_compare(fatal_calls++, fatal::disabled_counter());
+  ASSERT_EQ(fatal_calls++, fatal::disabled_counter());
   fatal_message("Fatal test");
 
   return TEST_SUCCESS;
@@ -872,8 +872,8 @@ static test_return_t fatal_message_TEST(void *)
 static test_return_t default_port_TEST(void *)
 {
   in_port_t ret_port= default_port();
-  test_compare(ret_port, libtest::default_port());
-  test_compare(ret_port, libtest::default_port());
+  ASSERT_EQ(ret_port, libtest::default_port());
+  ASSERT_EQ(ret_port, libtest::default_port());
 
   return TEST_SUCCESS;
 }

libtest/vchar.cc

@@ -88,6 +88,19 @@ void make(libtest::vchar_t& arg, size_t length)
   }
 }
 
+void append(libtest::vchar_ptr_t& arg, const char* ptr)
+{
+  if (ptr)
+  {
+    char* new_ptr= strdup(ptr);
+    if (new_ptr == NULL)
+    {
+      fatal_message("UNABLE to allocate %s(%p)", ptr, ptr);
+    }
+    arg.push_back(new_ptr);
+  }
+}
+
 } // namespace vchar
 
 void make_vector(libtest::vchar_t& arg, const char *str, size_t length)