X-Git-Url: https://git.m6w6.name/?a=blobdiff_plain;f=tests%2Ffunction.c;h=0ecd7b1401f5a6258dad730a54fef60a4ca3e828;hb=f7cf48062dc8410ebeabf0a575eeb8e1b5201a6b;hp=0be895d66a1d7e97b37040bd762168049a1ded56;hpb=6f50a6acc95303396a8a073c3746cdff83df2301;p=awesomized%2Flibmemcached

diff --git a/tests/function.c b/tests/function.c
index 0be895d6..0ecd7b14 100644
--- a/tests/function.c
+++ b/tests/function.c
@@ -15,6 +15,14 @@
 #include "../src/generator.h"
 #include "../src/execute.h"
 
+#ifndef INT64_MAX
+#define INT64_MAX LONG_MAX
+#endif
+#ifndef INT32_MAX
+#define INT32_MAX INT_MAX
+#endif
+
+
 #include "test.h"
 
 #define GLOBAL_COUNT 100000
@@ -32,6 +40,23 @@ uint8_t init_test(memcached_st *not_used)
   return 0;
 }
 
+uint8_t server_list_null_test(memcached_st *ptr)
+{
+  memcached_server_st *server_list;
+  memcached_return rc;
+
+  server_list= memcached_server_list_append(NULL, NULL, 0, NULL);
+  assert(server_list == NULL);
+
+  server_list= memcached_server_list_append(NULL, "localhost", 0, NULL);
+  assert(server_list == NULL);
+
+  server_list= memcached_server_list_append(NULL, NULL, 0, &rc);
+  assert(server_list == NULL);
+
+  return 0;
+}
+
 uint8_t allocation_test(memcached_st *not_used)
 {
   memcached_st *memc;
@@ -112,7 +137,7 @@ uint8_t set_test(memcached_st *memc)
   rc= memcached_set(memc, key, strlen(key), 
                     value, strlen(value),
                     (time_t)0, (uint32_t)0);
-  assert(rc == MEMCACHED_SUCCESS);
+  assert(rc == MEMCACHED_SUCCESS || rc == MEMCACHED_BUFFERED);
 
   return 0;
 }
@@ -331,11 +356,12 @@ uint8_t add_test(memcached_st *memc)
   rc= memcached_set(memc, key, strlen(key), 
                     value, strlen(value),
                     (time_t)0, (uint32_t)0);
-  assert(rc == MEMCACHED_SUCCESS);
+  assert(rc == MEMCACHED_SUCCESS || rc == MEMCACHED_BUFFERED);
   memcached_quit(memc);
   rc= memcached_add(memc, key, strlen(key), 
                     value, strlen(value),
                     (time_t)0, (uint32_t)0);
+  WATCHPOINT_ERROR(rc);
   assert(rc == MEMCACHED_NOTSTORED);
 
   return 0;
@@ -374,10 +400,10 @@ uint8_t delete_test(memcached_st *memc)
   rc= memcached_set(memc, key, strlen(key), 
                     value, strlen(value),
                     (time_t)0, (uint32_t)0);
-  assert(rc == MEMCACHED_SUCCESS);
+  assert(rc == MEMCACHED_SUCCESS || rc == MEMCACHED_BUFFERED);
 
   rc= memcached_delete(memc, key, strlen(key), (time_t)0);
-  assert(rc == MEMCACHED_SUCCESS);
+  assert(rc == MEMCACHED_SUCCESS || rc == MEMCACHED_BUFFERED);
 
   return 0;
 }
@@ -401,7 +427,7 @@ uint8_t get_test(memcached_st *memc)
   uint32_t flags;
 
   rc= memcached_delete(memc, key, strlen(key), (time_t)0);
-  assert(rc == MEMCACHED_SUCCESS || rc == MEMCACHED_NOTFOUND);
+  assert(rc == MEMCACHED_BUFFERED || rc == MEMCACHED_NOTFOUND);
 
   string= memcached_get(memc, key, strlen(key),
                         &string_length, &flags, &rc);
@@ -425,7 +451,7 @@ uint8_t get_test2(memcached_st *memc)
   rc= memcached_set(memc, key, strlen(key), 
                     value, strlen(value),
                     (time_t)0, (uint32_t)0);
-  assert(rc == MEMCACHED_SUCCESS);
+  assert(rc == MEMCACHED_SUCCESS || rc == MEMCACHED_BUFFERED);
 
   string= memcached_get(memc, key, strlen(key),
                         &string_length, &flags, &rc);
@@ -453,7 +479,7 @@ uint8_t set_test2(memcached_st *memc)
     rc= memcached_set(memc, key, strlen(key), 
                       value, value_length,
                       (time_t)0, (uint32_t)0);
-    assert(rc == MEMCACHED_SUCCESS);
+    assert(rc == MEMCACHED_SUCCESS || rc == MEMCACHED_BUFFERED);
   }
 
   return 0;
@@ -478,7 +504,7 @@ uint8_t set_test3(memcached_st *memc)
     rc= memcached_set(memc, key, strlen(key), 
                       value, value_length,
                       (time_t)0, (uint32_t)0);
-    assert(rc == MEMCACHED_SUCCESS);
+    assert(rc == MEMCACHED_SUCCESS || rc == MEMCACHED_BUFFERED);
   }
 
   free(value);
@@ -506,7 +532,7 @@ uint8_t get_test3(memcached_st *memc)
   rc= memcached_set(memc, key, strlen(key), 
                     value, value_length,
                     (time_t)0, (uint32_t)0);
-  assert(rc == MEMCACHED_SUCCESS);
+  assert(rc == MEMCACHED_SUCCESS || rc == MEMCACHED_BUFFERED);
 
   string= memcached_get(memc, key, strlen(key),
                         &string_length, &flags, &rc);
@@ -542,7 +568,7 @@ uint8_t get_test4(memcached_st *memc)
   rc= memcached_set(memc, key, strlen(key), 
                     value, value_length,
                     (time_t)0, (uint32_t)0);
-  assert(rc == MEMCACHED_SUCCESS);
+  assert(rc == MEMCACHED_SUCCESS || rc == MEMCACHED_BUFFERED);
 
   for (x= 0; x < 10; x++)
   {
@@ -583,7 +609,7 @@ uint8_t increment_test(memcached_st *memc)
   rc= memcached_set(memc, key, strlen(key), 
                     value, strlen(value),
                     (time_t)0, (uint32_t)0);
-  assert(rc == MEMCACHED_SUCCESS);
+  assert(rc == MEMCACHED_SUCCESS || rc == MEMCACHED_BUFFERED);
 
   rc= memcached_increment(memc, key, strlen(key),
                           1, &new_number);
@@ -608,7 +634,7 @@ uint8_t decrement_test(memcached_st *memc)
   rc= memcached_set(memc, key, strlen(key), 
                     value, strlen(value),
                     (time_t)0, (uint32_t)0);
-  assert(rc == MEMCACHED_SUCCESS);
+  assert(rc == MEMCACHED_SUCCESS || rc == MEMCACHED_BUFFERED);
 
   rc= memcached_decrement(memc, key, strlen(key),
                           1, &new_number);
@@ -632,13 +658,13 @@ uint8_t quit_test(memcached_st *memc)
   rc= memcached_set(memc, key, strlen(key), 
                     value, strlen(value),
                     (time_t)10, (uint32_t)3);
-  assert(rc == MEMCACHED_SUCCESS);
+  assert(rc == MEMCACHED_SUCCESS || rc == MEMCACHED_BUFFERED);
   memcached_quit(memc);
 
   rc= memcached_set(memc, key, strlen(key), 
                     value, strlen(value),
                     (time_t)50, (uint32_t)9);
-  assert(rc == MEMCACHED_SUCCESS);
+  assert(rc == MEMCACHED_SUCCESS || rc == MEMCACHED_BUFFERED);
 
   return 0;
 }
@@ -678,7 +704,7 @@ uint8_t mget_result_test(memcached_st *memc)
     rc= memcached_set(memc, keys[x], key_length[x], 
                       keys[x], key_length[x],
                       (time_t)50, (uint32_t)9);
-    assert(rc == MEMCACHED_SUCCESS);
+    assert(rc == MEMCACHED_SUCCESS || rc == MEMCACHED_BUFFERED);
   }
 
   rc= memcached_mget(memc, keys, key_length, 3);
@@ -728,7 +754,7 @@ uint8_t mget_result_alloc_test(memcached_st *memc)
     rc= memcached_set(memc, keys[x], key_length[x], 
                       keys[x], key_length[x],
                       (time_t)50, (uint32_t)9);
-    assert(rc == MEMCACHED_SUCCESS);
+    assert(rc == MEMCACHED_SUCCESS || rc == MEMCACHED_BUFFERED);
   }
 
   rc= memcached_mget(memc, keys, key_length, 3);
@@ -750,6 +776,47 @@ uint8_t mget_result_alloc_test(memcached_st *memc)
   return 0;
 }
 
+/* Count the results */
+unsigned int callback_counter(memcached_st *ptr, memcached_result_st *result, void *context)
+{
+  unsigned int *counter= (unsigned int *)context;
+
+  *counter= *counter + 1;
+
+  return 0;
+}
+
+uint8_t mget_result_function(memcached_st *memc)
+{
+  memcached_return rc;
+  char *keys[]= {"fudge", "son", "food"};
+  size_t key_length[]= {5, 3, 4};
+  unsigned int x;
+  unsigned int counter;
+  unsigned int (*callbacks[1])(memcached_st *, memcached_result_st *, void *);
+
+  /* We need to empty the server before continueing test */
+  rc= memcached_flush(memc, 0);
+  for (x= 0; x < 3; x++)
+  {
+    rc= memcached_set(memc, keys[x], key_length[x], 
+                      keys[x], key_length[x],
+                      (time_t)50, (uint32_t)9);
+    assert(rc == MEMCACHED_SUCCESS || rc == MEMCACHED_BUFFERED);
+  }
+
+  rc= memcached_mget(memc, keys, key_length, 3);
+  assert(rc == MEMCACHED_SUCCESS);
+
+  callbacks[0]= &callback_counter;
+  counter= 0;
+  rc= memcached_fetch_execute(memc, callbacks, (void *)&counter, 1); 
+
+  assert(counter == 3);
+
+  return 0;
+}
+
 uint8_t mget_test(memcached_st *memc)
 {
   memcached_return rc;
@@ -784,7 +851,7 @@ uint8_t mget_test(memcached_st *memc)
     rc= memcached_set(memc, keys[x], key_length[x], 
                       keys[x], key_length[x],
                       (time_t)50, (uint32_t)9);
-    assert(rc == MEMCACHED_SUCCESS);
+    assert(rc == MEMCACHED_SUCCESS || rc == MEMCACHED_BUFFERED);
   }
 
   rc= memcached_mget(memc, keys, key_length, 3);
@@ -969,10 +1036,10 @@ uint8_t user_supplied_bug1(memcached_st *memc)
     rc = memcached_set(memc, key, strlen(key), 
                        randomstuff, strlen(randomstuff), 10, 0);
     /* If we fail, lets try again */
-    if (rc != MEMCACHED_SUCCESS)
+    if (rc != MEMCACHED_SUCCESS && rc != MEMCACHED_BUFFERED)
       rc = memcached_set(memc, key, strlen(key), 
                          randomstuff, strlen(randomstuff), 10, 0);
-    assert(rc == MEMCACHED_SUCCESS);
+    assert(rc == MEMCACHED_SUCCESS || rc == MEMCACHED_BUFFERED);
   }
 
   return 0;
@@ -1099,6 +1166,10 @@ uint8_t user_supplied_bug4(memcached_st *memc)
   size_t key_length[]= {5, 3, 4};
   unsigned int x;
   uint32_t flags;
+  char return_key[MEMCACHED_MAX_KEY];
+  size_t return_key_length;
+  char *return_value;
+  size_t return_value_length;
 
   /* Here we free everything before running a bunch of mget tests */
   {
@@ -1107,10 +1178,6 @@ uint8_t user_supplied_bug4(memcached_st *memc)
     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);
@@ -1424,7 +1491,7 @@ uint8_t user_supplied_bug10(memcached_st *memc)
   {
     rc= memcached_set(mclone, key, key_len,value, value_length, 0, 0);
 
-    assert(rc == MEMCACHED_SUCCESS || rc == MEMCACHED_WRITE_FAILURE);
+    assert(rc == MEMCACHED_SUCCESS || rc == MEMCACHED_WRITE_FAILURE || rc == MEMCACHED_BUFFERED);
 
     if (rc == MEMCACHED_WRITE_FAILURE)
       x--;
@@ -1470,7 +1537,6 @@ uint8_t user_supplied_bug11(memcached_st *memc)
     rc= memcached_set(mclone, key, key_len,value, value_length, 0, 0);
 
     WATCHPOINT_IFERROR(rc);
-    //assert(rc == MEMCACHED_SUCCESS);
   }
 
   free(value);
@@ -1618,6 +1684,35 @@ uint8_t generate_data(memcached_st *memc)
   return 0;
 }
 
+uint8_t generate_buffer_data(memcached_st *memc)
+{
+  int latch= 0;
+
+  latch= 1;
+  memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_BUFFER_REQUESTS, &latch);
+  generate_data(memc);
+
+  return 0;
+}
+
+#ifdef NOT_DONE
+uint8_t mset_data(memcached_st *memc)
+{
+  unsigned long long x;
+  global_pairs= pairs_generate(GLOBAL_COUNT);
+
+  (void)memcached_delete(memc, global_keys[x], global_keys_length[x], (time_t)0);
+
+  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;
+}
+#endif
+
 uint8_t get_read(memcached_st *memc)
 {
   unsigned int x;
@@ -1695,6 +1790,50 @@ uint8_t mget_read_result(memcached_st *memc)
   return 0;
 }
 
+uint8_t mget_read_function(memcached_st *memc)
+{
+  memcached_return rc;
+  unsigned int counter;
+  unsigned int (*callbacks[1])(memcached_st *, memcached_result_st *, void *);
+
+  rc= memcached_mget(memc, global_keys, global_keys_length, GLOBAL_COUNT);
+  assert(rc == MEMCACHED_SUCCESS);
+
+  callbacks[0]= &callback_counter;
+  counter= 0;
+  rc= memcached_fetch_execute(memc, callbacks, (void *)&counter, 1); 
+
+  return 0;
+}
+
+uint8_t delete_generate(memcached_st *memc)
+{
+  unsigned int x;
+
+  for (x= 0; x < GLOBAL_COUNT; x++)
+  {
+    (void)memcached_delete(memc, global_keys[x], global_keys_length[x], (time_t)0);
+  }
+
+  return 0;
+}
+
+uint8_t delete_buffer_generate(memcached_st *memc)
+{
+  int latch= 0;
+  unsigned int x;
+
+  latch= 1;
+  memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_BUFFER_REQUESTS, &latch);
+
+  for (x= 0; x < GLOBAL_COUNT; x++)
+  {
+    (void)memcached_delete(memc, global_keys[x], global_keys_length[x], (time_t)0);
+  }
+
+  return 0;
+}
+
 uint8_t free_data(memcached_st *memc)
 {
   pairs_free(global_pairs);
@@ -1914,6 +2053,7 @@ test_st tests[] ={
   {"flush", 0, flush_test },
   {"init", 0, init_test },
   {"allocation", 0, allocation_test },
+  {"server_list_null_test", 0, server_list_null_test},
   {"clone_test", 0, clone_test },
   {"error", 0, error_test },
   {"set", 0, set_test },
@@ -1933,6 +2073,7 @@ test_st tests[] ={
   {"mget", 1, mget_test },
   {"mget_result", 1, mget_result_test },
   {"mget_result_alloc", 1, mget_result_alloc_test },
+  {"mget_result_function", 1, mget_result_function },
   {"get_stats", 0, get_stats },
   {"add_host_test", 0, add_host_test },
   {"get_stats_keys", 0, get_stats_keys },
@@ -1986,11 +2127,16 @@ test_st user_tests[] ={
 };
 
 test_st generate_tests[] ={
-  {"generate_data", 0, generate_data },
+  {"generate_data", 1, generate_data },
   {"get_read", 0, get_read },
+  {"delete_generate", 0, delete_generate },
+  {"generate_buffer_data", 1, generate_buffer_data },
+  {"delete_buffer", 0, delete_buffer_generate},
+  {"generate_data", 1, generate_data },
   {"mget_read", 0, mget_read },
   {"mget_read_result", 0, mget_read_result },
-  {"cleanup", 0, cleanup_pairs },
+  {"mget_read_function", 0, mget_read_function },
+  {"cleanup", 1, cleanup_pairs },
   {0, 0, 0}
 };