Merge in trunk.
authorBrian Aker <brian@tangent.org>
Sat, 17 Sep 2011 19:45:35 +0000 (12:45 -0700)
committerBrian Aker <brian@tangent.org>
Sat, 17 Sep 2011 19:45:35 +0000 (12:45 -0700)
40 files changed:
.bzrignore
clients/client_options.h
clients/generator.cc
clients/memcapable.cc
clients/memcat.cc
clients/memcp.cc
clients/memdump.cc
clients/memerror.cc
clients/memflush.cc
clients/memping.cc
clients/memrm.cc
clients/memslap.cc
clients/memstat.cc
clients/utilities.cc
clients/utilities.h
libhashkit/hashkit.cc
libmemcached/assert.hpp
libmemcached/behavior.cc
libmemcached/delete.cc
libmemcached/dump.cc
libmemcached/hosts.cc
libmemcached/protocol/cache.h
libmemcached/return.h
libtest/cmdline.cc
libtest/test.cc
libtest/test.h
m4/pandora_have_libgtest.m4 [deleted file]
support/libmemcached.spec.in
tests/hashkit_functions.cc
tests/include.am
tests/mem_functions.cc
tests/memcapable.cc
tests/memcat.cc [new file with mode: 0644]
tests/memcp.cc [new file with mode: 0644]
tests/memdump.cc [new file with mode: 0644]
tests/memerror.cc [new file with mode: 0644]
tests/memflush.cc [new file with mode: 0644]
tests/memrm.cc [new file with mode: 0644]
tests/memslap.cc
tests/memstat.cc [new file with mode: 0644]

index 3a6e517ac449971e835d39648434e163996baed6..da5a7c17fa4db3d870b65744c4538e4a746e70b3 100644 (file)
@@ -127,3 +127,10 @@ tests/testudp
 tests/var/
 tmp_chroot
 unittests/unittests
+tests/memerror
+tests/memcp
+tests/memdump
+tests/memflush
+tests/memrm
+tests/memstat
+tests/memcat
index 70329051038281b5fa9742b63b2d07afe8bdf955..57aefd2bb4d366c29054611f56230a2c74e93a5d 100644 (file)
@@ -9,12 +9,11 @@
  *
  */
 
-#ifndef __CLIENT_OPTIONS_H__
-#define __CLIENT_OPTIONS_H__
+#pragma once
 
 typedef struct memcached_help_text_st memcached_help_text_st;
 
-typedef enum {
+enum memcached_options {
   OPT_SERVERS= 's',
   OPT_VERSION= 'V',
   OPT_HELP= 'h',
@@ -39,7 +38,6 @@ typedef enum {
   OPT_USERNAME,
   OPT_PASSWD,
   OPT_STAT_ARGS,
+  OPT_QUIET,
   OPT_FILE= 'f'
-} memcached_options;
-
-#endif /* CLIENT_OPTIONS */
+};
index 80b398b251df3a73b0f476f0439a91553f8951b1..011ed3a499bb778ed5963d3695d4cb48088967b3 100644 (file)
@@ -9,12 +9,15 @@
  *
  */
 
-#include "config.h"
+#include <config.h>
 
-#include <stdio.h>
-#include <stdlib.h>
 #include <stdint.h>
-#include <string.h>
+
+#include <cstdio>
+#include <cstdlib>
+#include <cstring>
+#include <iostream>
+#include <unistd.h>
 
 #include "generator.h"
 
@@ -40,13 +43,11 @@ static void get_random_string(char *buffer, size_t size)
 
 void pairs_free(pairs_st *pairs)
 {
-  uint32_t x;
-
-  if (! pairs)
+  if (pairs == NULL)
     return;
 
   /* We free until we hit the null pair we stores during creation */
-  for (x= 0; pairs[x].key; x++)
+  for (uint32_t x= 0; pairs[x].key; x++)
   {
     free(pairs[x].key);
     if (pairs[x].value)
@@ -58,27 +59,30 @@ void pairs_free(pairs_st *pairs)
 
 pairs_st *pairs_generate(uint64_t number_of, size_t value_length)
 {
-  unsigned int x;
-  pairs_st *pairs;
-
-  pairs= (pairs_st*)calloc((size_t)number_of + 1, sizeof(pairs_st));
+  pairs_st *pairs= (pairs_st*)calloc((size_t)number_of + 1, sizeof(pairs_st));
 
-  if (!pairs)
+  if (pairs == NULL)
+  {
     goto error;
+  }
 
-  for (x= 0; x < number_of; x++)
+  for (uint64_t x= 0; x < number_of; x++)
   {
     pairs[x].key= (char *)calloc(100, sizeof(char));
-    if (!pairs[x].key)
+
+    if (pairs[x].key == NULL)
       goto error;
+
     get_random_string(pairs[x].key, 100);
     pairs[x].key_length= 100;
 
     if (value_length)
     {
       pairs[x].value= (char *)calloc(value_length, sizeof(char));
-      if (!pairs[x].value)
+
+      if (pairs[x].value == NULL)
         goto error;
+
       get_random_string(pairs[x].value, value_length);
       pairs[x].value_length= value_length;
     }
@@ -91,6 +95,6 @@ pairs_st *pairs_generate(uint64_t number_of, size_t value_length)
 
   return pairs;
 error:
-    fprintf(stderr, "Memory Allocation failure in pairs_generate.\n");
-    exit(0);
+  std::cerr << "Memory Allocation failure in pairs_generate." << std::endl;
+  exit(EXIT_SUCCESS);
 }
index 1bb7a88a675abbc20cedacccc366331ff57d94d2..2d82f30062b5e79f45968f7c3a706c5b21ad43ce 100644 (file)
@@ -1973,17 +1973,19 @@ int main(int argc, char **argv)
 
 
 
-  while ((cmd= getopt(argc, argv, "t:vch:p:PT:?ab")) != EOF)
+  while ((cmd= getopt(argc, argv, "qt:vch:p:PT:?ab")) != EOF)
   {
     switch (cmd) {
     case 'a':
       tests.ascii= true;
       tests.binary= false;
       break;
+
     case 'b':
       tests.ascii= false;
       tests.binary= true;
       break;
+
     case 't':
       timeout= atoi(optarg);
       if (timeout == 0)
@@ -1992,18 +1994,29 @@ int main(int argc, char **argv)
         return EXIT_FAILURE;
       }
       break;
+
     case 'v': verbose= true;
       break;
+
     case 'c': do_core= true;
       break;
+
     case 'h': hostname= optarg;
       break;
+
     case 'p': port= optarg;
       break;
+
+    case 'q':
+      close_stdio();
+      break;
+
     case 'P': prompt= true;
       break;
+
     case 'T': testname= optarg;
        break;
+
     default:
       fprintf(stderr, "Usage: %s [-h hostname] [-p port] [-c] [-v] [-t n] [-P] [-T testname]'\n"
               "\t-c\tGenerate coredump if a test fails\n"
index 3e073650345750b35b3325855f1b4fe63af77fca..ab482e5d6ad57549b17f06d0352b3b132562f1b4 100644 (file)
@@ -192,6 +192,7 @@ void options_parse(int argc, char *argv[])
     {
       {(OPTIONSTRING)"version", no_argument, NULL, OPT_VERSION},
       {(OPTIONSTRING)"help", no_argument, NULL, OPT_HELP},
+      {(OPTIONSTRING)"quiet", no_argument, NULL, OPT_QUIET},
       {(OPTIONSTRING)"verbose", no_argument, &opt_verbose, OPT_VERBOSE},
       {(OPTIONSTRING)"debug", no_argument, &opt_verbose, OPT_DEBUG},
       {(OPTIONSTRING)"servers", required_argument, NULL, OPT_SERVERS},
@@ -242,6 +243,11 @@ void options_parse(int argc, char *argv[])
     case OPT_FILE:
       opt_file= optarg;
       break;
+
+    case OPT_QUIET:
+      close_stdio();
+      break;
+
     case '?':
       /* getopt_long already printed an error message. */
       exit(1);
index 228362513905beabef0108285301d6c48f3d741f..4f4f8e1097243ac10e4a754ae244a3ae54dca6f7 100644 (file)
@@ -41,7 +41,7 @@
 /* Prototypes */
 static void options_parse(int argc, char *argv[]);
 
-static int opt_binary=0;
+static bool opt_binary= false;
 static int opt_verbose= 0;
 static char *opt_servers= NULL;
 static char *opt_hash= NULL;
@@ -80,19 +80,14 @@ static long strtol_wrapper(const char *nptr, int base, bool *error)
 
 int main(int argc, char *argv[])
 {
-  memcached_st *memc;
-  memcached_return_t rc;
-  memcached_server_st *servers;
-
-  int return_code= 0;
 
   options_parse(argc, argv);
   initialize_sockets();
 
-  memc= memcached_create(NULL);
+  memcached_st *memc= memcached_create(NULL);
   process_hash_option(memc, opt_hash);
 
-  if (!opt_servers)
+  if (opt_servers == NULL)
   {
     char *temp;
 
@@ -102,15 +97,20 @@ int main(int argc, char *argv[])
     }
     else
     {
-      fprintf(stderr, "No Servers provided\n");
-      exit(1);
+      std::cerr << "No Servers provided" << std::endl;
+      exit(EXIT_FAILURE);
     }
   }
 
+  memcached_server_st *servers;
   if (opt_servers)
+  {
     servers= memcached_servers_parse(opt_servers);
+  }
   else
+  {
     servers= memcached_servers_parse(argv[--argc]);
+  }
 
   memcached_server_push(memc, servers);
   memcached_server_list_free(servers);
@@ -135,29 +135,33 @@ int main(int argc, char *argv[])
     }
   }
 
+  int exit_code= EXIT_SUCCESS;
   while (optind < argc)
   {
-    struct stat sbuf;
-    int fd;
-    char *ptr;
-    ssize_t read_length;
-    char *file_buffer_ptr;
-
-    fd= open(argv[optind], O_RDONLY);
+    int fd= open(argv[optind], O_RDONLY);
     if (fd < 0)
     {
-      fprintf(stderr, "memcp: %s: %s\n", argv[optind], strerror(errno));
-      optind++;
+      if (opt_verbose)
+      {
+        fprintf(stderr, "memcp: %s: %s\n", argv[optind], strerror(errno));
+        optind++;
+      }
+      exit_code= EXIT_FAILURE;
       continue;
     }
 
+    struct stat sbuf;
     (void)fstat(fd, &sbuf);
 
-    ptr= rindex(argv[optind], '/');
+    char *ptr= rindex(argv[optind], '/');
     if (ptr)
+    {
       ptr++;
+    }
     else
+    {
       ptr= argv[optind];
+    }
 
     if (opt_verbose)
     {
@@ -168,16 +172,18 @@ int main(int argc, char *argv[])
             ptr, opt_flags, (unsigned long)opt_expires);
     }
 
+    char *file_buffer_ptr;
     if ((file_buffer_ptr= (char *)malloc(sizeof(char) * (size_t)sbuf.st_size)) == NULL)
     {
       fprintf(stderr, "malloc: %s\n", strerror(errno));
-      exit(1);
+      exit(EXIT_FAILURE);
     }
 
+    ssize_t read_length;
     if ((read_length= read(fd, file_buffer_ptr, (size_t)sbuf.st_size)) == -1)
     {
       fprintf(stderr, "read: %s\n", strerror(errno));
-      exit(1);
+      exit(EXIT_FAILURE);
     }
 
     if (read_length != sbuf.st_size)
@@ -186,6 +192,7 @@ int main(int argc, char *argv[])
       exit(1);
     }
 
+    memcached_return_t rc;
     if (opt_method == OPT_ADD)
       rc= memcached_add(memc, ptr, strlen(ptr),
                         file_buffer_ptr, (size_t)sbuf.st_size,
@@ -207,7 +214,7 @@ int main(int argc, char *argv[])
        fprintf(stderr, " system error %s", strerror(memcached_last_error_errno(memc)));
       fprintf(stderr, "\n");
 
-      return_code= -1;
+      exit_code= EXIT_FAILURE;
     }
 
     free(file_buffer_ptr);
@@ -222,14 +229,11 @@ int main(int argc, char *argv[])
   if (opt_hash)
     free(opt_hash);
 
-  return return_code;
+  return exit_code;
 }
 
 static void options_parse(int argc, char *argv[])
 {
-  int option_index= 0;
-  int option_rv;
-
   memcached_programs_help_st help_options[]=
   {
     {0},
@@ -239,6 +243,7 @@ static void options_parse(int argc, char *argv[])
     {
       {(OPTIONSTRING)"version", no_argument, NULL, OPT_VERSION},
       {(OPTIONSTRING)"help", no_argument, NULL, OPT_HELP},
+      {(OPTIONSTRING)"quiet", no_argument, NULL, OPT_QUIET},
       {(OPTIONSTRING)"verbose", no_argument, &opt_verbose, OPT_VERBOSE},
       {(OPTIONSTRING)"debug", no_argument, &opt_verbose, OPT_DEBUG},
       {(OPTIONSTRING)"servers", required_argument, NULL, OPT_SERVERS},
@@ -254,34 +259,45 @@ static void options_parse(int argc, char *argv[])
       {0, 0, 0, 0},
     };
 
+  bool opt_version= false;
+  bool opt_help= false;
+  int option_index= 0;
+
   while (1)
   {
-    option_rv= getopt_long(argc, argv, "Vhvds:", long_options, &option_index);
+    int option_rv= getopt_long(argc, argv, "Vhvds:", long_options, &option_index);
 
-    if (option_rv == -1) break;
+    if (option_rv == -1)
+      break;
 
     switch (option_rv)
     {
     case 0:
       break;
     case OPT_BINARY:
-      opt_binary = 1;
+      opt_binary= true;
       break;
+
     case OPT_VERBOSE: /* --verbose or -v */
-      opt_verbose = OPT_VERBOSE;
+      opt_verbose= OPT_VERBOSE;
       break;
+
     case OPT_DEBUG: /* --debug or -d */
-      opt_verbose = OPT_DEBUG;
+      opt_verbose= OPT_DEBUG;
       break;
+
     case OPT_VERSION: /* --version or -V */
-      version_command(PROGRAM_NAME);
+      opt_version= true;
       break;
+
     case OPT_HELP: /* --help or -h */
-      help_command(PROGRAM_NAME, PROGRAM_DESCRIPTION, long_options, help_options);
+      opt_help= true;
       break;
+
     case OPT_SERVERS: /* --servers or -s */
       opt_servers= strdup(optarg);
       break;
+
     case OPT_FLAG: /* --flag */
       {
         bool strtol_error;
@@ -291,8 +307,9 @@ static void options_parse(int argc, char *argv[])
           fprintf(stderr, "Bad value passed via --flag\n");
           exit(1);
         }
-        break;
       }
+      break;
+
     case OPT_EXPIRE: /* --expire */
       {
         bool strtol_error;
@@ -303,29 +320,53 @@ static void options_parse(int argc, char *argv[])
           exit(1);
         }
       }
+      break;
+
     case OPT_SET:
       opt_method= OPT_SET;
       break;
+
     case OPT_REPLACE:
       opt_method= OPT_REPLACE;
       break;
+
     case OPT_ADD:
       opt_method= OPT_ADD;
       break;
+
     case OPT_HASH:
       opt_hash= strdup(optarg);
       break;
+
     case OPT_USERNAME:
       opt_username= optarg;
       break;
+
     case OPT_PASSWD:
       opt_passwd= optarg;
       break;
-   case '?':
+
+    case OPT_QUIET:
+      close_stdio();
+      break;
+
+    case '?':
       /* getopt_long already printed an error message. */
       exit(1);
     default:
       abort();
     }
   }
+
+  if (opt_version)
+  {
+    version_command(PROGRAM_NAME);
+    exit(EXIT_SUCCESS);
+  }
+
+  if (opt_help)
+  {
+    help_command(PROGRAM_NAME, PROGRAM_DESCRIPTION, long_options, help_options);
+    exit(EXIT_SUCCESS);
+  }
 }
index 2b7b96fa50d13c959330f9af9972963ec3fe285f..fded16f2ae8793e9232ef644cf1f684cb45efc1f 100644 (file)
@@ -35,7 +35,7 @@
 /* Prototypes */
 static void options_parse(int argc, char *argv[]);
 
-static int opt_binary=0;
+static bool opt_binary=0;
 static int opt_verbose= 0;
 static char *opt_servers= NULL;
 static char *opt_hash= NULL;
@@ -43,47 +43,51 @@ static char *opt_username;
 static char *opt_passwd;
 
 /* Print the keys and counter how many were found */
-static memcached_return_t key_printer(const memcached_st *ptr,
+static memcached_return_t key_printer(const memcached_st *,
                                       const char *key, size_t key_length,
-                                      void *context)
+                                      void *)
 {
-  (void)ptr;(void)context;
-  printf("%.*s\n", (uint32_t)key_length, key);
+  std::cout.write(key, key_length);
+  std::cout << std::endl;
 
   return MEMCACHED_SUCCESS;
 }
 
 int main(int argc, char *argv[])
 {
-  memcached_st *memc;
-  memcached_return_t rc;
-  memcached_server_st *servers;
   memcached_dump_fn callbacks[1];
 
   callbacks[0]= &key_printer;
 
   options_parse(argc, argv);
 
-  memc= memcached_create(NULL);
+  memcached_st *memc= memcached_create(NULL);
   process_hash_option(memc, opt_hash);
 
-  if (!opt_servers)
+  if (opt_servers == NULL)
   {
     char *temp;
 
     if ((temp= getenv("MEMCACHED_SERVERS")))
+    {
       opt_servers= strdup(temp);
+    }
     else
     {
-      fprintf(stderr, "No Servers provided\n");
-      exit(1);
+      std::cerr << "No Servers provided" << std::endl;
+      exit(EXIT_FAILURE);
     }
   }
 
+  memcached_server_st *servers;
   if (opt_servers)
+  {
     servers= memcached_servers_parse(opt_servers);
+  }
   else
+  {
     servers= memcached_servers_parse(argv[--argc]);
+  }
 
   memcached_server_push(memc, servers);
   memcached_server_list_free(servers);
@@ -108,35 +112,39 @@ int main(int argc, char *argv[])
     }
   }
 
-  rc= memcached_dump(memc, callbacks, NULL, 1);
+  memcached_return_t rc= memcached_dump(memc, callbacks, NULL, 1);
 
-  if (rc != MEMCACHED_SUCCESS)
+  int exit_code= EXIT_SUCCESS;
+  if (memcached_failed(rc))
   {
-    fprintf(stderr, "memdump: memcache error %s", memcached_strerror(memc, rc));
-    if (memcached_last_error_errno(memc))
-      fprintf(stderr, " system error %s", strerror(memcached_last_error_errno(memc)));
-    fprintf(stderr, "\n");
+    if (opt_verbose)
+    {
+      std::cerr << "Failed to dump keys: " << memcached_last_error_message(memc) << std::endl;
+    }
+    exit_code= EXIT_FAILURE;
   }
 
   memcached_free(memc);
 
   if (opt_servers)
+  {
     free(opt_servers);
+  }
   if (opt_hash)
+  {
     free(opt_hash);
+  }
 
-  return EXIT_SUCCESS;
+  return exit_code;
 }
 
 static void options_parse(int argc, char *argv[])
 {
-  int option_index= 0;
-  int option_rv;
-
   static struct option long_options[]=
     {
       {(OPTIONSTRING)"version", no_argument, NULL, OPT_VERSION},
       {(OPTIONSTRING)"help", no_argument, NULL, OPT_HELP},
+      {(OPTIONSTRING)"quiet", no_argument, NULL, OPT_QUIET},
       {(OPTIONSTRING)"verbose", no_argument, &opt_verbose, OPT_VERBOSE},
       {(OPTIONSTRING)"debug", no_argument, &opt_verbose, OPT_DEBUG},
       {(OPTIONSTRING)"servers", required_argument, NULL, OPT_SERVERS},
@@ -147,9 +155,12 @@ static void options_parse(int argc, char *argv[])
       {0, 0, 0, 0}
     };
 
+  int option_index= 0;
+  bool opt_version= false;
+  bool opt_help= false;
   while (1)
   {
-    option_rv= getopt_long(argc, argv, "Vhvds:", long_options, &option_index);
+    int option_rv= getopt_long(argc, argv, "Vhvds:", long_options, &option_index);
 
     if (option_rv == -1) break;
 
@@ -157,33 +168,47 @@ static void options_parse(int argc, char *argv[])
     {
     case 0:
       break;
+
     case OPT_BINARY:
-      opt_binary = 1;
+      opt_binary= true;
       break;
+
     case OPT_VERBOSE: /* --verbose or -v */
-      opt_verbose = OPT_VERBOSE;
+      opt_verbose= OPT_VERBOSE;
       break;
+
     case OPT_DEBUG: /* --debug or -d */
-      opt_verbose = OPT_DEBUG;
+      opt_verbose= OPT_DEBUG;
       break;
+
     case OPT_VERSION: /* --version or -V */
-      version_command(PROGRAM_NAME);
+      opt_verbose= true;
       break;
+
     case OPT_HELP: /* --help or -h */
-      help_command(PROGRAM_NAME, PROGRAM_DESCRIPTION, long_options, NULL);
+      opt_help= true;
       break;
+
     case OPT_SERVERS: /* --servers or -s */
       opt_servers= strdup(optarg);
       break;
+
     case OPT_HASH:
       opt_hash= strdup(optarg);
       break;
+
     case OPT_USERNAME:
        opt_username= optarg;
        break;
+
     case OPT_PASSWD:
        opt_passwd= optarg;
        break;
+
+    case OPT_QUIET:
+      close_stdio();
+      break;
+
     case '?':
       /* getopt_long already printed an error message. */
       exit(1);
@@ -191,4 +216,16 @@ static void options_parse(int argc, char *argv[])
       abort();
     }
   }
+
+  if (opt_version)
+  {
+    version_command(PROGRAM_NAME);
+    exit(EXIT_SUCCESS);
+  }
+
+  if (opt_help)
+  {
+    help_command(PROGRAM_NAME, PROGRAM_DESCRIPTION, long_options, NULL);
+    exit(EXIT_SUCCESS);
+  }
 }
index c30dd2e9d9f69ab307d05b98672f4da95150082b..fd4238a51eb3dd256fa6530510d9605c12d1aceb 100644 (file)
  */
 #include "config.h"
 
-#include <stdio.h>
 #include <inttypes.h>
-#include <string.h>
-#include <unistd.h>
+#include <cstdio>
+#include <cstdlib>
+#include <cstring>
 #include <getopt.h>
-#include <stdlib.h>
+#include <iostream>
+#include <unistd.h>
+
 #include <libmemcached/memcached.h>
 
 #include "utilities.h"
@@ -31,21 +33,22 @@ static int opt_verbose= 0;
 
 int main(int argc, char *argv[])
 {
-  unsigned long value;
   options_parse(argc, argv);
 
   if (argc != 2)
+  {
     return EXIT_FAILURE;
+  }
 
-  value= strtoul(argv[1], (char **) NULL, 10);
+  unsigned long value= strtoul(argv[1], (char **) NULL, 10);
 
   if (value < MEMCACHED_MAXIMUM_RETURN)
   {
-    printf("%s\n", memcached_strerror(NULL, (memcached_return_t)value));
+    std::cout << memcached_strerror(NULL, (memcached_return_t)value) << std::endl;
   }
   else
   {
-    fprintf(stderr, "Unknown Error Code\n");
+    std::cerr << memcached_strerror(NULL, MEMCACHED_MAXIMUM_RETURN) << std::endl;
     return EXIT_FAILURE;
   }
 
@@ -55,48 +58,70 @@ int main(int argc, char *argv[])
 
 void options_parse(int argc, char *argv[])
 {
-  int option_index= 0;
-  int option_rv;
-
-  memcached_programs_help_st help_options[]=
-  {
-    {0},
-  };
-
   static struct option long_options[]=
     {
       {(OPTIONSTRING)"version", no_argument, NULL, OPT_VERSION},
       {(OPTIONSTRING)"help", no_argument, NULL, OPT_HELP},
+      {(OPTIONSTRING)"quiet", no_argument, NULL, OPT_QUIET},
       {(OPTIONSTRING)"verbose", no_argument, &opt_verbose, OPT_VERBOSE},
       {(OPTIONSTRING)"debug", no_argument, &opt_verbose, OPT_DEBUG},
       {0, 0, 0, 0},
     };
 
+  bool opt_version= false;
+  bool opt_help= false;
+  int option_index= 0;
   while (1) 
   {
-    option_rv= getopt_long(argc, argv, "Vhvds:", long_options, &option_index);
-    if (option_rv == -1) break;
+    int option_rv= getopt_long(argc, argv, "Vhvds:", long_options, &option_index);
+    if (option_rv == -1)
+    {
+      break;
+    }
+
     switch (option_rv)
     {
     case 0:
       break;
+
     case OPT_VERBOSE: /* --verbose or -v */
       opt_verbose = OPT_VERBOSE;
       break;
+
     case OPT_DEBUG: /* --debug or -d */
       opt_verbose = OPT_DEBUG;
       break;
+
     case OPT_VERSION: /* --version or -V */
-      version_command(PROGRAM_NAME);
+      opt_version= true;
       break;
+
     case OPT_HELP: /* --help or -h */
-      help_command(PROGRAM_NAME, PROGRAM_DESCRIPTION, long_options, help_options);
+      opt_help= true;
       break;
+
+    case OPT_QUIET:
+      close_stdio();
+      break;
+
     case '?':
       /* getopt_long already printed an error message. */
-      exit(1);
+      exit(EXIT_FAILURE);
+
     default:
       abort();
     }
   }
+
+  if (opt_version)
+  {
+    version_command(PROGRAM_NAME);
+    exit(EXIT_SUCCESS);
+  }
+
+  if (opt_help)
+  {
+    help_command(PROGRAM_NAME, PROGRAM_DESCRIPTION, long_options, NULL);
+    exit(EXIT_SUCCESS);
+  }
 }
index 1ef1bfde52629e9775573c8f6ef57691c46503a0..81bb2574f27190e64a1d6dba4ddcaa8623ec33cb 100644 (file)
@@ -35,28 +35,26 @@ void options_parse(int argc, char *argv[]);
 
 int main(int argc, char *argv[])
 {
-  memcached_st *memc;
-  memcached_return_t rc;
-  memcached_server_st *servers;
-
   options_parse(argc, argv);
 
-  if (!opt_servers)
+  if (opt_servers == false)
   {
     char *temp;
 
     if ((temp= getenv("MEMCACHED_SERVERS")))
+    {
       opt_servers= strdup(temp);
+    }
     else
     {
-      fprintf(stderr, "No Servers provided\n");
-      exit(1);
+      std::cerr << "No Servers provided" << std::endl;
+      exit(EXIT_FAILURE);
     }
   }
 
-  memc= memcached_create(NULL);
+  memcached_st *memc= memcached_create(NULL);
 
-  servers= memcached_servers_parse(opt_servers);
+  memcached_server_st *servers= memcached_servers_parse(opt_servers);
   memcached_server_push(memc, servers);
   memcached_server_list_free(servers);
   memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL,
@@ -80,14 +78,10 @@ int main(int argc, char *argv[])
     }
   }
 
-  rc = memcached_flush(memc, opt_expire);
+  memcached_return_t rc = memcached_flush(memc, opt_expire);
   if (rc != MEMCACHED_SUCCESS)
   {
-    fprintf(stderr, "memflush: memcache error %s",
-           memcached_strerror(memc, rc));
-    if (memcached_last_error_errno(memc))
-      fprintf(stderr, " system error %s", strerror(memcached_last_error_errno(memc)));
-    fprintf(stderr, "\n");
+    std::cerr << memcached_last_error_message(memc) << std::endl;
   }
 
   memcached_free(memc);
@@ -100,15 +94,11 @@ int main(int argc, char *argv[])
 
 void options_parse(int argc, char *argv[])
 {
-  memcached_programs_help_st help_options[]=
-  {
-    {0},
-  };
-
   static struct option long_options[]=
   {
     {(OPTIONSTRING)"version", no_argument, NULL, OPT_VERSION},
     {(OPTIONSTRING)"help", no_argument, NULL, OPT_HELP},
+    {(OPTIONSTRING)"quiet", no_argument, NULL, OPT_QUIET},
     {(OPTIONSTRING)"verbose", no_argument, &opt_verbose, OPT_VERBOSE},
     {(OPTIONSTRING)"debug", no_argument, &opt_verbose, OPT_DEBUG},
     {(OPTIONSTRING)"servers", required_argument, NULL, OPT_SERVERS},
@@ -118,49 +108,77 @@ void options_parse(int argc, char *argv[])
     {(OPTIONSTRING)"password", required_argument, NULL, OPT_PASSWD},
     {0, 0, 0, 0},
   };
-  int option_index= 0;
-  int option_rv;
 
+  bool opt_version= false;
+  bool opt_help= false;
+  int option_index= 0;
   while (1)
   {
-    option_rv= getopt_long(argc, argv, "Vhvds:", long_options, &option_index);
+    int option_rv= getopt_long(argc, argv, "Vhvds:", long_options, &option_index);
     if (option_rv == -1) break;
     switch (option_rv)
     {
     case 0:
       break;
+
     case OPT_BINARY:
-      opt_binary = 1;
+      opt_binary= true;
       break;
+
     case OPT_VERBOSE: /* --verbose or -v */
-      opt_verbose = OPT_VERBOSE;
+      opt_verbose= OPT_VERBOSE;
       break;
+
     case OPT_DEBUG: /* --debug or -d */
-      opt_verbose = OPT_DEBUG;
+      opt_verbose= OPT_DEBUG;
       break;
+
     case OPT_VERSION: /* --version or -V */
-      version_command(PROGRAM_NAME);
+      opt_version= true;
       break;
+
     case OPT_HELP: /* --help or -h */
-      help_command(PROGRAM_NAME, PROGRAM_DESCRIPTION, long_options, help_options);
+      opt_help= true;
       break;
+
     case OPT_SERVERS: /* --servers or -s */
       opt_servers= strdup(optarg);
       break;
+
     case OPT_EXPIRE: /* --expire */
       opt_expire= (time_t)strtoll(optarg, (char **)NULL, 10);
       break;
+
     case OPT_USERNAME:
       opt_username= optarg;
       break;
+
     case OPT_PASSWD:
       opt_passwd= optarg;
       break;
+
+    case OPT_QUIET:
+      close_stdio();
+      break;
+
     case '?':
       /* getopt_long already printed an error message. */
-      exit(1);
+      exit(EXIT_FAILURE);
+
     default:
       abort();
     }
   }
+
+  if (opt_version)
+  {
+    version_command(PROGRAM_NAME);
+    exit(EXIT_SUCCESS);
+  }
+
+  if (opt_help)
+  {
+    help_command(PROGRAM_NAME, PROGRAM_DESCRIPTION, long_options, NULL);
+    exit(EXIT_SUCCESS);
+  }
 }
index e2253471599b5a37569ab6bba2a5669c6d446ef7..bcc07cd3921397661ad44941a4cf9d2ec4c32a42 100644 (file)
@@ -21,7 +21,7 @@
 
 #include <iostream>
 
-static int opt_binary= 0;
+static bool opt_binary= false;
 static int opt_verbose= 0;
 static time_t opt_expire= 0;
 static char *opt_servers= NULL;
@@ -88,6 +88,7 @@ void options_parse(int argc, char *argv[])
   {
     {(OPTIONSTRING)"version", no_argument, NULL, OPT_VERSION},
     {(OPTIONSTRING)"help", no_argument, NULL, OPT_HELP},
+    {(OPTIONSTRING)"quiet", no_argument, NULL, OPT_QUIET},
     {(OPTIONSTRING)"verbose", no_argument, &opt_verbose, OPT_VERBOSE},
     {(OPTIONSTRING)"debug", no_argument, &opt_verbose, OPT_DEBUG},
     {(OPTIONSTRING)"servers", required_argument, NULL, OPT_SERVERS},
@@ -97,44 +98,61 @@ void options_parse(int argc, char *argv[])
     {(OPTIONSTRING)"password", required_argument, NULL, OPT_PASSWD},
     {0, 0, 0, 0},
   };
-  int option_index= 0;
-  int option_rv;
 
+  bool opt_version= false;
+  bool opt_help= false;
+  int option_index= 0;
   while (1)
   {
-    option_rv= getopt_long(argc, argv, "Vhvds:", long_options, &option_index);
+    int option_rv= getopt_long(argc, argv, "Vhvds:", long_options, &option_index);
+
     if (option_rv == -1) break;
+
     switch (option_rv)
     {
     case 0:
       break;
+
     case OPT_BINARY:
-      opt_binary = 1;
+      opt_binary= true;
       break;
+
     case OPT_VERBOSE: /* --verbose or -v */
       opt_verbose = OPT_VERBOSE;
       break;
+
     case OPT_DEBUG: /* --debug or -d */
       opt_verbose = OPT_DEBUG;
       break;
+
     case OPT_VERSION: /* --version or -V */
       version_command(PROGRAM_NAME);
       break;
+
     case OPT_HELP: /* --help or -h */
       help_command(PROGRAM_NAME, PROGRAM_DESCRIPTION, long_options, help_options);
       break;
+
     case OPT_SERVERS: /* --servers or -s */
       opt_servers= strdup(optarg);
       break;
+
     case OPT_EXPIRE: /* --expire */
       opt_expire= (time_t)strtoll(optarg, (char **)NULL, 10);
       break;
+
     case OPT_USERNAME:
       opt_username= optarg;
       break;
+
     case OPT_PASSWD:
       opt_passwd= optarg;
       break;
+
+    case OPT_QUIET:
+      close_stdio();
+      break;
+
     case '?':
       /* getopt_long already printed an error message. */
       exit(1);
@@ -142,4 +160,16 @@ void options_parse(int argc, char *argv[])
       abort();
     }
   }
+
+  if (opt_version)
+  {
+    version_command(PROGRAM_NAME);
+    exit(EXIT_SUCCESS);
+  }
+
+  if (opt_help)
+  {
+    help_command(PROGRAM_NAME, PROGRAM_DESCRIPTION, long_options, help_options);
+    exit(EXIT_SUCCESS);
+  }
 }
index 73a29de96d9fbd9e646180f8c3f35edcce0deab2..cbfcd2418e64a577a9096e7a0991fc8edb02cf23 100644 (file)
@@ -37,11 +37,8 @@ static void options_parse(int argc, char *argv[]);
 int main(int argc, char *argv[])
 {
   memcached_st *memc;
-  memcached_return_t rc;
   memcached_server_st *servers;
 
-  int return_code= 0;
-
   options_parse(argc, argv);
   initialize_sockets();
 
@@ -50,7 +47,9 @@ int main(int argc, char *argv[])
     char *temp;
 
     if ((temp= getenv("MEMCACHED_SERVERS")))
+    {
       opt_servers= strdup(temp);
+    }
     else
     {
       std::cerr << "No Servers provided" << std::endl;
@@ -85,26 +84,39 @@ int main(int argc, char *argv[])
     }
   }
 
+  int return_code= EXIT_SUCCESS;
+
   while (optind < argc)
   {
-    if (opt_verbose)
+    memcached_return_t rc= memcached_delete(memc, argv[optind], strlen(argv[optind]), opt_expire);
+
+    if (rc == MEMCACHED_NOTFOUND)
     {
-      std::cout << "key: " << argv[optind] << std::endl;
-      std::cout << "expires: " << opt_expire << std::endl;
+      if (opt_verbose)
+      {
+        std::cerr << "Could not find key \"" << argv[optind] << "\"" << std::endl;
+      }
     }
-    rc= memcached_delete(memc, argv[optind], strlen(argv[optind]), opt_expire);
-
-    if (memcached_failed(rc))
+    else if (memcached_failed(rc))
     {
-      std::cerr << PROGRAM_NAME << ": " << argv[optind] << ": error " << memcached_strerror(memc, rc) << std::endl; 
-
-      if (memcached_last_error_errno(memc))
+      if (opt_verbose)
       {
-        std::cerr << " system error " << strerror(memcached_last_error_errno(memc));
+        std::cerr << "Failed to delete key \"" << argv[optind] << "\" :" <<  memcached_last_error_message(memc) << std::endl;
       }
-      std::cerr << std::endl;
 
-      return_code= -1;
+      return_code= EXIT_FAILURE;
+    }
+    else // success
+    {
+      if (opt_verbose)
+      {
+        std::cout << "Deleted key " << argv[optind];
+        if (opt_expire)
+        {
+          std::cout << " expires: " << opt_expire << std::endl;
+        }
+        std::cout << std::endl;
+      }
     }
 
     optind++;
@@ -113,10 +125,14 @@ int main(int argc, char *argv[])
   memcached_free(memc);
 
   if (opt_servers)
+  {
     free(opt_servers);
+  }
 
   if (opt_hash)
+  {
     free(opt_hash);
+  }
 
   return return_code;
 }
@@ -133,6 +149,7 @@ static void options_parse(int argc, char *argv[])
   {
     {(OPTIONSTRING)"version", no_argument, NULL, OPT_VERSION},
     {(OPTIONSTRING)"help", no_argument, NULL, OPT_HELP},
+    {(OPTIONSTRING)"quiet", no_argument, NULL, OPT_QUIET},
     {(OPTIONSTRING)"verbose", no_argument, &opt_verbose, OPT_VERBOSE},
     {(OPTIONSTRING)"debug", no_argument, &opt_verbose, OPT_DEBUG},
     {(OPTIONSTRING)"servers", required_argument, NULL, OPT_SERVERS},
@@ -143,52 +160,86 @@ static void options_parse(int argc, char *argv[])
     {(OPTIONSTRING)"password", required_argument, NULL, OPT_PASSWD},
     {0, 0, 0, 0},
   };
+
+  bool opt_version= false;
+  bool opt_help= false;
   int option_index= 0;
-  int option_rv;
 
   while (1)
   {
-    option_rv= getopt_long(argc, argv, "Vhvds:", long_options, &option_index);
-    if (option_rv == -1) break;
+    int option_rv= getopt_long(argc, argv, "Vhvds:", long_options, &option_index);
+    if (option_rv == -1) 
+    {
+      break;
+    }
+
     switch (option_rv)
     {
     case 0:
       break;
+
     case OPT_BINARY:
       opt_binary = 1;
       break;
+
     case OPT_VERBOSE: /* --verbose or -v */
       opt_verbose = OPT_VERBOSE;
       break;
+
     case OPT_DEBUG: /* --debug or -d */
       opt_verbose = OPT_DEBUG;
       break;
+
     case OPT_VERSION: /* --version or -V */
-      version_command(PROGRAM_NAME);
+      opt_version= true;
       break;
+
     case OPT_HELP: /* --help or -h */
-      help_command(PROGRAM_NAME, PROGRAM_DESCRIPTION, long_options, help_options);
+      opt_help= true;
       break;
+
     case OPT_SERVERS: /* --servers or -s */
       opt_servers= strdup(optarg);
       break;
+
     case OPT_EXPIRE: /* --expire */
       opt_expire= (time_t)strtoll(optarg, (char **)NULL, 10);
       break;
+
     case OPT_HASH:
       opt_hash= strdup(optarg);
       break;
+
     case OPT_USERNAME:
       opt_username= optarg;
       break;
+
     case OPT_PASSWD:
       opt_passwd= optarg;
       break;
+
+    case OPT_QUIET:
+      close_stdio();
+      break;
+
     case '?':
       /* getopt_long already printed an error message. */
-      exit(1);
+      exit(EXIT_SUCCESS);
+
     default:
       abort();
     }
   }
+
+  if (opt_version)
+  {
+    version_command(PROGRAM_NAME);
+    exit(EXIT_SUCCESS);
+  }
+
+  if (opt_help)
+  {
+    help_command(PROGRAM_NAME, PROGRAM_DESCRIPTION, long_options, help_options);
+    exit(EXIT_SUCCESS);
+  }
 }
index 095cd08817b74e59804347e159227f1604f98e32..f00ba45764ed24bf43b3e762dbe5dab0b9668dca 100644 (file)
@@ -51,6 +51,7 @@
 #include <sys/time.h>
 #include <sys/types.h>
 #include <sys/types.h>
+#include <unistd.h>
 
 #include <libmemcached/memcached.h>
 
@@ -141,7 +142,7 @@ pairs_st *load_create_data(memcached_st *memc, unsigned int number_of,
                            unsigned int *actual_loaded);
 void flush_all(memcached_st *memc);
 
-static int opt_binary= 0;
+static bool opt_binary= 0;
 static int opt_verbose= 0;
 static int opt_flush= 0;
 static int opt_non_blocking_io= 0;
@@ -360,6 +361,7 @@ void options_parse(int argc, char *argv[])
     {
       {(OPTIONSTRING)"concurrency", required_argument, NULL, OPT_SLAP_CONCURRENCY},
       {(OPTIONSTRING)"debug", no_argument, &opt_verbose, OPT_DEBUG},
+      {(OPTIONSTRING)"quiet", no_argument, NULL, OPT_QUIET},
       {(OPTIONSTRING)"execute-number", required_argument, NULL, OPT_SLAP_EXECUTE_NUMBER},
       {(OPTIONSTRING)"flag", no_argument, &opt_displayflag, OPT_FLAG},
       {(OPTIONSTRING)"flush", no_argument, &opt_flush, OPT_FLUSH},
@@ -376,13 +378,15 @@ void options_parse(int argc, char *argv[])
       {0, 0, 0, 0},
     };
 
+  bool opt_help= false;
+  bool opt_version= false;
   int option_index= 0;
-  int option_rv;
-
   while (1)
   {
-    option_rv= getopt_long(argc, argv, "Vhvds:", long_options, &option_index);
+    int option_rv= getopt_long(argc, argv, "Vhvds:", long_options, &option_index);
+
     if (option_rv == -1) break;
+
     switch (option_rv)
     {
     case 0:
@@ -399,11 +403,11 @@ void options_parse(int argc, char *argv[])
       break;
 
     case OPT_BINARY:
-      opt_binary = 1;
+      opt_binary= true;
       break;
 
     case OPT_VERBOSE: /* --verbose or -v */
-      opt_verbose = OPT_VERBOSE;
+      opt_verbose= OPT_VERBOSE;
       break;
 
     case OPT_DEBUG: /* --debug or -d */
@@ -411,11 +415,11 @@ void options_parse(int argc, char *argv[])
       break;
 
     case OPT_VERSION: /* --version or -V */
-      version_command(PROGRAM_NAME);
+      opt_version= true;
       break;
 
     case OPT_HELP: /* --help or -h */
-      help_command(PROGRAM_NAME, PROGRAM_DESCRIPTION, long_options, help_options);
+      opt_help= true;
       break;
 
     case OPT_SERVERS: /* --servers or -s */
@@ -423,28 +427,28 @@ void options_parse(int argc, char *argv[])
       break;
 
     case OPT_SLAP_TEST:
-      if (!strcmp(optarg, "get"))
+      if (strcmp(optarg, "get") == 0)
       {
         if (opt_udp_io == 1)
         {
           fprintf(stderr, "You can not run a get test in UDP mode. UDP mode "
                   "does not currently support get ops.\n");
-          exit(1);
+          exit(EXIT_FAILURE);
         }
         opt_test= GET_TEST ;
       }
-      else if (!strcmp(optarg, "set"))
+      else if (strcmp(optarg, "set") == 0)
       {
         opt_test= SET_TEST;
       }
-      else if (!strcmp(optarg, "mget"))
+      else if (strcmp(optarg, "mget") == 0)
       {
         opt_test= MGET_TEST;
       }
       else
       {
         fprintf(stderr, "Your test, %s, is not a known test\n", optarg);
-        exit(1);
+        exit(EXIT_FAILURE);
       }
       break;
 
@@ -460,16 +464,33 @@ void options_parse(int argc, char *argv[])
       opt_createial_load= (unsigned int)strtoul(optarg, (char **)NULL, 10);
       break;
 
+    case OPT_QUIET:
+      close_stdio();
+      break;
+
+
     case '?':
       /* getopt_long already printed an error message. */
-      exit(1);
+      exit(EXIT_FAILURE);
 
     default:
       abort();
     }
   }
 
-  if ((opt_test == GET_TEST or opt_test == MGET_TEST) && opt_createial_load == 0)
+  if (opt_version)
+  {
+    version_command(PROGRAM_NAME);
+    exit(EXIT_SUCCESS);
+  }
+
+  if (opt_help)
+  {
+    help_command(PROGRAM_NAME, PROGRAM_DESCRIPTION, long_options, help_options);
+    exit(EXIT_SUCCESS);
+  }
+
+  if ((opt_test == GET_TEST or opt_test == MGET_TEST) and opt_createial_load == 0)
     opt_createial_load= DEFAULT_INITIAL_LOAD;
 
   if (opt_execute_number == 0)
index a3b85108c4f95363db42aee1aa92a9e1a4898383..8036ea186ada1b38a46aeb725ead246740d1e4cd 100644 (file)
  *          Brian Aker
  *          Toru Maesaka
  */
-#include "config.h"
+#include <config.h>
 
 #include <cstdio>
 #include <cstring>
 #include <ctime>
+#include <iostream>
 #include <fcntl.h>
 #include <getopt.h>
+#include <unistd.h>
 #include <sys/stat.h>
 #include <sys/time.h>
 #include <sys/types.h>
@@ -49,6 +51,7 @@ static struct option long_options[]=
   {(OPTIONSTRING)"args", required_argument, NULL, OPT_STAT_ARGS},
   {(OPTIONSTRING)"version", no_argument, NULL, OPT_VERSION},
   {(OPTIONSTRING)"help", no_argument, NULL, OPT_HELP},
+  {(OPTIONSTRING)"quiet", no_argument, NULL, OPT_QUIET},
   {(OPTIONSTRING)"verbose", no_argument, &opt_verbose, OPT_VERBOSE},
   {(OPTIONSTRING)"debug", no_argument, &opt_verbose, OPT_DEBUG},
   {(OPTIONSTRING)"servers", required_argument, NULL, OPT_SERVERS},
@@ -83,17 +86,17 @@ int main(int argc, char *argv[])
   options_parse(argc, argv);
   initialize_sockets();
 
-  if (! opt_servers)
+  if (opt_servers == false)
   {
     char *temp;
-
     if ((temp= getenv("MEMCACHED_SERVERS")))
+    {
       opt_servers= strdup(temp);
+    }
     else
     {
-      fprintf(stderr, "No Servers provided\n\n");
-      help_command(PROGRAM_NAME, PROGRAM_DESCRIPTION, long_options, 0);
-      exit(1);
+      std::cerr << "No Servers provided" << std::endl;
+      return EXIT_FAILURE;
     }
   }
 
@@ -307,38 +310,54 @@ static void options_parse(int argc, char *argv[])
   };
 
   int option_index= 0;
-  int option_rv;
 
+  bool opt_version= false;
+  bool opt_help= false;
   while (1) 
   {
-    option_rv= getopt_long(argc, argv, "Vhvds:a", long_options, &option_index);
-    if (option_rv == -1) break;
+    int option_rv= getopt_long(argc, argv, "Vhvds:a", long_options, &option_index);
+
+    if (option_rv == -1)
+      break;
+
     switch (option_rv)
     {
     case 0:
       break;
+
     case OPT_VERBOSE: /* --verbose or -v */
       opt_verbose = OPT_VERBOSE;
       break;
+
     case OPT_DEBUG: /* --debug or -d */
       opt_verbose = OPT_DEBUG;
       break;
+
     case OPT_VERSION: /* --version or -V */
-      version_command(PROGRAM_NAME);
+      opt_version= true;
       break;
+
     case OPT_HELP: /* --help or -h */
-      help_command(PROGRAM_NAME, PROGRAM_DESCRIPTION, long_options, help_options);
+      opt_help= true;
       break;
+
     case OPT_SERVERS: /* --servers or -s */
       opt_servers= strdup(optarg);
       break;
+
     case OPT_STAT_ARGS:
       stat_args= strdup(optarg);
       break;
+
     case OPT_ANALYZE: /* --analyze or -a */
       opt_analyze= OPT_ANALYZE;
       analyze_mode= (optarg) ? strdup(optarg) : NULL;
       break;
+
+    case OPT_QUIET:
+      close_stdio();
+      break;
+
     case '?':
       /* getopt_long already printed an error message. */
       exit(1);
@@ -346,4 +365,16 @@ static void options_parse(int argc, char *argv[])
       abort();
     }
   }
+
+  if (opt_version)
+  {
+    version_command(PROGRAM_NAME);
+    exit(EXIT_SUCCESS);
+  }
+
+  if (opt_help)
+  {
+    help_command(PROGRAM_NAME, PROGRAM_DESCRIPTION, long_options, help_options);
+    exit(EXIT_SUCCESS);
+  }
 }
index 97c3078377789040772bbe3b4176e9a19dc6d0a5..4dfc15bbc80f9a66a9e9e8ae7d54f597136e169c 100644 (file)
@@ -8,12 +8,18 @@
  * Summary:
  *
  */
-#include "config.h"
+#include <config.h>
 
 #include <clients/utilities.h>
+
 #include <cstdio>
+#include <cstdlib>
 #include <cstring>
 #include <ctype.h>
+#include <fcntl.h>
+#include <sys/stat.h>
+#include <sys/types.h>
+#include <unistd.h>
 
 
 long int timedif(struct timeval a, struct timeval b)
@@ -30,9 +36,41 @@ long int timedif(struct timeval a, struct timeval b)
 void version_command(const char *command_name)
 {
   printf("%s v%u.%u\n", command_name, 1U, 0U);
-  exit(0);
+  exit(EXIT_SUCCESS);
 }
 
+void close_stdio(void)
+{
+  int fd;
+  if ((fd = open("/dev/null", O_RDWR, 0)) < 0)
+  {
+    return;
+  }
+  else
+  {
+    if (dup2(fd, STDIN_FILENO) < 0)
+    {
+      return;
+    }
+
+    if (dup2(fd, STDOUT_FILENO) < 0)
+    {
+      return;
+    }
+
+    if (dup2(fd, STDERR_FILENO) < 0)
+    {
+      return;
+    }
+
+    if (fd > STDERR_FILENO)
+    {
+      close(fd);
+    }
+  }
+}
+
+
 static const char *lookup_help(memcached_options option)
 {
   switch (option)
@@ -41,6 +79,7 @@ static const char *lookup_help(memcached_options option)
   case OPT_VERSION: return("Display the version of the application and then exit.");
   case OPT_HELP: return("Display this message and then exit.");
   case OPT_VERBOSE: return("Give more details on the progression of the application.");
+  case OPT_QUIET: return("stderr and stdin will be closed at application startup.");
   case OPT_DEBUG: return("Provide output only useful for debugging.");
   case OPT_FLAG: return("Provide flag information for storage operation.");
   case OPT_EXPIRE: return("Set the expire option for the object.");
@@ -91,7 +130,7 @@ void help_command(const char *command_name, const char *description,
   }
 
   printf("\n");
-  exit(0);
+  exit(EXIT_SUCCESS);
 }
 
 void process_hash_option(memcached_st *memc, char *opt_hash)
@@ -116,14 +155,14 @@ void process_hash_option(memcached_st *memc, char *opt_hash)
   else
   {
     fprintf(stderr, "hash: type not recognized %s\n", opt_hash);
-    exit(1);
+    exit(EXIT_FAILURE);
   }
 
   rc= memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_HASH, set);
   if (rc != MEMCACHED_SUCCESS)
   {
     fprintf(stderr, "hash: memcache error %s\n", memcached_strerror(memc, rc));
-    exit(1);
+    exit(EXIT_FAILURE);
   }
 }
 
index 685be6a5443d07d693ff3b1c5f6838b72446791f..0bac61a75aac155900181e821bb2339670e7139a 100644 (file)
@@ -58,6 +58,7 @@ void process_hash_option(memcached_st *memc, char *opt_hash);
 bool initialize_sasl(memcached_st *memc, char *user, char *password);
 void shutdown_sasl(void);
 void initialize_sockets(void);
+void close_stdio(void);
 
 #ifdef __cplusplus
 } // extern "C"
index 7f3514d1062de0c25c42927c39586e31e884411a..96e39515efe9dde16cdbce1bdf43a39209ceb1e0 100644 (file)
@@ -23,7 +23,7 @@ static inline hashkit_st *_hashkit_create(hashkit_st *self)
 {
   if (not self)
   {
-    self= new hashkit_st;
+    self= (hashkit_st*)calloc(1, sizeof(hashkit_st));
     if (not self)
     {
       return NULL;
@@ -55,7 +55,7 @@ void hashkit_free(hashkit_st *self)
 {
   if (hashkit_is_allocated(self))
   {
-    delete self;
+    free(self);
   }
 }
 
index acd0198e3df52848cefa876a36068ea822f0a730..787d844adb414e51a165af7a0d382b85fe7a3b5e 100644 (file)
@@ -41,7 +41,7 @@
 #include <cstdio>
 
 #ifdef NDEBUG
-#define        assert(__expr, __mesg)  ((void)0)
+#define assert_msg(__expr, __mesg) (void)(__expr); (void)(__mesg);
 #else
 
 #define assert_msg(__expr, __mesg) \
index 2a1e75372f89c71f7296a56338460f88b8c88b27..6036aebd95a0dc485a335dd4c22e76ac33ea34ce 100644 (file)
@@ -250,10 +250,10 @@ memcached_return_t memcached_behavior_set(memcached_st *ptr,
 
   case MEMCACHED_BEHAVIOR_MAX:
   default:
-    /* Shouldn't get here */
-    assert_msg(0, "Invalid behavior passed to memcached_behavior_set()");
-    return memcached_set_error(*ptr, MEMCACHED_INVALID_ARGUMENTS, MEMCACHED_AT,
-                               memcached_literal_param("Invalid behavior passed to memcached_behavior_set()"));
+      /* Shouldn't get here */
+      assert_msg(0, "Invalid behavior passed to memcached_behavior_set()");
+      return memcached_set_error(*ptr, MEMCACHED_INVALID_ARGUMENTS, MEMCACHED_AT,
+                                 memcached_literal_param("Invalid behavior passed to memcached_behavior_set()"));
   }
 
   return MEMCACHED_SUCCESS;
index ea3b602539cf557558869e2feb43a67360caf78d..7348dabe2d92ef5105fb3cfa48785368c4cdf67f 100644 (file)
@@ -56,7 +56,6 @@ memcached_return_t memcached_delete_by_key(memcached_st *ptr,
                                            const char *key, size_t key_length,
                                            time_t expiration)
 {
-  bool to_write;
   char buffer[MEMCACHED_DEFAULT_COMMAND_SIZE];
   memcached_server_write_instance_st instance;
 
@@ -80,7 +79,7 @@ memcached_return_t memcached_delete_by_key(memcached_st *ptr,
   uint32_t server_key= memcached_generate_hash_with_redistribution(ptr, group_key, group_key_length);
   instance= memcached_server_instance_fetch(ptr, server_key);
 
-  to_write= (ptr->flags.buffer_requests) ? false : true;
+  bool to_write= (ptr->flags.buffer_requests) ? false : true;
 
   bool no_reply= (ptr->flags.no_reply);
 
@@ -120,7 +119,7 @@ memcached_return_t memcached_delete_by_key(memcached_st *ptr,
 
           if (instance->minor_version == 0)
           {
-             if (no_reply || ! to_write)
+             if (no_reply or to_write == false)
              {
                 /* We might get out of sync with the server if we
                  * send this command to a server newer than 1.2.x..
@@ -155,7 +154,7 @@ memcached_return_t memcached_delete_by_key(memcached_st *ptr,
       goto error;
     }
 
-    if (ptr->flags.use_udp && ! to_write)
+    if (ptr->flags.use_udp and to_write == false)
     {
       if (send_length > MAX_UDP_DATAGRAM_LENGTH - UDP_DATAGRAM_HEADER_LENGTH)
         return MEMCACHED_WRITE_FAILURE;
@@ -170,21 +169,27 @@ memcached_return_t memcached_delete_by_key(memcached_st *ptr,
   }
 
   if (rc != MEMCACHED_SUCCESS)
+  {
     goto error;
+  }
 
-  if (! to_write)
+  if (to_write == false)
   {
     rc= MEMCACHED_BUFFERED;
   }
-  else if (!no_reply)
+  else if (no_reply == false)
   {
     rc= memcached_response(instance, buffer, MEMCACHED_DEFAULT_COMMAND_SIZE, NULL);
     if (rc == MEMCACHED_DELETED)
+    {
       rc= MEMCACHED_SUCCESS;
+    }
   }
 
-  if (rc == MEMCACHED_SUCCESS && ptr->delete_trigger)
+  if (rc == MEMCACHED_SUCCESS and ptr->delete_trigger)
+  {
     ptr->delete_trigger(ptr, key, key_length);
+  }
 
 error:
   LIBMEMCACHED_MEMCACHED_DELETE_END();
index ef4a0ce388fa48b0e1e42883e0c5c3c279e4cbf2..dcbe15b81c5104448b811880582215bf73fdb412 100644 (file)
@@ -6,25 +6,21 @@
   all slabs on servers and "grab" the keys.
 */
 
-#include "common.h"
+#include <libmemcached/common.h>
+
 static memcached_return_t ascii_dump(memcached_st *ptr, memcached_dump_fn *callback, void *context, uint32_t number_of_callbacks)
 {
   memcached_return_t rc= MEMCACHED_SUCCESS;
-  char buffer[MEMCACHED_DEFAULT_COMMAND_SIZE];
-  uint32_t server_key;
-  uint32_t x;
-
-  unlikely (memcached_server_count(ptr) == 0)
-    return MEMCACHED_NO_SERVERS;
 
-  for (server_key= 0; server_key < memcached_server_count(ptr); server_key++)
+  for (uint32_t server_key= 0; server_key < memcached_server_count(ptr); server_key++)
   {
     memcached_server_write_instance_st instance;
     instance= memcached_server_instance_fetch(ptr, server_key);
 
     /* 256 I BELIEVE is the upper limit of slabs */
-    for (x= 0; x < 256; x++)
+    for (uint32_t x= 0; x < 256; x++)
     {
+      char buffer[MEMCACHED_DEFAULT_COMMAND_SIZE];
       int send_length;
       send_length= snprintf(buffer, MEMCACHED_DEFAULT_COMMAND_SIZE,
                             "stats cachedump %u 0 0\r\n", x);
@@ -37,8 +33,10 @@ static memcached_return_t ascii_dump(memcached_st *ptr, memcached_dump_fn *callb
 
       rc= memcached_do(instance, buffer, (size_t)send_length, true);
 
-      unlikely (rc != MEMCACHED_SUCCESS)
+      if (rc != MEMCACHED_SUCCESS)
+      {
         goto error;
+      }
 
       while (1)
       {
@@ -48,23 +46,29 @@ static memcached_return_t ascii_dump(memcached_st *ptr, memcached_dump_fn *callb
         if (rc == MEMCACHED_ITEM)
         {
           char *string_ptr, *end_ptr;
-          char *key;
 
           string_ptr= buffer;
           string_ptr+= 5; /* Move past ITEM */
+
           for (end_ptr= string_ptr; isgraph(*end_ptr); end_ptr++) {} ;
-          key= string_ptr;
+
+          char *key= string_ptr;
           key[(size_t)(end_ptr-string_ptr)]= 0;
+
           for (callback_counter= 0; callback_counter < number_of_callbacks; callback_counter++)
           {
             rc= (*callback[callback_counter])(ptr, key, (size_t)(end_ptr-string_ptr), context);
             if (rc != MEMCACHED_SUCCESS)
+            {
               break;
+            }
           }
         }
         else if (rc == MEMCACHED_END)
+        {
           break;
-        else if (rc == MEMCACHED_SERVER_ERROR || rc == MEMCACHED_CLIENT_ERROR)
+        }
+        else if (rc == MEMCACHED_SERVER_ERROR or rc == MEMCACHED_CLIENT_ERROR)
         {
           /* If we try to request stats cachedump for a slab class that is too big
            * the server will return an incorrect error message:
@@ -77,16 +81,22 @@ static memcached_return_t ascii_dump(memcached_st *ptr, memcached_dump_fn *callb
           break;
         }
         else
+        {
           goto error;
+        }
       }
     }
   }
 
 error:
   if (rc == MEMCACHED_END)
+  {
     return MEMCACHED_SUCCESS;
+  }
   else
+  {
     return rc;
+  }
 }
 
 memcached_return_t memcached_dump(memcached_st *ptr, memcached_dump_fn *callback, void *context, uint32_t number_of_callbacks)
@@ -102,7 +112,9 @@ memcached_return_t memcached_dump(memcached_st *ptr, memcached_dump_fn *callback
     @todo Fix this so that we just flush, switch to ascii, and then go back to binary.
   */
   if (ptr->flags.binary_protocol)
+  {
     return MEMCACHED_FAILURE;
+  }
 
   return ascii_dump(ptr, callback, context, number_of_callbacks);
 }
index 5c4cf175e095a9e08e3736bf51275def28fba2ad..179b7c29289c39dda38cd6a2a0932c6da1a441c2 100644 (file)
@@ -219,7 +219,7 @@ static memcached_return_t update_continuum(memcached_st *ptr)
     if (is_ketama_weighted)
     {
         float pct= (float)list[host_index].weight / (float)total_weight;
-        pointer_per_server= (uint32_t) ((floorf((float) (pct * MEMCACHED_POINTS_PER_SERVER_KETAMA / 4 * (float)live_servers + 0.0000000001))) * 4);
+        pointer_per_server= (uint32_t) ((floor((float) (pct * MEMCACHED_POINTS_PER_SERVER_KETAMA / 4 * (float)live_servers + 0.0000000001))) * 4);
         pointer_per_hash= 4;
         if (DEBUG)
         {
index a96fba9987d520b1dafe0e32a9e3ae4eba57a3f2..6f84feaa007e48bbd3471f3c1d51f7159898515e 100644 (file)
@@ -1,22 +1,56 @@
+/*  vim:expandtab:shiftwidth=2:tabstop=2:smarttab:
+ * 
+ *  Libmemcached library
+ *
+ *  Copyright (C) 2011 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.
+ *
+ */
+
 /* -*- Mode: C; tab-width: 4; c-basic-offset: 4; indent-tabs-mode: nil -*- */
-#ifndef CACHE_H
-#define CACHE_H
+#pragma once
+
 #include <pthread.h>
 
 #ifdef HAVE_UMEM_H
-#include <umem.h>
-#define cache_t umem_cache_t
-#define cache_alloc(a) umem_cache_alloc(a, UMEM_DEFAULT)
-#define cache_free(a, b) umem_cache_free(a, b)
-#define cache_create(a,b,c,d,e) umem_cache_create((char*)a, b, c, d, e, NULL, NULL, NULL, 0)
-#define cache_destroy(a) umem_cache_destroy(a);
-
+# include <umem.h>
+# define cache_t umem_cache_t
+# define cache_alloc(a) umem_cache_alloc(a, UMEM_DEFAULT)
+# define cache_free(a, b) umem_cache_free(a, b)
+# define cache_create(a,b,c,d,e) umem_cache_create((char*)a, b, c, d, e, NULL, NULL, NULL, 0)
+# define cache_destroy(a) umem_cache_destroy(a);
 #else
-
-#ifndef NDEBUG
+# ifndef NDEBUG
 /* may be used for debug purposes */
 extern int cache_error;
-#endif
+# endif
 
 /**
  * Constructor used to initialize allocated objects
@@ -111,6 +145,4 @@ void* cache_alloc(cache_t* handle);
  * @param ptr pointer to the object to return.
  */
 void cache_free(cache_t* handle, void* ptr);
-#endif
-
-#endif
+#endif //  HAVE_UMEM_H
index 378194fd9fe08d33aeb1d4ffa39ba0373dd54b77..fa36243f769db098cb474392384c6ba6c3d200d1 100644 (file)
@@ -115,4 +115,15 @@ static inline bool memcached_failed(memcached_return_t rc)
           rc != MEMCACHED_VALUE);
 }
 
+static inline bool memcached_fatal(memcached_return_t rc)
+{
+  return (rc != MEMCACHED_SUCCESS && 
+          rc != MEMCACHED_END && 
+          rc != MEMCACHED_STORED && 
+          rc != MEMCACHED_STAT && 
+          rc != MEMCACHED_DELETED &&
+          rc != MEMCACHED_BUFFERED &&
+          rc != MEMCACHED_VALUE);
+}
+
 #define memcached_continue(__memcached_return_t) ((__memcached_return_t) == MEMCACHED_IN_PROGRESS)
index 421fa006f53feffcafd7530d0237b9533b6e83e7..4dc84c9d66990d547f48f40180530c2977b259be 100644 (file)
@@ -35,10 +35,10 @@ bool exec_cmdline(const std::string& executable, const char *args[])
 
   arg_buffer << libtool();
 
-  if (getenv("LIBTEST_TEST_ENVIRONMENT"))
+  if (getenv("PWD"))
   {
-    arg_buffer << getenv("LIBTEST_TEST_ENVIRONMENT");
-    arg_buffer << " ";
+    arg_buffer << getenv("PWD");
+    arg_buffer << "/";
   }
 
   arg_buffer << executable;
@@ -47,14 +47,9 @@ bool exec_cmdline(const std::string& executable, const char *args[])
     arg_buffer << " " << *ptr;
   }
 
-  if (getenv("LIBTEST_TEST_ENVIRONMENT"))
-  {
-    std::cerr << std::endl << arg_buffer.str() << std::endl;
-  }
-  else
-  {
+#if 0
     arg_buffer << " > /dev/null 2>&1";
-  }
+#endif
 
   if (system(arg_buffer.str().c_str()) == -1)
   {
index b7f584421276443b9f8b9a2d206b029ffb6df232..80cb8ddd64f30fee70ad949c335ebba24e1ae7bc 100644 (file)
@@ -139,7 +139,6 @@ int main(int argc, char *argv[])
   case TEST_FATAL:
   case TEST_FAILURE:
   case TEST_MEMORY_ALLOCATION_FAILURE:
-    Error << argv[0] << " failed in Framework::create()";
     delete world;
     return EXIT_FAILURE;
   }
@@ -151,7 +150,10 @@ int main(int argc, char *argv[])
   }
   else if (getenv("TEST_COLLECTION"))
   {
-    collection_to_run= getenv("TEST_COLLECTION");
+    if (strlen(getenv("TEST_COLLECTION")))
+    {
+      collection_to_run= getenv("TEST_COLLECTION");
+    }
   }
 
   if (collection_to_run)
index e92d9e23917b0a079f959d2a424fcd4bc4be5370..0f1e1e0ad7044846d0f1a60b99077e407850ade7 100644 (file)
@@ -148,6 +148,8 @@ do \
   } \
 } while (0)
 
+#define test_null test_zero
+
 #define test_compare_got(__expected, __actual, __hint) \
 do \
 { \
diff --git a/m4/pandora_have_libgtest.m4 b/m4/pandora_have_libgtest.m4
deleted file mode 100644 (file)
index fe269fb..0000000
+++ /dev/null
@@ -1,47 +0,0 @@
-dnl Copyright (C) 2010 Monty Taylor
-dnl This file is free software; Monty Taylor
-dnl gives unlimited permission to copy and/or distribute it,
-dnl with or without modifications, as long as this notice is preserved.
-
-AC_DEFUN([_PANDORA_SEARCH_LIBGTEST],[
-  AC_REQUIRE([AC_LIB_PREFIX])
-
-  dnl --------------------------------------------------------------------
-  dnl  Check for libgtest
-  dnl --------------------------------------------------------------------
-
-  AC_ARG_ENABLE([libgtest],
-    [AS_HELP_STRING([--disable-libgtest],
-      [Build with libgtest support @<:@default=on@:>@])],
-    [ac_enable_libgtest="$enableval"],
-    [ac_enable_libgtest="yes"])
-
-  AS_IF([test "x$ac_enable_libgtest" = "xyes"],[
-    AC_LANG_PUSH(C++)
-    save_CXXFLAGS="${CXXFLAGS}"
-    CXXFLAGS="${AM_CXXFLAGS} ${CXXFLAGS}"
-    AC_LIB_HAVE_LINKFLAGS(gtest,,[
-      #include <gtest/gtest.h>
-TEST(pandora_test_libgtest, PandoraTest)
-{
-  ASSERT_EQ(1, 1);
-}
-    ],[])
-    CXXFLAGS="${save_CXXFLAGS}"
-    AC_LANG_POP()
-  ],[
-    ac_cv_libgtest="no"
-  ])
-
-  AM_CONDITIONAL(HAVE_LIBGTEST, [test "x${ac_cv_libgtest}" = "xyes"])
-])
-
-AC_DEFUN([PANDORA_HAVE_LIBGTEST],[
-  AC_REQUIRE([_PANDORA_SEARCH_LIBGTEST])
-])
-
-AC_DEFUN([PANDORA_REQUIRE_LIBGTEST],[
-  AC_REQUIRE([_PANDORA_SEARCH_LIBGTEST])
-  AS_IF([test "x${ac_cv_libgtest}" = "xno"],
-    AC_MSG_ERROR([libgtest is required for ${PACKAGE}]))
-])
index 3406dd7e9d2192d741b7935c7380a5c12f067a86..f0d6b73d8339561b833b400ec286940e27b3481b 100644 (file)
@@ -82,6 +82,10 @@ you will need to install %{name}-devel.
 %exclude %{_libdir}/libhashkit.la
 %exclude %{_libdir}/libmemcachedutil.la
 %exclude %{_libdir}/libmemcachedprotocol.la
+%exclude %{_libdir}/libmemcached.a
+%exclude %{_libdir}/libhashkit.a
+%exclude %{_libdir}/libmemcachedutil.a
+%exclude %{_libdir}/libmemcachedprotocol.a
 %{_libdir}/libhashkit.so.1.0.0
 %{_libdir}/libmemcached.so.8.0.0
 %{_libdir}/libmemcachedutil.so.2.0.0
@@ -116,7 +120,6 @@ you will need to install %{name}-devel.
 %{_includedir}/libhashkit/strerror.h
 %{_includedir}/libhashkit/types.h
 %{_includedir}/libhashkit/visibility.h
-%{_includedir}/libhashkit/hashkit.hpp
 
 %{_includedir}/libmemcached/allocators.h
 %{_includedir}/libmemcached/analyze.h
index c8ca52414a9553f39f95ff56a61583f67b7d4beb..12cd3988ba83cc97fbff8ef40fe8af303bc5bc36 100644 (file)
@@ -192,7 +192,7 @@ static test_return_t crc_run (hashkit_st *hashk)
     uint32_t hash_val;
 
     hash_val= libhashkit_crc32(*ptr, strlen(*ptr));
-    assert(crc_values[x] == hash_val);
+    test_compare(crc_values[x], hash_val);
   }
 
   return TEST_SUCCESS;
@@ -209,7 +209,7 @@ static test_return_t fnv1_64_run (hashkit_st *hashk)
     uint32_t hash_val;
 
     hash_val= libhashkit_fnv1_64(*ptr, strlen(*ptr));
-    assert(fnv1_64_values[x] == hash_val);
+    test_compare(fnv1_64_values[x], hash_val);
   }
 
   return TEST_SUCCESS;
@@ -226,7 +226,7 @@ static test_return_t fnv1a_64_run (hashkit_st *hashk)
     uint32_t hash_val;
 
     hash_val= libhashkit_fnv1a_64(*ptr, strlen(*ptr));
-    assert(fnv1a_64_values[x] == hash_val);
+    test_compare(fnv1a_64_values[x], hash_val);
   }
 
   return TEST_SUCCESS;
@@ -243,7 +243,7 @@ static test_return_t fnv1_32_run (hashkit_st *hashk)
     uint32_t hash_val;
 
     hash_val= libhashkit_fnv1_32(*ptr, strlen(*ptr));
-    assert(fnv1_32_values[x] == hash_val);
+    test_compare(fnv1_32_values[x], hash_val);
   }
 
   return TEST_SUCCESS;
@@ -260,7 +260,7 @@ static test_return_t fnv1a_32_run (hashkit_st *hashk)
     uint32_t hash_val;
 
     hash_val= libhashkit_fnv1a_32(*ptr, strlen(*ptr));
-    assert(fnv1a_32_values[x] == hash_val);
+    test_compare(fnv1a_32_values[x], hash_val);
   }
 
   return TEST_SUCCESS;
@@ -281,7 +281,7 @@ static test_return_t hsieh_run (hashkit_st *hashk)
 #else
     hash_val= 1;
 #endif
-    assert(hsieh_values[x] == hash_val);
+    test_compare(hsieh_values[x], hash_val);
   }
 
   return TEST_SUCCESS;
@@ -307,7 +307,7 @@ static test_return_t murmur_run (hashkit_st *hashk)
 #else
     hash_val= 1;
 #endif
-    assert(murmur_values[x] == hash_val);
+    test_compare(murmur_values[x], hash_val);
   }
 
   return TEST_SUCCESS;
@@ -325,7 +325,7 @@ static test_return_t jenkins_run (hashkit_st *hashk)
     uint32_t hash_val;
 
     hash_val= libhashkit_jenkins(*ptr, strlen(*ptr));
-    assert(jenkins_values[x] == hash_val);
+    test_compare(jenkins_values[x], hash_val);
   }
 
   return TEST_SUCCESS;
index 38a07f9912bcb230e43e992913d501a82a8675fc..2bbe5802a0fcba4f779835edc2ced1b4df16a2d6 100644 (file)
@@ -174,12 +174,61 @@ tests_memcapable_LDADD=  $(tests_memcapable_DEPENDENCIES)
 check_PROGRAMS+= tests/memcapable
 noinst_PROGRAMS+= tests/memcapable
 
+tests_memstat_SOURCES= tests/memstat.cc
+tests_memstat_CXXFLAGS= $(AM_CXXFLAGS) $(NO_EFF_CXX)
+tests_memstat_DEPENDENCIES= libtest/libtest.la $(TESTS_LDADDS)
+tests_memstat_LDADD=  $(tests_memstat_DEPENDENCIES)
+check_PROGRAMS+= tests/memstat
+noinst_PROGRAMS+= tests/memstat
+
+tests_memcp_SOURCES= tests/memcp.cc
+tests_memcp_CXXFLAGS= $(AM_CXXFLAGS) $(NO_EFF_CXX)
+tests_memcp_DEPENDENCIES= libtest/libtest.la $(TESTS_LDADDS)
+tests_memcp_LDADD=  $(tests_memcp_DEPENDENCIES)
+check_PROGRAMS+= tests/memcp
+noinst_PROGRAMS+= tests/memcp
+
+tests_memflush_SOURCES= tests/memflush.cc
+tests_memflush_CXXFLAGS= $(AM_CXXFLAGS) $(NO_EFF_CXX)
+tests_memflush_DEPENDENCIES= libtest/libtest.la $(TESTS_LDADDS)
+tests_memflush_LDADD=  $(tests_memflush_DEPENDENCIES)
+check_PROGRAMS+= tests/memflush
+noinst_PROGRAMS+= tests/memflush
+
+tests_memrm_SOURCES= tests/memrm.cc
+tests_memrm_CXXFLAGS= $(AM_CXXFLAGS) $(NO_EFF_CXX)
+tests_memrm_DEPENDENCIES= libtest/libtest.la $(TESTS_LDADDS)
+tests_memrm_LDADD=  $(tests_memrm_DEPENDENCIES)
+check_PROGRAMS+= tests/memrm
+noinst_PROGRAMS+= tests/memrm
+
+tests_memcat_SOURCES= tests/memcat.cc
+tests_memcat_CXXFLAGS= $(AM_CXXFLAGS) $(NO_EFF_CXX)
+tests_memcat_DEPENDENCIES= libtest/libtest.la $(TESTS_LDADDS)
+tests_memcat_LDADD=  $(tests_memcat_DEPENDENCIES)
+check_PROGRAMS+= tests/memcat
+noinst_PROGRAMS+= tests/memcat
+
+tests_memerror_SOURCES= tests/memerror.cc
+tests_memerror_CXXFLAGS= $(AM_CXXFLAGS) $(NO_EFF_CXX)
+tests_memerror_DEPENDENCIES= libtest/libtest.la $(TESTS_LDADDS)
+tests_memerror_LDADD=  $(tests_memerror_DEPENDENCIES)
+check_PROGRAMS+= tests/memerror
+noinst_PROGRAMS+= tests/memerror
+
 tests_memslap_SOURCES= tests/memslap.cc
 tests_memslap_CXXFLAGS= $(AM_CXXFLAGS) $(NO_EFF_CXX)
 tests_memslap_DEPENDENCIES= libtest/libtest.la $(TESTS_LDADDS)
 tests_memslap_LDADD=  $(tests_memslap_DEPENDENCIES)
 check_PROGRAMS+= tests/memslap
 noinst_PROGRAMS+= tests/memslap
+
+tests_memdump_SOURCES= tests/memdump.cc
+tests_memdump_CXXFLAGS= $(AM_CXXFLAGS) $(NO_EFF_CXX)
+tests_memdump_DEPENDENCIES= libtest/libtest.la $(TESTS_LDADDS)
+tests_memdump_LDADD=  $(tests_memdump_DEPENDENCIES)
+check_PROGRAMS+= tests/memdump
+noinst_PROGRAMS+= tests/memdump
  
 # Test linking with C application
 tests_c_test_SOURCES= tests/c_test.c
@@ -200,31 +249,9 @@ test: check
 check-local: $(TEST_DOCS)
        @echo "Tests completed"
 
-test-x: test-plus test-memcat test-memcp test-memrm test-memerror test-memdump test-memflush test-memstat
+test-x: test-plus test-memcp test-memdump test-memflush test-memstat
        @echo "Tests completed"
 
-test-memcat: clients/memcat clients/memcp
-       @echo "Testing memcat"
-       @@MEMC_BINARY@ -d -u root -P `pwd`/tests/Xumemc.pid -p 12555
-       @clients/memcp --servers="localhost:12555" `pwd`/clients/memcp
-       @clients/memcat --servers="localhost:12555" memcp > `pwd`/tests/scratch
-       @clients/memcat --servers="localhost:12555" --file=`pwd`/tests/scratch2 memcp
-#      @diff clients/memcp tests/scratch
-       @cat `pwd`/tests/Xumemc.pid | xargs kill || echo "Failed to kill memcached server"
-       @rm `pwd`/tests/Xumemc.pid
-       @rm `pwd`/tests/scratch
-       @rm `pwd`/tests/scratch2
-
-valgrind-memcat: clients/memcat clients/memcp
-       @echo "Testing memcat"
-       @@MEMC_BINARY@ -d -u root -P `pwd`/tests/Xumemc.pid -p 12555
-       @clients/memcp --servers="localhost:12555" clients/memcp
-       @$(VALGRIND_COMMAND) clients/memcat --servers="localhost:12555" memcp > tests/scratch
-#      @diff clients/memcp tests/scratch
-       @cat tests/Xumemc.pid | xargs kill || echo "Failed to kill memcached server"
-       @rm tests/Xumemc.pid
-       @rm tests/scratch
-
 test-memcp: clients/memcp
        @echo "Testing memcp"
        @@MEMC_BINARY@ -d -u root -P `pwd`/tests/Xumemc.pid -p 12555
@@ -239,22 +266,6 @@ valgrind-memcp: clients/memcat clients/memcp
        @cat tests/Xumemc.pid | xargs kill || echo "Failed to kill memcached server"
        @rm tests/Xumemc.pid
 
-test-memrm: clients/memrm clients/memcp
-       @echo "Testing memrm"
-       @@MEMC_BINARY@ -d -u root -P `pwd`/tests/Xumemc.pid -p 12555
-       @clients/memcp --servers="localhost:12555" clients/memcat
-       @clients/memrm --servers="localhost:12555" memcat
-       @cat tests/Xumemc.pid | xargs kill || echo "Failed to kill memcached server"
-       @rm tests/Xumemc.pid
-
-valgrind-memrm: clients/memcat clients/memcp
-       @echo "Testing memrm"
-       @@MEMC_BINARY@ -d -u root -P `pwd`/tests/Xumemc.pid -p 12555
-       @clients/memcp --servers="localhost:12555" clients/memcat
-       @$(VALGRIND_COMMAND) clients/memrm --servers="localhost:12555" memcat
-       @cat tests/Xumemc.pid | xargs kill || echo "Failed to kill memcached server"
-       @rm tests/Xumemc.pid
-
 test-memflush: clients/memflush
        @echo "Testing memflush"
        @$(MEMC_BINARY) -d -u root -P `pwd`/tests/Xumemc.pid -p 12555
@@ -299,24 +310,12 @@ valgrind-memstat: clients/memstat
        @cat tests/Xumemc.pid | xargs kill || echo "Failed to kill memcached server"
        @rm tests/Xumemc.pid
 
-test-memerror: clients/memerror
-       @echo "Testing memerror"
-       @clients/memerror 0 > /dev/null
-
-valgrind-memerror: clients/memerror
-       @echo "Testing memerror"
-       @$(VALGRIND_COMMAND) clients/memerror 0 > /dev/null
-
 test-mem: tests/var tests/testapp
        @tests/testapp
 
 test-sasl: tests/sasl
        @tests/sasl
 
-
-test-udp: tests/var tests/testudp
-       @tests/testudp
-
 test-atom: tests/var tests/atomsmasher
        @tests/atomsmasher
 
index 464668219b3d8bffe4e4c64e255f713927675c20..b56c47bc26b714383752e5fe2a8e56929d32e494 100644 (file)
@@ -821,10 +821,11 @@ static test_return_t bad_key_test(memcached_st *memc)
   memcached_st *memc_clone;
   size_t max_keylen= 0xffff;
 
-  // Just skip if we are in binary mode.
   uint64_t query_id= memcached_query_id(memc);
-  if (memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL))
-    return TEST_SKIPPED;
+  
+  // Just skip if we are in binary mode.
+  test_skip(false, memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL));
+
   test_compare(query_id, memcached_query_id(memc)); // We should not increase the query_id for memcached_behavior_get()
 
   memc_clone= memcached_clone(NULL, memc);
@@ -890,20 +891,16 @@ static test_return_t bad_key_test(memcached_st *memc)
 
     std::vector <char> longkey;
     longkey.insert(longkey.end(), max_keylen +1, 'a');
-    if (longkey.size())
+    test_compare(longkey.size(), max_keylen +1);
     {
       size_t string_length;
-      char *string= memcached_get(memc_clone, &longkey[0], max_keylen,
-                                  &string_length, &flags, &rc);
+      test_null(memcached_get(memc_clone, &longkey[0], max_keylen, &string_length, &flags, &rc));
       test_compare(MEMCACHED_NOTFOUND, rc);
       test_zero(string_length);
-      test_false(string);
 
-      string= memcached_get(memc_clone, &longkey[0], max_keylen +1,
-                            &string_length, &flags, &rc);
+      test_null(memcached_get(memc_clone, &longkey[0], max_keylen +1, &string_length, &flags, &rc));
       test_compare(MEMCACHED_BAD_KEY_PROVIDED, rc);
       test_zero(string_length);
-      test_false(string);
     }
   }
 
index 65db1698fd1ee8cf41606bd897aa310382361615..60fd00ada4820c0d68080279439a30045cfa11c0 100644 (file)
@@ -52,11 +52,17 @@ using namespace libtest;
 
 static std::string executable;
 
+static test_return_t quiet_test(void *)
+{
+  const char *args[]= { "-q", 0 };
+
+  test_true(exec_cmdline(executable, args));
+  return TEST_SUCCESS;
+}
+
 static test_return_t help_test(void *)
 {
-  char buffer[1024];
-  snprintf(buffer, sizeof(buffer), "-p %d", int(default_port()));
-  const char *args[]= { buffer, "--help", 0 };
+  const char *args[]= { "-q", "--help", 0 };
 
   test_true(exec_cmdline(executable, args));
   return TEST_SUCCESS;
@@ -66,7 +72,7 @@ static test_return_t ascii_test(void *)
 {
   char buffer[1024];
   snprintf(buffer, sizeof(buffer), "-p %d", int(default_port()));
-  const char *args[]= { buffer, " -a ", 0 };
+  const char *args[]= { "-q", buffer, " -a ", 0 };
 
   test_true(exec_cmdline(executable, args));
   return TEST_SUCCESS;
@@ -76,13 +82,14 @@ static test_return_t binary_test(void *)
 {
   char buffer[1024];
   snprintf(buffer, sizeof(buffer), "-p %d", int(default_port()));
-  const char *args[]= { buffer, " -b ", 0 };
+  const char *args[]= { "-q", buffer, " -b ", 0 };
 
   test_true(exec_cmdline(executable, args));
   return TEST_SUCCESS;
 }
 
 test_st memcapable_tests[] ={
+  {"--quiet", 0, quiet_test},
   {"--help", 0, help_test},
   {"-a, ascii", 0, ascii_test},
   {"-b, binary", 0, binary_test},
@@ -96,6 +103,12 @@ collection_st collection[] ={
 
 static void *world_create(server_startup_st& servers, test_return_t& error)
 {
+  if (HAVE_MEMCACHED_BINARY == 0)
+  {
+    error= TEST_FATAL;
+    return NULL;
+  }
+
   const char *argv[1]= { "memcapable" };
   if (not server_startup(servers, "memcached", MEMCACHED_DEFAULT_PORT +10, 1, argv))
   {
diff --git a/tests/memcat.cc b/tests/memcat.cc
new file mode 100644 (file)
index 0000000..e8ed3ef
--- /dev/null
@@ -0,0 +1,159 @@
+/*  vim:expandtab:shiftwidth=2:tabstop=2:smarttab:
+ * 
+ *  Test memcat
+ *
+ *  Copyright (C) 2011 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.
+ *
+ */
+
+
+/*
+  Test that we are cycling the servers we are creating during testing.
+*/
+
+#include <config.h>
+
+#include <libtest/test.hpp>
+#include <libmemcached/memcached.h>
+
+using namespace libtest;
+
+#ifndef __INTEL_COMPILER
+#pragma GCC diagnostic ignored "-Wstrict-aliasing"
+#endif
+
+static std::string executable;
+
+static test_return_t quiet_test(void *)
+{
+  const char *args[]= { "--quiet", 0 };
+
+  test_true(exec_cmdline(executable, args));
+  return TEST_SUCCESS;
+}
+
+static test_return_t help_test(void *)
+{
+  const char *args[]= { "--quiet", "--help", 0 };
+
+  test_true(exec_cmdline(executable, args));
+  return TEST_SUCCESS;
+}
+
+static test_return_t cat_test(void *)
+{
+  char buffer[1024];
+  snprintf(buffer, sizeof(buffer), "--server=localhost:%d", int(default_port()));
+  const char *args[]= { "--quiet", buffer, "foo", 0 };
+
+  memcached_st *memc= memcached(buffer, strlen(buffer));
+  test_true(memc);
+
+  test_compare(MEMCACHED_SUCCESS,
+               memcached_set(memc, test_literal_param("foo"), 0, 0, 0, 0));
+
+  memcached_return_t rc;
+  test_null(memcached_get(memc, test_literal_param("foo"), 0, 0, &rc));
+  test_compare(MEMCACHED_SUCCESS, rc);
+
+  test_true(exec_cmdline(executable, args));
+
+  test_null(memcached_get(memc, test_literal_param("foo"), 0, 0, &rc));
+  test_compare(MEMCACHED_SUCCESS, rc);
+
+  memcached_free(memc);
+
+  return TEST_SUCCESS;
+}
+
+static test_return_t NOT_FOUND_test(void *)
+{
+  char buffer[1024];
+  snprintf(buffer, sizeof(buffer), "--server=localhost:%d", int(default_port()));
+  const char *args[]= { "--quiet", buffer, "foo", 0 };
+
+  memcached_st *memc= memcached(buffer, strlen(buffer));
+  test_true(memc);
+
+  test_compare(MEMCACHED_SUCCESS, memcached_flush(memc, 0));
+
+  memcached_return_t rc;
+  test_null(memcached_get(memc, test_literal_param("foo"), 0, 0, &rc));
+  test_compare(MEMCACHED_NOTFOUND, rc);
+
+  test_true(exec_cmdline(executable, args));
+
+  test_null(memcached_get(memc, test_literal_param("foo"), 0, 0, &rc));
+  test_compare(MEMCACHED_NOTFOUND, rc);
+
+  memcached_free(memc);
+
+  return TEST_SUCCESS;
+}
+
+test_st memcat_tests[] ={
+  {"--quiet", true, quiet_test },
+  {"--help", true, help_test },
+  {"cat(FOUND)", true, cat_test },
+  {"cat(NOT_FOUND)", true, NOT_FOUND_test },
+  {0, 0, 0}
+};
+
+collection_st collection[] ={
+  {"memcat", 0, 0, memcat_tests },
+  {0, 0, 0, 0}
+};
+
+static void *world_create(server_startup_st& servers, test_return_t& error)
+{
+  if (HAVE_MEMCACHED_BINARY == 0)
+  {
+    error= TEST_FATAL;
+    return NULL;
+  }
+
+  const char *argv[1]= { "memcat" };
+  if (not server_startup(servers, "memcached", MEMCACHED_DEFAULT_PORT +10, 1, argv))
+  {
+    error= TEST_FAILURE;
+  }
+
+  return &servers;
+}
+
+
+void get_world(Framework *world)
+{
+  executable= "clients/memcat";
+  world->collections= collection;
+  world->_create= world_create;
+}
+
diff --git a/tests/memcp.cc b/tests/memcp.cc
new file mode 100644 (file)
index 0000000..c22c4db
--- /dev/null
@@ -0,0 +1,117 @@
+/*  vim:expandtab:shiftwidth=2:tabstop=2:smarttab:
+ * 
+ *  Test memcp
+ *
+ *  Copyright (C) 2011 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.
+ *
+ */
+
+
+/*
+  Test that we are cycling the servers we are creating during testing.
+*/
+
+#include <config.h>
+
+#include <libtest/test.hpp>
+#include <libmemcached/memcached.h>
+
+using namespace libtest;
+
+#ifndef __INTEL_COMPILER
+#pragma GCC diagnostic ignored "-Wstrict-aliasing"
+#endif
+
+static std::string executable;
+
+static test_return_t quiet_test(void *)
+{
+  const char *args[]= { "--quiet", 0 };
+
+  test_true(exec_cmdline(executable, args));
+  return TEST_SUCCESS;
+}
+
+static test_return_t help_test(void *)
+{
+  const char *args[]= { "--quiet", "--help", 0 };
+
+  test_true(exec_cmdline(executable, args));
+  return TEST_SUCCESS;
+}
+
+static test_return_t server_test(void *)
+{
+  char buffer[1024];
+  snprintf(buffer, sizeof(buffer), "--servers=localhost:%d", int(default_port()));
+  const char *args[]= { "--quiet", buffer, 0 };
+
+  test_true(exec_cmdline(executable, args));
+  return TEST_SUCCESS;
+}
+
+test_st memcp_tests[] ={
+  {"--quiet", true, quiet_test },
+  {"--help", true, help_test },
+  {"--server_test", true, server_test },
+  {0, 0, 0}
+};
+
+collection_st collection[] ={
+  {"memcp", 0, 0, memcp_tests },
+  {0, 0, 0, 0}
+};
+
+static void *world_create(server_startup_st& servers, test_return_t& error)
+{
+  if (HAVE_MEMCACHED_BINARY == 0)
+  {
+    error= TEST_FATAL;
+    return NULL;
+  }
+
+  const char *argv[1]= { "memcp" };
+  if (not server_startup(servers, "memcached", MEMCACHED_DEFAULT_PORT +10, 1, argv))
+  {
+    error= TEST_FAILURE;
+  }
+
+  return &servers;
+}
+
+
+void get_world(Framework *world)
+{
+  executable= "./clients/memcp";
+  world->collections= collection;
+  world->_create= world_create;
+}
+
diff --git a/tests/memdump.cc b/tests/memdump.cc
new file mode 100644 (file)
index 0000000..6e5a2ae
--- /dev/null
@@ -0,0 +1,144 @@
+/*  vim:expandtab:shiftwidth=2:tabstop=2:smarttab:
+ * 
+ *  Test memdump
+ *
+ *  Copyright (C) 2011 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.
+ *
+ */
+
+
+/*
+  Test that we are cycling the servers we are creating during testing.
+*/
+
+#include <config.h>
+
+#include <libtest/test.hpp>
+#include <libmemcached/memcached.h>
+
+using namespace libtest;
+
+#ifndef __INTEL_COMPILER
+#pragma GCC diagnostic ignored "-Wstrict-aliasing"
+#endif
+
+static std::string executable;
+
+static test_return_t quiet_test(void *)
+{
+  const char *args[]= { "--quiet", 0 };
+
+  test_true(exec_cmdline(executable, args));
+  return TEST_SUCCESS;
+}
+
+static test_return_t help_test(void *)
+{
+  const char *args[]= { "--help", "--quiet", 0 };
+
+  test_true(exec_cmdline(executable, args));
+  return TEST_SUCCESS;
+}
+
+static test_return_t server_test(void *)
+{
+  char buffer[1024];
+  snprintf(buffer, sizeof(buffer), "--servers=localhost:%d", int(default_port()));
+  const char *args[]= { buffer, 0 };
+
+  test_true(exec_cmdline(executable, args));
+  return TEST_SUCCESS;
+}
+
+static test_return_t FOUND_test(void *)
+{
+  char buffer[1024];
+  snprintf(buffer, sizeof(buffer), "--server=localhost:%d", int(default_port()));
+  const char *args[]= { "--quiet", buffer, 0 };
+
+  memcached_st *memc= memcached(buffer, strlen(buffer));
+  test_true(memc);
+
+  test_compare(MEMCACHED_SUCCESS,
+               memcached_set(memc, test_literal_param("foo"), 0, 0, 0, 0));
+
+  test_compare(MEMCACHED_SUCCESS,
+               memcached_set(memc, test_literal_param("foo2"), 0, 0, 0, 0));
+
+  memcached_return_t rc;
+  test_null(memcached_get(memc, test_literal_param("foo"), 0, 0, &rc));
+  test_compare(MEMCACHED_SUCCESS, rc);
+
+  test_true(exec_cmdline(executable, args));
+
+  memcached_free(memc);
+
+  return TEST_SUCCESS;
+}
+
+test_st memdump_tests[] ={
+  {"--quiet", true, quiet_test },
+  {"--help", true, help_test },
+  {"--server", true, server_test },
+  {"FOUND", true, FOUND_test },
+  {0, 0, 0}
+};
+
+collection_st collection[] ={
+  {"memdump", 0, 0, memdump_tests },
+  {0, 0, 0, 0}
+};
+
+static void *world_create(server_startup_st& servers, test_return_t& error)
+{
+  if (HAVE_MEMCACHED_BINARY == 0)
+  {
+    error= TEST_FATAL;
+    return NULL;
+  }
+
+  const char *argv[1]= { "memdump" };
+  if (not server_startup(servers, "memcached", MEMCACHED_DEFAULT_PORT +10, 1, argv))
+  {
+    error= TEST_FAILURE;
+  }
+
+  return &servers;
+}
+
+
+void get_world(Framework *world)
+{
+  executable= "./clients/memdump";
+  world->collections= collection;
+  world->_create= world_create;
+}
+
diff --git a/tests/memerror.cc b/tests/memerror.cc
new file mode 100644 (file)
index 0000000..88ddcba
--- /dev/null
@@ -0,0 +1,112 @@
+/*  vim:expandtab:shiftwidth=2:tabstop=2:smarttab:
+ * 
+ *  Test memerror
+ *
+ *  Copyright (C) 2011 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.
+ *
+ */
+
+
+/*
+  Test that we are cycling the servers we are creating during testing.
+*/
+
+#include <config.h>
+
+#include <libtest/test.hpp>
+#include <libmemcached/memcached.h>
+
+using namespace libtest;
+
+#ifndef __INTEL_COMPILER
+#pragma GCC diagnostic ignored "-Wstrict-aliasing"
+#endif
+
+static std::string executable;
+
+static test_return_t quiet_test(void *)
+{
+  const char *args[]= { "--quiet", 0 };
+
+  test_true(exec_cmdline(executable, args));
+  return TEST_SUCCESS;
+}
+
+static test_return_t help_test(void *)
+{
+  const char *args[]= { "--quiet", "--help", 0 };
+
+  test_true(exec_cmdline(executable, args));
+  return TEST_SUCCESS;
+}
+
+static test_return_t error_test(void *)
+{
+  const char *args[]= { "--quiet", "MEMCACHED_SUCCESS", 0 };
+
+  test_true(exec_cmdline(executable, args));
+  return TEST_SUCCESS;
+}
+
+static test_return_t bad_input_test(void *)
+{
+  const char *args[]= { "--quiet", "bad input", 0 };
+
+  test_true(exec_cmdline(executable, args));
+  return TEST_SUCCESS;
+}
+
+test_st memerror_tests[] ={
+  {"--quiet", 0, quiet_test},
+  {"--help", 0, help_test},
+  {"<error>", 0, error_test},
+  {"<bad input>", 0, bad_input_test},
+  {0, 0, 0}
+};
+
+collection_st collection[] ={
+  {"memerror", 0, 0, memerror_tests },
+  {0, 0, 0, 0}
+};
+
+static void *world_create(server_startup_st&, test_return_t&)
+{
+  return NULL;
+}
+
+
+void get_world(Framework *world)
+{
+  executable= "./clients/memerror";
+  world->collections= collection;
+  world->_create= world_create;
+}
+
diff --git a/tests/memflush.cc b/tests/memflush.cc
new file mode 100644 (file)
index 0000000..8f91356
--- /dev/null
@@ -0,0 +1,117 @@
+/*  vim:expandtab:shiftwidth=2:tabstop=2:smarttab:
+ * 
+ *  Test memflush
+ *
+ *  Copyright (C) 2011 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.
+ *
+ */
+
+
+/*
+  Test that we are cycling the servers we are creating during testing.
+*/
+
+#include <config.h>
+
+#include <libtest/test.hpp>
+#include <libmemcached/memcached.h>
+
+using namespace libtest;
+
+#ifndef __INTEL_COMPILER
+#pragma GCC diagnostic ignored "-Wstrict-aliasing"
+#endif
+
+static std::string executable;
+
+static test_return_t quiet_test(void *)
+{
+  const char *args[]= { "--quiet", 0 };
+
+  test_true(exec_cmdline(executable, args));
+  return TEST_SUCCESS;
+}
+
+static test_return_t help_test(void *)
+{
+  const char *args[]= { "--quiet", "--help", 0 };
+
+  test_true(exec_cmdline(executable, args));
+  return TEST_SUCCESS;
+}
+
+static test_return_t server_test(void *)
+{
+  char buffer[1024];
+  snprintf(buffer, sizeof(buffer), "--servers=localhost:%d", int(default_port()));
+  const char *args[]= { "--quiet", buffer, 0 };
+
+  test_true(exec_cmdline(executable, args));
+  return TEST_SUCCESS;
+}
+
+test_st memflush_tests[] ={
+  {"--quiet", true, quiet_test },
+  {"--help", true, help_test },
+  {"--server", true, server_test },
+  {0, 0, 0}
+};
+
+collection_st collection[] ={
+  {"memflush", 0, 0, memflush_tests },
+  {0, 0, 0, 0}
+};
+
+static void *world_create(server_startup_st& servers, test_return_t& error)
+{
+  if (HAVE_MEMCACHED_BINARY == 0)
+  {
+    error= TEST_FATAL;
+    return NULL;
+  }
+
+  const char *argv[1]= { "memflush" };
+  if (not server_startup(servers, "memcached", MEMCACHED_DEFAULT_PORT +10, 1, argv))
+  {
+    error= TEST_FAILURE;
+  }
+
+  return &servers;
+}
+
+
+void get_world(Framework *world)
+{
+  executable= "./clients/memflush";
+  world->collections= collection;
+  world->_create= world_create;
+}
+
diff --git a/tests/memrm.cc b/tests/memrm.cc
new file mode 100644 (file)
index 0000000..bf2dc86
--- /dev/null
@@ -0,0 +1,157 @@
+/*  vim:expandtab:shiftwidth=2:tabstop=2:smarttab:
+ * 
+ *  Test memrm
+ *
+ *  Copyright (C) 2011 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.
+ *
+ */
+
+
+/*
+  Test that we are cycling the servers we are creating during testing.
+*/
+
+#include <config.h>
+
+#include <libtest/test.hpp>
+#include <libmemcached/memcached.h>
+
+using namespace libtest;
+
+#ifndef __INTEL_COMPILER
+#pragma GCC diagnostic ignored "-Wstrict-aliasing"
+#endif
+
+static std::string executable;
+
+static test_return_t quiet_test(void *)
+{
+  const char *args[]= { "--quiet", 0 };
+
+  test_true(exec_cmdline(executable, args));
+  return TEST_SUCCESS;
+}
+
+static test_return_t help_test(void *)
+{
+  const char *args[]= { "--quiet", "--help", 0 };
+
+  test_true(exec_cmdline(executable, args));
+  return TEST_SUCCESS;
+}
+
+static test_return_t rm_test(void *)
+{
+  char buffer[1024];
+  snprintf(buffer, sizeof(buffer), "--server=localhost:%d", int(default_port()));
+  const char *args[]= { "--quiet", buffer, "foo", 0 };
+
+  memcached_st *memc= memcached(buffer, strlen(buffer));
+  test_true(memc);
+
+  test_compare(MEMCACHED_SUCCESS,
+               memcached_set(memc, test_literal_param("foo"), 0, 0, 0, 0));
+
+  memcached_return_t rc;
+  test_null(memcached_get(memc, test_literal_param("foo"), 0, 0, &rc));
+  test_compare(MEMCACHED_SUCCESS, rc);
+
+  test_true(exec_cmdline(executable, args));
+
+  test_null(memcached_get(memc, test_literal_param("foo"), 0, 0, &rc));
+  test_compare(MEMCACHED_NOTFOUND, rc);
+
+  memcached_free(memc);
+
+  return TEST_SUCCESS;
+}
+
+static test_return_t NOT_FOUND_test(void *)
+{
+  char buffer[1024];
+  snprintf(buffer, sizeof(buffer), "--server=localhost:%d", int(default_port()));
+  const char *args[]= { "--quiet", buffer, "foo", 0 };
+
+  memcached_st *memc= memcached(buffer, strlen(buffer));
+  test_true(memc);
+
+  memcached_return_t rc;
+  test_null(memcached_get(memc, test_literal_param("foo"), 0, 0, &rc));
+  test_compare(MEMCACHED_NOTFOUND, rc);
+
+  test_true(exec_cmdline(executable, args));
+
+  test_null(memcached_get(memc, test_literal_param("foo"), 0, 0, &rc));
+  test_compare(MEMCACHED_NOTFOUND, rc);
+
+  memcached_free(memc);
+
+  return TEST_SUCCESS;
+}
+
+test_st memrm_tests[] ={
+  {"--quiet", true, quiet_test },
+  {"--help", true, help_test },
+  {"rm(FOUND)", true, rm_test },
+  {"rm(NOT_FOUND)", true, NOT_FOUND_test },
+  {0, 0, 0}
+};
+
+collection_st collection[] ={
+  {"memrm", 0, 0, memrm_tests },
+  {0, 0, 0, 0}
+};
+
+static void *world_create(server_startup_st& servers, test_return_t& error)
+{
+  if (HAVE_MEMCACHED_BINARY == 0)
+  {
+    error= TEST_FATAL;
+    return NULL;
+  }
+
+  const char *argv[1]= { "memrm" };
+  if (not server_startup(servers, "memcached", MEMCACHED_DEFAULT_PORT +10, 1, argv))
+  {
+    error= TEST_FAILURE;
+  }
+
+  return &servers;
+}
+
+
+void get_world(Framework *world)
+{
+  executable= "./clients/memrm";
+  world->collections= collection;
+  world->_create= world_create;
+}
+
index 544ed2802e0cdf1178ac2cb6dd9d1117abf77485..229a920cd27ff7ba197e84a72330270f78ede60c 100644 (file)
@@ -52,9 +52,17 @@ using namespace libtest;
 
 static std::string executable;
 
+static test_return_t quiet_test(void *)
+{
+  const char *args[]= { "--quiet", 0 };
+
+  test_true(exec_cmdline(executable, args));
+  return TEST_SUCCESS;
+}
+
 static test_return_t help_test(void *)
 {
-  const char *args[]= { "--help", 0 };
+  const char *args[]= { "--quiet", "--help", 0 };
 
   test_true(exec_cmdline(executable, args));
   return TEST_SUCCESS;
@@ -64,7 +72,7 @@ static test_return_t server_test(void *)
 {
   char buffer[1024];
   snprintf(buffer, sizeof(buffer), "--servers=localhost:%d", int(default_port()));
-  const char *args[]= { buffer, 0 };
+  const char *args[]= { "--quiet", buffer, 0 };
 
   test_true(exec_cmdline(executable, args));
   return TEST_SUCCESS;
@@ -74,7 +82,7 @@ static test_return_t server_concurrency_test(void *)
 {
   char buffer[1024];
   snprintf(buffer, sizeof(buffer), "--servers=localhost:%d", int(default_port()));
-  const char *args[]= { buffer, "--concurrency=10", 0 };
+  const char *args[]= { "--quiet", buffer, "--concurrency=10", 0 };
 
   test_true(exec_cmdline(executable, args));
   return TEST_SUCCESS;
@@ -84,7 +92,7 @@ static test_return_t server_concurrency_initial_load_test(void *)
 {
   char buffer[1024];
   snprintf(buffer, sizeof(buffer), "--servers=localhost:%d", int(default_port()));
-  const char *args[]= { buffer, "--concurrency=10", "--initial-load=1000", 0 };
+  const char *args[]= { "--quiet", buffer, "--concurrency=10", "--initial-load=1000", 0 };
 
   test_true(exec_cmdline(executable, args));
   return TEST_SUCCESS;
@@ -94,7 +102,7 @@ static test_return_t server_concurrency_initial_load_execute_number_test(void *)
 {
   char buffer[1024];
   snprintf(buffer, sizeof(buffer), "--servers=localhost:%d", int(default_port()));
-  const char *args[]= { buffer, "--concurrency=10", "--initial-load=1000", "--execute-number=10", 0 };
+  const char *args[]= { "--quiet", buffer, "--concurrency=10", "--initial-load=1000", "--execute-number=10", 0 };
 
   test_true(exec_cmdline(executable, args));
   return TEST_SUCCESS;
@@ -104,7 +112,7 @@ static test_return_t server_concurrency_initial_load_execute_number_test_get_tes
 {
   char buffer[1024];
   snprintf(buffer, sizeof(buffer), "--servers=localhost:%d", int(default_port()));
-  const char *args[]= { buffer, "--concurrency=10", "--initial-load=1000", "--execute-number=10", "--test=get", 0 };
+  const char *args[]= { "--quiet", buffer, "--concurrency=10", "--initial-load=1000", "--execute-number=10", "--test=get", 0 };
 
   test_true(exec_cmdline(executable, args));
   return TEST_SUCCESS;
@@ -114,7 +122,7 @@ static test_return_t server_concurrency_initial_load_execute_number_test_set_tes
 {
   char buffer[1024];
   snprintf(buffer, sizeof(buffer), "--servers=localhost:%d", int(default_port()));
-  const char *args[]= { buffer, "--concurrency=10", "--initial-load=1000", "--execute-number=10", "--test=set", 0 };
+  const char *args[]= { "--quiet", buffer, "--concurrency=10", "--initial-load=1000", "--execute-number=10", "--test=set", 0 };
 
   test_true(exec_cmdline(executable, args));
   return TEST_SUCCESS;
@@ -124,13 +132,14 @@ static test_return_t server_concurrency_initial_load_execute_number_test_set_non
 {
   char buffer[1024];
   snprintf(buffer, sizeof(buffer), "--servers=localhost:%d", int(default_port()));
-  const char *args[]= { buffer, "--concurrency=10", "--initial-load=1000", "--execute-number=10", "--test=set", "--non-blocking", 0 };
+  const char *args[]= { "--quiet", buffer, "--concurrency=10", "--initial-load=1000", "--execute-number=10", "--test=set", "--non-blocking", 0 };
 
   test_true(exec_cmdline(executable, args));
   return TEST_SUCCESS;
 }
 
 test_st memslap_tests[] ={
+  {"--quiet", true, quiet_test },
   {"--help", true, help_test },
   {"--server_test", true, server_test },
   {"--concurrency=10", true, server_concurrency_test },
@@ -149,6 +158,12 @@ collection_st collection[] ={
 
 static void *world_create(server_startup_st& servers, test_return_t& error)
 {
+  if (HAVE_MEMCACHED_BINARY == 0)
+  {
+    error= TEST_FATAL;
+    return NULL;
+  }
+
   const char *argv[1]= { "memslap" };
   if (not server_startup(servers, "memcached", MEMCACHED_DEFAULT_PORT +10, 1, argv))
   {
diff --git a/tests/memstat.cc b/tests/memstat.cc
new file mode 100644 (file)
index 0000000..44bc77a
--- /dev/null
@@ -0,0 +1,130 @@
+/*  vim:expandtab:shiftwidth=2:tabstop=2:smarttab:
+ * 
+ *  Test memstat
+ *
+ *  Copyright (C) 2011 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.
+ *
+ */
+
+
+/*
+  Test that we are cycling the servers we are creating during testing.
+*/
+
+#include <config.h>
+
+#include <libtest/test.hpp>
+#include <libmemcached/memcached.h>
+
+using namespace libtest;
+
+#ifndef __INTEL_COMPILER
+#pragma GCC diagnostic ignored "-Wstrict-aliasing"
+#endif
+
+static std::string executable;
+
+static test_return_t quiet_test(void *)
+{
+  const char *args[]= { "--quiet", 0 };
+
+  test_true(exec_cmdline(executable, args));
+  return TEST_SUCCESS;
+}
+
+
+static test_return_t help_test(void *)
+{
+  const char *args[]= { "--help", "--quiet", 0 };
+
+  test_true(exec_cmdline(executable, args));
+
+  return TEST_SUCCESS;
+}
+
+static test_return_t ascii_test(void *)
+{
+  char buffer[1024];
+  snprintf(buffer, sizeof(buffer), "-p %d", int(default_port()));
+  const char *args[]= { "--quiet", buffer, " -a ", 0 };
+
+  test_true(exec_cmdline(executable, args));
+  return TEST_SUCCESS;
+}
+
+static test_return_t binary_test(void *)
+{
+  char buffer[1024];
+  snprintf(buffer, sizeof(buffer), "-p %d", int(default_port()));
+  const char *args[]= { "--quiet", buffer, " -b ", 0 };
+
+  test_true(exec_cmdline(executable, args));
+  return TEST_SUCCESS;
+}
+
+test_st memstat_tests[] ={
+  {"--quiet", 0, quiet_test},
+  {"--help", 0, help_test},
+  {"-a, ascii", 0, ascii_test},
+  {"-b, binary", 0, binary_test},
+  {0, 0, 0}
+};
+
+collection_st collection[] ={
+  {"memstat", 0, 0, memstat_tests },
+  {0, 0, 0, 0}
+};
+
+static void *world_create(server_startup_st& servers, test_return_t& error)
+{
+  if (HAVE_MEMCACHED_BINARY == 0)
+  {
+    error= TEST_FATAL;
+    return NULL;
+  }
+
+  const char *argv[1]= { "memstat" };
+  if (not server_startup(servers, "memcached", MEMCACHED_DEFAULT_PORT +10, 1, argv))
+  {
+    error= TEST_FAILURE;
+  }
+
+  return &servers;
+}
+
+
+void get_world(Framework *world)
+{
+  executable= "./clients/memstat";
+  world->collections= collection;
+  world->_create= world_create;
+}
+