X-Git-Url: https://git.m6w6.name/?a=blobdiff_plain;f=clients%2Fmemcapable.c;h=08524c495647de4aa300624b40931445d9ab64b8;hb=0bbb14508a90f9af985efc198428e1560ab9b44a;hp=36be2e55577ad6de9e04df4e51166dbfcf215f6f;hpb=e0c60fb6c74608ed7b935ff27042e8df0cf1ae2d;p=m6w6%2Flibmemcached

diff --git a/clients/memcapable.c b/clients/memcapable.c
index 36be2e55..08524c49 100644
--- a/clients/memcapable.c
+++ b/clients/memcapable.c
@@ -342,7 +342,7 @@ static enum test_return recv_packet(response *rsp)
  * @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
+ * @param exptime the expiry time for the key
  */
 static void storage_command(command *cmd,
                             uint8_t cc,
@@ -351,7 +351,7 @@ static void storage_command(command *cmd,
                             const void* dta,
                             size_t dtalen,
                             uint32_t flags,
-                            uint32_t exp)
+                            uint32_t exptime)
 {
   /* all of the storage commands use the same command layout */
   protocol_binary_request_set *request= &cmd->set;
@@ -364,7 +364,7 @@ static void storage_command(command *cmd,
   request->message.header.request.bodylen= (uint32_t)(keylen + 8 + dtalen);
   request->message.header.request.opaque= 0xdeadbeef;
   request->message.body.flags= flags;
-  request->message.body.expiration= exp;
+  request->message.body.expiration= exptime;
 
   off_t key_offset= sizeof (protocol_binary_request_no_extras) + 8;
   memcpy(cmd->bytes + key_offset, key, keylen);
@@ -435,7 +435,7 @@ static void flush_command(command *cmd,
  * @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
+ * @param exptime when the key should expire if it isn't set
  */
 static void arithmetic_command(command *cmd,
                                uint8_t cc,
@@ -443,7 +443,7 @@ static void arithmetic_command(command *cmd,
                                size_t keylen,
                                uint64_t delta,
                                uint64_t initial,
-                               uint32_t exp)
+                               uint32_t exptime)
 {
   memset(cmd, 0, sizeof (cmd->incr));
   cmd->incr.message.header.request.magic= PROTOCOL_BINARY_REQ;
@@ -454,7 +454,7 @@ static void arithmetic_command(command *cmd,
   cmd->incr.message.header.request.opaque= 0xdeadbeef;
   cmd->incr.message.body.delta= htonll(delta);
   cmd->incr.message.body.initial= htonll(initial);
-  cmd->incr.message.body.expiration= htonl(exp);
+  cmd->incr.message.body.expiration= htonl(exptime);
 
   off_t key_offset= sizeof (protocol_binary_request_no_extras) + 20;
   memcpy(cmd->bytes + key_offset, key, keylen);
@@ -575,18 +575,31 @@ static enum test_return do_validate_response_header(response *rsp,
 #define validate_response_header(a,b,c) \
         do_validate_response_header(a,b,c) == TEST_PASS
 
-static enum test_return test_binary_noop(void)
+
+static enum test_return send_binary_noop(void)
 {
   command cmd;
-  response rsp;
   raw_command(&cmd, PROTOCOL_BINARY_CMD_NOOP, NULL, 0, NULL, 0);
   execute(send_packet(&cmd));
+  return TEST_PASS;
+}
+
+static enum test_return receive_binary_noop(void)
+{
+  response rsp;
   execute(recv_packet(&rsp));
   verify(validate_response_header(&rsp, PROTOCOL_BINARY_CMD_NOOP,
                                   PROTOCOL_BINARY_RESPONSE_SUCCESS));
   return TEST_PASS;
 }
 
+static enum test_return test_binary_noop(void)
+{
+  execute(send_binary_noop());
+  execute(receive_binary_noop());
+  return TEST_PASS;
+}
+
 static enum test_return test_binary_quit_impl(uint8_t cc)
 {
   command cmd;
@@ -854,19 +867,23 @@ static enum test_return test_binary_get_impl(const char *key, uint8_t cc)
 
   raw_command(&cmd, cc, key, strlen(key), NULL, 0);
   execute(send_packet(&cmd));
+  execute(send_binary_noop());
 
   if (cc == PROTOCOL_BINARY_CMD_GET || cc == PROTOCOL_BINARY_CMD_GETK)
   {
     execute(recv_packet(&rsp));
     verify(validate_response_header(&rsp, cc, PROTOCOL_BINARY_RESPONSE_KEY_ENOENT));
   }
-  else
-    execute(test_binary_noop());
+
+  execute(receive_binary_noop());
 
   execute(binary_set_item(key, key));
   execute(resend_packet(&cmd));
+  execute(send_binary_noop());
+
   execute(recv_packet(&rsp));
   verify(validate_response_header(&rsp, cc, PROTOCOL_BINARY_RESPONSE_SUCCESS));
+  execute(receive_binary_noop());
 
   return TEST_PASS;
 }
@@ -1114,24 +1131,6 @@ static enum test_return test_binary_stat(void)
   return TEST_PASS;
 }
 
-static enum test_return test_binary_illegal(void)
-{
-  command cmd;
-  response rsp;
-  uint8_t cc= 0x1b;
-
-  while (cc != 0x00)
-  {
-    raw_command(&cmd, cc, NULL, 0, NULL, 0);
-    execute(send_packet(&cmd));
-    execute(recv_packet(&rsp));
-    verify(validate_response_header(&rsp, cc, PROTOCOL_BINARY_RESPONSE_UNKNOWN_COMMAND));
-    ++cc;
-  }
-
-  return TEST_PASS_RECONNECT;
-}
-
 static enum test_return send_string(const char *cmd)
 {
   execute(retry_write(cmd, strlen(cmd)));
@@ -1163,19 +1162,32 @@ static enum test_return receive_line(char *buffer, size_t size)
 static enum test_return receive_response(const char *msg) {
   char buffer[80];
   execute(receive_line(buffer, sizeof(buffer)));
+  if (strcmp(msg, buffer) != 0) {
+      fprintf(stderr, "[%s]\n", buffer);
+  }
   verify(strcmp(msg, buffer) == 0);
   return TEST_PASS;
 }
 
+static enum test_return receive_error_response(void)
+{
+  char buffer[80];
+  execute(receive_line(buffer, sizeof(buffer)));
+  verify(strncmp(buffer, "ERROR", 5) == 0 ||
+         strncmp(buffer, "CLIENT_ERROR", 12) == 0 ||
+         strncmp(buffer, "SERVER_ERROR", 12) == 0);
+  return TEST_PASS;
+}
+
 static enum test_return test_ascii_quit(void)
 {
   /* Verify that quit handles unknown options */
   execute(send_string("quit foo bar\r\n"));
-  execute(receive_response("ERROR\r\n"));
+  execute(receive_error_response());
 
   /* quit doesn't support noreply */
   execute(send_string("quit noreply\r\n"));
-  execute(receive_response("ERROR\r\n"));
+  execute(receive_error_response());
 
   /* Verify that quit works */
   execute(send_string("quit\r\n"));
@@ -1191,11 +1203,11 @@ static enum test_return test_ascii_version(void)
 {
   /* Verify that version command handles unknown options */
   execute(send_string("version foo bar\r\n"));
-  execute(receive_response("ERROR\r\n"));
+  execute(receive_error_response());
 
   /* version doesn't support noreply */
   execute(send_string("version noreply\r\n"));
-  execute(receive_response("ERROR\r\n"));
+  execute(receive_error_response());
 
   /* Verify that verify works */
   execute(send_string("version\r\n"));
@@ -1210,16 +1222,16 @@ static enum test_return test_ascii_verbosity(void)
 {
   /* This command does not adhere to the spec! */
   execute(send_string("verbosity foo bar my\r\n"));
-  execute(receive_response("ERROR\r\n"));
+  execute(receive_error_response());
 
   execute(send_string("verbosity noreply\r\n"));
-  execute(test_ascii_version());
+  execute(receive_error_response());
 
   execute(send_string("verbosity 0 noreply\r\n"));
   execute(test_ascii_version());
 
   execute(send_string("verbosity\r\n"));
-  execute(receive_response("ERROR\r\n"));
+  execute(receive_error_response());
 
   execute(send_string("verbosity 1\r\n"));
   execute(receive_response("OK\r\n"));
@@ -1492,10 +1504,10 @@ static enum test_return test_ascii_delete_impl(const char *key, bool noreply)
   execute(ascii_set_item(key, "value"));
 
   execute(send_string("delete\r\n"));
-  execute(receive_response("ERROR\r\n"));
+  execute(receive_error_response());
   /* BUG: the server accepts delete a b */
   execute(send_string("delete a b c d e\r\n"));
-  execute(receive_response("ERROR\r\n"));
+  execute(receive_error_response());
 
   char buffer[1024];
   sprintf(buffer, "delete %s%s\r\n", key, noreply ? " noreply" : "");
@@ -1531,7 +1543,7 @@ static enum test_return test_ascii_get(void)
   execute(ascii_set_item("test_ascii_get", "value"));
 
   execute(send_string("get\r\n"));
-  execute(receive_response("ERROR\r\n"));
+  execute(receive_error_response());
   execute(ascii_get_item("test_ascii_get", "value", true));
   execute(ascii_get_item("test_ascii_get_notfound", "value", false));
 
@@ -1543,7 +1555,7 @@ static enum test_return test_ascii_gets(void)
   execute(ascii_set_item("test_ascii_gets", "value"));
 
   execute(send_string("gets\r\n"));
-  execute(receive_response("ERROR\r\n"));
+  execute(receive_error_response());
   unsigned long cas;
   execute(ascii_gets_item("test_ascii_gets", "value", true, &cas));
   execute(ascii_gets_item("test_ascii_gets_notfound", "value", false, &cas));
@@ -1664,7 +1676,7 @@ static enum test_return test_ascii_flush_impl(const char *key, bool noreply)
   /* Verify that the flush_all command handles unknown options */
   /* Bug in the current memcached server! */
   execute(send_string("flush_all foo bar\r\n"));
-  execute(receive_response("ERROR\r\n"));
+  execute(receive_error_response());
 #endif
 
   execute(ascii_set_item(key, key));
@@ -1765,7 +1777,7 @@ static enum test_return test_ascii_prepend_noreply(void)
 static enum test_return test_ascii_stat(void)
 {
   execute(send_string("stats noreply\r\n"));
-  execute(receive_response("ERROR\r\n"));
+  execute(receive_error_response());
   execute(send_string("stats\r\n"));
   char buffer[1024];
   do {
@@ -1838,7 +1850,6 @@ struct testcase testcases[]= {
   { "binary prepend", test_binary_prepend },
   { "binary prependq", test_binary_prependq },
   { "binary stat", test_binary_stat },
-  { "binary illegal", test_binary_illegal },
   { NULL, NULL}
 };