X-Git-Url: https://git.m6w6.name/?a=blobdiff_plain;f=tests%2Ffunction.c;h=3c5dd6e88b16fcf6122144dbfd63bcc8ce0a5112;hb=20502c526be080e3ffee3c542eac4d1ada382fd8;hp=5d0c64b986b819413a8dc92728724772ff3a303e;hpb=3408a01e0f51d7eb701786253acb2709c1548443;p=awesomized%2Flibmemcached

diff --git a/tests/function.c b/tests/function.c
index 5d0c64b9..3c5dd6e8 100644
--- a/tests/function.c
+++ b/tests/function.c
@@ -1,6 +1,7 @@
 /*
   Sample test application.
 */
+
 #include "libmemcached/common.h"
 
 #include <assert.h>
@@ -37,7 +38,7 @@
 static uint32_t global_count;
 
 static pairs_st *global_pairs;
-static char *global_keys[GLOBAL_COUNT];
+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)))
@@ -47,7 +48,7 @@ static test_return  init_test(memcached_st *not_used __attribute__((unused)))
   (void)memcached_create(&memc);
   memcached_free(&memc);
 
-  return 0;
+  return TEST_SUCCESS;
 }
 
 static test_return  server_list_null_test(memcached_st *ptr __attribute__((unused)))
@@ -64,7 +65,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
@@ -107,7 +108,7 @@ 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)))
@@ -137,7 +138,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)
@@ -183,7 +184,7 @@ 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)))
@@ -193,7 +194,7 @@ static test_return  allocation_test(memcached_st *not_used __attribute__((unused
   assert(memc);
   memcached_free(memc);
 
-  return 0;
+  return TEST_SUCCESS;
 }
 
 static test_return  clone_test(memcached_st *memc)
@@ -260,7 +261,7 @@ 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)
@@ -269,7 +270,7 @@ static test_return userdata_test(memcached_st *memc)
   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;
 }
 
@@ -280,75 +281,92 @@ static test_return  connection_test(memcached_st *memc)
   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)
 {
   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)
 {
   memcached_return rc;
-  char *key= "foo";
-  char *value= "when we sanitize";
+  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)
 {
   memcached_return rc;
-  char *key= "fig";
-  char *value= "we";
+  const char *key= "fig";
+  const char *in_value= "we";
+  char *out_value= NULL;
   size_t value_length;
   uint32_t flags;
 
   rc= memcached_flush(memc, 0);
   assert(rc == MEMCACHED_SUCCESS);
 
-  rc= memcached_set(memc, key, strlen(key), 
-                    value, strlen(value),
+  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);
 
-  value= memcached_get(memc, key, strlen(key),
+  out_value= memcached_get(memc, key, strlen(key),
                        &value_length, &flags, &rc);
-  assert(!memcmp(value, "we the people", strlen("we the people")));
+  assert(!memcmp(out_value, "we the people", strlen("we the people")));
   assert(strlen("we the people") == value_length);
   assert(rc == MEMCACHED_SUCCESS);
-  free(value);
+  free(out_value);
 
-  return 0;
+  return TEST_SUCCESS;
 }
 
 static test_return  append_binary_test(memcached_st *memc)
 {
   memcached_return rc;
-  char *key= "numbers";
+  const char *key= "numbers";
   unsigned int *store_ptr;
   unsigned int store_list[] = { 23, 56, 499, 98, 32847, 0 };
   char *value;
@@ -359,16 +377,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);
@@ -388,15 +406,15 @@ static test_return  append_binary_test(memcached_st *memc)
   }
   free(value);
 
-  return 0;
+  return TEST_SUCCESS;
 }
 
 static test_return  cas2_test(memcached_st *memc)
 {
   memcached_return rc;
-  char *keys[]= {"fudge", "son", "food"};
+  const char *keys[]= {"fudge", "son", "food"};
   size_t key_length[]= {5, 3, 4};
-  char *value= "we the people";
+  const char *value= "we the people";
   size_t value_length= strlen("we the people");
   unsigned int x;
   memcached_result_st results_obj;
@@ -410,7 +428,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);
@@ -424,7 +442,7 @@ static test_return  cas2_test(memcached_st *memc)
   assert(results);
   assert(results->cas);
   assert(rc == MEMCACHED_SUCCESS);
-  WATCHPOINT_ASSERT(memcached_result_cas(results));
+  assert(memcached_result_cas(results));
 
   assert(!memcmp(value, "we the people", strlen("we the people")));
   assert(strlen("we the people") == value_length);
@@ -432,7 +450,7 @@ 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)
@@ -441,7 +459,7 @@ static test_return  cas_test(memcached_st *memc)
   const char *key= "fun";
   size_t key_length= strlen(key);
   const char *value= "we the people";
-  char* keys[2] = { (char*)key, NULL };
+  const char* keys[2] = { key, NULL };
   size_t keylengths[2] = { strlen(key), 0 };
   size_t value_length= strlen(value);
   const char *value2= "change the value";
@@ -456,7 +474,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);
@@ -468,7 +486,7 @@ static test_return  cas_test(memcached_st *memc)
   results= memcached_fetch_result(memc, &results_obj, &rc);
   assert(results);
   assert(rc == MEMCACHED_SUCCESS);
-  WATCHPOINT_ASSERT(memcached_result_cas(results));
+  assert(memcached_result_cas(results));
   assert(!memcmp(value, memcached_result_value(results), value_length));
   assert(strlen(memcached_result_value(results)) == value_length);
   assert(rc == MEMCACHED_SUCCESS);
@@ -479,7 +497,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);
 
@@ -492,64 +510,65 @@ 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)
 {
   memcached_return rc;
-  char *key= "fig";
-  char *value= "people";
+  const char *key= "fig";
+  const char *value= "people";
+  char *out_value= NULL;
   size_t value_length;
   uint32_t flags;
 
   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);
 
-  value= memcached_get(memc, key, strlen(key),
+  out_value= memcached_get(memc, key, strlen(key),
                        &value_length, &flags, &rc);
-  assert(!memcmp(value, "we the people", strlen("we the people")));
+  assert(!memcmp(out_value, "we the people", strlen("we the people")));
   assert(strlen("we the people") == value_length);
   assert(rc == MEMCACHED_SUCCESS);
-  free(value);
+  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)
 {
   memcached_return rc;
-  char *key= "foo";
-  char *value= "when we sanitize";
+  const char *key= "foo";
+  const char *value= "when we sanitize";
   unsigned long long setting_value;
 
   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);
 
@@ -559,7 +578,7 @@ static test_return  add_test(memcached_st *memc)
   else
     assert(rc == MEMCACHED_NOTSTORED || rc == MEMCACHED_DATA_EXISTS);
 
-  return 0;
+  return TEST_SUCCESS;
 }
 
 /*
@@ -576,40 +595,43 @@ static test_return  add_wrapper(memcached_st *memc)
 #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)
 {
   memcached_return rc;
-  char *key= "foo";
-  char *value= "when we sanitize";
-  char *original= "first we insert some data";
+  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)
 {
   memcached_return rc;
-  char *key= "foo";
-  char *value= "when we sanitize";
+  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);
@@ -617,7 +639,7 @@ 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)
@@ -627,11 +649,11 @@ static test_return  flush_test(memcached_st *memc)
   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 */
@@ -641,19 +663,19 @@ static memcached_return  server_function(memcached_st *ptr __attribute__((unused
 
 static test_return  memcached_server_cursor_test(memcached_st *memc)
 {
-  char *context= "foo bad";
+  char context[8];
+  strcpy(context, "foo bad");
   memcached_server_function callbacks[1];
 
   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)
 {
   memcached_return rc;
-  char *key= "foo bad";
+  const char *key= "foo bad";
   char *string;
   size_t string_length;
   uint32_t flags;
@@ -668,7 +690,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);
@@ -686,7 +708,7 @@ static test_return  bad_key_test(memcached_st *memc)
     assert(!string);
 
     /* Test multi key for bad keys */
-    char *keys[] = { "GoodKey", "Bad Key", "NotMine" };
+    const char *keys[] = { "GoodKey", "Bad Key", "NotMine" };
     size_t key_lengths[] = { 7, 7, 7 };
     set= 1;
     rc= memcached_behavior_set(memc_clone, MEMCACHED_BEHAVIOR_VERIFY_KEY, set);
@@ -708,7 +730,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,
@@ -739,23 +761,23 @@ 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)
 {
   memcached_return rc;
-  char *key= "foo";
+  const char *key= "foo";
   char *string;
   size_t string_length;
   uint32_t flags;
@@ -788,11 +810,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);
@@ -810,13 +832,13 @@ 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)
 {
   memcached_return rc;
-  char *key= "foo";
+  const char *key= "foo";
   char *string;
   size_t string_length;
   uint32_t flags;
@@ -831,19 +853,19 @@ 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)
 {
   memcached_return rc;
-  char *key= "foo";
-  char *value= "when we sanitize";
+  const char *key= "foo";
+  const char *value= "when we sanitize";
   char *string;
   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);
@@ -858,26 +880,26 @@ static test_return  get_test2(memcached_st *memc)
 
   free(string);
 
-  return 0;
+  return TEST_SUCCESS;
 }
 
 static test_return  set_test2(memcached_st *memc)
 {
   memcached_return rc;
-  char *key= "foo";
-  char *value= "train in the brain";
+  const char *key= "foo";
+  const char *value= "train in the brain";
   size_t value_length= strlen(value);
   unsigned int x;
 
   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)
@@ -900,7 +922,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);
@@ -908,13 +930,13 @@ static test_return  set_test3(memcached_st *memc)
 
   free(value);
 
-  return 0;
+  return TEST_SUCCESS;
 }
 
 static test_return  get_test3(memcached_st *memc)
 {
   memcached_return rc;
-  char *key= "foo";
+  const char *key= "foo";
   char *value;
   size_t value_length= 8191;
   char *string;
@@ -928,7 +950,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);
@@ -944,13 +966,13 @@ 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)
 {
   memcached_return rc;
-  char *key= "foo";
+  const char *key= "foo";
   char *value;
   size_t value_length= 8191;
   char *string;
@@ -964,7 +986,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);
@@ -983,7 +1005,7 @@ static test_return  get_test4(memcached_st *memc)
 
   free(value);
 
-  return 0;
+  return TEST_SUCCESS;
 }
 
 /*
@@ -997,12 +1019,12 @@ static test_return get_test5(memcached_st *memc)
   ** Request the same key twice, to ensure that we hash to the same server
   ** (so that we have multiple response values queued up) ;-)
   */
-  char *keys[]= { "key", "key" };
+  const char *keys[]= { "key", "key" };
   size_t lengths[]= { 3, 3 };
   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);
@@ -1031,26 +1053,90 @@ static test_return get_test5(memcached_st *memc)
   return TEST_SUCCESS;
 }
 
+static test_return  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)
 {
   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)
 {
   uint64_t new_number;
   memcached_return rc;
-  char *key= "number";
-  char *value= "0";
+  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);
@@ -1065,7 +1151,7 @@ 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)
@@ -1074,7 +1160,7 @@ static test_return  increment_with_initial_test(memcached_st *memc)
   {
     uint64_t new_number;
     memcached_return rc;
-    char *key= "number";
+    const char *key= "number";
     uint64_t initial= 0;
 
     rc= memcached_increment_with_initial(memc, key, strlen(key),
@@ -1087,17 +1173,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)
 {
   uint64_t new_number;
   memcached_return rc;
-  char *key= "number";
-  char *value= "3";
+  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);
@@ -1112,7 +1198,7 @@ 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)
@@ -1121,7 +1207,7 @@ static test_return  decrement_with_initial_test(memcached_st *memc)
   {
     uint64_t new_number;
     memcached_return rc;
-    char *key= "number";
+    const char *key= "number";
     uint64_t initial= 3;
 
     rc= memcached_decrement_with_initial(memc, key, strlen(key),
@@ -1134,33 +1220,33 @@ 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)
 {
   memcached_return rc;
-  char *key= "fudge";
-  char *value= "sanford and sun";
+  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)
 {
   memcached_return rc;
-  char *keys[]= {"fudge", "son", "food"};
+  const char *keys[]= {"fudge", "son", "food"};
   size_t key_length[]= {5, 3, 4};
   unsigned int x;
 
@@ -1189,7 +1275,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);
@@ -1204,20 +1290,20 @@ 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)
 {
   memcached_return rc;
-  char *keys[]= {"fudge", "son", "food"};
+  const char *keys[]= {"fudge", "son", "food"};
   size_t key_length[]= {5, 3, 4};
   unsigned int x;
 
@@ -1239,7 +1325,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);
@@ -1254,19 +1340,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 +1365,7 @@ static memcached_return callback_counter(memcached_st *ptr __attribute__((unused
 static test_return  mget_result_function(memcached_st *memc)
 {
   memcached_return rc;
-  char *keys[]= {"fudge", "son", "food"};
+  const char *keys[]= {"fudge", "son", "food"};
   size_t key_length[]= {5, 3, 4};
   unsigned int x;
   unsigned int counter;
@@ -1289,7 +1375,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);
@@ -1300,17 +1386,17 @@ 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)
 {
   memcached_return rc;
-  char *keys[]= {"fudge", "son", "food"};
+  const char *keys[]= {"fudge", "son", "food"};
   size_t key_length[]= {5, 3, 4};
   unsigned int x;
   uint32_t flags;
@@ -1327,7 +1413,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);
@@ -1338,7 +1424,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);
@@ -1348,7 +1434,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);
@@ -1359,7 +1445,7 @@ static test_return  mget_test(memcached_st *memc)
     x++;
   }
 
-  return 0;
+  return TEST_SUCCESS;
 }
 
 static test_return  get_stats_keys(memcached_st *memc)
@@ -1377,7 +1463,7 @@ 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)))
@@ -1388,7 +1474,7 @@ 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)
@@ -1416,7 +1502,7 @@ 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)
@@ -1435,7 +1521,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));
@@ -1448,7 +1534,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)))
@@ -1504,7 +1590,7 @@ 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 */
@@ -1555,7 +1641,7 @@ 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;
 }
 
 /* Test case provided by Cal Haldenbrand */
@@ -1567,7 +1653,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);
@@ -1588,22 +1674,22 @@ 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 */
@@ -1640,15 +1726,14 @@ 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++;
       else
       {
-        WATCHPOINT_ERROR(rc);
-        assert(0);
+        assert(rc);
       }
 
       continue;
@@ -1658,7 +1743,7 @@ 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 */
@@ -1695,7 +1780,7 @@ static test_return  user_supplied_bug3(memcached_st *memc)
     key_lengths[x]= strlen(keys[x]);
   }
 
-  rc= memcached_mget(memc, keys, key_lengths, KEY_COUNT);
+  rc= memcached_mget(memc, (const char **)keys, key_lengths, KEY_COUNT);
   assert(rc == MEMCACHED_SUCCESS);
 
   /* Turn this into a help function */
@@ -1706,7 +1791,7 @@ static test_return  user_supplied_bug3(memcached_st *memc)
     size_t return_value_length;
     uint32_t flags;
 
-    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);
@@ -1719,14 +1804,14 @@ static test_return  user_supplied_bug3(memcached_st *memc)
     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)
 {
   memcached_return rc;
-  char *keys[]= {"fudge", "son", "food"};
+  const char *keys[]= {"fudge", "son", "food"};
   size_t key_length[]= {5, 3, 4};
   unsigned int x;
   uint32_t flags;
@@ -1750,7 +1835,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);
@@ -1761,7 +1846,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);
@@ -1771,7 +1856,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);
@@ -1782,14 +1867,14 @@ 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)
 {
   memcached_return rc;
-  char *keys[]= {"036790384900", "036790384902", "036790384904", "036790384906"};
+  const char *keys[]= {"036790384900", "036790384902", "036790384904", "036790384906"};
   size_t key_length[]=  {strlen("036790384900"), strlen("036790384902"), strlen("036790384904"), strlen("036790384906")};
   char return_key[MEMCACHED_MAX_KEY];
   size_t return_key_length;
@@ -1805,19 +1890,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);
@@ -1826,13 +1911,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++;
@@ -1841,13 +1926,13 @@ 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)
 {
   memcached_return rc;
-  char *keys[]= {"036790384900", "036790384902", "036790384904", "036790384906"};
+  const char *keys[]= {"036790384900", "036790384902", "036790384904", "036790384906"};
   size_t key_length[]=  {strlen("036790384900"), strlen("036790384902"), strlen("036790384904"), strlen("036790384906")};
   char return_key[MEMCACHED_MAX_KEY];
   size_t return_key_length;
@@ -1863,14 +1948,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);
@@ -1878,7 +1963,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);
@@ -1887,7 +1972,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);
 
@@ -1897,7 +1982,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)));
@@ -1906,7 +1991,7 @@ 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)))
@@ -1916,7 +2001,7 @@ static test_return  user_supplied_bug8(memcached_st *memc __attribute__((unused)
   memcached_st *memc_clone;
 
   memcached_server_st *servers;
-  char *server_list= "memcache1.memcache.bk.sapo.pt:11211, memcache1.memcache.bk.sapo.pt:11212, memcache1.memcache.bk.sapo.pt:11213, memcache1.memcache.bk.sapo.pt:11214, memcache2.memcache.bk.sapo.pt:11211, memcache2.memcache.bk.sapo.pt:11212, memcache2.memcache.bk.sapo.pt:11213, memcache2.memcache.bk.sapo.pt:11214";
+  const char *server_list= "memcache1.memcache.bk.sapo.pt:11211, memcache1.memcache.bk.sapo.pt:11212, memcache1.memcache.bk.sapo.pt:11213, memcache1.memcache.bk.sapo.pt:11214, memcache2.memcache.bk.sapo.pt:11211, memcache2.memcache.bk.sapo.pt:11212, memcache2.memcache.bk.sapo.pt:11213, memcache2.memcache.bk.sapo.pt:11214";
 
   servers= memcached_servers_parse(server_list);
   assert(servers);
@@ -1936,15 +2021,15 @@ 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)
 {
   memcached_return rc;
-  char *keys= "036790384900";
-  size_t key_length=  strlen("036790384900");
+  const char *keys= "036790384900";
+  size_t key_length=  strlen(keys);
   char return_key[MEMCACHED_MAX_KEY];
   size_t return_key_length;
   char *value;
@@ -1959,14 +2044,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);
@@ -1974,20 +2059,20 @@ 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)
 {
   memcached_return rc;
-  char *keys[]= {"UDATA:edevil@sapo.pt", "fudge&*@#", "for^#@&$not"};
+  const char *keys[]= {"UDATA:edevil@sapo.pt", "fudge&*@#", "for^#@&$not"};
   size_t key_length[3];
   unsigned int x;
   uint32_t flags;
@@ -2006,7 +2091,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);
@@ -2016,7 +2101,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);
@@ -2025,13 +2110,13 @@ 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)
 {
-  char *key= "foo";
+  const char *key= "foo";
   char *value;
   size_t value_length= 512;
   unsigned int x;
@@ -2056,7 +2141,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)
@@ -2066,7 +2151,7 @@ static test_return  user_supplied_bug10(memcached_st *memc)
   free(value);
   memcached_free(mclone);
 
-  return 0;
+  return TEST_SUCCESS;
 }
 
 /*
@@ -2074,7 +2159,7 @@ static test_return  user_supplied_bug10(memcached_st *memc)
 */
 static test_return  user_supplied_bug11(memcached_st *memc)
 {
-  char *key= "foo";
+  const char *key= "foo";
   char *value;
   size_t value_length= 512;
   unsigned int x;
@@ -2107,7 +2192,7 @@ static test_return  user_supplied_bug11(memcached_st *memc)
   free(value);
   memcached_free(mclone);
 
-  return 0;
+  return TEST_SUCCESS;
 }
 
 /*
@@ -2122,7 +2207,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);
 
@@ -2131,7 +2216,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);
@@ -2139,7 +2224,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);
@@ -2149,7 +2234,7 @@ static test_return  user_supplied_bug12(memcached_st *memc)
   assert(number_value == 2);
   assert(rc == MEMCACHED_SUCCESS);
 
-  return 0;
+  return TEST_SUCCESS;
 }
 
 /*
@@ -2184,7 +2269,7 @@ static test_return  user_supplied_bug13(memcached_st *memc)
     free(overflow);
   }
 
-  return 0;
+  return TEST_SUCCESS;
 }
 
 
@@ -2199,7 +2284,7 @@ static test_return  user_supplied_bug14(memcached_st *memc)
   size_t setter= 1;
   memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_TCP_NODELAY, setter);
   memcached_return rc;
-  char *key= "foo";
+  const char *key= "foo";
   char *value;
   size_t value_length= 18000;
   char *string;
@@ -2216,7 +2301,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);
@@ -2233,7 +2318,7 @@ static test_return  user_supplied_bug14(memcached_st *memc)
 
   free(value);
 
-  return 0;
+  return TEST_SUCCESS;
 }
 
 /*
@@ -2243,14 +2328,14 @@ static test_return  user_supplied_bug15(memcached_st *memc)
 {
   uint32_t x;
   memcached_return rc;
-  char *key= "mykey";
+  const char *key= "mykey";
   char *value;
   size_t length;
   uint32_t flags;
 
   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);
 
@@ -2273,19 +2358,19 @@ 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)
 {
   memcached_return rc;
-  char *key= "mykey";
+  const char *key= "mykey";
   char *value;
   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);
 
@@ -2299,15 +2384,16 @@ 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)
 {
     memcached_return rc;
-    char *key= "豆瓣";
-    char *value="我们在炎热抑郁的夏天无法停止豆瓣";
+    const char *key= "豆瓣";
+    const char *value="我们在炎热抑郁的夏天无法停止豆瓣";
     char *value2;
     size_t length;
     uint32_t flags;
@@ -2326,8 +2412,9 @@ 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
@@ -2350,7 +2437,7 @@ static test_return user_supplied_bug19(memcached_st *memc)
 
   memcached_free(m);
 
-  return 0;
+  return TEST_SUCCESS;
 }
 
 /* CAS test from Andei */
@@ -2358,9 +2445,9 @@ static test_return user_supplied_bug20(memcached_st *memc)
 {
   memcached_return status;
   memcached_result_st *result, result_obj;
-  char *key = "abc";
+  const char *key = "abc";
   size_t key_len = strlen("abc");
-  char *value = "foobar";
+  const char *value = "foobar";
   size_t value_len = strlen(value);
 
   memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_SUPPORT_CAS, 1);
@@ -2382,7 +2469,7 @@ static test_return user_supplied_bug20(memcached_st *memc)
 
   memcached_result_free(result);
 
-  return 0;
+  return TEST_SUCCESS;
 }
 
 #include "ketama_test_cases.h"
@@ -2398,7 +2485,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);
 
@@ -2413,7 +2500,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);
@@ -2442,7 +2529,7 @@ static test_return user_supplied_bug18(memcached_st *trash)
   memcached_server_list_free(server_pool);
   memcached_free(memc);
 
-  return 0;
+  return TEST_SUCCESS;
 }
 
 static test_return auto_eject_hosts(memcached_st *trash)
@@ -2524,7 +2611,7 @@ 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)
@@ -2535,7 +2622,7 @@ 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)
@@ -2548,7 +2635,7 @@ 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)
@@ -2559,7 +2646,7 @@ 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)
@@ -2570,7 +2657,7 @@ 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)
@@ -2580,7 +2667,7 @@ static test_return  string_alloc_with_size_toobig(memcached_st *memc)
   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)
@@ -2603,7 +2690,7 @@ 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)
@@ -2628,14 +2715,14 @@ 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)))
 {
   pairs_free(global_pairs);
 
-  return 0;
+  return TEST_SUCCESS;
 }
 
 static test_return  generate_pairs(memcached_st *memc __attribute__((unused)))
@@ -2646,11 +2733,11 @@ 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)))
@@ -2661,18 +2748,18 @@ 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)
 {
   execute_set(memc, global_pairs, global_count);
 
-  return 0;
+  return TEST_SUCCESS;
 }
 
 static test_return  generate_data_with_stats(memcached_st *memc)
@@ -2697,7 +2784,7 @@ 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)
 {
@@ -2707,7 +2794,7 @@ 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)
@@ -2743,7 +2830,7 @@ static test_return  get_read_count(memcached_st *memc)
 
   memcached_free(memc_clone);
 
-  return 0;
+  return TEST_SUCCESS;
 }
 
 static test_return  get_read(memcached_st *memc)
@@ -2769,7 +2856,7 @@ static test_return  get_read(memcached_st *memc)
     }
   }
 
-  return 0;
+  return TEST_SUCCESS;
 }
 
 static test_return  mget_read(memcached_st *memc)
@@ -2795,7 +2882,7 @@ static test_return  mget_read(memcached_st *memc)
     }
   }
 
-  return 0;
+  return TEST_SUCCESS;
 }
 
 static test_return  mget_read_result(memcached_st *memc)
@@ -2820,7 +2907,7 @@ 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)
@@ -2834,9 +2921,9 @@ 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)
@@ -2848,7 +2935,7 @@ 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)
@@ -2864,7 +2951,7 @@ 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)
@@ -2883,7 +2970,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));
@@ -2896,7 +2983,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)
@@ -2917,7 +3004,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);
@@ -3041,7 +3128,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);
@@ -3055,13 +3142,13 @@ static memcached_return  pre_binary(memcached_st *memc)
 static memcached_return pre_replication(memcached_st *memc)
 {
   memcached_return rc= MEMCACHED_FAILURE;
-  if (pre_binary(memc) == MEMCACHED_SUCCESS) 
+  if (pre_binary(memc) == MEMCACHED_SUCCESS)
   {
     /*
-     * Make sure that we store the item on all servers 
-     * (master + replicas == number of servers) 
+     * 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, 
+    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);
@@ -3073,7 +3160,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;
 
@@ -3139,7 +3226,9 @@ static memcached_return set_prefix(memcached_st *memc)
 
   /* Set to Zero, and then Set to something too large */
   {
-    char *long_key;
+    char long_key[255];
+    memset(long_key, 0, 255);
+
     rc= memcached_callback_set(memc, MEMCACHED_CALLBACK_PREFIX_KEY, NULL);
     assert(rc == MEMCACHED_SUCCESS);
 
@@ -3149,13 +3238,13 @@ static memcached_return set_prefix(memcached_st *memc)
 
     /* Test a long key for failure */
     /* TODO, extend test to determine based on setting, what result should be */
-    long_key= "Thisismorethentheallottednumberofcharacters";
+    strcpy(long_key, "Thisismorethentheallottednumberofcharacters");
     rc= memcached_callback_set(memc, MEMCACHED_CALLBACK_PREFIX_KEY, long_key);
     //assert(rc == MEMCACHED_BAD_KEY_PROVIDED);
     assert(rc == MEMCACHED_SUCCESS);
 
     /* Now test a key with spaces (which will fail from long key, since bad key is not set) */
-    long_key= "This is more then the allotted number of characters";
+    strcpy(long_key, "This is more then the allotted number of characters");
     rc= memcached_callback_set(memc, MEMCACHED_CALLBACK_PREFIX_KEY, long_key);
     assert(rc == MEMCACHED_BAD_KEY_PROVIDED);
 
@@ -3163,7 +3252,7 @@ static memcached_return set_prefix(memcached_st *memc)
     rc= memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_VERIFY_KEY, 1);
     assert(rc == MEMCACHED_SUCCESS);
 
-    long_key= "dog cat";
+    strcpy(long_key, "dog cat");
     rc= memcached_callback_set(memc, MEMCACHED_CALLBACK_PREFIX_KEY, long_key);
     assert(rc == MEMCACHED_BAD_KEY_PROVIDED);
   }
@@ -3177,7 +3266,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;
@@ -3190,7 +3279,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;
@@ -3203,7 +3292,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;
@@ -3221,19 +3310,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);
@@ -3267,7 +3356,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);
@@ -3330,7 +3419,7 @@ 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);
 
@@ -3429,7 +3518,7 @@ static test_return noreply_test(memcached_st *memc)
   /* Try setting an illegal cas value (should not return an error to
    * the caller (because we don't expect a return message from the server)
    */
-  char* keys[]= {"0"};
+  const char* keys[]= {"0"};
   size_t lengths[]= {1};
   size_t length;
   uint32_t flags;
@@ -3473,7 +3562,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);
 
@@ -3484,9 +3573,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;
@@ -3578,6 +3667,29 @@ 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;
 }
@@ -3586,8 +3698,8 @@ static test_return connection_pool_test(memcached_st *memc)
 static test_return replication_set_test(memcached_st *memc)
 {
   memcached_return rc;
-  memcached_st *clone= memcached_clone(NULL, memc);
-  memcached_behavior_set(clone, MEMCACHED_BEHAVIOR_NUMBER_OF_REPLICAS, 0);
+  memcached_st *memc_clone= memcached_clone(NULL, memc);
+  memcached_behavior_set(memc_clone, MEMCACHED_BEHAVIOR_NUMBER_OF_REPLICAS, 0);
 
   rc= memcached_set(memc, "bubba", 5, "0", 1, 0, 0);
   assert(rc == MEMCACHED_SUCCESS);
@@ -3604,7 +3716,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);
 
   /*
@@ -3618,14 +3730,14 @@ 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(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);
     free(val);
   }
 
-  memcached_free(clone);
+  memcached_free(memc_clone);
 
   return TEST_SUCCESS;
 }
@@ -3639,24 +3751,24 @@ 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 *clone= memcached_clone(NULL, memc);
-    clone->hosts[host].port= 0;
+    memcached_st *memc_clone= memcached_clone(NULL, memc);
+    memc_clone->hosts[host].port= 0;
 
     for (int x= 'a'; x <= 'z'; ++x)
     {
       char key[2]= { [0]= (char)x };
       size_t len;
       uint32_t flags;
-      char *val= memcached_get_by_key(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);
       free(val);
     }
 
-    memcached_free(clone);
+    memcached_free(memc_clone);
   }
 
   return TEST_SUCCESS;
@@ -3665,10 +3777,10 @@ static test_return replication_get_test(memcached_st *memc)
 static test_return replication_mget_test(memcached_st *memc)
 {
   memcached_return rc;
-  memcached_st *clone= memcached_clone(NULL, memc);
-  memcached_behavior_set(clone, MEMCACHED_BEHAVIOR_NUMBER_OF_REPLICAS, 0);
+  memcached_st *memc_clone= memcached_clone(NULL, memc);
+  memcached_behavior_set(memc_clone, MEMCACHED_BEHAVIOR_NUMBER_OF_REPLICAS, 0);
 
-  char *keys[]= { "bubba", "key1", "key2", "key3" };
+  const char *keys[]= { "bubba", "key1", "key2", "key3" };
   size_t len[]= { 5, 4, 4, 4 };
 
   for (int x=0; x< 4; ++x)
@@ -3689,7 +3801,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);
 
   /*
@@ -3698,14 +3810,14 @@ 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 < 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;
 
     for (int x= 'a'; x <= 'z'; ++x)
     {
-      char key[2]= { [0]= (char)x };
+      const char key[2]= { [0]= (const char)x };
 
       rc= memcached_mget_by_key(new_clone, key, 1, keys, len, 4);
       assert(rc == MEMCACHED_SUCCESS);
@@ -3725,19 +3837,21 @@ 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)
 {
   memcached_return rc;
-  memcached_st *clone= memcached_clone(NULL, memc);
+  memcached_st *memc_clone= memcached_clone(NULL, memc);
   /* Delete the items from all of the servers except 1 */
   uint64_t repl= memcached_behavior_get(memc,
                                         MEMCACHED_BEHAVIOR_NUMBER_OF_REPLICAS);
   memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_NUMBER_OF_REPLICAS, --repl);
 
-  char *keys[]= { "bubba", "key1", "key2", "key3" };
+  const char *keys[]= { "bubba", "key1", "key2", "key3" };
   size_t len[]= { 5, 4, 4, 4 };
 
   for (int x=0; x< 4; ++x)
@@ -3752,28 +3866,28 @@ 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)
   {
-    clone->hosts[hash].port= 0;
-    if (++hash == clone->number_of_hosts)
+    memc_clone->hosts[hash].port= 0;
+    if (++hash == memc_clone->number_of_hosts)
       hash= 0;
   }
 
   memcached_result_st result_obj;
-  for (uint32_t host= 0; host < clone->number_of_hosts; ++host) 
+  for (uint32_t host= 0; host < memc_clone->number_of_hosts; ++host)
   {
     for (int x= 'a'; x <= 'z'; ++x)
     {
-      char key[2]= { [0]= (char)x };
+      const char key[2]= { [0]= (const char)x };
 
-      rc= memcached_mget_by_key(clone, key, 1, keys, len, 4);
+      rc= memcached_mget_by_key(memc_clone, key, 1, keys, len, 4);
       assert(rc == MEMCACHED_SUCCESS);
 
-      memcached_result_st *results= memcached_result_create(clone, &result_obj);
+      memcached_result_st *results= memcached_result_create(memc_clone, &result_obj);
       assert(results);
 
       int hits= 0;
-      while ((results= memcached_fetch_result(clone, &result_obj, &rc)) != NULL)
+      while ((results= memcached_fetch_result(memc_clone, &result_obj, &rc)) != NULL)
       {
         ++hits;
       }
@@ -3781,7 +3895,7 @@ static test_return replication_delete_test(memcached_st *memc)
       memcached_result_free(&result_obj);
     }
   }
-  memcached_free(clone);
+  memcached_free(memc_clone);
 
   return TEST_SUCCESS;
 }
@@ -3890,7 +4004,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);
@@ -3907,8 +4021,8 @@ static test_return udp_set_test(memcached_st *memc)
   for (x= 0; x < num_iters;x++)
   {
     memcached_return rc;
-    char *key= "foo";
-    char *value= "when we sanitize";
+    const char *key= "foo";
+    const char *value= "when we sanitize";
     uint16_t *expected_ids= get_udp_request_ids(memc);
     unsigned int server_key= memcached_generate_hash(memc,key,strlen(key));
     size_t init_offset= memc->hosts[server_key].write_buffer_offset;
@@ -3923,11 +4037,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);
@@ -3947,7 +4061,7 @@ static test_return udp_buffered_set_test(memcached_st *memc)
 static test_return udp_set_too_big_test(memcached_st *memc)
 {
   memcached_return rc;
-  char *key= "bar";
+  const char *key= "bar";
   char value[MAX_UDP_DATAGRAM_LENGTH];
   uint16_t *expected_ids= get_udp_request_ids(memc);
   rc= memcached_set(memc, key, strlen(key),
@@ -3964,7 +4078,7 @@ static test_return udp_delete_test(memcached_st *memc)
   for (x= 0; x < num_iters;x++)
   {
     memcached_return rc;
-    char *key= "foo";
+    const char *key= "foo";
     uint16_t *expected_ids=get_udp_request_ids(memc);
     unsigned int server_key= memcached_generate_hash(memc, key, strlen(key));
     size_t init_offset= memc->hosts[server_key].write_buffer_offset;
@@ -4015,7 +4129,7 @@ static test_return 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);
@@ -4026,12 +4140,12 @@ static test_return udp_flush_test(memcached_st *memc)
 static test_return udp_incr_test(memcached_st *memc)
 {
   memcached_return rc;
-  char *key= "incr";
-  char *value= "1";
-  rc= memcached_set(memc, key, strlen(key), 
+  const char *key= "incr";
+  const char *value= "1";
+  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));
@@ -4045,12 +4159,12 @@ static test_return udp_incr_test(memcached_st *memc)
 static test_return udp_decr_test(memcached_st *memc)
 {
   memcached_return rc;
-  char *key= "decr";
-  char *value= "1";
-  rc= memcached_set(memc, key, strlen(key), 
+  const char *key= "decr";
+  const char *value= "1";
+  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));
@@ -4086,7 +4200,7 @@ static test_return udp_version_test(memcached_st *memc)
 static test_return udp_get_test(memcached_st *memc)
 {
   memcached_return rc;
-  char *key= "foo";
+  const char *key= "foo";
   size_t vlen;
   uint16_t *expected_ids = get_udp_request_ids(memc);
   char *val= memcached_get(memc, key, strlen(key), &vlen, (uint32_t)0, &rc);
@@ -4130,7 +4244,7 @@ static test_return hsieh_avaibility_test (memcached_st *memc)
   return TEST_SUCCESS;
 }
 
-static char *list[]=
+static const char *list[]=
 {
   "apple",
   "beat",
@@ -4163,19 +4277,19 @@ static char *list[]=
 static test_return md5_run (memcached_st *memc __attribute__((unused)))
 {
   uint32_t x;
-  char **ptr;
+  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);
@@ -4187,15 +4301,15 @@ static test_return md5_run (memcached_st *memc __attribute__((unused)))
 static test_return crc_run (memcached_st *memc __attribute__((unused)))
 {
   uint32_t x;
-  char **ptr;
+  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);
@@ -4207,18 +4321,18 @@ static test_return crc_run (memcached_st *memc __attribute__((unused)))
 static test_return fnv1_64_run (memcached_st *memc __attribute__((unused)))
 {
   uint32_t x;
-  char **ptr;
-  uint32_t values[]= {  473199127U, 4148981457U, 3971873300U, 3257986707U, 
-                        1722477987U, 2991193800U, 4147007314U, 3633179701U, 
+  const char **ptr;
+  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);
@@ -4230,18 +4344,18 @@ static test_return fnv1_64_run (memcached_st *memc __attribute__((unused)))
 static test_return fnv1a_64_run (memcached_st *memc __attribute__((unused)))
 {
   uint32_t x;
-  char **ptr;
-  uint32_t values[]= {  1488911807U, 2500855813U, 1510099634U, 1390325195U, 
-                        3647689787U, 3241528582U, 1669328060U, 2604311949U, 
+  const char **ptr;
+  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);
@@ -4253,10 +4367,10 @@ static test_return fnv1a_64_run (memcached_st *memc __attribute__((unused)))
 static test_return fnv1_32_run (memcached_st *memc __attribute__((unused)))
 {
   uint32_t x;
-  char **ptr;
-  uint32_t values[]= {  67176023U, 1190179409U, 2043204404U, 3221866419U, 
+  const char **ptr;
+  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,
@@ -4265,7 +4379,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);
@@ -4277,7 +4391,7 @@ static test_return fnv1_32_run (memcached_st *memc __attribute__((unused)))
 static test_return fnv1a_32_run (memcached_st *memc __attribute__((unused)))
 {
   uint32_t x;
-  char **ptr;
+  const char **ptr;
   uint32_t values[]= {  280767167U, 2421315013U, 3072375666U, 855001899U,
                         459261019U, 3521085446U, 18738364U, 1625305005U,
                         2162232970U, 777243802U, 3323728671U, 132336572U,
@@ -4288,7 +4402,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);
@@ -4300,7 +4414,7 @@ static test_return fnv1a_32_run (memcached_st *memc __attribute__((unused)))
 static test_return hsieh_run (memcached_st *memc __attribute__((unused)))
 {
   uint32_t x;
-  char **ptr;
+  const char **ptr;
 #ifdef HAVE_HSIEH_HASH
   uint32_t values[]= {  3738850110, 3636226060, 3821074029, 3489929160, 3485772682, 80540287,
                         1805464076, 1895033657, 409795758, 979934958, 3634096985, 1284445480,
@@ -4313,7 +4427,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);
@@ -4325,7 +4439,7 @@ static test_return hsieh_run (memcached_st *memc __attribute__((unused)))
 static test_return murmur_run (memcached_st *memc __attribute__((unused)))
 {
   uint32_t x;
-  char **ptr;
+  const char **ptr;
   uint32_t values[]= { 473199127U, 4148981457U, 3971873300U, 3257986707U,
                        1722477987U, 2991193800U, 4147007314U, 3633179701U,
                        1805162104U, 3503289120U, 3395702895U, 3325073042U,
@@ -4336,7 +4450,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);
@@ -4348,7 +4462,7 @@ static test_return murmur_run (memcached_st *memc __attribute__((unused)))
 static test_return jenkins_run (memcached_st *memc __attribute__((unused)))
 {
   uint32_t x;
-  char **ptr;
+  const char **ptr;
   uint32_t values[]= {  1442444624U, 4253821186U, 1885058256U, 2120131735U,
                         3261968576U, 3515188778U, 4232909173U, 4288625128U,
                         1812047395U, 3689182164U, 2502979932U, 1214050606U,
@@ -4360,7 +4474,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);
@@ -4369,6 +4483,178 @@ static test_return jenkins_run (memcached_st *memc __attribute__((unused)))
   return TEST_SUCCESS;
 }
 
+static test_return regression_bug_434484(memcached_st *memc)
+{
+  if (pre_binary(memc) != TEST_SUCCESS)
+    return TEST_SUCCESS;
+
+  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= malloc(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 regression_bug_434843(memcached_st *memc)
+{
+  if (pre_binary(memc) != TEST_SUCCESS)
+    return TEST_SUCCESS;
+
+  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
+   * 10240 (that should satisfy most users don't you tink?)
+   */
+  uint32_t number_of_hosts= memc->number_of_hosts;
+  memc->number_of_hosts= 1;
+  const size_t max_keys= 10240;
+  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];
+      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 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 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 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_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},
@@ -4431,6 +4717,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 },
@@ -4498,8 +4785,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,
@@ -4521,6 +4808,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 },
@@ -4629,6 +4931,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}
 };