Merge lp:~trond-norbye/libmemcached/memcapable into lp:~tangent-org/libmemcached/trunk

[Trond Norbye]

[Trond Norbye (trond-norbye)]

Added new tool memcapable who tries to run the binary protocol on a given server and verifies the output

[Brian Aker (brianaker)]

I tried to merge this in on gaz but I got many warnings/etc.

review: Approve

[Brian Aker (brianaker)]

I tried to merge this in on gaz but I got many warnings/etc.

review: Needs Fixing

[lp:~trond-norbye/libmemcached/memcapable]

571. By Brian Aker <brian@gaz> on 2009-09-15

Merge Trond.

572. By Brian Aker <brian@gaz> on 2009-09-15

Merging Trond.

573. By Brian Aker <brian@gaz> on 2009-09-15

Fix for linger behavior

574. By Brian Aker <brian@gaz> on 2009-09-16

Updating for version .32

575. By Brian Aker <brian@gaz> on 2009-09-16

Updating library version number

576. By Brian Aker <brian@gaz> on 2009-09-17

Update pandora

577. By Brian Aker <brian@gaz> on 2009-09-17

Merge Trond

=== modified file 'clients/Makefile.am'
--- clients/Makefile.am	2009-07-08 17:58:46 +0000
+++ clients/Makefile.am	2009-09-03 15:09:18 +0000
@@ -1,6 +1,6 @@
 LDADDS = $(top_builddir)/libmemcached/libmemcached.la libutilities.la
 
-bin_PROGRAMS = memcat memdump memcp memstat memrm memflush memslap memerror
+bin_PROGRAMS = memcat memdump memcp memstat memrm memflush memslap memerror memcapable
 
 noinst_HEADERS = client_options.h \
 		utilities.h \
@@ -45,6 +45,8 @@
 memslap_LDADD = $(LDADDS) $(PTHREAD_LIBS) libgenexec.la
 memslap_LDFLAGS = $(AM_LDFLAGS) -rpath $(pkglibdir)
 
+memcapable_SOURCES = memcapable.c
+
 test-start-server:
 	memflush --servers=localhost
 	memcp --servers=localhost /etc/services

=== added file 'clients/memcapable.c'
--- clients/memcapable.c	1970-01-01 00:00:00 +0000
+++ clients/memcapable.c	2009-09-03 15:09:18 +0000
@@ -0,0 +1,1111 @@
+/* -*- Mode: C; tab-width: 3; c-basic-offset: 3; indent-tabs-mode: nil -*- */
+#undef NDEBUG
+#include <pthread.h>
+#include <sys/types.h>
+#include <sys/socket.h>
+#include <netdb.h>
+#include <arpa/inet.h>
+#include <netinet/in.h>
+#include <netinet/tcp.h>
+#include <signal.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <errno.h>
+#include <assert.h>
+#include <string.h>
+#include <inttypes.h>
+#include <stdbool.h>
+#include <unistd.h>
+#include <netinet/in.h>
+
+#include <libmemcached/memcached/protocol_binary.h>
+
+/* Should we generate coredumps when we enounter an error (-c) */
+static bool do_core=false;
+/* connection to the server */
+static int sock;
+
+typedef union
+{
+  protocol_binary_request_no_extras plain;
+  protocol_binary_request_flush flush;
+  protocol_binary_request_incr incr;
+  protocol_binary_request_set set;
+  char bytes[1024];
+} command;
+
+typedef union
+{
+  protocol_binary_response_no_extras plain;
+  protocol_binary_response_incr incr;
+  protocol_binary_response_decr decr;
+  char bytes[1024];
+} response;
+
+enum test_return
+{
+  TEST_SKIP, TEST_PASS, TEST_PASS_RECONNECT, TEST_FAIL
+};
+
+/**
+ * Try to get an addrinfo struct for a given port on a given host
+ */
+static struct addrinfo *lookuphost(const char *hostname, const char *port)
+{
+  struct addrinfo *ai= 0;
+  struct addrinfo hints= {.ai_family=AF_UNSPEC,
+    .ai_protocol=IPPROTO_TCP,
+    .ai_socktype=SOCK_STREAM};
+  int error= getaddrinfo(hostname, port, &hints, &ai);
+
+  if (error != 0)
+    if (error != EAI_SYSTEM)
+      fprintf(stderr, "getaddrinfo(): %s\n", gai_strerror(error));
+    else
+      perror("getaddrinfo()");
+
+  return ai;
+}
+
+/**
+ * Try to open a connection to the server
+ * @param hostname the name of the server to connect to
+ * @param port the port number (or service) to connect to
+ * @return positive integer if success, -1 otherwise
+ */
+static int connect_server(const char *hostname, const char *port)
+{
+  struct addrinfo *ai= lookuphost(hostname, port);
+  sock= -1;
+  if (ai != NULL)
+  {
+    if ((sock=socket(ai->ai_family, ai->ai_socktype,
+                     ai->ai_protocol)) != -1)
+    {
+      if (connect(sock, ai->ai_addr, ai->ai_addrlen) == -1)
+      {
+        fprintf(stderr, "Failed to connect socket: %s\n",
+                strerror(errno));
+        close(sock);
+        sock= -1;
+      }
+    } else
+      fprintf(stderr, "Failed to create socket: %s\n", strerror(errno));
+
+    freeaddrinfo(ai);
+  }
+
+  return sock;
+}
+
+/**
+ * Ensure that an expression is true. If it isn't print out a message similar
+ * to assert() and create a coredump if the user wants that. If not an error
+ * message is returned.
+ *
+ */
+static enum test_return ensure(bool val, const char *expression, const char *file, int line)
+{
+  if (!val)
+  {
+    fprintf(stderr, "%s:%u: %s\n", file, line, expression);
+    if (do_core)
+      abort();
+
+    return TEST_FAIL;
+  }
+
+  return TEST_PASS;
+}
+
+#define verify(expression) do { if (ensure(expression, #expression, __FILE__, __LINE__) == TEST_FAIL) return TEST_FAIL; } while (0)
+#define execute(expression) do { if (ensure(expression == TEST_PASS, #expression, __FILE__, __LINE__) == TEST_FAIL) return TEST_FAIL; } while (0)
+
+/**
+ * Send a chunk of memory over the socket (retry if the call is iterrupted
+ */
+static enum test_return retry_write(const void* buf, size_t len)
+{
+  off_t offset= 0;
+  const char* ptr= buf;
+
+  do
+  {
+    size_t num_bytes= len - offset;
+    ssize_t nw= write(sock, ptr + offset, num_bytes);
+    if (nw == -1)
+      verify(errno == EINTR);
+    else
+      offset+= nw;
+  } while (offset < len);
+
+  return TEST_PASS;
+}
+
+/**
+ * Resend a packet to the server (All fields in the command header should
+ * be in network byte order)
+ */
+static enum test_return resend_packet(command *command)
+{
+  size_t length= sizeof (protocol_binary_request_no_extras) +
+          ntohl(command->plain.message.header.request.bodylen);
+
+  execute(retry_write(command, length));
+  return TEST_PASS;
+}
+
+/**
+ * Send a command to the server. The command header needs to be updated
+ * to network byte order
+ */
+static enum test_return send_packet(command *command)
+{
+  /* Fix the byteorder of the header */
+  command->plain.message.header.request.keylen=
+          ntohs(command->plain.message.header.request.keylen);
+  command->plain.message.header.request.bodylen=
+          ntohl(command->plain.message.header.request.bodylen);
+  command->plain.message.header.request.cas=
+          ntohll(command->plain.message.header.request.cas);
+
+  execute(resend_packet(command));
+  return TEST_PASS;
+}
+
+/**
+ * Read a fixed length chunk of data from the server
+ */
+static enum test_return retry_read(void *buf, size_t len)
+{
+  off_t offset= 0;
+  do
+  {
+    ssize_t nr= read(sock, ((char*) buf) + offset, len - offset);
+    switch (nr) {
+    case -1 :
+      verify(errno == EINTR);
+      break;
+    case 0:
+      return TEST_FAIL;
+    default:
+      offset+= nr;
+    }
+  } while (offset < len);
+
+  return TEST_PASS;
+}
+
+/**
+ * Receive a response from the server and conver the fields in the header
+ * to local byte order
+ */
+static enum test_return recv_packet(response *response)
+{
+  execute(retry_read(response, sizeof (protocol_binary_response_no_extras)));
+
+  /* Fix the byte order in the packet header */
+  response->plain.message.header.response.keylen=
+          ntohs(response->plain.message.header.response.keylen);
+  response->plain.message.header.response.status=
+          ntohs(response->plain.message.header.response.status);
+  response->plain.message.header.response.bodylen=
+          ntohl(response->plain.message.header.response.bodylen);
+  response->plain.message.header.response.cas=
+          ntohll(response->plain.message.header.response.cas);
+
+  size_t bodysz= response->plain.message.header.response.bodylen;
+  if (bodysz > 0)
+    execute(retry_read(response->bytes + sizeof (protocol_binary_response_no_extras), bodysz));
+
+  return TEST_PASS;
+}
+
+/**
+ * Create a storage command (add, set, replace etc)
+ *
+ * @param command destination buffer
+ * @param cmd the storage command to create
+ * @param key the key to store
+ * @param keylen the length of the key
+ * @param dta the data to store with the key
+ * @param dtalen the length of the data to store with the key
+ * @param flags the flags to store along with the key
+ * @param exp the expiry time for the key
+ */
+static void storage_command(command *command,
+                            uint8_t cmd,
+                            const void* key,
+                            size_t keylen,
+                            const void* dta,
+                            size_t dtalen,
+                            uint32_t flags,
+                            uint32_t exp)
+{
+  /* all of the storage commands use the same command layout */
+  protocol_binary_request_set *request= &command->set;
+
+  memset(request, 0, sizeof (*request));
+  request->message.header.request.magic= PROTOCOL_BINARY_REQ;
+  request->message.header.request.opcode= cmd;
+  request->message.header.request.keylen= keylen;
+  request->message.header.request.extlen= 8;
+  request->message.header.request.bodylen= keylen + 8 + dtalen;
+  request->message.header.request.opaque= 0xdeadbeef;
+  request->message.body.flags= flags;
+  request->message.body.expiration= exp;
+
+  off_t key_offset= sizeof (protocol_binary_request_no_extras) + 8;
+  memcpy(command->bytes + key_offset, key, keylen);
+  if (dta != NULL)
+    memcpy(command->bytes + key_offset + keylen, dta, dtalen);
+}
+
+/**
+ * Create a basic command to send to the server
+ * @param command destination buffer
+ * @param cmd the command to create
+ * @param key the key to store
+ * @param keylen the length of the key
+ * @param dta the data to store with the key
+ * @param dtalen the length of the data to store with the key
+ */
+static void raw_command(command *command,
+                        uint8_t cmd,
+                        const void* key,
+                        size_t keylen,
+                        const void* dta,
+                        size_t dtalen)
+{
+  /* all of the storage commands use the same command layout */
+  memset(command, 0, sizeof (*command));
+  command->plain.message.header.request.magic= PROTOCOL_BINARY_REQ;
+  command->plain.message.header.request.opcode= cmd;
+  command->plain.message.header.request.keylen= keylen;
+  command->plain.message.header.request.bodylen= keylen + dtalen;
+  command->plain.message.header.request.opaque= 0xdeadbeef;
+
+  off_t key_offset= sizeof (protocol_binary_request_no_extras);
+
+  if (key != NULL)
+    memcpy(command->bytes + key_offset, key, keylen);
+
+  if (dta != NULL)
+    memcpy(command->bytes + key_offset + keylen, dta, dtalen);
+}
+
+/**
+ * Create the flush command
+ * @param command destination buffer
+ * @param cmd the command to create (FLUSH/FLUSHQ)
+ * @param exptime when to flush
+ * @param use_extra to force using of the extra field?
+ */
+static void flush_command(command *command,
+                          uint8_t cmd, uint32_t exptime, bool use_extra)
+{
+  memset(command, 0, sizeof (command->flush));
+  command->flush.message.header.request.magic= PROTOCOL_BINARY_REQ;
+  command->flush.message.header.request.opcode= cmd;
+  command->flush.message.header.request.opaque= 0xdeadbeef;
+
+  if (exptime != 0 || use_extra)
+  {
+    command->flush.message.header.request.extlen= 4;
+    command->flush.message.body.expiration= htonl(exptime);
+    command->flush.message.header.request.bodylen= 4;
+  }
+}
+
+/**
+ * Create a incr/decr command
+ * @param cmd the command to create (FLUSH/FLUSHQ)
+ * @param key the key to operate on
+ * @param keylen the number of bytes in the key
+ * @param delta the number to add/subtract
+ * @param initial the initial value if the key doesn't exist
+ * @param exp when the key should expire if it isn't set
+ */
+static void arithmetic_command(command *command,
+                               uint8_t cmd,
+                               const void* key,
+                               size_t keylen,
+                               uint64_t delta,
+                               uint64_t initial,
+                               uint32_t exp)
+{
+  memset(command, 0, sizeof (command->incr));
+  command->incr.message.header.request.magic= PROTOCOL_BINARY_REQ;
+  command->incr.message.header.request.opcode= cmd;
+  command->incr.message.header.request.keylen= keylen;
+  command->incr.message.header.request.extlen= 20;
+  command->incr.message.header.request.bodylen= keylen + 20;
+  command->incr.message.header.request.opaque= 0xdeadbeef;
+  command->incr.message.body.delta= htonll(delta);
+  command->incr.message.body.initial= htonll(initial);
+  command->incr.message.body.expiration= htonl(exp);
+
+  off_t key_offset= sizeof (protocol_binary_request_no_extras) + 20;
+  memcpy(command->bytes + key_offset, key, keylen);
+}
+
+/**
+ * Validate the response header from the server
+ * @param response the response to check
+ * @param cmd the expected command
+ * @param status the expected status
+ */
+static enum test_return validate_response_header(response *response,
+                                                 uint8_t cmd, uint16_t status)
+{
+  verify(response->plain.message.header.response.magic == PROTOCOL_BINARY_RES);
+  verify(response->plain.message.header.response.opcode == cmd);
+  verify(response->plain.message.header.response.datatype == PROTOCOL_BINARY_RAW_BYTES);
+  verify(response->plain.message.header.response.status == status);
+  verify(response->plain.message.header.response.opaque == 0xdeadbeef);
+
+  if (status == PROTOCOL_BINARY_RESPONSE_SUCCESS)
+  {
+    switch (cmd) {
+    case PROTOCOL_BINARY_CMD_ADDQ:
+    case PROTOCOL_BINARY_CMD_APPENDQ:
+    case PROTOCOL_BINARY_CMD_DECREMENTQ:
+    case PROTOCOL_BINARY_CMD_DELETEQ:
+    case PROTOCOL_BINARY_CMD_FLUSHQ:
+    case PROTOCOL_BINARY_CMD_INCREMENTQ:
+    case PROTOCOL_BINARY_CMD_PREPENDQ:
+    case PROTOCOL_BINARY_CMD_QUITQ:
+    case PROTOCOL_BINARY_CMD_REPLACEQ:
+    case PROTOCOL_BINARY_CMD_SETQ:
+      verify("Quiet command shouldn't return on success" == NULL);
+    default:
+      break;
+    }
+
+    switch (cmd) {
+    case PROTOCOL_BINARY_CMD_ADD:
+    case PROTOCOL_BINARY_CMD_REPLACE:
+    case PROTOCOL_BINARY_CMD_SET:
+    case PROTOCOL_BINARY_CMD_APPEND:
+    case PROTOCOL_BINARY_CMD_PREPEND:
+      verify(response->plain.message.header.response.keylen == 0);
+      verify(response->plain.message.header.response.extlen == 0);
+      verify(response->plain.message.header.response.bodylen == 0);
+      verify(response->plain.message.header.response.cas != 0);
+      break;
+    case PROTOCOL_BINARY_CMD_FLUSH:
+    case PROTOCOL_BINARY_CMD_NOOP:
+    case PROTOCOL_BINARY_CMD_QUIT:
+    case PROTOCOL_BINARY_CMD_DELETE:
+      verify(response->plain.message.header.response.keylen == 0);
+      verify(response->plain.message.header.response.extlen == 0);
+      verify(response->plain.message.header.response.bodylen == 0);
+      verify(response->plain.message.header.response.cas == 0);
+      break;
+
+    case PROTOCOL_BINARY_CMD_DECREMENT:
+    case PROTOCOL_BINARY_CMD_INCREMENT:
+      verify(response->plain.message.header.response.keylen == 0);
+      verify(response->plain.message.header.response.extlen == 0);
+      verify(response->plain.message.header.response.bodylen == 8);
+      verify(response->plain.message.header.response.cas != 0);
+      break;
+
+    case PROTOCOL_BINARY_CMD_STAT:
+      verify(response->plain.message.header.response.extlen == 0);
+      /* key and value exists in all packets except in the terminating */
+      verify(response->plain.message.header.response.cas == 0);
+      break;
+
+    case PROTOCOL_BINARY_CMD_VERSION:
+      verify(response->plain.message.header.response.keylen == 0);
+      verify(response->plain.message.header.response.extlen == 0);
+      verify(response->plain.message.header.response.bodylen != 0);
+      verify(response->plain.message.header.response.cas == 0);
+      break;
+
+    case PROTOCOL_BINARY_CMD_GET:
+    case PROTOCOL_BINARY_CMD_GETQ:
+      verify(response->plain.message.header.response.keylen == 0);
+      verify(response->plain.message.header.response.extlen == 4);
+      verify(response->plain.message.header.response.cas != 0);
+      break;
+
+    case PROTOCOL_BINARY_CMD_GETK:
+    case PROTOCOL_BINARY_CMD_GETKQ:
+      verify(response->plain.message.header.response.keylen != 0);
+      verify(response->plain.message.header.response.extlen == 4);
+      verify(response->plain.message.header.response.cas != 0);
+      break;
+
+    default:
+      /* Undefined command code */
+      break;
+    }
+  }
+  else
+  {
+    verify(response->plain.message.header.response.cas == 0);
+    verify(response->plain.message.header.response.extlen == 0);
+    if (cmd != PROTOCOL_BINARY_CMD_GETK)
+    {
+      verify(response->plain.message.header.response.keylen == 0);
+    }
+  }
+
+  return TEST_PASS;
+}
+
+static enum test_return test_binary_noop(void)
+{
+  command command;
+  response response;
+  raw_command(&command, PROTOCOL_BINARY_CMD_NOOP, NULL, 0, NULL, 0);
+  execute(send_packet(&command));
+  execute(recv_packet(&response));
+  verify(validate_response_header(&response, PROTOCOL_BINARY_CMD_NOOP,
+                                  PROTOCOL_BINARY_RESPONSE_SUCCESS));
+  return TEST_PASS;
+}
+
+static enum test_return test_binary_quit_impl(uint8_t cmd)
+{
+  command command;
+  response response;
+  raw_command(&command, cmd, NULL, 0, NULL, 0);
+
+  execute(send_packet(&command));
+  if (cmd == PROTOCOL_BINARY_CMD_QUIT)
+  {
+    execute(recv_packet(&response));
+    verify(validate_response_header(&response, PROTOCOL_BINARY_CMD_QUIT,
+                                    PROTOCOL_BINARY_RESPONSE_SUCCESS));
+  }
+
+  /* Socket should be closed now, read should return 0 */
+  verify(read(sock, response.bytes, sizeof (response.bytes)) == 0);
+
+  return TEST_PASS_RECONNECT;
+}
+
+static enum test_return test_binary_quit(void)
+{
+  return test_binary_quit_impl(PROTOCOL_BINARY_CMD_QUIT);
+}
+
+static enum test_return test_binary_quitq(void)
+{
+  return test_binary_quit_impl(PROTOCOL_BINARY_CMD_QUITQ);
+}
+
+static enum test_return test_binary_set_impl(const char* key, uint8_t cmd)
+{
+  command command;
+  response response;
+
+  uint64_t value= 0xdeadbeefdeadcafe;
+  storage_command(&command, cmd, key, strlen(key), &value, sizeof (value), 0, 0);
+
+  /* set should always work */
+  for (int ii= 0; ii < 10; ii++)
+  {
+    if (ii == 0)
+      execute(send_packet(&command));
+    else
+      execute(resend_packet(&command));
+
+    if (cmd == PROTOCOL_BINARY_CMD_SET)
+    {
+      execute(recv_packet(&response));
+      verify(validate_response_header(&response, cmd, PROTOCOL_BINARY_RESPONSE_SUCCESS));
+    }
+    else
+      execute(test_binary_noop());
+  }
+
+  /* try to set with the correct CAS value */
+  command.plain.message.header.request.cas=
+          htonll(response.plain.message.header.response.cas);
+  execute(resend_packet(&command));
+  if (cmd == PROTOCOL_BINARY_CMD_SET)
+  {
+    execute(recv_packet(&response));
+    verify(validate_response_header(&response, cmd, PROTOCOL_BINARY_RESPONSE_SUCCESS));
+  }
+  else
+    execute(test_binary_noop());
+
+  /* try to set with an incorrect CAS value */
+  command.plain.message.header.request.cas=
+          htonll(response.plain.message.header.response.cas - 1);
+  execute(resend_packet(&command));
+  execute(recv_packet(&response));
+  verify(validate_response_header(&response, cmd, PROTOCOL_BINARY_RESPONSE_KEY_EEXISTS));
+
+  return test_binary_noop();
+}
+
+static enum test_return test_binary_set(void)
+{
+  return test_binary_set_impl("test_binary_set", PROTOCOL_BINARY_CMD_SET);
+}
+
+static enum test_return test_binary_setq(void)
+{
+  return test_binary_set_impl("test_binary_setq", PROTOCOL_BINARY_CMD_SETQ);
+}
+
+static enum test_return test_binary_add_impl(const char* key, uint8_t cmd)
+{
+  command command;
+  response response;
+  uint64_t value= 0xdeadbeefdeadcafe;
+  storage_command(&command, cmd, key, strlen(key), &value, sizeof (value), 0, 0);
+
+  /* first add should work, rest of them should fail (even with cas
+     as wildcard */
+  for (int ii=0; ii < 10; ii++)
+  {
+    if (ii == 0)
+      execute(send_packet(&command));
+    else
+      execute(resend_packet(&command));
+
+    if (cmd == PROTOCOL_BINARY_CMD_ADD || ii > 0)
+    {
+      uint16_t expected_result;
+      if (ii == 0)
+        expected_result= PROTOCOL_BINARY_RESPONSE_SUCCESS;
+      else
+        expected_result= PROTOCOL_BINARY_RESPONSE_KEY_EEXISTS;
+
+      execute(recv_packet(&response));
+      verify(validate_response_header(&response, cmd, expected_result));
+    }
+    else
+      execute(test_binary_noop());
+  }
+
+  return TEST_PASS;
+}
+
+static enum test_return test_binary_add(void)
+{
+  return test_binary_add_impl("test_binary_add", PROTOCOL_BINARY_CMD_ADD);
+}
+
+static enum test_return test_binary_addq(void)
+{
+  return test_binary_add_impl("test_binary_addq", PROTOCOL_BINARY_CMD_ADDQ);
+}
+
+static enum test_return set_item(const char *key, const char *value)
+{
+  command command;
+  response response;
+  storage_command(&command, PROTOCOL_BINARY_CMD_SET, key, strlen(key),
+                  value, strlen(value), 0, 0);
+  execute(send_packet(&command));
+  execute(recv_packet(&response));
+  verify(validate_response_header(&response, PROTOCOL_BINARY_CMD_SET,
+                                  PROTOCOL_BINARY_RESPONSE_SUCCESS));
+  return TEST_PASS;
+}
+
+static enum test_return test_binary_replace_impl(const char* key, uint8_t cmd)
+{
+  command command;
+  response response;
+  uint64_t value= 0xdeadbeefdeadcafe;
+  storage_command(&command, cmd, key, strlen(key), &value, sizeof (value), 0, 0);
+
+  /* first replace should fail, successive should succeed (when the
+     item is added! */
+  for (int ii= 0; ii < 10; ii++)
+  {
+    if (ii == 0)
+      execute(send_packet(&command));
+    else
+      execute(resend_packet(&command));
+
+    if (cmd == PROTOCOL_BINARY_CMD_REPLACE || ii == 0)
+    {
+      uint16_t expected_result;
+      if (ii == 0)
+        expected_result=PROTOCOL_BINARY_RESPONSE_KEY_ENOENT;
+      else
+        expected_result=PROTOCOL_BINARY_RESPONSE_SUCCESS;
+
+      execute(recv_packet(&response));
+      verify(validate_response_header(&response, cmd, expected_result));
+
+      if (ii == 0)
+        execute(set_item(key, key));
+    }
+    else
+      execute(test_binary_noop());
+  }
+
+  /* verify that replace with CAS value works! */
+  command.plain.message.header.request.cas=
+          htonll(response.plain.message.header.response.cas);
+  execute(resend_packet(&command));
+
+  if (cmd == PROTOCOL_BINARY_CMD_REPLACE)
+  {
+    execute(recv_packet(&response));
+    verify(validate_response_header(&response, cmd, PROTOCOL_BINARY_RESPONSE_SUCCESS));
+  }
+  else
+    execute(test_binary_noop());
+
+  /* try to set with an incorrect CAS value */
+  command.plain.message.header.request.cas=
+          htonll(response.plain.message.header.response.cas - 1);
+  execute(resend_packet(&command));
+  execute(recv_packet(&response));
+  verify(validate_response_header(&response, cmd, PROTOCOL_BINARY_RESPONSE_KEY_EEXISTS));
+
+  return TEST_PASS;
+}
+
+static enum test_return test_binary_replace(void)
+{
+  return test_binary_replace_impl("test_binary_replace", PROTOCOL_BINARY_CMD_REPLACE);
+}
+
+static enum test_return test_binary_replaceq(void)
+{
+  return test_binary_replace_impl("test_binary_replaceq", PROTOCOL_BINARY_CMD_REPLACEQ);
+}
+
+static enum test_return test_binary_delete_impl(const char *key, uint8_t cmd)
+{
+  command command;
+  response response;
+  raw_command(&command, cmd, key, strlen(key), NULL, 0);
+
+  /* The delete shouldn't work the first time, because the item isn't there */
+  execute(send_packet(&command));
+  execute(recv_packet(&response));
+  verify(validate_response_header(&response, cmd, PROTOCOL_BINARY_RESPONSE_KEY_ENOENT));
+  execute(set_item(key, key));
+
+  /* The item should be present now, resend*/
+  execute(resend_packet(&command));
+  if (cmd == PROTOCOL_BINARY_CMD_DELETE)
+  {
+    execute(recv_packet(&response));
+    verify(validate_response_header(&response, cmd, PROTOCOL_BINARY_RESPONSE_SUCCESS));
+  }
+
+  execute(test_binary_noop());
+
+  return TEST_PASS;
+}
+
+static enum test_return test_binary_delete(void)
+{
+  return test_binary_delete_impl("test_binary_delete", PROTOCOL_BINARY_CMD_DELETE);
+}
+
+static enum test_return test_binary_deleteq(void)
+{
+  return test_binary_delete_impl("test_binary_deleteq", PROTOCOL_BINARY_CMD_DELETEQ);
+}
+
+static enum test_return test_binary_get_impl(const char *key, uint8_t cmd)
+{
+  command command;
+  response response;
+
+  raw_command(&command, cmd, key, strlen(key), NULL, 0);
+  execute(send_packet(&command));
+
+  if (cmd == PROTOCOL_BINARY_CMD_GET || cmd == PROTOCOL_BINARY_CMD_GETK)
+  {
+    execute(recv_packet(&response));
+    verify(validate_response_header(&response, cmd, PROTOCOL_BINARY_RESPONSE_KEY_ENOENT));
+  }
+  else
+    execute(test_binary_noop());
+
+  execute(set_item(key, key));
+  execute(resend_packet(&command));
+  execute(recv_packet(&response));
+  verify(validate_response_header(&response, cmd, PROTOCOL_BINARY_RESPONSE_SUCCESS));
+
+  return TEST_PASS;
+}
+
+static enum test_return test_binary_get(void)
+{
+  return test_binary_get_impl("test_binary_get", PROTOCOL_BINARY_CMD_GET);
+}
+
+static enum test_return test_binary_getk(void)
+{
+  return test_binary_get_impl("test_binary_getk", PROTOCOL_BINARY_CMD_GETK);
+}
+
+static enum test_return test_binary_getq(void)
+{
+  return test_binary_get_impl("test_binary_getq", PROTOCOL_BINARY_CMD_GETQ);
+}
+
+static enum test_return test_binary_getkq(void)
+{
+  return test_binary_get_impl("test_binary_getkq", PROTOCOL_BINARY_CMD_GETKQ);
+}
+
+static enum test_return test_binary_incr_impl(const char* key, uint8_t cmd)
+{
+  command command;
+  response response;
+  arithmetic_command(&command, cmd, key, strlen(key), 1, 0, 0);
+
+  int ii;
+  for (ii= 0; ii < 10; ++ii)
+  {
+    if (ii == 0)
+      execute(send_packet(&command));
+    else
+      execute(resend_packet(&command));
+
+    if (cmd == PROTOCOL_BINARY_CMD_INCREMENT)
+    {
+      execute(recv_packet(&response));
+      verify(validate_response_header(&response, cmd, PROTOCOL_BINARY_RESPONSE_SUCCESS));
+      verify(ntohll(response.incr.message.body.value) == ii);
+    }
+    else
+      execute(test_binary_noop());
+  }
+
+  /* @todo add incorrect CAS */
+  return TEST_PASS;
+}
+
+static enum test_return test_binary_incr(void)
+{
+  return test_binary_incr_impl("test_binary_incr", PROTOCOL_BINARY_CMD_INCREMENT);
+}
+
+static enum test_return test_binary_incrq(void)
+{
+  return test_binary_incr_impl("test_binary_incrq", PROTOCOL_BINARY_CMD_INCREMENTQ);
+}
+
+static enum test_return test_binary_decr_impl(const char* key, uint8_t cmd)
+{
+  command command;
+  response response;
+  arithmetic_command(&command, cmd, key, strlen(key), 1, 9, 0);
+
+  int ii;
+  for (ii= 9; ii > -1; --ii)
+  {
+    if (ii == 9)
+      execute(send_packet(&command));
+    else
+      execute(resend_packet(&command));
+
+    if (cmd == PROTOCOL_BINARY_CMD_DECREMENT)
+    {
+      execute(recv_packet(&response));
+      verify(validate_response_header(&response, cmd, PROTOCOL_BINARY_RESPONSE_SUCCESS));
+      verify(ntohll(response.decr.message.body.value) == ii);
+    }
+    else
+      execute(test_binary_noop());
+  }
+
+  /* decr 0 should not wrap */
+  execute(resend_packet(&command));
+  if (cmd == PROTOCOL_BINARY_CMD_DECREMENT)
+  {
+    execute(recv_packet(&response));
+    verify(validate_response_header(&response, cmd, PROTOCOL_BINARY_RESPONSE_SUCCESS));
+    verify(ntohll(response.decr.message.body.value) == 0);
+  }
+  else
+  {
+    /* @todo get the value and verify! */
+
+  }
+
+  /* @todo add incorrect cas */
+  execute(test_binary_noop());
+  return TEST_PASS;
+}
+
+static enum test_return test_binary_decr(void)
+{
+  return test_binary_decr_impl("test_binary_decr",
+                               PROTOCOL_BINARY_CMD_DECREMENT);
+}
+
+static enum test_return test_binary_decrq(void)
+{
+  return test_binary_decr_impl("test_binary_decrq",
+                               PROTOCOL_BINARY_CMD_DECREMENTQ);
+}
+
+static enum test_return test_binary_version(void)
+{
+  command command;
+  response response;
+  raw_command(&command, PROTOCOL_BINARY_CMD_VERSION, NULL, 0, NULL, 0);
+
+  execute(send_packet(&command));
+  execute(recv_packet(&response));
+  verify(validate_response_header(&response, PROTOCOL_BINARY_CMD_VERSION,
+                                  PROTOCOL_BINARY_RESPONSE_SUCCESS));
+
+  return TEST_PASS;
+}
+
+static enum test_return test_binary_flush_impl(const char *key, uint8_t cmd)
+{
+  command command;
+  response response;
+
+  for (int ii= 0; ii < 2; ++ii)
+  {
+    execute(set_item(key, key));
+    flush_command(&command, cmd, 0, ii == 0);
+    execute(send_packet(&command));
+
+    if (cmd == PROTOCOL_BINARY_CMD_FLUSH)
+    {
+      execute(recv_packet(&response));
+      verify(validate_response_header(&response, cmd, PROTOCOL_BINARY_RESPONSE_SUCCESS));
+    }
+    else
+      execute(test_binary_noop());
+
+    raw_command(&command, PROTOCOL_BINARY_CMD_GET, key, strlen(key), NULL, 0);
+    execute(send_packet(&command));
+    execute(recv_packet(&response));
+    verify(validate_response_header(&response, PROTOCOL_BINARY_CMD_GET,
+                                    PROTOCOL_BINARY_RESPONSE_KEY_ENOENT));
+  }
+
+  return TEST_PASS;
+}
+
+static enum test_return test_binary_flush(void)
+{
+  return test_binary_flush_impl("test_binary_flush", PROTOCOL_BINARY_CMD_FLUSH);
+}
+
+static enum test_return test_binary_flushq(void)
+{
+  return test_binary_flush_impl("test_binary_flushq", PROTOCOL_BINARY_CMD_FLUSHQ);
+}
+
+static enum test_return test_binary_concat_impl(const char *key, uint8_t cmd)
+{
+  command command;
+  response response;
+  const char *value;
+
+  if (cmd == PROTOCOL_BINARY_CMD_APPEND || cmd == PROTOCOL_BINARY_CMD_APPENDQ)
+    value="hello";
+  else
+    value=" world";
+
+  execute(set_item(key, value));
+
+  if (cmd == PROTOCOL_BINARY_CMD_APPEND || cmd == PROTOCOL_BINARY_CMD_APPENDQ)
+    value=" world";
+  else
+    value="hello";
+
+  raw_command(&command, cmd, key, strlen(key), value, strlen(value));
+  execute(send_packet(&command));
+  if (cmd == PROTOCOL_BINARY_CMD_APPEND || cmd == PROTOCOL_BINARY_CMD_PREPEND)
+  {
+    execute(recv_packet(&response));
+    verify(validate_response_header(&response, cmd, PROTOCOL_BINARY_RESPONSE_SUCCESS));
+  }
+  else
+    execute(test_binary_noop());
+
+  raw_command(&command, PROTOCOL_BINARY_CMD_GET, key, strlen(key), NULL, 0);
+  execute(send_packet(&command));
+  execute(recv_packet(&response));
+  verify(validate_response_header(&response, PROTOCOL_BINARY_CMD_GET,
+                                  PROTOCOL_BINARY_RESPONSE_SUCCESS));
+  verify(response.plain.message.header.response.bodylen - 4 == 11);
+  verify(memcmp(response.bytes + 28, "hello world", 11) == 0);
+
+  return TEST_PASS;
+}
+
+static enum test_return test_binary_append(void)
+{
+  return test_binary_concat_impl("test_binary_append", PROTOCOL_BINARY_CMD_APPEND);
+}
+
+static enum test_return test_binary_prepend(void)
+{
+  return test_binary_concat_impl("test_binary_prepend", PROTOCOL_BINARY_CMD_PREPEND);
+}
+
+static enum test_return test_binary_appendq(void)
+{
+  return test_binary_concat_impl("test_binary_appendq", PROTOCOL_BINARY_CMD_APPENDQ);
+}
+
+static enum test_return test_binary_prependq(void)
+{
+  return test_binary_concat_impl("test_binary_prependq", PROTOCOL_BINARY_CMD_PREPENDQ);
+}
+
+static enum test_return test_binary_stat(void)
+{
+  command command;
+  response response;
+
+  raw_command(&command, PROTOCOL_BINARY_CMD_STAT, NULL, 0, NULL, 0);
+  execute(send_packet(&command));
+
+  do
+  {
+    execute(recv_packet(&response));
+    verify(validate_response_header(&response, PROTOCOL_BINARY_CMD_STAT,
+                                    PROTOCOL_BINARY_RESPONSE_SUCCESS));
+  } while (response.plain.message.header.response.keylen != 0);
+
+  return TEST_PASS;
+}
+
+static enum test_return test_binary_illegal(void)
+{
+  command command;
+  response response;
+  uint8_t cmd= 0x1b;
+
+  while (cmd != 0x00)
+  {
+    raw_command(&command, cmd, NULL, 0, NULL, 0);
+    execute(send_packet(&command));
+    execute(recv_packet(&response));
+    verify(validate_response_header(&response, cmd, PROTOCOL_BINARY_RESPONSE_UNKNOWN_COMMAND));
+    ++cmd;
+  }
+
+  return TEST_PASS;
+}
+
+typedef enum test_return(*TEST_FUNC)(void);
+
+struct testcase
+{
+  const char *description;
+  TEST_FUNC function;
+};
+
+struct testcase testcases[]= {
+  { "noop", test_binary_noop},
+  { "quit", test_binary_quit},
+  { "quitq", test_binary_quitq},
+  { "set", test_binary_set},
+  { "setq", test_binary_setq},
+  { "flush", test_binary_flush},
+  { "flushq", test_binary_flushq},
+  { "add", test_binary_add},
+  { "addq", test_binary_addq},
+  { "replace", test_binary_replace},
+  { "replaceq", test_binary_replaceq},
+  { "delete", test_binary_delete},
+  { "deleteq", test_binary_deleteq},
+  { "get", test_binary_get},
+  { "getq", test_binary_getq},
+  { "getk", test_binary_getk},
+  { "getkq", test_binary_getkq},
+  { "incr", test_binary_incr},
+  { "incrq", test_binary_incrq},
+  { "decr", test_binary_decr},
+  { "decrq", test_binary_decrq},
+  { "version", test_binary_version},
+  { "append", test_binary_append},
+  { "appendq", test_binary_appendq},
+  { "prepend", test_binary_prepend},
+  { "prependq", test_binary_prependq},
+  { "stat", test_binary_stat},
+  { "illegal", test_binary_illegal},
+  { NULL, NULL}
+};
+
+int main(int argc, char **argv)
+{
+  static const char * const status_msg[]= {"[skip]", "[pass]", "[pass]", "[FAIL]"};
+  int total= 0;
+  int failed= 0;
+  const char *hostname= "localhost";
+  const char *port= "11211";
+  int cmd;
+
+  while ((cmd= getopt(argc, argv, "ch:p:?")) != EOF)
+  {
+    switch (cmd) {
+    case 'c': do_core= true;
+      break;
+    case 'h': hostname= optarg;
+      break;
+    case 'p': port= optarg;
+      break;
+    default:
+      fprintf(stderr, "Usage: %s [-h hostname] [-p port]\n", argv[0]);
+      return 1;
+    }
+  }
+
+  int sock= connect_server(hostname, port);
+  if (sock == -1)
+  {
+    fprintf(stderr, "Failed to connect to <%s:%s>: %s\n",
+            hostname, port, strerror(errno));
+    return 1;
+  }
+
+  for (int ii= 0; testcases[ii].description != NULL; ++ii)
+  {
+    ++total;
+    fprintf(stdout, "%s\t\t", testcases[ii].description);
+    fflush(stdout);
+
+    bool reconnect= false;
+    enum test_return ret= testcases[ii].function();
+    fprintf(stderr, "%s\n", status_msg[ret]);
+    if (ret == TEST_FAIL)
+    {
+      reconnect= true;
+      ++failed;
+    }
+    else if (ret == TEST_PASS_RECONNECT)
+      reconnect= true;
+
+    if (reconnect)
+    {
+      (void) close(sock);
+      if ((sock=connect_server(hostname, port)) == -1)
+      {
+        fprintf(stderr, "Failed to connect to <%s:%s>: %s\n",
+                hostname, port, strerror(errno));
+        fprintf(stderr, "%d of %d tests failed\n", failed, total);
+        return 1;
+      }
+    }
+  }
+
+  (void) close(sock);
+  if (failed == 0)
+    fprintf(stdout, "All tests passed\n");
+  else
+    fprintf(stderr, "%d of %d tests failed\n", failed, total);
+
+  return (failed == 0) ? 0 : 1;
+}