X-Git-Url: https://git.m6w6.name/?a=blobdiff_plain;ds=sidebyside;f=tests%2Fmem_functions.c;h=76f7d6eee2316470238443098de97dc44b874a60;hb=5978e22206f36565d27a4d513962832f92955652;hp=02df660d3b3d686175c412a05f181c3eeec8e8a7;hpb=0b440c1273944e5ad216f1d6fe9e881e66ea0550;p=awesomized%2Flibmemcached

diff --git a/tests/mem_functions.c b/tests/mem_functions.c
index 02df660d..76f7d6ee 100644
--- a/tests/mem_functions.c
+++ b/tests/mem_functions.c
@@ -104,7 +104,7 @@ static memcached_return_t dump_server_information(const memcached_st *ptr __attr
   /* Do Nothing */
   FILE *stream= (FILE *)context;
 
-  fprintf(stream, "Memcached Server: %s %u Version %d.%d.%d\n", 
+  fprintf(stream, "Memcached Server: %s %u Version %u.%u.%u\n", 
           memcached_server_name(instance),
           memcached_server_port(instance),
           instance->major_version,
@@ -1031,7 +1031,7 @@ static test_return_t set_test3(memcached_st *memc)
   {
     char key[16];
 
-    sprintf(key, "foo%u", x);
+    snprintf(key, sizeof(key), "foo%u", x);
 
     rc= memcached_set(memc, key, strlen(key),
                       value, value_length,
@@ -1700,7 +1700,7 @@ static test_return_t mget_execute(memcached_st *memc)
   {
     char k[251];
 
-    key_length[x]= (size_t)snprintf(k, sizeof(k), "0200%zu", x);
+    key_length[x]= (size_t)snprintf(k, sizeof(k), "0200%lu", (unsigned long)x);
     keys[x]= strdup(k);
     test_true(keys[x] != NULL);
     rc= memcached_add(memc, keys[x], key_length[x], blob, sizeof(blob), 0, 0);
@@ -2054,7 +2054,7 @@ static test_return_t MEMCACHED_BEHAVIOR_TCP_KEEPIDLE_test(memcached_st *memc)
   return TEST_SUCCESS;
 }
 
-static test_return_t fetch_all_results(memcached_st *memc)
+static test_return_t fetch_all_results(memcached_st *memc, size_t *keys_returned)
 {
   memcached_return_t rc= MEMCACHED_SUCCESS;
   char return_key[MEMCACHED_MAX_KEY];
@@ -2063,15 +2063,20 @@ static test_return_t fetch_all_results(memcached_st *memc)
   size_t return_value_length;
   uint32_t flags;
 
+  *keys_returned= 0;
+
   while ((return_value= memcached_fetch(memc, return_key, &return_key_length,
                                         &return_value_length, &flags, &rc)))
   {
     test_true(return_value);
     test_true(rc == MEMCACHED_SUCCESS);
     free(return_value);
+    *keys_returned= *keys_returned +1;
   }
 
-  return ((rc == MEMCACHED_END) || (rc == MEMCACHED_SUCCESS)) ? TEST_SUCCESS : TEST_FAILURE;
+  test_true_got(rc == MEMCACHED_END || rc == MEMCACHED_SUCCESS, memcached_strerror(NULL, rc));
+
+  return TEST_SUCCESS;
 }
 
 /* Test case provided by Cal Haldenbrand */
@@ -2209,7 +2214,8 @@ static test_return_t user_supplied_bug3(memcached_st *memc)
   rc= memcached_mget(memc, (const char **)keys, key_lengths, KEY_COUNT);
   test_true(rc == MEMCACHED_SUCCESS);
 
-  test_true(fetch_all_results(memc) == TEST_SUCCESS);
+  size_t keys_returned;
+  test_true(fetch_all_results(memc, &keys_returned) == TEST_SUCCESS);
 
   for (x= 0; x < KEY_COUNT; x++)
     free(keys[x]);
@@ -3005,7 +3011,8 @@ static test_return_t _user_supplied_bug21(memcached_st* memc, size_t key_count)
   alarm(0);
   signal(SIGALRM, oldalarm);
 
-  test_true(fetch_all_results(memc) == TEST_SUCCESS);
+  size_t keys_returned;
+  test_true(fetch_all_results(memc, &keys_returned) == TEST_SUCCESS);
 
   for (x= 0; x < key_count; x++)
     free(keys[x]);
@@ -3160,7 +3167,7 @@ static test_return_t output_ketama_weighted_keys(memcached_st *trash)
   for (int x= 0; x < 10000; x++)
   {
     char key[10];
-    sprintf(key, "%d", x);
+    snprintf(key, sizeof(key), "%d", x);
 
     uint32_t server_idx = memcached_generate_hash(memc, key, strlen(key));
     char *hostname = memc->hosts[server_idx].hostname;
@@ -3359,7 +3366,9 @@ static test_return_t generate_large_pairs(memcached_st *memc __attribute__((unus
 
 static test_return_t generate_data(memcached_st *memc)
 {
-  execute_set(memc, global_pairs, global_count);
+  unsigned int check_execute= execute_set(memc, global_pairs, global_count);
+
+  test_true(check_execute == global_count);
 
   return TEST_SUCCESS;
 }
@@ -3369,7 +3378,9 @@ static test_return_t generate_data_with_stats(memcached_st *memc)
   memcached_stat_st *stat_p;
   memcached_return_t rc;
   uint32_t host_index= 0;
-  execute_set(memc, global_pairs, global_count);
+  unsigned int check_execute= execute_set(memc, global_pairs, global_count);
+
+  test_true(check_execute == global_count);
 
   //TODO: hosts used size stats
   stat_p= memcached_stat(memc, NULL, &rc);
@@ -3465,9 +3476,20 @@ static test_return_t mget_read(memcached_st *memc)
 {
   memcached_return_t rc;
 
+  rc= memcached_flush_buffers(memc);
+  test_true_got(rc == MEMCACHED_SUCCESS, memcached_strerror(NULL, rc));
+
   rc= memcached_mget(memc, global_keys, global_keys_length, global_count);
-  test_true(rc == MEMCACHED_SUCCESS);
-  test_true(fetch_all_results(memc) == TEST_SUCCESS);
+  if (rc == MEMCACHED_SUCCESS || MEMCACHED_SOME_ERRORS)
+  {
+    size_t keys_returned;
+    test_true(fetch_all_results(memc, &keys_returned) == TEST_SUCCESS);
+    char buffer[30];
+    snprintf(buffer, sizeof(buffer), "%lu", (unsigned long)keys_returned);
+    test_true_got(global_count == keys_returned, buffer);
+  }
+
+  test_true_got(rc == MEMCACHED_SUCCESS, memcached_strerror(NULL, rc));
 
   return TEST_SUCCESS;
 }
@@ -3477,7 +3499,7 @@ static test_return_t mget_read_result(memcached_st *memc)
   memcached_return_t rc;
 
   rc= memcached_mget(memc, global_keys, global_keys_length, global_count);
-  test_true(rc == MEMCACHED_SUCCESS);
+  test_true_got(rc == MEMCACHED_SUCCESS, memcached_strerror(NULL, rc));
   /* Turn this into a help function */
   {
     memcached_result_st results_obj;
@@ -3504,7 +3526,7 @@ static test_return_t mget_read_function(memcached_st *memc)
   memcached_execute_fn callbacks[1];
 
   rc= memcached_mget(memc, global_keys, global_keys_length, global_count);
-  test_true(rc == MEMCACHED_SUCCESS);
+  test_true_got(rc == MEMCACHED_SUCCESS, memcached_strerror(NULL, rc));
 
   callbacks[0]= &callback_counter;
   counter= 0;
@@ -3552,7 +3574,7 @@ static test_return_t add_host_test1(memcached_st *memc)
   {
     char buffer[SMALL_STRING_LEN];
 
-    snprintf(buffer, SMALL_STRING_LEN, "%zu.example.com", 400+x);
+    snprintf(buffer, SMALL_STRING_LEN, "%lu.example.com", (unsigned long)(400 +x));
     servers= memcached_server_list_append_with_weight(servers, buffer, 401, 0,
                                      &rc);
     test_true(rc == MEMCACHED_SUCCESS);
@@ -3620,7 +3642,7 @@ static test_return_t pre_nonblock_binary(memcached_st *memc)
   // will not toggle protocol on an connection.
   memcached_version(memc_clone);
 
-  if (libmemcached_util_version_check(memc_clone, 1, 3, 0))
+  if (libmemcached_util_version_check(memc_clone, 1, 4, 4))
   {
     memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_NO_BLOCK, 0);
     rc = memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL, 1);
@@ -3746,7 +3768,7 @@ static test_return_t pre_binary(memcached_st *memc)
 {
   memcached_return_t rc= MEMCACHED_FAILURE;
 
-  if (libmemcached_util_version_check(memc, 1, 3, 0))
+  if (libmemcached_util_version_check(memc, 1, 4, 4))
   {
     rc = memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL, 1);
     test_true(rc == MEMCACHED_SUCCESS);
@@ -4168,7 +4190,11 @@ static test_return_t noreply_test(memcached_st *memc)
     for (size_t x= 0; x < 100; ++x)
     {
       char key[10];
-      size_t len= (size_t)sprintf(key, "%zu", x);
+      int check_length= (size_t)snprintf(key, sizeof(key), "%lu", (unsigned long)x);
+      test_false((size_t)check_length >= sizeof(key) || check_length < 0);
+
+      size_t len= (size_t)check_length;
+
       switch (count)
       {
       case 0:
@@ -4216,7 +4242,11 @@ static test_return_t noreply_test(memcached_st *memc)
     {
       char key[10];
 
-      size_t len= (size_t)sprintf(key, "%zu", x);
+      int check_length= (size_t)snprintf(key, sizeof(key), "%lu", (unsigned long)x);
+
+      test_false((size_t)check_length >= sizeof(key) || check_length < 0);
+
+      size_t len= (size_t)check_length;
       size_t length;
       uint32_t flags;
       char* value=memcached_get(memc, key, strlen(key),
@@ -4353,14 +4383,15 @@ static void* connection_release(void *arg)
   return arg;
 }
 
+#define POOL_SIZE 10
 static test_return_t connection_pool_test(memcached_st *memc)
 {
-  memcached_pool_st* pool= memcached_pool_create(memc, 5, 10);
+  memcached_pool_st* pool= memcached_pool_create(memc, 5, POOL_SIZE);
   test_true(pool != NULL);
-  memcached_st* mmc[10];
+  memcached_st *mmc[POOL_SIZE];
   memcached_return_t rc;
 
-  for (size_t x= 0; x < 10; ++x)
+  for (size_t x= 0; x < POOL_SIZE; ++x)
   {
     mmc[x]= memcached_pool_pop(pool, false, &rc);
     test_true(mmc[x] != NULL);
@@ -4387,7 +4418,7 @@ static test_return_t connection_pool_test(memcached_st *memc)
   rc= memcached_set(mmc[0], key, keylen, "0", 1, 0, 0);
   test_true(rc == MEMCACHED_SUCCESS);
 
-  for (size_t x= 0; x < 10; ++x)
+  for (size_t x= 0; x < POOL_SIZE; ++x)
   {
     uint64_t number_value;
     rc= memcached_increment(mmc[x], key, keylen, 1, &number_value);
@@ -4396,7 +4427,7 @@ static test_return_t connection_pool_test(memcached_st *memc)
   }
 
   // Release them..
-  for (size_t x= 0; x < 10; ++x)
+  for (size_t x= 0; x < POOL_SIZE; ++x)
   {
     test_true(memcached_pool_push(pool, mmc[x]) == MEMCACHED_SUCCESS);
   }
@@ -4423,8 +4454,8 @@ static test_return_t connection_pool_test(memcached_st *memc)
   test_true(memcached_behavior_get(mmc[0], MEMCACHED_BEHAVIOR_IO_MSG_WATERMARK) == 9999);
   test_true(memcached_pool_push(pool, mmc[0]) == MEMCACHED_SUCCESS);
 
-
   test_true(memcached_pool_destroy(pool) == memc);
+
   return TEST_SUCCESS;
 }
 
@@ -4437,7 +4468,8 @@ static test_return_t util_version_test(memcached_st *memc)
 
   if_successful= libmemcached_util_version_check(memc, 9, 9, 9);
 
-//  if (! if_successful)
+  // We expect failure
+  if (if_successful)
   {
     fprintf(stderr, "\n----------------------------------------------------------------------\n");
     fprintf(stderr, "\nDumping Server Information\n\n");
@@ -5324,7 +5356,7 @@ static test_return_t regression_bug_434843(memcached_st *memc)
   {
      char k[251];
 
-     key_length[x]= (size_t)snprintf(k, sizeof(k), "0200%zu", x);
+     key_length[x]= (size_t)snprintf(k, sizeof(k), "0200%lu", (unsigned long)x);
      keys[x]= strdup(k);
      test_true(keys[x] != NULL);
   }
@@ -5481,7 +5513,7 @@ static test_return_t regression_bug_447342(memcached_st *memc)
   {
     char k[251];
 
-    key_length[x]= (size_t)snprintf(k, sizeof(k), "0200%zu", x);
+    key_length[x]= (size_t)snprintf(k, sizeof(k), "0200%lu", (unsigned long)x);
     keys[x]= strdup(k);
     test_true(keys[x] != NULL);
     rc= memcached_set(memc, k, key_length[x], k, key_length[x], 0, 0);
@@ -5878,7 +5910,7 @@ static test_return_t regression_bug_490486(memcached_st *memc)
   for (size_t x= 0; x < max_keys; ++x)
   {
     char k[251];
-    key_length[x]= (size_t)snprintf(k, sizeof(k), "0200%zu", x);
+    key_length[x]= (size_t)snprintf(k, sizeof(k), "0200%lu", (unsigned long)x);
     keys[x]= strdup(k);
     assert(keys[x] != NULL);
     rc= memcached_set(memc, keys[x], key_length[x], blob, sizeof(blob), 0, 0);
@@ -5971,7 +6003,7 @@ static test_return_t regression_bug_583031(memcached_st *unused)
 
     (void)memcached_get(memc, "dsf", 3, &length, &flags, &rc);
 
-    test_true(rc == MEMCACHED_TIMEOUT);
+    test_true_got(rc == MEMCACHED_TIMEOUT, memcached_strerror(NULL, rc));
 
     memcached_free(memc);