Merge

diff --git a/.bzrignore b/.bzrignore
index dbe3e8943e3ec736662fdf864b90187e76e5abcf..b9bd9e5342a54626b6e98c3c4085599e83ce7366 100644 (file)
--- a/.bzrignore
+++ b/.bzrignore
@@ -85,11 +85,7 @@ libtest/unittest
 libtest/version.h
 libtest/wait
 libtool
-libtool.m4
-ltoptions.m4
-ltsugar.m4
-ltversion.m4
-lt~obsolete.m4
+m4/libtool.m4
 m4/libtool.m4 
 m4/ltoptions.m4
 m4/ltsugar.m4

diff --git a/libmemcached/result.cc b/libmemcached/result.cc
index 851337f30facf159c5fe0b59fbbd43587f44bc30..1a5095af5c349a921625cfe4c5651ee9e633954b 100644 (file)
--- a/libmemcached/result.cc
+++ b/libmemcached/result.cc
@@ -101,8 +101,10 @@ void memcached_result_reset(memcached_result_st *ptr)
 
 void memcached_result_free(memcached_result_st *ptr)
 {
-  if (not ptr)
+  if (ptr == NULL)
+  {
     return;
+  }
 
   memcached_string_free(&ptr->value);
 

diff --git a/libmemcached/virtual_bucket.c b/libmemcached/virtual_bucket.c
index f91bf4549f089ec887312d186cb54ab9f0d96a7a..8af3a72fdca656c5a85abf9c62877fb29d93179f 100644 (file)
--- a/libmemcached/virtual_bucket.c
+++ b/libmemcached/virtual_bucket.c
@@ -35,7 +35,6 @@
  *
  */
 
-#include <config.h>
 #include <libmemcached/common.h>
 
 struct bucket_t {
@@ -65,8 +64,11 @@ memcached_return_t memcached_virtual_bucket_create(memcached_st *self,
 
   struct memcached_virtual_bucket_t *virtual_bucket= (struct memcached_virtual_bucket_t *)malloc(sizeof(struct memcached_virtual_bucket_t) + sizeof(struct bucket_t) *buckets);
   
-  if (! virtual_bucket)
+  if (virtual_bucket == NULL)
+  {
     return MEMCACHED_MEMORY_ALLOCATION_FAILURE;
+  }
+
 
   virtual_bucket->size= buckets;
   virtual_bucket->replicas= replicas;
@@ -85,18 +87,21 @@ memcached_return_t memcached_virtual_bucket_create(memcached_st *self,
       virtual_bucket->buckets[x].forward= 0;
     }
   }
-  
 
   return MEMCACHED_SUCCESS;
 }
 
 void memcached_virtual_bucket_free(memcached_st *self)
 {
-  if (! self)
+  if (self == NULL)
+  {
     return;
+  }
 
-  if (! self->virtual_bucket)
+  if (self->virtual_bucket == NULL)
+  {
     return;
+  }
 
   free(self->virtual_bucket);
   self->virtual_bucket= NULL;
@@ -104,11 +109,15 @@ void memcached_virtual_bucket_free(memcached_st *self)
 
 uint32_t memcached_virtual_bucket_get(const memcached_st *self, uint32_t digest)
 {
-  if (! self)
+  if (self == NULL)
+  {
     return 0;
+  }
 
-  if (! self->virtual_bucket)
+  if (self->virtual_bucket == NULL)
+  {
     return 0;
+  }
 
   if (self->virtual_bucket)
   {

diff --git a/tests/mem_functions.cc b/tests/mem_functions.cc
index d6aaa7cbf6451c7904386125ae8a0fe531cc3aa6..54cce01d265bbad784a8ec65b4a5bdd530119e79 100644 (file)
--- a/tests/mem_functions.cc
+++ b/tests/mem_functions.cc
@@ -1874,14 +1874,9 @@ static test_return_t get_stats_keys(memcached_st *memc)
  return TEST_SUCCESS;
 }
 
-static test_return_t version_string_test(memcached_st *memc)
+static test_return_t version_string_test(memcached_st *)
 {
-  const char *version_string;
-  (void)memc;
-
-  version_string= memcached_lib_version();
-
-  test_strcmp(version_string, LIBMEMCACHED_VERSION_STRING);
+  test_strcmp(LIBMEMCACHED_VERSION_STRING, memcached_lib_version());
 
   return TEST_SUCCESS;
 }
@@ -1910,16 +1905,13 @@ static test_return_t get_stats(memcached_st *memc)
 
 static test_return_t add_host_test(memcached_st *memc)
 {
-  unsigned int x;
-  memcached_server_st *servers;
-  memcached_return_t rc;
   char servername[]= "0.example.com";
 
-  servers= memcached_server_list_append_with_weight(NULL, servername, 400, 0, &rc);
-  test_true(servers);
-  test_true(1 == memcached_server_list_count(servers));
+  memcached_return_t rc;
+  memcached_server_st *servers= memcached_server_list_append_with_weight(NULL, servername, 400, 0, &rc);
+  test_compare(1U, memcached_server_list_count(servers));
 
-  for (x= 2; x < 20; x++)
+  for (unsigned int x= 2; x < 20; x++)
   {
     char buffer[SMALL_STRING_LEN];
 
@@ -1927,13 +1919,11 @@ static test_return_t add_host_test(memcached_st *memc)
     servers= memcached_server_list_append_with_weight(servers, buffer, 401, 0,
                                      &rc);
     test_compare(MEMCACHED_SUCCESS, rc);
-    test_true(x == memcached_server_list_count(servers));
+    test_compare(x, memcached_server_list_count(servers));
   }
 
-  rc= memcached_server_push(memc, servers);
-  test_compare(MEMCACHED_SUCCESS, rc);
-  rc= memcached_server_push(memc, servers);
-  test_compare(MEMCACHED_SUCCESS, rc);
+  test_compare(MEMCACHED_SUCCESS, memcached_server_push(memc, servers));
+  test_compare(MEMCACHED_SUCCESS, memcached_server_push(memc, servers));
 
   memcached_server_list_free(servers);
 
@@ -1943,15 +1933,15 @@ static test_return_t add_host_test(memcached_st *memc)
 static test_return_t memcached_fetch_result_NOT_FOUND(memcached_st *memc)
 {
   memcached_return_t rc;
+
   const char *key= "not_found";
-  size_t key_len= strlen(key);
+  size_t key_length= test_literal_param_size("not_found");
 
   test_compare(MEMCACHED_SUCCESS,
-               memcached_mget(memc, &key, &key_len, 1));
+               memcached_mget(memc, &key, &key_length, 1));
 
-  memcached_result_st *result= NULL;
-  result= memcached_fetch_result(memc, result, &rc);
-  test_false(result);
+  memcached_result_st *result= memcached_fetch_result(memc, NULL, &rc);
+  test_null(result);
   test_compare_got(MEMCACHED_NOTFOUND, rc, memcached_strerror(NULL, rc));
 
   memcached_result_free(result);
@@ -1959,15 +1949,13 @@ static test_return_t memcached_fetch_result_NOT_FOUND(memcached_st *memc)
   return TEST_SUCCESS;
 }
 
-static memcached_return_t  clone_test_callback(memcached_st *parent, memcached_st *memc_clone)
+static memcached_return_t  clone_test_callback(memcached_st *, memcached_st *)
 {
-  (void)parent;(void)memc_clone;
   return MEMCACHED_SUCCESS;
 }
 
-static memcached_return_t  cleanup_test_callback(memcached_st *ptr)
+static memcached_return_t  cleanup_test_callback(memcached_st *)
 {
-  (void)ptr;
   return MEMCACHED_SUCCESS;
 }
 
@@ -1979,8 +1967,7 @@ static test_return_t callback_test(memcached_st *memc)
     int *test_ptr;
     memcached_return_t rc;
 
-    rc= memcached_callback_set(memc, MEMCACHED_CALLBACK_USER_DATA, &x);
-    test_compare(MEMCACHED_SUCCESS, rc);
+    test_compare(MEMCACHED_SUCCESS, memcached_callback_set(memc, MEMCACHED_CALLBACK_USER_DATA, &x));
     test_ptr= (int *)memcached_callback_get(memc, MEMCACHED_CALLBACK_USER_DATA, &rc);
     test_true(*test_ptr == x);
   }
@@ -1990,26 +1977,22 @@ static test_return_t callback_test(memcached_st *memc)
     memcached_clone_fn clone_cb= (memcached_clone_fn)clone_test_callback;
     void *clone_cb_ptr= *(void **)&clone_cb;
     void *temp_function= NULL;
-    memcached_return_t rc;
 
-    rc= memcached_callback_set(memc, MEMCACHED_CALLBACK_CLONE_FUNCTION,
-                               clone_cb_ptr);
-    test_compare(MEMCACHED_SUCCESS, rc);
+    test_compare(MEMCACHED_SUCCESS, memcached_callback_set(memc, MEMCACHED_CALLBACK_CLONE_FUNCTION, clone_cb_ptr));
+    memcached_return_t rc;
     temp_function= memcached_callback_get(memc, MEMCACHED_CALLBACK_CLONE_FUNCTION, &rc);
     test_true(temp_function == clone_cb_ptr);
+    test_compare(MEMCACHED_SUCCESS, rc);
   }
 
   /* Test Cleanup Callback */
   {
-    memcached_cleanup_fn cleanup_cb=
-      (memcached_cleanup_fn)cleanup_test_callback;
+    memcached_cleanup_fn cleanup_cb= (memcached_cleanup_fn)cleanup_test_callback;
     void *cleanup_cb_ptr= *(void **)&cleanup_cb;
     void *temp_function= NULL;
     memcached_return_t rc;
 
-    rc= memcached_callback_set(memc, MEMCACHED_CALLBACK_CLONE_FUNCTION,
-                               cleanup_cb_ptr);
-    test_compare(MEMCACHED_SUCCESS, rc);
+    test_compare(MEMCACHED_SUCCESS, memcached_callback_set(memc, MEMCACHED_CALLBACK_CLONE_FUNCTION, cleanup_cb_ptr));
     temp_function= memcached_callback_get(memc, MEMCACHED_CALLBACK_CLONE_FUNCTION, &rc);
     test_true(temp_function == cleanup_cb_ptr);
   }
@@ -2020,62 +2003,42 @@ static test_return_t callback_test(memcached_st *memc)
 /* We don't test the behavior itself, we test the switches */
 static test_return_t behavior_test(memcached_st *memc)
 {
-  uint64_t value;
-  uint32_t set= 1;
-
-  memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_NO_BLOCK, set);
-  value= memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_NO_BLOCK);
-  test_true(value == 1);
-
-  memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_TCP_NODELAY, set);
-  value= memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_TCP_NODELAY);
-  test_true(value == 1);
+  memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_NO_BLOCK, 1);
+  test_compare(true, memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_NO_BLOCK));
 
-  set= MEMCACHED_HASH_MD5;
-  memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_HASH, set);
-  value= memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_HASH);
-  test_true(value == MEMCACHED_HASH_MD5);
+  memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_TCP_NODELAY, 1);
+  test_compare(true, memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_TCP_NODELAY));
 
-  set= 0;
+  memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_HASH, MEMCACHED_HASH_MD5);
+  test_compare(uint64_t(MEMCACHED_HASH_MD5), memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_HASH));
 
-  memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_NO_BLOCK, set);
-  value= memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_NO_BLOCK);
-  test_true(value == 0);
+  memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_NO_BLOCK, 0);
+  test_zero(memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_NO_BLOCK));
 
-  memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_TCP_NODELAY, set);
-  value= memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_TCP_NODELAY);
-  test_true(value == 0);
+  memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_TCP_NODELAY, 0);
+  test_zero(memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_TCP_NODELAY));
 
-  set= MEMCACHED_HASH_DEFAULT;
-  memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_HASH, set);
-  value= memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_HASH);
-  test_true(value == MEMCACHED_HASH_DEFAULT);
+  memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_HASH, MEMCACHED_HASH_DEFAULT);
+  test_compare(uint64_t(MEMCACHED_HASH_DEFAULT), memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_HASH));
 
-  set= MEMCACHED_HASH_CRC;
-  memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_HASH, set);
-  value= memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_HASH);
-  test_true(value == MEMCACHED_HASH_CRC);
+  memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_HASH, MEMCACHED_HASH_CRC);
+  test_compare(uint64_t(MEMCACHED_HASH_CRC), memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_HASH));
 
-  value= memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_SOCKET_SEND_SIZE);
-  test_true(value > 0);
+  test_true(memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_SOCKET_SEND_SIZE));
 
-  value= memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_SOCKET_RECV_SIZE);
-  test_true(value > 0);
+  test_true(memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_SOCKET_RECV_SIZE));
 
-  value= memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_NUMBER_OF_REPLICAS);
-  memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_NUMBER_OF_REPLICAS, value + 1);
-  test_true((value + 1) == memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_NUMBER_OF_REPLICAS));
+  uint64_t value= memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_NUMBER_OF_REPLICAS);
+  memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_NUMBER_OF_REPLICAS, value +1);
+  test_compare((value +1),  memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_NUMBER_OF_REPLICAS));
 
   return TEST_SUCCESS;
 }
 
 static test_return_t MEMCACHED_BEHAVIOR_CORK_test(memcached_st *memc)
 {
-  memcached_return_t rc;
-  bool set= true;
-
-  rc= memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_CORK, set);
-  test_true(rc == MEMCACHED_DEPRECATED);
+  test_compare(MEMCACHED_DEPRECATED, 
+               memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_CORK, true));
 
   // Platform dependent
 #if 0
@@ -2089,22 +2052,18 @@ static test_return_t MEMCACHED_BEHAVIOR_CORK_test(memcached_st *memc)
 
 static test_return_t MEMCACHED_BEHAVIOR_TCP_KEEPALIVE_test(memcached_st *memc)
 {
-  memcached_return_t rc;
-  bool set= true;
-  bool value;
-
-  rc= memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_TCP_KEEPALIVE, set);
+  memcached_return_t rc= memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_TCP_KEEPALIVE, true);
   test_true(rc == MEMCACHED_SUCCESS || rc == MEMCACHED_NOT_SUPPORTED);
 
-  value= (bool)memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_TCP_KEEPALIVE);
+  bool value= (bool)memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_TCP_KEEPALIVE);
 
-  if (rc == MEMCACHED_SUCCESS)
+  if (memcached_success(rc))
   {
-    test_true((bool)value == set);
+    test_true(value);
   }
   else
   {
-    test_false((bool)value == set);
+    test_false(value);
   }
 
   return TEST_SUCCESS;
@@ -2113,22 +2072,18 @@ static test_return_t MEMCACHED_BEHAVIOR_TCP_KEEPALIVE_test(memcached_st *memc)
 
 static test_return_t MEMCACHED_BEHAVIOR_TCP_KEEPIDLE_test(memcached_st *memc)
 {
-  memcached_return_t rc;
-  bool set= true;
-  bool value;
-
-  rc= memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_TCP_KEEPIDLE, set);
+  memcached_return_t rc= memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_TCP_KEEPIDLE, true);
   test_true(rc == MEMCACHED_SUCCESS || rc == MEMCACHED_NOT_SUPPORTED);
 
-  value= (bool)memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_TCP_KEEPIDLE);
+  bool value= (bool)memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_TCP_KEEPIDLE);
 
-  if (rc == MEMCACHED_SUCCESS)
+  if (memcached_success(rc))
   {
-    test_true((bool)value == set);
+    test_true(value);
   }
   else
   {
-    test_false((bool)value == set);
+    test_false(value);
   }
 
   return TEST_SUCCESS;
@@ -2174,11 +2129,10 @@ static test_return_t user_supplied_bug1(memcached_st *memc)
   /* We just keep looking at the same values over and over */
   srandom(10);
 
-  unsigned int setter= 1;
   test_compare(MEMCACHED_SUCCESS,
-               memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_NO_BLOCK, setter));
+               memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_NO_BLOCK, true));
   test_compare(MEMCACHED_SUCCESS,
-               memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_TCP_NODELAY, setter));
+               memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_TCP_NODELAY, true));
 
 
   /* add key */
@@ -2209,19 +2163,15 @@ static test_return_t user_supplied_bug1(memcached_st *memc)
 /* Test case provided by Cal Haldenbrand */
 static test_return_t user_supplied_bug2(memcached_st *memc)
 {
-  unsigned int setter= 1;
-
   test_compare(MEMCACHED_SUCCESS, 
-               memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_NO_BLOCK, setter));
+               memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_NO_BLOCK, true));
 
   test_compare(MEMCACHED_SUCCESS, 
-               memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_TCP_NODELAY, setter));
+               memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_TCP_NODELAY, true));
 
 #ifdef NOT_YET
-  setter = 20 * 1024576;
-  memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_SOCKET_SEND_SIZE, setter);
-  setter = 20 * 1024576;
-  memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_SOCKET_RECV_SIZE, setter);
+  test_compare(MEMCACHED_SUCCESS, memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_SOCKET_SEND_SIZE, 20 * 1024576));
+  test_compare(MEMCACHED_SUCCESS, memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_SOCKET_RECV_SIZE, 20 * 1024576));
   getter = memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_SOCKET_SEND_SIZE);
   getter = memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_SOCKET_RECV_SIZE);
 
@@ -2269,10 +2219,8 @@ static test_return_t user_supplied_bug3(memcached_st *memc)
   test_compare(MEMCACHED_SUCCESS, memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_TCP_NODELAY, 1));
 
 #ifdef NOT_YET
-  setter = 20 * 1024576;
-  memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_SOCKET_SEND_SIZE, setter);
-  setter = 20 * 1024576;
-  memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_SOCKET_RECV_SIZE, setter);
+  memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_SOCKET_SEND_SIZE, 20 * 1024576);
+  memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_SOCKET_RECV_SIZE, 20 * 1024576);
   getter = memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_SOCKET_SEND_SIZE);
   getter = memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_SOCKET_RECV_SIZE);
 #endif
@@ -2381,9 +2329,7 @@ static test_return_t user_supplied_bug5(memcached_st *memc)
                memcached_flush(memc, 0));
 
   memcached_return_t rc;
-  value= memcached_get(memc, keys[0], key_length[0],
-                       &value_length, &flags, &rc);
-  test_false(value);
+  test_null(memcached_get(memc, keys[0], key_length[0], &value_length, &flags, &rc));
   test_compare(MEMCACHED_SUCCESS,
                memcached_mget(memc, keys, key_length, 4));
 
@@ -2530,7 +2476,9 @@ static test_return_t user_supplied_bug7(memcached_st *memc)
   char *insert_data= new (std::nothrow) char[VALUE_SIZE_BUG5];
 
   for (unsigned int x= 0; x < VALUE_SIZE_BUG5; x++)
+  {
     insert_data[x]= (signed char)rand();
+  }
 
   memcached_flush(memc, 0);
 
@@ -2543,11 +2491,11 @@ static test_return_t user_supplied_bug7(memcached_st *memc)
   flags= 0;
   value= memcached_get(memc, keys, key_length,
                        &value_length, &flags, &rc);
-  test_true(flags == 245);
+  test_compare(245U, flags);
   test_true(value);
   free(value);
 
-  rc= memcached_mget(memc, &keys, &key_length, 1);
+  test_compare(MEMCACHED_SUCCESS, memcached_mget(memc, &keys, &key_length, 1));
 
   flags= 0;
   value= memcached_fetch(memc, return_key, &return_key_length,

diff --git a/tests/plus.cpp b/tests/plus.cpp
index d9d00ad1604713910cc329adeb6d047aefccd83f..e020cdd988e2bdddf71c6d6ba52cbc67319af265 100644 (file)
--- a/tests/plus.cpp
+++ b/tests/plus.cpp
@@ -205,17 +205,15 @@ static test_return_t mget_test(memcached_st *original)
 static test_return_t basic_behavior(memcached_st *original)
 {
   Memcache memc(original);
-  uint64_t value= 1;
-  test_true(memc.setBehavior(MEMCACHED_BEHAVIOR_VERIFY_KEY, value));
-  uint64_t behavior= memc.getBehavior(MEMCACHED_BEHAVIOR_VERIFY_KEY);
-  test_compare(behavior, value);
+  test_true(memc.setBehavior(MEMCACHED_BEHAVIOR_VERIFY_KEY, true));
+  test_compare(true, memc.getBehavior(MEMCACHED_BEHAVIOR_VERIFY_KEY));
 
   return TEST_SUCCESS;
 }
 
 static test_return_t error_test(memcached_st *)
 {
-  Memcache memc("--server=localhost:0");
+  Memcache memc("--server=localhost:178");
   std::vector<char> value;
 
   test_false(memc.set("key", value, time_t(0), uint32_t(0)));
@@ -227,7 +225,7 @@ static test_return_t error_test(memcached_st *)
 
 static test_return_t error_std_string_test(memcached_st *)
 {
-  Memcache memc("--server=localhost:0");
+  Memcache memc("--server=localhost:178");
   std::vector<char> value;
 
   test_false(memc.set("key", value, time_t(0), uint32_t(0)));
@@ -241,7 +239,7 @@ static test_return_t error_std_string_test(memcached_st *)
 
 static test_return_t error_memcached_return_t_test(memcached_st *)
 {
-  Memcache memc("--server=localhost:0");
+  Memcache memc("--server=localhost:178");
   std::vector<char> value;
 
   test_false(memc.set("key", value, time_t(0), uint32_t(0)));