X-Git-Url: https://git.m6w6.name/?a=blobdiff_plain;f=tests%2Flibmemcached-1.0%2Fmem_functions.cc;h=dfd7d21e2171e3993d43cafacacaafd4e325fe43;hb=59e77031ba00e924cb7f8a2863e858f10cbcb9f8;hp=83ea4460e2fefd45aadfc9093ba3474f3a8077b0;hpb=51351e672a6a1626e09d5a9d41e3229df44fc3c8;p=m6w6%2Flibmemcached

diff --git a/tests/libmemcached-1.0/mem_functions.cc b/tests/libmemcached-1.0/mem_functions.cc
index 83ea4460..dfd7d21e 100644
--- a/tests/libmemcached-1.0/mem_functions.cc
+++ b/tests/libmemcached-1.0/mem_functions.cc
@@ -78,6 +78,8 @@
 #include "tests/ketama.h"
 #include "tests/namespace.h"
 #include "tests/parser.h"
+#include "tests/libmemcached-1.0/dump.h"
+#include "tests/libmemcached-1.0/stat.h"
 #include "tests/touch.h"
 #include "tests/callbacks.h"
 #include "tests/pool.h"
@@ -465,7 +467,7 @@ static test_return_t libmemcached_string_behavior_test(memcached_st *)
   {
     test_true(libmemcached_string_behavior(memcached_behavior_t(x)));
   }
-  test_compare(36, int(MEMCACHED_BEHAVIOR_MAX));
+  test_compare(37, int(MEMCACHED_BEHAVIOR_MAX));
 
   return TEST_SUCCESS;
 }
@@ -485,7 +487,7 @@ static test_return_t memcached_return_t_TEST(memcached_st *memc)
 {
   uint32_t values[] = { 851992627U, 2337886783U, 4109241422U, 4001849190U,
                         982370485U, 1263635348U, 4242906218U, 3829656100U,
-                        1891735253U, 334139633U, 2257084983U, 3088286104U,
+                        1891735253U, 334139633U, 2257084983U, 3351789013U,
                         13199785U, 2542027183U, 1097051614U, 199566778U,
                         2748246961U, 2465192557U, 1664094137U, 2405439045U,
                         1842224848U, 692413798U, 3479807801U, 919913813U,
@@ -880,7 +882,7 @@ static test_return_t bad_key_test(memcached_st *memc)
   test_compare(query_id, memcached_query_id(memc_clone)); // We should not increase the query_id for memcached_behavior_set()
 
   /* All keys are valid in the binary protocol (except for length) */
-  if (not memcached_behavior_get(memc_clone, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL))
+  if (memcached_behavior_get(memc_clone, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL) == false)
   {
     uint64_t before_query_id= memcached_query_id(memc_clone);
     {
@@ -920,7 +922,8 @@ static test_return_t bad_key_test(memcached_st *memc)
     test_compare(query_id +1, memcached_query_id(memc_clone));
 
     query_id= memcached_query_id(memc_clone);
-    test_compare(MEMCACHED_BAD_KEY_PROVIDED,
+    // Grouping keys are not required to follow normal key behaviors
+    test_compare(MEMCACHED_SUCCESS,
                  memcached_mget_by_key(memc_clone, "foo daddy", 9, keys, key_lengths, 1));
     test_compare(query_id +1, memcached_query_id(memc_clone));
 
@@ -997,8 +1000,8 @@ static test_return_t read_through(memcached_st *memc)
   test_false(string_length);
   test_false(string);
 
-  rc= memcached_callback_set(memc, MEMCACHED_CALLBACK_GET_FAILURE, *(void **)&cb);
-  test_compare(MEMCACHED_SUCCESS, rc);
+  test_compare(MEMCACHED_SUCCESS,
+               memcached_callback_set(memc, MEMCACHED_CALLBACK_GET_FAILURE, *(void **)&cb));
 
   string= memcached_get(memc,
                         test_literal_param(__func__),
@@ -1035,7 +1038,7 @@ static test_return_t get_test(memcached_st *memc)
   rc= memcached_delete(memc,
                        test_literal_param(__func__),
                        time_t(0));
-  test_true_got(rc == MEMCACHED_BUFFERED || rc == MEMCACHED_NOTFOUND, memcached_last_error_message(memc));
+  test_true_got(rc == MEMCACHED_BUFFERED or rc == MEMCACHED_NOTFOUND, memcached_last_error_message(memc));
   test_compare(query_id +1, memcached_query_id(memc));
 
   string= memcached_get(memc,
@@ -1253,8 +1256,6 @@ static test_return_t mget_end(memcached_st *memc)
   size_t lengths[]= { 3, 4 };
   const char *values[]= { "fjord", "41" };
 
-  memcached_return_t rc;
-
   // Set foo and foo2
   for (size_t x= 0; x < test_array_length(keys); x++)
   {
@@ -1277,6 +1278,7 @@ static test_return_t mget_end(memcached_st *memc)
 
   char key[MEMCACHED_MAX_KEY];
   size_t key_length;
+  memcached_return_t rc;
 
   // this should get both
   for (size_t x= 0; x < test_array_length(keys); x++)
@@ -1382,25 +1384,24 @@ static test_return_t increment_with_initial_test(memcached_st *memc)
 
 static test_return_t decrement_test(memcached_st *memc)
 {
-  uint64_t new_number;
-  memcached_return_t rc;
-  const char *value= "3";
-
-  rc= memcached_set(memc,
-                    test_literal_param("number"),
-                    value, strlen(value),
-                    (time_t)0, (uint32_t)0);
-  test_true(rc == MEMCACHED_SUCCESS or rc == MEMCACHED_BUFFERED);
+  test_compare(return_value_based_on_buffering(memc),
+               memcached_set(memc,
+                             test_literal_param(__func__),
+                             test_literal_param("3"),
+                             time_t(0), uint32_t(0)));
+  // Make sure we flush the value we just set
+  test_compare(MEMCACHED_SUCCESS, memcached_flush_buffers(memc));
 
+  uint64_t new_number;
   test_compare(MEMCACHED_SUCCESS,
                memcached_decrement(memc,
-                                   test_literal_param("number"),
+                                   test_literal_param(__func__),
                                    1, &new_number));
   test_compare(uint64_t(2), new_number);
 
   test_compare(MEMCACHED_SUCCESS,
                memcached_decrement(memc,
-                                   test_literal_param("number"),
+                                   test_literal_param(__func__),
                                    1, &new_number));
   test_compare(uint64_t(1), new_number);
 
@@ -1411,21 +1412,23 @@ static test_return_t decrement_with_initial_test(memcached_st *memc)
 {
   test_skip(true, memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL));
 
-  uint64_t new_number;
   uint64_t initial= 3;
 
   test_compare(MEMCACHED_SUCCESS, memcached_flush_buffers(memc));
 
+  uint64_t new_number;
   test_compare(MEMCACHED_SUCCESS,
                memcached_decrement_with_initial(memc,
-                                                test_literal_param("number"),
-                                                1, initial, 0, &new_number));
+                                                test_literal_param(__func__),
+                                                1, initial, 
+                                                0, &new_number));
   test_compare(new_number, initial);
 
   test_compare(MEMCACHED_SUCCESS,
                memcached_decrement_with_initial(memc,
-                                                test_literal_param("number"),
-                                                1, initial, 0, &new_number));
+                                                test_literal_param(__func__),
+                                                1, initial, 
+                                                0, &new_number));
   test_compare(new_number, (initial - 1));
 
   return TEST_SUCCESS;
@@ -1433,24 +1436,28 @@ static test_return_t decrement_with_initial_test(memcached_st *memc)
 
 static test_return_t increment_by_key_test(memcached_st *memc)
 {
-  uint64_t new_number;
-  memcached_return_t rc;
   const char *master_key= "foo";
   const char *key= "number";
   const char *value= "0";
 
-  rc= memcached_set_by_key(memc, master_key, strlen(master_key),
-                           key, strlen(key),
-                           value, strlen(value),
-                           (time_t)0, (uint32_t)0);
-  test_true(rc == MEMCACHED_SUCCESS or rc == MEMCACHED_BUFFERED);
+  test_compare(return_value_based_on_buffering(memc),
+               memcached_set_by_key(memc, master_key, strlen(master_key),
+                                    key, strlen(key),
+                                    value, strlen(value),
+                                    time_t(0), uint32_t(0)));
+  
+  // Make sure we flush the value we just set
+  test_compare(MEMCACHED_SUCCESS, memcached_flush_buffers(memc));
 
+  uint64_t new_number;
   test_compare(MEMCACHED_SUCCESS,
-               memcached_increment_by_key(memc, master_key, strlen(master_key), key, strlen(key), 1, &new_number));
+               memcached_increment_by_key(memc, master_key, strlen(master_key),
+                                          key, strlen(key), 1, &new_number));
   test_compare(uint64_t(1), new_number);
 
   test_compare(MEMCACHED_SUCCESS,
-               memcached_increment_by_key(memc, master_key, strlen(master_key), key, strlen(key), 1, &new_number));
+               memcached_increment_by_key(memc, master_key, strlen(master_key),
+                                          key, strlen(key), 1, &new_number));
   test_compare(uint64_t(2), new_number);
 
   return TEST_SUCCESS;
@@ -1461,21 +1468,20 @@ static test_return_t increment_with_initial_by_key_test(memcached_st *memc)
   test_skip(true, memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL));
 
   uint64_t new_number;
-  memcached_return_t rc;
   const char *master_key= "foo";
   const char *key= "number";
   uint64_t initial= 0;
 
-  rc= memcached_increment_with_initial_by_key(memc, master_key, strlen(master_key),
-                                              key, strlen(key),
-                                              1, initial, 0, &new_number);
-  test_compare(MEMCACHED_SUCCESS, rc);
+  test_compare(MEMCACHED_SUCCESS,
+               memcached_increment_with_initial_by_key(memc, master_key, strlen(master_key),
+                                                       key, strlen(key),
+                                                       1, initial, 0, &new_number));
   test_compare(new_number, initial);
 
-  rc= memcached_increment_with_initial_by_key(memc, master_key, strlen(master_key),
-                                              key, strlen(key),
-                                              1, initial, 0, &new_number);
-  test_compare(MEMCACHED_SUCCESS, rc);
+  test_compare(MEMCACHED_SUCCESS,
+               memcached_increment_with_initial_by_key(memc, master_key, strlen(master_key),
+                                                       key, strlen(key),
+                                                       1, initial, 0, &new_number));
   test_compare(new_number, (initial +1));
 
   return TEST_SUCCESS;
@@ -1484,15 +1490,14 @@ static test_return_t increment_with_initial_by_key_test(memcached_st *memc)
 static test_return_t decrement_by_key_test(memcached_st *memc)
 {
   uint64_t new_number;
-  memcached_return_t rc;
   const char *value= "3";
 
-  rc= memcached_set_by_key(memc,
-                           test_literal_param("foo"),
-                           test_literal_param("number"),
-                           value, strlen(value),
-                           (time_t)0, (uint32_t)0);
-  test_true(rc == MEMCACHED_SUCCESS or rc == MEMCACHED_BUFFERED);
+  test_compare(return_value_based_on_buffering(memc),
+               memcached_set_by_key(memc,
+                                    test_literal_param("foo"),
+                                    test_literal_param("number"),
+                                    value, strlen(value),
+                                    (time_t)0, (uint32_t)0));
 
   test_compare(MEMCACHED_SUCCESS,
                memcached_decrement_by_key(memc,
@@ -1534,20 +1539,17 @@ static test_return_t decrement_with_initial_by_key_test(memcached_st *memc)
 
   return TEST_SUCCESS;
 }
-static test_return_t binary_increment_with_prefix_test(memcached_st *orig_memc)
+static test_return_t binary_increment_with_prefix_test(memcached_st *memc)
 {
-  memcached_st *memc= memcached_clone(NULL, orig_memc);
-
-  test_skip(TEST_SUCCESS, pre_binary(memc));
+  test_skip(true, memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL));
 
   test_compare(MEMCACHED_SUCCESS, memcached_callback_set(memc, MEMCACHED_CALLBACK_PREFIX_KEY, (void *)"namespace:"));
 
-  memcached_return_t rc;
-  rc= memcached_set(memc,
-                    test_literal_param("number"),
-                    test_literal_param("0"),
-                    (time_t)0, (uint32_t)0);
-  test_true(rc == MEMCACHED_SUCCESS || rc == MEMCACHED_BUFFERED);
+  test_compare(return_value_based_on_buffering(memc),
+               memcached_set(memc,
+                             test_literal_param("number"),
+                             test_literal_param("0"),
+                             (time_t)0, (uint32_t)0));
 
   uint64_t new_number;
   test_compare(MEMCACHED_SUCCESS, memcached_increment(memc, 
@@ -1559,27 +1561,26 @@ static test_return_t binary_increment_with_prefix_test(memcached_st *orig_memc)
                                                       test_literal_param("number"),
                                                       1, &new_number));
   test_compare(uint64_t(2), new_number);
-  memcached_free(memc);
 
   return TEST_SUCCESS;
 }
 
 static test_return_t quit_test(memcached_st *memc)
 {
-  memcached_return_t rc;
-  const char *key= "fudge";
   const char *value= "sanford and sun";
 
-  rc= memcached_set(memc, key, strlen(key),
-                    value, strlen(value),
-                    (time_t)10, (uint32_t)3);
-  test_true_got(rc == MEMCACHED_SUCCESS or rc == MEMCACHED_BUFFERED, memcached_strerror(NULL, rc));
+  test_compare(return_value_based_on_buffering(memc),
+               memcached_set(memc,
+                             test_literal_param(__func__),
+                             value, strlen(value),
+                             (time_t)10, (uint32_t)3));
   memcached_quit(memc);
 
-  rc= memcached_set(memc, key, strlen(key),
-                    value, strlen(value),
-                    (time_t)50, (uint32_t)9);
-  test_true(rc == MEMCACHED_SUCCESS or rc == MEMCACHED_BUFFERED);
+  test_compare(return_value_based_on_buffering(memc),
+               memcached_set(memc,
+                             test_literal_param(__func__),
+                             value, strlen(value),
+                             (time_t)50, (uint32_t)9));
 
   return TEST_SUCCESS;
 }
@@ -1706,16 +1707,15 @@ static test_return_t mget_result_function(memcached_st *memc)
   size_t counter;
   memcached_execute_fn callbacks[1];
 
-  /* We need to empty the server before continueing test */
-  test_compare(MEMCACHED_SUCCESS,
-               memcached_flush(memc, 0));
   for (uint32_t x= 0; x < 3; x++)
   {
-    memcached_return_t rc= memcached_set(memc, keys[x], key_length[x],
-                                         keys[x], key_length[x],
-                                         (time_t)50, (uint32_t)9);
-    test_true(rc == MEMCACHED_SUCCESS || rc == MEMCACHED_BUFFERED);
+    test_compare(return_value_based_on_buffering(memc), 
+                 memcached_set(memc, keys[x], key_length[x],
+                               keys[x], key_length[x],
+                               time_t(50), uint32_t(9)));
   }
+  test_compare(MEMCACHED_SUCCESS, memcached_flush_buffers(memc));
+  memcached_quit(memc);
 
   test_compare(MEMCACHED_SUCCESS,
                memcached_mget(memc, keys, key_length, 3));
@@ -1741,10 +1741,6 @@ static test_return_t mget_test(memcached_st *memc)
   char *return_value;
   size_t return_value_length;
 
-  /* We need to empty the server before continueing test */
-  test_compare(MEMCACHED_SUCCESS,
-               memcached_flush(memc, 0));
-
   test_compare(MEMCACHED_SUCCESS,
                memcached_mget(memc, keys, key_length, 3));
 
@@ -2119,36 +2115,25 @@ static test_return_t MEMCACHED_BEHAVIOR_TCP_KEEPIDLE_test(memcached_st *memc)
   return TEST_SUCCESS;
 }
 
-static test_return_t fetch_all_results(memcached_st *memc, unsigned int &keys_returned, const memcached_return_t expect)
+static test_return_t fetch_all_results(memcached_st *memc, unsigned int &keys_returned, memcached_return_t& rc)
 {
-  memcached_return_t rc;
-  char return_key[MEMCACHED_MAX_KEY];
-  size_t return_key_length;
-  char *return_value;
-  size_t return_value_length;
-  uint32_t flags;
-
   keys_returned= 0;
-  while ((return_value= memcached_fetch(memc, return_key, &return_key_length,
-                                        &return_value_length, &flags, &rc)))
+
+  memcached_result_st* result= NULL;
+  while ((result= memcached_fetch_result(memc, result, &rc)))
   {
-    test_true(return_value);
-    test_compare_got(MEMCACHED_SUCCESS, rc, memcached_strerror(NULL, rc));
-    free(return_value);
+    test_compare(MEMCACHED_SUCCESS, rc);
     keys_returned+= 1;
   }
+  memcached_result_free(result);
 
-  if (memcached_success(expect) and memcached_success(rc))
-  {
-    return TEST_SUCCESS;
-  }
-  else if (expect == rc)
-  {
-    return TEST_SUCCESS;
-  }
-  fprintf(stderr, "\n%s:%u %s(#%u)\n", __FILE__, __LINE__, memcached_strerror(NULL, rc), keys_returned);
+  return TEST_SUCCESS;
+}
 
-  return TEST_FAILURE;
+static test_return_t fetch_all_results(memcached_st *memc, unsigned int &keys_returned)
+{
+  memcached_return_t rc;
+  return fetch_all_results(memc, keys_returned, rc);
 }
 
 /* Test case provided by Cal Haldenbrand */
@@ -2180,10 +2165,12 @@ static test_return_t user_supplied_bug1(memcached_st *memc)
     }
 
     total+= size;
-    char key[22];
+    char key[MEMCACHED_MAXIMUM_INTEGER_DISPLAY_LENGTH +1];
     int key_length= snprintf(key, sizeof(key), "%u", x);
     test_compare(MEMCACHED_SUCCESS,
-                 memcached_set(memc, key, key_length, randomstuff, strlen(randomstuff), time_t(0), HALDENBRAND_FLAG_KEY));
+                 memcached_set(memc, key, key_length,
+                               randomstuff, strlen(randomstuff),
+                               time_t(0), HALDENBRAND_FLAG_KEY));
   }
   test_true(total > HALDENBRAND_KEY_COUNT);
 
@@ -2233,10 +2220,11 @@ static test_return_t user_supplied_bug2(memcached_st *memc)
       continue;
     }
     test_compare(uint32_t(HALDENBRAND_FLAG_KEY), flags);
+    test_true(getval);
 
     total_value_length+= val_len;
     errors= 0;
-    free(getval);
+    ::free(getval);
   }
 
   return TEST_SUCCESS;
@@ -2245,8 +2233,8 @@ 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(MEMCACHED_SUCCESS, memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_NO_BLOCK, 1));
-  test_compare(MEMCACHED_SUCCESS, memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_TCP_NODELAY, 1));
+  test_compare(MEMCACHED_SUCCESS, memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_NO_BLOCK, true));
+  test_compare(MEMCACHED_SUCCESS, memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_TCP_NODELAY, true));
 
 #ifdef NOT_YET
   memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_SOCKET_SEND_SIZE, 20 * 1024576);
@@ -2272,14 +2260,14 @@ static test_return_t user_supplied_bug3(memcached_st *memc)
                memcached_mget(memc, &keys[0], &key_lengths[0], key_lengths.size()));
 
   unsigned int keys_returned;
-  test_compare(TEST_SUCCESS, fetch_all_results(memc, keys_returned, MEMCACHED_SUCCESS));
+  test_compare(TEST_SUCCESS, fetch_all_results(memc, keys_returned));
   test_compare(HALDENBRAND_KEY_COUNT, keys_returned);
 
   for (std::vector<char *>::iterator iter= keys.begin();
        iter != keys.end();
        iter++)
   {
-    free(*iter);
+    ::free(*iter);
   }
 
   return TEST_SUCCESS;
@@ -2302,9 +2290,13 @@ static test_return_t user_supplied_bug4(memcached_st *memc)
   test_compare(MEMCACHED_NO_SERVERS,
                memcached_mget(memc, keys, key_length, 3));
 
-  unsigned int keys_returned;
-  test_compare(TEST_SUCCESS, fetch_all_results(memc, keys_returned, MEMCACHED_NOTFOUND));
-  test_zero(keys_returned);
+  {
+    unsigned int keys_returned;
+    memcached_return_t rc;
+    test_compare(TEST_SUCCESS, fetch_all_results(memc, keys_returned, rc));
+    test_compare(MEMCACHED_NOTFOUND, rc);
+    test_zero(keys_returned);
+  }
 
   for (uint32_t x= 0; x < 3; x++)
   {
@@ -2364,7 +2356,8 @@ static test_return_t user_supplied_bug5(memcached_st *memc)
                memcached_mget(memc, keys, key_length, 4));
 
   unsigned int count;
-  test_compare(TEST_SUCCESS, fetch_all_results(memc, count, MEMCACHED_NOTFOUND));
+  test_compare(TEST_SUCCESS, fetch_all_results(memc, count, rc));
+  test_compare(MEMCACHED_NOTFOUND, rc);
   test_zero(count);
 
   for (uint32_t x= 0; x < 4; x++)
@@ -2381,12 +2374,12 @@ static test_return_t user_supplied_bug5(memcached_st *memc)
                          &value_length, &flags, &rc);
     test_compare(rc, MEMCACHED_SUCCESS);
     test_true(value);
-    free(value);
+    ::free(value);
 
     test_compare(MEMCACHED_SUCCESS,
                  memcached_mget(memc, keys, key_length, 4));
 
-    test_compare(TEST_SUCCESS, fetch_all_results(memc, count, MEMCACHED_SUCCESS));
+    test_compare(TEST_SUCCESS, fetch_all_results(memc, count));
     test_compare(4U, count);
   }
   delete [] insert_data;
@@ -3128,7 +3121,7 @@ static test_return_t generate_data(memcached_st *memc)
 {
   unsigned int check_execute= execute_set(memc, global_pairs, global_count);
 
-  test_compare(global_count, check_execute);
+  test_compare_warn_hint(global_count, check_execute, "Possible false, positive, memcached may have ejected key/value based on memory needs");
 
   return TEST_SUCCESS;
 }
@@ -3205,6 +3198,7 @@ static test_return_t get_read_count(memcached_st *memc)
 
 static test_return_t get_read(memcached_st *memc)
 {
+  size_t keys_returned= 0;
   for (size_t x= 0; x < global_count; x++)
   {
     size_t return_value_length;
@@ -3218,9 +3212,11 @@ static test_return_t get_read(memcached_st *memc)
     */
     if (rc == MEMCACHED_SUCCESS && return_value)
     {
+      keys_returned++;
       free(return_value);
     }
   }
+  test_compare_warn_hint(global_count, keys_returned, "Possible false, positive, memcached may have ejected key/value based on memory needs");
 
   return TEST_SUCCESS;
 }
@@ -3236,7 +3232,7 @@ static test_return_t mget_read(memcached_st *memc)
   // Go fetch the keys and test to see if all of them were returned
   {
     unsigned int keys_returned;
-    test_compare(TEST_SUCCESS, fetch_all_results(memc, keys_returned, MEMCACHED_SUCCESS));
+    test_compare(TEST_SUCCESS, fetch_all_results(memc, keys_returned));
     test_true(keys_returned > 0);
     test_compare_warn_hint(global_count, keys_returned, "Possible false, positive, memcached may have ejected key/value based on memory needs");
   }
@@ -3361,10 +3357,15 @@ static test_return_t mget_read_function(memcached_st *memc)
 
 static test_return_t delete_generate(memcached_st *memc)
 {
+  size_t total= 0;
   for (size_t x= 0; x < global_count; x++)
   {
-    (void)memcached_delete(memc, global_keys[x], global_keys_length[x], (time_t)0);
+    if (memcached_success(memcached_delete(memc, global_keys[x], global_keys_length[x], (time_t)0)))
+    {
+      total++;
+    }
   }
+  test_compare_warn_hint(global_count, total, "Possible false, positive, memcached may have ejected key/value based on memory needs");
 
   return TEST_SUCCESS;
 }
@@ -3373,10 +3374,15 @@ static test_return_t delete_buffer_generate(memcached_st *memc)
 {
   memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_BUFFER_REQUESTS, true);
 
+  size_t total= 0;
   for (size_t x= 0; x < global_count; x++)
   {
-    (void)memcached_delete(memc, global_keys[x], global_keys_length[x], (time_t)0);
+    if (memcached_success(memcached_delete(memc, global_keys[x], global_keys_length[x], (time_t)0)))
+    {
+      total++;
+    }
   }
+  test_compare_warn_hint(global_count, total, "Possible false, positive, memcached may have ejected key/value based on memory needs");
 
   return TEST_SUCCESS;
 }
@@ -3961,7 +3967,7 @@ static test_return_t noreply_test(memcached_st *memc)
   {
     for (size_t x= 0; x < 100; ++x)
     {
-      char key[10];
+      char key[MEMCACHED_MAXIMUM_INTEGER_DISPLAY_LENGTH +1];
       int check_length= (size_t)snprintf(key, sizeof(key), "%lu", (unsigned long)x);
       test_false((size_t)check_length >= sizeof(key) || check_length < 0);
 
@@ -4085,8 +4091,8 @@ static test_return_t noreply_test(memcached_st *memc)
 
 static test_return_t analyzer_test(memcached_st *memc)
 {
-  memcached_return_t rc;
   memcached_analysis_st *report;
+  memcached_return_t rc;
 
   memcached_stat_st *memc_stat= memcached_stat(memc, NULL, &rc);
   test_compare(MEMCACHED_SUCCESS, rc);
@@ -4102,24 +4108,6 @@ static test_return_t analyzer_test(memcached_st *memc)
   return TEST_SUCCESS;
 }
 
-/* Count the objects */
-
-static test_return_t dump_test(memcached_st *memc)
-{
-  /* No support for Binary protocol yet */
-  test_skip(false, memc->flags.binary_protocol);
-
-  test_compare(TEST_SUCCESS, set_test3(memc));
-
-  // confirm_key_count() call dump
-  size_t counter= confirm_key_count(memc);
-
-  /* We may have more then 32 if our previous flush has not completed */
-  test_true(counter >= 32);
-
-  return TEST_SUCCESS;
-}
-
 static test_return_t util_version_test(memcached_st *memc)
 {
   test_compare_hint(MEMCACHED_SUCCESS, memcached_version(memc), memcached_last_error_message(memc));
@@ -4675,6 +4663,8 @@ static test_return_t regression_bug_434843(memcached_st *original_memc)
     test_compare(MEMCACHED_SUCCESS,
                  memcached_mget(memc, (const char**)keys, key_length, max_keys));
 
+    // One the first run we should get a NOT_FOUND, but on the second some data
+    // should be returned.
     test_compare(y ?  MEMCACHED_SUCCESS : MEMCACHED_NOTFOUND, 
                  memcached_fetch_execute(memc, callbacks, (void *)&counter, 1));
 
@@ -4785,8 +4775,7 @@ static test_return_t regression_bug_442914(memcached_st *memc)
     test_true(rc == MEMCACHED_SUCCESS || rc == MEMCACHED_BUFFERED);
   }
 
-  (void)snprintf(k, sizeof(k), "%037u", 251U);
-  len= strlen(k);
+  len= snprintf(k, sizeof(k), "%037u", 251U);
 
   memcached_return_t rc= memcached_delete(memc, k, len, 0);
   test_true(rc == MEMCACHED_SUCCESS || rc == MEMCACHED_BUFFERED);
@@ -4923,6 +4912,10 @@ static test_return_t regression_bug_447342(memcached_st *memc)
 
 static test_return_t regression_bug_463297(memcached_st *memc)
 {
+  test_compare(MEMCACHED_INVALID_ARGUMENTS, memcached_delete(memc, "foo", 3, 1));
+
+  // Since we blocked timed delete, this test is no longer valid.
+#if 0
   memcached_st *memc_clone= memcached_clone(NULL, memc);
   test_true(memc_clone);
   test_true(memcached_version(memc_clone) == MEMCACHED_SUCCESS);
@@ -4978,6 +4971,8 @@ static test_return_t regression_bug_463297(memcached_st *memc)
   }
 
   memcached_free(memc_clone);
+#endif
+
   return TEST_SUCCESS;
 }
 
@@ -5445,7 +5440,7 @@ static test_return_t regression_bug_490520(memcached_st *memc)
     test_true(keys[x]);
 
     memcached_return rc= memcached_set(memc, keys[x], key_length[x], blob, sizeof(blob), 0, 0);
-    test_true(rc == MEMCACHED_SUCCESS or rc == MEMCACHED_BUFFERED);
+    test_true_got(rc == MEMCACHED_SUCCESS or rc == MEMCACHED_BUFFERED, memcached_last_error_message(memc));
   }
 
   for (uint32_t x= 0; x < regression_bug_490520_COUNT; ++x)
@@ -5602,10 +5597,9 @@ test_st tests[] ={
   {"connection_test", false, (test_callback_fn*)connection_test},
   {"callback_test", false, (test_callback_fn*)callback_test},
   {"userdata_test", false, (test_callback_fn*)userdata_test},
-  {"set", false, (test_callback_fn*)set_test },
-  {"set2", false, (test_callback_fn*)set_test2 },
-  {"set3", false, (test_callback_fn*)set_test3 },
-  {"dump", true, (test_callback_fn*)dump_test},
+  {"memcached_set()", false, (test_callback_fn*)set_test },
+  {"memcached_set() 2", false, (test_callback_fn*)set_test2 },
+  {"memcached_set() 3", false, (test_callback_fn*)set_test3 },
   {"add", true, (test_callback_fn*)add_test },
   {"memcached_fetch_result(MEMCACHED_NOTFOUND)", true, (test_callback_fn*)memcached_fetch_result_NOT_FOUND },
   {"replace", true, (test_callback_fn*)replace_test },
@@ -5658,6 +5652,10 @@ test_st tests[] ={
   {"memcached_exist_by_key(MEMCACHED_SUCCESS)", true, (test_callback_fn*)memcached_exist_by_key_SUCCESS },
   {"memcached_touch", 0, (test_callback_fn*)test_memcached_touch},
   {"memcached_touch_with_prefix", 0, (test_callback_fn*)test_memcached_touch_by_key},
+#if 0
+  {"memcached_dump() no data", true, (test_callback_fn*)memcached_dump_TEST },
+#endif
+  {"memcached_dump() with data", true, (test_callback_fn*)memcached_dump_TEST2 },
   {0, 0, 0}
 };
 
@@ -5667,6 +5665,12 @@ test_st touch_tests[] ={
   {0, 0, 0}
 };
 
+test_st memcached_stat_tests[] ={
+  {"memcached_stat() INVALID ARG", 0, (test_callback_fn*)memcached_stat_TEST},
+  {"memcached_stat()", 0, (test_callback_fn*)memcached_stat_TEST2},
+  {0, 0, 0}
+};
+
 test_st behavior_tests[] ={
   {"libmemcached_string_behavior()", false, (test_callback_fn*)libmemcached_string_behavior_test},
   {"libmemcached_string_distribution()", false, (test_callback_fn*)libmemcached_string_distribution_test},
@@ -5775,6 +5779,7 @@ test_st replication_tests[]= {
   {"mget", false, (test_callback_fn*)replication_mget_test },
   {"delete", true, (test_callback_fn*)replication_delete_test },
   {"rand_mget", false, (test_callback_fn*)replication_randomize_mget_test },
+  {"miss", false, (test_callback_fn*)replication_miss_test },
   {"fail", false, (test_callback_fn*)replication_randomize_mget_fail_test },
   {0, 0, (test_callback_fn*)0}
 };
@@ -6003,6 +6008,8 @@ collection_st collection[] ={
   {"virtual buckets", 0, 0, virtual_bucket_tests},
   {"memcached_server_get_last_disconnect", 0, 0, memcached_server_get_last_disconnect_tests},
   {"touch", 0, 0, touch_tests},
+  {"touch", (test_callback_fn*)pre_binary, 0, touch_tests},
+  {"memcached_stat()", 0, 0, memcached_stat_tests},
   {0, 0, 0, 0}
 };