Cleanuped up make test

[m6w6/libmemcached] / tests / function.c

diff --git a/tests/function.c b/tests/function.c
index 68eddbd738816fb8ecdc6feed165f35d2ed6ce31..b5af2b5038eb7cae54dc6f58f4244a624ce723a4 100644 (file)
--- a/tests/function.c
+++ b/tests/function.c
@@ -148,6 +148,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 +189,56 @@ 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;
+}
+
+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;
 }
@@ -206,10 +252,13 @@ uint8_t cas_test(memcached_st *memc)
   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);
@@ -222,7 +271,6 @@ uint8_t cas_test(memcached_st *memc)
   results= memcached_fetch_result(memc, &results_obj, &rc);
   assert(results);
   assert(rc == MEMCACHED_SUCCESS);
-  WATCHPOINT_NUMBER(memcached_result_cas(results));
   WATCHPOINT_ASSERT(memcached_result_cas(results));
 
   assert(!memcmp(value, "we the people", strlen("we the people")));
@@ -265,6 +313,7 @@ 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;
 }
@@ -493,13 +542,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;
 }
@@ -599,6 +649,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);
@@ -769,10 +820,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);
  }
@@ -1365,6 +1415,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;
@@ -1519,6 +1576,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;
@@ -1559,6 +1624,24 @@ memcached_return pre_hash_ketama(memcached_st *memc)
   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);
@@ -1612,6 +1695,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[] ={
@@ -1663,7 +1761,8 @@ test_st result_tests[] ={
 test_st version_1_2_3[] ={
   {"append", 0, append_test },
   {"prepend", 0, prepend_test },
-//  {"cas", 0, cas_test },
+  {"cas", 0, cas_test },
+  {"cas2", 0, cas2_test },
   {"append_binary", 0, append_binary_test },
   {0, 0, 0}
 };
@@ -1684,6 +1783,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}
 };
 
@@ -1694,6 +1794,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},
@@ -1701,12 +1802,15 @@ 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},
 //  {"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}
 };