Testing to make sure that partial reads do not break protocol (aka on active

[awesomized/libmemcached] / tests / function.c

diff --git a/tests/function.c b/tests/function.c
index 6bac2d530d5ab946d2b44a434bb997421e12610c..1e2c6f075646dd6ed9dc03b658a1431e60f1362f 100644 (file)
--- a/tests/function.c
+++ b/tests/function.c
@@ -354,7 +354,7 @@ uint8_t stats_servername_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";
@@ -379,7 +379,7 @@ uint8_t increment_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";
@@ -893,7 +893,6 @@ uint8_t user_supplied_bug4(memcached_st *memc)
 
   /* We need to empty the server before continueing test */
   rc= memcached_flush(memc, 0);
-  WATCHPOINT_ERROR(rc);
   assert(rc == MEMCACHED_NO_SERVERS);
 
   rc= memcached_mget(memc, keys, key_length, 3);
@@ -908,7 +907,6 @@ uint8_t user_supplied_bug4(memcached_st *memc)
   assert(return_value_length == 0);
   assert(rc == MEMCACHED_NO_SERVERS);
 
-  WATCHPOINT;
   for (x= 0; x < 3; x++)
   {
     rc= memcached_set(memc, keys[x], key_length[x], 
@@ -917,16 +915,13 @@ uint8_t user_supplied_bug4(memcached_st *memc)
     assert(rc == MEMCACHED_NO_SERVERS);
   }
 
-  WATCHPOINT;
   rc= memcached_mget(memc, keys, key_length, 3);
   assert(rc == MEMCACHED_NO_SERVERS);
-  WATCHPOINT;
 
   x= 0;
   while ((return_value= memcached_fetch(memc, return_key, &return_key_length, 
                                         &return_value_length, &flags, &rc)))
   {
-    WATCHPOINT;
     assert(return_value);
     assert(rc == MEMCACHED_SUCCESS);
     assert(return_key_length == return_value_length);
@@ -938,6 +933,124 @@ uint8_t user_supplied_bug4(memcached_st *memc)
   return 0;
 }
 
+#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);
+  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= 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);
+      free(value);
+      assert(rc == MEMCACHED_SUCCESS);
+    }
+  }
+
+  return 0;
+}
+
 uint8_t result_static(memcached_st *memc)
 {
   memcached_result_st result;
@@ -1327,6 +1440,8 @@ test_st user_tests[] ={
   {"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 },
   {0, 0, 0}
 };