From: Monty Taylor <mordred@inaugust.com>
Date: Wed, 8 Jul 2009 13:38:34 +0000 (+0000)
Subject: Fixed -Wwrite-strings warnings.
X-Git-Tag: 0.32~14^2~9
X-Git-Url: https://git.m6w6.name/?a=commitdiff_plain;h=17715ceb4fae0acb43811fa8ec17e0e788c44931;p=m6w6%2Flibmemcached

Fixed -Wwrite-strings warnings.
---

diff --git a/clients/memcp.c b/clients/memcp.c
index d6864b1a..778beaf7 100644
--- a/clients/memcp.c
+++ b/clients/memcp.c
@@ -91,7 +91,7 @@ int main(int argc, char *argv[])
 
     if (opt_verbose) 
     {
-      static char *opstr[] = { "set", "add", "replace" };
+      static const char *opstr[] = { "set", "add", "replace" };
       printf("op: %s\nsource file: %s\nlength: %zu\n"
 	     "key: %s\nflags: %x\nexpires: %llu\n",
 	     opstr[opt_method - OPT_SET], argv[optind], (size_t)sbuf.st_size,
diff --git a/clients/utilities.c b/clients/utilities.c
index 6551684d..9ad6edcf 100644
--- a/clients/utilities.c
+++ b/clients/utilities.c
@@ -16,13 +16,13 @@ long int timedif(struct timeval a, struct timeval b)
   return s + us;
 }
 
-void version_command(char *command_name)
+void version_command(const char *command_name)
 {
   printf("%s v%u.%u\n", command_name, 1, 0);
   exit(0);
 }
 
-static char *lookup_help(memcached_options option)
+static const char *lookup_help(memcached_options option)
 {
   switch (option)
   {
@@ -54,7 +54,7 @@ static char *lookup_help(memcached_options option)
   return "forgot to document this function :)";
 }
 
-void help_command(char *command_name, char *description,
+void help_command(const char *command_name, const char *description,
                   const struct option *long_options,
                   memcached_programs_help_st *options __attribute__((unused)))
 {
@@ -66,7 +66,7 @@ void help_command(char *command_name, char *description,
 
   for (x= 0; long_options[x].name; x++) 
   {
-    char *help_message;
+    const char *help_message;
 
     printf("\t --%s%c\n", long_options[x].name, 
            long_options[x].has_arg ? '=' : ' ');  
diff --git a/clients/utilities.h b/clients/utilities.h
index ea0be2ea..af670613 100644
--- a/clients/utilities.h
+++ b/clients/utilities.h
@@ -23,8 +23,8 @@ struct memcached_programs_help_st
 char *strdup_cleanup(const char *str);
 void cleanup(void);
 long int timedif(struct timeval a, struct timeval b);
-void version_command(char *command_name);
-void help_command(char *command_name, char *description,
+void version_command(const char *command_name);
+void help_command(const char *command_name, const char *description,
                   const struct option *long_options,
                   memcached_programs_help_st *options);
 void process_hash_option(memcached_st *memc, char *opt_hash);
diff --git a/libmemcached/common.h b/libmemcached/common.h
index d8371d18..7942b27a 100644
--- a/libmemcached/common.h
+++ b/libmemcached/common.h
@@ -135,7 +135,7 @@ LIBMEMCACHED_LOCAL
 void server_list_free(memcached_st *ptr, memcached_server_st *servers);
 
 LIBMEMCACHED_LOCAL
-memcached_return memcached_key_test(char **keys, size_t *key_length,
+memcached_return memcached_key_test(const char **keys, size_t *key_length,
                                     unsigned int number_of_keys);
 
 
diff --git a/libmemcached/memcached.h b/libmemcached/memcached.h
index c2602116..1293eefb 100644
--- a/libmemcached/memcached.h
+++ b/libmemcached/memcached.h
@@ -172,7 +172,7 @@ memcached_return memcached_verbosity(memcached_st *ptr, unsigned int verbosity);
 LIBMEMCACHED_API
 void memcached_quit(memcached_st *ptr);
 LIBMEMCACHED_API
-char *memcached_strerror(memcached_st *ptr, memcached_return rc);
+const char *memcached_strerror(memcached_st *ptr, memcached_return rc);
 LIBMEMCACHED_API
 memcached_return memcached_behavior_set(memcached_st *ptr, memcached_behavior flag, uint64_t data);
 LIBMEMCACHED_API
diff --git a/libmemcached/memcached.hh b/libmemcached/memcached.hh
index 2f2d519e..d13ca23a 100644
--- a/libmemcached/memcached.hh
+++ b/libmemcached/memcached.hh
@@ -46,7 +46,7 @@ public:
                                 value_length, &flags, &rc);
   }
 
-  memcached_return mget(char **keys, size_t *key_length, 
+  memcached_return mget(const char **keys, size_t *key_length, 
                         unsigned int number_of_keys)
   {
 
diff --git a/libmemcached/memcached_auto.c b/libmemcached/memcached_auto.c
index 2cb810db..176cbcc9 100644
--- a/libmemcached/memcached_auto.c
+++ b/libmemcached/memcached_auto.c
@@ -15,7 +15,7 @@ static memcached_return memcached_auto(memcached_st *ptr,
   unlikely (ptr->hosts == NULL || ptr->number_of_hosts == 0)
     return MEMCACHED_NO_SERVERS;
 
-  if ((ptr->flags & MEM_VERIFY_KEY) && (memcached_key_test((char **)&key, &key_length, 1) == MEMCACHED_BAD_KEY_PROVIDED))
+  if ((ptr->flags & MEM_VERIFY_KEY) && (memcached_key_test((const char **)&key, &key_length, 1) == MEMCACHED_BAD_KEY_PROVIDED))
     return MEMCACHED_BAD_KEY_PROVIDED;
 
   server_key= memcached_generate_hash(ptr, key, key_length);
diff --git a/libmemcached/memcached_callback.c b/libmemcached/memcached_callback.c
index 3433585c..ea59f844 100644
--- a/libmemcached/memcached_callback.c
+++ b/libmemcached/memcached_callback.c
@@ -21,7 +21,7 @@ memcached_return memcached_callback_set(memcached_st *ptr,
       {
         size_t key_length= strlen(key);
 
-        if (memcached_key_test((char **)&key, &key_length, 1) == MEMCACHED_BAD_KEY_PROVIDED)
+        if (memcached_key_test((const char **)&key, &key_length, 1) == MEMCACHED_BAD_KEY_PROVIDED)
         {
           return MEMCACHED_BAD_KEY_PROVIDED;
         }
diff --git a/libmemcached/memcached_get.c b/libmemcached/memcached_get.c
index e91db4cf..b7e90005 100644
--- a/libmemcached/memcached_get.c
+++ b/libmemcached/memcached_get.c
@@ -37,7 +37,7 @@ char *memcached_get_by_key(memcached_st *ptr,
   *error= memcached_mget_by_key(ptr, 
                                 master_key, 
                                 master_key_length, 
-                                (char **)&key, &key_length, 1);
+                                (const char **)&key, &key_length, 1);
 
   value= memcached_fetch(ptr, NULL, NULL, 
                          value_length, flags, error);
@@ -102,7 +102,7 @@ char *memcached_get_by_key(memcached_st *ptr,
 }
 
 memcached_return memcached_mget(memcached_st *ptr, 
-                                char **keys, size_t *key_length, 
+                                const char **keys, size_t *key_length, 
                                 unsigned int number_of_keys)
 {
   return memcached_mget_by_key(ptr, NULL, 0, keys, key_length, number_of_keys);
@@ -111,19 +111,19 @@ memcached_return memcached_mget(memcached_st *ptr,
 static memcached_return binary_mget_by_key(memcached_st *ptr,
                                            unsigned int master_server_key,
                                            bool is_master_key_set,
-                                           char **keys, size_t *key_length,
+                                           const char **keys, size_t *key_length,
                                            unsigned int number_of_keys);
 
 memcached_return memcached_mget_by_key(memcached_st *ptr, 
                                        const char *master_key, 
                                        size_t master_key_length,
-                                       char **keys, 
+                                       const char **keys, 
                                        size_t *key_length, 
                                        unsigned int number_of_keys)
 {
   unsigned int x;
   memcached_return rc= MEMCACHED_NOTFOUND;
-  char *get_command= "get ";
+  const char *get_command= "get ";
   uint8_t get_command_length= 4;
   unsigned int master_server_key= (unsigned int)-1; /* 0 is a valid server id! */
   bool is_master_key_set= false;
@@ -145,7 +145,7 @@ memcached_return memcached_mget_by_key(memcached_st *ptr,
 
   if (master_key && master_key_length)
   {
-    if ((ptr->flags & MEM_VERIFY_KEY) && (memcached_key_test((char **)&master_key, &master_key_length, 1) == MEMCACHED_BAD_KEY_PROVIDED))
+    if ((ptr->flags & MEM_VERIFY_KEY) && (memcached_key_test((const char **)&master_key, &master_key_length, 1) == MEMCACHED_BAD_KEY_PROVIDED))
       return MEMCACHED_BAD_KEY_PROVIDED;
     master_server_key= memcached_generate_hash(ptr, master_key, master_key_length);
     is_master_key_set= true;
@@ -259,7 +259,7 @@ memcached_return memcached_mget_by_key(memcached_st *ptr,
 static memcached_return simple_binary_mget(memcached_st *ptr,
                                            unsigned int master_server_key,
                                            bool is_master_key_set,
-                                           char **keys, size_t *key_length, 
+                                           const char **keys, size_t *key_length, 
                                            unsigned int number_of_keys)
 {
   memcached_return rc= MEMCACHED_NOTFOUND;
@@ -360,7 +360,7 @@ static memcached_return simple_binary_mget(memcached_st *ptr,
 
 static memcached_return replication_binary_mget(memcached_st *ptr,
                                              uint32_t* hash, bool* dead_servers,
-                                             char **keys, size_t *key_length,
+                                             const char **keys, size_t *key_length,
                                              unsigned int number_of_keys)
 {
   memcached_return rc= MEMCACHED_NOTFOUND;
@@ -459,7 +459,7 @@ static memcached_return replication_binary_mget(memcached_st *ptr,
 static memcached_return binary_mget_by_key(memcached_st *ptr,
                                            unsigned int master_server_key,
                                            bool is_master_key_set,
-                                           char **keys, size_t *key_length,
+                                           const char **keys, size_t *key_length,
                                            unsigned int number_of_keys)
 {
   memcached_return rc;
diff --git a/libmemcached/memcached_get.h b/libmemcached/memcached_get.h
index dba3c919..70444427 100644
--- a/libmemcached/memcached_get.h
+++ b/libmemcached/memcached_get.h
@@ -23,7 +23,7 @@ char *memcached_get(memcached_st *ptr,
 
 LIBMEMCACHED_API
 memcached_return memcached_mget(memcached_st *ptr, 
-                                char **keys, size_t *key_length, 
+                                const char **keys, size_t *key_length, 
                                 unsigned int number_of_keys);
 
 LIBMEMCACHED_API
@@ -38,7 +38,7 @@ LIBMEMCACHED_API
 memcached_return memcached_mget_by_key(memcached_st *ptr, 
                                        const char *master_key, size_t 
                                        master_key_length,
-                                       char **keys, 
+                                       const char **keys, 
                                        size_t *key_length, 
                                        unsigned int number_of_keys);
 
diff --git a/libmemcached/memcached_key.c b/libmemcached/memcached_key.c
index bbbd940d..c992c338 100644
--- a/libmemcached/memcached_key.c
+++ b/libmemcached/memcached_key.c
@@ -1,6 +1,6 @@
 #include "common.h"
 
-memcached_return memcached_key_test(char **keys, size_t *key_length, 
+memcached_return memcached_key_test(const char **keys, size_t *key_length, 
                                     unsigned int number_of_keys)
 {
   uint32_t x;
diff --git a/libmemcached/memcached_result.c b/libmemcached/memcached_result.c
index 1462b89c..0d77130d 100644
--- a/libmemcached/memcached_result.c
+++ b/libmemcached/memcached_result.c
@@ -40,7 +40,7 @@ void memcached_result_reset(memcached_result_st *ptr)
 /*
   NOTE turn into macro
 */
-memcached_return memcached_result_set_value(memcached_result_st *ptr, char *value, size_t length)
+memcached_return memcached_result_set_value(memcached_result_st *ptr, const char *value, size_t length)
 {
   return memcached_string_append(&ptr->value, value, length);
 }
diff --git a/libmemcached/memcached_result.h b/libmemcached/memcached_result.h
index b06ea2ce..e7ce012b 100644
--- a/libmemcached/memcached_result.h
+++ b/libmemcached/memcached_result.h
@@ -48,7 +48,7 @@ size_t memcached_result_length(memcached_result_st *ptr);
 #define memcached_result_flags(A) (A)->flags
 #define memcached_result_cas(A) (A)->cas
 LIBMEMCACHED_API
-memcached_return memcached_result_set_value(memcached_result_st *ptr, char *value, size_t length);
+memcached_return memcached_result_set_value(memcached_result_st *ptr, const char *value, size_t length);
 #define memcached_result_set_flags(A,B) (A)->flags=(B)
 #define memcached_result_set_expiration(A,B) (A)->expiration=(B)
 
diff --git a/libmemcached/memcached_server.c b/libmemcached/memcached_server.c
index 04364f3a..11e5988a 100644
--- a/libmemcached/memcached_server.c
+++ b/libmemcached/memcached_server.c
@@ -120,7 +120,7 @@ memcached_server_st *memcached_server_by_key(memcached_st *ptr,  const char *key
     return NULL;
   }
 
-  if ((ptr->flags & MEM_VERIFY_KEY) && (memcached_key_test((char **)&key, &key_length, 1) == MEMCACHED_BAD_KEY_PROVIDED))
+  if ((ptr->flags & MEM_VERIFY_KEY) && (memcached_key_test((const char **)&key, &key_length, 1) == MEMCACHED_BAD_KEY_PROVIDED))
   {
     *error= MEMCACHED_BAD_KEY_PROVIDED;
     return NULL;
diff --git a/libmemcached/memcached_stats.c b/libmemcached/memcached_stats.c
index c7e1197b..e64ca550 100644
--- a/libmemcached/memcached_stats.c
+++ b/libmemcached/memcached_stats.c
@@ -3,7 +3,7 @@
 
 #include "common.h"
 
-static char *memcached_stat_keys[] = {
+static const char *memcached_stat_keys[] = {
   "pid",
   "uptime",
   "time",
diff --git a/libmemcached/memcached_storage.c b/libmemcached/memcached_storage.c
index 53d79822..e10f85f0 100644
--- a/libmemcached/memcached_storage.c
+++ b/libmemcached/memcached_storage.c
@@ -19,7 +19,7 @@ typedef enum {
 } memcached_storage_action;
 
 /* Inline this */
-static char *storage_op_string(memcached_storage_action verb)
+static const char *storage_op_string(memcached_storage_action verb)
 {
   switch (verb)
   {
@@ -79,7 +79,7 @@ static inline memcached_return memcached_send(memcached_st *ptr,
   unlikely (ptr->number_of_hosts == 0)
     return MEMCACHED_NO_SERVERS;
 
-  if ((ptr->flags & MEM_VERIFY_KEY) && (memcached_key_test((char **)&key, &key_length, 1) == MEMCACHED_BAD_KEY_PROVIDED))
+  if ((ptr->flags & MEM_VERIFY_KEY) && (memcached_key_test((const char **)&key, &key_length, 1) == MEMCACHED_BAD_KEY_PROVIDED))
     return MEMCACHED_BAD_KEY_PROVIDED;
 
   if (ptr->flags & MEM_BINARY_PROTOCOL)
diff --git a/libmemcached/memcached_strerror.c b/libmemcached/memcached_strerror.c
index 47afdbda..8b75edd4 100644
--- a/libmemcached/memcached_strerror.c
+++ b/libmemcached/memcached_strerror.c
@@ -1,6 +1,6 @@
 #include "common.h"
 
-char *memcached_strerror(memcached_st *ptr __attribute__((unused)), memcached_return rc)
+const char *memcached_strerror(memcached_st *ptr __attribute__((unused)), memcached_return rc)
 {
   switch (rc)
   {
diff --git a/libmemcached/memcached_string.c b/libmemcached/memcached_string.c
index c190997b..5b9e9281 100644
--- a/libmemcached/memcached_string.c
+++ b/libmemcached/memcached_string.c
@@ -79,7 +79,7 @@ memcached_return memcached_string_append_character(memcached_string_st *string,
 }
 
 memcached_return memcached_string_append(memcached_string_st *string,
-                                         char *value, size_t length)
+                                         const char *value, size_t length)
 {
   memcached_return rc;
 
diff --git a/libmemcached/memcached_string.h b/libmemcached/memcached_string.h
index 8f347cd8..bed14281 100644
--- a/libmemcached/memcached_string.h
+++ b/libmemcached/memcached_string.h
@@ -40,7 +40,7 @@ memcached_return memcached_string_append_character(memcached_string_st *string,
                                                    char character);
 LIBMEMCACHED_API
 memcached_return memcached_string_append(memcached_string_st *string,
-                                         char *value, size_t length);
+                                         const char *value, size_t length);
 LIBMEMCACHED_API
 memcached_return memcached_string_reset(memcached_string_st *string);
 LIBMEMCACHED_API
diff --git a/libmemcached/memcached_version.c b/libmemcached/memcached_version.c
index 30bcb1bd..9c070eaf 100644
--- a/libmemcached/memcached_version.c
+++ b/libmemcached/memcached_version.c
@@ -26,7 +26,7 @@ static inline memcached_return memcached_version_textual(memcached_st *ptr)
   memcached_return rc;
   char buffer[MEMCACHED_DEFAULT_COMMAND_SIZE];
   char *response_ptr;
-  char *command= "version\r\n";
+  const char *command= "version\r\n";
 
   send_length= strlen(command);
 
diff --git a/tests/atomsmasher.c b/tests/atomsmasher.c
index eee08d6b..3b4879df 100644
--- a/tests/atomsmasher.c
+++ b/tests/atomsmasher.c
@@ -156,8 +156,8 @@ static memcached_return enable_consistent(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);
diff --git a/tests/function.c b/tests/function.c
index b806c883..b9e7d303 100644
--- a/tests/function.c
+++ b/tests/function.c
@@ -38,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)))
@@ -299,8 +299,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 +313,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 +323,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 +337,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 +350,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 +396,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;
@@ -442,7 +443,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";
@@ -499,8 +500,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 +524,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 +541,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 +589,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 +609,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,19 +644,19 @@ static memcached_return  server_function(memcached_st *ptr __attribute__((unused
 
 static test_return  memcached_server_cursor_test(memcached_st *memc)
 {
-  char *context= "foo bad";
+  char context[8];
+  strcpy(context, "foo bad");
   memcached_server_function callbacks[1];
 
   callbacks[0]= server_function;
   memcached_server_cursor(memc, callbacks, context,  1);
-
   return 0;
 }
 
 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;
@@ -687,7 +689,7 @@ static test_return  bad_key_test(memcached_st *memc)
     assert(!string);
 
     /* Test multi key for bad keys */
-    char *keys[] = { "GoodKey", "Bad Key", "NotMine" };
+    const char *keys[] = { "GoodKey", "Bad Key", "NotMine" };
     size_t key_lengths[] = { 7, 7, 7 };
     set= 1;
     rc= memcached_behavior_set(memc_clone, MEMCACHED_BEHAVIOR_VERIFY_KEY, set);
@@ -756,7 +758,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 +819,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 +840,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 +867,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 +917,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 +953,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 +1000,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;
@@ -1048,8 +1050,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 +1077,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 +1097,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 +1124,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 +1143,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 +1163,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 +1220,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 +1282,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 +1313,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;
@@ -1695,7 +1697,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 */
@@ -1726,7 +1728,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;
@@ -1789,7 +1791,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;
@@ -1847,7 +1849,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;
@@ -1916,7 +1918,7 @@ static test_return  user_supplied_bug8(memcached_st *memc __attribute__((unused)
   memcached_st *memc_clone;
 
   memcached_server_st *servers;
-  char *server_list= "memcache1.memcache.bk.sapo.pt:11211, memcache1.memcache.bk.sapo.pt:11212, memcache1.memcache.bk.sapo.pt:11213, memcache1.memcache.bk.sapo.pt:11214, memcache2.memcache.bk.sapo.pt:11211, memcache2.memcache.bk.sapo.pt:11212, memcache2.memcache.bk.sapo.pt:11213, memcache2.memcache.bk.sapo.pt:11214";
+  const char *server_list= "memcache1.memcache.bk.sapo.pt:11211, memcache1.memcache.bk.sapo.pt:11212, memcache1.memcache.bk.sapo.pt:11213, memcache1.memcache.bk.sapo.pt:11214, memcache2.memcache.bk.sapo.pt:11211, memcache2.memcache.bk.sapo.pt:11212, memcache2.memcache.bk.sapo.pt:11213, memcache2.memcache.bk.sapo.pt:11214";
 
   servers= memcached_servers_parse(server_list);
   assert(servers);
@@ -1943,8 +1945,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;
@@ -1987,7 +1989,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;
@@ -2031,7 +2033,7 @@ 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;
@@ -2074,7 +2076,7 @@ static test_return  user_supplied_bug10(memcached_st *memc)
 */
 static test_return  user_supplied_bug11(memcached_st *memc)
 {
-  char *key= "foo";
+  const char *key= "foo";
   char *value;
   size_t value_length= 512;
   unsigned int x;
@@ -2199,7 +2201,7 @@ static test_return  user_supplied_bug14(memcached_st *memc)
   size_t setter= 1;
   memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_TCP_NODELAY, setter);
   memcached_return rc;
-  char *key= "foo";
+  const char *key= "foo";
   char *value;
   size_t value_length= 18000;
   char *string;
@@ -2243,7 +2245,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;
@@ -2280,7 +2282,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;
@@ -2306,8 +2308,8 @@ static test_return  user_supplied_bug16(memcached_st *memc)
 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;
@@ -2358,9 +2360,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);
@@ -3139,7 +3141,9 @@ static memcached_return set_prefix(memcached_st *memc)
 
   /* Set to Zero, and then Set to something too large */
   {
-    char *long_key;
+    char long_key[255];
+    memset(long_key, 0, 255);
+
     rc= memcached_callback_set(memc, MEMCACHED_CALLBACK_PREFIX_KEY, NULL);
     assert(rc == MEMCACHED_SUCCESS);
 
@@ -3149,13 +3153,13 @@ static memcached_return set_prefix(memcached_st *memc)
 
     /* Test a long key for failure */
     /* TODO, extend test to determine based on setting, what result should be */
-    long_key= "Thisismorethentheallottednumberofcharacters";
+    strcpy(long_key, "Thisismorethentheallottednumberofcharacters");
     rc= memcached_callback_set(memc, MEMCACHED_CALLBACK_PREFIX_KEY, long_key);
     //assert(rc == MEMCACHED_BAD_KEY_PROVIDED);
     assert(rc == MEMCACHED_SUCCESS);
 
     /* Now test a key with spaces (which will fail from long key, since bad key is not set) */
-    long_key= "This is more then the allotted number of characters";
+    strcpy(long_key, "This is more then the allotted number of characters");
     rc= memcached_callback_set(memc, MEMCACHED_CALLBACK_PREFIX_KEY, long_key);
     assert(rc == MEMCACHED_BAD_KEY_PROVIDED);
 
@@ -3163,7 +3167,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);
   }
@@ -3429,7 +3433,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;
@@ -3668,7 +3672,7 @@ static test_return replication_mget_test(memcached_st *memc)
   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)
@@ -3705,7 +3709,7 @@ static test_return replication_mget_test(memcached_st *memc)
 
     for (int x= 'a'; x <= 'z'; ++x)
     {
-      char key[2]= { [0]= (char)x };
+      const char key[2]= { [0]= (const char)x };
 
       rc= memcached_mget_by_key(new_clone, key, 1, keys, len, 4);
       assert(rc == MEMCACHED_SUCCESS);
@@ -3737,7 +3741,7 @@ static test_return replication_delete_test(memcached_st *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)
@@ -3764,7 +3768,7 @@ static test_return replication_delete_test(memcached_st *memc)
   {
     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(memc_clone, key, 1, keys, len, 4);
       assert(rc == MEMCACHED_SUCCESS);
@@ -3907,8 +3911,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;
@@ -3947,7 +3951,7 @@ static test_return udp_buffered_set_test(memcached_st *memc)
 static test_return udp_set_too_big_test(memcached_st *memc)
 {
   memcached_return rc;
-  char *key= "bar";
+  const char *key= "bar";
   char value[MAX_UDP_DATAGRAM_LENGTH];
   uint16_t *expected_ids= get_udp_request_ids(memc);
   rc= memcached_set(memc, key, strlen(key),
@@ -3964,7 +3968,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;
@@ -4026,8 +4030,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);
@@ -4045,8 +4049,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);
@@ -4086,7 +4090,7 @@ static test_return udp_version_test(memcached_st *memc)
 static test_return udp_get_test(memcached_st *memc)
 {
   memcached_return rc;
-  char *key= "foo";
+  const char *key= "foo";
   size_t vlen;
   uint16_t *expected_ids = get_udp_request_ids(memc);
   char *val= memcached_get(memc, key, strlen(key), &vlen, (uint32_t)0, &rc);
@@ -4130,7 +4134,7 @@ static test_return hsieh_avaibility_test (memcached_st *memc)
   return TEST_SUCCESS;
 }
 
-static char *list[]=
+static const char *list[]=
 {
   "apple",
   "beat",
@@ -4163,7 +4167,7 @@ static char *list[]=
 static test_return md5_run (memcached_st *memc __attribute__((unused)))
 {
   uint32_t x;
-  char **ptr;
+  const char **ptr;
   uint32_t values[]= {  3195025439U, 2556848621U, 3724893440U, 3332385401U,
                         245758794U, 2550894432U, 121710495U, 3053817768U,
                         1250994555U, 1862072655U, 2631955953U, 2951528551U, 
@@ -4187,7 +4191,7 @@ static test_return md5_run (memcached_st *memc __attribute__((unused)))
 static test_return crc_run (memcached_st *memc __attribute__((unused)))
 {
   uint32_t x;
-  char **ptr;
+  const char **ptr;
   uint32_t values[]= {  10542U, 22009U, 14526U, 19510U, 19432U, 10199U, 20634U,
                         9369U, 11511U, 10362U, 7893U, 31289U, 11313U, 9354U,
                         7621U, 30628U, 15218U, 25967U, 2695U, 9380U, 
@@ -4207,7 +4211,7 @@ 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;
+  const char **ptr;
   uint32_t values[]= {  473199127U, 4148981457U, 3971873300U, 3257986707U, 
                         1722477987U, 2991193800U, 4147007314U, 3633179701U, 
                         1805162104U, 3503289120U, 3395702895U, 3325073042U,
@@ -4230,7 +4234,7 @@ 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;
+  const char **ptr;
   uint32_t values[]= {  1488911807U, 2500855813U, 1510099634U, 1390325195U, 
                         3647689787U, 3241528582U, 1669328060U, 2604311949U, 
                         734810122U, 1516407546U, 560948863U, 1767346780U,
@@ -4253,7 +4257,7 @@ 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;
+  const char **ptr;
   uint32_t values[]= {  67176023U, 1190179409U, 2043204404U, 3221866419U, 
                         2567703427U, 3787535528U, 4147287986U, 3500475733U,
                         344481048U, 3865235296U, 2181839183U, 119581266U, 
@@ -4277,7 +4281,7 @@ static test_return fnv1_32_run (memcached_st *memc __attribute__((unused)))
 static test_return fnv1a_32_run (memcached_st *memc __attribute__((unused)))
 {
   uint32_t x;
-  char **ptr;
+  const char **ptr;
   uint32_t values[]= {  280767167U, 2421315013U, 3072375666U, 855001899U,
                         459261019U, 3521085446U, 18738364U, 1625305005U,
                         2162232970U, 777243802U, 3323728671U, 132336572U,
@@ -4300,7 +4304,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,
@@ -4325,7 +4329,7 @@ static test_return hsieh_run (memcached_st *memc __attribute__((unused)))
 static test_return murmur_run (memcached_st *memc __attribute__((unused)))
 {
   uint32_t x;
-  char **ptr;
+  const char **ptr;
   uint32_t values[]= { 473199127U, 4148981457U, 3971873300U, 3257986707U,
                        1722477987U, 2991193800U, 4147007314U, 3633179701U,
                        1805162104U, 3503289120U, 3395702895U, 3325073042U,
@@ -4348,7 +4352,7 @@ static test_return murmur_run (memcached_st *memc __attribute__((unused)))
 static test_return jenkins_run (memcached_st *memc __attribute__((unused)))
 {
   uint32_t x;
-  char **ptr;
+  const char **ptr;
   uint32_t values[]= {  1442444624U, 4253821186U, 1885058256U, 2120131735U,
                         3261968576U, 3515188778U, 4232909173U, 4288625128U,
                         1812047395U, 3689182164U, 2502979932U, 1214050606U,
diff --git a/tests/ketama_test_cases.h b/tests/ketama_test_cases.h
index 2c13b671..a0d72b08 100644
--- a/tests/ketama_test_cases.h
+++ b/tests/ketama_test_cases.h
@@ -1,8 +1,8 @@
 typedef struct {
-    char *key;
+    const char *key;
     unsigned long hash1;
     unsigned long hash2;
-    char *server;
+    const char *server;
 } TestCase;
 
 static TestCase test_cases[99] = {
diff --git a/tests/udp.c b/tests/udp.c
index 4c7050e2..2fc178f0 100644
--- a/tests/udp.c
+++ b/tests/udp.c
@@ -22,8 +22,8 @@ void world_destroy(void *p);
 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),