X-Git-Url: https://git.m6w6.name/?a=blobdiff_plain;ds=sidebyside;f=tests%2Fmem_functions.cc;h=8d9be93e629fd273d50ab523c9e4dd06e342c31f;hb=ea7a5dd332779c77eaef6d14eac58372cb3439e1;hp=093721b5cd29e52c64409b075b167cfeab4eaf7e;hpb=f8fd4b41acd1abf63eb305170638fa397afe06fa;p=awesomized%2Flibmemcached

diff --git a/tests/mem_functions.cc b/tests/mem_functions.cc
index 093721b5..8d9be93e 100644
--- a/tests/mem_functions.cc
+++ b/tests/mem_functions.cc
@@ -1809,10 +1809,7 @@ static test_return_t mget_execute(memcached_st *memc)
 
 static test_return_t key_setup(memcached_st *memc)
 {
-  (void)memc;
-
-  if (pre_binary(memc) != TEST_SUCCESS)
-    return TEST_SKIPPED;
+  test_skip(TEST_SUCCESS, pre_binary(memc));
 
   global_pairs= pairs_generate(REGRESSION_BINARY_VS_BLOCK_COUNT, 0);
 
@@ -1881,22 +1878,17 @@ static test_return_t version_string_test(memcached_st *memc)
 
 static test_return_t get_stats(memcached_st *memc)
 {
- char **stat_list;
- char **ptr;
  memcached_return_t rc;
- memcached_stat_st *memc_stat;
 
- memc_stat= memcached_stat(memc, NULL, &rc);
- test_true(rc == MEMCACHED_SUCCESS);
-
- test_true(rc == MEMCACHED_SUCCESS);
+ memcached_stat_st *memc_stat= memcached_stat(memc, NULL, &rc);
+ test_compare(MEMCACHED_SUCCESS, rc);
  test_true(memc_stat);
 
  for (uint32_t x= 0; x < memcached_server_count(memc); x++)
  {
-   stat_list= memcached_stat_get_keys(memc, memc_stat+x, &rc);
-   test_true(rc == MEMCACHED_SUCCESS);
-   for (ptr= stat_list; *ptr; ptr++);
+   char **stat_list= memcached_stat_get_keys(memc, memc_stat+x, &rc);
+   test_compare(MEMCACHED_SUCCESS, rc);
+   for (char **ptr= stat_list; *ptr; ptr++);
 
    free(stat_list);
  }
@@ -2589,34 +2581,34 @@ static test_return_t user_supplied_bug9(memcached_st *memc)
 static test_return_t user_supplied_bug10(memcached_st *memc)
 {
   const char *key= "foo";
-  char *value;
   size_t value_length= 512;
-  unsigned int x;
   size_t key_len= 3;
   unsigned int set= 1;
   memcached_st *mclone= memcached_clone(NULL, memc);
-  int32_t timeout;
 
   memcached_behavior_set(mclone, MEMCACHED_BEHAVIOR_NO_BLOCK, set);
   memcached_behavior_set(mclone, MEMCACHED_BEHAVIOR_TCP_NODELAY, set);
-  timeout= 2;
-  memcached_behavior_set(mclone, MEMCACHED_BEHAVIOR_POLL_TIMEOUT,
-                         (uint64_t)timeout);
+  int32_t timeout= 0;
+  memcached_behavior_set(mclone, MEMCACHED_BEHAVIOR_POLL_TIMEOUT, (uint64_t)timeout);
 
-  value = (char*)malloc(value_length * sizeof(char));
+  char *value= (char*)malloc(value_length * sizeof(char));
 
-  for (x= 0; x < value_length; x++)
+  for (unsigned int x= 0; x < value_length; x++)
+  {
     value[x]= (char) (x % 127);
+  }
 
-  for (x= 1; x <= 100000; ++x)
+  for (unsigned int x= 1; x <= 100000; ++x)
   {
     memcached_return_t rc= memcached_set(mclone, key, key_len,value, value_length, 0, 0);
 
-    test_true(rc == MEMCACHED_SUCCESS || rc == MEMCACHED_WRITE_FAILURE ||
-           rc == MEMCACHED_BUFFERED || rc == MEMCACHED_TIMEOUT);
+    test_true_got(rc == MEMCACHED_SUCCESS or rc == MEMCACHED_WRITE_FAILURE or rc == MEMCACHED_BUFFERED or rc == MEMCACHED_TIMEOUT or rc == MEMCACHED_CONNECTION_FAILURE, 
+                  memcached_strerror(NULL, rc));
 
-    if (rc == MEMCACHED_WRITE_FAILURE || rc == MEMCACHED_TIMEOUT)
+    if (rc == MEMCACHED_WRITE_FAILURE or rc == MEMCACHED_TIMEOUT)
+    {
       x--;
+    }
   }
 
   free(value);
@@ -2631,33 +2623,31 @@ static test_return_t user_supplied_bug10(memcached_st *memc)
 static test_return_t user_supplied_bug11(memcached_st *memc)
 {
   const char *key= "foo";
-  char *value;
   size_t value_length= 512;
-  unsigned int x;
   size_t key_len= 3;
-  memcached_return_t rc;
   unsigned int set= 1;
-  int32_t timeout;
   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);
-  timeout= -1;
-  memcached_behavior_set(mclone, MEMCACHED_BEHAVIOR_POLL_TIMEOUT,
-                         (size_t)timeout);
+  int32_t timeout= -1;
+  memcached_behavior_set(mclone, MEMCACHED_BEHAVIOR_POLL_TIMEOUT, (size_t)timeout);
 
   timeout= (int32_t)memcached_behavior_get(mclone, MEMCACHED_BEHAVIOR_POLL_TIMEOUT);
 
   test_true(timeout == -1);
 
-  value = (char*)malloc(value_length * sizeof(char));
+  char *value= (char*)malloc(value_length * sizeof(char));
 
-  for (x= 0; x < value_length; x++)
+  for (unsigned int x= 0; x < value_length; x++)
+  {
     value[x]= (char) (x % 127);
+  }
 
-  for (x= 1; x <= 100000; ++x)
+  for (unsigned int x= 1; x <= 100000; ++x)
   {
-    rc= memcached_set(mclone, key, key_len,value, value_length, 0, 0);
+    memcached_return_t rc= memcached_set(mclone, key, key_len,value, value_length, 0, 0);
+    (void)rc;
   }
 
   free(value);
@@ -3411,8 +3401,7 @@ static test_return_t get_read(memcached_st *memc)
 static test_return_t mget_read(memcached_st *memc)
 {
 
-  if (not libmemcached_util_version_check(memc, 1, 4, 4))
-    return TEST_SKIPPED;
+  test_skip(true, bool(libmemcached_util_version_check(memc, 1, 4, 4)));
 
   memcached_return_t rc= memcached_mget(memc, global_keys, global_keys_length, global_count);
 
@@ -3434,8 +3423,7 @@ static test_return_t mget_read(memcached_st *memc)
 static test_return_t mget_read_result(memcached_st *memc)
 {
 
-  if (not libmemcached_util_version_check(memc, 1, 4, 4))
-    return TEST_SKIPPED;
+  test_skip(true, bool(libmemcached_util_version_check(memc, 1, 4, 4)));
 
   memcached_return_t rc= memcached_mget(memc, global_keys, global_keys_length, global_count);
 
@@ -3460,9 +3448,7 @@ static test_return_t mget_read_result(memcached_st *memc)
 
 static test_return_t mget_read_function(memcached_st *memc)
 {
-
-  if (not libmemcached_util_version_check(memc, 1, 4, 4))
-    return TEST_SKIPPED;
+  test_skip(true, bool(libmemcached_util_version_check(memc, 1, 4, 4)));
 
   memcached_return_t rc= memcached_mget(memc, global_keys, global_keys_length, global_count);
 
@@ -3730,7 +3716,7 @@ static test_return_t pre_sasl(memcached_st *memc)
 
 static test_return_t pre_replication(memcached_st *memc)
 {
-  test_true(TEST_SUCCESS == pre_binary(memc));
+  test_skip(TEST_SUCCESS, pre_binary(memc));
 
   /*
    * Make sure that we store the item on all servers
@@ -3747,7 +3733,7 @@ static test_return_t pre_replication(memcached_st *memc)
 
 static test_return_t pre_replication_noblock(memcached_st *memc)
 {
-  test_compare(TEST_SUCCESS, pre_replication(memc));
+  test_skip(TEST_SUCCESS, pre_replication(memc));
 
   return pre_nonblock(memc);
 }
@@ -4077,15 +4063,13 @@ static test_return_t pre_settimer(memcached_st *memc)
 
 static test_return_t poll_timeout(memcached_st *memc)
 {
-  size_t timeout;
-
-  timeout= 100;
+  size_t timeout= 100; // Not using, just checking that it sets
 
   memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_POLL_TIMEOUT, timeout);
 
   timeout= (size_t)memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_POLL_TIMEOUT);
 
-  test_true(timeout == 100);
+  test_compare(100, timeout);
 
   return TEST_SUCCESS;
 }
@@ -4768,7 +4752,6 @@ static test_return_t memcached_get_MEMCACHED_ERRNO(memcached_st *memc)
 {
   (void)memc;
   memcached_st *tl_memc_h;
-  memcached_server_st *servers;
 
   const char *key= "MemcachedLives";
   size_t len;
@@ -4778,7 +4761,8 @@ static test_return_t memcached_get_MEMCACHED_ERRNO(memcached_st *memc)
 
   // Create a handle.
   tl_memc_h= memcached_create(NULL);
-  servers= memcached_servers_parse("localhost:9898,localhost:9899"); // This server should not exist
+  memcached_server_st *servers= memcached_servers_parse("localhost:9898,localhost:9899"); // This server should not exist
+  test_true(servers);
   memcached_server_push(tl_memc_h, servers);
   memcached_server_list_free(servers);
 
@@ -4786,7 +4770,7 @@ static test_return_t memcached_get_MEMCACHED_ERRNO(memcached_st *memc)
   value= memcached_get(tl_memc_h, key, strlen(key), &len, &flags, &rc);
 
   test_false(value);
-  test_true(len == 0);
+  test_compare(0, len);
   test_false(rc == MEMCACHED_SUCCESS);
 
   memcached_free(tl_memc_h);
@@ -5437,7 +5421,7 @@ static test_return_t test_multiple_get_last_disconnect(memcached_st *)
     {
       const char *msg=  memcached_strerror(memc, memcached_return_t(x));
       memcached_return_t ret= memcached_set(memc, msg, strlen(msg), NULL, 0, (time_t)0, (uint32_t)0);
-      test_compare_got(MEMCACHED_WRITE_FAILURE, ret, memcached_strerror(NULL, ret));
+      test_compare_got(MEMCACHED_CONNECTION_FAILURE, ret, memcached_last_error_message(memc));
 
       memcached_server_instance_st disconnected_server= memcached_server_get_last_disconnect(memc);
       test_true(disconnected_server);
@@ -5776,6 +5760,91 @@ static test_return_t regression_bug_581030(memcached_st *)
   return TEST_SUCCESS;
 }
 
+#define regression_bug_655423_COUNT 6000
+static test_return_t regression_bug_655423(memcached_st *memc)
+{
+  memcached_st *clone= memcached_clone(NULL, memc);
+  memc= NULL; // Just to make sure it is not used
+  test_true(clone);
+  char payload[100];
+
+  test_skip(MEMCACHED_SUCCESS, memcached_behavior_set(clone, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL, 1));
+  test_skip(MEMCACHED_SUCCESS, memcached_behavior_set(clone, MEMCACHED_BEHAVIOR_SUPPORT_CAS, 1));
+  test_skip(MEMCACHED_SUCCESS, memcached_behavior_set(clone, MEMCACHED_BEHAVIOR_TCP_NODELAY, 1));
+  test_skip(MEMCACHED_SUCCESS, memcached_behavior_set(clone, MEMCACHED_BEHAVIOR_IO_KEY_PREFETCH, 1));
+
+  memset(payload, int('x'), sizeof(payload));
+
+  for (uint32_t x= 0; x < regression_bug_655423_COUNT; x++)
+  {
+    char key[1024];
+    snprintf(key, sizeof(key), "%u", x);
+
+    test_compare(MEMCACHED_SUCCESS, memcached_set(clone, key, strlen(key), payload, sizeof(payload), 0, 0));
+  }
+
+  for (uint32_t x= 0; x < regression_bug_655423_COUNT; x++)
+  {
+    char key[1024];
+    snprintf(key, sizeof(key), "%u", x);
+
+    size_t value_length;
+    memcached_return_t rc;
+    char *value= memcached_get(clone, key, strlen(key), &value_length, NULL, &rc);
+
+    if (rc == MEMCACHED_NOTFOUND)
+    {
+      test_false(value);
+      test_compare(0, value_length);
+      continue;
+    }
+
+    test_compare(MEMCACHED_SUCCESS, rc);
+    test_true(value);
+    test_compare(100, value_length);
+    free(value);
+  }
+
+  char **keys= (char**)calloc(regression_bug_655423_COUNT, sizeof(char*));
+  size_t *key_length= (size_t *)calloc(regression_bug_655423_COUNT, sizeof(size_t));
+  for (uint32_t x= 0; x < regression_bug_655423_COUNT; x++)
+  {
+    char key[1024];
+    snprintf(key, sizeof(key), "%u", x);
+
+    keys[x]= strdup(key);
+    key_length[x]= strlen(key);
+  }
+
+  memcached_return_t rc;
+  test_compare_got(MEMCACHED_SUCCESS,
+                   rc= memcached_mget(clone, (const char* const *)keys, key_length, regression_bug_655423_COUNT),
+                   memcached_strerror(NULL, rc));
+
+  uint32_t count= 0;
+  memcached_result_st *result= NULL;
+  while ((result= memcached_fetch_result(clone, result, NULL)))
+  {
+    test_compare(100, memcached_result_length(result));
+    count++;
+  }
+
+  test_true(count > 100); // If we don't get back atleast this, something is up
+
+  /* Release all allocated resources */
+  for (size_t x= 0; x < regression_bug_655423_COUNT; ++x)
+  {
+    free(keys[x]);
+  }
+  free(keys);
+  free(key_length);
+
+
+  memcached_free(clone);
+
+  return TEST_SUCCESS;
+}
+
 static void memcached_die(memcached_st* mc, memcached_return error, const char* what, uint32_t it)
 {
   fprintf(stderr, "Iteration #%u: ", it);
@@ -6116,6 +6185,7 @@ test_st regression_tests[]= {
   {"lp:581030", 1, (test_callback_fn)regression_bug_581030 },
   {"lp:71231153 connect()", 1, (test_callback_fn)regression_bug_71231153_connect },
   {"lp:71231153 poll()", 1, (test_callback_fn)regression_bug_71231153_poll },
+  {"lp:655423", 1, (test_callback_fn)regression_bug_655423 },
   {0, 0, (test_callback_fn)0}
 };