X-Git-Url: https://git.m6w6.name/?a=blobdiff_plain;f=tests%2Fmem_functions.cc;h=d7402dbd0b2f8b4786f396c79cb4f6d711cb0555;hb=e82f6a9bffe896a579ae5013a9cab51180cd003d;hp=1b07d9c8e72d012ffdd759ca049570ba67a0182d;hpb=276e5c1e7fefa8f7061270f79443a704231c819e;p=awesomized%2Flibmemcached

diff --git a/tests/mem_functions.cc b/tests/mem_functions.cc
index 1b07d9c8..d7402dbd 100644
--- a/tests/mem_functions.cc
+++ b/tests/mem_functions.cc
@@ -35,6 +35,7 @@
  *
  */
 
+#include <libtest/common.h>
 
 /*
   Test cases
@@ -44,8 +45,6 @@
 // !NEVER use common.h, always use memcached.h in your own apps
 #include <libmemcached/common.h>
 
-#include <stdint.h>
-
 #include <cassert>
 #include <memory>
 #include <signal.h>
@@ -63,10 +62,11 @@
 
 #define SMALL_STRING_LEN 1024
 
-#include <libtest/test.h>
+#include <libtest/test.hpp>
 #include "tests/deprecated.h"
 #include "tests/parser.h"
 #include "tests/pool.h"
+#include "tests/namespace.h"
 #include "tests/string.h"
 #include "tests/replication.h"
 #include "tests/basic.h"
@@ -880,7 +880,7 @@ static test_return_t bad_key_test(memcached_st *memc)
        binary protocol
     */
     test_compare(MEMCACHED_SUCCESS, 
-                 memcached_callback_set(memc_clone, MEMCACHED_CALLBACK_PREFIX_KEY, NULL));
+                 memcached_callback_set(memc_clone, MEMCACHED_CALLBACK_NAMESPACE, NULL));
 
     char *longkey= (char *)malloc(max_keylen + 1);
     if (longkey)
@@ -954,7 +954,8 @@ static test_return_t read_through(memcached_st *memc)
                         &string_length, &flags, &rc);
 
   test_compare(MEMCACHED_SUCCESS, rc);
-  test_compare(string_length, strlen(READ_THROUGH_VALUE));
+  test_compare(string_length, sizeof(READ_THROUGH_VALUE) -1);
+  test_true(string[sizeof(READ_THROUGH_VALUE) -1] == 0);
   test_strcmp(READ_THROUGH_VALUE, string);
   free(string);
 
@@ -962,7 +963,9 @@ static test_return_t read_through(memcached_st *memc)
                         &string_length, &flags, &rc);
 
   test_compare(MEMCACHED_SUCCESS, rc);
-  test_compare(string_length, strlen(READ_THROUGH_VALUE));
+  test_true(string);
+  test_compare(string_length, sizeof(READ_THROUGH_VALUE) -1);
+  test_true(string[sizeof(READ_THROUGH_VALUE) -1] == 0);
   test_strcmp(READ_THROUGH_VALUE, string);
   free(string);
 
@@ -1133,30 +1136,28 @@ static test_return_t get_test3(memcached_st *memc)
 
 static test_return_t get_test4(memcached_st *memc)
 {
-  memcached_return_t rc;
   const char *key= "foo";
-  char *value;
   size_t value_length= 8191;
-  char *string;
-  size_t string_length;
-  uint32_t flags;
-  uint32_t x;
 
-  value = (char*)malloc(value_length);
+  char *value= (char*)malloc(value_length);
   test_true(value);
 
-  for (x= 0; x < value_length; x++)
+  for (uint32_t x= 0; x < value_length; x++)
+  {
     value[x] = (char) (x % 127);
+  }
 
-  rc= memcached_set(memc, key, strlen(key),
-                    value, value_length,
-                    (time_t)0, (uint32_t)0);
-  test_true(rc == MEMCACHED_SUCCESS || rc == MEMCACHED_BUFFERED);
+  memcached_return_t rc= memcached_set(memc, key, strlen(key),
+                                       value, value_length,
+                                       (time_t)0, (uint32_t)0);
+  test_true(rc == MEMCACHED_SUCCESS or rc == MEMCACHED_BUFFERED);
 
-  for (x= 0; x < 10; x++)
+  for (uint32_t x= 0; x < 10; x++)
   {
-    string= memcached_get(memc, key, strlen(key),
-                          &string_length, &flags, &rc);
+    uint32_t flags;
+    size_t string_length;
+    char *string= memcached_get(memc, key, strlen(key),
+                                &string_length, &flags, &rc);
 
     test_compare(MEMCACHED_SUCCESS, rc);
     test_true(string);
@@ -1250,7 +1251,10 @@ static test_return_t mget_end(memcached_st *memc)
     test_compare(MEMCACHED_SUCCESS, rc);
     int val = 0;
     if (key_length == 4)
+    {
       val= 1;
+    }
+
     test_compare(string_length, strlen(values[val]));
     test_true(strncmp(values[val], string, string_length) == 0);
     free(string);
@@ -1301,47 +1305,53 @@ static test_return_t stats_servername_test(memcached_st *memc)
 static test_return_t increment_test(memcached_st *memc)
 {
   uint64_t new_number;
-  memcached_return_t rc;
-  const char *key= "number";
-  const char *value= "0";
 
-  rc= memcached_set(memc, key, strlen(key),
-                    value, strlen(value),
-                    (time_t)0, (uint32_t)0);
-  test_true(rc == MEMCACHED_SUCCESS || rc == MEMCACHED_BUFFERED);
+  test_compare(MEMCACHED_SUCCESS, 
+               memcached_set(memc, 
+                             test_literal_param("number"),
+                             test_literal_param("0"),
+                             (time_t)0, (uint32_t)0));
 
-  rc= memcached_increment(memc, key, strlen(key),
-                          1, &new_number);
-  test_compare(MEMCACHED_SUCCESS, rc);
-  test_true(new_number == 1);
+  memcached_return_t rc;
+  test_compare_got(MEMCACHED_SUCCESS, 
+                   rc= memcached_increment(memc,
+                                           test_literal_param("number"),
+                                           1, &new_number),
+                   memcached_strerror(NULL, rc));
+  test_compare(1, new_number);
 
-  rc= memcached_increment(memc, key, strlen(key),
-                          1, &new_number);
-  test_compare(MEMCACHED_SUCCESS, rc);
-  test_true(new_number == 2);
+  test_compare(MEMCACHED_SUCCESS, 
+               memcached_increment(memc,
+                                   test_literal_param("number"),
+                                   1, &new_number));
+  test_compare(2, new_number);
 
   return TEST_SUCCESS;
 }
 
 static test_return_t increment_with_initial_test(memcached_st *memc)
 {
-  if (memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL) != 0)
-  {
-    uint64_t new_number;
-    memcached_return_t rc;
-    const char *key= "number";
-    uint64_t initial= 0;
+  test_skip(true, memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL));
 
-    rc= memcached_increment_with_initial(memc, key, strlen(key),
-                                         1, initial, 0, &new_number);
-    test_compare(MEMCACHED_SUCCESS, rc);
-    test_true(new_number == initial);
+  uint64_t new_number;
+  uint64_t initial= 0;
+
+  test_compare(MEMCACHED_SUCCESS, memcached_flush_buffers(memc));
+
+  memcached_return_t rc;
+  test_compare_got(MEMCACHED_SUCCESS, 
+                   rc= memcached_increment_with_initial(memc,
+                                                        test_literal_param("number"),
+                                                        1, initial, 0, &new_number),
+                   memcached_strerror(NULL, rc));
+  test_compare(new_number, initial);
+
+  test_compare(MEMCACHED_SUCCESS, 
+               memcached_increment_with_initial(memc,
+                                                test_literal_param("number"),
+                                                1, initial, 0, &new_number));
+  test_compare(new_number, (initial + 1));
 
-    rc= memcached_increment_with_initial(memc, key, strlen(key),
-                                         1, initial, 0, &new_number);
-    test_compare(MEMCACHED_SUCCESS, rc);
-    test_true(new_number == (initial + 1));
-  }
   return TEST_SUCCESS;
 }
 
@@ -1349,46 +1359,50 @@ static test_return_t decrement_test(memcached_st *memc)
 {
   uint64_t new_number;
   memcached_return_t rc;
-  const char *key= "number";
   const char *value= "3";
 
-  rc= memcached_set(memc, key, strlen(key),
+  rc= memcached_set(memc,
+                    test_literal_param("number"),
                     value, strlen(value),
                     (time_t)0, (uint32_t)0);
   test_true(rc == MEMCACHED_SUCCESS || rc == MEMCACHED_BUFFERED);
 
-  rc= memcached_decrement(memc, key, strlen(key),
-                          1, &new_number);
-  test_compare(MEMCACHED_SUCCESS, rc);
-  test_true(new_number == 2);
+  test_compare(MEMCACHED_SUCCESS,
+               memcached_decrement(memc,
+                                   test_literal_param("number"),
+                                   1, &new_number));
+  test_compare(new_number, 2);
 
-  rc= memcached_decrement(memc, key, strlen(key),
-                          1, &new_number);
-  test_compare(MEMCACHED_SUCCESS, rc);
-  test_true(new_number == 1);
+  test_compare(MEMCACHED_SUCCESS,
+               memcached_decrement(memc,
+                                   test_literal_param("number"),
+                                   1, &new_number));
+  test_compare(new_number, 1);
 
   return TEST_SUCCESS;
 }
 
 static test_return_t decrement_with_initial_test(memcached_st *memc)
 {
-  if (memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL) != 0)
-  {
-    uint64_t new_number;
-    memcached_return_t rc;
-    const char *key= "number";
-    uint64_t initial= 3;
+  test_skip(true, memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL));
 
-    rc= memcached_decrement_with_initial(memc, key, strlen(key),
-                                         1, initial, 0, &new_number);
-    test_compare(MEMCACHED_SUCCESS, rc);
-    test_true(new_number == initial);
+  uint64_t new_number;
+  uint64_t initial= 3;
+
+  test_compare(MEMCACHED_SUCCESS, memcached_flush_buffers(memc));
+
+  test_compare(MEMCACHED_SUCCESS,
+               memcached_decrement_with_initial(memc,
+                                                test_literal_param("number"),
+                                                1, initial, 0, &new_number));
+  test_compare(new_number, initial);
+
+  test_compare(MEMCACHED_SUCCESS,
+               memcached_decrement_with_initial(memc,
+                                                test_literal_param("number"),
+                                                1, initial, 0, &new_number));
+  test_compare(new_number, (initial - 1));
 
-    rc= memcached_decrement_with_initial(memc, key, strlen(key),
-                                         1, initial, 0, &new_number);
-    test_compare(MEMCACHED_SUCCESS, rc);
-    test_true(new_number == (initial - 1));
-  }
   return TEST_SUCCESS;
 }
 
@@ -1404,43 +1418,43 @@ static test_return_t increment_by_key_test(memcached_st *memc)
                            key, strlen(key),
                            value, strlen(value),
                            (time_t)0, (uint32_t)0);
-  test_true(rc == MEMCACHED_SUCCESS || rc == MEMCACHED_BUFFERED);
+  test_true(rc == MEMCACHED_SUCCESS or rc == MEMCACHED_BUFFERED);
 
-  rc= memcached_increment_by_key(memc, master_key, strlen(master_key), key, strlen(key),
-                                 1, &new_number);
-  test_compare(MEMCACHED_SUCCESS, rc);
-  test_true(new_number == 1);
+  test_compare(MEMCACHED_SUCCESS,
+               memcached_increment_by_key(memc, master_key, strlen(master_key), key, strlen(key),
+                                          1, &new_number));
+  test_compare(new_number, 1);
 
-  rc= memcached_increment_by_key(memc, master_key, strlen(master_key), key, strlen(key),
-                                 1, &new_number);
-  test_compare(MEMCACHED_SUCCESS, rc);
-  test_true(new_number == 2);
+  test_compare(MEMCACHED_SUCCESS,
+               memcached_increment_by_key(memc, master_key, strlen(master_key), key, strlen(key),
+                                          1, &new_number));
+  test_compare(new_number, 2);
 
   return TEST_SUCCESS;
 }
 
 static test_return_t increment_with_initial_by_key_test(memcached_st *memc)
 {
-  if (memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL) != 0)
-  {
-    uint64_t new_number;
-    memcached_return_t rc;
-    const char *master_key= "foo";
-    const char *key= "number";
-    uint64_t initial= 0;
+  test_skip(true, memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL));
 
-    rc= memcached_increment_with_initial_by_key(memc, master_key, strlen(master_key),
-                                                key, strlen(key),
-                                                1, initial, 0, &new_number);
-    test_compare(MEMCACHED_SUCCESS, rc);
-    test_true(new_number == initial);
+  uint64_t new_number;
+  memcached_return_t rc;
+  const char *master_key= "foo";
+  const char *key= "number";
+  uint64_t initial= 0;
+
+  rc= memcached_increment_with_initial_by_key(memc, master_key, strlen(master_key),
+                                              key, strlen(key),
+                                              1, initial, 0, &new_number);
+  test_compare(MEMCACHED_SUCCESS, rc);
+  test_true(new_number == initial);
+
+  rc= memcached_increment_with_initial_by_key(memc, master_key, strlen(master_key),
+                                              key, strlen(key),
+                                              1, initial, 0, &new_number);
+  test_compare(MEMCACHED_SUCCESS, rc);
+  test_true(new_number == (initial + 1));
 
-    rc= memcached_increment_with_initial_by_key(memc, master_key, strlen(master_key),
-                                                key, strlen(key),
-                                                1, initial, 0, &new_number);
-    test_compare(MEMCACHED_SUCCESS, rc);
-    test_true(new_number == (initial + 1));
-  }
   return TEST_SUCCESS;
 }
 
@@ -1448,52 +1462,53 @@ static test_return_t decrement_by_key_test(memcached_st *memc)
 {
   uint64_t new_number;
   memcached_return_t rc;
-  const char *master_key= "foo";
-  const char *key= "number";
   const char *value= "3";
 
-  rc= memcached_set_by_key(memc, master_key, strlen(master_key),
-                           key, strlen(key),
+  rc= memcached_set_by_key(memc,
+                           test_literal_param("foo"),
+                           test_literal_param("number"),
                            value, strlen(value),
                            (time_t)0, (uint32_t)0);
   test_true(rc == MEMCACHED_SUCCESS || rc == MEMCACHED_BUFFERED);
 
-  rc= memcached_decrement_by_key(memc, master_key, strlen(master_key),
-                                 key, strlen(key),
-                                 1, &new_number);
-  test_compare(MEMCACHED_SUCCESS, rc);
-  test_true(new_number == 2);
+  test_compare(MEMCACHED_SUCCESS,
+               memcached_decrement_by_key(memc,
+                                          test_literal_param("foo"),
+                                          test_literal_param("number"),
+                                          1, &new_number));
+  test_compare(new_number, 2);
 
-  rc= memcached_decrement_by_key(memc, master_key, strlen(master_key),
-                                 key, strlen(key),
-                                 1, &new_number);
-  test_compare(MEMCACHED_SUCCESS, rc);
-  test_true(new_number == 1);
+  test_compare(MEMCACHED_SUCCESS,
+               memcached_decrement_by_key(memc,
+                                          test_literal_param("foo"),
+                                          test_literal_param("number"),
+                                          1, &new_number));
+  test_compare(new_number, 1);
 
   return TEST_SUCCESS;
 }
 
 static test_return_t decrement_with_initial_by_key_test(memcached_st *memc)
 {
-  if (memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL) != 0)
-  {
-    uint64_t new_number;
-    const char *master_key= "foo";
-    const char *key= "number";
-    uint64_t initial= 3;
+  test_skip(true, memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL));
 
-    test_compare(MEMCACHED_SUCCESS,
-                 memcached_decrement_with_initial_by_key(memc, master_key, strlen(master_key),
-                                                         key, strlen(key),
-                                                         1, initial, 0, &new_number));
-    test_compare(new_number, initial);
+  uint64_t new_number;
+  uint64_t initial= 3;
+
+  test_compare(MEMCACHED_SUCCESS,
+               memcached_decrement_with_initial_by_key(memc,
+                                                       test_literal_param("foo"),
+                                                       test_literal_param("number"),
+                                                       1, initial, 0, &new_number));
+  test_compare(new_number, initial);
+
+  test_compare(MEMCACHED_SUCCESS,
+               memcached_decrement_with_initial_by_key(memc,
+                                                       test_literal_param("foo"),
+                                                       test_literal_param("number"),
+                                                       1, initial, 0, &new_number));
+  test_compare(new_number, (initial - 1));
 
-    test_compare(MEMCACHED_SUCCESS,
-                 memcached_decrement_with_initial_by_key(memc, master_key, strlen(master_key),
-                                                         key, strlen(key),
-                                                         1, initial, 0, &new_number));
-    test_compare(new_number, (initial - 1));
-  }
   return TEST_SUCCESS;
 }
 
@@ -1562,10 +1577,10 @@ static test_return_t mget_result_test(memcached_st *memc)
     test_true(results);
     test_true(&results_obj == results);
     test_compare(MEMCACHED_SUCCESS, rc);
-    test_compare(memcached_result_key_length(results), memcached_result_length(results));
     test_memcmp(memcached_result_key_value(results),
                 memcached_result_value(results),
                 memcached_result_length(results));
+    test_compare(memcached_result_key_length(results), memcached_result_length(results));
   }
 
   memcached_result_free(&results_obj);
@@ -1611,7 +1626,7 @@ static test_return_t mget_result_alloc_test(memcached_st *memc)
   {
     test_true(results);
     test_compare(MEMCACHED_SUCCESS, rc);
-    test_true(memcached_result_key_length(results) == memcached_result_length(results));
+    test_compare(memcached_result_key_length(results), memcached_result_length(results));
     test_memcmp(memcached_result_key_value(results),
                 memcached_result_value(results),
                 memcached_result_length(results));
@@ -1710,8 +1725,11 @@ static test_return_t mget_test(memcached_st *memc)
   {
     test_true(return_value);
     test_compare(MEMCACHED_SUCCESS, rc);
-    test_true(return_key_length == return_value_length);
-    test_memcmp(return_value, return_key, return_value_length);
+    if (not memc->prefix_key)
+    {
+      test_compare(return_key_length, return_value_length);
+      test_memcmp(return_value, return_key, return_value_length);
+    }
     free(return_value);
     x++;
   }
@@ -1877,7 +1895,7 @@ static test_return_t get_stats(memcached_st *memc)
  {
    char **stat_list= memcached_stat_get_keys(memc, memc_stat+x, &rc);
    test_compare(MEMCACHED_SUCCESS, rc);
-   for (char **ptr= stat_list; *ptr; ptr++);
+   for (char **ptr= stat_list; *ptr; ptr++) {};
 
    free(stat_list);
  }
@@ -2268,7 +2286,7 @@ static test_return_t user_supplied_bug3(memcached_st *memc)
     keys[x]= strdup(key);
     test_true(keys[x]);
     key_lengths[x]= key_length;
-    test_compare(key_length, strlen(keys[x]));
+    test_compare(size_t(key_length), strlen(keys[x]));
   }
 
   test_compare(MEMCACHED_SUCCESS,
@@ -2802,7 +2820,6 @@ static test_return_t user_supplied_bug15(memcached_st *memc)
   uint32_t x;
   memcached_return_t rc;
   const char *key= "mykey";
-  char *value;
   size_t length;
   uint32_t flags;
 
@@ -2814,13 +2831,13 @@ static test_return_t user_supplied_bug15(memcached_st *memc)
 
     test_compare(MEMCACHED_SUCCESS, rc);
 
-    value= memcached_get(memc, key, strlen(key),
-                         &length, &flags, &rc);
+    char *value= memcached_get(memc, key, strlen(key),
+                               &length, &flags, &rc);
 
     test_compare(MEMCACHED_SUCCESS, rc);
-    test_true(value == NULL);
-    test_true(length == 0);
-    test_true(flags == 0);
+    test_false(value);
+    test_false(length);
+    test_false(flags);
 
     value= memcached_get(memc, key, strlen(key),
                          &length, &flags, &rc);
@@ -2893,19 +2910,14 @@ static test_return_t user_supplied_bug17(memcached_st *memc)
   From Andrei on IRC
 */
 
-static test_return_t user_supplied_bug19(memcached_st *not_used)
+static test_return_t user_supplied_bug19(memcached_st *)
 {
-  memcached_st *memc;
-  const memcached_server_st *server;
   memcached_return_t res;
 
-  (void)not_used;
-
-  memc= memcached_create(NULL);
-  memcached_server_add_with_weight(memc, "localhost", 11311, 100);
-  memcached_server_add_with_weight(memc, "localhost", 11312, 100);
+  memcached_st *memc= memcached(test_literal_param("--server=localhost:11311/?100 --server=localhost:11312/?100"));
 
-  server= memcached_server_by_key(memc, "a", 1, &res);
+  const memcached_server_st *server= memcached_server_by_key(memc, "a", 1, &res);
+  test_true(server);
 
   memcached_free(memc);
 
@@ -3469,6 +3481,71 @@ static test_return_t mget_read_result(memcached_st *memc)
   return TEST_SUCCESS;
 }
 
+static test_return_t mget_read_internal_result(memcached_st *memc)
+{
+
+  test_skip(true, bool(libmemcached_util_version_check(memc, 1, 4, 4)));
+
+  test_compare(MEMCACHED_SUCCESS,
+               memcached_mget(memc, global_keys, global_keys_length, global_count));
+  {
+    memcached_result_st *results= NULL;
+    memcached_return_t rc;
+    while ((results= memcached_fetch_result(memc, results, &rc)))
+    {
+      test_true(results);
+      test_compare(MEMCACHED_SUCCESS, rc);
+    }
+    test_compare(MEMCACHED_END, rc);
+
+    memcached_result_free(results);
+  }
+
+  return TEST_SUCCESS;
+}
+
+static test_return_t mget_read_partial_result(memcached_st *memc)
+{
+
+  test_skip(true, bool(libmemcached_util_version_check(memc, 1, 4, 4)));
+
+  test_compare(MEMCACHED_SUCCESS,
+               memcached_mget(memc, global_keys, global_keys_length, global_count));
+
+  // We will scan for just one key
+  {
+    memcached_result_st results_obj;
+    memcached_result_st *results= memcached_result_create(memc, &results_obj);
+
+    memcached_return_t rc;
+    results= memcached_fetch_result(memc, results, &rc);
+    test_true(results);
+    test_compare(MEMCACHED_SUCCESS, rc);
+
+    memcached_result_free(&results_obj);
+  }
+
+  // We already have a read happening, lets start up another one.
+  test_compare(MEMCACHED_SUCCESS,
+               memcached_mget(memc, global_keys, global_keys_length, global_count));
+  {
+    memcached_result_st results_obj;
+    memcached_result_st *results= memcached_result_create(memc, &results_obj);
+
+    memcached_return_t rc;
+    while ((results= memcached_fetch_result(memc, &results_obj, &rc)))
+    {
+      test_true(results);
+      test_compare(MEMCACHED_SUCCESS, rc);
+    }
+    test_compare(MEMCACHED_END, rc);
+
+    memcached_result_free(&results_obj);
+  }
+
+  return TEST_SUCCESS;
+}
+
 static test_return_t mget_read_function(memcached_st *memc)
 {
   test_skip(true, bool(libmemcached_util_version_check(memc, 1, 4, 4)));
@@ -3834,40 +3911,40 @@ static void *my_calloc(const memcached_st *ptr, size_t nelem, const size_t size,
 #endif
 }
 
-static test_return_t set_prefix(memcached_st *memc)
+static test_return_t selection_of_namespace_tests(memcached_st *memc)
 {
   memcached_return_t rc;
   const char *key= "mine";
   char *value;
 
   /* Make sure be default none exists */
-  value= (char*)memcached_callback_get(memc, MEMCACHED_CALLBACK_PREFIX_KEY, &rc);
-  test_true(rc == MEMCACHED_FAILURE);
+  value= (char*)memcached_callback_get(memc, MEMCACHED_CALLBACK_NAMESPACE, &rc);
+  test_compare_got(MEMCACHED_FAILURE, rc, memcached_strerror(NULL, rc));
 
   /* Test a clean set */
-  rc= memcached_callback_set(memc, MEMCACHED_CALLBACK_PREFIX_KEY, (void *)key);
-  test_true_got(rc == MEMCACHED_SUCCESS, memcached_last_error_message(memc));
+  test_compare(MEMCACHED_SUCCESS,
+               memcached_callback_set(memc, MEMCACHED_CALLBACK_NAMESPACE, (void *)key));
 
-  value= (char*)memcached_callback_get(memc, MEMCACHED_CALLBACK_PREFIX_KEY, &rc);
+  value= (char*)memcached_callback_get(memc, MEMCACHED_CALLBACK_NAMESPACE, &rc);
   test_true(value);
   test_memcmp(value, key, 4);
-  test_compare(MEMCACHED_SUCCESS, rc);
+  test_compare_got(MEMCACHED_SUCCESS, rc, memcached_strerror(NULL, rc));
 
   /* Test that we can turn it off */
-  rc= memcached_callback_set(memc, MEMCACHED_CALLBACK_PREFIX_KEY, NULL);
-  test_compare(MEMCACHED_SUCCESS, rc);
+  test_compare(MEMCACHED_SUCCESS,
+               memcached_callback_set(memc, MEMCACHED_CALLBACK_NAMESPACE, NULL));
 
-  value= (char*)memcached_callback_get(memc, MEMCACHED_CALLBACK_PREFIX_KEY, &rc);
+  value= (char*)memcached_callback_get(memc, MEMCACHED_CALLBACK_NAMESPACE, &rc);
   test_false(value);
-  test_true(rc == MEMCACHED_FAILURE);
+  test_compare_got(MEMCACHED_FAILURE, rc, memcached_strerror(NULL, rc));
 
   /* Now setup for main test */
-  rc= memcached_callback_set(memc, MEMCACHED_CALLBACK_PREFIX_KEY, (void *)key);
-  test_compare(MEMCACHED_SUCCESS, rc);
+  test_compare(MEMCACHED_SUCCESS,
+               memcached_callback_set(memc, MEMCACHED_CALLBACK_NAMESPACE, (void *)key));
 
-  value= (char *)memcached_callback_get(memc, MEMCACHED_CALLBACK_PREFIX_KEY, &rc);
+  value= (char *)memcached_callback_get(memc, MEMCACHED_CALLBACK_NAMESPACE, &rc);
   test_true(value);
-  test_compare(MEMCACHED_SUCCESS, rc);
+  test_compare_got(MEMCACHED_SUCCESS, rc, memcached_strerror(NULL, rc));
   test_memcmp(value, key, 4);
 
   /* Set to Zero, and then Set to something too large */
@@ -3875,10 +3952,10 @@ static test_return_t set_prefix(memcached_st *memc)
     char long_key[255];
     memset(long_key, 0, 255);
 
-    rc= memcached_callback_set(memc, MEMCACHED_CALLBACK_PREFIX_KEY, NULL);
-    test_compare(MEMCACHED_SUCCESS, rc);
+    test_compare(MEMCACHED_SUCCESS,
+                 memcached_callback_set(memc, MEMCACHED_CALLBACK_NAMESPACE, NULL));
 
-    value= (char*)memcached_callback_get(memc, MEMCACHED_CALLBACK_PREFIX_KEY, &rc);
+    value= (char*)memcached_callback_get(memc, MEMCACHED_CALLBACK_NAMESPACE, &rc);
     test_false(value);
     test_true(rc == MEMCACHED_FAILURE);
     test_true(value == NULL);
@@ -3886,27 +3963,55 @@ static test_return_t set_prefix(memcached_st *memc)
     /* Test a long key for failure */
     /* TODO, extend test to determine based on setting, what result should be */
     strncpy(long_key, "Thisismorethentheallottednumberofcharacters", sizeof(long_key));
-    rc= memcached_callback_set(memc, MEMCACHED_CALLBACK_PREFIX_KEY, long_key);
-    //test_compare(MEMCACHED_BAD_KEY_PROVIDED, rc);
-    test_compare(MEMCACHED_SUCCESS, rc);
+    test_compare(MEMCACHED_SUCCESS, 
+                 memcached_callback_set(memc, MEMCACHED_CALLBACK_NAMESPACE, long_key));
 
     /* Now test a key with spaces (which will fail from long key, since bad key is not set) */
     strncpy(long_key, "This is more then the allotted number of characters", sizeof(long_key));
-    test_compare(MEMCACHED_BAD_KEY_PROVIDED,
-                 memcached_callback_set(memc, MEMCACHED_CALLBACK_PREFIX_KEY, long_key));
+    test_compare(memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL) ? MEMCACHED_SUCCESS : MEMCACHED_BAD_KEY_PROVIDED,
+                 memcached_callback_set(memc, MEMCACHED_CALLBACK_NAMESPACE, long_key));
 
     /* Test for a bad prefix, but with a short key */
-    test_compare(MEMCACHED_SUCCESS,
-                 memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_VERIFY_KEY, 1));
+    test_compare_got(memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL) ? MEMCACHED_INVALID_ARGUMENTS : MEMCACHED_SUCCESS,
+                     rc= memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_VERIFY_KEY, 1),
+                     memcached_strerror(NULL, rc));
 
-    strncpy(long_key, "dog cat", sizeof(long_key));
-    test_compare(MEMCACHED_BAD_KEY_PROVIDED,
-                 memcached_callback_set(memc, MEMCACHED_CALLBACK_PREFIX_KEY, long_key));
+    test_compare(memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL) ? MEMCACHED_SUCCESS : MEMCACHED_BAD_KEY_PROVIDED,
+                 memcached_callback_set(memc, MEMCACHED_CALLBACK_NAMESPACE, "dog cat"));
   }
 
   return TEST_SUCCESS;
 }
 
+static test_return_t set_namespace(memcached_st *memc)
+{
+  memcached_return_t rc;
+  const char *key= "mine";
+  char *value;
+
+  /* Make sure be default none exists */
+  value= (char*)memcached_callback_get(memc, MEMCACHED_CALLBACK_NAMESPACE, &rc);
+  test_compare_got(MEMCACHED_FAILURE, rc, memcached_strerror(NULL, rc));
+
+  /* Test a clean set */
+  test_compare(MEMCACHED_SUCCESS,
+               memcached_callback_set(memc, MEMCACHED_CALLBACK_NAMESPACE, (void *)key));
+
+  value= (char*)memcached_callback_get(memc, MEMCACHED_CALLBACK_NAMESPACE, &rc);
+  test_true(value);
+  test_memcmp(value, key, 4);
+  test_compare_got(MEMCACHED_SUCCESS, rc, memcached_strerror(NULL, rc));
+
+  return TEST_SUCCESS;
+}
+
+static test_return_t set_namespace_and_binary(memcached_st *memc)
+{
+  test_return_if(pre_binary(memc));
+  test_return_if(set_namespace(memc));
+
+  return TEST_SUCCESS;
+}
 
 #ifdef MEMCACHED_ENABLE_DEPRECATED
 static test_return_t deprecated_set_memory_alloc(memcached_st *memc)
@@ -4765,26 +4870,18 @@ static test_return_t memcached_get_hashkit_test (memcached_st *memc)
   We are testing the error condition when we connect to a server via memcached_get()
   but find that the server is not available.
 */
-static test_return_t memcached_get_MEMCACHED_ERRNO(memcached_st *memc)
+static test_return_t memcached_get_MEMCACHED_ERRNO(memcached_st *)
 {
-  (void)memc;
-  memcached_st *tl_memc_h;
-
   const char *key= "MemcachedLives";
   size_t len;
   uint32_t flags;
   memcached_return rc;
-  char *value;
 
   // Create a handle.
-  tl_memc_h= memcached_create(NULL);
-  memcached_server_st *servers= memcached_servers_parse("localhost:9898,localhost:9899"); // This server should not exist
-  test_true(servers);
-  memcached_server_push(tl_memc_h, servers);
-  memcached_server_list_free(servers);
+  memcached_st *tl_memc_h= memcached(test_literal_param("--server=localhost:9898 --server=localhost:9899")); // This server should not exist
 
   // See if memcached is reachable.
-  value= memcached_get(tl_memc_h, key, strlen(key), &len, &flags, &rc);
+  char *value= memcached_get(tl_memc_h, key, strlen(key), &len, &flags, &rc);
 
   test_false(value);
   test_compare(0, len);
@@ -5778,6 +5875,10 @@ static test_return_t regression_bug_655423(memcached_st *memc)
   test_true(clone);
   char payload[100];
 
+#ifdef __APPLE__
+  return TEST_SKIPPED;
+#endif
+
   test_skip(MEMCACHED_SUCCESS, memcached_behavior_set(clone, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL, 1));
   test_skip(MEMCACHED_SUCCESS, memcached_behavior_set(clone, MEMCACHED_BEHAVIOR_SUPPORT_CAS, 1));
   test_skip(MEMCACHED_SUCCESS, memcached_behavior_set(clone, MEMCACHED_BEHAVIOR_TCP_NODELAY, 1));
@@ -5787,7 +5888,7 @@ static test_return_t regression_bug_655423(memcached_st *memc)
 
   for (uint32_t x= 0; x < regression_bug_655423_COUNT; x++)
   {
-    char key[1024];
+    char key[MEMCACHED_MAXIMUM_INTEGER_DISPLAY_LENGTH +1];
     snprintf(key, sizeof(key), "%u", x);
 
     test_compare(MEMCACHED_SUCCESS, memcached_set(clone, key, strlen(key), payload, sizeof(payload), 0, 0));
@@ -5795,7 +5896,7 @@ static test_return_t regression_bug_655423(memcached_st *memc)
 
   for (uint32_t x= 0; x < regression_bug_655423_COUNT; x++)
   {
-    char key[1024];
+    char key[MEMCACHED_MAXIMUM_INTEGER_DISPLAY_LENGTH +1];
     snprintf(key, sizeof(key), "%u", x);
 
     size_t value_length;
@@ -5819,11 +5920,13 @@ static test_return_t regression_bug_655423(memcached_st *memc)
   size_t *key_length= (size_t *)calloc(regression_bug_655423_COUNT, sizeof(size_t));
   for (uint32_t x= 0; x < regression_bug_655423_COUNT; x++)
   {
-    char key[1024];
+    char key[MEMCACHED_MAXIMUM_INTEGER_DISPLAY_LENGTH +1];
     snprintf(key, sizeof(key), "%u", x);
 
     keys[x]= strdup(key);
+    test_true(keys[x]);
     key_length[x]= strlen(key);
+    test_true(key_length[x]);
   }
 
   memcached_return_t rc;
@@ -6038,155 +6141,155 @@ static test_return_t sasl_auth_test(memcached_st *memc)
 
 /* Clean the server before beginning testing */
 test_st tests[] ={
-  {"util_version", 1, (test_callback_fn)util_version_test },
-  {"flush", 0, (test_callback_fn)flush_test },
-  {"init", 0, (test_callback_fn)init_test },
-  {"allocation", 0, (test_callback_fn)allocation_test },
-  {"server_list_null_test", 0, (test_callback_fn)server_list_null_test},
-  {"server_unsort", 0, (test_callback_fn)server_unsort_test},
-  {"server_sort", 0, (test_callback_fn)server_sort_test},
-  {"server_sort2", 0, (test_callback_fn)server_sort2_test},
-  {"memcached_server_remove", 0, (test_callback_fn)memcached_server_remove_test},
-  {"clone_test", 0, (test_callback_fn)clone_test },
-  {"connection_test", 0, (test_callback_fn)connection_test},
-  {"callback_test", 0, (test_callback_fn)callback_test},
-  {"userdata_test", 0, (test_callback_fn)userdata_test},
-  {"error", 0, (test_callback_fn)error_test },
-  {"set", 0, (test_callback_fn)set_test },
-  {"set2", 0, (test_callback_fn)set_test2 },
-  {"set3", 0, (test_callback_fn)set_test3 },
-  {"dump", 1, (test_callback_fn)dump_test},
-  {"add", 1, (test_callback_fn)add_test },
-  {"memcached_fetch_result(MEMCACHED_NOTFOUND)", 1, (test_callback_fn)memcached_fetch_result_NOT_FOUND },
-  {"replace", 1, (test_callback_fn)replace_test },
-  {"delete", 1, (test_callback_fn)delete_test },
-  {"get", 1, (test_callback_fn)get_test },
-  {"get2", 0, (test_callback_fn)get_test2 },
-  {"get3", 0, (test_callback_fn)get_test3 },
-  {"get4", 0, (test_callback_fn)get_test4 },
-  {"partial mget", 0, (test_callback_fn)get_test5 },
-  {"stats_servername", 0, (test_callback_fn)stats_servername_test },
-  {"increment", 0, (test_callback_fn)increment_test },
-  {"increment_with_initial", 1, (test_callback_fn)increment_with_initial_test },
-  {"decrement", 0, (test_callback_fn)decrement_test },
-  {"decrement_with_initial", 1, (test_callback_fn)decrement_with_initial_test },
-  {"increment_by_key", 0, (test_callback_fn)increment_by_key_test },
-  {"increment_with_initial_by_key", 1, (test_callback_fn)increment_with_initial_by_key_test },
-  {"decrement_by_key", 0, (test_callback_fn)decrement_by_key_test },
-  {"decrement_with_initial_by_key", 1, (test_callback_fn)decrement_with_initial_by_key_test },
-  {"quit", 0, (test_callback_fn)quit_test },
-  {"mget", 1, (test_callback_fn)mget_test },
-  {"mget_result", 1, (test_callback_fn)mget_result_test },
-  {"mget_result_alloc", 1, (test_callback_fn)mget_result_alloc_test },
-  {"mget_result_function", 1, (test_callback_fn)mget_result_function },
-  {"mget_execute", 1, (test_callback_fn)mget_execute },
-  {"mget_end", 0, (test_callback_fn)mget_end },
-  {"get_stats", 0, (test_callback_fn)get_stats },
-  {"add_host_test", 0, (test_callback_fn)add_host_test },
-  {"add_host_test_1", 0, (test_callback_fn)add_host_test1 },
-  {"get_stats_keys", 0, (test_callback_fn)get_stats_keys },
-  {"version_string_test", 0, (test_callback_fn)version_string_test},
-  {"bad_key", 1, (test_callback_fn)bad_key_test },
-  {"memcached_server_cursor", 1, (test_callback_fn)memcached_server_cursor_test },
-  {"read_through", 1, (test_callback_fn)read_through },
-  {"delete_through", 1, (test_callback_fn)delete_through },
-  {"noreply", 1, (test_callback_fn)noreply_test},
-  {"analyzer", 1, (test_callback_fn)analyzer_test},
-  {"connectionpool", 1, (test_callback_fn)connection_pool_test },
-  {"memcached_pool_test", 1, (test_callback_fn)memcached_pool_test },
-  {"ping", 1, (test_callback_fn)ping_test },
-  {"test_get_last_disconnect", 1, (test_callback_fn)test_get_last_disconnect},
-  {"verbosity", 1, (test_callback_fn)test_verbosity},
-  {"test_server_failure", 1, (test_callback_fn)test_server_failure},
-  {"cull_servers", 1, (test_callback_fn)test_cull_servers},
-  {"memcached_stat_execute", 1, (test_callback_fn)memcached_stat_execute_test},
+  {"util_version", 1, (test_callback_fn*)util_version_test },
+  {"flush", 0, (test_callback_fn*)flush_test },
+  {"init", 0, (test_callback_fn*)init_test },
+  {"allocation", 0, (test_callback_fn*)allocation_test },
+  {"server_list_null_test", 0, (test_callback_fn*)server_list_null_test},
+  {"server_unsort", 0, (test_callback_fn*)server_unsort_test},
+  {"server_sort", 0, (test_callback_fn*)server_sort_test},
+  {"server_sort2", 0, (test_callback_fn*)server_sort2_test},
+  {"memcached_server_remove", 0, (test_callback_fn*)memcached_server_remove_test},
+  {"clone_test", 0, (test_callback_fn*)clone_test },
+  {"connection_test", 0, (test_callback_fn*)connection_test},
+  {"callback_test", 0, (test_callback_fn*)callback_test},
+  {"userdata_test", 0, (test_callback_fn*)userdata_test},
+  {"error", 0, (test_callback_fn*)error_test },
+  {"set", 0, (test_callback_fn*)set_test },
+  {"set2", 0, (test_callback_fn*)set_test2 },
+  {"set3", 0, (test_callback_fn*)set_test3 },
+  {"dump", 1, (test_callback_fn*)dump_test},
+  {"add", 1, (test_callback_fn*)add_test },
+  {"memcached_fetch_result(MEMCACHED_NOTFOUND)", 1, (test_callback_fn*)memcached_fetch_result_NOT_FOUND },
+  {"replace", 1, (test_callback_fn*)replace_test },
+  {"delete", 1, (test_callback_fn*)delete_test },
+  {"get", 1, (test_callback_fn*)get_test },
+  {"get2", 0, (test_callback_fn*)get_test2 },
+  {"get3", 0, (test_callback_fn*)get_test3 },
+  {"get4", 0, (test_callback_fn*)get_test4 },
+  {"partial mget", 0, (test_callback_fn*)get_test5 },
+  {"stats_servername", 0, (test_callback_fn*)stats_servername_test },
+  {"increment", 0, (test_callback_fn*)increment_test },
+  {"increment_with_initial", 1, (test_callback_fn*)increment_with_initial_test },
+  {"decrement", 0, (test_callback_fn*)decrement_test },
+  {"decrement_with_initial", 1, (test_callback_fn*)decrement_with_initial_test },
+  {"increment_by_key", 0, (test_callback_fn*)increment_by_key_test },
+  {"increment_with_initial_by_key", 1, (test_callback_fn*)increment_with_initial_by_key_test },
+  {"decrement_by_key", 0, (test_callback_fn*)decrement_by_key_test },
+  {"decrement_with_initial_by_key", 1, (test_callback_fn*)decrement_with_initial_by_key_test },
+  {"quit", 0, (test_callback_fn*)quit_test },
+  {"mget", 1, (test_callback_fn*)mget_test },
+  {"mget_result", 1, (test_callback_fn*)mget_result_test },
+  {"mget_result_alloc", 1, (test_callback_fn*)mget_result_alloc_test },
+  {"mget_result_function", 1, (test_callback_fn*)mget_result_function },
+  {"mget_execute", 1, (test_callback_fn*)mget_execute },
+  {"mget_end", 0, (test_callback_fn*)mget_end },
+  {"get_stats", 0, (test_callback_fn*)get_stats },
+  {"add_host_test", 0, (test_callback_fn*)add_host_test },
+  {"add_host_test_1", 0, (test_callback_fn*)add_host_test1 },
+  {"get_stats_keys", 0, (test_callback_fn*)get_stats_keys },
+  {"version_string_test", 0, (test_callback_fn*)version_string_test},
+  {"bad_key", 1, (test_callback_fn*)bad_key_test },
+  {"memcached_server_cursor", 1, (test_callback_fn*)memcached_server_cursor_test },
+  {"read_through", 1, (test_callback_fn*)read_through },
+  {"delete_through", 1, (test_callback_fn*)delete_through },
+  {"noreply", 1, (test_callback_fn*)noreply_test},
+  {"analyzer", 1, (test_callback_fn*)analyzer_test},
+  {"connectionpool", 1, (test_callback_fn*)connection_pool_test },
+  {"memcached_pool_test", 1, (test_callback_fn*)memcached_pool_test },
+  {"ping", 1, (test_callback_fn*)ping_test },
+  {"test_get_last_disconnect", 1, (test_callback_fn*)test_get_last_disconnect},
+  {"verbosity", 1, (test_callback_fn*)test_verbosity},
+  {"test_server_failure", 1, (test_callback_fn*)test_server_failure},
+  {"cull_servers", 1, (test_callback_fn*)test_cull_servers},
+  {"memcached_stat_execute", 1, (test_callback_fn*)memcached_stat_execute_test},
   {0, 0, 0}
 };
 
 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},
-  {"MEMCACHED_BEHAVIOR_TCP_KEEPIDLE", 0, (test_callback_fn)MEMCACHED_BEHAVIOR_TCP_KEEPIDLE_test},
+  {"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},
+  {"MEMCACHED_BEHAVIOR_TCP_KEEPIDLE", 0, (test_callback_fn*)MEMCACHED_BEHAVIOR_TCP_KEEPIDLE_test},
   {0, 0, 0}
 };
 
 test_st basic_tests[] ={
-  {"init", 1, (test_callback_fn)basic_init_test},
-  {"clone", 1, (test_callback_fn)basic_clone_test},
-  {"reset", 1, (test_callback_fn)basic_reset_stack_test},
-  {"reset heap", 1, (test_callback_fn)basic_reset_heap_test},
-  {"reset stack clone", 1, (test_callback_fn)basic_reset_stack_clone_test},
-  {"reset heap clone", 1, (test_callback_fn)basic_reset_heap_clone_test},
+  {"init", 1, (test_callback_fn*)basic_init_test},
+  {"clone", 1, (test_callback_fn*)basic_clone_test},
+  {"reset", 1, (test_callback_fn*)basic_reset_stack_test},
+  {"reset heap", 1, (test_callback_fn*)basic_reset_heap_test},
+  {"reset stack clone", 1, (test_callback_fn*)basic_reset_stack_clone_test},
+  {"reset heap clone", 1, (test_callback_fn*)basic_reset_heap_clone_test},
   {0, 0, 0}
 };
 
 test_st regression_binary_vs_block[] ={
-  {"block add", 1, (test_callback_fn)block_add_regression},
-  {"binary add", 1, (test_callback_fn)binary_add_regression},
+  {"block add", 1, (test_callback_fn*)block_add_regression},
+  {"binary add", 1, (test_callback_fn*)binary_add_regression},
   {0, 0, 0}
 };
 
 test_st async_tests[] ={
-  {"add", 1, (test_callback_fn)add_wrapper },
+  {"add", 1, (test_callback_fn*)add_wrapper },
   {0, 0, 0}
 };
 
 test_st string_tests[] ={
-  {"string static with null", 0, (test_callback_fn)string_static_null },
-  {"string alloc with null", 0, (test_callback_fn)string_alloc_null },
-  {"string alloc with 1K", 0, (test_callback_fn)string_alloc_with_size },
-  {"string alloc with malloc failure", 0, (test_callback_fn)string_alloc_with_size_toobig },
-  {"string append", 0, (test_callback_fn)string_alloc_append },
-  {"string append failure (too big)", 0, (test_callback_fn)string_alloc_append_toobig },
-  {"string_alloc_append_multiple", 0, (test_callback_fn)string_alloc_append_multiple },
-  {0, 0, (test_callback_fn)0}
+  {"string static with null", 0, (test_callback_fn*)string_static_null },
+  {"string alloc with null", 0, (test_callback_fn*)string_alloc_null },
+  {"string alloc with 1K", 0, (test_callback_fn*)string_alloc_with_size },
+  {"string alloc with malloc failure", 0, (test_callback_fn*)string_alloc_with_size_toobig },
+  {"string append", 0, (test_callback_fn*)string_alloc_append },
+  {"string append failure (too big)", 0, (test_callback_fn*)string_alloc_append_toobig },
+  {"string_alloc_append_multiple", 0, (test_callback_fn*)string_alloc_append_multiple },
+  {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}
+  {"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},
-  {0, 0, (test_callback_fn)0}
+  {"result static", 0, (test_callback_fn*)result_static},
+  {"result alloc", 0, (test_callback_fn*)result_alloc},
+  {0, 0, (test_callback_fn*)0}
 };
 
 test_st version_1_2_3[] ={
-  {"append", 0, (test_callback_fn)append_test },
-  {"prepend", 0, (test_callback_fn)prepend_test },
-  {"cas", 0, (test_callback_fn)cas_test },
-  {"cas2", 0, (test_callback_fn)cas2_test },
-  {"append_binary", 0, (test_callback_fn)append_binary_test },
-  {0, 0, (test_callback_fn)0}
+  {"append", 0, (test_callback_fn*)append_test },
+  {"prepend", 0, (test_callback_fn*)prepend_test },
+  {"cas", 0, (test_callback_fn*)cas_test },
+  {"cas2", 0, (test_callback_fn*)cas2_test },
+  {"append_binary", 0, (test_callback_fn*)append_binary_test },
+  {0, 0, (test_callback_fn*)0}
 };
 
 test_st haldenbrand_tests[] ={
-  {"memcached_set", 0, (test_callback_fn)user_supplied_bug1 },
-  {"memcached_get()", 0, (test_callback_fn)user_supplied_bug2 },
-  {"memcached_mget()", 0, (test_callback_fn)user_supplied_bug3 },
-  {0, 0, (test_callback_fn)0}
+  {"memcached_set", 0, (test_callback_fn*)user_supplied_bug1 },
+  {"memcached_get()", 0, (test_callback_fn*)user_supplied_bug2 },
+  {"memcached_mget()", 0, (test_callback_fn*)user_supplied_bug3 },
+  {0, 0, (test_callback_fn*)0}
 };
 
 test_st user_tests[] ={
-  {"user_supplied_bug4", true, (test_callback_fn)user_supplied_bug4 },
-  {"user_supplied_bug5", 1, (test_callback_fn)user_supplied_bug5 },
-  {"user_supplied_bug6", 1, (test_callback_fn)user_supplied_bug6 },
-  {"user_supplied_bug7", 1, (test_callback_fn)user_supplied_bug7 },
-  {"user_supplied_bug8", 1, (test_callback_fn)user_supplied_bug8 },
-  {"user_supplied_bug9", 1, (test_callback_fn)user_supplied_bug9 },
-  {"user_supplied_bug10", 1, (test_callback_fn)user_supplied_bug10 },
-  {"user_supplied_bug11", 1, (test_callback_fn)user_supplied_bug11 },
-  {"user_supplied_bug12", 1, (test_callback_fn)user_supplied_bug12 },
-  {"user_supplied_bug13", 1, (test_callback_fn)user_supplied_bug13 },
-  {"user_supplied_bug14", 1, (test_callback_fn)user_supplied_bug14 },
-  {"user_supplied_bug15", 1, (test_callback_fn)user_supplied_bug15 },
-  {"user_supplied_bug16", 1, (test_callback_fn)user_supplied_bug16 },
+  {"user_supplied_bug4", true, (test_callback_fn*)user_supplied_bug4 },
+  {"user_supplied_bug5", 1, (test_callback_fn*)user_supplied_bug5 },
+  {"user_supplied_bug6", 1, (test_callback_fn*)user_supplied_bug6 },
+  {"user_supplied_bug7", 1, (test_callback_fn*)user_supplied_bug7 },
+  {"user_supplied_bug8", 1, (test_callback_fn*)user_supplied_bug8 },
+  {"user_supplied_bug9", 1, (test_callback_fn*)user_supplied_bug9 },
+  {"user_supplied_bug10", 1, (test_callback_fn*)user_supplied_bug10 },
+  {"user_supplied_bug11", 1, (test_callback_fn*)user_supplied_bug11 },
+  {"user_supplied_bug12", 1, (test_callback_fn*)user_supplied_bug12 },
+  {"user_supplied_bug13", 1, (test_callback_fn*)user_supplied_bug13 },
+  {"user_supplied_bug14", 1, (test_callback_fn*)user_supplied_bug14 },
+  {"user_supplied_bug15", 1, (test_callback_fn*)user_supplied_bug15 },
+  {"user_supplied_bug16", 1, (test_callback_fn*)user_supplied_bug16 },
 #if !defined(__sun) && !defined(__OpenBSD__)
   /*
   ** It seems to be something weird with the character sets..
@@ -6195,25 +6298,25 @@ test_st user_tests[] ={
   ** to run the test in a specific locale (I tried zh_CN.UTF-8 without success,
   ** so just disable the code for now...).
   */
-  {"user_supplied_bug17", 1, (test_callback_fn)user_supplied_bug17 },
+  {"user_supplied_bug17", 1, (test_callback_fn*)user_supplied_bug17 },
 #endif
-  {"user_supplied_bug18", 1, (test_callback_fn)user_supplied_bug18 },
-  {"user_supplied_bug19", 1, (test_callback_fn)user_supplied_bug19 },
-  {"user_supplied_bug20", 1, (test_callback_fn)user_supplied_bug20 },
-  {"user_supplied_bug21", 1, (test_callback_fn)user_supplied_bug21 },
-  {"wrong_failure_counter_test", 1, (test_callback_fn)wrong_failure_counter_test},
-  {"wrong_failure_counter_two_test", 1, (test_callback_fn)wrong_failure_counter_two_test},
-  {0, 0, (test_callback_fn)0}
+  {"user_supplied_bug18", 1, (test_callback_fn*)user_supplied_bug18 },
+  {"user_supplied_bug19", 1, (test_callback_fn*)user_supplied_bug19 },
+  {"user_supplied_bug20", 1, (test_callback_fn*)user_supplied_bug20 },
+  {"user_supplied_bug21", 1, (test_callback_fn*)user_supplied_bug21 },
+  {"wrong_failure_counter_test", 1, (test_callback_fn*)wrong_failure_counter_test},
+  {"wrong_failure_counter_two_test", 1, (test_callback_fn*)wrong_failure_counter_two_test},
+  {0, 0, (test_callback_fn*)0}
 };
 
 test_st replication_tests[]= {
-  {"set", 1, (test_callback_fn)replication_set_test },
-  {"get", 0, (test_callback_fn)replication_get_test },
-  {"mget", 0, (test_callback_fn)replication_mget_test },
-  {"delete", 0, (test_callback_fn)replication_delete_test },
-  {"rand_mget", 0, (test_callback_fn)replication_randomize_mget_test },
-  {"fail", 0, (test_callback_fn)replication_randomize_mget_fail_test },
-  {0, 0, (test_callback_fn)0}
+  {"set", 1, (test_callback_fn*)replication_set_test },
+  {"get", 0, (test_callback_fn*)replication_get_test },
+  {"mget", 0, (test_callback_fn*)replication_mget_test },
+  {"delete", 0, (test_callback_fn*)replication_delete_test },
+  {"rand_mget", 0, (test_callback_fn*)replication_randomize_mget_test },
+  {"fail", 0, (test_callback_fn*)replication_randomize_mget_fail_test },
+  {0, 0, (test_callback_fn*)0}
 };
 
 /*
@@ -6223,141 +6326,150 @@ test_st replication_tests[]= {
  *   http://bugs.launchpad.net/libmemcached
  */
 test_st regression_tests[]= {
-  {"lp:434484", 1, (test_callback_fn)regression_bug_434484 },
-  {"lp:434843", 1, (test_callback_fn)regression_bug_434843 },
-  {"lp:434843-buffered", 1, (test_callback_fn)regression_bug_434843_buffered },
-  {"lp:421108", 1, (test_callback_fn)regression_bug_421108 },
-  {"lp:442914", 1, (test_callback_fn)regression_bug_442914 },
-  {"lp:447342", 1, (test_callback_fn)regression_bug_447342 },
-  {"lp:463297", 1, (test_callback_fn)regression_bug_463297 },
-  {"lp:490486", 1, (test_callback_fn)regression_bug_490486 },
-  {"lp:583031", 1, (test_callback_fn)regression_bug_583031 },
-  {"lp:?", 1, (test_callback_fn)regression_bug_ },
-  {"lp:728286", 1, (test_callback_fn)regression_bug_728286 },
-  {"lp:581030", 1, (test_callback_fn)regression_bug_581030 },
-  {"lp:71231153 connect()", 1, (test_callback_fn)regression_bug_71231153_connect },
-  {"lp:71231153 poll()", 1, (test_callback_fn)regression_bug_71231153_poll },
-  {"lp:655423", 1, (test_callback_fn)regression_bug_655423 },
-  {"lp:490520", 1, (test_callback_fn)regression_bug_490520 },
-  {0, 0, (test_callback_fn)0}
+  {"lp:434484", 1, (test_callback_fn*)regression_bug_434484 },
+  {"lp:434843", 1, (test_callback_fn*)regression_bug_434843 },
+  {"lp:434843-buffered", 1, (test_callback_fn*)regression_bug_434843_buffered },
+  {"lp:421108", 1, (test_callback_fn*)regression_bug_421108 },
+  {"lp:442914", 1, (test_callback_fn*)regression_bug_442914 },
+  {"lp:447342", 1, (test_callback_fn*)regression_bug_447342 },
+  {"lp:463297", 1, (test_callback_fn*)regression_bug_463297 },
+  {"lp:490486", 1, (test_callback_fn*)regression_bug_490486 },
+  {"lp:583031", 1, (test_callback_fn*)regression_bug_583031 },
+  {"lp:?", 1, (test_callback_fn*)regression_bug_ },
+  {"lp:728286", 1, (test_callback_fn*)regression_bug_728286 },
+  {"lp:581030", 1, (test_callback_fn*)regression_bug_581030 },
+  {"lp:71231153 connect()", 1, (test_callback_fn*)regression_bug_71231153_connect },
+  {"lp:71231153 poll()", 1, (test_callback_fn*)regression_bug_71231153_poll },
+  {"lp:655423", 1, (test_callback_fn*)regression_bug_655423 },
+  {"lp:490520", 1, (test_callback_fn*)regression_bug_490520 },
+  {0, 0, (test_callback_fn*)0}
 };
 
 test_st sasl_auth_tests[]= {
-  {"sasl_auth", 1, (test_callback_fn)sasl_auth_test },
-  {0, 0, (test_callback_fn)0}
+  {"sasl_auth", 1, (test_callback_fn*)sasl_auth_test },
+  {0, 0, (test_callback_fn*)0}
 };
 
 test_st ketama_compatibility[]= {
-  {"libmemcached", 1, (test_callback_fn)ketama_compatibility_libmemcached },
-  {"spymemcached", 1, (test_callback_fn)ketama_compatibility_spymemcached },
-  {0, 0, (test_callback_fn)0}
+  {"libmemcached", 1, (test_callback_fn*)ketama_compatibility_libmemcached },
+  {"spymemcached", 1, (test_callback_fn*)ketama_compatibility_spymemcached },
+  {0, 0, (test_callback_fn*)0}
 };
 
 test_st generate_tests[] ={
-  {"generate_pairs", 1, (test_callback_fn)generate_pairs },
-  {"generate_data", 1, (test_callback_fn)generate_data },
-  {"get_read", 0, (test_callback_fn)get_read },
-  {"delete_generate", 0, (test_callback_fn)delete_generate },
-  {"generate_buffer_data", 1, (test_callback_fn)generate_buffer_data },
-  {"delete_buffer", 0, (test_callback_fn)delete_buffer_generate},
-  {"generate_data", 1, (test_callback_fn)generate_data },
-  {"mget_read", 0, (test_callback_fn)mget_read },
-  {"mget_read_result", 0, (test_callback_fn)mget_read_result },
-  {"mget_read_function", 0, (test_callback_fn)mget_read_function },
-  {"cleanup", 1, (test_callback_fn)cleanup_pairs },
-  {"generate_large_pairs", 1, (test_callback_fn)generate_large_pairs },
-  {"generate_data", 1, (test_callback_fn)generate_data },
-  {"generate_buffer_data", 1, (test_callback_fn)generate_buffer_data },
-  {"cleanup", 1, (test_callback_fn)cleanup_pairs },
-  {0, 0, (test_callback_fn)0}
+  {"generate_pairs", 1, (test_callback_fn*)generate_pairs },
+  {"generate_data", 1, (test_callback_fn*)generate_data },
+  {"get_read", 0, (test_callback_fn*)get_read },
+  {"delete_generate", 0, (test_callback_fn*)delete_generate },
+  {"generate_buffer_data", 1, (test_callback_fn*)generate_buffer_data },
+  {"delete_buffer", 0, (test_callback_fn*)delete_buffer_generate},
+  {"generate_data", 1, (test_callback_fn*)generate_data },
+  {"mget_read", 0, (test_callback_fn*)mget_read },
+  {"mget_read_result", 0, (test_callback_fn*)mget_read_result },
+  {"memcached_fetch_result() use internal result", 0, (test_callback_fn*)mget_read_internal_result },
+  {"memcached_fetch_result() partial read", 0, (test_callback_fn*)mget_read_partial_result },
+  {"mget_read_function", 0, (test_callback_fn*)mget_read_function },
+  {"cleanup", 1, (test_callback_fn*)cleanup_pairs },
+  {"generate_large_pairs", 1, (test_callback_fn*)generate_large_pairs },
+  {"generate_data", 1, (test_callback_fn*)generate_data },
+  {"generate_buffer_data", 1, (test_callback_fn*)generate_buffer_data },
+  {"cleanup", 1, (test_callback_fn*)cleanup_pairs },
+  {0, 0, (test_callback_fn*)0}
 };
 
 test_st consistent_tests[] ={
-  {"generate_pairs", 1, (test_callback_fn)generate_pairs },
-  {"generate_data", 1, (test_callback_fn)generate_data },
-  {"get_read", 0, (test_callback_fn)get_read_count },
-  {"cleanup", 1, (test_callback_fn)cleanup_pairs },
-  {0, 0, (test_callback_fn)0}
+  {"generate_pairs", 1, (test_callback_fn*)generate_pairs },
+  {"generate_data", 1, (test_callback_fn*)generate_data },
+  {"get_read", 0, (test_callback_fn*)get_read_count },
+  {"cleanup", 1, (test_callback_fn*)cleanup_pairs },
+  {0, 0, (test_callback_fn*)0}
 };
 
 test_st consistent_weighted_tests[] ={
-  {"generate_pairs", 1, (test_callback_fn)generate_pairs },
-  {"generate_data", 1, (test_callback_fn)generate_data_with_stats },
-  {"get_read", 0, (test_callback_fn)get_read_count },
-  {"cleanup", 1, (test_callback_fn)cleanup_pairs },
-  {0, 0, (test_callback_fn)0}
+  {"generate_pairs", 1, (test_callback_fn*)generate_pairs },
+  {"generate_data", 1, (test_callback_fn*)generate_data_with_stats },
+  {"get_read", 0, (test_callback_fn*)get_read_count },
+  {"cleanup", 1, (test_callback_fn*)cleanup_pairs },
+  {0, 0, (test_callback_fn*)0}
 };
 
 test_st hsieh_availability[] ={
-  {"hsieh_avaibility_test", 0, (test_callback_fn)hsieh_avaibility_test},
-  {0, 0, (test_callback_fn)0}
+  {"hsieh_avaibility_test", 0, (test_callback_fn*)hsieh_avaibility_test},
+  {0, 0, (test_callback_fn*)0}
 };
 
 test_st murmur_availability[] ={
-  {"murmur_avaibility_test", 0, (test_callback_fn)murmur_avaibility_test},
-  {0, 0, (test_callback_fn)0}
+  {"murmur_avaibility_test", 0, (test_callback_fn*)murmur_avaibility_test},
+  {0, 0, (test_callback_fn*)0}
 };
 
 #if 0
 test_st hash_sanity[] ={
-  {"hash sanity", 0, (test_callback_fn)hash_sanity_test},
-  {0, 0, (test_callback_fn)0}
+  {"hash sanity", 0, (test_callback_fn*)hash_sanity_test},
+  {0, 0, (test_callback_fn*)0}
 };
 #endif
 
 test_st ketama_auto_eject_hosts[] ={
-  {"auto_eject_hosts", 1, (test_callback_fn)auto_eject_hosts },
-  {"output_ketama_weighted_keys", 1, (test_callback_fn)output_ketama_weighted_keys },
-  {0, 0, (test_callback_fn)0}
+  {"auto_eject_hosts", 1, (test_callback_fn*)auto_eject_hosts },
+  {"output_ketama_weighted_keys", 1, (test_callback_fn*)output_ketama_weighted_keys },
+  {0, 0, (test_callback_fn*)0}
 };
 
 test_st hash_tests[] ={
-  {"one_at_a_time_run", 0, (test_callback_fn)one_at_a_time_run },
-  {"md5", 0, (test_callback_fn)md5_run },
-  {"crc", 0, (test_callback_fn)crc_run },
-  {"fnv1_64", 0, (test_callback_fn)fnv1_64_run },
-  {"fnv1a_64", 0, (test_callback_fn)fnv1a_64_run },
-  {"fnv1_32", 0, (test_callback_fn)fnv1_32_run },
-  {"fnv1a_32", 0, (test_callback_fn)fnv1a_32_run },
-  {"hsieh", 0, (test_callback_fn)hsieh_run },
-  {"murmur", 0, (test_callback_fn)murmur_run },
-  {"jenkis", 0, (test_callback_fn)jenkins_run },
-  {"memcached_get_hashkit", 0, (test_callback_fn)memcached_get_hashkit_test },
-  {0, 0, (test_callback_fn)0}
+  {"one_at_a_time_run", 0, (test_callback_fn*)one_at_a_time_run },
+  {"md5", 0, (test_callback_fn*)md5_run },
+  {"crc", 0, (test_callback_fn*)crc_run },
+  {"fnv1_64", 0, (test_callback_fn*)fnv1_64_run },
+  {"fnv1a_64", 0, (test_callback_fn*)fnv1a_64_run },
+  {"fnv1_32", 0, (test_callback_fn*)fnv1_32_run },
+  {"fnv1a_32", 0, (test_callback_fn*)fnv1a_32_run },
+  {"hsieh", 0, (test_callback_fn*)hsieh_run },
+  {"murmur", 0, (test_callback_fn*)murmur_run },
+  {"jenkis", 0, (test_callback_fn*)jenkins_run },
+  {"memcached_get_hashkit", 0, (test_callback_fn*)memcached_get_hashkit_test },
+  {0, 0, (test_callback_fn*)0}
 };
 
 test_st error_conditions[] ={
-  {"memcached_get(MEMCACHED_ERRNO)", 0, (test_callback_fn)memcached_get_MEMCACHED_ERRNO },
-  {"memcached_get(MEMCACHED_NOTFOUND)", 0, (test_callback_fn)memcached_get_MEMCACHED_NOTFOUND },
-  {"memcached_get_by_key(MEMCACHED_ERRNO)", 0, (test_callback_fn)memcached_get_by_key_MEMCACHED_ERRNO },
-  {"memcached_get_by_key(MEMCACHED_NOTFOUND)", 0, (test_callback_fn)memcached_get_by_key_MEMCACHED_NOTFOUND },
-  {"memcached_get_by_key(MEMCACHED_NOTFOUND)", 0, (test_callback_fn)memcached_get_by_key_MEMCACHED_NOTFOUND },
-  {"memcached_increment(MEMCACHED_NO_SERVERS)", 0, (test_callback_fn)memcached_increment_MEMCACHED_NO_SERVERS },
-  {0, 0, (test_callback_fn)0}
+  {"memcached_get(MEMCACHED_ERRNO)", 0, (test_callback_fn*)memcached_get_MEMCACHED_ERRNO },
+  {"memcached_get(MEMCACHED_NOTFOUND)", 0, (test_callback_fn*)memcached_get_MEMCACHED_NOTFOUND },
+  {"memcached_get_by_key(MEMCACHED_ERRNO)", 0, (test_callback_fn*)memcached_get_by_key_MEMCACHED_ERRNO },
+  {"memcached_get_by_key(MEMCACHED_NOTFOUND)", 0, (test_callback_fn*)memcached_get_by_key_MEMCACHED_NOTFOUND },
+  {"memcached_get_by_key(MEMCACHED_NOTFOUND)", 0, (test_callback_fn*)memcached_get_by_key_MEMCACHED_NOTFOUND },
+  {"memcached_increment(MEMCACHED_NO_SERVERS)", 0, (test_callback_fn*)memcached_increment_MEMCACHED_NO_SERVERS },
+  {0, 0, (test_callback_fn*)0}
 };
 
 
 test_st parser_tests[] ={
-  {"behavior", 0, (test_callback_fn)behavior_parser_test },
-  {"boolean_options", 0, (test_callback_fn)parser_boolean_options_test },
-  {"configure_file", 0, (test_callback_fn)memcached_create_with_options_with_filename },
-  {"distribtions", 0, (test_callback_fn)parser_distribution_test },
-  {"hash", 0, (test_callback_fn)parser_hash_test },
-  {"libmemcached_check_configuration", 0, (test_callback_fn)libmemcached_check_configuration_test },
-  {"libmemcached_check_configuration_with_filename", 0, (test_callback_fn)libmemcached_check_configuration_with_filename_test },
-  {"number_options", 0, (test_callback_fn)parser_number_options_test },
-  {"randomly generated options", 0, (test_callback_fn)random_statement_build_test },
-  {"prefix_key", 0, (test_callback_fn)parser_key_prefix_test },
-  {"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}
+  {"behavior", 0, (test_callback_fn*)behavior_parser_test },
+  {"boolean_options", 0, (test_callback_fn*)parser_boolean_options_test },
+  {"configure_file", 0, (test_callback_fn*)memcached_create_with_options_with_filename },
+  {"distribtions", 0, (test_callback_fn*)parser_distribution_test },
+  {"hash", 0, (test_callback_fn*)parser_hash_test },
+  {"libmemcached_check_configuration", 0, (test_callback_fn*)libmemcached_check_configuration_test },
+  {"libmemcached_check_configuration_with_filename", 0, (test_callback_fn*)libmemcached_check_configuration_with_filename_test },
+  {"number_options", 0, (test_callback_fn*)parser_number_options_test },
+  {"randomly generated options", 0, (test_callback_fn*)random_statement_build_test },
+  {"prefix_key", 0, (test_callback_fn*)parser_key_prefix_test },
+  {"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 },
+  {"--socket=", 0, (test_callback_fn*)test_parse_socket },
+  {0, 0, (test_callback_fn*)0}
 };
 
 test_st virtual_bucket_tests[] ={
-  {"basic", 0, (test_callback_fn)virtual_back_map },
-  {0, 0, (test_callback_fn)0}
+  {"basic", 0, (test_callback_fn*)virtual_back_map },
+  {0, 0, (test_callback_fn*)0}
+};
+
+test_st namespace_tests[] ={
+  {"basic tests", true, (test_callback_fn*)selection_of_namespace_tests },
+  {"increment", true, (test_callback_fn*)memcached_increment_namespace },
+  {0, 0, (test_callback_fn*)0}
 };
 
 collection_st collection[] ={
@@ -6368,61 +6480,64 @@ collection_st collection[] ={
   {"hsieh_availability", 0, 0, hsieh_availability},
   {"murmur_availability", 0, 0, murmur_availability},
   {"block", 0, 0, tests},
-  {"binary", (test_callback_fn)pre_binary, 0, tests},
-  {"nonblock", (test_callback_fn)pre_nonblock, 0, tests},
-  {"nodelay", (test_callback_fn)pre_nodelay, 0, tests},
-  {"settimer", (test_callback_fn)pre_settimer, 0, tests},
-  {"md5", (test_callback_fn)pre_md5, 0, tests},
-  {"crc", (test_callback_fn)pre_crc, 0, tests},
-  {"hsieh", (test_callback_fn)pre_hsieh, 0, tests},
-  {"jenkins", (test_callback_fn)pre_jenkins, 0, tests},
-  {"fnv1_64", (test_callback_fn)pre_hash_fnv1_64, 0, tests},
-  {"fnv1a_64", (test_callback_fn)pre_hash_fnv1a_64, 0, tests},
-  {"fnv1_32", (test_callback_fn)pre_hash_fnv1_32, 0, tests},
-  {"fnv1a_32", (test_callback_fn)pre_hash_fnv1a_32, 0, tests},
-  {"ketama", (test_callback_fn)pre_behavior_ketama, 0, tests},
-  {"ketama_auto_eject_hosts", (test_callback_fn)pre_behavior_ketama, 0, ketama_auto_eject_hosts},
-  {"unix_socket", (test_callback_fn)pre_unix_socket, 0, tests},
-  {"unix_socket_nodelay", (test_callback_fn)pre_nodelay, 0, tests},
-  {"poll_timeout", (test_callback_fn)poll_timeout, 0, tests},
-  {"gets", (test_callback_fn)enable_cas, 0, tests},
-  {"consistent_crc", (test_callback_fn)enable_consistent_crc, 0, tests},
-  {"consistent_hsieh", (test_callback_fn)enable_consistent_hsieh, 0, tests},
+  {"binary", (test_callback_fn*)pre_binary, 0, tests},
+  {"nonblock", (test_callback_fn*)pre_nonblock, 0, tests},
+  {"nodelay", (test_callback_fn*)pre_nodelay, 0, tests},
+  {"settimer", (test_callback_fn*)pre_settimer, 0, tests},
+  {"md5", (test_callback_fn*)pre_md5, 0, tests},
+  {"crc", (test_callback_fn*)pre_crc, 0, tests},
+  {"hsieh", (test_callback_fn*)pre_hsieh, 0, tests},
+  {"jenkins", (test_callback_fn*)pre_jenkins, 0, tests},
+  {"fnv1_64", (test_callback_fn*)pre_hash_fnv1_64, 0, tests},
+  {"fnv1a_64", (test_callback_fn*)pre_hash_fnv1a_64, 0, tests},
+  {"fnv1_32", (test_callback_fn*)pre_hash_fnv1_32, 0, tests},
+  {"fnv1a_32", (test_callback_fn*)pre_hash_fnv1a_32, 0, tests},
+  {"ketama", (test_callback_fn*)pre_behavior_ketama, 0, tests},
+  {"ketama_auto_eject_hosts", (test_callback_fn*)pre_behavior_ketama, 0, ketama_auto_eject_hosts},
+  {"unix_socket", (test_callback_fn*)pre_unix_socket, 0, tests},
+  {"unix_socket_nodelay", (test_callback_fn*)pre_nodelay, 0, tests},
+  {"poll_timeout", (test_callback_fn*)poll_timeout, 0, tests},
+  {"gets", (test_callback_fn*)enable_cas, 0, tests},
+  {"consistent_crc", (test_callback_fn*)enable_consistent_crc, 0, tests},
+  {"consistent_hsieh", (test_callback_fn*)enable_consistent_hsieh, 0, tests},
 #ifdef MEMCACHED_ENABLE_DEPRECATED
-  {"deprecated_memory_allocators", (test_callback_fn)deprecated_set_memory_alloc, 0, tests},
+  {"deprecated_memory_allocators", (test_callback_fn*)deprecated_set_memory_alloc, 0, tests},
 #endif
-  {"memory_allocators", (test_callback_fn)set_memory_alloc, 0, tests},
-  {"prefix", (test_callback_fn)set_prefix, 0, tests},
-  {"sasl_auth", (test_callback_fn)pre_sasl, 0, sasl_auth_tests },
-  {"sasl", (test_callback_fn)pre_sasl, 0, tests },
-  {"version_1_2_3", (test_callback_fn)check_for_1_2_3, 0, version_1_2_3},
+  {"memory_allocators", (test_callback_fn*)set_memory_alloc, 0, tests},
+  {"namespace", (test_callback_fn*)set_namespace, 0, tests},
+  {"namespace(BINARY)", (test_callback_fn*)set_namespace_and_binary, 0, tests},
+  {"specific namespace", 0, 0, namespace_tests},
+  {"specific namespace(BINARY)", (test_callback_fn*)pre_binary, 0, namespace_tests},
+  {"sasl_auth", (test_callback_fn*)pre_sasl, 0, sasl_auth_tests },
+  {"sasl", (test_callback_fn*)pre_sasl, 0, tests },
+  {"version_1_2_3", (test_callback_fn*)check_for_1_2_3, 0, version_1_2_3},
   {"string", 0, 0, string_tests},
   {"result", 0, 0, result_tests},
-  {"async", (test_callback_fn)pre_nonblock, 0, async_tests},
-  {"async_binary", (test_callback_fn)pre_nonblock_binary, 0, async_tests},
+  {"async", (test_callback_fn*)pre_nonblock, 0, async_tests},
+  {"async(BINARY)", (test_callback_fn*)pre_nonblock_binary, 0, async_tests},
   {"Cal Haldenbrand's tests", 0, 0, haldenbrand_tests},
   {"user", 0, 0, user_tests},
   {"generate", 0, 0, generate_tests},
-  {"generate_hsieh", (test_callback_fn)pre_hsieh, 0, generate_tests},
-  {"generate_ketama", (test_callback_fn)pre_behavior_ketama, 0, generate_tests},
-  {"generate_hsieh_consistent", (test_callback_fn)enable_consistent_hsieh, 0, generate_tests},
-  {"generate_md5", (test_callback_fn)pre_md5, 0, generate_tests},
-  {"generate_murmur", (test_callback_fn)pre_murmur, 0, generate_tests},
-  {"generate_jenkins", (test_callback_fn)pre_jenkins, 0, generate_tests},
-  {"generate_nonblock", (test_callback_fn)pre_nonblock, 0, generate_tests},
+  {"generate_hsieh", (test_callback_fn*)pre_hsieh, 0, generate_tests},
+  {"generate_ketama", (test_callback_fn*)pre_behavior_ketama, 0, generate_tests},
+  {"generate_hsieh_consistent", (test_callback_fn*)enable_consistent_hsieh, 0, generate_tests},
+  {"generate_md5", (test_callback_fn*)pre_md5, 0, generate_tests},
+  {"generate_murmur", (test_callback_fn*)pre_murmur, 0, generate_tests},
+  {"generate_jenkins", (test_callback_fn*)pre_jenkins, 0, generate_tests},
+  {"generate_nonblock", (test_callback_fn*)pre_nonblock, 0, generate_tests},
   // Too slow
-  {"generate_corked", (test_callback_fn)pre_cork, 0, generate_tests},
-  {"generate_corked_and_nonblock", (test_callback_fn)pre_cork_and_nonblock, 0, generate_tests},
+  {"generate_corked", (test_callback_fn*)pre_cork, 0, generate_tests},
+  {"generate_corked_and_nonblock", (test_callback_fn*)pre_cork_and_nonblock, 0, generate_tests},
   {"consistent_not", 0, 0, consistent_tests},
-  {"consistent_ketama", (test_callback_fn)pre_behavior_ketama, 0, consistent_tests},
-  {"consistent_ketama_weighted", (test_callback_fn)pre_behavior_ketama_weighted, 0, consistent_weighted_tests},
+  {"consistent_ketama", (test_callback_fn*)pre_behavior_ketama, 0, consistent_tests},
+  {"consistent_ketama_weighted", (test_callback_fn*)pre_behavior_ketama_weighted, 0, consistent_weighted_tests},
   {"ketama_compat", 0, 0, ketama_compatibility},
   {"test_hashes", 0, 0, hash_tests},
-  {"replication", (test_callback_fn)pre_replication, 0, replication_tests},
-  {"replication_noblock", (test_callback_fn)pre_replication_noblock, 0, replication_tests},
+  {"replication", (test_callback_fn*)pre_replication, 0, replication_tests},
+  {"replication_noblock", (test_callback_fn*)pre_replication_noblock, 0, replication_tests},
   {"regression", 0, 0, regression_tests},
   {"behaviors", 0, 0, behavior_tests},
-  {"regression_binary_vs_block", (test_callback_fn)key_setup, (test_callback_fn)key_teardown, regression_binary_vs_block},
+  {"regression_binary_vs_block", (test_callback_fn*)key_setup, (test_callback_fn*)key_teardown, regression_binary_vs_block},
   {"error_conditions", 0, 0, error_conditions},
   {"parser", 0, 0, parser_tests},
   {"virtual buckets", 0, 0, virtual_bucket_tests},
@@ -6432,21 +6547,21 @@ collection_st collection[] ={
 
 #include "tests/libmemcached_world.h"
 
-void get_world(world_st *world)
+void get_world(Framework *world)
 {
   world->collections= collection;
 
-  world->create= (test_callback_create_fn)world_create;
-  world->destroy= (test_callback_fn)world_destroy;
+  world->_create= (test_callback_create_fn*)world_create;
+  world->_destroy= (test_callback_fn*)world_destroy;
 
-  world->test.startup= (test_callback_fn)world_test_startup;
-  world->test.flush= (test_callback_fn)world_flush;
-  world->test.pre_run= (test_callback_fn)world_pre_run;
-  world->test.post_run= (test_callback_fn)world_post_run;
-  world->test.on_error= (test_callback_error_fn)world_on_error;
+  world->item._startup= (test_callback_fn*)world_test_startup;
+  world->item._flush= (test_callback_fn*)world_flush;
+  world->item.set_pre((test_callback_fn*)world_pre_run);
+  world->item.set_post((test_callback_fn*)world_post_run);
+  world->_on_error= (test_callback_error_fn*)world_on_error;
 
-  world->collection.startup= (test_callback_fn)world_container_startup;
-  world->collection.shutdown= (test_callback_fn)world_container_shutdown;
+  world->collection_startup= (test_callback_fn*)world_container_startup;
+  world->collection_shutdown= (test_callback_fn*)world_container_shutdown;
 
   world->runner= &defualt_libmemcached_runner;
 }