X-Git-Url: https://git.m6w6.name/?a=blobdiff_plain;f=tests%2Fmem_functions.cc;h=14141a0b4e95ac0da50eed997541ef972139838b;hb=6dab5e4d5dfb6145966a3efa48a41cf7e609c9ad;hp=dd5a25690a3e10a788fec6a5adf1ca1c829a37e3;hpb=b205590481ac80ab64ddf5025e995e0a3d0acc1d;p=awesomized%2Flibmemcached

diff --git a/tests/mem_functions.cc b/tests/mem_functions.cc
index dd5a2569..14141a0b 100644
--- a/tests/mem_functions.cc
+++ b/tests/mem_functions.cc
@@ -37,18 +37,16 @@
 
 
 /*
-  Sample test application.
+  Test cases
 */
 
-#include "config.h"
+#define BUILDING_LIBMEMCACHED
+// !NEVER use common.h, always use memcached.h in your own apps
+#include <libmemcached/common.h>
 
 #include <stdint.h>
 
 #include <cassert>
-#include <cstdio>
-#include <cstdlib>
-#include <cstring>
-#include <ctime>
 #include <memory>
 #include <signal.h>
 #include <sys/stat.h>
@@ -56,8 +54,6 @@
 #include <sys/types.h>
 #include <unistd.h>
 
-#include "libmemcached/common.h"
-
 #include <libtest/server.h>
 
 #include "clients/generator.h"
@@ -212,11 +208,15 @@ static test_return_t server_sort2_test(memcached_st *ptr)
   return TEST_SUCCESS;
 }
 
-static test_return_t memcached_server_remove_test(memcached_st *ptr)
+static test_return_t memcached_server_remove_test(memcached_st*)
 {
   const char *server_string= "--server=localhost:4444 --server=localhost:4445 --server=localhost:4446 --server=localhost:4447 --server=localhost --server=memcache1.memcache.bk.sapo.pt:11211 --server=memcache1.memcache.bk.sapo.pt:11212 --server=memcache1.memcache.bk.sapo.pt:11213 --server=memcache1.memcache.bk.sapo.pt:11214 --server=memcache2.memcache.bk.sapo.pt:11211 --server=memcache2.memcache.bk.sapo.pt:11212 --server=memcache2.memcache.bk.sapo.pt:11213 --server=memcache2.memcache.bk.sapo.pt:11214";
-  (void)ptr;
+  char buffer[BUFSIZ];
 
+  memcached_return_t rc;
+  test_compare_got(MEMCACHED_SUCCESS,
+                   rc= libmemcached_check_configuration(server_string, strlen(server_string), buffer, sizeof(buffer)),
+                   memcached_strerror(NULL, rc));
   memcached_st *memc= memcached(server_string, strlen(server_string));
   test_true(memc);
 
@@ -229,13 +229,12 @@ static test_return_t memcached_server_remove_test(memcached_st *ptr)
   return TEST_SUCCESS;
 }
 
-static memcached_return_t server_display_unsort_function(const memcached_st *ptr,
+static memcached_return_t server_display_unsort_function(const memcached_st*,
                                                          const memcached_server_st *server,
                                                          void *context)
 {
   /* Do Nothing */
   uint32_t x= *((uint32_t *)(context));
-  (void)ptr;
 
   if (! (test_ports[x] == server->port))
   {
@@ -399,9 +398,31 @@ static test_return_t connection_test(memcached_st *memc)
   return TEST_SUCCESS;
 }
 
+static test_return_t libmemcached_string_behavior_test(memcached_st *)
+{
+  for (int x= MEMCACHED_BEHAVIOR_NO_BLOCK; x < int(MEMCACHED_BEHAVIOR_MAX); ++x)
+  {
+    test_true(libmemcached_string_behavior(memcached_behavior_t(x)));
+  }
+  test_compare(36, MEMCACHED_BEHAVIOR_MAX);
+
+  return TEST_SUCCESS;
+}
+
+static test_return_t libmemcached_string_distribution_test(memcached_st *)
+{
+  for (int x= MEMCACHED_DISTRIBUTION_MODULA; x < int(MEMCACHED_DISTRIBUTION_CONSISTENT_MAX); ++x)
+  {
+    test_true(libmemcached_string_distribution(memcached_server_distribution_t(x)));
+  }
+  test_compare(7, MEMCACHED_DISTRIBUTION_CONSISTENT_MAX);
+
+  return TEST_SUCCESS;
+}
+
 static test_return_t error_test(memcached_st *memc)
 {
-  uint32_t values[] = { 851992627U, 2337886783U, 3196981036U, 4001849190U,
+  uint32_t values[] = { 851992627U, 2337886783U, 646418395U, 4001849190U,
                         982370485U, 1263635348U, 4242906218U, 3829656100U,
                         1891735253U, 334139633U, 2257084983U, 3088286104U,
                         13199785U, 2542027183U, 1097051614U, 199566778U,
@@ -435,13 +456,10 @@ static test_return_t error_test(memcached_st *memc)
 
 static test_return_t set_test(memcached_st *memc)
 {
-  memcached_return_t rc;
-  const char *key= "foo";
-  const char *value= "when we sanitize";
-
-  rc= memcached_set(memc, key, strlen(key),
-                    value, strlen(value),
-                    (time_t)0, (uint32_t)0);
+  memcached_return_t rc= memcached_set(memc,
+                                       memcached_literal_param("foo"),
+                                       memcached_literal_param("when we sanitize"),
+                                       time_t(0), (uint32_t)0);
   test_true(rc == MEMCACHED_SUCCESS || rc == MEMCACHED_BUFFERED);
 
   return TEST_SUCCESS;
@@ -2117,7 +2135,7 @@ static test_return_t fetch_all_results(memcached_st *memc, size_t *keys_returned
     *keys_returned= *keys_returned +1;
   }
 
-  test_true_got(rc == MEMCACHED_END || rc == MEMCACHED_SUCCESS, memcached_strerror(NULL, rc));
+  test_true_got(rc == MEMCACHED_END || memcached_success(rc), memcached_strerror(NULL, rc));
 
   return TEST_SUCCESS;
 }
@@ -2547,10 +2565,9 @@ static test_return_t user_supplied_bug9(memcached_st *memc)
 
   for (unsigned int x= 0; x < 3; x++)
   {
-    memcached_return_t rc;
-    rc= memcached_set(memc, keys[x], key_length[x],
-                      keys[x], key_length[x],
-                      (time_t)50, (uint32_t)9);
+    memcached_return_t rc= memcached_set(memc, keys[x], key_length[x],
+                                         keys[x], key_length[x],
+                                         (time_t)50, (uint32_t)9);
     test_true(rc == MEMCACHED_SUCCESS);
   }
 
@@ -2559,13 +2576,13 @@ static test_return_t user_supplied_bug9(memcached_st *memc)
 
   /* We need to empty the server before continueing test */
   while ((return_value= memcached_fetch(memc, return_key, &return_key_length,
-                      &return_value_length, &flags, &rc)) != NULL)
+                                        &return_value_length, &flags, &rc)) != NULL)
   {
     test_true(return_value);
     free(return_value);
     count++;
   }
-  test_true(count == 3);
+  test_compare(3, count);
 
   return TEST_SUCCESS;
 }
@@ -2725,7 +2742,7 @@ static test_return_t user_supplied_bug13(memcached_st *memc)
     rc= memcached_set(memc, key, strlen(key),
                       overflow, testSize, 0, 0);
     test_true(rc == MEMCACHED_SUCCESS);
-    delete overflow;
+    delete [] overflow;
   }
 
   return TEST_SUCCESS;
@@ -3016,28 +3033,23 @@ static test_return_t _user_supplied_bug21(memcached_st* memc, size_t key_count)
   (void)key_count;
   return TEST_SKIPPED;
 #else
-  memcached_return_t rc;
-  unsigned int x;
-  char **keys;
-  size_t* key_lengths;
   void (*oldalarm)(int);
-  memcached_st *memc_clone;
 
-  memc_clone= memcached_clone(NULL, memc);
+  memcached_st *memc_clone= memcached_clone(NULL, memc);
   test_true(memc_clone);
 
   /* only binproto uses getq for mget */
   memcached_behavior_set(memc_clone, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL, 1);
 
   /* empty the cache to ensure misses (hence non-responses) */
-  rc= memcached_flush(memc_clone, 0);
+  memcached_return_t rc= memcached_flush(memc_clone, 0);
   test_true(rc == MEMCACHED_SUCCESS);
 
-  key_lengths= new (std::nothrow) size_t[key_count];
+  size_t* key_lengths= new (std::nothrow) size_t[key_count];
   test_true(key_lengths);
-  keys= static_cast<char **>(calloc(key_count, sizeof(char *)));
+  char **keys= static_cast<char **>(calloc(key_count, sizeof(char *)));
   test_true(keys);
-  for (x= 0; x < key_count; x++)
+  for (unsigned int x= 0; x < key_count; x++)
   {
     char buffer[30];
 
@@ -3049,8 +3061,7 @@ static test_return_t _user_supplied_bug21(memcached_st* memc, size_t key_count)
   oldalarm= signal(SIGALRM, fail);
   alarm(5);
 
-  rc= memcached_mget(memc_clone, (const char **)keys, key_lengths, key_count);
-  test_true(rc == MEMCACHED_SUCCESS);
+  test_true_got(memcached_success(memcached_mget(memc_clone, (const char **)keys, key_lengths, key_count)), memcached_last_error_message(memc_clone));
 
   alarm(0);
   signal(SIGALRM, oldalarm);
@@ -3058,10 +3069,12 @@ static test_return_t _user_supplied_bug21(memcached_st* memc, size_t key_count)
   size_t keys_returned;
   test_true(fetch_all_results(memc, &keys_returned) == TEST_SUCCESS);
 
-  for (x= 0; x < key_count; x++)
+  for (unsigned int x= 0; x < key_count; x++)
+  {
     free(keys[x]);
+  }
   free(keys);
-  delete key_lengths;
+  delete [] key_lengths;
 
   memcached_free(memc_clone);
 
@@ -3284,9 +3297,8 @@ static test_return_t generate_pairs(memcached_st *memc)
   return TEST_SUCCESS;
 }
 
-static test_return_t generate_large_pairs(memcached_st *memc)
+static test_return_t generate_large_pairs(memcached_st *)
 {
-  (void)memc;
   global_pairs= pairs_generate(GLOBAL2_COUNT, MEMCACHED_MAX_BUFFER+10);
   global_count= GLOBAL2_COUNT;
 
@@ -3310,15 +3322,14 @@ static test_return_t generate_data(memcached_st *memc)
 
 static test_return_t generate_data_with_stats(memcached_st *memc)
 {
-  memcached_stat_st *stat_p;
-  memcached_return_t rc;
   uint32_t host_index= 0;
   unsigned int check_execute= execute_set(memc, global_pairs, global_count);
 
   test_true(check_execute == global_count);
 
-  //TODO: hosts used size stats
-  stat_p= memcached_stat(memc, NULL, &rc);
+  // @todo hosts used size stats
+  memcached_return_t rc;
+  memcached_stat_st *stat_p= memcached_stat(memc, NULL, &rc);
   test_true(stat_p);
 
   for (host_index= 0; host_index < SERVERS_TO_CREATE; host_index++)
@@ -3350,10 +3361,7 @@ static test_return_t generate_buffer_data(memcached_st *memc)
 
 static test_return_t get_read_count(memcached_st *memc)
 {
-  memcached_return_t rc;
-  memcached_st *memc_clone;
-
-  memc_clone= memcached_clone(NULL, memc);
+  memcached_st *memc_clone= memcached_clone(NULL, memc);
   test_true(memc_clone);
 
   memcached_server_add_with_weight(memc_clone, "localhost", 6666, 0);
@@ -3366,6 +3374,7 @@ static test_return_t get_read_count(memcached_st *memc)
 
     for (size_t x= count= 0; x < global_count; x++)
     {
+      memcached_return_t rc;
       return_value= memcached_get(memc_clone, global_keys[x], global_keys_length[x],
                                   &return_value_length, &flags, &rc);
       if (rc == MEMCACHED_SUCCESS)
@@ -3384,24 +3393,19 @@ static test_return_t get_read_count(memcached_st *memc)
 
 static test_return_t get_read(memcached_st *memc)
 {
-  memcached_return_t rc;
-
+  for (size_t x= 0; x < global_count; x++)
   {
-    char *return_value;
     size_t return_value_length;
     uint32_t flags;
-
-    for (size_t x= 0; x < global_count; x++)
-    {
-      return_value= memcached_get(memc, global_keys[x], global_keys_length[x],
-                                  &return_value_length, &flags, &rc);
-      /*
+    memcached_return_t rc;
+    char *return_value= memcached_get(memc, global_keys[x], global_keys_length[x],
+                                      &return_value_length, &flags, &rc);
+    /*
       test_true(return_value);
       test_true(rc == MEMCACHED_SUCCESS);
     */
-      if (rc == MEMCACHED_SUCCESS && return_value)
-        free(return_value);
-    }
+    if (rc == MEMCACHED_SUCCESS && return_value)
+      free(return_value);
   }
 
   return TEST_SUCCESS;
@@ -3409,14 +3413,13 @@ static test_return_t get_read(memcached_st *memc)
 
 static test_return_t mget_read(memcached_st *memc)
 {
-  memcached_return_t rc;
 
-  if (! libmemcached_util_version_check(memc, 1, 4, 4))
+  if (not libmemcached_util_version_check(memc, 1, 4, 4))
     return TEST_SKIPPED;
 
-  rc= memcached_mget(memc, global_keys, global_keys_length, global_count);
+  memcached_return_t rc= memcached_mget(memc, global_keys, global_keys_length, global_count);
 
-  test_true_got(rc == MEMCACHED_SUCCESS, memcached_strerror(NULL, rc));
+  test_true_got(memcached_success(rc), memcached_strerror(NULL, rc));
 
   // Go fetch the keys and test to see if all of them were returned
   {
@@ -3433,21 +3436,18 @@ static test_return_t mget_read(memcached_st *memc)
 
 static test_return_t mget_read_result(memcached_st *memc)
 {
-  memcached_return_t rc;
 
-  if (! libmemcached_util_version_check(memc, 1, 4, 4))
+  if (not libmemcached_util_version_check(memc, 1, 4, 4))
     return TEST_SKIPPED;
 
-  rc= memcached_mget(memc, global_keys, global_keys_length, global_count);
+  memcached_return_t rc= memcached_mget(memc, global_keys, global_keys_length, global_count);
 
-  test_true_got(rc == MEMCACHED_SUCCESS, memcached_strerror(NULL, rc));
+  test_true_got(memcached_success(rc), memcached_strerror(NULL, rc));
 
   /* Turn this into a help function */
   {
     memcached_result_st results_obj;
-    memcached_result_st *results;
-
-    results= memcached_result_create(memc, &results_obj);
+    memcached_result_st *results= memcached_result_create(memc, &results_obj);
 
     while ((results= memcached_fetch_result(memc, &results_obj, &rc)))
     {
@@ -3463,19 +3463,16 @@ static test_return_t mget_read_result(memcached_st *memc)
 
 static test_return_t mget_read_function(memcached_st *memc)
 {
-  memcached_return_t rc;
-  size_t counter;
-  memcached_execute_fn callbacks[1];
 
-  if (! libmemcached_util_version_check(memc, 1, 4, 4))
+  if (not libmemcached_util_version_check(memc, 1, 4, 4))
     return TEST_SKIPPED;
 
-  rc= memcached_mget(memc, global_keys, global_keys_length, global_count);
+  memcached_return_t rc= memcached_mget(memc, global_keys, global_keys_length, global_count);
 
-  test_true_got(rc == MEMCACHED_SUCCESS, memcached_strerror(NULL, rc));
+  test_true_got(memcached_success(rc), memcached_strerror(NULL, rc));
 
-  callbacks[0]= &callback_counter;
-  counter= 0;
+  memcached_execute_fn callbacks[]= { &callback_counter };
+  size_t counter= 0;
   rc= memcached_fetch_execute(memc, callbacks, (void *)&counter, 1);
 
   return TEST_SUCCESS;
@@ -3493,9 +3490,7 @@ static test_return_t delete_generate(memcached_st *memc)
 
 static test_return_t delete_buffer_generate(memcached_st *memc)
 {
-  uint64_t latch= 0;
-
-  latch= 1;
+  uint64_t latch= 1;
   memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_BUFFER_REQUESTS, latch);
 
   for (size_t x= 0; x < global_count; x++)
@@ -3510,11 +3505,10 @@ static test_return_t add_host_test1(memcached_st *memc)
 {
   memcached_return_t rc;
   char servername[]= "0.example.com";
-  memcached_server_st *servers;
 
-  servers= memcached_server_list_append_with_weight(NULL, servername, 400, 0, &rc);
+  memcached_server_st *servers= memcached_server_list_append_with_weight(NULL, servername, 400, 0, &rc);
   test_true(servers);
-  test_true(1 == memcached_server_list_count(servers));
+  test_compare(1, memcached_server_list_count(servers));
 
   for (size_t x= 2; x < 20; x++)
   {
@@ -3523,14 +3517,12 @@ static test_return_t add_host_test1(memcached_st *memc)
     snprintf(buffer, SMALL_STRING_LEN, "%lu.example.com", (unsigned long)(400 +x));
     servers= memcached_server_list_append_with_weight(servers, buffer, 401, 0,
                                      &rc);
-    test_true(rc == MEMCACHED_SUCCESS);
-    test_true(x == memcached_server_list_count(servers));
+    test_compare(MEMCACHED_SUCCESS, rc);
+    test_compare(x, memcached_server_list_count(servers));
   }
 
-  rc= memcached_server_push(memc, servers);
-  test_true(rc == MEMCACHED_SUCCESS);
-  rc= memcached_server_push(memc, servers);
-  test_true(rc == MEMCACHED_SUCCESS);
+  test_compare(MEMCACHED_SUCCESS, memcached_server_push(memc, servers));
+  test_compare(MEMCACHED_SUCCESS, memcached_server_push(memc, servers));
 
   memcached_server_list_free(servers);
 
@@ -3546,16 +3538,11 @@ static test_return_t pre_nonblock(memcached_st *memc)
 
 static test_return_t pre_cork(memcached_st *memc)
 {
-  memcached_return_t rc;
-  bool set= true;
-
-  rc= memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_CORK, set);
-
 #ifdef __APPLE__
   return TEST_SKIPPED;
 #endif
-
-  if (rc == MEMCACHED_SUCCESS)
+  bool set= true;
+  if (memcached_success(memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_CORK, set)))
     return TEST_SUCCESS;
 
   return TEST_SKIPPED;
@@ -3563,16 +3550,12 @@ static test_return_t pre_cork(memcached_st *memc)
 
 static test_return_t pre_cork_and_nonblock(memcached_st *memc)
 {
-  test_return_t rc;
-
-  rc= pre_cork(memc);
-
 #ifdef __APPLE__
   return TEST_SKIPPED;
 #endif
-
-  if (rc != TEST_SUCCESS)
-    return rc;
+  test_return_t test_rc;
+  if ((test_rc= pre_cork(memc)) != TEST_SUCCESS)
+    return test_rc;
 
   return pre_nonblock(memc);
 }
@@ -3679,13 +3662,10 @@ static test_return_t pre_hash_fnv1a_32(memcached_st *memc)
 
 static test_return_t pre_behavior_ketama(memcached_st *memc)
 {
-  memcached_return_t rc;
-  uint64_t value;
-
-  rc= memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_KETAMA, 1);
+  memcached_return_t rc= memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_KETAMA, 1);
   test_true(rc == MEMCACHED_SUCCESS);
 
-  value= memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_KETAMA);
+  uint64_t value= memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_KETAMA);
   test_true(value == 1);
 
   return TEST_SUCCESS;
@@ -3693,13 +3673,10 @@ static test_return_t pre_behavior_ketama(memcached_st *memc)
 
 static test_return_t pre_behavior_ketama_weighted(memcached_st *memc)
 {
-  memcached_return_t rc;
-  uint64_t value;
-
-  rc= memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_KETAMA_WEIGHTED, 1);
+  memcached_return_t rc= memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_KETAMA_WEIGHTED, 1);
   test_true(rc == MEMCACHED_SUCCESS);
 
-  value= memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_KETAMA_WEIGHTED);
+  uint64_t value= memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_KETAMA_WEIGHTED);
   test_true(value == 1);
 
   rc= memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_KETAMA_HASH, MEMCACHED_HASH_MD5);
@@ -3737,10 +3714,10 @@ static test_return_t pre_sasl(memcached_st *memc)
   const char *user= getenv("LIBMEMCACHED_TEST_SASL_USERNAME");
   const char *pass= getenv("LIBMEMCACHED_TEST_SASL_PASSWORD");
 
-  if (server != NULL && user != NULL && pass != NULL)
+  if (server and user and pass)
   {
     memcached_server_st *servers= memcached_servers_parse(server);
-    test_true(servers != NULL);
+    test_true(servers);
     memcached_servers_reset(memc);
     test_true(memcached_server_push(memc, servers) == MEMCACHED_SUCCESS);
     memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL, 1);
@@ -3756,19 +3733,14 @@ static test_return_t pre_sasl(memcached_st *memc)
 
 static test_return_t pre_replication(memcached_st *memc)
 {
-  test_return_t test_rc;
-  test_rc= pre_binary(memc);
-
-  if (test_rc != TEST_SUCCESS)
-    return test_rc;
+  test_true(TEST_SUCCESS == pre_binary(memc));
 
   /*
    * Make sure that we store the item on all servers
    * (master + replicas == number of servers)
    */
-  memcached_return_t rc;
-  rc= memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_NUMBER_OF_REPLICAS,
-                             memcached_server_count(memc) - 1);
+  memcached_return_t rc= memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_NUMBER_OF_REPLICAS,
+                                                memcached_server_count(memc) - 1);
   test_true(rc == MEMCACHED_SUCCESS);
   test_true(memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_NUMBER_OF_REPLICAS) == memcached_server_count(memc) - 1);
 
@@ -3778,15 +3750,9 @@ static test_return_t pre_replication(memcached_st *memc)
 
 static test_return_t pre_replication_noblock(memcached_st *memc)
 {
-  test_return_t rc;
-
-  rc= pre_replication(memc);
-  if (rc != TEST_SUCCESS)
-    return rc;
-
-  rc= pre_nonblock(memc);
+  test_compare(TEST_SUCCESS, pre_replication(memc));
 
-  return rc;
+  return pre_nonblock(memc);
 }
 
 
@@ -3826,9 +3792,8 @@ static void *my_malloc(const memcached_st *ptr, const size_t size, void *context
 }
 
 
-static void *my_realloc(const memcached_st *ptr, void *mem, const size_t size, void *context)
+static void *my_realloc(const memcached_st *ptr, void *mem, const size_t size, void *)
 {
-  (void)context;
 #ifdef HARD_MALLOC_TESTS
   void *real_ptr= (mem == NULL) ? NULL : (void*)((caddr_t)mem - 8);
   void *nmem= realloc(real_ptr, size + 8);
@@ -3847,9 +3812,8 @@ static void *my_realloc(const memcached_st *ptr, void *mem, const size_t size, v
 }
 
 
-static void *my_calloc(const memcached_st *ptr, size_t nelem, const size_t size, void *context)
+static void *my_calloc(const memcached_st *ptr, size_t nelem, const size_t size, void *)
 {
-  (void)context;
 #ifdef HARD_MALLOC_TESTS
   void *mem= my_malloc(ptr, nelem * size);
   if (mem)
@@ -4304,7 +4268,6 @@ static memcached_return_t callback_dump_counter(const memcached_st *ptr,
 
 static test_return_t dump_test(memcached_st *memc)
 {
-  memcached_return_t rc;
   size_t counter= 0;
   memcached_dump_fn callbacks[1];
   test_return_t main_rc;
@@ -4319,7 +4282,7 @@ static test_return_t dump_test(memcached_st *memc)
 
   test_true (main_rc == TEST_SUCCESS);
 
-  rc= memcached_dump(memc, callbacks, (void *)&counter, 1);
+  memcached_return_t rc= memcached_dump(memc, callbacks, (void *)&counter, 1);
   test_true(rc == MEMCACHED_SUCCESS);
 
   /* We may have more then 32 if our previous flush has not completed */
@@ -5417,13 +5380,14 @@ static test_return_t test_get_last_disconnect(memcached_st *memc)
   const char *value= "milka";
 
   memcached_reset_last_disconnected_server(memc);
+  test_false(memc->last_disconnected_server);
   rc= memcached_set(memc, key, strlen(key),
                     value, strlen(value),
                     (time_t)0, (uint32_t)0);
   test_true(rc == MEMCACHED_SUCCESS || rc == MEMCACHED_BUFFERED);
 
   disconnected_server = memcached_server_get_last_disconnect(memc);
-  test_true(disconnected_server == NULL);
+  test_false(disconnected_server);
 
   /* With a non existing server */
   memcached_st *mine;
@@ -5442,16 +5406,11 @@ static test_return_t test_get_last_disconnect(memcached_st *memc)
   rc= memcached_set(mine, key, strlen(key),
                     value, strlen(value),
                     (time_t)0, (uint32_t)0);
-  test_true(rc != MEMCACHED_SUCCESS);
+  test_true(memcached_failed(rc));
 
   disconnected_server= memcached_server_get_last_disconnect(mine);
-  if (disconnected_server == NULL)
-  {
-    fprintf(stderr, "RC %s\n", memcached_strerror(mine, rc));
-    abort();
-  }
-  test_true(disconnected_server != NULL);
-  test_true(memcached_server_port(disconnected_server)== 9);
+  test_true_got(disconnected_server, memcached_strerror(mine, rc));
+  test_compare(9, memcached_server_port(disconnected_server));
   test_true(strncmp(memcached_server_name(disconnected_server),"localhost",9) == 0);
 
   memcached_quit(mine);
@@ -5460,6 +5419,46 @@ static test_return_t test_get_last_disconnect(memcached_st *memc)
   return TEST_SUCCESS;
 }
 
+static test_return_t test_multiple_get_last_disconnect(memcached_st *)
+{
+  const char *server_string= "--server=localhost:8888 --server=localhost:8889 --server=localhost:8890 --server=localhost:8891 --server=localhost:8892";
+  char buffer[BUFSIZ];
+
+  memcached_return_t rc;
+  test_compare_got(MEMCACHED_SUCCESS,
+                   rc= libmemcached_check_configuration(server_string, strlen(server_string), buffer, sizeof(buffer)),
+                   memcached_strerror(NULL, rc));
+
+  memcached_st *memc= memcached(server_string, strlen(server_string));
+  test_true(memc);
+
+  // We will just use the error strings as our keys
+  uint32_t counter= 100;
+  while (--counter)
+  {
+    for (int x= int(MEMCACHED_SUCCESS); x < int(MEMCACHED_MAXIMUM_RETURN); ++x)
+    {
+      const char *msg=  memcached_strerror(memc, memcached_return_t(x));
+      memcached_return_t ret= memcached_set(memc, msg, strlen(msg), NULL, 0, (time_t)0, (uint32_t)0);
+      test_compare_got(MEMCACHED_WRITE_FAILURE, ret, memcached_strerror(NULL, ret));
+
+      memcached_server_instance_st disconnected_server= memcached_server_get_last_disconnect(memc);
+      test_true(disconnected_server);
+      test_strcmp("localhost", memcached_server_name(disconnected_server));
+      test_true(memcached_server_port(disconnected_server) >= 8888 and memcached_server_port(disconnected_server) <= 8892);
+
+      if (random() % 2)
+      {
+        memcached_reset_last_disconnected_server(memc);
+      }
+    }
+  }
+
+  memcached_free(memc);
+
+  return TEST_SUCCESS;
+}
+
 static test_return_t test_verbosity(memcached_st *memc)
 {
   memcached_verbosity(memc, 3);
@@ -5762,38 +5761,36 @@ static test_return_t regression_bug_490486(memcached_st *memc)
   return TEST_SUCCESS;
 }
 
-static test_return_t regression_bug_583031(memcached_st *unused)
+static test_return_t regression_bug_583031(memcached_st *)
 {
-  (void)unused;
-
-    memcached_st *memc= memcached_create(NULL);
-    assert(memc);
-    memcached_server_add(memc, "10.2.3.4", 11211);
+  memcached_st *memc= memcached_create(NULL);
+  test_true(memc);
+  test_true(memcached_success(memcached_server_add(memc, "10.2.3.4", 11211)));
 
-    memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_CONNECT_TIMEOUT, 1000);
-    memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_RETRY_TIMEOUT, 1000);
-    memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_SND_TIMEOUT, 1000);
-    memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_RCV_TIMEOUT, 1000);
-    memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_POLL_TIMEOUT, 1000);
-    memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_SERVER_FAILURE_LIMIT, 3);
+  memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_CONNECT_TIMEOUT, 1000);
+  memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_RETRY_TIMEOUT, 1000);
+  memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_SND_TIMEOUT, 1000);
+  memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_RCV_TIMEOUT, 1000);
+  memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_POLL_TIMEOUT, 1000);
+  memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_SERVER_FAILURE_LIMIT, 3);
 
-    memcached_return_t rc;
-    size_t length;
-    uint32_t flags;
+  memcached_return_t rc;
+  size_t length;
+  uint32_t flags;
 
-    (void)memcached_get(memc, "dsf", 3, &length, &flags, &rc);
+  const char *value= memcached_get(memc, "dsf", 3, &length, &flags, &rc);
+  test_false(value);
+  test_compare(0, length);
 
-    test_true_got(rc == MEMCACHED_TIMEOUT || rc == MEMCACHED_ERRNO || rc == MEMCACHED_FAILURE, memcached_strerror(memc, rc));
+  test_true_got(rc == MEMCACHED_TIMEOUT || rc == MEMCACHED_ERRNO || rc == MEMCACHED_FAILURE, memcached_strerror(memc, rc));
 
-    memcached_free(memc);
+  memcached_free(memc);
 
-    return TEST_SUCCESS;
+  return TEST_SUCCESS;
 }
 
-static test_return_t regression_bug_581030(memcached_st *unused)
+static test_return_t regression_bug_581030(memcached_st *)
 {
-  (void)unused;
-
 #ifndef DEBUG
   memcached_stat_st *local_stat= memcached_stat(NULL, NULL, NULL);
   test_false(local_stat);
@@ -6015,6 +6012,8 @@ test_st tests[] ={
 };
 
 test_st behavior_tests[] ={
+  {"libmemcached_string_behavior()", 0, (test_callback_fn)libmemcached_string_behavior_test},
+  {"libmemcached_string_distribution()", 0, (test_callback_fn)libmemcached_string_distribution_test},
   {"behavior_test", 0, (test_callback_fn)behavior_test},
   {"MEMCACHED_BEHAVIOR_CORK", 0, (test_callback_fn)MEMCACHED_BEHAVIOR_CORK_test},
   {"MEMCACHED_BEHAVIOR_TCP_KEEPALIVE", 0, (test_callback_fn)MEMCACHED_BEHAVIOR_TCP_KEEPALIVE_test},
@@ -6054,6 +6053,12 @@ test_st string_tests[] ={
   {0, 0, (test_callback_fn)0}
 };
 
+test_st memcached_server_get_last_disconnect_tests[] ={
+  {"memcached_server_get_last_disconnect()", 0, (test_callback_fn)test_multiple_get_last_disconnect},
+  {0, 0, (test_callback_fn)0}
+};
+
+
 test_st result_tests[] ={
   {"result static", 0, (test_callback_fn)result_static},
   {"result alloc", 0, (test_callback_fn)result_alloc},
@@ -6245,6 +6250,7 @@ test_st parser_tests[] ={
   {"server", 0, (test_callback_fn)server_test },
   {"bad server strings", 0, (test_callback_fn)servers_bad_test },
   {"server with weights", 0, (test_callback_fn)server_with_weight_test },
+  {"parsing servername, port, and weight", 0, (test_callback_fn)test_hostname_port_weight },
   {0, 0, (test_callback_fn)0}
 };
 
@@ -6318,6 +6324,7 @@ collection_st collection[] ={
   {"error_conditions", 0, 0, error_conditions},
   {"parser", 0, 0, parser_tests},
   {"virtual buckets", 0, 0, virtual_bucket_tests},
+  {"memcached_server_get_last_disconnect", 0, 0, memcached_server_get_last_disconnect_tests},
   {0, 0, 0, 0}
 };