Fix in issue where no servers are to be found (introduced in last refactoring)

[awesomized/libmemcached] / tests / function.c

diff --git a/tests/function.c b/tests/function.c
index 640fbfe45d19c9147d8f1be845ad8964892ab18b..5ececc5f89ad4f24d861468d496342951d69fdb2 100644 (file)
--- a/tests/function.c
+++ b/tests/function.c
@@ -112,6 +112,7 @@ uint8_t set_test(memcached_st *memc)
   rc= memcached_set(memc, key, strlen(key), 
                     value, strlen(value),
                     (time_t)0, (uint16_t)0);
+  WATCHPOINT_ERROR(rc);
   assert(rc == MEMCACHED_SUCCESS);
 
   return 0;
@@ -148,6 +149,7 @@ uint8_t append_test(memcached_st *memc)
   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;
 }
@@ -188,11 +190,12 @@ uint8_t append_binary_test(memcached_st *memc)
 
   store_ptr= (unsigned int *)value;
   x= 0;
-  while (*store_ptr)
+  while ((size_t)store_ptr < (size_t)(value + value_length))
   {
     assert(*store_ptr == store_list[x++]);
     store_ptr++;
   }
+  free(value);
 
   return 0;
 }
@@ -311,16 +314,26 @@ uint8_t prepend_test(memcached_st *memc)
   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);
@@ -539,13 +552,14 @@ uint8_t get_test4(memcached_st *memc)
   return 0;
 }
 
+/* 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;
 }
@@ -645,6 +659,7 @@ uint8_t mget_result_test(memcached_st *memc)
   {
     assert(results);
   }
+
   while ((results= memcached_fetch_result(memc, &results_obj, &rc)) != NULL)
   assert(!results);
   assert(rc == MEMCACHED_NOTFOUND);
@@ -815,10 +830,9 @@ uint8_t 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);
  }
@@ -1211,13 +1225,16 @@ uint8_t user_supplied_bug6(memcached_st *memc)
   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_NOTFOUND);
 
   for (x= 0; x < 4; x++)
   {
@@ -1235,12 +1252,15 @@ uint8_t user_supplied_bug6(memcached_st *memc)
     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);
+      memcmp(value, insert_data, value_length);
+      assert(value_length);
       free(value);
       assert(rc == MEMCACHED_SUCCESS);
     }
@@ -1249,6 +1269,36 @@ uint8_t user_supplied_bug6(memcached_st *memc)
   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)
 {
@@ -1411,6 +1461,13 @@ uint8_t string_alloc_append_toobig(memcached_st *memc)
   return 0;
 }
 
+uint8_t cleanup_pairs(memcached_st *memc)
+{
+  pairs_free(global_pairs);
+
+  return 0;
+}
+
 uint8_t generate_data(memcached_st *memc)
 {
   unsigned long long x;
@@ -1565,6 +1622,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;
@@ -1605,6 +1670,14 @@ 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_behavior_set(memc, MEMCACHED_BEHAVIOR_DISTRIBUTION, &value);
+
+  return MEMCACHED_SUCCESS;
+}
+
 memcached_return enable_cas(memcached_st *memc)
 {
   unsigned int set= 1;
@@ -1702,7 +1775,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 },
@@ -1756,6 +1829,7 @@ test_st user_tests[] ={
   {"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 },
   {0, 0, 0}
 };
 
@@ -1764,6 +1838,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}
 };
 
@@ -1774,6 +1849,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},
@@ -1783,12 +1859,14 @@ collection_st collection[] ={
   {"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_nonblock", pre_nonblock, 0, generate_tests},
   {0, 0, 0, 0}
 };