X-Git-Url: https://git.m6w6.name/?a=blobdiff_plain;f=tests%2Ffunction.c;h=771178267b1d06c2fe29506605597f0b425cb39b;hb=f9e6b77431a796dd1937f9f49198225a392d95ca;hp=fb21db56e46e93928d167b878f34e1906a925942;hpb=137a6414386ce392447905dab6d11d629a1b381b;p=awesomized%2Flibmemcached

diff --git a/tests/function.c b/tests/function.c
index fb21db56..77117826 100644
--- a/tests/function.c
+++ b/tests/function.c
@@ -22,23 +22,27 @@ static pairs_st *global_pairs;
 static char *global_keys[GLOBAL_COUNT];
 static size_t global_keys_length[GLOBAL_COUNT];
 
-void init_test(memcached_st *not_used)
+uint8_t init_test(memcached_st *not_used)
 {
   memcached_st memc;
 
   (void)memcached_create(&memc);
   memcached_free(&memc);
+
+  return 0;
 }
 
-void allocation_test(memcached_st *not_used)
+uint8_t allocation_test(memcached_st *not_used)
 {
   memcached_st *memc;
   memc= memcached_create(NULL);
   assert(memc);
   memcached_free(memc);
+
+  return 0;
 }
 
-void clone_test(memcached_st *memc)
+uint8_t clone_test(memcached_st *memc)
 {
   /* All null? */
   {
@@ -73,17 +77,21 @@ void clone_test(memcached_st *memc)
     assert(clone);
     memcached_free(clone);
   }
+
+  return 0;
 }
 
-void connection_test(memcached_st *memc)
+uint8_t connection_test(memcached_st *memc)
 {
   memcached_return rc;
 
   rc= memcached_server_add(memc, "localhost", 0);
   assert(rc == MEMCACHED_SUCCESS);
+
+  return 0;
 }
 
-void error_test(memcached_st *memc)
+uint8_t error_test(memcached_st *memc)
 {
   memcached_return rc;
 
@@ -91,9 +99,11 @@ void error_test(memcached_st *memc)
   {
     printf("Error %d -> %s\n", rc, memcached_strerror(memc, rc));
   }
+
+  return 0;
 }
 
-void set_test(memcached_st *memc)
+uint8_t set_test(memcached_st *memc)
 {
   memcached_return rc;
   char *key= "foo";
@@ -103,21 +113,235 @@ void set_test(memcached_st *memc)
                     value, strlen(value),
                     (time_t)0, (uint16_t)0);
   assert(rc == MEMCACHED_SUCCESS);
+
+  return 0;
+}
+
+uint8_t append_test(memcached_st *memc)
+{
+  memcached_return rc;
+  char *key= "fig";
+  char *value= "we";
+  size_t value_length;
+  uint16_t flags;
+
+  rc= memcached_flush(memc, 0);
+  assert(rc == MEMCACHED_SUCCESS);
+
+  rc= memcached_set(memc, key, strlen(key), 
+                    value, strlen(value),
+                    (time_t)0, (uint16_t)0);
+  assert(rc == MEMCACHED_SUCCESS);
+
+  rc= memcached_append(memc, key, strlen(key), 
+                       " the", strlen(" the"),
+                       (time_t)0, (uint16_t)0);
+  assert(rc == MEMCACHED_SUCCESS);
+
+  rc= memcached_append(memc, key, strlen(key), 
+                       " people", strlen(" people"),
+                       (time_t)0, (uint16_t)0);
+  assert(rc == MEMCACHED_SUCCESS);
+
+  value= memcached_get(memc, key, strlen(key),
+                       &value_length, &flags, &rc);
+  assert(!memcmp(value, "we the people", strlen("we the people")));
+  assert(strlen("we the people") == value_length);
+  assert(rc == MEMCACHED_SUCCESS);
+  free(value);
+
+  return 0;
+}
+
+uint8_t append_binary_test(memcached_st *memc)
+{
+  memcached_return rc;
+  char *key= "numbers";
+  unsigned int *store_ptr;
+  unsigned int store_list[] = { 23, 56, 499, 98, 32847, 0 };
+  char *value;
+  size_t value_length;
+  uint16_t flags;
+  unsigned int x;
+
+  rc= memcached_flush(memc, 0);
+  assert(rc == MEMCACHED_SUCCESS);
+
+  rc= memcached_set(memc, 
+                    key, strlen(key), 
+                    NULL, 0,
+                    (time_t)0, (uint16_t)0);
+  assert(rc == MEMCACHED_SUCCESS);
+
+  for (x= 0; store_list[x] ; x++)
+  {
+    rc= memcached_append(memc, 
+                         key, strlen(key), 
+                         (char *)&store_list[x], sizeof(unsigned int),
+                         (time_t)0, (uint16_t)0);
+    assert(rc == MEMCACHED_SUCCESS);
+  }
+
+  value= memcached_get(memc, key, strlen(key),
+                       &value_length, &flags, &rc);
+  assert((value_length == (sizeof(unsigned int) * x)));
+  assert(rc == MEMCACHED_SUCCESS);
+
+  store_ptr= (unsigned int *)value;
+  x= 0;
+  while ((size_t)store_ptr < (size_t)(value + value_length))
+  {
+    assert(*store_ptr == store_list[x++]);
+    store_ptr++;
+  }
+  free(value);
+
+  return 0;
+}
+
+uint8_t cas2_test(memcached_st *memc)
+{
+  memcached_return rc;
+  char *keys[]= {"fudge", "son", "food"};
+  size_t key_length[]= {5, 3, 4};
+  char *value= "we the people";
+  size_t value_length= strlen("we the people");
+  unsigned int x;
+  memcached_result_st results_obj;
+  memcached_result_st *results;
+  unsigned int set= 1;
+
+  rc= memcached_flush(memc, 0);
+  assert(rc == MEMCACHED_SUCCESS);
+
+  memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_SUPPORT_CAS, &set);
+
+  for (x= 0; x < 3; x++)
+  {
+    rc= memcached_set(memc, keys[x], key_length[x], 
+                      keys[x], key_length[x],
+                      (time_t)50, (uint16_t)9);
+    assert(rc == MEMCACHED_SUCCESS);
+  }
+
+  rc= memcached_mget(memc, keys, key_length, 3);
+
+  results= memcached_result_create(memc, &results_obj);
+
+  results= memcached_fetch_result(memc, &results_obj, &rc);
+  assert(results);
+  assert(results->cas);
+  assert(rc == MEMCACHED_SUCCESS);
+  WATCHPOINT_ASSERT(memcached_result_cas(results));
+
+  assert(!memcmp(value, "we the people", strlen("we the people")));
+  assert(strlen("we the people") == value_length);
+  assert(rc == MEMCACHED_SUCCESS);
+
+  memcached_result_free(&results_obj);
+
+  return 0;
 }
 
-void add_test(memcached_st *memc)
+uint8_t cas_test(memcached_st *memc)
+{
+  memcached_return rc;
+  char *key= "fun";
+  size_t key_length= strlen("fun");
+  char *value= "we the people";
+  size_t value_length= strlen("we the people");
+  memcached_result_st results_obj;
+  memcached_result_st *results;
+  unsigned int set= 1;
+
+  rc= memcached_flush(memc, 0);
+  assert(rc == MEMCACHED_SUCCESS);
+
+  memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_SUPPORT_CAS, &set);
+
+  rc= memcached_set(memc, key, strlen(key), 
+                    value, strlen(value),
+                    (time_t)0, (uint16_t)0);
+  assert(rc == MEMCACHED_SUCCESS);
+
+  rc= memcached_mget(memc, &key, &key_length, 1);
+
+  results= memcached_result_create(memc, &results_obj);
+
+  results= memcached_fetch_result(memc, &results_obj, &rc);
+  assert(results);
+  assert(rc == MEMCACHED_SUCCESS);
+  WATCHPOINT_ASSERT(memcached_result_cas(results));
+
+  assert(!memcmp(value, "we the people", strlen("we the people")));
+  assert(strlen("we the people") == value_length);
+  assert(rc == MEMCACHED_SUCCESS);
+
+  memcached_result_free(&results_obj);
+
+  return 0;
+}
+
+uint8_t prepend_test(memcached_st *memc)
+{
+  memcached_return rc;
+  char *key= "fig";
+  char *value= "people";
+  size_t value_length;
+  uint16_t flags;
+
+  rc= memcached_flush(memc, 0);
+  assert(rc == MEMCACHED_SUCCESS);
+
+  rc= memcached_set(memc, key, strlen(key), 
+                    value, strlen(value),
+                    (time_t)0, (uint16_t)0);
+  assert(rc == MEMCACHED_SUCCESS);
+
+  rc= memcached_prepend(memc, key, strlen(key), 
+                       "the ", strlen("the "),
+                       (time_t)0, (uint16_t)0);
+  assert(rc == MEMCACHED_SUCCESS);
+
+  rc= memcached_prepend(memc, key, strlen(key), 
+                       "we ", strlen("we "),
+                       (time_t)0, (uint16_t)0);
+  assert(rc == MEMCACHED_SUCCESS);
+
+  value= memcached_get(memc, key, strlen(key),
+                       &value_length, &flags, &rc);
+  assert(!memcmp(value, "we the people", strlen("we the people")));
+  assert(strlen("we the people") == value_length);
+  assert(rc == MEMCACHED_SUCCESS);
+  free(value);
+
+  return 0;
+}
+
+/* 
+  Set the value, then quit to make sure it is flushed.
+  Come back in and test that add fails.
+*/
+uint8_t add_test(memcached_st *memc)
 {
   memcached_return rc;
   char *key= "foo";
   char *value= "when we sanitize";
 
+  rc= memcached_set(memc, key, strlen(key), 
+                    value, strlen(value),
+                    (time_t)0, (uint16_t)0);
+  assert(rc == MEMCACHED_SUCCESS);
+  memcached_quit(memc);
   rc= memcached_add(memc, key, strlen(key), 
                     value, strlen(value),
                     (time_t)0, (uint16_t)0);
   assert(rc == MEMCACHED_NOTSTORED);
+
+  return 0;
 }
 
-void replace_test(memcached_st *memc)
+uint8_t replace_test(memcached_st *memc)
 {
   memcached_return rc;
   char *key= "foo";
@@ -127,9 +351,11 @@ void replace_test(memcached_st *memc)
                     value, strlen(value),
                     (time_t)0, (uint16_t)0);
   assert(rc == MEMCACHED_SUCCESS);
+
+  return 0;
 }
 
-void delete_test(memcached_st *memc)
+uint8_t delete_test(memcached_st *memc)
 {
   memcached_return rc;
   char *key= "foo";
@@ -142,17 +368,21 @@ void delete_test(memcached_st *memc)
 
   rc= memcached_delete(memc, key, strlen(key), (time_t)0);
   assert(rc == MEMCACHED_SUCCESS);
+
+  return 0;
 }
 
-void flush_test(memcached_st *memc)
+uint8_t flush_test(memcached_st *memc)
 {
   memcached_return rc;
 
   rc= memcached_flush(memc, 0);
   assert(rc == MEMCACHED_SUCCESS);
+
+  return 0;
 }
 
-void get_test(memcached_st *memc)
+uint8_t get_test(memcached_st *memc)
 {
   memcached_return rc;
   char *key= "foo";
@@ -169,9 +399,11 @@ void get_test(memcached_st *memc)
   assert(rc == MEMCACHED_NOTFOUND);
   assert(string_length ==  0);
   assert(!string);
+
+  return 0;
 }
 
-void get_test2(memcached_st *memc)
+uint8_t get_test2(memcached_st *memc)
 {
   memcached_return rc;
   char *key= "foo";
@@ -194,9 +426,11 @@ void get_test2(memcached_st *memc)
   assert(!memcmp(string, value, string_length));
 
   free(string);
+
+  return 0;
 }
 
-void set_test2(memcached_st *memc)
+uint8_t set_test2(memcached_st *memc)
 {
   memcached_return rc;
   char *key= "foo";
@@ -211,9 +445,11 @@ void set_test2(memcached_st *memc)
                       (time_t)0, (uint16_t)0);
     assert(rc == MEMCACHED_SUCCESS);
   }
+
+  return 0;
 }
 
-void set_test3(memcached_st *memc)
+uint8_t set_test3(memcached_st *memc)
 {
   memcached_return rc;
   char *key= "foo";
@@ -236,9 +472,11 @@ void set_test3(memcached_st *memc)
   }
 
   free(value);
+
+  return 0;
 }
 
-void get_test3(memcached_st *memc)
+uint8_t get_test3(memcached_st *memc)
 {
   memcached_return rc;
   char *key= "foo";
@@ -270,9 +508,11 @@ void get_test3(memcached_st *memc)
 
   free(string);
   free(value);
+
+  return 0;
 }
 
-void get_test4(memcached_st *memc)
+uint8_t get_test4(memcached_st *memc)
 {
   memcached_return rc;
   char *key= "foo";
@@ -307,20 +547,25 @@ void get_test4(memcached_st *memc)
   }
 
   free(value);
+
+  return 0;
 }
 
-void stats_servername_test(memcached_st *memc)
+/* Do not copy the style of this code, I just access hosts to testthis function */
+uint8_t stats_servername_test(memcached_st *memc)
 {
   memcached_return rc;
   memcached_stat_st stat;
   rc= memcached_stat_servername(&stat, NULL,
-                                 "localhost", 
-                                 MEMCACHED_DEFAULT_PORT);
+                                 memc->hosts[0].hostname, 
+                                 memc->hosts[0].port);
+
+  return 0;
 }
 
-void increment_test(memcached_st *memc)
+uint8_t increment_test(memcached_st *memc)
 {
-  unsigned int new_number;
+  uint64_t new_number;
   memcached_return rc;
   char *key= "number";
   char *value= "0";
@@ -339,11 +584,13 @@ void increment_test(memcached_st *memc)
                           1, &new_number);
   assert(rc == MEMCACHED_SUCCESS);
   assert(new_number == 2);
+
+  return 0;
 }
 
-void decrement_test(memcached_st *memc)
+uint8_t decrement_test(memcached_st *memc)
 {
-  unsigned int new_number;
+  uint64_t new_number;
   memcached_return rc;
   char *key= "number";
   char *value= "3";
@@ -362,9 +609,11 @@ void decrement_test(memcached_st *memc)
                           1, &new_number);
   assert(rc == MEMCACHED_SUCCESS);
   assert(new_number == 1);
+
+  return 0;
 }
 
-void quit_test(memcached_st *memc)
+uint8_t quit_test(memcached_st *memc)
 {
   memcached_return rc;
   char *key= "fudge";
@@ -380,9 +629,11 @@ void quit_test(memcached_st *memc)
                     value, strlen(value),
                     (time_t)50, (uint16_t)9);
   assert(rc == MEMCACHED_SUCCESS);
+
+  return 0;
 }
 
-void mget_result_test(memcached_st *memc)
+uint8_t mget_result_test(memcached_st *memc)
 {
   memcached_return rc;
   char *keys[]= {"fudge", "son", "food"};
@@ -407,9 +658,10 @@ void mget_result_test(memcached_st *memc)
   {
     assert(results);
   }
+
   while ((results= memcached_fetch_result(memc, &results_obj, &rc)) != NULL)
   assert(!results);
-  assert(rc == MEMCACHED_NOTFOUND);
+  assert(rc == MEMCACHED_END);
 
   for (x= 0; x < 3; x++)
   {
@@ -434,9 +686,11 @@ void mget_result_test(memcached_st *memc)
   }
 
   memcached_result_free(&results_obj);
+
+  return 0;
 }
 
-void mget_result_alloc_test(memcached_st *memc)
+uint8_t mget_result_alloc_test(memcached_st *memc)
 {
   memcached_return rc;
   char *keys[]= {"fudge", "son", "food"};
@@ -457,7 +711,7 @@ void mget_result_alloc_test(memcached_st *memc)
     assert(results);
   }
   assert(!results);
-  assert(rc == MEMCACHED_NOTFOUND);
+  assert(rc == MEMCACHED_END);
 
   for (x= 0; x < 3; x++)
   {
@@ -482,9 +736,11 @@ void mget_result_alloc_test(memcached_st *memc)
     memcached_result_free(results);
     x++;
   }
+
+  return 0;
 }
 
-void mget_test(memcached_st *memc)
+uint8_t mget_test(memcached_st *memc)
 {
   memcached_return rc;
   char *keys[]= {"fudge", "son", "food"};
@@ -511,7 +767,7 @@ void mget_test(memcached_st *memc)
   }
   assert(!return_value);
   assert(return_value_length == 0);
-  assert(rc == MEMCACHED_NOTFOUND);
+  assert(rc == MEMCACHED_END);
 
   for (x= 0; x < 3; x++)
   {
@@ -535,9 +791,11 @@ void mget_test(memcached_st *memc)
     free(return_value);
     x++;
   }
+
+  return 0;
 }
 
-void get_stats_keys(memcached_st *memc)
+uint8_t get_stats_keys(memcached_st *memc)
 {
  char **list;
  char **ptr;
@@ -551,9 +809,11 @@ void get_stats_keys(memcached_st *memc)
  fflush(stdout);
 
  free(list);
+
+ return 0;
 }
 
-void get_stats(memcached_st *memc)
+uint8_t get_stats(memcached_st *memc)
 {
  unsigned int x;
  char **list;
@@ -569,18 +829,19 @@ void get_stats(memcached_st *memc)
 
  for (x= 0; x < memcached_server_count(memc); x++)
  {
-   list= memcached_stat_get_keys(memc, &stat[x], &rc);
+   list= memcached_stat_get_keys(memc, stat+x, &rc);
    assert(rc == MEMCACHED_SUCCESS);
-   for (ptr= list; *ptr; ptr++)
-     printf("Found key %s\n", *ptr);
+   for (ptr= list; *ptr; ptr++);
 
    free(list);
  }
 
  memcached_stat_free(NULL, stat);
+
+  return 0;
 }
 
-void add_host_test(memcached_st *memc)
+uint8_t add_host_test(memcached_st *memc)
 {
   unsigned int x;
   memcached_server_st *servers;
@@ -608,10 +869,12 @@ void add_host_test(memcached_st *memc)
   assert(rc == MEMCACHED_SUCCESS);
 
   memcached_server_list_free(servers);
+
+  return 0;
 }
 
 /* We don't test the behavior itself, we test the switches */
-void behavior_test(memcached_st *memc)
+uint8_t behavior_test(memcached_st *memc)
 {
   unsigned long long value;
   unsigned int set= 1;
@@ -654,10 +917,12 @@ void behavior_test(memcached_st *memc)
 
   value= memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_SOCKET_RECV_SIZE);
   assert(value > 0);
+
+  return 0;
 }
 
 /* Test case provided by Cal Haldenbrand */
-void user_supplied_bug1(memcached_st *memc)
+uint8_t user_supplied_bug1(memcached_st *memc)
 {
   unsigned int setter= 1;
   unsigned int x;
@@ -699,10 +964,12 @@ void user_supplied_bug1(memcached_st *memc)
                          randomstuff, strlen(randomstuff), 10, 0);
     assert(rc == MEMCACHED_SUCCESS);
   }
+
+  return 0;
 }
 
 /* Test case provided by Cal Haldenbrand */
-void user_supplied_bug2(memcached_st *memc)
+uint8_t user_supplied_bug2(memcached_st *memc)
 {
   int errors;
   unsigned int setter;
@@ -749,11 +1016,13 @@ void user_supplied_bug2(memcached_st *memc)
     errors= 0;
     free(getval);
   }
+
+  return 0;
 }
 
 /* Do a large mget() over all the keys we think exist */
 #define KEY_COUNT 3000 // * 1024576
-void user_supplied_bug3(memcached_st *memc)
+uint8_t user_supplied_bug3(memcached_st *memc)
 {
   memcached_return rc;
   unsigned int setter;
@@ -808,9 +1077,351 @@ void user_supplied_bug3(memcached_st *memc)
   for (x= 0; x < KEY_COUNT; x++)
     free(keys[x]);
   free(keys);
+
+  return 0;
+}
+
+/* Make sure we behave properly if server list has no values */
+uint8_t user_supplied_bug4(memcached_st *memc)
+{
+  memcached_return rc;
+  char *keys[]= {"fudge", "son", "food"};
+  size_t key_length[]= {5, 3, 4};
+  unsigned int x;
+  uint16_t flags;
+
+  /* Here we free everything before running a bunch of mget tests */
+  {
+    memcached_server_list_free(memc->hosts);
+    memc->hosts= NULL;
+    memc->number_of_hosts= 0;
+  }
+
+  char return_key[MEMCACHED_MAX_KEY];
+  size_t return_key_length;
+  char *return_value;
+  size_t return_value_length;
+
+  /* We need to empty the server before continueing test */
+  rc= memcached_flush(memc, 0);
+  assert(rc == MEMCACHED_NO_SERVERS);
+
+  rc= memcached_mget(memc, keys, key_length, 3);
+  assert(rc == MEMCACHED_NO_SERVERS);
+
+  while ((return_value= memcached_fetch(memc, return_key, &return_key_length, 
+                      &return_value_length, &flags, &rc)) != NULL)
+  {
+    assert(return_value);
+  }
+  assert(!return_value);
+  assert(return_value_length == 0);
+  assert(rc == MEMCACHED_NO_SERVERS);
+
+  for (x= 0; x < 3; x++)
+  {
+    rc= memcached_set(memc, keys[x], key_length[x], 
+                      keys[x], key_length[x],
+                      (time_t)50, (uint16_t)9);
+    assert(rc == MEMCACHED_NO_SERVERS);
+  }
+
+  rc= memcached_mget(memc, keys, key_length, 3);
+  assert(rc == MEMCACHED_NO_SERVERS);
+
+  x= 0;
+  while ((return_value= memcached_fetch(memc, return_key, &return_key_length, 
+                                        &return_value_length, &flags, &rc)))
+  {
+    assert(return_value);
+    assert(rc == MEMCACHED_SUCCESS);
+    assert(return_key_length == return_value_length);
+    assert(!memcmp(return_value, return_key, return_value_length));
+    free(return_value);
+    x++;
+  }
+
+  return 0;
 }
 
-void result_static(memcached_st *memc)
+#define VALUE_SIZE_BUG5 1048064
+uint8_t user_supplied_bug5(memcached_st *memc)
+{
+  memcached_return rc;
+  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;
+  char *value;
+  size_t value_length;
+  uint16_t flags;
+  unsigned int count;
+  unsigned int x;
+  char insert_data[VALUE_SIZE_BUG5];
+
+  for (x= 0; x < VALUE_SIZE_BUG5; x++)
+    insert_data[x]= rand();
+
+  memcached_flush(memc, 0);
+  value= memcached_get(memc, keys[0], key_length[0],
+                        &value_length, &flags, &rc);		
+  assert(value == NULL);
+  rc= memcached_mget(memc, keys, key_length, 4);
+
+  count= 0;
+  while ((value= memcached_fetch(memc, return_key, &return_key_length, 
+                                        &value_length, &flags, &rc)))
+    count++;
+  assert(count == 0);
+
+  for (x= 0; x < 4; x++)
+  {
+    rc= memcached_set(memc, keys[x], key_length[x], 
+                      insert_data, VALUE_SIZE_BUG5,
+                      (time_t)0, (uint16_t)0);
+    assert(rc == MEMCACHED_SUCCESS);
+  }
+
+  for (x= 0; x < 10; x++)
+  {
+    value= memcached_get(memc, keys[0], key_length[0],
+                         &value_length, &flags, &rc);		
+    assert(value);
+    free(value);
+
+    rc= memcached_mget(memc, keys, key_length, 4);
+    count= 0;
+    while ((value= memcached_fetch(memc, return_key, &return_key_length, 
+                                          &value_length, &flags, &rc)))
+    {
+      count++;
+      free(value);
+    }
+    assert(count == 4);
+  }
+
+  return 0;
+}
+
+uint8_t user_supplied_bug6(memcached_st *memc)
+{
+  memcached_return rc;
+  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;
+  char *value;
+  size_t value_length;
+  uint16_t flags;
+  unsigned int count;
+  unsigned int x;
+  char insert_data[VALUE_SIZE_BUG5];
+
+  for (x= 0; x < VALUE_SIZE_BUG5; x++)
+    insert_data[x]= rand();
+
+  memcached_flush(memc, 0);
+  value= memcached_get(memc, keys[0], key_length[0],
+                        &value_length, &flags, &rc);		
+  assert(value == NULL);
+  assert(rc == MEMCACHED_NOTFOUND);
+  rc= memcached_mget(memc, keys, key_length, 4);
+  assert(rc == MEMCACHED_SUCCESS);
+
+  count= 0;
+  while ((value= memcached_fetch(memc, return_key, &return_key_length, 
+                                        &value_length, &flags, &rc)))
+    count++;
+  assert(count == 0);
+  assert(rc == MEMCACHED_END);
+
+  for (x= 0; x < 4; x++)
+  {
+    rc= memcached_set(memc, keys[x], key_length[x], 
+                      insert_data, VALUE_SIZE_BUG5,
+                      (time_t)0, (uint16_t)0);
+    assert(rc == MEMCACHED_SUCCESS);
+  }
+
+  for (x= 0; x < 2; x++)
+  {
+    value= memcached_get(memc, keys[0], key_length[0],
+                         &value_length, &flags, &rc);		
+    assert(value);
+    free(value);
+
+    rc= memcached_mget(memc, keys, key_length, 4);
+    assert(rc == MEMCACHED_SUCCESS);
+    count= 3;
+    /* We test for purge of partial complete fetches */
+    for (count= 3; count; count--)
+    {
+      value= memcached_fetch(memc, return_key, &return_key_length, 
+                             &value_length, &flags, &rc);
+      assert(rc == MEMCACHED_SUCCESS);
+      assert(!(memcmp(value, insert_data, value_length)));
+      assert(value_length);
+      free(value);
+    }
+  }
+
+  return 0;
+}
+
+uint8_t user_supplied_bug8(memcached_st *memc)
+{
+  memcached_return rc;
+  memcached_st *mine;
+  memcached_st *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";
+
+  servers= memcached_servers_parse(server_list);
+  assert(servers);
+
+  mine= memcached_create(NULL);
+  rc= memcached_server_push(mine, servers);
+  assert(rc == MEMCACHED_SUCCESS);
+  memcached_server_list_free(servers);
+
+  assert(mine);
+  clone= memcached_clone(NULL, mine);
+
+  memcached_quit(mine);
+  memcached_quit(clone);
+
+
+  memcached_free(mine);
+  memcached_free(clone);
+
+  return 0;
+}
+
+/* Test flag store/retrieve */
+uint8_t user_supplied_bug7(memcached_st *memc)
+{
+  memcached_return rc;
+  char *keys= "036790384900";
+  size_t key_length=  strlen("036790384900");
+  char return_key[MEMCACHED_MAX_KEY];
+  size_t return_key_length;
+  char *value;
+  size_t value_length;
+  uint16_t flags;
+  unsigned int x;
+  char insert_data[VALUE_SIZE_BUG5];
+
+  for (x= 0; x < VALUE_SIZE_BUG5; x++)
+    insert_data[x]= rand();
+
+  memcached_flush(memc, 0);
+
+  flags= 245;
+  rc= memcached_set(memc, keys, key_length, 
+                    insert_data, VALUE_SIZE_BUG5,
+                    (time_t)0, flags);
+  assert(rc == MEMCACHED_SUCCESS);
+
+  flags= 0;
+  value= memcached_get(memc, keys, key_length,
+                        &value_length, &flags, &rc);		
+  assert(flags == 245);
+  assert(value);
+  free(value);
+
+  rc= memcached_mget(memc, &keys, &key_length, 1);
+
+  flags= 0;
+  value= memcached_fetch(memc, return_key, &return_key_length, 
+                         &value_length, &flags, &rc);
+  assert(flags == 245);
+  assert(value);
+  free(value);
+
+
+  return 0;
+}
+
+uint8_t user_supplied_bug9(memcached_st *memc)
+{
+  memcached_return rc;
+  char *keys[]= {"UDATA:edevil@sapo.pt", "fudge&*@#", "for^#@&$not"};
+  size_t key_length[3];
+  unsigned int x;
+  uint16_t flags;
+  unsigned count= 0;
+
+  char return_key[MEMCACHED_MAX_KEY];
+  size_t return_key_length;
+  char *return_value;
+  size_t return_value_length;
+
+
+  key_length[0]= strlen("UDATA:edevil@sapo.pt");
+  key_length[1]= strlen("fudge&*@#");
+  key_length[2]= strlen("for^#@&$not");
+
+
+  for (x= 0; x < 3; x++)
+  {
+    rc= memcached_set(memc, keys[x], key_length[x], 
+                      keys[x], key_length[x],
+                      (time_t)50, (uint16_t)9);
+    assert(rc == MEMCACHED_SUCCESS);
+  }
+
+  rc= memcached_mget(memc, keys, key_length, 3);
+  assert(rc == MEMCACHED_SUCCESS);
+
+  /* We need to empty the server before continueing test */
+  while ((return_value= memcached_fetch(memc, return_key, &return_key_length, 
+                      &return_value_length, &flags, &rc)) != NULL)
+  {
+    assert(return_value);
+    count++;
+  }
+  assert(count == 3);
+
+  return 0;
+}
+
+uint8_t user_supplied_bug10(memcached_st *memc)
+{
+  char *key= "foo";
+  char *value;
+  size_t value_length= 512;
+  unsigned int x;
+  int key_len= 3;
+  memcached_return rc;
+  unsigned int set= 1;
+  memcached_st *mclone= memcached_clone(NULL, memc);
+
+  memcached_behavior_set(mclone, MEMCACHED_BEHAVIOR_NO_BLOCK, &set);
+  memcached_behavior_set(mclone, MEMCACHED_BEHAVIOR_TCP_NODELAY, &set);
+
+  value = (char*)malloc(value_length * sizeof(char));
+
+  for (x= 0; x < value_length; x++)
+    value[x]= (char) (x % 127);
+
+  for (x= 1; x <= 100000; ++x)
+  {
+    rc= memcached_set(mclone, key, key_len,value, value_length, 0, 0);
+
+    assert(rc == MEMCACHED_SUCCESS || rc == MEMCACHED_WRITE_FAILURE);
+
+    if (rc == MEMCACHED_WRITE_FAILURE)
+      x--;
+  }
+
+  free(value);
+  memcached_free(mclone);
+
+  return 0;
+}
+
+uint8_t result_static(memcached_st *memc)
 {
   memcached_result_st result;
   memcached_result_st *result_ptr;
@@ -819,18 +1430,22 @@ void result_static(memcached_st *memc)
   assert(result.is_allocated == MEMCACHED_NOT_ALLOCATED);
   assert(result_ptr);
   memcached_result_free(&result);
+
+  return 0;
 }
 
-void result_alloc(memcached_st *memc)
+uint8_t result_alloc(memcached_st *memc)
 {
   memcached_result_st *result;
 
   result= memcached_result_create(memc, NULL);
   assert(result);
   memcached_result_free(result);
+
+  return 0;
 }
 
-void string_static_null(memcached_st *memc)
+uint8_t string_static_null(memcached_st *memc)
 {
   memcached_string_st string;
   memcached_string_st *string_ptr;
@@ -839,35 +1454,43 @@ void string_static_null(memcached_st *memc)
   assert(string.is_allocated == MEMCACHED_NOT_ALLOCATED);
   assert(string_ptr);
   memcached_string_free(&string);
+
+  return 0;
 }
 
-void string_alloc_null(memcached_st *memc)
+uint8_t string_alloc_null(memcached_st *memc)
 {
   memcached_string_st *string;
 
   string= memcached_string_create(memc, NULL, 0);
   assert(string);
   memcached_string_free(string);
+
+  return 0;
 }
 
-void string_alloc_with_size(memcached_st *memc)
+uint8_t string_alloc_with_size(memcached_st *memc)
 {
   memcached_string_st *string;
 
   string= memcached_string_create(memc, NULL, 1024);
   assert(string);
   memcached_string_free(string);
+
+  return 0;
 }
 
-void string_alloc_with_size_toobig(memcached_st *memc)
+uint8_t string_alloc_with_size_toobig(memcached_st *memc)
 {
   memcached_string_st *string;
 
   string= memcached_string_create(memc, NULL, INT64_MAX);
   assert(string == NULL);
+
+  return 0;
 }
 
-void string_alloc_append(memcached_st *memc)
+uint8_t string_alloc_append(memcached_st *memc)
 {
   unsigned int x;
   char buffer[SMALL_STRING_LEN];
@@ -886,9 +1509,11 @@ void string_alloc_append(memcached_st *memc)
     assert(rc == MEMCACHED_SUCCESS);
   }
   memcached_string_free(string);
+
+  return 0;
 }
 
-void string_alloc_append_toobig(memcached_st *memc)
+uint8_t string_alloc_append_toobig(memcached_st *memc)
 {
   memcached_return rc;
   unsigned int x;
@@ -909,9 +1534,18 @@ void string_alloc_append_toobig(memcached_st *memc)
   rc= memcached_string_append(string, buffer, INT64_MAX);
   assert(rc == MEMCACHED_MEMORY_ALLOCATION_FAILURE);
   memcached_string_free(string);
+
+  return 0;
+}
+
+uint8_t cleanup_pairs(memcached_st *memc)
+{
+  pairs_free(global_pairs);
+
+  return 0;
 }
 
-void generate_data(memcached_st *memc)
+uint8_t generate_data(memcached_st *memc)
 {
   unsigned long long x;
   global_pairs= pairs_generate(GLOBAL_COUNT);
@@ -922,9 +1556,11 @@ void generate_data(memcached_st *memc)
     global_keys[x]= global_pairs[x].key; 
     global_keys_length[x]=  global_pairs[x].key_length;
   }
+
+  return 0;
 }
 
-void get_read(memcached_st *memc)
+uint8_t get_read(memcached_st *memc)
 {
   unsigned int x;
   memcached_return rc;
@@ -946,9 +1582,11 @@ void get_read(memcached_st *memc)
         free(return_value);
     }
   }
+
+  return 0;
 }
 
-void mget_read(memcached_st *memc)
+uint8_t mget_read(memcached_st *memc)
 {
   memcached_return rc;
 
@@ -970,9 +1608,11 @@ void mget_read(memcached_st *memc)
       free(return_value);
     }
   }
+
+  return 0;
 }
 
-void mget_read_result(memcached_st *memc)
+uint8_t mget_read_result(memcached_st *memc)
 {
   memcached_return rc;
 
@@ -993,14 +1633,18 @@ void mget_read_result(memcached_st *memc)
 
     memcached_result_free(&results_obj);
   }
+
+  return 0;
 }
 
-void free_data(memcached_st *memc)
+uint8_t free_data(memcached_st *memc)
 {
   pairs_free(global_pairs);
+
+  return 0;
 }
 
-void add_host_test1(memcached_st *memc)
+uint8_t add_host_test1(memcached_st *memc)
 {
   unsigned int x;
   memcached_return rc;
@@ -1028,6 +1672,8 @@ void add_host_test1(memcached_st *memc)
   assert(rc == MEMCACHED_SUCCESS);
 
   memcached_server_list_free(servers);
+
+  return 0;
 }
 
 memcached_return pre_nonblock(memcached_st *memc)
@@ -1053,6 +1699,14 @@ memcached_return pre_crc(memcached_st *memc)
   return MEMCACHED_SUCCESS;
 }
 
+memcached_return pre_hsieh(memcached_st *memc)
+{
+  memcached_hash value= MEMCACHED_HASH_HSIEH;
+  memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_HASH, &value);
+
+  return MEMCACHED_SUCCESS;
+}
+
 memcached_return pre_hash_fnv1_64(memcached_st *memc)
 {
   memcached_hash value= MEMCACHED_HASH_FNV1_64;
@@ -1093,6 +1747,53 @@ memcached_return pre_hash_ketama(memcached_st *memc)
   return MEMCACHED_SUCCESS;
 }
 
+memcached_return enable_consistent(memcached_st *memc)
+{
+  memcached_server_distribution value= MEMCACHED_DISTRIBUTION_CONSISTENT;
+  memcached_hash hash;
+  memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_DISTRIBUTION, &value);
+  pre_hsieh(memc);
+
+  value= (memcached_server_distribution)memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_DISTRIBUTION);
+  assert(value == MEMCACHED_DISTRIBUTION_CONSISTENT);
+
+  hash= (memcached_hash)memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_HASH);
+  assert(hash == MEMCACHED_HASH_HSIEH);
+
+
+  return MEMCACHED_SUCCESS;
+}
+
+memcached_return enable_cas(memcached_st *memc)
+{
+  unsigned int set= 1;
+
+  memcached_version(memc);
+
+  if (memc->hosts[0].major_version >= 1 &&
+      memc->hosts[0].minor_version >= 2 &&
+      memc->hosts[0].micro_version >= 4)
+  {
+    memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_SUPPORT_CAS, &set);
+
+    return MEMCACHED_SUCCESS;
+  }
+
+  return MEMCACHED_FAILURE;
+}
+
+memcached_return check_for_1_2_3(memcached_st *memc)
+{
+  memcached_version(memc);
+
+  if (memc->hosts[0].major_version >= 1 &&
+      memc->hosts[0].minor_version >= 2 &&
+      memc->hosts[0].micro_version >= 4)
+    return MEMCACHED_SUCCESS;
+
+  return MEMCACHED_FAILURE;
+}
+
 memcached_return pre_unix_socket(memcached_st *memc)
 {
   memcached_return rc;
@@ -1110,6 +1811,22 @@ memcached_return pre_unix_socket(memcached_st *memc)
   return rc;
 }
 
+memcached_return pre_udp(memcached_st *memc)
+{
+  memcached_return rc;
+
+  memcached_server_list_free(memc->hosts);
+  memc->hosts= NULL;
+  memc->number_of_hosts= 0;
+
+  if (0)
+    return MEMCACHED_FAILURE;
+
+  rc= memcached_server_add_udp(memc, "localhost", MEMCACHED_DEFAULT_PORT);
+
+  return rc;
+}
+
 memcached_return pre_nodelay(memcached_st *memc)
 {
   memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_NO_BLOCK, NULL);
@@ -1118,6 +1835,21 @@ memcached_return pre_nodelay(memcached_st *memc)
   return MEMCACHED_SUCCESS;
 }
 
+memcached_return poll_timeout(memcached_st *memc)
+{
+  int32_t timeout;
+
+  timeout= 100;
+
+  memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_POLL_TIMEOUT, &timeout);
+
+  timeout= (int32_t)memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_POLL_TIMEOUT);
+
+  assert(timeout == 100);
+
+  return MEMCACHED_SUCCESS;
+}
+
 
 /* Clean the server before beginning testing */
 test_st tests[] ={
@@ -1129,7 +1861,7 @@ test_st tests[] ={
   {"set", 0, set_test },
   {"set2", 0, set_test2 },
   {"set3", 0, set_test3 },
-  {"add", 0, add_test },
+  {"add", 1, add_test },
   {"replace", 0, replace_test },
   {"delete", 1, delete_test },
   {"get", 1, get_test },
@@ -1166,10 +1898,26 @@ test_st result_tests[] ={
   {0, 0, 0}
 };
 
+test_st version_1_2_3[] ={
+  {"append", 0, append_test },
+  {"prepend", 0, prepend_test },
+  {"cas", 0, cas_test },
+  {"cas2", 0, cas2_test },
+  {"append_binary", 0, append_binary_test },
+  {0, 0, 0}
+};
+
 test_st user_tests[] ={
   {"user_supplied_bug1", 0, user_supplied_bug1 },
   {"user_supplied_bug2", 0, user_supplied_bug2 },
   {"user_supplied_bug3", 0, user_supplied_bug3 },
+  {"user_supplied_bug4", 0, user_supplied_bug4 },
+  {"user_supplied_bug5", 1, user_supplied_bug5 },
+  {"user_supplied_bug6", 1, user_supplied_bug6 },
+  {"user_supplied_bug7", 1, user_supplied_bug7 },
+  {"user_supplied_bug8", 1, user_supplied_bug8 },
+  {"user_supplied_bug9", 1, user_supplied_bug9 },
+  {"user_supplied_bug10", 1, user_supplied_bug10 },
   {0, 0, 0}
 };
 
@@ -1178,6 +1926,7 @@ test_st generate_tests[] ={
   {"get_read", 0, get_read },
   {"mget_read", 0, mget_read },
   {"mget_read_result", 0, mget_read_result },
+  {"cleanup", 0, cleanup_pairs },
   {0, 0, 0}
 };
 
@@ -1188,6 +1937,7 @@ collection_st collection[] ={
   {"nodelay", pre_nodelay, 0, tests},
   {"md5", pre_md5, 0, tests},
   {"crc", pre_crc, 0, tests},
+  {"hsieh", pre_hsieh, 0, tests},
   {"fnv1_64", pre_hash_fnv1_64, 0, tests},
   {"fnv1a_64", pre_hash_fnv1a_64, 0, tests},
   {"fnv1_32", pre_hash_fnv1_32, 0, tests},
@@ -1195,10 +1945,19 @@ collection_st collection[] ={
   {"ketama", pre_hash_ketama, 0, tests},
   {"unix_socket", pre_unix_socket, 0, tests},
   {"unix_socket_nodelay", pre_nodelay, 0, tests},
+  {"poll_timeout", poll_timeout, 0, tests},
+  {"gets", enable_cas, 0, tests},
+  {"consistent", enable_consistent, 0, tests},
+//  {"udp", pre_udp, 0, tests},
+  {"version_1_2_3", check_for_1_2_3, 0, version_1_2_3},
   {"string", 0, 0, string_tests},
   {"result", 0, 0, result_tests},
   {"user", 0, 0, user_tests},
   {"generate", 0, 0, generate_tests},
+  {"generate_hsieh", pre_hsieh, 0, generate_tests},
+  {"generate_hsieh_consistent", enable_consistent, 0, generate_tests},
+  {"generate_md5", pre_md5, 0, generate_tests},
+  {"generate_nonblock", pre_nonblock, 0, generate_tests},
   {0, 0, 0, 0}
 };