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

diff --git a/tests/function.c b/tests/function.c
index 1e2c6f07..640fbfe4 100644
--- a/tests/function.c
+++ b/tests/function.c
@@ -117,6 +117,204 @@ uint8_t set_test(memcached_st *memc)
   return 0;
 }
 
+uint8_t append_test(memcached_st *memc)
+{
+  memcached_return rc;
+  char *key= "fig";
+  char *value= "we";
+  size_t value_length;
+  uint16_t flags;
+
+  rc= memcached_flush(memc, 0);
+  assert(rc == MEMCACHED_SUCCESS);
+
+  rc= memcached_set(memc, key, strlen(key), 
+                    value, strlen(value),
+                    (time_t)0, (uint16_t)0);
+  assert(rc == MEMCACHED_SUCCESS);
+
+  rc= memcached_append(memc, key, strlen(key), 
+                       " the", strlen(" the"),
+                       (time_t)0, (uint16_t)0);
+  assert(rc == MEMCACHED_SUCCESS);
+
+  rc= memcached_append(memc, key, strlen(key), 
+                       " people", strlen(" people"),
+                       (time_t)0, (uint16_t)0);
+  assert(rc == MEMCACHED_SUCCESS);
+
+  value= memcached_get(memc, key, strlen(key),
+                       &value_length, &flags, &rc);
+  assert(!memcmp(value, "we the people", strlen("we the people")));
+  assert(strlen("we the people") == value_length);
+  assert(rc == MEMCACHED_SUCCESS);
+
+  return 0;
+}
+
+uint8_t append_binary_test(memcached_st *memc)
+{
+  memcached_return rc;
+  char *key= "numbers";
+  unsigned int *store_ptr;
+  unsigned int store_list[] = { 23, 56, 499, 98, 32847, 0 };
+  char *value;
+  size_t value_length;
+  uint16_t flags;
+  unsigned int x;
+
+  rc= memcached_flush(memc, 0);
+  assert(rc == MEMCACHED_SUCCESS);
+
+  rc= memcached_set(memc, 
+                    key, strlen(key), 
+                    NULL, 0,
+                    (time_t)0, (uint16_t)0);
+  assert(rc == MEMCACHED_SUCCESS);
+
+  for (x= 0; store_list[x] ; x++)
+  {
+    rc= memcached_append(memc, 
+                         key, strlen(key), 
+                         (char *)&store_list[x], sizeof(unsigned int),
+                         (time_t)0, (uint16_t)0);
+    assert(rc == MEMCACHED_SUCCESS);
+  }
+
+  value= memcached_get(memc, key, strlen(key),
+                       &value_length, &flags, &rc);
+  assert((value_length == (sizeof(unsigned int) * x)));
+  assert(rc == MEMCACHED_SUCCESS);
+
+  store_ptr= (unsigned int *)value;
+  x= 0;
+  while (*store_ptr)
+  {
+    assert(*store_ptr == store_list[x++]);
+    store_ptr++;
+  }
+
+  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;
+}
+
+uint8_t cas_test(memcached_st *memc)
+{
+  memcached_return rc;
+  char *key= "fun";
+  size_t key_length= strlen("fun");
+  char *value= "we the people";
+  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);
+  assert(rc == MEMCACHED_SUCCESS);
+
+  rc= memcached_mget(memc, &key, &key_length, 1);
+
+  results= memcached_result_create(memc, &results_obj);
+
+  results= memcached_fetch_result(memc, &results_obj, &rc);
+  assert(results);
+  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;
+}
+
+uint8_t prepend_test(memcached_st *memc)
+{
+  memcached_return rc;
+  char *key= "fig";
+  char *value= "people";
+  size_t value_length;
+  uint16_t flags;
+
+  rc= memcached_flush(memc, 0);
+  assert(rc == MEMCACHED_SUCCESS);
+
+  rc= memcached_set(memc, key, strlen(key), 
+                    value, strlen(value),
+                    (time_t)0, (uint16_t)0);
+  assert(rc == MEMCACHED_SUCCESS);
+
+  rc= memcached_prepend(memc, key, strlen(key), 
+                       "the ", strlen("the "),
+                       (time_t)0, (uint16_t)0);
+  assert(rc == MEMCACHED_SUCCESS);
+
+  rc= memcached_prepend(memc, key, strlen(key), 
+                       "we ", strlen("we "),
+                       (time_t)0, (uint16_t)0);
+  assert(rc == MEMCACHED_SUCCESS);
+
+  value= memcached_get(memc, key, strlen(key),
+                       &value_length, &flags, &rc);
+  assert(!memcmp(value, "we the people", strlen("we the people")));
+  assert(strlen("we the people") == value_length);
+  assert(rc == MEMCACHED_SUCCESS);
+
+  return 0;
+}
+
 uint8_t add_test(memcached_st *memc)
 {
   memcached_return rc;
@@ -1051,6 +1249,51 @@ uint8_t user_supplied_bug6(memcached_st *memc)
   return 0;
 }
 
+/* Test flag store/retrieve */
+uint8_t user_supplied_bug7(memcached_st *memc)
+{
+  memcached_return rc;
+  char *keys= "036790384900";
+  size_t key_length=  strlen("036790384900");
+  char return_key[MEMCACHED_MAX_KEY];
+  size_t return_key_length;
+  char *value;
+  size_t value_length;
+  uint16_t flags;
+  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);
+
+  flags= 245;
+  rc= memcached_set(memc, keys, key_length, 
+                    insert_data, VALUE_SIZE_BUG5,
+                    (time_t)0, flags);
+  assert(rc == MEMCACHED_SUCCESS);
+
+  flags= 0;
+  value= memcached_get(memc, keys, key_length,
+                        &value_length, &flags, &rc);		
+  assert(flags == 245);
+  assert(value);
+  free(value);
+
+  rc= memcached_mget(memc, &keys, &key_length, 1);
+
+  flags= 0;
+  value= memcached_fetch(memc, return_key, &return_key_length, 
+                         &value_length, &flags, &rc);
+  assert(flags == 245);
+  assert(value);
+  free(value);
+
+
+  return 0;
+}
+
 uint8_t result_static(memcached_st *memc)
 {
   memcached_result_st result;
@@ -1362,6 +1605,36 @@ 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);
+
+  if (memc->hosts[0].major_version >= 1 &&
+      memc->hosts[0].minor_version >= 2 &&
+      memc->hosts[0].micro_version >= 4)
+    return MEMCACHED_SUCCESS;
+
+  return MEMCACHED_FAILURE;
+}
+
 memcached_return pre_unix_socket(memcached_st *memc)
 {
   memcached_return rc;
@@ -1379,6 +1652,22 @@ memcached_return pre_unix_socket(memcached_st *memc)
   return rc;
 }
 
+memcached_return pre_udp(memcached_st *memc)
+{
+  memcached_return rc;
+
+  memcached_server_list_free(memc->hosts);
+  memc->hosts= NULL;
+  memc->number_of_hosts= 0;
+
+  if (0)
+    return MEMCACHED_FAILURE;
+
+  rc= memcached_server_add_udp(memc, "localhost", MEMCACHED_DEFAULT_PORT);
+
+  return rc;
+}
+
 memcached_return pre_nodelay(memcached_st *memc)
 {
   memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_NO_BLOCK, NULL);
@@ -1387,6 +1676,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[] ={
@@ -1435,6 +1739,15 @@ test_st result_tests[] ={
   {0, 0, 0}
 };
 
+test_st version_1_2_3[] ={
+  {"append", 0, append_test },
+  {"prepend", 0, prepend_test },
+  {"cas", 0, cas_test },
+  {"cas2", 0, cas2_test },
+  {"append_binary", 0, append_binary_test },
+  {0, 0, 0}
+};
+
 test_st user_tests[] ={
   {"user_supplied_bug1", 0, user_supplied_bug1 },
   {"user_supplied_bug2", 0, user_supplied_bug2 },
@@ -1442,6 +1755,7 @@ test_st user_tests[] ={
   {"user_supplied_bug4", 0, user_supplied_bug4 },
   {"user_supplied_bug5", 1, user_supplied_bug5 },
   {"user_supplied_bug6", 1, user_supplied_bug6 },
+  {"user_supplied_bug7", 1, user_supplied_bug7 },
   {0, 0, 0}
 };
 
@@ -1467,10 +1781,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_nonblock", pre_nonblock, 0, generate_tests},
   {0, 0, 0, 0}
 };