X-Git-Url: https://git.m6w6.name/?a=blobdiff_plain;f=tests%2Ffunction.c;h=3cf729ba467a9dc59154a8626ca07844d20f73b2;hb=07999ea4e52b8a80ea66376ec22768c32add7f29;hp=b9e7d303efdbfa121fe44e357dc9b0f1b837a1e2;hpb=89608dc3370371a9fde46d6f60e9480fa576fc3a;p=awesomized%2Flibmemcached

diff --git a/tests/function.c b/tests/function.c
index b9e7d303..3cf729ba 100644
--- a/tests/function.c
+++ b/tests/function.c
@@ -11,6 +11,7 @@
 #include <sys/time.h>
 #include <sys/types.h>
 #include <sys/stat.h>
+#include <signal.h>
 #include <unistd.h>
 #include <time.h>
 #include "server.h"
@@ -41,17 +42,17 @@ static pairs_st *global_pairs;
 static const char *global_keys[GLOBAL_COUNT];
 static size_t global_keys_length[GLOBAL_COUNT];
 
-static test_return  init_test(memcached_st *not_used __attribute__((unused)))
+static test_return_t  init_test(memcached_st *not_used __attribute__((unused)))
 {
   memcached_st memc;
 
   (void)memcached_create(&memc);
   memcached_free(&memc);
 
-  return 0;
+  return TEST_SUCCESS;
 }
 
-static test_return  server_list_null_test(memcached_st *ptr __attribute__((unused)))
+static test_return_t  server_list_null_test(memcached_st *ptr __attribute__((unused)))
 {
   memcached_server_st *server_list;
   memcached_return rc;
@@ -65,7 +66,7 @@ static test_return  server_list_null_test(memcached_st *ptr __attribute__((unuse
   server_list= memcached_server_list_append_with_weight(NULL, NULL, 0, 0, &rc);
   assert(server_list == NULL);
 
-  return 0;
+  return TEST_SUCCESS;
 }
 
 #define TEST_PORT_COUNT 7
@@ -81,7 +82,7 @@ static memcached_return  server_display_function(memcached_st *ptr __attribute__
   return MEMCACHED_SUCCESS;
 }
 
-static test_return  server_sort_test(memcached_st *ptr __attribute__((unused)))
+static test_return_t  server_sort_test(memcached_st *ptr __attribute__((unused)))
 {
   uint32_t x;
   uint32_t bigger= 0; /* Prime the value for the assert in server_display_function */
@@ -108,10 +109,10 @@ static test_return  server_sort_test(memcached_st *ptr __attribute__((unused)))
 
   memcached_free(local_memc);
 
-  return 0;
+  return TEST_SUCCESS;
 }
 
-static test_return  server_sort2_test(memcached_st *ptr __attribute__((unused)))
+static test_return_t  server_sort2_test(memcached_st *ptr __attribute__((unused)))
 {
   uint32_t bigger= 0; /* Prime the value for the assert in server_display_function */
   memcached_return rc;
@@ -138,7 +139,7 @@ static test_return  server_sort2_test(memcached_st *ptr __attribute__((unused)))
 
   memcached_free(local_memc);
 
-  return 0;
+  return TEST_SUCCESS;
 }
 
 static memcached_return  server_display_unsort_function(memcached_st *ptr __attribute__((unused)), memcached_server_st *server, void *context)
@@ -152,7 +153,7 @@ static memcached_return  server_display_unsort_function(memcached_st *ptr __attr
   return MEMCACHED_SUCCESS;
 }
 
-static test_return  server_unsort_test(memcached_st *ptr __attribute__((unused)))
+static test_return_t  server_unsort_test(memcached_st *ptr __attribute__((unused)))
 {
   uint32_t x;
   uint32_t counter= 0; /* Prime the value for the assert in server_display_function */
@@ -184,20 +185,20 @@ static test_return  server_unsort_test(memcached_st *ptr __attribute__((unused))
 
   memcached_free(local_memc);
 
-  return 0;
+  return TEST_SUCCESS;
 }
 
-static test_return  allocation_test(memcached_st *not_used __attribute__((unused)))
+static test_return_t  allocation_test(memcached_st *not_used __attribute__((unused)))
 {
   memcached_st *memc;
   memc= memcached_create(NULL);
   assert(memc);
   memcached_free(memc);
 
-  return 0;
+  return TEST_SUCCESS;
 }
 
-static test_return  clone_test(memcached_st *memc)
+static test_return_t  clone_test(memcached_st *memc)
 {
   /* All null? */
   {
@@ -261,56 +262,72 @@ static test_return  clone_test(memcached_st *memc)
     memcached_free(memc_clone);
   }
 
-  return 0;
+  return TEST_SUCCESS;
 }
 
-static test_return userdata_test(memcached_st *memc)
+static test_return_t userdata_test(memcached_st *memc)
 {
   void* foo= NULL;
   assert(memcached_set_user_data(memc, foo) == NULL);
   assert(memcached_get_user_data(memc) == foo);
   assert(memcached_set_user_data(memc, NULL) == foo);
-  
+
   return TEST_SUCCESS;
 }
 
-static test_return  connection_test(memcached_st *memc)
+static test_return_t  connection_test(memcached_st *memc)
 {
   memcached_return rc;
 
   rc= memcached_server_add_with_weight(memc, "localhost", 0, 0);
   assert(rc == MEMCACHED_SUCCESS);
 
-  return 0;
+  return TEST_SUCCESS;
 }
 
-static test_return  error_test(memcached_st *memc)
+static test_return_t  error_test(memcached_st *memc)
 {
   memcached_return rc;
-
+  uint32_t values[] = { 851992627U, 2337886783U, 3196981036U, 4001849190U,
+                        982370485U, 1263635348U, 4242906218U, 3829656100U,
+                        1891735253U, 334139633U, 2257084983U, 3088286104U,
+                        13199785U, 2542027183U, 1097051614U, 199566778U,
+                        2748246961U, 2465192557U, 1664094137U, 2405439045U,
+                        1842224848U, 692413798U, 3479807801U, 919913813U,
+                        4269430871U, 610793021U, 527273862U, 1437122909U,
+                        2300930706U, 2943759320U, 674306647U, 2400528935U,
+                        54481931U, 4186304426U, 1741088401U, 2979625118U,
+                        4159057246U, 3425930182U};
+
+  // You have updated the memcache_error messages but not updated docs/tests.
+  assert(MEMCACHED_MAXIMUM_RETURN == 38);
   for (rc= MEMCACHED_SUCCESS; rc < MEMCACHED_MAXIMUM_RETURN; rc++)
   {
-    printf("Error %d -> %s\n", rc, memcached_strerror(memc, rc));
+    uint32_t hash_val;
+    const char *msg=  memcached_strerror(memc, rc);
+    hash_val= memcached_generate_hash_value(msg, strlen(msg),
+                                            MEMCACHED_HASH_JENKINS);
+    assert(values[rc] == hash_val);
   }
 
-  return 0;
+  return TEST_SUCCESS;
 }
 
-static test_return  set_test(memcached_st *memc)
+static test_return_t  set_test(memcached_st *memc)
 {
   memcached_return rc;
   const char *key= "foo";
   const char *value= "when we sanitize";
 
-  rc= memcached_set(memc, key, strlen(key), 
+  rc= memcached_set(memc, key, strlen(key),
                     value, strlen(value),
                     (time_t)0, (uint32_t)0);
   assert(rc == MEMCACHED_SUCCESS || rc == MEMCACHED_BUFFERED);
 
-  return 0;
+  return TEST_SUCCESS;
 }
 
-static test_return  append_test(memcached_st *memc)
+static test_return_t  append_test(memcached_st *memc)
 {
   memcached_return rc;
   const char *key= "fig";
@@ -322,17 +339,17 @@ static test_return  append_test(memcached_st *memc)
   rc= memcached_flush(memc, 0);
   assert(rc == MEMCACHED_SUCCESS);
 
-  rc= memcached_set(memc, key, strlen(key), 
+  rc= memcached_set(memc, key, strlen(key),
                     in_value, strlen(in_value),
                     (time_t)0, (uint32_t)0);
   assert(rc == MEMCACHED_SUCCESS);
 
-  rc= memcached_append(memc, key, strlen(key), 
+  rc= memcached_append(memc, key, strlen(key),
                        " the", strlen(" the"),
                        (time_t)0, (uint32_t)0);
   assert(rc == MEMCACHED_SUCCESS);
 
-  rc= memcached_append(memc, key, strlen(key), 
+  rc= memcached_append(memc, key, strlen(key),
                        " people", strlen(" people"),
                        (time_t)0, (uint32_t)0);
   assert(rc == MEMCACHED_SUCCESS);
@@ -344,10 +361,10 @@ static test_return  append_test(memcached_st *memc)
   assert(rc == MEMCACHED_SUCCESS);
   free(out_value);
 
-  return 0;
+  return TEST_SUCCESS;
 }
 
-static test_return  append_binary_test(memcached_st *memc)
+static test_return_t  append_binary_test(memcached_st *memc)
 {
   memcached_return rc;
   const char *key= "numbers";
@@ -361,16 +378,16 @@ static test_return  append_binary_test(memcached_st *memc)
   rc= memcached_flush(memc, 0);
   assert(rc == MEMCACHED_SUCCESS);
 
-  rc= memcached_set(memc, 
-                    key, strlen(key), 
+  rc= memcached_set(memc,
+                    key, strlen(key),
                     NULL, 0,
                     (time_t)0, (uint32_t)0);
   assert(rc == MEMCACHED_SUCCESS);
 
   for (x= 0; store_list[x] ; x++)
   {
-    rc= memcached_append(memc, 
-                         key, strlen(key), 
+    rc= memcached_append(memc,
+                         key, strlen(key),
                          (char *)&store_list[x], sizeof(unsigned int),
                          (time_t)0, (uint32_t)0);
     assert(rc == MEMCACHED_SUCCESS);
@@ -390,10 +407,10 @@ static test_return  append_binary_test(memcached_st *memc)
   }
   free(value);
 
-  return 0;
+  return TEST_SUCCESS;
 }
 
-static test_return  cas2_test(memcached_st *memc)
+static test_return_t  cas2_test(memcached_st *memc)
 {
   memcached_return rc;
   const char *keys[]= {"fudge", "son", "food"};
@@ -412,7 +429,7 @@ static test_return  cas2_test(memcached_st *memc)
 
   for (x= 0; x < 3; x++)
   {
-    rc= memcached_set(memc, keys[x], key_length[x], 
+    rc= memcached_set(memc, keys[x], key_length[x],
                       keys[x], key_length[x],
                       (time_t)50, (uint32_t)9);
     assert(rc == MEMCACHED_SUCCESS);
@@ -434,10 +451,10 @@ static test_return  cas2_test(memcached_st *memc)
 
   memcached_result_free(&results_obj);
 
-  return 0;
+  return TEST_SUCCESS;
 }
 
-static test_return  cas_test(memcached_st *memc)
+static test_return_t  cas_test(memcached_st *memc)
 {
   memcached_return rc;
   const char *key= "fun";
@@ -458,7 +475,7 @@ static test_return  cas_test(memcached_st *memc)
 
   memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_SUPPORT_CAS, set);
 
-  rc= memcached_set(memc, key, strlen(key), 
+  rc= memcached_set(memc, key, strlen(key),
                     value, strlen(value),
                     (time_t)0, (uint32_t)0);
   assert(rc == MEMCACHED_SUCCESS);
@@ -481,7 +498,7 @@ static test_return  cas_test(memcached_st *memc)
   assert(rc == MEMCACHED_END);
   assert(results == NULL);
 #endif
-  
+
   rc= memcached_cas(memc, key, key_length, value2, value2_length, 0, 0, cas);
   assert(rc == MEMCACHED_SUCCESS);
 
@@ -494,10 +511,10 @@ static test_return  cas_test(memcached_st *memc)
 
   memcached_result_free(&results_obj);
 
-  return 0;
+  return TEST_SUCCESS;
 }
 
-static test_return  prepend_test(memcached_st *memc)
+static test_return_t  prepend_test(memcached_st *memc)
 {
   memcached_return rc;
   const char *key= "fig";
@@ -509,17 +526,17 @@ static test_return  prepend_test(memcached_st *memc)
   rc= memcached_flush(memc, 0);
   assert(rc == MEMCACHED_SUCCESS);
 
-  rc= memcached_set(memc, key, strlen(key), 
+  rc= memcached_set(memc, key, strlen(key),
                     value, strlen(value),
                     (time_t)0, (uint32_t)0);
   assert(rc == MEMCACHED_SUCCESS);
 
-  rc= memcached_prepend(memc, key, strlen(key), 
+  rc= memcached_prepend(memc, key, strlen(key),
                        "the ", strlen("the "),
                        (time_t)0, (uint32_t)0);
   assert(rc == MEMCACHED_SUCCESS);
 
-  rc= memcached_prepend(memc, key, strlen(key), 
+  rc= memcached_prepend(memc, key, strlen(key),
                        "we ", strlen("we "),
                        (time_t)0, (uint32_t)0);
   assert(rc == MEMCACHED_SUCCESS);
@@ -531,14 +548,14 @@ static test_return  prepend_test(memcached_st *memc)
   assert(rc == MEMCACHED_SUCCESS);
   free(out_value);
 
-  return 0;
+  return TEST_SUCCESS;
 }
 
-/* 
+/*
   Set the value, then quit to make sure it is flushed.
   Come back in and test that add fails.
 */
-static test_return  add_test(memcached_st *memc)
+static test_return_t  add_test(memcached_st *memc)
 {
   memcached_return rc;
   const char *key= "foo";
@@ -547,12 +564,12 @@ static test_return  add_test(memcached_st *memc)
 
   setting_value= memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_NO_BLOCK);
 
-  rc= memcached_set(memc, key, strlen(key), 
+  rc= memcached_set(memc, key, strlen(key),
                     value, strlen(value),
                     (time_t)0, (uint32_t)0);
   assert(rc == MEMCACHED_SUCCESS || rc == MEMCACHED_BUFFERED);
   memcached_quit(memc);
-  rc= memcached_add(memc, key, strlen(key), 
+  rc= memcached_add(memc, key, strlen(key),
                     value, strlen(value),
                     (time_t)0, (uint32_t)0);
 
@@ -562,7 +579,7 @@ static test_return  add_test(memcached_st *memc)
   else
     assert(rc == MEMCACHED_NOTSTORED || rc == MEMCACHED_DATA_EXISTS);
 
-  return 0;
+  return TEST_SUCCESS;
 }
 
 /*
@@ -572,47 +589,50 @@ static test_return  add_test(memcached_st *memc)
 ** because the connects starts to time out (the test doesn't do much
 ** anyway, so just loop 10 iterations)
 */
-static test_return  add_wrapper(memcached_st *memc)
+static test_return_t  add_wrapper(memcached_st *memc)
 {
   unsigned int x;
   unsigned int max= 10000;
 #ifdef __sun
   max= 10;
 #endif
+#ifdef __APPLE__
+  max= 10;
+#endif
 
   for (x= 0; x < max; x++)
     add_test(memc);
 
-  return 0;
+  return TEST_SUCCESS;
 }
 
-static test_return  replace_test(memcached_st *memc)
+static test_return_t  replace_test(memcached_st *memc)
 {
   memcached_return rc;
   const char *key= "foo";
   const char *value= "when we sanitize";
   const char *original= "first we insert some data";
 
-  rc= memcached_set(memc, key, strlen(key), 
+  rc= memcached_set(memc, key, strlen(key),
                     original, strlen(original),
                     (time_t)0, (uint32_t)0);
   assert(rc == MEMCACHED_SUCCESS || rc == MEMCACHED_BUFFERED);
 
-  rc= memcached_replace(memc, key, strlen(key), 
+  rc= memcached_replace(memc, key, strlen(key),
                     value, strlen(value),
                     (time_t)0, (uint32_t)0);
   assert(rc == MEMCACHED_SUCCESS);
 
-  return 0;
+  return TEST_SUCCESS;
 }
 
-static test_return  delete_test(memcached_st *memc)
+static test_return_t  delete_test(memcached_st *memc)
 {
   memcached_return rc;
   const char *key= "foo";
   const char *value= "when we sanitize";
 
-  rc= memcached_set(memc, key, strlen(key), 
+  rc= memcached_set(memc, key, strlen(key),
                     value, strlen(value),
                     (time_t)0, (uint32_t)0);
   assert(rc == MEMCACHED_SUCCESS || rc == MEMCACHED_BUFFERED);
@@ -620,21 +640,21 @@ static test_return  delete_test(memcached_st *memc)
   rc= memcached_delete(memc, key, strlen(key), (time_t)0);
   assert(rc == MEMCACHED_SUCCESS || rc == MEMCACHED_BUFFERED);
 
-  return 0;
+  return TEST_SUCCESS;
 }
 
-static test_return  flush_test(memcached_st *memc)
+static test_return_t  flush_test(memcached_st *memc)
 {
   memcached_return rc;
 
   rc= memcached_flush(memc, 0);
   assert(rc == MEMCACHED_SUCCESS);
 
-  return 0;
+  return TEST_SUCCESS;
 }
 
-static memcached_return  server_function(memcached_st *ptr __attribute__((unused)), 
-                                         memcached_server_st *server __attribute__((unused)), 
+static memcached_return  server_function(memcached_st *ptr __attribute__((unused)),
+                                         memcached_server_st *server __attribute__((unused)),
                                          void *context __attribute__((unused)))
 {
   /* Do Nothing */
@@ -642,7 +662,7 @@ static memcached_return  server_function(memcached_st *ptr __attribute__((unused
   return MEMCACHED_SUCCESS;
 }
 
-static test_return  memcached_server_cursor_test(memcached_st *memc)
+static test_return_t  memcached_server_cursor_test(memcached_st *memc)
 {
   char context[8];
   strcpy(context, "foo bad");
@@ -650,10 +670,10 @@ static test_return  memcached_server_cursor_test(memcached_st *memc)
 
   callbacks[0]= server_function;
   memcached_server_cursor(memc, callbacks, context,  1);
-  return 0;
+  return TEST_SUCCESS;
 }
 
-static test_return  bad_key_test(memcached_st *memc)
+static test_return_t  bad_key_test(memcached_st *memc)
 {
   memcached_return rc;
   const char *key= "foo bad";
@@ -671,7 +691,7 @@ static test_return  bad_key_test(memcached_st *memc)
   assert(rc == MEMCACHED_SUCCESS);
 
   /* All keys are valid in the binary protocol (except for length) */
-  if (memcached_behavior_get(memc_clone, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL) == 0) 
+  if (memcached_behavior_get(memc_clone, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL) == 0)
   {
     string= memcached_get(memc_clone, key, strlen(key),
                           &string_length, &flags, &rc);
@@ -711,7 +731,7 @@ static test_return  bad_key_test(memcached_st *memc)
     assert(rc == MEMCACHED_SUCCESS);
 
     char *longkey= malloc(max_keylen + 1);
-    if (longkey != NULL) 
+    if (longkey != NULL)
     {
       memset(longkey, 'a', max_keylen + 1);
       string= memcached_get(memc_clone, longkey, max_keylen,
@@ -742,20 +762,20 @@ static test_return  bad_key_test(memcached_st *memc)
 
   memcached_free(memc_clone);
 
-  return 0;
+  return TEST_SUCCESS;
 }
 
 #define READ_THROUGH_VALUE "set for me"
 static memcached_return  read_through_trigger(memcached_st *memc __attribute__((unused)),
-                                      char *key __attribute__((unused)), 
-                                      size_t key_length __attribute__((unused)), 
+                                      char *key __attribute__((unused)),
+                                      size_t key_length __attribute__((unused)),
                                       memcached_result_st *result)
 {
-  
+
   return memcached_result_set_value(result, READ_THROUGH_VALUE, strlen(READ_THROUGH_VALUE));
 }
 
-static test_return  read_through(memcached_st *memc)
+static test_return_t  read_through(memcached_st *memc)
 {
   memcached_return rc;
   const char *key= "foo";
@@ -791,11 +811,11 @@ static test_return  read_through(memcached_st *memc)
   assert(!strcmp(READ_THROUGH_VALUE, string));
   free(string);
 
-  return 0;
+  return TEST_SUCCESS;
 }
 
-static memcached_return  delete_trigger(memcached_st *ptr __attribute__((unused)),  
-                                        const char *key, 
+static memcached_return  delete_trigger(memcached_st *ptr __attribute__((unused)),
+                                        const char *key,
                                         size_t key_length __attribute__((unused)))
 {
   assert(key);
@@ -803,7 +823,7 @@ static memcached_return  delete_trigger(memcached_st *ptr __attribute__((unused)
   return MEMCACHED_SUCCESS;
 }
 
-static test_return  delete_through(memcached_st *memc)
+static test_return_t  delete_through(memcached_st *memc)
 {
   memcached_trigger_delete_key callback;
   memcached_return rc;
@@ -813,10 +833,10 @@ static test_return  delete_through(memcached_st *memc)
   rc= memcached_callback_set(memc, MEMCACHED_CALLBACK_DELETE_TRIGGER, *(void**)&callback);
   assert(rc == MEMCACHED_SUCCESS);
 
-  return 0;
+  return TEST_SUCCESS;
 }
 
-static test_return  get_test(memcached_st *memc)
+static test_return_t  get_test(memcached_st *memc)
 {
   memcached_return rc;
   const char *key= "foo";
@@ -834,10 +854,10 @@ static test_return  get_test(memcached_st *memc)
   assert(string_length ==  0);
   assert(!string);
 
-  return 0;
+  return TEST_SUCCESS;
 }
 
-static test_return  get_test2(memcached_st *memc)
+static test_return_t  get_test2(memcached_st *memc)
 {
   memcached_return rc;
   const char *key= "foo";
@@ -846,7 +866,7 @@ static test_return  get_test2(memcached_st *memc)
   size_t string_length;
   uint32_t flags;
 
-  rc= memcached_set(memc, key, strlen(key), 
+  rc= memcached_set(memc, key, strlen(key),
                     value, strlen(value),
                     (time_t)0, (uint32_t)0);
   assert(rc == MEMCACHED_SUCCESS || rc == MEMCACHED_BUFFERED);
@@ -861,10 +881,10 @@ static test_return  get_test2(memcached_st *memc)
 
   free(string);
 
-  return 0;
+  return TEST_SUCCESS;
 }
 
-static test_return  set_test2(memcached_st *memc)
+static test_return_t  set_test2(memcached_st *memc)
 {
   memcached_return rc;
   const char *key= "foo";
@@ -874,16 +894,16 @@ static test_return  set_test2(memcached_st *memc)
 
   for (x= 0; x < 10; x++)
   {
-    rc= memcached_set(memc, key, strlen(key), 
+    rc= memcached_set(memc, key, strlen(key),
                       value, value_length,
                       (time_t)0, (uint32_t)0);
     assert(rc == MEMCACHED_SUCCESS || rc == MEMCACHED_BUFFERED);
   }
 
-  return 0;
+  return TEST_SUCCESS;
 }
 
-static test_return  set_test3(memcached_st *memc)
+static test_return_t  set_test3(memcached_st *memc)
 {
   memcached_return rc;
   char *value;
@@ -903,7 +923,7 @@ static test_return  set_test3(memcached_st *memc)
 
     sprintf(key, "foo%u", x);
 
-    rc= memcached_set(memc, key, strlen(key), 
+    rc= memcached_set(memc, key, strlen(key),
                       value, value_length,
                       (time_t)0, (uint32_t)0);
     assert(rc == MEMCACHED_SUCCESS || rc == MEMCACHED_BUFFERED);
@@ -911,10 +931,10 @@ static test_return  set_test3(memcached_st *memc)
 
   free(value);
 
-  return 0;
+  return TEST_SUCCESS;
 }
 
-static test_return  get_test3(memcached_st *memc)
+static test_return_t  get_test3(memcached_st *memc)
 {
   memcached_return rc;
   const char *key= "foo";
@@ -931,7 +951,7 @@ static test_return  get_test3(memcached_st *memc)
   for (x= 0; x < value_length; x++)
     value[x] = (char) (x % 127);
 
-  rc= memcached_set(memc, key, strlen(key), 
+  rc= memcached_set(memc, key, strlen(key),
                     value, value_length,
                     (time_t)0, (uint32_t)0);
   assert(rc == MEMCACHED_SUCCESS || rc == MEMCACHED_BUFFERED);
@@ -947,10 +967,10 @@ static test_return  get_test3(memcached_st *memc)
   free(string);
   free(value);
 
-  return 0;
+  return TEST_SUCCESS;
 }
 
-static test_return  get_test4(memcached_st *memc)
+static test_return_t  get_test4(memcached_st *memc)
 {
   memcached_return rc;
   const char *key= "foo";
@@ -967,7 +987,7 @@ static test_return  get_test4(memcached_st *memc)
   for (x= 0; x < value_length; x++)
     value[x] = (char) (x % 127);
 
-  rc= memcached_set(memc, key, strlen(key), 
+  rc= memcached_set(memc, key, strlen(key),
                     value, value_length,
                     (time_t)0, (uint32_t)0);
   assert(rc == MEMCACHED_SUCCESS || rc == MEMCACHED_BUFFERED);
@@ -986,7 +1006,7 @@ static test_return  get_test4(memcached_st *memc)
 
   free(value);
 
-  return 0;
+  return TEST_SUCCESS;
 }
 
 /*
@@ -994,7 +1014,7 @@ static test_return  get_test4(memcached_st *memc)
  * dereference a NIL-pointer if you issue a multi-get and don't read out all
  * responses before you execute a storage command.
  */
-static test_return get_test5(memcached_st *memc)
+static test_return_t get_test5(memcached_st *memc)
 {
   /*
   ** Request the same key twice, to ensure that we hash to the same server
@@ -1005,7 +1025,7 @@ static test_return get_test5(memcached_st *memc)
   uint32_t flags;
   size_t rlen;
 
-  memcached_return rc= memcached_set(memc, keys[0], lengths[0], 
+  memcached_return rc= memcached_set(memc, keys[0], lengths[0],
                                      keys[0], lengths[0], 0, 0);
   assert(rc == MEMCACHED_SUCCESS);
   rc= memcached_mget(memc, keys, lengths, 2);
@@ -1034,26 +1054,90 @@ static test_return get_test5(memcached_st *memc)
   return TEST_SUCCESS;
 }
 
+static test_return_t  mget_end(memcached_st *memc)
+{
+  const char *keys[]= { "foo", "foo2" };
+  size_t lengths[]= { 3, 4 };
+  const char *values[]= { "fjord", "41" };
+
+  memcached_return rc;
+
+  // Set foo and foo2
+  for (int i= 0; i < 2; i++)
+  {
+    rc= memcached_set(memc, keys[i], lengths[i], values[i], strlen(values[i]),
+		      (time_t)0, (uint32_t)0);
+    assert(rc == MEMCACHED_SUCCESS);
+  }
+
+  char *string;
+  size_t string_length;
+  uint32_t flags;
+
+  // retrieve both via mget
+  rc= memcached_mget(memc, keys, lengths, 2);
+  assert(rc == MEMCACHED_SUCCESS);
+
+  char key[MEMCACHED_MAX_KEY];
+  size_t key_length;
+
+  // this should get both
+  for (int i = 0; i < 2; i++)
+  {
+    string= memcached_fetch(memc, key, &key_length, &string_length,
+                            &flags, &rc);
+    assert(rc == MEMCACHED_SUCCESS);
+    int val = 0;
+    if (key_length == 4)
+      val= 1;
+    assert(string_length == strlen(values[val]));
+    assert(strncmp(values[val], string, string_length) == 0);
+    free(string);
+  }
+
+  // this should indicate end
+  string= memcached_fetch(memc, key, &key_length, &string_length, &flags, &rc);
+  assert(rc == MEMCACHED_END);
+
+  // now get just one
+  rc= memcached_mget(memc, keys, lengths, 1);
+  assert(rc == MEMCACHED_SUCCESS);
+
+  string= memcached_fetch(memc, key, &key_length, &string_length, &flags, &rc);
+  assert(key_length == lengths[0]);
+  assert(strncmp(keys[0], key, key_length) == 0);
+  assert(string_length == strlen(values[0]));
+  assert(strncmp(values[0], string, string_length) == 0);
+  assert(rc == MEMCACHED_SUCCESS);
+  free(string);
+
+  // this should indicate end
+  string= memcached_fetch(memc, key, &key_length, &string_length, &flags, &rc);
+  assert(rc == MEMCACHED_END);
+
+  return TEST_SUCCESS;
+}
+
 /* Do not copy the style of this code, I just access hosts to testthis function */
-static test_return  stats_servername_test(memcached_st *memc)
+static test_return_t  stats_servername_test(memcached_st *memc)
 {
   memcached_return rc;
   memcached_stat_st memc_stat;
   rc= memcached_stat_servername(&memc_stat, NULL,
-                                 memc->hosts[0].hostname, 
+                                 memc->hosts[0].hostname,
                                  memc->hosts[0].port);
 
-  return 0;
+  return TEST_SUCCESS;
 }
 
-static test_return  increment_test(memcached_st *memc)
+static test_return_t  increment_test(memcached_st *memc)
 {
   uint64_t new_number;
   memcached_return rc;
   const char *key= "number";
   const char *value= "0";
 
-  rc= memcached_set(memc, key, strlen(key), 
+  rc= memcached_set(memc, key, strlen(key),
                     value, strlen(value),
                     (time_t)0, (uint32_t)0);
   assert(rc == MEMCACHED_SUCCESS || rc == MEMCACHED_BUFFERED);
@@ -1068,10 +1152,10 @@ static test_return  increment_test(memcached_st *memc)
   assert(rc == MEMCACHED_SUCCESS);
   assert(new_number == 2);
 
-  return 0;
+  return TEST_SUCCESS;
 }
 
-static test_return  increment_with_initial_test(memcached_st *memc)
+static test_return_t  increment_with_initial_test(memcached_st *memc)
 {
   if (memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL) != 0)
   {
@@ -1090,17 +1174,17 @@ static test_return  increment_with_initial_test(memcached_st *memc)
     assert(rc == MEMCACHED_SUCCESS);
     assert(new_number == (initial + 1));
   }
-  return 0;
+  return TEST_SUCCESS;
 }
 
-static test_return  decrement_test(memcached_st *memc)
+static test_return_t  decrement_test(memcached_st *memc)
 {
   uint64_t new_number;
   memcached_return rc;
   const char *key= "number";
   const char *value= "3";
 
-  rc= memcached_set(memc, key, strlen(key), 
+  rc= memcached_set(memc, key, strlen(key),
                     value, strlen(value),
                     (time_t)0, (uint32_t)0);
   assert(rc == MEMCACHED_SUCCESS || rc == MEMCACHED_BUFFERED);
@@ -1115,10 +1199,10 @@ static test_return  decrement_test(memcached_st *memc)
   assert(rc == MEMCACHED_SUCCESS);
   assert(new_number == 1);
 
-  return 0;
+  return TEST_SUCCESS;
 }
 
-static test_return  decrement_with_initial_test(memcached_st *memc)
+static test_return_t  decrement_with_initial_test(memcached_st *memc)
 {
   if (memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL) != 0)
   {
@@ -1137,30 +1221,30 @@ static test_return  decrement_with_initial_test(memcached_st *memc)
     assert(rc == MEMCACHED_SUCCESS);
     assert(new_number == (initial - 1));
   }
-  return 0;
+  return TEST_SUCCESS;
 }
 
-static test_return  quit_test(memcached_st *memc)
+static test_return_t  quit_test(memcached_st *memc)
 {
   memcached_return rc;
   const char *key= "fudge";
   const char *value= "sanford and sun";
 
-  rc= memcached_set(memc, key, strlen(key), 
+  rc= memcached_set(memc, key, strlen(key),
                     value, strlen(value),
                     (time_t)10, (uint32_t)3);
   assert(rc == MEMCACHED_SUCCESS || rc == MEMCACHED_BUFFERED);
   memcached_quit(memc);
 
-  rc= memcached_set(memc, key, strlen(key), 
+  rc= memcached_set(memc, key, strlen(key),
                     value, strlen(value),
                     (time_t)50, (uint32_t)9);
   assert(rc == MEMCACHED_SUCCESS || rc == MEMCACHED_BUFFERED);
 
-  return 0;
+  return TEST_SUCCESS;
 }
 
-static test_return  mget_result_test(memcached_st *memc)
+static test_return_t  mget_result_test(memcached_st *memc)
 {
   memcached_return rc;
   const char *keys[]= {"fudge", "son", "food"};
@@ -1192,7 +1276,7 @@ static test_return  mget_result_test(memcached_st *memc)
 
   for (x= 0; x < 3; x++)
   {
-    rc= memcached_set(memc, keys[x], key_length[x], 
+    rc= memcached_set(memc, keys[x], key_length[x],
                       keys[x], key_length[x],
                       (time_t)50, (uint32_t)9);
     assert(rc == MEMCACHED_SUCCESS || rc == MEMCACHED_BUFFERED);
@@ -1207,17 +1291,17 @@ static test_return  mget_result_test(memcached_st *memc)
     assert(&results_obj == results);
     assert(rc == MEMCACHED_SUCCESS);
     assert(memcached_result_key_length(results) == memcached_result_length(results));
-    assert(!memcmp(memcached_result_key_value(results), 
-                   memcached_result_value(results), 
+    assert(!memcmp(memcached_result_key_value(results),
+                   memcached_result_value(results),
                    memcached_result_length(results)));
   }
 
   memcached_result_free(&results_obj);
 
-  return 0;
+  return TEST_SUCCESS;
 }
 
-static test_return  mget_result_alloc_test(memcached_st *memc)
+static test_return_t  mget_result_alloc_test(memcached_st *memc)
 {
   memcached_return rc;
   const char *keys[]= {"fudge", "son", "food"};
@@ -1242,7 +1326,7 @@ static test_return  mget_result_alloc_test(memcached_st *memc)
 
   for (x= 0; x < 3; x++)
   {
-    rc= memcached_set(memc, keys[x], key_length[x], 
+    rc= memcached_set(memc, keys[x], key_length[x],
                       keys[x], key_length[x],
                       (time_t)50, (uint32_t)9);
     assert(rc == MEMCACHED_SUCCESS || rc == MEMCACHED_BUFFERED);
@@ -1257,19 +1341,19 @@ static test_return  mget_result_alloc_test(memcached_st *memc)
     assert(results);
     assert(rc == MEMCACHED_SUCCESS);
     assert(memcached_result_key_length(results) == memcached_result_length(results));
-    assert(!memcmp(memcached_result_key_value(results), 
-                   memcached_result_value(results), 
+    assert(!memcmp(memcached_result_key_value(results),
+                   memcached_result_value(results),
                    memcached_result_length(results)));
     memcached_result_free(results);
     x++;
   }
 
-  return 0;
+  return TEST_SUCCESS;
 }
 
 /* Count the results */
-static memcached_return callback_counter(memcached_st *ptr __attribute__((unused)), 
-                                     memcached_result_st *result __attribute__((unused)), 
+static memcached_return callback_counter(memcached_st *ptr __attribute__((unused)),
+                                     memcached_result_st *result __attribute__((unused)),
                                      void *context)
 {
   unsigned int *counter= (unsigned int *)context;
@@ -1279,7 +1363,7 @@ static memcached_return callback_counter(memcached_st *ptr __attribute__((unused
   return MEMCACHED_SUCCESS;
 }
 
-static test_return  mget_result_function(memcached_st *memc)
+static test_return_t  mget_result_function(memcached_st *memc)
 {
   memcached_return rc;
   const char *keys[]= {"fudge", "son", "food"};
@@ -1292,7 +1376,7 @@ static test_return  mget_result_function(memcached_st *memc)
   rc= memcached_flush(memc, 0);
   for (x= 0; x < 3; x++)
   {
-    rc= memcached_set(memc, keys[x], key_length[x], 
+    rc= memcached_set(memc, keys[x], key_length[x],
                       keys[x], key_length[x],
                       (time_t)50, (uint32_t)9);
     assert(rc == MEMCACHED_SUCCESS || rc == MEMCACHED_BUFFERED);
@@ -1303,14 +1387,14 @@ static test_return  mget_result_function(memcached_st *memc)
 
   callbacks[0]= &callback_counter;
   counter= 0;
-  rc= memcached_fetch_execute(memc, callbacks, (void *)&counter, 1); 
+  rc= memcached_fetch_execute(memc, callbacks, (void *)&counter, 1);
 
   assert(counter == 3);
 
-  return 0;
+  return TEST_SUCCESS;
 }
 
-static test_return  mget_test(memcached_st *memc)
+static test_return_t  mget_test(memcached_st *memc)
 {
   memcached_return rc;
   const char *keys[]= {"fudge", "son", "food"};
@@ -1330,7 +1414,7 @@ static test_return  mget_test(memcached_st *memc)
   rc= memcached_mget(memc, keys, key_length, 3);
   assert(rc == MEMCACHED_SUCCESS);
 
-  while ((return_value= memcached_fetch(memc, return_key, &return_key_length, 
+  while ((return_value= memcached_fetch(memc, return_key, &return_key_length,
                       &return_value_length, &flags, &rc)) != NULL)
   {
     assert(return_value);
@@ -1341,7 +1425,7 @@ static test_return  mget_test(memcached_st *memc)
 
   for (x= 0; x < 3; x++)
   {
-    rc= memcached_set(memc, keys[x], key_length[x], 
+    rc= memcached_set(memc, keys[x], key_length[x],
                       keys[x], key_length[x],
                       (time_t)50, (uint32_t)9);
     assert(rc == MEMCACHED_SUCCESS || rc == MEMCACHED_BUFFERED);
@@ -1351,7 +1435,7 @@ static test_return  mget_test(memcached_st *memc)
   assert(rc == MEMCACHED_SUCCESS);
 
   x= 0;
-  while ((return_value= memcached_fetch(memc, return_key, &return_key_length, 
+  while ((return_value= memcached_fetch(memc, return_key, &return_key_length,
                                         &return_value_length, &flags, &rc)))
   {
     assert(return_value);
@@ -1362,10 +1446,10 @@ static test_return  mget_test(memcached_st *memc)
     x++;
   }
 
-  return 0;
+  return TEST_SUCCESS;
 }
 
-static test_return  get_stats_keys(memcached_st *memc)
+static test_return_t  get_stats_keys(memcached_st *memc)
 {
  char **list;
  char **ptr;
@@ -1380,10 +1464,10 @@ static test_return  get_stats_keys(memcached_st *memc)
 
  free(list);
 
- return 0;
+ return TEST_SUCCESS;
 }
 
-static test_return  version_string_test(memcached_st *memc __attribute__((unused)))
+static test_return_t  version_string_test(memcached_st *memc __attribute__((unused)))
 {
   const char *version_string;
 
@@ -1391,10 +1475,10 @@ static test_return  version_string_test(memcached_st *memc __attribute__((unused
 
   assert(!strcmp(version_string, LIBMEMCACHED_VERSION_STRING));
 
-  return 0;
+  return TEST_SUCCESS;
 }
 
-static test_return  get_stats(memcached_st *memc)
+static test_return_t  get_stats(memcached_st *memc)
 {
  unsigned int x;
  char **list;
@@ -1419,10 +1503,10 @@ static test_return  get_stats(memcached_st *memc)
 
  memcached_stat_free(NULL, memc_stat);
 
-  return 0;
+  return TEST_SUCCESS;
 }
 
-static test_return  add_host_test(memcached_st *memc)
+static test_return_t  add_host_test(memcached_st *memc)
 {
   unsigned int x;
   memcached_server_st *servers;
@@ -1438,7 +1522,7 @@ static test_return  add_host_test(memcached_st *memc)
     char buffer[SMALL_STRING_LEN];
 
     snprintf(buffer, SMALL_STRING_LEN, "%u.example.com", 400+x);
-    servers= memcached_server_list_append_with_weight(servers, buffer, 401, 0, 
+    servers= memcached_server_list_append_with_weight(servers, buffer, 401, 0,
                                      &rc);
     assert(rc == MEMCACHED_SUCCESS);
     assert(x == memcached_server_list_count(servers));
@@ -1451,7 +1535,7 @@ static test_return  add_host_test(memcached_st *memc)
 
   memcached_server_list_free(servers);
 
-  return 0;
+  return TEST_SUCCESS;
 }
 
 static memcached_return  clone_test_callback(memcached_st *parent __attribute__((unused)), memcached_st *memc_clone __attribute__((unused)))
@@ -1464,7 +1548,7 @@ static memcached_return  cleanup_test_callback(memcached_st *ptr __attribute__((
   return MEMCACHED_SUCCESS;
 }
 
-static test_return  callback_test(memcached_st *memc)
+static test_return_t  callback_test(memcached_st *memc)
 {
   /* Test User Data */
   {
@@ -1507,11 +1591,11 @@ static test_return  callback_test(memcached_st *memc)
     assert(temp_function == cleanup_cb_ptr);
   }
 
-  return 0;
+  return TEST_SUCCESS;
 }
 
 /* We don't test the behavior itself, we test the switches */
-static test_return  behavior_test(memcached_st *memc)
+static test_return_t  behavior_test(memcached_st *memc)
 {
   uint64_t value;
   uint32_t set= 1;
@@ -1558,11 +1642,31 @@ static test_return  behavior_test(memcached_st *memc)
   value= memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_NUMBER_OF_REPLICAS);
   memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_NUMBER_OF_REPLICAS, value + 1);
   assert((value + 1) == memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_NUMBER_OF_REPLICAS));
-  return 0;
+  return TEST_SUCCESS;
+}
+
+static test_return_t fetch_all_results(memcached_st *memc)
+{
+  memcached_return rc= MEMCACHED_SUCCESS;
+  char return_key[MEMCACHED_MAX_KEY];
+  size_t return_key_length;
+  char *return_value;
+  size_t return_value_length;
+  uint32_t flags;
+
+  while ((return_value= memcached_fetch(memc, return_key, &return_key_length,
+                                        &return_value_length, &flags, &rc)))
+  {
+    assert(return_value);
+    assert(rc == MEMCACHED_SUCCESS);
+    free(return_value);
+  }
+
+  return ((rc == MEMCACHED_END) || (rc == MEMCACHED_SUCCESS)) ? TEST_SUCCESS : TEST_FAILURE;
 }
 
 /* Test case provided by Cal Haldenbrand */
-static test_return  user_supplied_bug1(memcached_st *memc)
+static test_return_t  user_supplied_bug1(memcached_st *memc)
 {
   unsigned int setter= 1;
   unsigned int x;
@@ -1570,7 +1674,7 @@ static test_return  user_supplied_bug1(memcached_st *memc)
   unsigned long long total= 0;
   uint32_t size= 0;
   char key[10];
-  char randomstuff[6 * 1024]; 
+  char randomstuff[6 * 1024];
   memcached_return rc;
 
   memset(randomstuff, 0, 6 * 1024);
@@ -1591,26 +1695,26 @@ static test_return  user_supplied_bug1(memcached_st *memc)
     memset(randomstuff, 0, 6 * 1024);
     assert(size < 6 * 1024); /* Being safe here */
 
-    for (j= 0 ; j < size ;j++) 
+    for (j= 0 ; j < size ;j++)
       randomstuff[j] = (signed char) ((rand() % 26) + 97);
 
     total += size;
     sprintf(key, "%d", x);
-    rc = memcached_set(memc, key, strlen(key), 
+    rc = memcached_set(memc, key, strlen(key),
                        randomstuff, strlen(randomstuff), 10, 0);
     assert(rc == MEMCACHED_SUCCESS || rc == MEMCACHED_BUFFERED);
     /* If we fail, lets try again */
     if (rc != MEMCACHED_SUCCESS && rc != MEMCACHED_BUFFERED)
-      rc = memcached_set(memc, key, strlen(key), 
+      rc = memcached_set(memc, key, strlen(key),
                          randomstuff, strlen(randomstuff), 10, 0);
     assert(rc == MEMCACHED_SUCCESS || rc == MEMCACHED_BUFFERED);
   }
 
-  return 0;
+  return TEST_SUCCESS;
 }
 
 /* Test case provided by Cal Haldenbrand */
-static test_return  user_supplied_bug2(memcached_st *memc)
+static test_return_t  user_supplied_bug2(memcached_st *memc)
 {
   int errors;
   unsigned int setter;
@@ -1643,8 +1747,8 @@ static test_return  user_supplied_bug2(memcached_st *memc)
 
     snprintf(buffer, SMALL_STRING_LEN, "%u", x);
     getval= memcached_get(memc, buffer, strlen(buffer),
-                           &val_len, &flags, &rc);		
-    if (rc != MEMCACHED_SUCCESS) 
+                           &val_len, &flags, &rc);
+    if (rc != MEMCACHED_SUCCESS)
     {
       if (rc == MEMCACHED_NOTFOUND)
         errors++;
@@ -1660,12 +1764,12 @@ static test_return  user_supplied_bug2(memcached_st *memc)
     free(getval);
   }
 
-  return 0;
+  return TEST_SUCCESS;
 }
 
 /* Do a large mget() over all the keys we think exist */
 #define KEY_COUNT 3000 // * 1024576
-static test_return  user_supplied_bug3(memcached_st *memc)
+static test_return_t  user_supplied_bug3(memcached_st *memc)
 {
   memcached_return rc;
   unsigned int setter;
@@ -1685,9 +1789,8 @@ static test_return  user_supplied_bug3(memcached_st *memc)
   getter = memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_SOCKET_RECV_SIZE);
 #endif
 
-  keys= (char **)malloc(sizeof(char *) * KEY_COUNT);
+  keys= calloc(KEY_COUNT, sizeof(char *));
   assert(keys);
-  memset(keys, 0, (sizeof(char *) * KEY_COUNT));
   for (x= 0; x < KEY_COUNT; x++)
   {
     char buffer[30];
@@ -1700,32 +1803,17 @@ static test_return  user_supplied_bug3(memcached_st *memc)
   rc= memcached_mget(memc, (const char **)keys, key_lengths, KEY_COUNT);
   assert(rc == MEMCACHED_SUCCESS);
 
-  /* Turn this into a help function */
-  {
-    char return_key[MEMCACHED_MAX_KEY];
-    size_t return_key_length;
-    char *return_value;
-    size_t return_value_length;
-    uint32_t flags;
-
-    while ((return_value= memcached_fetch(memc, return_key, &return_key_length, 
-                                          &return_value_length, &flags, &rc)))
-    {
-      assert(return_value);
-      assert(rc == MEMCACHED_SUCCESS);
-      free(return_value);
-    }
-  }
+  assert(fetch_all_results(memc) == TEST_SUCCESS);
 
   for (x= 0; x < KEY_COUNT; x++)
     free(keys[x]);
   free(keys);
 
-  return 0;
+  return TEST_SUCCESS;
 }
 
 /* Make sure we behave properly if server list has no values */
-static test_return  user_supplied_bug4(memcached_st *memc)
+static test_return_t  user_supplied_bug4(memcached_st *memc)
 {
   memcached_return rc;
   const char *keys[]= {"fudge", "son", "food"};
@@ -1752,7 +1840,7 @@ static test_return  user_supplied_bug4(memcached_st *memc)
   rc= memcached_mget(memc, keys, key_length, 3);
   assert(rc == MEMCACHED_NO_SERVERS);
 
-  while ((return_value= memcached_fetch(memc, return_key, &return_key_length, 
+  while ((return_value= memcached_fetch(memc, return_key, &return_key_length,
                       &return_value_length, &flags, &rc)) != NULL)
   {
     assert(return_value);
@@ -1763,7 +1851,7 @@ static test_return  user_supplied_bug4(memcached_st *memc)
 
   for (x= 0; x < 3; x++)
   {
-    rc= memcached_set(memc, keys[x], key_length[x], 
+    rc= memcached_set(memc, keys[x], key_length[x],
                       keys[x], key_length[x],
                       (time_t)50, (uint32_t)9);
     assert(rc == MEMCACHED_NO_SERVERS);
@@ -1773,7 +1861,7 @@ static test_return  user_supplied_bug4(memcached_st *memc)
   assert(rc == MEMCACHED_NO_SERVERS);
 
   x= 0;
-  while ((return_value= memcached_fetch(memc, return_key, &return_key_length, 
+  while ((return_value= memcached_fetch(memc, return_key, &return_key_length,
                                         &return_value_length, &flags, &rc)))
   {
     assert(return_value);
@@ -1784,11 +1872,11 @@ static test_return  user_supplied_bug4(memcached_st *memc)
     x++;
   }
 
-  return 0;
+  return TEST_SUCCESS;
 }
 
 #define VALUE_SIZE_BUG5 1048064
-static test_return  user_supplied_bug5(memcached_st *memc)
+static test_return_t  user_supplied_bug5(memcached_st *memc)
 {
   memcached_return rc;
   const char *keys[]= {"036790384900", "036790384902", "036790384904", "036790384906"};
@@ -1807,19 +1895,19 @@ static test_return  user_supplied_bug5(memcached_st *memc)
 
   memcached_flush(memc, 0);
   value= memcached_get(memc, keys[0], key_length[0],
-                        &value_length, &flags, &rc);		
+                        &value_length, &flags, &rc);
   assert(value == NULL);
   rc= memcached_mget(memc, keys, key_length, 4);
 
   count= 0;
-  while ((value= memcached_fetch(memc, return_key, &return_key_length, 
+  while ((value= memcached_fetch(memc, return_key, &return_key_length,
                                         &value_length, &flags, &rc)))
     count++;
   assert(count == 0);
 
   for (x= 0; x < 4; x++)
   {
-    rc= memcached_set(memc, keys[x], key_length[x], 
+    rc= memcached_set(memc, keys[x], key_length[x],
                       insert_data, VALUE_SIZE_BUG5,
                       (time_t)0, (uint32_t)0);
     assert(rc == MEMCACHED_SUCCESS);
@@ -1828,13 +1916,13 @@ static test_return  user_supplied_bug5(memcached_st *memc)
   for (x= 0; x < 10; x++)
   {
     value= memcached_get(memc, keys[0], key_length[0],
-                         &value_length, &flags, &rc);		
+                         &value_length, &flags, &rc);
     assert(value);
     free(value);
 
     rc= memcached_mget(memc, keys, key_length, 4);
     count= 0;
-    while ((value= memcached_fetch(memc, return_key, &return_key_length, 
+    while ((value= memcached_fetch(memc, return_key, &return_key_length,
                                           &value_length, &flags, &rc)))
     {
       count++;
@@ -1843,10 +1931,10 @@ static test_return  user_supplied_bug5(memcached_st *memc)
     assert(count == 4);
   }
 
-  return 0;
+  return TEST_SUCCESS;
 }
 
-static test_return  user_supplied_bug6(memcached_st *memc)
+static test_return_t  user_supplied_bug6(memcached_st *memc)
 {
   memcached_return rc;
   const char *keys[]= {"036790384900", "036790384902", "036790384904", "036790384906"};
@@ -1865,14 +1953,14 @@ static test_return  user_supplied_bug6(memcached_st *memc)
 
   memcached_flush(memc, 0);
   value= memcached_get(memc, keys[0], key_length[0],
-                        &value_length, &flags, &rc);		
+                        &value_length, &flags, &rc);
   assert(value == NULL);
   assert(rc == MEMCACHED_NOTFOUND);
   rc= memcached_mget(memc, keys, key_length, 4);
   assert(rc == MEMCACHED_SUCCESS);
 
   count= 0;
-  while ((value= memcached_fetch(memc, return_key, &return_key_length, 
+  while ((value= memcached_fetch(memc, return_key, &return_key_length,
                                         &value_length, &flags, &rc)))
     count++;
   assert(count == 0);
@@ -1880,7 +1968,7 @@ static test_return  user_supplied_bug6(memcached_st *memc)
 
   for (x= 0; x < 4; x++)
   {
-    rc= memcached_set(memc, keys[x], key_length[x], 
+    rc= memcached_set(memc, keys[x], key_length[x],
                       insert_data, VALUE_SIZE_BUG5,
                       (time_t)0, (uint32_t)0);
     assert(rc == MEMCACHED_SUCCESS);
@@ -1889,7 +1977,7 @@ static test_return  user_supplied_bug6(memcached_st *memc)
   for (x= 0; x < 2; x++)
   {
     value= memcached_get(memc, keys[0], key_length[0],
-                         &value_length, &flags, &rc);		
+                         &value_length, &flags, &rc);
     assert(value);
     free(value);
 
@@ -1899,7 +1987,7 @@ static test_return  user_supplied_bug6(memcached_st *memc)
     /* We test for purge of partial complete fetches */
     for (count= 3; count; count--)
     {
-      value= memcached_fetch(memc, return_key, &return_key_length, 
+      value= memcached_fetch(memc, return_key, &return_key_length,
                              &value_length, &flags, &rc);
       assert(rc == MEMCACHED_SUCCESS);
       assert(!(memcmp(value, insert_data, value_length)));
@@ -1908,10 +1996,10 @@ static test_return  user_supplied_bug6(memcached_st *memc)
     }
   }
 
-  return 0;
+  return TEST_SUCCESS;
 }
 
-static test_return  user_supplied_bug8(memcached_st *memc __attribute__((unused)))
+static test_return_t  user_supplied_bug8(memcached_st *memc __attribute__((unused)))
 {
   memcached_return rc;
   memcached_st *mine;
@@ -1938,11 +2026,11 @@ static test_return  user_supplied_bug8(memcached_st *memc __attribute__((unused)
   memcached_free(mine);
   memcached_free(memc_clone);
 
-  return 0;
+  return TEST_SUCCESS;
 }
 
 /* Test flag store/retrieve */
-static test_return  user_supplied_bug7(memcached_st *memc)
+static test_return_t  user_supplied_bug7(memcached_st *memc)
 {
   memcached_return rc;
   const char *keys= "036790384900";
@@ -1961,14 +2049,14 @@ static test_return  user_supplied_bug7(memcached_st *memc)
   memcached_flush(memc, 0);
 
   flags= 245;
-  rc= memcached_set(memc, keys, key_length, 
+  rc= memcached_set(memc, keys, key_length,
                     insert_data, VALUE_SIZE_BUG5,
                     (time_t)0, flags);
   assert(rc == MEMCACHED_SUCCESS);
 
   flags= 0;
   value= memcached_get(memc, keys, key_length,
-                        &value_length, &flags, &rc);		
+                        &value_length, &flags, &rc);
   assert(flags == 245);
   assert(value);
   free(value);
@@ -1976,17 +2064,17 @@ static test_return  user_supplied_bug7(memcached_st *memc)
   rc= memcached_mget(memc, &keys, &key_length, 1);
 
   flags= 0;
-  value= memcached_fetch(memc, return_key, &return_key_length, 
+  value= memcached_fetch(memc, return_key, &return_key_length,
                          &value_length, &flags, &rc);
   assert(flags == 245);
   assert(value);
   free(value);
 
 
-  return 0;
+  return TEST_SUCCESS;
 }
 
-static test_return  user_supplied_bug9(memcached_st *memc)
+static test_return_t  user_supplied_bug9(memcached_st *memc)
 {
   memcached_return rc;
   const char *keys[]= {"UDATA:edevil@sapo.pt", "fudge&*@#", "for^#@&$not"};
@@ -2008,7 +2096,7 @@ static test_return  user_supplied_bug9(memcached_st *memc)
 
   for (x= 0; x < 3; x++)
   {
-    rc= memcached_set(memc, keys[x], key_length[x], 
+    rc= memcached_set(memc, keys[x], key_length[x],
                       keys[x], key_length[x],
                       (time_t)50, (uint32_t)9);
     assert(rc == MEMCACHED_SUCCESS);
@@ -2018,7 +2106,7 @@ static test_return  user_supplied_bug9(memcached_st *memc)
   assert(rc == MEMCACHED_SUCCESS);
 
   /* We need to empty the server before continueing test */
-  while ((return_value= memcached_fetch(memc, return_key, &return_key_length, 
+  while ((return_value= memcached_fetch(memc, return_key, &return_key_length,
                       &return_value_length, &flags, &rc)) != NULL)
   {
     assert(return_value);
@@ -2027,11 +2115,11 @@ static test_return  user_supplied_bug9(memcached_st *memc)
   }
   assert(count == 3);
 
-  return 0;
+  return TEST_SUCCESS;
 }
 
 /* We are testing with aggressive timeout to get failures */
-static test_return  user_supplied_bug10(memcached_st *memc)
+static test_return_t  user_supplied_bug10(memcached_st *memc)
 {
   const char *key= "foo";
   char *value;
@@ -2058,7 +2146,7 @@ static test_return  user_supplied_bug10(memcached_st *memc)
   {
     rc= memcached_set(mclone, key, key_len,value, value_length, 0, 0);
 
-    assert(rc == MEMCACHED_SUCCESS || rc == MEMCACHED_WRITE_FAILURE || 
+    assert(rc == MEMCACHED_SUCCESS || rc == MEMCACHED_WRITE_FAILURE ||
            rc == MEMCACHED_BUFFERED || rc == MEMCACHED_TIMEOUT);
 
     if (rc == MEMCACHED_WRITE_FAILURE || rc == MEMCACHED_TIMEOUT)
@@ -2068,13 +2156,13 @@ static test_return  user_supplied_bug10(memcached_st *memc)
   free(value);
   memcached_free(mclone);
 
-  return 0;
+  return TEST_SUCCESS;
 }
 
 /*
   We are looking failures in the async protocol
 */
-static test_return  user_supplied_bug11(memcached_st *memc)
+static test_return_t  user_supplied_bug11(memcached_st *memc)
 {
   const char *key= "foo";
   char *value;
@@ -2109,13 +2197,13 @@ static test_return  user_supplied_bug11(memcached_st *memc)
   free(value);
   memcached_free(mclone);
 
-  return 0;
+  return TEST_SUCCESS;
 }
 
 /*
   Bug found where incr was not returning MEMCACHED_NOTFOUND when object did not exist.
 */
-static test_return  user_supplied_bug12(memcached_st *memc)
+static test_return_t  user_supplied_bug12(memcached_st *memc)
 {
   memcached_return rc;
   uint32_t flags;
@@ -2124,7 +2212,7 @@ static test_return  user_supplied_bug12(memcached_st *memc)
   uint64_t number_value;
 
   value= memcached_get(memc, "autoincrement", strlen("autoincrement"),
-                        &value_length, &flags, &rc);		
+                        &value_length, &flags, &rc);
   assert(value == NULL);
   assert(rc == MEMCACHED_NOTFOUND);
 
@@ -2133,7 +2221,7 @@ static test_return  user_supplied_bug12(memcached_st *memc)
 
   assert(value == NULL);
   /* The binary protocol will set the key if it doesn't exist */
-  if (memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL) == 1) 
+  if (memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL) == 1)
     assert(rc == MEMCACHED_SUCCESS);
   else
     assert(rc == MEMCACHED_NOTFOUND);
@@ -2141,7 +2229,7 @@ static test_return  user_supplied_bug12(memcached_st *memc)
   rc= memcached_set(memc, "autoincrement", strlen("autoincrement"), "1", 1, 0, 0);
 
   value= memcached_get(memc, "autoincrement", strlen("autoincrement"),
-                        &value_length, &flags, &rc);		
+                        &value_length, &flags, &rc);
   assert(value);
   assert(rc == MEMCACHED_SUCCESS);
   free(value);
@@ -2151,14 +2239,14 @@ static test_return  user_supplied_bug12(memcached_st *memc)
   assert(number_value == 2);
   assert(rc == MEMCACHED_SUCCESS);
 
-  return 0;
+  return TEST_SUCCESS;
 }
 
 /*
   Bug found where command total one more than MEMCACHED_MAX_BUFFER
   set key34567890 0 0 8169 \r\n is sent followed by buffer of size 8169, followed by 8169
  */
-static test_return  user_supplied_bug13(memcached_st *memc)
+static test_return_t  user_supplied_bug13(memcached_st *memc)
 {
   char key[] = "key34567890";
   char *overflow;
@@ -2186,7 +2274,7 @@ static test_return  user_supplied_bug13(memcached_st *memc)
     free(overflow);
   }
 
-  return 0;
+  return TEST_SUCCESS;
 }
 
 
@@ -2196,7 +2284,7 @@ static test_return  user_supplied_bug13(memcached_st *memc)
   set key34567890 0 0 8169 \r\n
   is sent followed by buffer of size 8169, followed by 8169
  */
-static test_return  user_supplied_bug14(memcached_st *memc)
+static test_return_t  user_supplied_bug14(memcached_st *memc)
 {
   size_t setter= 1;
   memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_TCP_NODELAY, setter);
@@ -2218,7 +2306,7 @@ static test_return  user_supplied_bug14(memcached_st *memc)
 
   for (current_length= 0; current_length < value_length; current_length++)
   {
-    rc= memcached_set(memc, key, strlen(key), 
+    rc= memcached_set(memc, key, strlen(key),
                       value, current_length,
                       (time_t)0, (uint32_t)0);
     assert(rc == MEMCACHED_SUCCESS || rc == MEMCACHED_BUFFERED);
@@ -2235,13 +2323,13 @@ static test_return  user_supplied_bug14(memcached_st *memc)
 
   free(value);
 
-  return 0;
+  return TEST_SUCCESS;
 }
 
 /*
   Look for zero length value problems
   */
-static test_return  user_supplied_bug15(memcached_st *memc)
+static test_return_t  user_supplied_bug15(memcached_st *memc)
 {
   uint32_t x;
   memcached_return rc;
@@ -2252,7 +2340,7 @@ static test_return  user_supplied_bug15(memcached_st *memc)
 
   for (x= 0; x < 2; x++)
   {
-    rc= memcached_set(memc, key, strlen(key), 
+    rc= memcached_set(memc, key, strlen(key),
                       NULL, 0,
                       (time_t)0, (uint32_t)0);
 
@@ -2275,11 +2363,11 @@ static test_return  user_supplied_bug15(memcached_st *memc)
     assert(flags == 0);
   }
 
-  return 0;
+  return TEST_SUCCESS;
 }
 
 /* Check the return sizes on FLAGS to make sure it stores 32bit unsigned values correctly */
-static test_return  user_supplied_bug16(memcached_st *memc)
+static test_return_t  user_supplied_bug16(memcached_st *memc)
 {
   memcached_return rc;
   const char *key= "mykey";
@@ -2287,7 +2375,7 @@ static test_return  user_supplied_bug16(memcached_st *memc)
   size_t length;
   uint32_t flags;
 
-  rc= memcached_set(memc, key, strlen(key), 
+  rc= memcached_set(memc, key, strlen(key),
                     NULL, 0,
                     (time_t)0, UINT32_MAX);
 
@@ -2301,11 +2389,12 @@ static test_return  user_supplied_bug16(memcached_st *memc)
   assert(length == 0);
   assert(flags == UINT32_MAX);
 
-  return 0;
+  return TEST_SUCCESS;
 }
 
+#ifndef __sun
 /* Check the validity of chinese key*/
-static test_return  user_supplied_bug17(memcached_st *memc)
+static test_return_t  user_supplied_bug17(memcached_st *memc)
 {
     memcached_return rc;
     const char *key= "豆瓣";
@@ -2328,14 +2417,15 @@ static test_return  user_supplied_bug17(memcached_st *memc)
     assert(memcmp(value, value2, length)==0);
     free(value2);
 
-    return 0;
+    return TEST_SUCCESS;
 }
+#endif
 
 /*
   From Andrei on IRC
 */
 
-static test_return user_supplied_bug19(memcached_st *memc)
+static test_return_t user_supplied_bug19(memcached_st *memc)
 {
   memcached_st *m;
   memcached_server_st *s;
@@ -2352,11 +2442,11 @@ static test_return user_supplied_bug19(memcached_st *memc)
 
   memcached_free(m);
 
-  return 0;
+  return TEST_SUCCESS;
 }
 
 /* CAS test from Andei */
-static test_return user_supplied_bug20(memcached_st *memc)
+static test_return_t user_supplied_bug20(memcached_st *memc)
 {
   memcached_return status;
   memcached_result_st *result, result_obj;
@@ -2384,11 +2474,11 @@ static test_return user_supplied_bug20(memcached_st *memc)
 
   memcached_result_free(result);
 
-  return 0;
+  return TEST_SUCCESS;
 }
 
 #include "ketama_test_cases.h"
-static test_return user_supplied_bug18(memcached_st *trash)
+static test_return_t user_supplied_bug18(memcached_st *trash)
 {
   memcached_return rc;
   uint64_t value;
@@ -2400,7 +2490,7 @@ static test_return user_supplied_bug18(memcached_st *trash)
 
   memc= memcached_create(NULL);
   assert(memc);
-    
+
   rc= memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_KETAMA_WEIGHTED, 1);
   assert(rc == MEMCACHED_SUCCESS);
 
@@ -2415,7 +2505,7 @@ static test_return user_supplied_bug18(memcached_st *trash)
 
   server_pool = memcached_servers_parse("10.0.1.1:11211 600,10.0.1.2:11211 300,10.0.1.3:11211 200,10.0.1.4:11211 350,10.0.1.5:11211 1000,10.0.1.6:11211 800,10.0.1.7:11211 950,10.0.1.8:11211 100");
   memcached_server_push(memc, server_pool);
-  
+
   /* verify that the server list was parsed okay. */
   assert(memc->number_of_hosts == 8);
   assert(strcmp(server_pool[0].hostname, "10.0.1.1") == 0);
@@ -2444,10 +2534,96 @@ static test_return user_supplied_bug18(memcached_st *trash)
   memcached_server_list_free(server_pool);
   memcached_free(memc);
 
-  return 0;
+  return TEST_SUCCESS;
+}
+
+/* Large mget() of missing keys with binary proto
+ *
+ * If many binary quiet commands (such as getq's in an mget) fill the output
+ * buffer and the server chooses not to respond, memcached_flush hangs. See
+ * http://lists.tangent.org/pipermail/libmemcached/2009-August/000918.html
+ */
+
+/* sighandler_t function that always asserts false */
+static void fail(int unused __attribute__((unused)))
+{
+  assert(0);
+}
+
+
+static test_return_t  _user_supplied_bug21(memcached_st* memc, size_t key_count)
+{
+  memcached_return rc;
+  unsigned int x;
+  char **keys;
+  size_t* key_lengths;
+  void (*oldalarm)(int);
+  memcached_st *memc_clone;
+
+  memc_clone= memcached_clone(NULL, memc);
+  assert(memc_clone);
+
+  /* only binproto uses getq for mget */
+  memcached_behavior_set(memc_clone, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL, 1);
+
+  /* empty the cache to ensure misses (hence non-responses) */
+  rc= memcached_flush(memc_clone, 0);
+  assert(rc == MEMCACHED_SUCCESS);
+
+  key_lengths= calloc(key_count, sizeof(size_t));
+  keys= calloc(key_count, sizeof(char *));
+  assert(keys);
+  for (x= 0; x < key_count; x++)
+  {
+    char buffer[30];
+
+    snprintf(buffer, 30, "%u", x);
+    keys[x]= strdup(buffer);
+    key_lengths[x]= strlen(keys[x]);
+  }
+
+  oldalarm= signal(SIGALRM, fail);
+  alarm(5);
+
+  rc= memcached_mget(memc_clone, (const char **)keys, key_lengths, key_count);
+  assert(rc == MEMCACHED_SUCCESS);
+
+  alarm(0);
+  signal(SIGALRM, oldalarm);
+
+  assert(fetch_all_results(memc) == TEST_SUCCESS);
+
+  for (x= 0; x < key_count; x++)
+    free(keys[x]);
+  free(keys);
+  free(key_lengths);
+
+  memcached_free(memc_clone);
+
+  return TEST_SUCCESS;
+}
+
+static memcached_return pre_binary(memcached_st *memc);
+
+static test_return_t user_supplied_bug21(memcached_st *memc)
+{
+  if (pre_binary(memc) != MEMCACHED_SUCCESS)
+    return TEST_SKIPPED;
+
+  test_return_t rc;
+
+  /* should work as of r580 */
+  rc= _user_supplied_bug21(memc, 10);
+  assert(rc == TEST_SUCCESS);
+
+  /* should fail as of r580 */
+  rc= _user_supplied_bug21(memc, 1000);
+  assert(rc == TEST_SUCCESS);
+
+  return TEST_SUCCESS;
 }
 
-static test_return auto_eject_hosts(memcached_st *trash)
+static test_return_t auto_eject_hosts(memcached_st *trash)
 {
   (void) trash;
 
@@ -2516,7 +2692,7 @@ static test_return auto_eject_hosts(memcached_st *trash)
   return TEST_SUCCESS;
 }
 
-static test_return  result_static(memcached_st *memc)
+static test_return_t  result_static(memcached_st *memc)
 {
   memcached_result_st result;
   memcached_result_st *result_ptr;
@@ -2526,10 +2702,10 @@ static test_return  result_static(memcached_st *memc)
   assert(result_ptr);
   memcached_result_free(&result);
 
-  return 0;
+  return TEST_SUCCESS;
 }
 
-static test_return  result_alloc(memcached_st *memc)
+static test_return_t  result_alloc(memcached_st *memc)
 {
   memcached_result_st *result;
 
@@ -2537,10 +2713,10 @@ static test_return  result_alloc(memcached_st *memc)
   assert(result);
   memcached_result_free(result);
 
-  return 0;
+  return TEST_SUCCESS;
 }
 
-static test_return  string_static_null(memcached_st *memc)
+static test_return_t  string_static_null(memcached_st *memc)
 {
   memcached_string_st string;
   memcached_string_st *string_ptr;
@@ -2550,10 +2726,10 @@ static test_return  string_static_null(memcached_st *memc)
   assert(string_ptr);
   memcached_string_free(&string);
 
-  return 0;
+  return TEST_SUCCESS;
 }
 
-static test_return  string_alloc_null(memcached_st *memc)
+static test_return_t  string_alloc_null(memcached_st *memc)
 {
   memcached_string_st *string;
 
@@ -2561,10 +2737,10 @@ static test_return  string_alloc_null(memcached_st *memc)
   assert(string);
   memcached_string_free(string);
 
-  return 0;
+  return TEST_SUCCESS;
 }
 
-static test_return  string_alloc_with_size(memcached_st *memc)
+static test_return_t  string_alloc_with_size(memcached_st *memc)
 {
   memcached_string_st *string;
 
@@ -2572,20 +2748,20 @@ static test_return  string_alloc_with_size(memcached_st *memc)
   assert(string);
   memcached_string_free(string);
 
-  return 0;
+  return TEST_SUCCESS;
 }
 
-static test_return  string_alloc_with_size_toobig(memcached_st *memc)
+static test_return_t  string_alloc_with_size_toobig(memcached_st *memc)
 {
   memcached_string_st *string;
 
   string= memcached_string_create(memc, NULL, SIZE_MAX);
   assert(string == NULL);
 
-  return 0;
+  return TEST_SUCCESS;
 }
 
-static test_return  string_alloc_append(memcached_st *memc)
+static test_return_t  string_alloc_append(memcached_st *memc)
 {
   unsigned int x;
   char buffer[SMALL_STRING_LEN];
@@ -2605,10 +2781,10 @@ static test_return  string_alloc_append(memcached_st *memc)
   }
   memcached_string_free(string);
 
-  return 0;
+  return TEST_SUCCESS;
 }
 
-static test_return  string_alloc_append_toobig(memcached_st *memc)
+static test_return_t  string_alloc_append_toobig(memcached_st *memc)
 {
   memcached_return rc;
   unsigned int x;
@@ -2630,17 +2806,17 @@ static test_return  string_alloc_append_toobig(memcached_st *memc)
   assert(rc == MEMCACHED_MEMORY_ALLOCATION_FAILURE);
   memcached_string_free(string);
 
-  return 0;
+  return TEST_SUCCESS;
 }
 
-static test_return  cleanup_pairs(memcached_st *memc __attribute__((unused)))
+static test_return_t  cleanup_pairs(memcached_st *memc __attribute__((unused)))
 {
   pairs_free(global_pairs);
 
-  return 0;
+  return TEST_SUCCESS;
 }
 
-static test_return  generate_pairs(memcached_st *memc __attribute__((unused)))
+static test_return_t  generate_pairs(memcached_st *memc __attribute__((unused)))
 {
   unsigned long long x;
   global_pairs= pairs_generate(GLOBAL_COUNT, 400);
@@ -2648,14 +2824,14 @@ static test_return  generate_pairs(memcached_st *memc __attribute__((unused)))
 
   for (x= 0; x < global_count; x++)
   {
-    global_keys[x]= global_pairs[x].key; 
+    global_keys[x]= global_pairs[x].key;
     global_keys_length[x]=  global_pairs[x].key_length;
   }
 
-  return 0;
+  return TEST_SUCCESS;
 }
 
-static test_return  generate_large_pairs(memcached_st *memc __attribute__((unused)))
+static test_return_t  generate_large_pairs(memcached_st *memc __attribute__((unused)))
 {
   unsigned long long x;
   global_pairs= pairs_generate(GLOBAL2_COUNT, MEMCACHED_MAX_BUFFER+10);
@@ -2663,21 +2839,21 @@ static test_return  generate_large_pairs(memcached_st *memc __attribute__((unuse
 
   for (x= 0; x < global_count; x++)
   {
-    global_keys[x]= global_pairs[x].key; 
+    global_keys[x]= global_pairs[x].key;
     global_keys_length[x]=  global_pairs[x].key_length;
   }
 
-  return 0;
+  return TEST_SUCCESS;
 }
 
-static test_return  generate_data(memcached_st *memc)
+static test_return_t  generate_data(memcached_st *memc)
 {
   execute_set(memc, global_pairs, global_count);
 
-  return 0;
+  return TEST_SUCCESS;
 }
 
-static test_return  generate_data_with_stats(memcached_st *memc)
+static test_return_t  generate_data_with_stats(memcached_st *memc)
 {
   memcached_stat_st *stat_p;
   memcached_return rc;
@@ -2699,9 +2875,9 @@ static test_return  generate_data_with_stats(memcached_st *memc)
 
   memcached_stat_free(NULL, stat_p);
 
-  return 0;
+  return TEST_SUCCESS;
 }
-static test_return  generate_buffer_data(memcached_st *memc)
+static test_return_t  generate_buffer_data(memcached_st *memc)
 {
   size_t latch= 0;
 
@@ -2709,10 +2885,10 @@ static test_return  generate_buffer_data(memcached_st *memc)
   memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_BUFFER_REQUESTS, latch);
   generate_data(memc);
 
-  return 0;
+  return TEST_SUCCESS;
 }
 
-static test_return  get_read_count(memcached_st *memc)
+static test_return_t  get_read_count(memcached_st *memc)
 {
   unsigned int x;
   memcached_return rc;
@@ -2740,15 +2916,14 @@ static test_return  get_read_count(memcached_st *memc)
           free(return_value);
       }
     }
-    fprintf(stderr, "\t%u -> %u", global_count, count);
   }
 
   memcached_free(memc_clone);
 
-  return 0;
+  return TEST_SUCCESS;
 }
 
-static test_return  get_read(memcached_st *memc)
+static test_return_t  get_read(memcached_st *memc)
 {
   unsigned int x;
   memcached_return rc;
@@ -2771,36 +2946,21 @@ static test_return  get_read(memcached_st *memc)
     }
   }
 
-  return 0;
+  return TEST_SUCCESS;
 }
 
-static test_return  mget_read(memcached_st *memc)
+static test_return_t  mget_read(memcached_st *memc)
 {
   memcached_return rc;
 
   rc= memcached_mget(memc, global_keys, global_keys_length, global_count);
   assert(rc == MEMCACHED_SUCCESS);
-  /* Turn this into a help function */
-  {
-    char return_key[MEMCACHED_MAX_KEY];
-    size_t return_key_length;
-    char *return_value;
-    size_t return_value_length;
-    uint32_t flags;
+  assert(fetch_all_results(memc) == TEST_SUCCESS);
 
-    while ((return_value= memcached_fetch(memc, return_key, &return_key_length,
-                                          &return_value_length, &flags, &rc)))
-    {
-      assert(return_value);
-      assert(rc == MEMCACHED_SUCCESS);
-      free(return_value);
-    }
-  }
-
-  return 0;
+  return TEST_SUCCESS;
 }
 
-static test_return  mget_read_result(memcached_st *memc)
+static test_return_t  mget_read_result(memcached_st *memc)
 {
   memcached_return rc;
 
@@ -2822,10 +2982,10 @@ static test_return  mget_read_result(memcached_st *memc)
     memcached_result_free(&results_obj);
   }
 
-  return 0;
+  return TEST_SUCCESS;
 }
 
-static test_return  mget_read_function(memcached_st *memc)
+static test_return_t  mget_read_function(memcached_st *memc)
 {
   memcached_return rc;
   unsigned int counter;
@@ -2836,12 +2996,12 @@ static test_return  mget_read_function(memcached_st *memc)
 
   callbacks[0]= &callback_counter;
   counter= 0;
-  rc= memcached_fetch_execute(memc, callbacks, (void *)&counter, 1); 
+  rc= memcached_fetch_execute(memc, callbacks, (void *)&counter, 1);
 
-  return 0;
+  return TEST_SUCCESS;
 }
 
-static test_return  delete_generate(memcached_st *memc)
+static test_return_t  delete_generate(memcached_st *memc)
 {
   unsigned int x;
 
@@ -2850,10 +3010,10 @@ static test_return  delete_generate(memcached_st *memc)
     (void)memcached_delete(memc, global_keys[x], global_keys_length[x], (time_t)0);
   }
 
-  return 0;
+  return TEST_SUCCESS;
 }
 
-static test_return  delete_buffer_generate(memcached_st *memc)
+static test_return_t  delete_buffer_generate(memcached_st *memc)
 {
   size_t latch= 0;
   unsigned int x;
@@ -2866,10 +3026,10 @@ static test_return  delete_buffer_generate(memcached_st *memc)
     (void)memcached_delete(memc, global_keys[x], global_keys_length[x], (time_t)0);
   }
 
-  return 0;
+  return TEST_SUCCESS;
 }
 
-static test_return  add_host_test1(memcached_st *memc)
+static test_return_t  add_host_test1(memcached_st *memc)
 {
   unsigned int x;
   memcached_return rc;
@@ -2885,7 +3045,7 @@ static test_return  add_host_test1(memcached_st *memc)
     char buffer[SMALL_STRING_LEN];
 
     snprintf(buffer, SMALL_STRING_LEN, "%u.example.com", 400+x);
-    servers= memcached_server_list_append_with_weight(servers, buffer, 401, 0, 
+    servers= memcached_server_list_append_with_weight(servers, buffer, 401, 0,
                                      &rc);
     assert(rc == MEMCACHED_SUCCESS);
     assert(x == memcached_server_list_count(servers));
@@ -2898,7 +3058,7 @@ static test_return  add_host_test1(memcached_st *memc)
 
   memcached_server_list_free(servers);
 
-  return 0;
+  return TEST_SUCCESS;
 }
 
 static memcached_return  pre_nonblock(memcached_st *memc)
@@ -2919,7 +3079,7 @@ static memcached_return  pre_nonblock_binary(memcached_st *memc)
   // will not toggle protocol on an connection.
   memcached_version(memc_clone);
 
-  if (memc_clone->hosts[0].major_version >= 1 && memc_clone->hosts[0].minor_version > 2) 
+  if (memc_clone->hosts[0].major_version >= 1 && memc_clone->hosts[0].minor_version > 2)
   {
     memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_NO_BLOCK, 0);
     rc = memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL, 1);
@@ -3043,7 +3203,7 @@ static memcached_return  pre_binary(memcached_st *memc)
   // will not toggle protocol on an connection.
   memcached_version(memc_clone);
 
-  if (memc_clone->hosts[0].major_version >= 1 && memc_clone->hosts[0].minor_version > 2) 
+  if (memc_clone->hosts[0].major_version >= 1 && memc_clone->hosts[0].minor_version > 2)
   {
     rc = memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL, 1);
     assert(rc == MEMCACHED_SUCCESS);
@@ -3051,23 +3211,24 @@ static memcached_return  pre_binary(memcached_st *memc)
   }
 
   memcached_free(memc_clone);
+
   return rc;
 }
 
 static memcached_return pre_replication(memcached_st *memc)
 {
-  memcached_return rc= MEMCACHED_FAILURE;
-  if (pre_binary(memc) == MEMCACHED_SUCCESS) 
-  {
-    /*
-     * Make sure that we store the item on all servers 
-     * (master + replicas == number of servers) 
-     */
-    rc= memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_NUMBER_OF_REPLICAS, 
-                               memc->number_of_hosts - 1);
-    assert(rc == MEMCACHED_SUCCESS);
-    assert(memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_NUMBER_OF_REPLICAS) == memc->number_of_hosts - 1);
-  }
+  if (pre_binary(memc) != MEMCACHED_SUCCESS)
+    return MEMCACHED_FAILURE;
+
+  /*
+   * Make sure that we store the item on all servers
+   * (master + replicas == number of servers)
+   */
+  memcached_return rc;
+  rc= memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_NUMBER_OF_REPLICAS,
+                             memc->number_of_hosts - 1);
+  assert(rc == MEMCACHED_SUCCESS);
+  assert(memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_NUMBER_OF_REPLICAS) == memc->number_of_hosts - 1);
 
   return rc;
 }
@@ -3075,7 +3236,7 @@ static memcached_return pre_replication(memcached_st *memc)
 static memcached_return pre_replication_noblock(memcached_st *memc)
 {
   memcached_return rc= MEMCACHED_FAILURE;
-  if (pre_replication(memc) == MEMCACHED_SUCCESS && 
+  if (pre_replication(memc) == MEMCACHED_SUCCESS &&
       pre_nonblock(memc) == MEMCACHED_SUCCESS)
     rc= MEMCACHED_SUCCESS;
 
@@ -3181,7 +3342,7 @@ static memcached_return deprecated_set_memory_alloc(memcached_st *memc)
   void *test_ptr= NULL;
   void *cb_ptr= NULL;
   {
-    memcached_malloc_function malloc_cb= 
+    memcached_malloc_function malloc_cb=
       (memcached_malloc_function)my_malloc;
     cb_ptr= *(void **)&malloc_cb;
     memcached_return rc;
@@ -3194,7 +3355,7 @@ static memcached_return deprecated_set_memory_alloc(memcached_st *memc)
   }
 
   {
-    memcached_realloc_function realloc_cb= 
+    memcached_realloc_function realloc_cb=
       (memcached_realloc_function)my_realloc;
     cb_ptr= *(void **)&realloc_cb;
     memcached_return rc;
@@ -3207,7 +3368,7 @@ static memcached_return deprecated_set_memory_alloc(memcached_st *memc)
   }
 
   {
-    memcached_free_function free_cb= 
+    memcached_free_function free_cb=
       (memcached_free_function)my_free;
     cb_ptr= *(void **)&free_cb;
     memcached_return rc;
@@ -3225,19 +3386,19 @@ static memcached_return deprecated_set_memory_alloc(memcached_st *memc)
 static memcached_return set_memory_alloc(memcached_st *memc)
 {
   memcached_return rc;
-  rc= memcached_set_memory_allocators(memc, NULL, my_free, 
+  rc= memcached_set_memory_allocators(memc, NULL, my_free,
                                       my_realloc, my_calloc);
   assert(rc == MEMCACHED_FAILURE);
 
-  rc= memcached_set_memory_allocators(memc, my_malloc, my_free, 
+  rc= memcached_set_memory_allocators(memc, my_malloc, my_free,
                                       my_realloc, my_calloc);
-  
+
   memcached_malloc_function mem_malloc;
   memcached_free_function mem_free;
   memcached_realloc_function mem_realloc;
   memcached_calloc_function mem_calloc;
-  memcached_get_memory_allocators(memc, &mem_malloc, &mem_free, 
-                                  &mem_realloc, &mem_calloc);   
+  memcached_get_memory_allocators(memc, &mem_malloc, &mem_free,
+                                  &mem_realloc, &mem_calloc);
 
   assert(mem_malloc == my_malloc);
   assert(mem_realloc == my_realloc);
@@ -3271,7 +3432,7 @@ static memcached_return  enable_cas(memcached_st *memc)
 
   memcached_version(memc);
 
-  if ((memc->hosts[0].major_version >= 1 && (memc->hosts[0].minor_version == 2 && memc->hosts[0].micro_version >= 4)) 
+  if ((memc->hosts[0].major_version >= 1 && (memc->hosts[0].minor_version == 2 && memc->hosts[0].micro_version >= 4))
       || memc->hosts[0].minor_version > 2)
   {
     memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_SUPPORT_CAS, set);
@@ -3334,14 +3495,14 @@ static memcached_return  poll_timeout(memcached_st *memc)
 
   memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_POLL_TIMEOUT, timeout);
 
-  timeout= memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_POLL_TIMEOUT);
+  timeout= (size_t)memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_POLL_TIMEOUT);
 
   assert(timeout == 100);
 
   return MEMCACHED_SUCCESS;
 }
 
-static test_return noreply_test(memcached_st *memc)
+static test_return_t noreply_test(memcached_st *memc)
 {
   memcached_return ret;
   ret= memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_NOREPLY, 1);
@@ -3467,7 +3628,7 @@ static test_return noreply_test(memcached_st *memc)
   return TEST_SUCCESS;
 }
 
-static test_return analyzer_test(memcached_st *memc)
+static test_return_t analyzer_test(memcached_st *memc)
 {
   memcached_return rc;
   memcached_stat_st *memc_stat;
@@ -3477,7 +3638,7 @@ static test_return analyzer_test(memcached_st *memc)
   assert(rc == MEMCACHED_SUCCESS);
   assert(memc_stat);
 
-  report= memcached_analyze(memc, memc_stat, &rc);  
+  report= memcached_analyze(memc, memc_stat, &rc);
   assert(rc == MEMCACHED_SUCCESS);
   assert(report);
 
@@ -3488,9 +3649,9 @@ static test_return analyzer_test(memcached_st *memc)
 }
 
 /* Count the objects */
-static memcached_return callback_dump_counter(memcached_st *ptr __attribute__((unused)),  
-                                              const char *key __attribute__((unused)), 
-                                              size_t key_length __attribute__((unused)), 
+static memcached_return callback_dump_counter(memcached_st *ptr __attribute__((unused)),
+                                              const char *key __attribute__((unused)),
+                                              size_t key_length __attribute__((unused)),
                                               void *context)
 {
   uint32_t *counter= (uint32_t *)context;
@@ -3500,12 +3661,12 @@ static memcached_return callback_dump_counter(memcached_st *ptr __attribute__((u
   return MEMCACHED_SUCCESS;
 }
 
-static test_return dump_test(memcached_st *memc)
+static test_return_t dump_test(memcached_st *memc)
 {
   memcached_return rc;
   uint32_t counter= 0;
   memcached_dump_func callbacks[1];
-  test_return main_rc;
+  test_return_t main_rc;
 
   callbacks[0]= &callback_dump_counter;
 
@@ -3538,7 +3699,7 @@ static void* connection_release(void *arg) {
   return arg;
 }
 
-static test_return connection_pool_test(memcached_st *memc)
+static test_return_t connection_pool_test(memcached_st *memc)
 {
   memcached_pool_st* pool= memcached_pool_create(memc, 5, 10);
   assert(pool != NULL);
@@ -3582,12 +3743,35 @@ static test_return connection_pool_test(memcached_st *memc)
   for (int x= 0; x < 10; ++x)
     assert(memcached_pool_push(pool, mmc[x]) == MEMCACHED_SUCCESS);
 
+
+  /* verify that I can set behaviors on the pool when I don't have all
+   * of the connections in the pool. It should however be enabled
+   * when I push the item into the pool
+   */
+  mmc[0]= memcached_pool_pop(pool, false, &rc);
+  assert(mmc[0] != NULL);
+
+  rc= memcached_pool_behavior_set(pool, MEMCACHED_BEHAVIOR_IO_MSG_WATERMARK, 9999);
+  assert(rc == MEMCACHED_SUCCESS);
+
+  mmc[1]= memcached_pool_pop(pool, false, &rc);
+  assert(mmc[1] != NULL);
+
+  assert(memcached_behavior_get(mmc[1], MEMCACHED_BEHAVIOR_IO_MSG_WATERMARK) == 9999);
+  assert(memcached_pool_push(pool, mmc[1]) == MEMCACHED_SUCCESS);
+  assert(memcached_pool_push(pool, mmc[0]) == MEMCACHED_SUCCESS);
+
+  mmc[0]= memcached_pool_pop(pool, false, &rc);
+  assert(memcached_behavior_get(mmc[0], MEMCACHED_BEHAVIOR_IO_MSG_WATERMARK) == 9999);
+  assert(memcached_pool_push(pool, mmc[0]) == MEMCACHED_SUCCESS);
+
+
   assert(memcached_pool_destroy(pool) == memc);
   return TEST_SUCCESS;
 }
 #endif
 
-static test_return replication_set_test(memcached_st *memc)
+static test_return_t replication_set_test(memcached_st *memc)
 {
   memcached_return rc;
   memcached_st *memc_clone= memcached_clone(NULL, memc);
@@ -3608,7 +3792,7 @@ static test_return replication_set_test(memcached_st *memc)
   ** to the server and wait for the response ;-) If you use the test code
   ** as an example for your own code, please note that you shouldn't need
   ** to do this ;-)
-  */ 
+  */
   memcached_quit(memc);
 
   /*
@@ -3622,7 +3806,7 @@ static test_return replication_set_test(memcached_st *memc)
     char key[2]= { [0]= (char)x };
     size_t len;
     uint32_t flags;
-    char *val= memcached_get_by_key(memc_clone, key, 1, "bubba", 5, 
+    char *val= memcached_get_by_key(memc_clone, key, 1, "bubba", 5,
                                     &len, &flags, &rc);
     assert(rc == MEMCACHED_SUCCESS);
     assert(val != NULL);
@@ -3634,7 +3818,7 @@ static test_return replication_set_test(memcached_st *memc)
   return TEST_SUCCESS;
 }
 
-static test_return replication_get_test(memcached_st *memc)
+static test_return_t replication_get_test(memcached_st *memc)
 {
   memcached_return rc;
 
@@ -3643,7 +3827,7 @@ static test_return replication_get_test(memcached_st *memc)
    * within the library, and this is not a supported interface.
    * This is to verify correct behavior in the library
    */
-  for (uint32_t host= 0; host < memc->number_of_hosts; ++host) 
+  for (uint32_t host= 0; host < memc->number_of_hosts; ++host)
   {
     memcached_st *memc_clone= memcached_clone(NULL, memc);
     memc_clone->hosts[host].port= 0;
@@ -3653,7 +3837,7 @@ static test_return replication_get_test(memcached_st *memc)
       char key[2]= { [0]= (char)x };
       size_t len;
       uint32_t flags;
-      char *val= memcached_get_by_key(memc_clone, key, 1, "bubba", 5, 
+      char *val= memcached_get_by_key(memc_clone, key, 1, "bubba", 5,
                                       &len, &flags, &rc);
       assert(rc == MEMCACHED_SUCCESS);
       assert(val != NULL);
@@ -3666,7 +3850,7 @@ static test_return replication_get_test(memcached_st *memc)
   return TEST_SUCCESS;
 }
 
-static test_return replication_mget_test(memcached_st *memc)
+static test_return_t replication_mget_test(memcached_st *memc)
 {
   memcached_return rc;
   memcached_st *memc_clone= memcached_clone(NULL, memc);
@@ -3693,7 +3877,7 @@ static test_return replication_mget_test(memcached_st *memc)
   ** to the server and wait for the response ;-) If you use the test code
   ** as an example for your own code, please note that you shouldn't need
   ** to do this ;-)
-  */ 
+  */
   memcached_quit(memc);
 
   /*
@@ -3702,7 +3886,7 @@ static test_return replication_mget_test(memcached_st *memc)
    * This is to verify correct behavior in the library
    */
   memcached_result_st result_obj;
-  for (uint32_t host= 0; host < memc_clone->number_of_hosts; host++) 
+  for (uint32_t host= 0; host < memc_clone->number_of_hosts; host++)
   {
     memcached_st *new_clone= memcached_clone(NULL, memc);
     new_clone->hosts[host].port= 0;
@@ -3729,10 +3913,12 @@ static test_return replication_mget_test(memcached_st *memc)
     memcached_free(new_clone);
   }
 
+  memcached_free(memc_clone);
+
   return TEST_SUCCESS;
 }
 
-static test_return replication_delete_test(memcached_st *memc)
+static test_return_t replication_delete_test(memcached_st *memc)
 {
   memcached_return rc;
   memcached_st *memc_clone= memcached_clone(NULL, memc);
@@ -3756,7 +3942,7 @@ static test_return replication_delete_test(memcached_st *memc)
    * This is to verify correct behavior in the library
    */
   uint32_t hash= memcached_generate_hash(memc, keys[0], len[0]);
-  for (uint32_t x= 0; x < (repl + 1); ++x) 
+  for (uint32_t x= 0; x < (repl + 1); ++x)
   {
     memc_clone->hosts[hash].port= 0;
     if (++hash == memc_clone->number_of_hosts)
@@ -3764,7 +3950,7 @@ static test_return replication_delete_test(memcached_st *memc)
   }
 
   memcached_result_st result_obj;
-  for (uint32_t host= 0; host < memc_clone->number_of_hosts; ++host) 
+  for (uint32_t host= 0; host < memc_clone->number_of_hosts; ++host)
   {
     for (int x= 'a'; x <= 'z'; ++x)
     {
@@ -3809,7 +3995,7 @@ static uint16_t *get_udp_request_ids(memcached_st *memc)
   return ids;
 }
 
-static test_return post_udp_op_check(memcached_st *memc, uint16_t *expected_req_ids)
+static test_return_t post_udp_op_check(memcached_st *memc, uint16_t *expected_req_ids)
 {
   unsigned int x;
   memcached_server_st *cur_server = memc->hosts;
@@ -3863,7 +4049,7 @@ static memcached_return binary_init_udp(memcached_st *memc)
 }
 
 /* Make sure that I cant add a tcp server to a udp client */
-static test_return add_tcp_server_udp_client_test(memcached_st *memc)
+static test_return_t add_tcp_server_udp_client_test(memcached_st *memc)
 {
   memcached_server_st server;
   memcached_server_clone(&server, &memc->hosts[0]);
@@ -3873,7 +4059,7 @@ static test_return add_tcp_server_udp_client_test(memcached_st *memc)
 }
 
 /* Make sure that I cant add a udp server to a tcp client */
-static test_return add_udp_server_tcp_client_test(memcached_st *memc)
+static test_return_t add_udp_server_tcp_client_test(memcached_st *memc)
 {
   memcached_server_st server;
   memcached_server_clone(&server, &memc->hosts[0]);
@@ -3885,7 +4071,7 @@ static test_return add_udp_server_tcp_client_test(memcached_st *memc)
   return TEST_SUCCESS;
 }
 
-static test_return set_udp_behavior_test(memcached_st *memc)
+static test_return_t set_udp_behavior_test(memcached_st *memc)
 {
 
   memcached_quit(memc);
@@ -3894,7 +4080,7 @@ static test_return set_udp_behavior_test(memcached_st *memc)
   assert(memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_USE_UDP, 1) == MEMCACHED_SUCCESS);
   assert(memc->flags & MEM_USE_UDP);
   assert(memc->flags & MEM_NOREPLY);;
-  
+
   assert(memc->number_of_hosts == 0);
 
   memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_USE_UDP,0);
@@ -3904,7 +4090,7 @@ static test_return set_udp_behavior_test(memcached_st *memc)
   return TEST_SUCCESS;
 }
 
-static test_return udp_set_test(memcached_st *memc)
+static test_return_t udp_set_test(memcached_st *memc)
 {
   unsigned int x= 0;
   unsigned int num_iters= 1025; //request id rolls over at 1024
@@ -3927,11 +4113,11 @@ static test_return udp_set_test(memcached_st *memc)
     if (rc == MEMCACHED_SUCCESS ||
             memc->hosts[server_key].write_buffer_offset < init_offset)
       increment_request_id(&expected_ids[server_key]);
-    
+
     if (rc == MEMCACHED_SUCCESS)
     {
       assert(memc->hosts[server_key].write_buffer_offset == UDP_DATAGRAM_HEADER_LENGTH);
-    } 
+    }
     else
     {
       assert(memc->hosts[server_key].write_buffer_offset != UDP_DATAGRAM_HEADER_LENGTH);
@@ -3942,13 +4128,13 @@ static test_return udp_set_test(memcached_st *memc)
   return TEST_SUCCESS;
 }
 
-static test_return udp_buffered_set_test(memcached_st *memc)
+static test_return_t udp_buffered_set_test(memcached_st *memc)
 {
   memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_BUFFER_REQUESTS, 1);
   return udp_set_test(memc);
 }
 
-static test_return udp_set_too_big_test(memcached_st *memc)
+static test_return_t udp_set_too_big_test(memcached_st *memc)
 {
   memcached_return rc;
   const char *key= "bar";
@@ -3961,7 +4147,7 @@ static test_return udp_set_too_big_test(memcached_st *memc)
   return post_udp_op_check(memc,expected_ids);
 }
 
-static test_return udp_delete_test(memcached_st *memc)
+static test_return_t udp_delete_test(memcached_st *memc)
 {
   unsigned int x= 0;
   unsigned int num_iters= 1025; //request id rolls over at 1024
@@ -3988,13 +4174,13 @@ static test_return udp_delete_test(memcached_st *memc)
   return TEST_SUCCESS;
 }
 
-static test_return udp_buffered_delete_test(memcached_st *memc)
+static test_return_t udp_buffered_delete_test(memcached_st *memc)
 {
   memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_BUFFER_REQUESTS, 1);
   return udp_delete_test(memc);
 }
 
-static test_return udp_verbosity_test(memcached_st *memc)
+static test_return_t udp_verbosity_test(memcached_st *memc)
 {
   memcached_return rc;
   uint16_t *expected_ids= get_udp_request_ids(memc);
@@ -4007,19 +4193,19 @@ static test_return udp_verbosity_test(memcached_st *memc)
   return post_udp_op_check(memc,expected_ids);
 }
 
-static test_return udp_quit_test(memcached_st *memc)
+static test_return_t udp_quit_test(memcached_st *memc)
 {
   uint16_t *expected_ids= get_udp_request_ids(memc);
   memcached_quit(memc);
   return post_udp_op_check(memc, expected_ids);
 }
 
-static test_return udp_flush_test(memcached_st *memc)
+static test_return_t udp_flush_test(memcached_st *memc)
 {
   memcached_return rc;
   uint16_t *expected_ids= get_udp_request_ids(memc);
   unsigned int x;
-  for (x= 0; x < memc->number_of_hosts;x++) 
+  for (x= 0; x < memc->number_of_hosts;x++)
     increment_request_id(&expected_ids[x]);
 
   rc= memcached_flush(memc,0);
@@ -4027,15 +4213,15 @@ static test_return udp_flush_test(memcached_st *memc)
   return post_udp_op_check(memc,expected_ids);
 }
 
-static test_return udp_incr_test(memcached_st *memc)
+static test_return_t udp_incr_test(memcached_st *memc)
 {
   memcached_return rc;
   const char *key= "incr";
   const char *value= "1";
-  rc= memcached_set(memc, key, strlen(key), 
+  rc= memcached_set(memc, key, strlen(key),
                     value, strlen(value),
                     (time_t)0, (uint32_t)0);
-  
+
   assert(rc == MEMCACHED_SUCCESS);
   uint16_t *expected_ids= get_udp_request_ids(memc);
   unsigned int server_key= memcached_generate_hash(memc, key, strlen(key));
@@ -4046,15 +4232,15 @@ static test_return udp_incr_test(memcached_st *memc)
   return post_udp_op_check(memc, expected_ids);
 }
 
-static test_return udp_decr_test(memcached_st *memc)
+static test_return_t udp_decr_test(memcached_st *memc)
 {
   memcached_return rc;
   const char *key= "decr";
   const char *value= "1";
-  rc= memcached_set(memc, key, strlen(key), 
+  rc= memcached_set(memc, key, strlen(key),
                     value, strlen(value),
                     (time_t)0, (uint32_t)0);
-  
+
   assert(rc == MEMCACHED_SUCCESS);
   uint16_t *expected_ids= get_udp_request_ids(memc);
   unsigned int server_key= memcached_generate_hash(memc, key, strlen(key));
@@ -4066,7 +4252,7 @@ static test_return udp_decr_test(memcached_st *memc)
 }
 
 
-static test_return udp_stat_test(memcached_st *memc)
+static test_return_t udp_stat_test(memcached_st *memc)
 {
   memcached_stat_st * rv= NULL;
   memcached_return rc;
@@ -4078,7 +4264,7 @@ static test_return udp_stat_test(memcached_st *memc)
   return post_udp_op_check(memc, expected_ids);
 }
 
-static test_return udp_version_test(memcached_st *memc)
+static test_return_t udp_version_test(memcached_st *memc)
 {
   memcached_return rc;
   uint16_t *expected_ids = get_udp_request_ids(memc);
@@ -4087,7 +4273,7 @@ static test_return udp_version_test(memcached_st *memc)
   return post_udp_op_check(memc, expected_ids);
 }
 
-static test_return udp_get_test(memcached_st *memc)
+static test_return_t udp_get_test(memcached_st *memc)
 {
   memcached_return rc;
   const char *key= "foo";
@@ -4099,7 +4285,7 @@ static test_return udp_get_test(memcached_st *memc)
   return post_udp_op_check(memc, expected_ids);
 }
 
-static test_return udp_mixed_io_test(memcached_st *memc)
+static test_return_t udp_mixed_io_test(memcached_st *memc)
 {
   test_st current_op;
   test_st mixed_io_ops [] ={
@@ -4122,7 +4308,7 @@ static test_return udp_mixed_io_test(memcached_st *memc)
   return TEST_SUCCESS;
 }
 
-static test_return hsieh_avaibility_test (memcached_st *memc)
+static test_return_t hsieh_avaibility_test (memcached_st *memc)
 {
   memcached_return expected_rc= MEMCACHED_FAILURE;
 #ifdef HAVE_HSIEH_HASH
@@ -4164,22 +4350,22 @@ static const char *list[]=
   NULL
 };
 
-static test_return md5_run (memcached_st *memc __attribute__((unused)))
+static test_return_t md5_run (memcached_st *memc __attribute__((unused)))
 {
   uint32_t x;
   const char **ptr;
   uint32_t values[]= {  3195025439U, 2556848621U, 3724893440U, 3332385401U,
                         245758794U, 2550894432U, 121710495U, 3053817768U,
-                        1250994555U, 1862072655U, 2631955953U, 2951528551U, 
+                        1250994555U, 1862072655U, 2631955953U, 2951528551U,
                         1451250070U, 2820856945U, 2060845566U, 3646985608U,
                         2138080750U, 217675895U, 2230934345U, 1234361223U,
-                        3968582726U, 2455685270U, 1293568479U, 199067604U, 
+                        3968582726U, 2455685270U, 1293568479U, 199067604U,
                         2042482093U };
 
 
   for (ptr= list, x= 0; *ptr; ptr++, x++)
   {
-    uint32_t hash_val; 
+    uint32_t hash_val;
 
     hash_val= memcached_generate_hash_value(*ptr, strlen(*ptr), MEMCACHED_HASH_MD5);
     assert(values[x] == hash_val);
@@ -4188,18 +4374,18 @@ static test_return md5_run (memcached_st *memc __attribute__((unused)))
   return TEST_SUCCESS;
 }
 
-static test_return crc_run (memcached_st *memc __attribute__((unused)))
+static test_return_t crc_run (memcached_st *memc __attribute__((unused)))
 {
   uint32_t x;
   const char **ptr;
   uint32_t values[]= {  10542U, 22009U, 14526U, 19510U, 19432U, 10199U, 20634U,
                         9369U, 11511U, 10362U, 7893U, 31289U, 11313U, 9354U,
-                        7621U, 30628U, 15218U, 25967U, 2695U, 9380U, 
+                        7621U, 30628U, 15218U, 25967U, 2695U, 9380U,
                         17300U, 28156U, 9192U, 20484U, 16925U };
 
   for (ptr= list, x= 0; *ptr; ptr++, x++)
   {
-    uint32_t hash_val; 
+    uint32_t hash_val;
 
     hash_val= memcached_generate_hash_value(*ptr, strlen(*ptr), MEMCACHED_HASH_CRC);
     assert(values[x] == hash_val);
@@ -4208,21 +4394,21 @@ static test_return crc_run (memcached_st *memc __attribute__((unused)))
   return TEST_SUCCESS;
 }
 
-static test_return fnv1_64_run (memcached_st *memc __attribute__((unused)))
+static test_return_t fnv1_64_run (memcached_st *memc __attribute__((unused)))
 {
   uint32_t x;
   const char **ptr;
-  uint32_t values[]= {  473199127U, 4148981457U, 3971873300U, 3257986707U, 
-                        1722477987U, 2991193800U, 4147007314U, 3633179701U, 
+  uint32_t values[]= {  473199127U, 4148981457U, 3971873300U, 3257986707U,
+                        1722477987U, 2991193800U, 4147007314U, 3633179701U,
                         1805162104U, 3503289120U, 3395702895U, 3325073042U,
                         2345265314U, 3340346032U, 2722964135U, 1173398992U,
-                        2815549194U, 2562818319U, 224996066U, 2680194749U, 
+                        2815549194U, 2562818319U, 224996066U, 2680194749U,
                         3035305390U, 246890365U, 2395624193U, 4145193337U,
                         1801941682U };
 
   for (ptr= list, x= 0; *ptr; ptr++, x++)
   {
-    uint32_t hash_val; 
+    uint32_t hash_val;
 
     hash_val= memcached_generate_hash_value(*ptr, strlen(*ptr), MEMCACHED_HASH_FNV1_64);
     assert(values[x] == hash_val);
@@ -4231,21 +4417,21 @@ static test_return fnv1_64_run (memcached_st *memc __attribute__((unused)))
   return TEST_SUCCESS;
 }
 
-static test_return fnv1a_64_run (memcached_st *memc __attribute__((unused)))
+static test_return_t fnv1a_64_run (memcached_st *memc __attribute__((unused)))
 {
   uint32_t x;
   const char **ptr;
-  uint32_t values[]= {  1488911807U, 2500855813U, 1510099634U, 1390325195U, 
-                        3647689787U, 3241528582U, 1669328060U, 2604311949U, 
+  uint32_t values[]= {  1488911807U, 2500855813U, 1510099634U, 1390325195U,
+                        3647689787U, 3241528582U, 1669328060U, 2604311949U,
                         734810122U, 1516407546U, 560948863U, 1767346780U,
                         561034892U, 4156330026U, 3716417003U, 3475297030U,
-                        1518272172U, 227211583U, 3938128828U, 126112909U, 
+                        1518272172U, 227211583U, 3938128828U, 126112909U,
                         3043416448U, 3131561933U, 1328739897U, 2455664041U,
-                        2272238452U }; 
+                        2272238452U };
 
   for (ptr= list, x= 0; *ptr; ptr++, x++)
   {
-    uint32_t hash_val; 
+    uint32_t hash_val;
 
     hash_val= memcached_generate_hash_value(*ptr, strlen(*ptr), MEMCACHED_HASH_FNV1A_64);
     assert(values[x] == hash_val);
@@ -4254,13 +4440,13 @@ static test_return fnv1a_64_run (memcached_st *memc __attribute__((unused)))
   return TEST_SUCCESS;
 }
 
-static test_return fnv1_32_run (memcached_st *memc __attribute__((unused)))
+static test_return_t fnv1_32_run (memcached_st *memc __attribute__((unused)))
 {
   uint32_t x;
   const char **ptr;
-  uint32_t values[]= {  67176023U, 1190179409U, 2043204404U, 3221866419U, 
+  uint32_t values[]= {  67176023U, 1190179409U, 2043204404U, 3221866419U,
                         2567703427U, 3787535528U, 4147287986U, 3500475733U,
-                        344481048U, 3865235296U, 2181839183U, 119581266U, 
+                        344481048U, 3865235296U, 2181839183U, 119581266U,
                         510234242U, 4248244304U, 1362796839U, 103389328U,
                         1449620010U, 182962511U, 3554262370U, 3206747549U,
                         1551306158U, 4127558461U, 1889140833U, 2774173721U,
@@ -4269,7 +4455,7 @@ static test_return fnv1_32_run (memcached_st *memc __attribute__((unused)))
 
   for (ptr= list, x= 0; *ptr; ptr++, x++)
   {
-    uint32_t hash_val; 
+    uint32_t hash_val;
 
     hash_val= memcached_generate_hash_value(*ptr, strlen(*ptr), MEMCACHED_HASH_FNV1_32);
     assert(values[x] == hash_val);
@@ -4278,7 +4464,7 @@ static test_return fnv1_32_run (memcached_st *memc __attribute__((unused)))
   return TEST_SUCCESS;
 }
 
-static test_return fnv1a_32_run (memcached_st *memc __attribute__((unused)))
+static test_return_t fnv1a_32_run (memcached_st *memc __attribute__((unused)))
 {
   uint32_t x;
   const char **ptr;
@@ -4292,7 +4478,7 @@ static test_return fnv1a_32_run (memcached_st *memc __attribute__((unused)))
 
   for (ptr= list, x= 0; *ptr; ptr++, x++)
   {
-    uint32_t hash_val; 
+    uint32_t hash_val;
 
     hash_val= memcached_generate_hash_value(*ptr, strlen(*ptr), MEMCACHED_HASH_FNV1A_32);
     assert(values[x] == hash_val);
@@ -4301,7 +4487,7 @@ static test_return fnv1a_32_run (memcached_st *memc __attribute__((unused)))
   return TEST_SUCCESS;
 }
 
-static test_return hsieh_run (memcached_st *memc __attribute__((unused)))
+static test_return_t hsieh_run (memcached_st *memc __attribute__((unused)))
 {
   uint32_t x;
   const char **ptr;
@@ -4317,7 +4503,7 @@ static test_return hsieh_run (memcached_st *memc __attribute__((unused)))
 
   for (ptr= list, x= 0; *ptr; ptr++, x++)
   {
-    uint32_t hash_val; 
+    uint32_t hash_val;
 
     hash_val= memcached_generate_hash_value(*ptr, strlen(*ptr), MEMCACHED_HASH_HSIEH);
     assert(values[x] == hash_val);
@@ -4326,7 +4512,7 @@ static test_return hsieh_run (memcached_st *memc __attribute__((unused)))
   return TEST_SUCCESS;
 }
 
-static test_return murmur_run (memcached_st *memc __attribute__((unused)))
+static test_return_t murmur_run (memcached_st *memc __attribute__((unused)))
 {
   uint32_t x;
   const char **ptr;
@@ -4340,7 +4526,7 @@ static test_return murmur_run (memcached_st *memc __attribute__((unused)))
 
   for (ptr= list, x= 0; *ptr; ptr++, x++)
   {
-    uint32_t hash_val; 
+    uint32_t hash_val;
 
     hash_val= memcached_generate_hash_value(*ptr, strlen(*ptr), MEMCACHED_HASH_FNV1_64);
     assert(values[x] == hash_val);
@@ -4349,7 +4535,7 @@ static test_return murmur_run (memcached_st *memc __attribute__((unused)))
   return TEST_SUCCESS;
 }
 
-static test_return jenkins_run (memcached_st *memc __attribute__((unused)))
+static test_return_t jenkins_run (memcached_st *memc __attribute__((unused)))
 {
   uint32_t x;
   const char **ptr;
@@ -4364,7 +4550,7 @@ static test_return jenkins_run (memcached_st *memc __attribute__((unused)))
 
   for (ptr= list, x= 0; *ptr; ptr++, x++)
   {
-    uint32_t hash_val; 
+    uint32_t hash_val;
 
     hash_val= memcached_generate_hash_value(*ptr, strlen(*ptr), MEMCACHED_HASH_JENKINS);
     assert(values[x] == hash_val);
@@ -4373,6 +4559,233 @@ static test_return jenkins_run (memcached_st *memc __attribute__((unused)))
   return TEST_SUCCESS;
 }
 
+static test_return_t regression_bug_434484(memcached_st *memc)
+{
+  if (pre_binary(memc) != MEMCACHED_SUCCESS)
+    return TEST_SKIPPED;
+
+  memcached_return ret;
+  const char *key= "regression_bug_434484";
+  size_t keylen= strlen(key);
+
+  ret= memcached_append(memc, key, keylen, key, keylen, 0, 0);
+  assert(ret == MEMCACHED_NOTSTORED);
+
+  size_t size= 2048 * 1024;
+  void *data= calloc(1, size);
+  assert(data != NULL);
+  ret= memcached_set(memc, key, keylen, data, size, 0, 0);
+  assert(ret == MEMCACHED_E2BIG);
+  free(data);
+
+  return TEST_SUCCESS;
+}
+
+static test_return_t regression_bug_434843(memcached_st *memc)
+{
+  if (pre_binary(memc) != MEMCACHED_SUCCESS)
+    return TEST_SKIPPED;
+
+  memcached_return rc;
+  unsigned int counter= 0;
+  memcached_execute_function callbacks[1]= { [0]= &callback_counter };
+
+  /*
+   * I only want to hit only _one_ server so I know the number of requests I'm
+   * sending in the pipleine to the server. Let's try to do a multiget of
+   * 1024 (that should satisfy most users don't you think?). Future versions
+   * will include a mget_execute function call if you need a higher number.
+   */
+  uint32_t number_of_hosts= memc->number_of_hosts;
+  memc->number_of_hosts= 1;
+  const size_t max_keys= 1024;
+  char **keys= calloc(max_keys, sizeof(char*));
+  size_t *key_length=calloc(max_keys, sizeof(size_t));
+
+  for (int x= 0; x < (int)max_keys; ++x)
+  {
+     char k[251];
+     key_length[x]= (size_t)snprintf(k, sizeof(k), "0200%u", x);
+     keys[x]= strdup(k);
+     assert(keys[x] != NULL);
+  }
+
+  /*
+   * Run two times.. the first time we should have 100% cache miss,
+   * and the second time we should have 100% cache hits
+   */
+  for (int y= 0; y < 2; ++y)
+  {
+    rc= memcached_mget(memc, (const char**)keys, key_length, max_keys);
+    assert(rc == MEMCACHED_SUCCESS);
+    rc= memcached_fetch_execute(memc, callbacks, (void *)&counter, 1);
+    if (y == 0)
+    {
+      /* The first iteration should give me a 100% cache miss. verify that*/
+      assert(counter == 0);
+      char blob[1024]= { 0 };
+      for (int x= 0; x < (int)max_keys; ++x)
+      {
+        rc= memcached_add(memc, keys[x], key_length[x],
+                          blob, sizeof(blob), 0, 0);
+        assert(rc == MEMCACHED_SUCCESS || rc == MEMCACHED_BUFFERED);
+      }
+    }
+    else
+    {
+      /* Verify that we received all of the key/value pairs */
+       assert(counter == (unsigned int)max_keys);
+    }
+  }
+
+  /* Release allocated resources */
+  for (size_t x= 0; x < max_keys; ++x)
+    free(keys[x]);
+  free(keys);
+  free(key_length);
+
+  memc->number_of_hosts= number_of_hosts;
+  return TEST_SUCCESS;
+}
+
+static test_return_t regression_bug_434843_buffered(memcached_st *memc)
+{
+  memcached_return rc;
+  rc= memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_BUFFER_REQUESTS, 1);
+  assert(rc == MEMCACHED_SUCCESS);
+
+  return regression_bug_434843(memc);
+}
+
+static test_return_t regression_bug_421108(memcached_st *memc)
+{
+  memcached_return rc;
+  memcached_stat_st *memc_stat= memcached_stat(memc, NULL, &rc);
+  assert(rc == MEMCACHED_SUCCESS);
+
+  char *bytes= memcached_stat_get_value(memc, memc_stat, "bytes", &rc);
+  assert(rc == MEMCACHED_SUCCESS);
+  assert(bytes != NULL);
+  char *bytes_read= memcached_stat_get_value(memc, memc_stat,
+                                             "bytes_read", &rc);
+  assert(rc == MEMCACHED_SUCCESS);
+  assert(bytes_read != NULL);
+
+  char *bytes_written= memcached_stat_get_value(memc, memc_stat,
+                                                "bytes_written", &rc);
+  assert(rc == MEMCACHED_SUCCESS);
+  assert(bytes_written != NULL);
+
+  assert(strcmp(bytes, bytes_read) != 0);
+  assert(strcmp(bytes, bytes_written) != 0);
+
+  /* Release allocated resources */
+  free(bytes);
+  free(bytes_read);
+  free(bytes_written);
+  memcached_stat_free(NULL, memc_stat);
+  return TEST_SUCCESS;
+}
+
+/*
+ * The test case isn't obvious so I should probably document why
+ * it works the way it does. Bug 442914 was caused by a bug
+ * in the logic in memcached_purge (it did not handle the case
+ * where the number of bytes sent was equal to the watermark).
+ * In this test case, create messages so that we hit that case
+ * and then disable noreply mode and issue a new command to
+ * verify that it isn't stuck. If we change the format for the
+ * delete command or the watermarks, we need to update this
+ * test....
+ */
+static test_return_t regression_bug_442914(memcached_st *memc)
+{
+  memcached_return rc;
+  rc= memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_NOREPLY, 1);
+  assert(rc == MEMCACHED_SUCCESS);
+  memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_TCP_NODELAY, 1);
+
+  uint32_t number_of_hosts= memc->number_of_hosts;
+  memc->number_of_hosts= 1;
+
+  char k[250];
+  size_t len;
+
+  for (int x= 0; x < 250; ++x)
+  {
+     len= (size_t)snprintf(k, sizeof(k), "%0250u", x);
+     rc= memcached_delete(memc, k, len, 0);
+     assert(rc == MEMCACHED_SUCCESS || rc == MEMCACHED_BUFFERED);
+  }
+
+  len= (size_t)snprintf(k, sizeof(k), "%037u", 251);
+  rc= memcached_delete(memc, k, len, 0);
+  assert(rc == MEMCACHED_SUCCESS || rc == MEMCACHED_BUFFERED);
+
+  rc= memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_NOREPLY, 0);
+  assert(rc == MEMCACHED_SUCCESS);
+  rc= memcached_delete(memc, k, len, 0);
+  assert(rc == MEMCACHED_NOTFOUND);
+
+  memc->number_of_hosts= number_of_hosts;
+
+  return TEST_SUCCESS;
+}
+
+
+
+/* Test memcached_server_get_last_disconnect
+ * For a working server set, shall be NULL
+ * For a set of non existing server, shall not be NULL
+ */
+static test_return_t  test_get_last_disconnect(memcached_st *memc)
+{
+  memcached_return rc;
+  memcached_server_st *disconnected_server;
+
+  /* With the working set of server */
+  const char *key= "marmotte";
+  const char *value= "milka";
+
+  rc= memcached_set(memc, key, strlen(key),
+                    value, strlen(value),
+                    (time_t)0, (uint32_t)0);
+  assert(rc == MEMCACHED_SUCCESS || rc == MEMCACHED_BUFFERED);
+
+  disconnected_server = memcached_server_get_last_disconnect(memc);
+  assert(disconnected_server == NULL);
+
+  /* With a non existing server */
+  memcached_st *mine;
+  memcached_server_st *servers;
+
+  const char *server_list= "localhost:9";
+
+  servers= memcached_servers_parse(server_list);
+  assert(servers);
+  mine= memcached_create(NULL);
+  rc= memcached_server_push(mine, servers);
+  assert(rc == MEMCACHED_SUCCESS);
+  memcached_server_list_free(servers);
+  assert(mine);
+
+  rc= memcached_set(mine, key, strlen(key),
+                    value, strlen(value),
+                    (time_t)0, (uint32_t)0);
+  assert(rc != MEMCACHED_SUCCESS);
+
+  disconnected_server = memcached_server_get_last_disconnect(mine);
+  assert(disconnected_server != NULL);
+  assert(disconnected_server->port == 9);
+  assert(strncmp(disconnected_server->hostname,"localhost",9) == 0);
+
+  memcached_quit(mine);
+  memcached_free(mine);
+
+  return TEST_SUCCESS;
+}
+
+
 test_st udp_setup_server_tests[] ={
   {"set_udp_behavior_test", 0, set_udp_behavior_test},
   {"add_tcp_server_udp_client_test", 0, add_tcp_server_udp_client_test},
@@ -4435,6 +4848,7 @@ test_st tests[] ={
   {"mget_result", 1, mget_result_test },
   {"mget_result_alloc", 1, mget_result_alloc_test },
   {"mget_result_function", 1, mget_result_function },
+  {"mget_end", 0, mget_end },
   {"get_stats", 0, get_stats },
   {"add_host_test", 0, add_host_test },
   {"add_host_test_1", 0, add_host_test1 },
@@ -4451,6 +4865,7 @@ test_st tests[] ={
 #ifdef HAVE_LIBMEMCACHEDUTIL
   {"connectionpool", 1, connection_pool_test },
 #endif
+  {"test_get_last_disconnect", 1, test_get_last_disconnect},
   {0, 0, 0}
 };
 
@@ -4502,8 +4917,8 @@ test_st user_tests[] ={
   {"user_supplied_bug15", 1, user_supplied_bug15 },
   {"user_supplied_bug16", 1, user_supplied_bug16 },
 #ifndef __sun
-  /* 
-  ** It seems to be something weird with the character sets.. 
+  /*
+  ** It seems to be something weird with the character sets..
   ** value_fetch is unable to parse the value line (iscntrl "fails"), so I
   ** guess I need to find out how this is supposed to work.. Perhaps I need
   ** to run the test in a specific locale (I tried zh_CN.UTF-8 without success,
@@ -4514,6 +4929,7 @@ test_st user_tests[] ={
   {"user_supplied_bug18", 1, user_supplied_bug18 },
   {"user_supplied_bug19", 1, user_supplied_bug19 },
   {"user_supplied_bug20", 1, user_supplied_bug20 },
+  {"user_supplied_bug21", 1, user_supplied_bug21 },
   {0, 0, 0}
 };
 
@@ -4525,6 +4941,21 @@ test_st replication_tests[]= {
   {0, 0, 0}
 };
 
+/*
+ * The following test suite is used to verify that we don't introduce
+ * regression bugs. If you want more information about the bug / test,
+ * you should look in the bug report at
+ *   http://bugs.launchpad.net/libmemcached
+ */
+test_st regression_tests[]= {
+  {"lp:434484", 1, regression_bug_434484 },
+  {"lp:434843", 1, regression_bug_434843 },
+  {"lp:434843 buffered", 1, regression_bug_434843_buffered },
+  {"lp:421108", 1, regression_bug_421108 },
+  {"lp:442914", 1, regression_bug_442914 },
+  {0, 0, 0}
+};
+
 test_st generate_tests[] ={
   {"generate_pairs", 1, generate_pairs },
   {"generate_data", 1, generate_data },
@@ -4633,6 +5064,7 @@ collection_st collection[] ={
   {"test_hashes", 0, 0, hash_tests},
   {"replication", pre_replication, 0, replication_tests},
   {"replication_noblock", pre_replication_noblock, 0, replication_tests},
+  {"regression", 0, 0, regression_tests},
   {0, 0, 0, 0}
 };
 
@@ -4646,8 +5078,7 @@ void *world_create(void)
 {
   server_startup_st *construct;
 
-  construct= (server_startup_st *)malloc(sizeof(server_startup_st));
-  memset(construct, 0, sizeof(server_startup_st));
+  construct= calloc(sizeof(server_startup_st), 1);
   construct->count= SERVERS_TO_CREATE;
   construct->udp= 0;
   server_startup(construct);