Merge in exp/alias patches

diff --git a/libmemcached/delete.cc b/libmemcached/delete.cc
index 91799bbd3397d5932d0b9c2a84de6679b5c2ebb0..ed7510a61ec0dc034dfb9f10ead54ee4b4e7faf5 100644 (file)
--- a/libmemcached/delete.cc
+++ b/libmemcached/delete.cc
@@ -41,8 +41,7 @@
 memcached_return_t memcached_delete(memcached_st *ptr, const char *key, size_t key_length,
                                     time_t expiration)
 {
-  return memcached_delete_by_key(ptr, key, key_length,
-                                 key, key_length, expiration);
+  return memcached_delete_by_key(ptr, key, key_length, key, key_length, expiration);
 }
 
 static inline memcached_return_t ascii_delete(memcached_st *ptr,
@@ -50,65 +49,15 @@ static inline memcached_return_t ascii_delete(memcached_st *ptr,
                                               uint32_t ,
                                               const char *key,
                                               size_t key_length,
-                                              uint64_t expiration,
                                               bool& reply,
                                               bool& flush)
 {
   char buffer[MEMCACHED_DEFAULT_COMMAND_SIZE];
-  int send_length;
-
-  if (expiration)
-  {
-    if ((instance->major_version == 1 and
-         instance->minor_version > 2) or
-        instance->major_version > 1)
-    {
-      return memcached_set_error(*ptr, MEMCACHED_INVALID_ARGUMENTS, MEMCACHED_AT, 
-                                 memcached_literal_param("Memcached server version does not allow expiration of deleted items"));
-    }
-    else
-    {
-      /* ensure that we are connected, otherwise we might bump the
-       * command counter before connection */
-      memcached_return_t rc;
-      if ((rc= memcached_connect(instance)) != MEMCACHED_SUCCESS)
-      {
-        WATCHPOINT_ERROR(rc);
-        return rc;
-      }
-
-      if (instance->minor_version == 0)
-      {
-        if (reply == false or flush == false)
-        {
-          /* We might get out of sync with the server if we send this command
-           * to a server newer than 1.2.x..  enable reply and buffered mode.
-         */
-          flush= true;
-          if (reply == false)
-          {
-            memcached_server_response_increment(instance);
-          }
-          reply= true;
-        }
-      }
-
-      send_length= snprintf(buffer, MEMCACHED_DEFAULT_COMMAND_SIZE,
-                            "delete %.*s%.*s %u%s\r\n",
+  int send_length= snprintf(buffer, MEMCACHED_DEFAULT_COMMAND_SIZE,
+                            "delete %.*s%.*s%s\r\n",
                             memcached_print_array(ptr->_namespace),
-                            (int) key_length, key,
-                            (uint32_t)expiration,
+                            (int)key_length, key, 
                             reply ? "" :  " noreply");
-    }
-  }
-  else
-  {
-    send_length= snprintf(buffer, MEMCACHED_DEFAULT_COMMAND_SIZE,
-                          "delete %.*s%.*s%s\r\n",
-                          memcached_print_array(ptr->_namespace),
-                          (int)key_length, key, 
-                          reply ? "" :  " noreply");
-  }
 
   if (send_length >= MEMCACHED_DEFAULT_COMMAND_SIZE || send_length < 0)
   {
@@ -137,18 +86,11 @@ static inline memcached_return_t binary_delete(memcached_st *ptr,
                                                uint32_t server_key,
                                                const char *key,
                                                size_t key_length,
-                                               time_t expiration,
                                                bool& reply,
                                                bool& flush)
 {
   protocol_binary_request_delete request= {};
 
-  // No expiration is supported in the binary protocol
-  if (expiration)
-  {
-    return MEMCACHED_INVALID_ARGUMENTS;
-  }
-
   request.message.header.request.magic= PROTOCOL_BINARY_REQ;
   if (reply)
   {
@@ -236,6 +178,12 @@ memcached_return_t memcached_delete_by_key(memcached_st *ptr,
   {
     return rc;
   }
+
+  if (expiration)
+  {
+    return memcached_set_error(*ptr, MEMCACHED_INVALID_ARGUMENTS, MEMCACHED_AT, 
+                               memcached_literal_param("Memcached server version does not allow expiration of deleted items"));
+  }
   
   // If a delete trigger exists, we need a response, so no buffering/noreply
   if (ptr->delete_trigger)
@@ -264,11 +212,11 @@ memcached_return_t memcached_delete_by_key(memcached_st *ptr,
 
   if (ptr->flags.binary_protocol)
   {
-    rc= binary_delete(ptr, instance, server_key, key, key_length, expiration, reply, to_write);
+    rc= binary_delete(ptr, instance, server_key, key, key_length, reply, to_write);
   }
   else
   {
-    rc= ascii_delete(ptr, instance, server_key, key, key_length, expiration, reply, to_write);
+    rc= ascii_delete(ptr, instance, server_key, key, key_length, reply, to_write);
   }
 
   if (rc == MEMCACHED_SUCCESS)

diff --git a/tests/callbacks.cc b/tests/callbacks.cc
index c490e002c005d27f90dc4fc8a9cd41fd64f5ad1d..206e60924db5358775fa5445f3136acb94115475 100644 (file)
--- a/tests/callbacks.cc
+++ b/tests/callbacks.cc
@@ -42,6 +42,10 @@
 
 using namespace libtest;
 
+#ifndef __INTEL_COMPILER
+#pragma GCC diagnostic ignored "-Wstrict-aliasing"
+#endif
+
 static memcached_return_t delete_trigger(memcached_st *,
                                          const char *key,
                                          size_t key_length)

diff --git a/tests/mem_functions.cc b/tests/mem_functions.cc
index abf2ea45d5be1c0e64f4f8d9f5666106c28288fa..d6aaa7cbf6451c7904386125ae8a0fe531cc3aa6 100644 (file)
--- a/tests/mem_functions.cc
+++ b/tests/mem_functions.cc
@@ -910,6 +910,7 @@ static test_return_t bad_key_test(memcached_st *memc)
                  memcached_callback_set(memc_clone, MEMCACHED_CALLBACK_NAMESPACE, NULL));
 
     std::vector <char> longkey;
+    longkey.reserve(MEMCACHED_MAX_KEY);
     longkey.insert(longkey.end(), MEMCACHED_MAX_KEY, 'a');
     test_compare(longkey.size(), size_t(MEMCACHED_MAX_KEY));
     {
@@ -1054,15 +1055,12 @@ static test_return_t get_test2(memcached_st *memc)
 
 static test_return_t set_test2(memcached_st *memc)
 {
-  const char *key= "foo";
-  const char *value= "train in the brain";
-  size_t value_length= strlen(value);
-
   for (uint32_t x= 0; x < 10; x++)
   {
-    memcached_return_t rc= memcached_set(memc, key, strlen(key),
-                                         value, value_length,
-                                         (time_t)0, (uint32_t)0);
+    memcached_return_t rc= memcached_set(memc,
+                                         test_literal_param("foo"),
+                                         test_literal_param("train in the brain"),
+                                         time_t(0), uint32_t(0));
     test_true(rc == MEMCACHED_SUCCESS or rc == MEMCACHED_BUFFERED);
   }
 
@@ -1073,12 +1071,11 @@ static test_return_t set_test3(memcached_st *memc)
 {
   size_t value_length= 8191;
 
-  char *value= (char*)malloc(value_length);
-  test_true(value);
-
+  std::vector<char> value;
+  value.reserve(value_length);
   for (uint32_t x= 0; x < value_length; x++)
   {
-    value[x] = (char) (x % 127);
+    value.push_back(char(x % 127));
   }
 
   /* The dump test relies on there being at least 32 items in memcached */
@@ -1090,14 +1087,12 @@ static test_return_t set_test3(memcached_st *memc)
 
     uint64_t query_id= memcached_query_id(memc);
     memcached_return_t rc= memcached_set(memc, key, strlen(key),
-                                         value, value_length,
+                                         &value[0], value.size(),
                                          (time_t)0, (uint32_t)0);
     test_true_got(rc == MEMCACHED_SUCCESS or rc == MEMCACHED_BUFFERED, memcached_strerror(NULL, rc));
     test_compare(query_id +1, memcached_query_id(memc));
   }
 
-  free(value);
-
   return TEST_SUCCESS;
 }
 
@@ -1106,17 +1101,16 @@ static test_return_t get_test3(memcached_st *memc)
   const char *key= "foo";
   size_t value_length= 8191;
 
-  char *value= (char*)malloc(value_length);
-  test_true(value);
-
+  std::vector<char> value;
+  value.reserve(value_length);
   for (uint32_t x= 0; x < value_length; x++)
   {
-    value[x] = (char) (x % 127);
+    value.push_back(char(x % 127));
   }
 
   memcached_return_t rc;
   rc= memcached_set(memc, key, strlen(key),
-                    value, value_length,
+                    &value[0], value.size(),
                     (time_t)0, (uint32_t)0);
   test_true(rc == MEMCACHED_SUCCESS or rc == MEMCACHED_BUFFERED);
 
@@ -1128,10 +1122,9 @@ static test_return_t get_test3(memcached_st *memc)
   test_compare(MEMCACHED_SUCCESS, rc);
   test_true(string);
   test_compare(string_length, value_length);
-  test_memcmp(string, value, string_length);
+  test_memcmp(string, &value[0], string_length);
 
   free(string);
-  free(value);
 
   return TEST_SUCCESS;
 }
@@ -1141,16 +1134,15 @@ static test_return_t get_test4(memcached_st *memc)
   const char *key= "foo";
   size_t value_length= 8191;
 
-  char *value= (char*)malloc(value_length);
-  test_true(value);
-
+  std::vector<char> value;
+  value.reserve(value_length);
   for (uint32_t x= 0; x < value_length; x++)
   {
-    value[x] = (char) (x % 127);
+    value.push_back(char(x % 127));
   }
 
   memcached_return_t rc= memcached_set(memc, key, strlen(key),
-                                       value, value_length,
+                                       &value[0], value.size(),
                                        (time_t)0, (uint32_t)0);
   test_true(rc == MEMCACHED_SUCCESS or rc == MEMCACHED_BUFFERED);
 
@@ -1164,12 +1156,10 @@ static test_return_t get_test4(memcached_st *memc)
     test_compare(MEMCACHED_SUCCESS, rc);
     test_true(string);
     test_compare(string_length, value_length);
-    test_memcmp(string, value, string_length);
+    test_memcmp(string, &value[0], string_length);
     free(string);
   }
 
-  free(value);
-
   return TEST_SUCCESS;
 }
 
@@ -2275,8 +2265,9 @@ static test_return_t user_supplied_bug2(memcached_st *memc)
 /* Do a large mget() over all the keys we think exist */
 static test_return_t user_supplied_bug3(memcached_st *memc)
 {
-  test_compare(true, memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_NO_BLOCK, 1));
-  test_compare(true, memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_TCP_NODELAY, 1));
+  test_compare(MEMCACHED_SUCCESS, memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_NO_BLOCK, 1));
+  test_compare(MEMCACHED_SUCCESS, memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_TCP_NODELAY, 1));
+
 #ifdef NOT_YET
   setter = 20 * 1024576;
   memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_SOCKET_SEND_SIZE, setter);
@@ -2623,18 +2614,19 @@ static test_return_t user_supplied_bug10(memcached_st *memc)
   memcached_behavior_set(mclone, MEMCACHED_BEHAVIOR_TCP_NODELAY, set);
   memcached_behavior_set(mclone, MEMCACHED_BEHAVIOR_POLL_TIMEOUT, uint64_t(0));
 
-  char *value= (char*)malloc(value_length * sizeof(char));
-
-  for (unsigned int x= 0; x < value_length; x++)
+  std::vector<char> value;
+  value.reserve(value_length);
+  for (uint32_t x= 0; x < value_length; x++)
   {
-    value[x]= (char) (x % 127);
+    value.push_back(char(x % 127));
   }
 
   for (unsigned int x= 1; x <= 100000; ++x)
   {
     memcached_return_t rc= memcached_set(mclone, 
                                          test_literal_param("foo"),
-                                         value, value_length, 0, 0);
+                                         &value[0], value.size(),
+                                         0, 0);
 
     test_true_got((rc == MEMCACHED_SUCCESS or rc == MEMCACHED_WRITE_FAILURE or rc == MEMCACHED_BUFFERED or rc == MEMCACHED_TIMEOUT or rc == MEMCACHED_CONNECTION_FAILURE 
                    or rc == MEMCACHED_SERVER_TEMPORARILY_DISABLED), 
@@ -2646,7 +2638,6 @@ static test_return_t user_supplied_bug10(memcached_st *memc)
     }
   }
 
-  free(value);
   memcached_free(mclone);
 
   return TEST_SUCCESS;
@@ -2657,35 +2648,28 @@ static test_return_t user_supplied_bug10(memcached_st *memc)
 */
 static test_return_t user_supplied_bug11(memcached_st *memc)
 {
-  const char *key= "foo";
-  size_t value_length= 512;
-  size_t key_len= 3;
-  unsigned int set= 1;
   memcached_st *mclone= memcached_clone(NULL, memc);
 
-  memcached_behavior_set(mclone, MEMCACHED_BEHAVIOR_NO_BLOCK, set);
-  memcached_behavior_set(mclone, MEMCACHED_BEHAVIOR_TCP_NODELAY, set);
-  int32_t timeout= -1;
-  memcached_behavior_set(mclone, MEMCACHED_BEHAVIOR_POLL_TIMEOUT, (size_t)timeout);
+  memcached_behavior_set(mclone, MEMCACHED_BEHAVIOR_NO_BLOCK, true);
+  memcached_behavior_set(mclone, MEMCACHED_BEHAVIOR_TCP_NODELAY, true);
+  memcached_behavior_set(mclone, MEMCACHED_BEHAVIOR_POLL_TIMEOUT, size_t(-1));
 
-  timeout= (int32_t)memcached_behavior_get(mclone, MEMCACHED_BEHAVIOR_POLL_TIMEOUT);
+  test_compare(-1, int32_t(memcached_behavior_get(mclone, MEMCACHED_BEHAVIOR_POLL_TIMEOUT)));
 
-  test_true(timeout == -1);
 
-  char *value= (char*)malloc(value_length * sizeof(char));
-
-  for (unsigned int x= 0; x < value_length; x++)
+  std::vector<char> value;
+  value.reserve(512);
+  for (unsigned int x= 0; x < 512; x++)
   {
-    value[x]= (char) (x % 127);
+    value.push_back(char(x % 127));
   }
 
   for (unsigned int x= 1; x <= 100000; ++x)
   {
-    memcached_return_t rc= memcached_set(mclone, key, key_len,value, value_length, 0, 0);
+    memcached_return_t rc= memcached_set(mclone, test_literal_param("foo"), &value[0], value.size(), 0, 0);
     (void)rc;
   }
 
-  free(value);
   memcached_free(mclone);
 
   return TEST_SUCCESS;
@@ -2709,7 +2693,6 @@ static test_return_t user_supplied_bug12(memcached_st *memc)
 
   rc= memcached_increment(memc, "autoincrement", strlen("autoincrement"),
                           1, &number_value);
-
   test_true(value == NULL);
   /* The binary protocol will set the key if it doesn't exist */
   if (memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL) == 1)
@@ -2783,6 +2766,7 @@ static test_return_t user_supplied_bug14(memcached_st *memc)
   memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_TCP_NODELAY, true);
 
   std::vector<char> value;
+  value.reserve(18000);
   for (size_t x= 0; x < 18000; x++)
   {
     value.push_back((char) (x % 127));