Merge trunk.

[m6w6/libmemcached] / libtest / unittest.cc

diff --git a/libtest/unittest.cc b/libtest/unittest.cc
index e3272783ca2094b4fc745a7591f349c59e06a920..87102ddd7afc8559c4292cc55bf7910fb47be7d4 100644 (file)
--- a/libtest/unittest.cc
+++ b/libtest/unittest.cc
@@ -24,6 +24,14 @@
 
 #include <libtest/test.hpp>
 
+#if defined(LIBTEST_WITH_LIBMEMCACHED_SUPPORT) && LIBTEST_WITH_LIBMEMCACHED_SUPPORT
+#include <libmemcached/memcached.h>
+#endif
+
+#if defined(LIBTEST_WITH_LIBGEARMAN_SUPPORT) && LIBTEST_WITH_LIBGEARMAN_SUPPORT
+#include <libgearman/gearman.h>
+#endif
+
 #include <cstdlib>
 #include <unistd.h>
 
@@ -53,6 +61,15 @@ static test_return_t GDB_COMMAND_test(void *)
   return TEST_SUCCESS;
 }
 
+static test_return_t test_success_equals_one_test(void *)
+{
+  test_skip(HAVE_LIBMEMCACHED, true);
+#if defined(HAVE_LIBMEMCACHED) && HAVE_LIBMEMCACHED 
+  test_zero(MEMCACHED_SUCCESS);
+#endif
+  return TEST_SUCCESS;
+}
+
 static test_return_t test_success_test(void *)
 {
   return TEST_SUCCESS;
@@ -113,28 +130,119 @@ static test_return_t local_not_test(void *)
   return TEST_SUCCESS;
 }
 
-#if 0
-static test_return_t pause_test(void *)
+static test_return_t var_exists_test(void *)
+{
+  test_compare(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));
+  return TEST_SUCCESS;
+}
+
+static test_return_t var_run_exists_test(void *)
+{
+  test_compare(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));
+  return TEST_SUCCESS;
+}
+
+static test_return_t var_tmp_test(void *)
+{
+  FILE *file= fopen("var/tmp/junk", "w+");
+  char buffer[1024];
+  const char *dir= getcwd(buffer, sizeof(buffer));
+  test_true_got(file, dir);
+  fclose(file);
+  return TEST_SUCCESS;
+}
+
+static test_return_t var_run_test(void *)
+{
+  FILE *file= fopen("var/run/junk", "w+");
+  test_true(file);
+  fclose(file);
+  return TEST_SUCCESS;
+}
+
+static test_return_t var_log_test(void *)
 {
-  (void)getchar();
+  FILE *file= fopen("var/log/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);
+  return TEST_SUCCESS;
+}
+
+static test_return_t var_run_rm_test(void *)
+{
+  test_true(unlink("var/run/junk") == 0);
+  return TEST_SUCCESS;
+}
+
+static test_return_t var_log_rm_test(void *)
+{
+  test_true(unlink("var/log/junk") == 0);
+  return TEST_SUCCESS;
+}
+
+static test_return_t _compare_test_return_t_test(void *)
+{
+  test_compare(TEST_SUCCESS, TEST_SUCCESS);
+
+  return TEST_SUCCESS;
+}
+
+static test_return_t _compare_memcached_return_t_test(void *)
+{
+  test_skip(HAVE_LIBMEMCACHED, true);
+#if defined(HAVE_LIBMEMCACHED) && HAVE_LIBMEMCACHED 
+  test_compare(MEMCACHED_SUCCESS, MEMCACHED_SUCCESS);
 #endif
 
+  return TEST_SUCCESS;
+}
+
+static test_return_t _compare_gearman_return_t_test(void *)
+{
+  test_skip(HAVE_LIBGEARMAN, true);
+#if defined(HAVE_LIBGEARMAN) && HAVE_LIBGEARMAN
+  test_compare(GEARMAN_SUCCESS, GEARMAN_SUCCESS);
+#endif
+
+  return TEST_SUCCESS;
+}
 
 static test_return_t gearmand_cycle_test(void *object)
 {
   server_startup_st *servers= (server_startup_st*)object;
   test_true(servers);
 
-#ifndef HAVE_LIBGEARMAN
-  return TEST_SKIPPED;
-#endif
-
-  const char *argv[1]= { "cycle_gearmand" };
-  test_true(server_startup(*servers, "gearmand", 9999, 1, argv));
+  if (GEARMAND_BINARY)
+  {
+    if (HAVE_LIBGEARMAN)
+    {
+      test_true(has_gearmand_binary());
+      const char *argv[1]= { "cycle_gearmand" };
+      test_true(server_startup(*servers, "gearmand", 9999, 1, argv));
+
+      return TEST_SUCCESS;
+    }
+  }
 
-  return TEST_SUCCESS;
+  return TEST_SKIPPED;
 }
 
 static test_return_t memcached_cycle_test(void *object)
@@ -142,14 +250,16 @@ static test_return_t memcached_cycle_test(void *object)
   server_startup_st *servers= (server_startup_st*)object;
   test_true(servers);
 
-#if !defined(MEMCACHED_BINARY) || !defined(HAVE_LIBMEMCACHED)
-  return TEST_SKIPPED;
-#endif
+  if (MEMCACHED_BINARY and HAVE_LIBMEMCACHED) 
+  {
+    test_true(has_memcached_binary());
+    const char *argv[1]= { "cycle_memcached" };
+    test_true(server_startup(*servers, "memcached", 9998, 1, argv));
 
-  const char *argv[1]= { "cycle_memcached" };
-  test_true(server_startup(*servers, "memcached", 9998, 1, argv));
+    return TEST_SUCCESS;
+  }
 
-  return TEST_SUCCESS;
+  return TEST_SKIPPED;
 }
 
 static test_return_t memcached_socket_cycle_test(void *object)
@@ -157,12 +267,69 @@ static test_return_t memcached_socket_cycle_test(void *object)
   server_startup_st *servers= (server_startup_st*)object;
   test_true(servers);
 
-#if !defined(MEMCACHED_BINARY) || !defined(HAVE_LIBMEMCACHED)
+  if (MEMCACHED_BINARY)
+  {
+    if (HAVE_LIBMEMCACHED)
+    {
+      test_true(has_memcached_binary());
+      const char *argv[1]= { "cycle_memcached" };
+      test_true(servers->start_socket_server("memcached", 9997, 1, argv));
+
+      return TEST_SUCCESS;
+    }
+  }
+
   return TEST_SKIPPED;
-#endif
+}
+
+static test_return_t memcached_sasl_test(void *object)
+{
+  server_startup_st *servers= (server_startup_st*)object;
+  test_true(servers);
 
-  const char *argv[1]= { "cycle_memcached" };
-  test_true(servers->start_socket_server("memcached", 9997, 1, argv));
+  if (getenv("TESTS_ENVIRONMENT"))
+  {
+    return TEST_SKIPPED;
+  }
+
+  if (MEMCACHED_SASL_BINARY)
+  {
+    if (HAVE_LIBMEMCACHED)
+    {
+      test_true(has_memcached_sasl_binary());
+      const char *argv[1]= { "cycle_memcached_sasl" };
+      test_true(server_startup(*servers, "memcached-sasl", 9996, 1, argv));
+
+      return TEST_SUCCESS;
+    }
+  }
+
+  return TEST_SKIPPED;
+}
+
+static test_return_t wait_BINARY(void *)
+{
+  const char *args[]= { "--quiet", 0 };
+
+  test_true(exec_cmdline("libtest/wait", args));
+
+  return TEST_SUCCESS;
+}
+
+static test_return_t wait_help_BINARY(void *)
+{
+  const char *args[]= { "--quiet", "--help", 0 };
+
+  test_true(exec_cmdline("libtest/wait", args));
+
+  return TEST_SUCCESS;
+}
+
+static test_return_t wait_version_BINARY(void *)
+{
+  const char *args[]= { "--quiet", "--version", 0 };
+
+  test_true(exec_cmdline("libtest/wait", args));
 
   return TEST_SUCCESS;
 }
@@ -178,6 +345,7 @@ test_st gearmand_tests[] ={
 test_st memcached_tests[] ={
   {"memcached startup-shutdown", 0, memcached_cycle_test },
   {"memcached(socket file) startup-shutdown", 0, memcached_socket_cycle_test },
+  {"memcached_sasl() startup-shutdown", 0, memcached_sasl_test },
   {0, 0, 0}
 };
 
@@ -190,8 +358,9 @@ test_st environment_tests[] ={
 };
 
 test_st tests_log[] ={
-  {"TEST_SUCCESS", 0, test_success_test },
-  {"TEST_FAILURE", 0, test_failure_test },
+  {"TEST_SUCCESS", false, test_success_test },
+  {"TEST_FAILURE", false, test_failure_test },
+  {"TEST_SUCCESS == 0", false, test_success_equals_one_test },
   {0, 0, 0}
 };
 
@@ -201,12 +370,43 @@ test_st local_log[] ={
   {0, 0, 0}
 };
 
+test_st directories_tests[] ={
+  {"var exists", 0, var_exists_test },
+  {"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/tmp", 0, var_tmp_test },
+  {"var/run", 0, var_run_test },
+  {"var/log", 0, var_log_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 },
+  {0, 0, 0}
+};
+
+test_st comparison_tests[] ={
+  {"_compare(test_return_t)", 0, _compare_test_return_t_test },
+  {"_compare(memcached_return_t)", 0, _compare_memcached_return_t_test },
+  {"_compare(gearman_return_t)", 0, _compare_gearman_return_t_test },
+  {0, 0, 0}
+};
+
+test_st cmdline_tests[] ={
+  {"wait --quiet", 0, wait_BINARY },
+  {"wait --quiet --help", 0, wait_help_BINARY },
+  {"wait --quiet --version", 0, wait_version_BINARY },
+  {0, 0, 0}
+};
+
 collection_st collection[] ={
   {"environment", 0, 0, environment_tests},
   {"return values", 0, 0, tests_log},
   {"local", 0, 0, local_log},
+  {"directories", 0, 0, directories_tests},
+  {"comparison", 0, 0, comparison_tests},
   {"gearmand", 0, 0, gearmand_tests},
   {"memcached", 0, 0, memcached_tests},
+  {"cmdline", 0, 0, cmdline_tests},
   {0, 0, 0, 0}
 };