X-Git-Url: https://git.m6w6.name/?a=blobdiff_plain;f=tests%2Ffunction.c;h=1e2c6f075646dd6ed9dc03b658a1431e60f1362f;hb=5845b33395414c577e0d88cc13a011db55cffa02;hp=72694b4039eb3cc77507f96d2bad74584ece114a;hpb=201fa21f8b3c3bf7cef0e705ae403d3ad7841341;p=awesomized%2Flibmemcached

diff --git a/tests/function.c b/tests/function.c
index 72694b40..1e2c6f07 100644
--- a/tests/function.c
+++ b/tests/function.c
@@ -12,9 +12,16 @@
 #include <unistd.h>
 #include <time.h>
 #include "../lib/common.h"
+#include "../src/generator.h"
+#include "../src/execute.h"
 
 #include "test.h"
 
+#define GLOBAL_COUNT 100000
+static pairs_st *global_pairs;
+static char *global_keys[GLOBAL_COUNT];
+static size_t global_keys_length[GLOBAL_COUNT];
+
 uint8_t init_test(memcached_st *not_used)
 {
   memcached_st memc;
@@ -347,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";
@@ -372,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";
@@ -466,9 +473,7 @@ uint8_t mget_result_test(memcached_st *memc)
                    memcached_result_length(results)));
   }
 
-  WATCHPOINT;
   memcached_result_free(&results_obj);
-  WATCHPOINT;
 
   return 0;
 }
@@ -865,6 +870,187 @@ uint8_t user_supplied_bug3(memcached_st *memc)
   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;
+}
+
+#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;
@@ -982,6 +1168,105 @@ uint8_t string_alloc_append_toobig(memcached_st *memc)
   return 0;
 }
 
+uint8_t generate_data(memcached_st *memc)
+{
+  unsigned long long x;
+  global_pairs= pairs_generate(GLOBAL_COUNT);
+  execute_set(memc, global_pairs, GLOBAL_COUNT);
+
+  for (x= 0; x < GLOBAL_COUNT; x++)
+  {
+    global_keys[x]= global_pairs[x].key; 
+    global_keys_length[x]=  global_pairs[x].key_length;
+  }
+
+  return 0;
+}
+
+uint8_t get_read(memcached_st *memc)
+{
+  unsigned int x;
+  memcached_return rc;
+
+  {
+    char *return_value;
+    size_t return_value_length;
+    uint16_t flags;
+
+    for (x= 0; x < GLOBAL_COUNT; x++)
+    {
+      return_value= memcached_get(memc, global_keys[x], global_keys_length[x],
+                                  &return_value_length, &flags, &rc);
+      /*
+      assert(return_value);
+      assert(rc == MEMCACHED_SUCCESS);
+    */
+      if (rc == MEMCACHED_SUCCESS && return_value)
+        free(return_value);
+    }
+  }
+
+  return 0;
+}
+
+uint8_t mget_read(memcached_st *memc)
+{
+  memcached_return rc;
+
+  rc= memcached_mget(memc, global_keys, global_keys_length, GLOBAL_COUNT);
+  assert(rc == MEMCACHED_SUCCESS);
+  /* Turn this into a help function */
+  {
+    char return_key[MEMCACHED_MAX_KEY];
+    size_t return_key_length;
+    char *return_value;
+    size_t return_value_length;
+    uint16_t flags;
+
+    while ((return_value= memcached_fetch(memc, return_key, &return_key_length,
+                                          &return_value_length, &flags, &rc)))
+    {
+      assert(return_value);
+      assert(rc == MEMCACHED_SUCCESS);
+      free(return_value);
+    }
+  }
+
+  return 0;
+}
+
+uint8_t mget_read_result(memcached_st *memc)
+{
+  memcached_return rc;
+
+  rc= memcached_mget(memc, global_keys, global_keys_length, GLOBAL_COUNT);
+  assert(rc == MEMCACHED_SUCCESS);
+  /* Turn this into a help function */
+  {
+    memcached_result_st results_obj;
+    memcached_result_st *results;
+
+    results= memcached_result_create(memc, &results_obj);
+
+    while ((results= memcached_fetch_result(memc, &results_obj, &rc)))
+    {
+      assert(results);
+      assert(rc == MEMCACHED_SUCCESS);
+    }
+
+    memcached_result_free(&results_obj);
+  }
+
+  return 0;
+}
+
+uint8_t free_data(memcached_st *memc)
+{
+  pairs_free(global_pairs);
+
+  return 0;
+}
+
 uint8_t add_host_test1(memcached_st *memc)
 {
   unsigned int x;
@@ -1154,6 +1439,17 @@ 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 },
+  {0, 0, 0}
+};
+
+test_st generate_tests[] ={
+  {"generate_data", 0, generate_data },
+  {"get_read", 0, get_read },
+  {"mget_read", 0, mget_read },
+  {"mget_read_result", 0, mget_read_result },
   {0, 0, 0}
 };
 
@@ -1174,6 +1470,7 @@ collection_st collection[] ={
   {"string", 0, 0, string_tests},
   {"result", 0, 0, result_tests},
   {"user", 0, 0, user_tests},
+  {"generate", 0, 0, generate_tests},
   {0, 0, 0, 0}
 };