X-Git-Url: https://git.m6w6.name/?a=blobdiff_plain;f=tests%2Ffunction.c;h=27af67369c5729de9442e37d03061a6968bb05f4;hb=1019d0d8979ae75ee6dea937cb405a1367d6254d;hp=5f83e1ea2a16a05d8f5133c189aff8a212fbe172;hpb=29db6c77e126d9ae0c416ad76402fdbef7372cdb;p=awesomized%2Flibmemcached

diff --git a/tests/function.c b/tests/function.c
index 5f83e1ea..27af6736 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)))
@@ -94,7 +95,7 @@ static test_return  server_sort_test(memcached_st *ptr __attribute__((unused)))
 
   for (x= 0; x < TEST_PORT_COUNT; x++)
   {
-    test_ports[x]= random() % 64000;
+    test_ports[x]= (uint32_t)random() % 64000;
     rc= memcached_server_add_with_weight(local_memc, "localhost", test_ports[x], 0);
     assert(local_memc->number_of_hosts == x + 1);
     assert(local_memc->hosts[0].count == x+1);
@@ -165,7 +166,7 @@ static test_return  server_unsort_test(memcached_st *ptr __attribute__((unused))
 
   for (x= 0; x < TEST_PORT_COUNT; x++)
   {
-    test_ports[x]= random() % 64000;
+    test_ports[x]= (uint32_t)(random() % 64000);
     rc= memcached_server_add_with_weight(local_memc, "localhost", test_ports[x], 0);
     assert(local_memc->number_of_hosts == x+1);
     assert(local_memc->hosts[0].count == x+1);
@@ -200,65 +201,64 @@ static test_return  clone_test(memcached_st *memc)
 {
   /* All null? */
   {
-    memcached_st *clone;
-    clone= memcached_clone(NULL, NULL);
-    assert(clone);
-    memcached_free(clone);
+    memcached_st *memc_clone;
+    memc_clone= memcached_clone(NULL, NULL);
+    assert(memc_clone);
+    memcached_free(memc_clone);
   }
 
   /* Can we init from null? */
   {
-    memcached_st *clone;
-    clone= memcached_clone(NULL, memc);
-    assert(clone);
-
-    assert(clone->call_free == memc->call_free);
-    assert(clone->call_malloc == memc->call_malloc);
-    assert(clone->call_realloc == memc->call_realloc);
-    assert(clone->call_calloc == memc->call_calloc);
-    assert(clone->connect_timeout == memc->connect_timeout);
-    assert(clone->delete_trigger == memc->delete_trigger);
-    assert(clone->distribution == memc->distribution);
-    assert(clone->flags == memc->flags);
-    assert(clone->get_key_failure == memc->get_key_failure);
-    assert(clone->hash == memc->hash);
-    assert(clone->hash_continuum == memc->hash_continuum);
-    assert(clone->io_bytes_watermark == memc->io_bytes_watermark);
-    assert(clone->io_msg_watermark == memc->io_msg_watermark);
-    assert(clone->io_key_prefetch == memc->io_key_prefetch);
-    assert(clone->on_cleanup == memc->on_cleanup);
-    assert(clone->on_clone == memc->on_clone);
-    assert(clone->poll_timeout == memc->poll_timeout);
-    assert(clone->rcv_timeout == memc->rcv_timeout);
-    assert(clone->recv_size == memc->recv_size);
-    assert(clone->retry_timeout == memc->retry_timeout);
-    assert(clone->send_size == memc->send_size);
-    assert(clone->server_failure_limit == memc->server_failure_limit);
-    assert(clone->snd_timeout == memc->snd_timeout);
-    assert(clone->user_data == memc->user_data);
-    assert(clone->number_of_replicas == memc->number_of_replicas);
-
-    memcached_free(clone);
+    memcached_st *memc_clone;
+    memc_clone= memcached_clone(NULL, memc);
+    assert(memc_clone);
+
+    assert(memc_clone->call_free == memc->call_free);
+    assert(memc_clone->call_malloc == memc->call_malloc);
+    assert(memc_clone->call_realloc == memc->call_realloc);
+    assert(memc_clone->call_calloc == memc->call_calloc);
+    assert(memc_clone->connect_timeout == memc->connect_timeout);
+    assert(memc_clone->delete_trigger == memc->delete_trigger);
+    assert(memc_clone->distribution == memc->distribution);
+    assert(memc_clone->flags == memc->flags);
+    assert(memc_clone->get_key_failure == memc->get_key_failure);
+    assert(memc_clone->hash == memc->hash);
+    assert(memc_clone->hash_continuum == memc->hash_continuum);
+    assert(memc_clone->io_bytes_watermark == memc->io_bytes_watermark);
+    assert(memc_clone->io_msg_watermark == memc->io_msg_watermark);
+    assert(memc_clone->io_key_prefetch == memc->io_key_prefetch);
+    assert(memc_clone->on_cleanup == memc->on_cleanup);
+    assert(memc_clone->on_clone == memc->on_clone);
+    assert(memc_clone->poll_timeout == memc->poll_timeout);
+    assert(memc_clone->rcv_timeout == memc->rcv_timeout);
+    assert(memc_clone->recv_size == memc->recv_size);
+    assert(memc_clone->retry_timeout == memc->retry_timeout);
+    assert(memc_clone->send_size == memc->send_size);
+    assert(memc_clone->server_failure_limit == memc->server_failure_limit);
+    assert(memc_clone->snd_timeout == memc->snd_timeout);
+    assert(memc_clone->user_data == memc->user_data);
+
+    memcached_free(memc_clone);
   }
 
   /* Can we init from struct? */
   {
     memcached_st declared_clone;
-    memcached_st *clone;
+    memcached_st *memc_clone;
     memset(&declared_clone, 0 , sizeof(memcached_st));
-    clone= memcached_clone(&declared_clone, NULL);
-    assert(clone);
-    memcached_free(clone);
+    memc_clone= memcached_clone(&declared_clone, NULL);
+    assert(memc_clone);
+    memcached_free(memc_clone);
   }
 
   /* Can we init from struct? */
   {
     memcached_st declared_clone;
-    memcached_st *clone;
+    memcached_st *memc_clone;
     memset(&declared_clone, 0 , sizeof(memcached_st));
-    clone= memcached_clone(&declared_clone, memc);
-    assert(clone);
-    memcached_free(clone);
+    memc_clone= memcached_clone(&declared_clone, memc);
+    assert(memc_clone);
+    memcached_free(memc_clone);
   }
 
   return 0;
@@ -266,7 +266,7 @@ static test_return  clone_test(memcached_st *memc)
 
 static test_return userdata_test(memcached_st *memc)
 {
-  void* foo;
+  void* foo= NULL;
   assert(memcached_set_user_data(memc, foo) == NULL);
   assert(memcached_get_user_data(memc) == foo);
   assert(memcached_set_user_data(memc, NULL) == foo);
@@ -287,10 +287,18 @@ static test_return  connection_test(memcached_st *memc)
 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 };
 
+  assert(MEMCACHED_MAXIMUM_RETURN == 37); // You have updated the memcache_error messages but not updated docs/tests.
   for (rc= MEMCACHED_SUCCESS; rc < MEMCACHED_MAXIMUM_RETURN; rc++)
   {
-    printf("Error %d -> %s\n", rc, memcached_strerror(memc, rc));
+    uint32_t hash_val;
+    hash_val= memcached_generate_hash_value(memcached_strerror(memc, rc), strlen(memcached_strerror(memc, rc)), MEMCACHED_HASH_JENKINS);
+    assert(values[rc] == hash_val);
   }
 
   return 0;
@@ -299,8 +307,8 @@ static test_return  error_test(memcached_st *memc)
 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), 
                     value, strlen(value),
@@ -313,8 +321,9 @@ static test_return  set_test(memcached_st *memc)
 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;
 
@@ -322,7 +331,7 @@ static test_return  append_test(memcached_st *memc)
   assert(rc == MEMCACHED_SUCCESS);
 
   rc= memcached_set(memc, key, strlen(key), 
-                    value, strlen(value),
+                    in_value, strlen(in_value),
                     (time_t)0, (uint32_t)0);
   assert(rc == MEMCACHED_SUCCESS);
 
@@ -336,12 +345,12 @@ static test_return  append_test(memcached_st *memc)
                        (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;
 }
@@ -349,7 +358,7 @@ static test_return  append_test(memcached_st *memc)
 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;
@@ -395,9 +404,9 @@ static test_return  append_binary_test(memcached_st *memc)
 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;
@@ -425,7 +434,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);
@@ -442,7 +451,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";
@@ -469,7 +478,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);
@@ -499,8 +508,9 @@ static test_return  cas_test(memcached_st *memc)
 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;
 
@@ -522,12 +532,12 @@ static test_return  prepend_test(memcached_st *memc)
                        (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;
 }
@@ -539,8 +549,8 @@ static test_return  prepend_test(memcached_st *memc)
 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);
@@ -587,9 +597,9 @@ static test_return  add_wrapper(memcached_st *memc)
 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), 
                     original, strlen(original),
@@ -607,8 +617,8 @@ static test_return  replace_test(memcached_st *memc)
 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), 
                     value, strlen(value),
@@ -642,61 +652,61 @@ 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;
 }
 
 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;
-  memcached_st *clone;
+  memcached_st *memc_clone;
   unsigned int set= 1;
   size_t max_keylen= 0xffff;
 
-  clone= memcached_clone(NULL, memc);
-  assert(clone);
+  memc_clone= memcached_clone(NULL, memc);
+  assert(memc_clone);
 
-  rc= memcached_behavior_set(clone, MEMCACHED_BEHAVIOR_VERIFY_KEY, set);
+  rc= memcached_behavior_set(memc_clone, MEMCACHED_BEHAVIOR_VERIFY_KEY, set);
   assert(rc == MEMCACHED_SUCCESS);
 
   /* All keys are valid in the binary protocol (except for length) */
-  if (memcached_behavior_get(clone, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL) == 0) 
+  if (memcached_behavior_get(memc_clone, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL) == 0) 
   {
-    string= memcached_get(clone, key, strlen(key),
+    string= memcached_get(memc_clone, key, strlen(key),
                           &string_length, &flags, &rc);
     assert(rc == MEMCACHED_BAD_KEY_PROVIDED);
     assert(string_length ==  0);
     assert(!string);
 
     set= 0;
-    rc= memcached_behavior_set(clone, MEMCACHED_BEHAVIOR_VERIFY_KEY, set);
+    rc= memcached_behavior_set(memc_clone, MEMCACHED_BEHAVIOR_VERIFY_KEY, set);
     assert(rc == MEMCACHED_SUCCESS);
-    string= memcached_get(clone, key, strlen(key),
+    string= memcached_get(memc_clone, key, strlen(key),
                           &string_length, &flags, &rc);
     assert(rc == MEMCACHED_NOTFOUND);
     assert(string_length ==  0);
     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(clone, MEMCACHED_BEHAVIOR_VERIFY_KEY, set);
+    rc= memcached_behavior_set(memc_clone, MEMCACHED_BEHAVIOR_VERIFY_KEY, set);
     assert(rc == MEMCACHED_SUCCESS);
 
-    rc= memcached_mget(clone, keys, key_lengths, 3);
+    rc= memcached_mget(memc_clone, keys, key_lengths, 3);
     assert(rc == MEMCACHED_BAD_KEY_PROVIDED);
 
-    rc= memcached_mget_by_key(clone, "foo daddy", 9, keys, key_lengths, 1);
+    rc= memcached_mget_by_key(memc_clone, "foo daddy", 9, keys, key_lengths, 1);
     assert(rc == MEMCACHED_BAD_KEY_PROVIDED);
 
     max_keylen= 250;
@@ -705,20 +715,20 @@ static test_return  bad_key_test(memcached_st *memc)
        memcached server is updated to allow max size length of the keys in the
        binary protocol
     */
-    rc= memcached_callback_set(clone, MEMCACHED_CALLBACK_PREFIX_KEY, NULL);
+    rc= memcached_callback_set(memc_clone, MEMCACHED_CALLBACK_PREFIX_KEY, NULL);
     assert(rc == MEMCACHED_SUCCESS);
 
     char *longkey= malloc(max_keylen + 1);
     if (longkey != NULL) 
     {
       memset(longkey, 'a', max_keylen + 1);
-      string= memcached_get(clone, longkey, max_keylen,
+      string= memcached_get(memc_clone, longkey, max_keylen,
                             &string_length, &flags, &rc);
       assert(rc == MEMCACHED_NOTFOUND);
       assert(string_length ==  0);
       assert(!string);
 
-      string= memcached_get(clone, longkey, max_keylen + 1,
+      string= memcached_get(memc_clone, longkey, max_keylen + 1,
                             &string_length, &flags, &rc);
       assert(rc == MEMCACHED_BAD_KEY_PROVIDED);
       assert(string_length ==  0);
@@ -730,15 +740,15 @@ static test_return  bad_key_test(memcached_st *memc)
 
   /* Make sure zero length keys are marked as bad */
   set= 1;
-  rc= memcached_behavior_set(clone, MEMCACHED_BEHAVIOR_VERIFY_KEY, set);
+  rc= memcached_behavior_set(memc_clone, MEMCACHED_BEHAVIOR_VERIFY_KEY, set);
   assert(rc == MEMCACHED_SUCCESS);
-  string= memcached_get(clone, key, 0,
+  string= memcached_get(memc_clone, key, 0,
                         &string_length, &flags, &rc);
   assert(rc == MEMCACHED_BAD_KEY_PROVIDED);
   assert(string_length ==  0);
   assert(!string);
 
-  memcached_free(clone);
+  memcached_free(memc_clone);
 
   return 0;
 }
@@ -756,7 +766,7 @@ static memcached_return  read_through_trigger(memcached_st *memc __attribute__((
 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;
@@ -817,7 +827,7 @@ static test_return  delete_through(memcached_st *memc)
 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;
@@ -838,8 +848,8 @@ static test_return  get_test(memcached_st *memc)
 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;
@@ -865,8 +875,8 @@ static test_return  get_test2(memcached_st *memc)
 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;
 
@@ -915,7 +925,7 @@ static test_return  set_test3(memcached_st *memc)
 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;
@@ -951,7 +961,7 @@ static test_return  get_test3(memcached_st *memc)
 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;
@@ -998,7 +1008,7 @@ 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;
@@ -1032,12 +1042,76 @@ 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_SUCCESS);
+  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 stat;
-  rc= memcached_stat_servername(&stat, NULL,
+  memcached_stat_st memc_stat;
+  rc= memcached_stat_servername(&memc_stat, NULL,
                                  memc->hosts[0].hostname, 
                                  memc->hosts[0].port);
 
@@ -1048,8 +1122,8 @@ 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), 
                     value, strlen(value),
@@ -1075,7 +1149,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),
@@ -1095,8 +1169,8 @@ 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), 
                     value, strlen(value),
@@ -1122,7 +1196,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),
@@ -1141,8 +1215,8 @@ static test_return  decrement_with_initial_test(memcached_st *memc)
 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), 
                     value, strlen(value),
@@ -1161,7 +1235,7 @@ static test_return  quit_test(memcached_st *memc)
 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;
 
@@ -1218,7 +1292,7 @@ static test_return  mget_result_test(memcached_st *memc)
 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;
 
@@ -1280,7 +1354,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;
@@ -1311,7 +1385,7 @@ static test_return  mget_result_function(memcached_st *memc)
 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;
@@ -1367,10 +1441,10 @@ static test_return  get_stats_keys(memcached_st *memc)
 {
  char **list;
  char **ptr;
- memcached_stat_st stat;
+ memcached_stat_st memc_stat;
  memcached_return rc;
 
- list= memcached_stat_get_keys(memc, &stat, &rc);
+ list= memcached_stat_get_keys(memc, &memc_stat, &rc);
  assert(rc == MEMCACHED_SUCCESS);
  for (ptr= list; *ptr; ptr++)
    assert(*ptr);
@@ -1398,24 +1472,24 @@ static test_return  get_stats(memcached_st *memc)
  char **list;
  char **ptr;
  memcached_return rc;
- memcached_stat_st *stat;
+ memcached_stat_st *memc_stat;
 
- stat= memcached_stat(memc, NULL, &rc);
+ memc_stat= memcached_stat(memc, NULL, &rc);
  assert(rc == MEMCACHED_SUCCESS);
 
  assert(rc == MEMCACHED_SUCCESS);
- assert(stat);
+ assert(memc_stat);
 
  for (x= 0; x < memcached_server_count(memc); x++)
  {
-   list= memcached_stat_get_keys(memc, stat+x, &rc);
+   list= memcached_stat_get_keys(memc, memc_stat+x, &rc);
    assert(rc == MEMCACHED_SUCCESS);
    for (ptr= list; *ptr; ptr++);
 
    free(list);
  }
 
- memcached_stat_free(NULL, stat);
+ memcached_stat_free(NULL, memc_stat);
 
   return 0;
 }
@@ -1452,7 +1526,7 @@ static test_return  add_host_test(memcached_st *memc)
   return 0;
 }
 
-static memcached_return  clone_test_callback(memcached_st *parent __attribute__((unused)), memcached_st *clone __attribute__((unused)))
+static memcached_return  clone_test_callback(memcached_st *parent __attribute__((unused)), memcached_st *memc_clone __attribute__((unused)))
 {
   return MEMCACHED_SUCCESS;
 }
@@ -1585,12 +1659,12 @@ static test_return  user_supplied_bug1(memcached_st *memc)
   {
     unsigned int j= 0;
 
-    size= (rand() % ( 5 * 1024 ) ) + 400;
+    size= (uint32_t)(rand() % ( 5 * 1024 ) ) + 400;
     memset(randomstuff, 0, 6 * 1024);
     assert(size < 6 * 1024); /* Being safe here */
 
     for (j= 0 ; j < size ;j++) 
-      randomstuff[j] = (char) (rand() % 26) + 97;
+      randomstuff[j] = (signed char) ((rand() % 26) + 97);
 
     total += size;
     sprintf(key, "%d", x);
@@ -1648,8 +1722,7 @@ static test_return  user_supplied_bug2(memcached_st *memc)
         errors++;
       else
       {
-        WATCHPOINT_ERROR(rc);
-        assert(0);
+        assert(rc);
       }
 
       continue;
@@ -1696,7 +1769,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 */
@@ -1727,7 +1800,7 @@ static test_return  user_supplied_bug3(memcached_st *memc)
 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;
@@ -1790,7 +1863,7 @@ static test_return  user_supplied_bug4(memcached_st *memc)
 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;
@@ -1802,7 +1875,7 @@ static test_return  user_supplied_bug5(memcached_st *memc)
   char insert_data[VALUE_SIZE_BUG5];
 
   for (x= 0; x < VALUE_SIZE_BUG5; x++)
-    insert_data[x]= rand();
+    insert_data[x]= (signed char)rand();
 
   memcached_flush(memc, 0);
   value= memcached_get(memc, keys[0], key_length[0],
@@ -1848,7 +1921,7 @@ static test_return  user_supplied_bug5(memcached_st *memc)
 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;
@@ -1860,7 +1933,7 @@ static test_return  user_supplied_bug6(memcached_st *memc)
   char insert_data[VALUE_SIZE_BUG5];
 
   for (x= 0; x < VALUE_SIZE_BUG5; x++)
-    insert_data[x]= rand();
+    insert_data[x]= (signed char)rand();
 
   memcached_flush(memc, 0);
   value= memcached_get(memc, keys[0], key_length[0],
@@ -1914,10 +1987,10 @@ static test_return  user_supplied_bug8(memcached_st *memc __attribute__((unused)
 {
   memcached_return rc;
   memcached_st *mine;
-  memcached_st *clone;
+  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);
@@ -1928,14 +2001,14 @@ static test_return  user_supplied_bug8(memcached_st *memc __attribute__((unused)
   memcached_server_list_free(servers);
 
   assert(mine);
-  clone= memcached_clone(NULL, mine);
+  memc_clone= memcached_clone(NULL, mine);
 
   memcached_quit(mine);
-  memcached_quit(clone);
+  memcached_quit(memc_clone);
 
 
   memcached_free(mine);
-  memcached_free(clone);
+  memcached_free(memc_clone);
 
   return 0;
 }
@@ -1944,8 +2017,8 @@ static test_return  user_supplied_bug8(memcached_st *memc __attribute__((unused)
 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;
@@ -1955,7 +2028,7 @@ static test_return  user_supplied_bug7(memcached_st *memc)
   char insert_data[VALUE_SIZE_BUG5];
 
   for (x= 0; x < VALUE_SIZE_BUG5; x++)
-    insert_data[x]= rand();
+    insert_data[x]= (signed char)rand();
 
   memcached_flush(memc, 0);
 
@@ -1988,7 +2061,7 @@ static test_return  user_supplied_bug7(memcached_st *memc)
 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;
@@ -2032,11 +2105,11 @@ static test_return  user_supplied_bug9(memcached_st *memc)
 /* 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;
-  int key_len= 3;
+  size_t key_len= 3;
   memcached_return rc;
   unsigned int set= 1;
   memcached_st *mclone= memcached_clone(NULL, memc);
@@ -2045,7 +2118,8 @@ static test_return  user_supplied_bug10(memcached_st *memc)
   memcached_behavior_set(mclone, MEMCACHED_BEHAVIOR_NO_BLOCK, set);
   memcached_behavior_set(mclone, MEMCACHED_BEHAVIOR_TCP_NODELAY, set);
   timeout= 2;
-  memcached_behavior_set(mclone, MEMCACHED_BEHAVIOR_POLL_TIMEOUT, timeout);
+  memcached_behavior_set(mclone, MEMCACHED_BEHAVIOR_POLL_TIMEOUT,
+                         (uint64_t)timeout);
 
   value = (char*)malloc(value_length * sizeof(char));
 
@@ -2074,11 +2148,11 @@ 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;
-  int key_len= 3;
+  size_t key_len= 3;
   memcached_return rc;
   unsigned int set= 1;
   int32_t timeout;
@@ -2087,7 +2161,8 @@ static test_return  user_supplied_bug11(memcached_st *memc)
   memcached_behavior_set(mclone, MEMCACHED_BEHAVIOR_NO_BLOCK, set);
   memcached_behavior_set(mclone, MEMCACHED_BEHAVIOR_TCP_NODELAY, set);
   timeout= -1;
-  memcached_behavior_set(mclone, MEMCACHED_BEHAVIOR_POLL_TIMEOUT, timeout);
+  memcached_behavior_set(mclone, MEMCACHED_BEHAVIOR_POLL_TIMEOUT,
+                         (size_t)timeout);
 
   timeout= (int32_t)memcached_behavior_get(mclone, MEMCACHED_BEHAVIOR_POLL_TIMEOUT);
 
@@ -2195,10 +2270,10 @@ static test_return  user_supplied_bug13(memcached_st *memc)
  */
 static test_return  user_supplied_bug14(memcached_st *memc)
 {
-  int setter= 1;
+  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;
@@ -2242,7 +2317,7 @@ 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;
@@ -2279,7 +2354,7 @@ static test_return  user_supplied_bug15(memcached_st *memc)
 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;
@@ -2301,12 +2376,13 @@ static test_return  user_supplied_bug16(memcached_st *memc)
   return 0;
 }
 
+#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;
@@ -2327,6 +2403,7 @@ static test_return  user_supplied_bug17(memcached_st *memc)
 
     return 0;
 }
+#endif
 
 /*
   From Andrei on IRC
@@ -2357,9 +2434,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);
@@ -2388,7 +2465,7 @@ static test_return user_supplied_bug20(memcached_st *memc)
 static test_return user_supplied_bug18(memcached_st *trash)
 {
   memcached_return rc;
-  int value;
+  uint64_t value;
   int x;
   memcached_server_st *server_pool;
   memcached_st *memc;
@@ -2700,7 +2777,7 @@ static test_return  generate_data_with_stats(memcached_st *memc)
 }
 static test_return  generate_buffer_data(memcached_st *memc)
 {
-  int latch= 0;
+  size_t latch= 0;
 
   latch= 1;
   memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_BUFFER_REQUESTS, latch);
@@ -2713,12 +2790,12 @@ static test_return  get_read_count(memcached_st *memc)
 {
   unsigned int x;
   memcached_return rc;
-  memcached_st *clone;
+  memcached_st *memc_clone;
 
-  clone= memcached_clone(NULL, memc);
-  assert(clone);
+  memc_clone= memcached_clone(NULL, memc);
+  assert(memc_clone);
 
-  memcached_server_add_with_weight(clone, "localhost", 6666, 0);
+  memcached_server_add_with_weight(memc_clone, "localhost", 6666, 0);
 
   {
     char *return_value;
@@ -2728,7 +2805,7 @@ static test_return  get_read_count(memcached_st *memc)
 
     for (x= count= 0; x < global_count; x++)
     {
-      return_value= memcached_get(clone, global_keys[x], global_keys_length[x],
+      return_value= memcached_get(memc_clone, global_keys[x], global_keys_length[x],
                                   &return_value_length, &flags, &rc);
       if (rc == MEMCACHED_SUCCESS)
       {
@@ -2740,7 +2817,7 @@ static test_return  get_read_count(memcached_st *memc)
     fprintf(stderr, "\t%u -> %u", global_count, count);
   }
 
-  memcached_free(clone);
+  memcached_free(memc_clone);
 
   return 0;
 }
@@ -2852,7 +2929,7 @@ static test_return  delete_generate(memcached_st *memc)
 
 static test_return  delete_buffer_generate(memcached_st *memc)
 {
-  int latch= 0;
+  size_t latch= 0;
   unsigned int x;
 
   latch= 1;
@@ -2908,15 +2985,15 @@ static memcached_return  pre_nonblock(memcached_st *memc)
 static memcached_return  pre_nonblock_binary(memcached_st *memc)
 {
   memcached_return rc= MEMCACHED_FAILURE;
-  memcached_st *clone;
+  memcached_st *memc_clone;
 
-  clone= memcached_clone(NULL, memc);
-  assert(clone);
+  memc_clone= memcached_clone(NULL, memc);
+  assert(memc_clone);
   // The memcached_version needs to be done on a clone, because the server
   // will not toggle protocol on an connection.
-  memcached_version(clone);
+  memcached_version(memc_clone);
 
-  if (clone->hosts[0].major_version >= 1 && 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);
@@ -2924,7 +3001,7 @@ static memcached_return  pre_nonblock_binary(memcached_st *memc)
     assert(memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL) == 1);
   }
 
-  memcached_free(clone);
+  memcached_free(memc_clone);
   return rc;
 }
 
@@ -3032,22 +3109,22 @@ static memcached_return  pre_behavior_ketama_weighted(memcached_st *memc)
 static memcached_return  pre_binary(memcached_st *memc)
 {
   memcached_return rc= MEMCACHED_FAILURE;
-  memcached_st *clone;
+  memcached_st *memc_clone;
 
-  clone= memcached_clone(NULL, memc);
-  assert(clone);
+  memc_clone= memcached_clone(NULL, memc);
+  assert(memc_clone);
   // The memcached_version needs to be done on a clone, because the server
   // will not toggle protocol on an connection.
-  memcached_version(clone);
+  memcached_version(memc_clone);
 
-  if (clone->hosts[0].major_version >= 1 && 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);
     assert(memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL) == 1);
   }
 
-  memcached_free(clone);
+  memcached_free(memc_clone);
   return rc;
 }
 
@@ -3069,6 +3146,16 @@ static memcached_return pre_replication(memcached_st *memc)
   return rc;
 }
 
+static memcached_return pre_replication_noblock(memcached_st *memc)
+{
+  memcached_return rc= MEMCACHED_FAILURE;
+  if (pre_replication(memc) == MEMCACHED_SUCCESS && 
+      pre_nonblock(memc) == MEMCACHED_SUCCESS)
+    rc= MEMCACHED_SUCCESS;
+
+  return rc;
+}
+
 static void my_free(memcached_st *ptr __attribute__((unused)), void *mem)
 {
   free(mem);
@@ -3128,7 +3215,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);
 
@@ -3138,13 +3227,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);
 
@@ -3152,7 +3241,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);
   }
@@ -3160,6 +3249,7 @@ static memcached_return set_prefix(memcached_st *memc)
   return MEMCACHED_SUCCESS;
 }
 
+#ifdef MEMCACHED_ENABLE_DEPRECATED
 static memcached_return deprecated_set_memory_alloc(memcached_st *memc)
 {
   void *test_ptr= NULL;
@@ -3204,6 +3294,7 @@ static memcached_return deprecated_set_memory_alloc(memcached_st *memc)
   }
   return MEMCACHED_SUCCESS;
 }
+#endif
 
 static memcached_return set_memory_alloc(memcached_st *memc)
 {
@@ -3311,13 +3402,13 @@ static memcached_return  pre_settimer(memcached_st *memc)
 
 static memcached_return  poll_timeout(memcached_st *memc)
 {
-  int32_t timeout;
+  size_t timeout;
 
   timeout= 100;
 
   memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_POLL_TIMEOUT, timeout);
 
-  timeout= (int32_t)memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_POLL_TIMEOUT);
+  timeout= (size_t)memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_POLL_TIMEOUT);
 
   assert(timeout == 100);
 
@@ -3342,7 +3433,7 @@ static test_return noreply_test(memcached_st *memc)
     for (int x=0; x < 100; ++x)
     {
       char key[10];
-      size_t len= sprintf(key, "%d", x);
+      size_t len= (size_t)sprintf(key, "%d", x);
       switch (count)
       {
       case 0:
@@ -3360,6 +3451,9 @@ static test_return noreply_test(memcached_st *memc)
       case 4:
         ret=memcached_prepend(memc, key, len, key, len, 0, 0);
         break;
+      default:
+        assert(count);
+        break;
       }
       assert(ret == MEMCACHED_SUCCESS || ret == MEMCACHED_BUFFERED);
     }
@@ -3371,7 +3465,7 @@ static test_return noreply_test(memcached_st *memc)
     */
     int no_msg=0;
     for (uint32_t x=0; x < memc->number_of_hosts; ++x)
-      no_msg+=memc->hosts[x].cursor_active;
+      no_msg+=(int)(memc->hosts[x].cursor_active);
 
     assert(no_msg == 0);
     assert(memcached_flush_buffers(memc) == MEMCACHED_SUCCESS);
@@ -3382,7 +3476,7 @@ static test_return noreply_test(memcached_st *memc)
     for (int x=0; x < 100; ++x)
     {
       char key[10];
-      size_t len= sprintf(key, "%d", x);
+      size_t len= (size_t)sprintf(key, "%d", x);
       size_t length;
       uint32_t flags;
       char* value=memcached_get(memc, key, strlen(key),
@@ -3402,6 +3496,9 @@ static test_return noreply_test(memcached_st *memc)
       case 4:
         assert(length == len * 3);
         break;
+      default:
+        assert(count);
+        break;
       }
       free(value);
     }
@@ -3410,7 +3507,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;
@@ -3447,19 +3544,19 @@ static test_return noreply_test(memcached_st *memc)
 static test_return analyzer_test(memcached_st *memc)
 {
   memcached_return rc;
-  memcached_stat_st *stat;
+  memcached_stat_st *memc_stat;
   memcached_analysis_st *report;
 
-  stat= memcached_stat(memc, NULL, &rc);
+  memc_stat= memcached_stat(memc, NULL, &rc);
   assert(rc == MEMCACHED_SUCCESS);
-  assert(stat);
+  assert(memc_stat);
 
-  report= memcached_analyze(memc, stat, &rc);  
+  report= memcached_analyze(memc, memc_stat, &rc);  
   assert(rc == MEMCACHED_SUCCESS);
   assert(report);
 
   free(report);
-  memcached_stat_free(NULL, stat);
+  memcached_stat_free(NULL, memc_stat);
 
   return TEST_SUCCESS;
 }
@@ -3567,12 +3664,27 @@ 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);
 
+  /*
+  ** We are using the quiet commands to store the replicas, so we need
+  ** to ensure that all of them are processed before we can continue.
+  ** In the test we go directly from storing the object to trying to
+  ** receive the object from all of the different servers, so we
+  ** could end up in a race condition (the memcached server hasn't yet
+  ** processed the quiet command from the replication set when it process
+  ** the request from the other client (created by the clone)). As a
+  ** workaround for that we call memcached_quit to send the quit command
+  ** 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);
+
   /*
   ** "bubba" should now be stored on all of our servers. We don't have an
   ** easy to use API to address each individual server, so I'll just iterate
@@ -3584,14 +3696,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;
 }
@@ -3605,23 +3717,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 (int host= 0; host < memc->number_of_hosts; ++host) {
-    memcached_st *clone= memcached_clone(NULL, memc);
-    clone->hosts[host].port= 0;
+  for (uint32_t host= 0; host < memc->number_of_hosts; ++host) 
+  {
+    memcached_st *memc_clone= memcached_clone(NULL, memc);
+    memc_clone->hosts[host].port= 0;
 
     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;
@@ -3630,10 +3743,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)
@@ -3642,29 +3755,44 @@ static test_return replication_mget_test(memcached_st *memc)
     assert(rc == MEMCACHED_SUCCESS);
   }
 
+  /*
+  ** We are using the quiet commands to store the replicas, so we need
+  ** to ensure that all of them are processed before we can continue.
+  ** In the test we go directly from storing the object to trying to
+  ** receive the object from all of the different servers, so we
+  ** could end up in a race condition (the memcached server hasn't yet
+  ** processed the quiet command from the replication set when it process
+  ** the request from the other client (created by the clone)). As a
+  ** workaround for that we call memcached_quit to send the quit command
+  ** 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);
+
   /*
    * Don't do the following in your code. I am abusing the internal details
    * within the library, and this is not a supported interface.
    * This is to verify correct behavior in the library
    */
   memcached_result_st result_obj;
-  for (int host= 0; host < clone->number_of_hosts; ++host) 
+  for (uint32_t host= 0; host < memc_clone->number_of_hosts; host++) 
   {
-    memcached_st *clone= memcached_clone(NULL, memc);
-    clone->hosts[host].port= 0;
+    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(clone, key, 1, keys, len, 4);
+      rc= memcached_mget_by_key(new_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(new_clone, &result_obj);
       assert(results);
 
       int hits= 0;
-      while ((results= memcached_fetch_result(clone, &result_obj, &rc)) != NULL)
+      while ((results= memcached_fetch_result(new_clone, &result_obj, &rc)) != NULL)
       {
         hits++;
       }
@@ -3672,22 +3800,24 @@ static test_return replication_mget_test(memcached_st *memc)
       memcached_result_free(&result_obj);
     }
 
-    memcached_free(clone);
+    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)
@@ -3701,28 +3831,29 @@ static test_return replication_delete_test(memcached_st *memc)
    * within the library, and this is not a supported interface.
    * This is to verify correct behavior in the library
    */
-  int hash= memcached_generate_hash(memc, keys[0], len[0]);
-  for (int x= 0; x < (repl + 1); ++x) {
-    clone->hosts[hash].port= 0;
-    if (++hash == clone->number_of_hosts)
+  uint32_t hash= memcached_generate_hash(memc, keys[0], len[0]);
+  for (uint32_t x= 0; x < (repl + 1); ++x) 
+  {
+    memc_clone->hosts[hash].port= 0;
+    if (++hash == memc_clone->number_of_hosts)
       hash= 0;
   }
 
   memcached_result_st result_obj;
-  for (int 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;
       }
@@ -3730,7 +3861,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;
 }
@@ -3856,8 +3987,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;
@@ -3896,7 +4027,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),
@@ -3913,7 +4044,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;
@@ -3975,8 +4106,8 @@ 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";
+  const char *key= "incr";
+  const char *value= "1";
   rc= memcached_set(memc, key, strlen(key), 
                     value, strlen(value),
                     (time_t)0, (uint32_t)0);
@@ -3994,8 +4125,8 @@ 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";
+  const char *key= "decr";
+  const char *value= "1";
   rc= memcached_set(memc, key, strlen(key), 
                     value, strlen(value),
                     (time_t)0, (uint32_t)0);
@@ -4035,7 +4166,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);
@@ -4079,7 +4210,7 @@ static test_return hsieh_avaibility_test (memcached_st *memc)
   return TEST_SUCCESS;
 }
 
-static char *list[]=
+static const char *list[]=
 {
   "apple",
   "beat",
@@ -4112,12 +4243,14 @@ static char *list[]=
 static test_return md5_run (memcached_st *memc __attribute__((unused)))
 {
   uint32_t x;
-  char **ptr;
-  uint32_t values[]= {  3195025439, 2556848621, 3724893440, 3332385401, 245758794, 2550894432, 
-                        121710495, 3053817768, 1250994555, 1862072655, 2631955953, 2951528551, 
-                        1451250070, 2820856945, 2060845566, 3646985608, 2138080750, 217675895, 
-                        2230934345, 1234361223, 3968582726, 2455685270, 1293568479, 199067604, 
-                        2042482093 };
+  const char **ptr;
+  uint32_t values[]= {  3195025439U, 2556848621U, 3724893440U, 3332385401U,
+                        245758794U, 2550894432U, 121710495U, 3053817768U,
+                        1250994555U, 1862072655U, 2631955953U, 2951528551U, 
+                        1451250070U, 2820856945U, 2060845566U, 3646985608U,
+                        2138080750U, 217675895U, 2230934345U, 1234361223U,
+                        3968582726U, 2455685270U, 1293568479U, 199067604U, 
+                        2042482093U };
 
 
   for (ptr= list, x= 0; *ptr; ptr++, x++)
@@ -4134,10 +4267,11 @@ 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;
-  uint32_t values[]= {  10542, 22009, 14526, 19510, 19432, 10199, 20634, 9369, 11511, 10362,
-                        7893, 31289, 11313, 9354, 7621, 30628, 15218, 25967, 2695, 9380, 
-                        17300, 28156, 9192, 20484, 16925 };
+  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, 
+                        17300U, 28156U, 9192U, 20484U, 16925U };
 
   for (ptr= list, x= 0; *ptr; ptr++, x++)
   {
@@ -4153,12 +4287,14 @@ 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[]= {  473199127, 4148981457, 3971873300, 3257986707, 1722477987, 2991193800, 
-                        4147007314, 3633179701, 1805162104, 3503289120, 3395702895, 3325073042,
-                        2345265314, 3340346032, 2722964135, 1173398992, 2815549194, 2562818319,
-                        224996066, 2680194749, 3035305390, 246890365, 2395624193, 4145193337,
-                        1801941682 };
+  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, 
+                        3035305390U, 246890365U, 2395624193U, 4145193337U,
+                        1801941682U };
 
   for (ptr= list, x= 0; *ptr; ptr++, x++)
   {
@@ -4174,12 +4310,14 @@ 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[]= {  1488911807, 2500855813, 1510099634, 1390325195, 3647689787, 3241528582,
-                        1669328060, 2604311949, 734810122, 1516407546, 560948863, 1767346780,
-                        561034892, 4156330026, 3716417003, 3475297030, 1518272172, 227211583,
-                        3938128828, 126112909, 3043416448, 3131561933, 1328739897, 2455664041,
-                        2272238452 }; 
+  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, 
+                        3043416448U, 3131561933U, 1328739897U, 2455664041U,
+                        2272238452U }; 
 
   for (ptr= list, x= 0; *ptr; ptr++, x++)
   {
@@ -4195,11 +4333,14 @@ 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[]= {  67176023, 1190179409, 2043204404, 3221866419, 2567703427, 3787535528, 4147287986,
-                        3500475733, 344481048, 3865235296, 2181839183, 119581266, 510234242, 4248244304,
-                        1362796839, 103389328, 1449620010, 182962511, 3554262370, 3206747549, 1551306158,
-                        4127558461, 1889140833, 2774173721, 1180552018 };
+  const char **ptr;
+  uint32_t values[]= {  67176023U, 1190179409U, 2043204404U, 3221866419U, 
+                        2567703427U, 3787535528U, 4147287986U, 3500475733U,
+                        344481048U, 3865235296U, 2181839183U, 119581266U, 
+                        510234242U, 4248244304U, 1362796839U, 103389328U,
+                        1449620010U, 182962511U, 3554262370U, 3206747549U,
+                        1551306158U, 4127558461U, 1889140833U, 2774173721U,
+                        1180552018U };
 
 
   for (ptr= list, x= 0; *ptr; ptr++, x++)
@@ -4216,11 +4357,14 @@ 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;
-  uint32_t values[]= {  280767167, 2421315013, 3072375666, 855001899, 459261019, 3521085446, 18738364,
-                        1625305005, 2162232970, 777243802, 3323728671, 132336572, 3654473228, 260679466,
-                        1169454059, 2698319462, 1062177260, 235516991, 2218399068, 405302637, 1128467232,
-                        3579622413, 2138539289, 96429129, 2877453236 };
+  const char **ptr;
+  uint32_t values[]= {  280767167U, 2421315013U, 3072375666U, 855001899U,
+                        459261019U, 3521085446U, 18738364U, 1625305005U,
+                        2162232970U, 777243802U, 3323728671U, 132336572U,
+                        3654473228U, 260679466U, 1169454059U, 2698319462U,
+                        1062177260U, 235516991U, 2218399068U, 405302637U,
+                        1128467232U, 3579622413U, 2138539289U, 96429129U,
+                        2877453236U };
 
   for (ptr= list, x= 0; *ptr; ptr++, x++)
   {
@@ -4236,7 +4380,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,
@@ -4261,12 +4405,14 @@ 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;
-  uint32_t values[]= { 473199127, 4148981457, 3971873300, 3257986707, 1722477987, 2991193800,
-                        4147007314, 3633179701, 1805162104, 3503289120, 3395702895, 3325073042,
-                        2345265314, 3340346032, 2722964135, 1173398992, 2815549194, 2562818319,
-                        224996066, 2680194749, 3035305390, 246890365, 2395624193, 4145193337,
-                        1801941682 };
+  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,
+                       3035305390U, 246890365U, 2395624193U, 4145193337U,
+                       1801941682U };
 
   for (ptr= list, x= 0; *ptr; ptr++, x++)
   {
@@ -4282,12 +4428,14 @@ 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;
-  uint32_t values[]= {  1442444624, 4253821186, 1885058256, 2120131735, 3261968576, 3515188778,
-                        4232909173, 4288625128, 1812047395, 3689182164, 2502979932, 1214050606,
-                        2415988847, 1494268927, 1025545760, 3920481083, 4153263658, 3824871822,
-                        3072759809, 798622255, 3065432577, 1453328165, 2691550971, 3408888387,
-                        2629893356 };
+  const char **ptr;
+  uint32_t values[]= {  1442444624U, 4253821186U, 1885058256U, 2120131735U,
+                        3261968576U, 3515188778U, 4232909173U, 4288625128U,
+                        1812047395U, 3689182164U, 2502979932U, 1214050606U,
+                        2415988847U, 1494268927U, 1025545760U, 3920481083U,
+                        4153263658U, 3824871822U, 3072759809U, 798622255U,
+                        3065432577U, 1453328165U, 2691550971U, 3408888387U,
+                        2629893356U };
 
 
   for (ptr= list, x= 0; *ptr; ptr++, x++)
@@ -4363,6 +4511,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 },
@@ -4536,7 +4685,9 @@ collection_st collection[] ={
   {"poll_timeout", poll_timeout, 0, tests},
   {"gets", enable_cas, 0, tests},
   {"consistent", enable_consistent, 0, tests},
+#ifdef MEMCACHED_ENABLE_DEPRECATED
   {"deprecated_memory_allocators", deprecated_set_memory_alloc, 0, tests},
+#endif
   {"memory_allocators", set_memory_alloc, 0, tests},
   {"prefix", set_prefix, 0, tests},
   {"version_1_2_3", check_for_1_2_3, 0, version_1_2_3},
@@ -4558,6 +4709,7 @@ collection_st collection[] ={
   {"consistent_ketama_weighted", pre_behavior_ketama_weighted, 0, consistent_weighted_tests},
   {"test_hashes", 0, 0, hash_tests},
   {"replication", pre_replication, 0, replication_tests},
+  {"replication_noblock", pre_replication_noblock, 0, replication_tests},
   {0, 0, 0, 0}
 };