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

diff --git a/tests/function.c b/tests/function.c
index 5ececc5f..77117826 100644
--- a/tests/function.c
+++ b/tests/function.c
@@ -112,7 +112,6 @@ 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;
@@ -662,7 +661,7 @@ uint8_t mget_result_test(memcached_st *memc)
 
   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++)
   {
@@ -712,7 +711,7 @@ uint8_t 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++)
   {
@@ -768,7 +767,7 @@ uint8_t 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++)
   {
@@ -1234,7 +1233,7 @@ uint8_t user_supplied_bug6(memcached_st *memc)
                                         &value_length, &flags, &rc)))
     count++;
   assert(count == 0);
-  assert(rc == MEMCACHED_NOTFOUND);
+  assert(rc == MEMCACHED_END);
 
   for (x= 0; x < 4; x++)
   {
@@ -1244,7 +1243,7 @@ uint8_t user_supplied_bug6(memcached_st *memc)
     assert(rc == MEMCACHED_SUCCESS);
   }
 
-  for (x= 0; x < 10; x++)
+  for (x= 0; x < 2; x++)
   {
     value= memcached_get(memc, keys[0], key_length[0],
                          &value_length, &flags, &rc);		
@@ -1259,10 +1258,10 @@ uint8_t user_supplied_bug6(memcached_st *memc)
     {
       value= memcached_fetch(memc, return_key, &return_key_length, 
                              &value_length, &flags, &rc);
-      memcmp(value, insert_data, value_length);
+      assert(rc == MEMCACHED_SUCCESS);
+      assert(!(memcmp(value, insert_data, value_length)));
       assert(value_length);
       free(value);
-      assert(rc == MEMCACHED_SUCCESS);
     }
   }
 
@@ -1344,6 +1343,84 @@ uint8_t user_supplied_bug7(memcached_st *memc)
   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;
@@ -1673,7 +1750,16 @@ memcached_return pre_hash_ketama(memcached_st *memc)
 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;
 }
@@ -1830,6 +1916,8 @@ test_st user_tests[] ={
   {"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}
 };
 
@@ -1867,6 +1955,8 @@ collection_st collection[] ={
   {"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}
 };