Fix situation where test case might bomb if not enough memory is available.

[awesomized/libmemcached] / tests / libmemcached-1.0 / mem_functions.cc

diff --git a/tests/libmemcached-1.0/mem_functions.cc b/tests/libmemcached-1.0/mem_functions.cc
index 199ee01b70a33a5c2e98cb3f39688e960642e3b5..a6adac1b433b39b513d298d27912e95b162e05dd 100644 (file)
--- a/tests/libmemcached-1.0/mem_functions.cc
+++ b/tests/libmemcached-1.0/mem_functions.cc
@@ -299,9 +299,9 @@ static memcached_return_t server_display_unsort_function(const memcached_st*,
   /* Do Nothing */
   uint32_t x= *((uint32_t *)(context));
 
-  if (! (test_ports[x] == server->port))
+  if (! (test_ports[x] == memcached_server_port(server)))
   {
-    fprintf(stderr, "%lu -> %lu\n", (unsigned long)test_ports[x], (unsigned long)server->port);
+    fprintf(stderr, "%lu -> %lu\n", (unsigned long)test_ports[x], (unsigned long)memcached_server_port(server));
     return MEMCACHED_FAILURE;
   }
 
@@ -390,7 +390,7 @@ test_return_t clone_test(memcached_st *memc)
       test_true(memc_clone->flags.buffer_requests == memc->flags.buffer_requests);
       test_true(memc_clone->flags.use_sort_hosts == memc->flags.use_sort_hosts);
       test_true(memc_clone->flags.verify_key == memc->flags.verify_key);
-      test_true(memc_clone->ketama.weighted == memc->ketama.weighted);
+      test_true(memc_clone->ketama.weighted_ == memc->ketama.weighted_);
       test_true(memc_clone->flags.binary_protocol == memc->flags.binary_protocol);
       test_true(memc_clone->flags.hash_with_namespace == memc->flags.hash_with_namespace);
       test_true(memc_clone->flags.reply == memc->flags.reply);
@@ -614,7 +614,7 @@ test_return_t memcached_mget_mixed_memcached_get_TEST(memcached_st *memc)
 
   for (libtest::vchar_ptr_t::iterator iter= keys.begin();
        iter != keys.end(); 
-       iter++)
+       ++iter)
   {
     test_compare_hint(MEMCACHED_SUCCESS,
                       memcached_set(memc,
@@ -1754,6 +1754,11 @@ test_return_t block_add_regression(memcached_st *memc)
                                                 global_pairs[x].key, global_pairs[x].key_length,
                                                 &blob[0], blob.size(),
                                                 time_t(0), uint32_t(0));
+    if (rc == MEMCACHED_MEMORY_ALLOCATION_FAILURE)
+    {
+      Error << memcached_last_error_message(memc);
+      return TEST_SKIPPED;
+    }
     test_compare(*memc, MEMCACHED_SUCCESS);
     test_compare(rc, MEMCACHED_SUCCESS);
   }
@@ -3312,7 +3317,7 @@ test_return_t analyzer_test(memcached_st *memc)
 
 test_return_t util_version_test(memcached_st *memc)
 {
-  test_compare(MEMCACHED_SUCCESS, memcached_version(memc));
+  test_compare(memcached_version(memc), MEMCACHED_SUCCESS);
   test_true(libmemcached_util_version_check(memc, 0, 0, 0));
 
   bool if_successful= libmemcached_util_version_check(memc, 9, 9, 9);
@@ -4044,11 +4049,11 @@ test_return_t regression_bug_447342(memcached_st *memc)
  */
   memcached_server_instance_st instance_one= memcached_server_instance_by_position(memc, 0);
   memcached_server_instance_st instance_two= memcached_server_instance_by_position(memc, 2);
-  in_port_t port0= instance_one->port;
-  in_port_t port2= instance_two->port;
+  in_port_t port0= instance_one->port();
+  in_port_t port2= instance_two->port();
 
-  ((memcached_server_write_instance_st)instance_one)->port= 0;
-  ((memcached_server_write_instance_st)instance_two)->port= 0;
+  ((memcached_server_write_instance_st)instance_one)->port(0);
+  ((memcached_server_write_instance_st)instance_two)->port(0);
 
   test_compare(MEMCACHED_SUCCESS,
                memcached_mget(memc, 
@@ -4060,8 +4065,8 @@ test_return_t regression_bug_447342(memcached_st *memc)
   test_compare(counter, keys.size());
 
   /* restore the memc handle */
-  ((memcached_server_write_instance_st)instance_one)->port= port0;
-  ((memcached_server_write_instance_st)instance_two)->port= port2;
+  ((memcached_server_write_instance_st)instance_one)->port(port0);
+  ((memcached_server_write_instance_st)instance_two)->port(port2);
 
   memcached_quit(memc);
 
@@ -4076,8 +4081,8 @@ test_return_t regression_bug_447342(memcached_st *memc)
   }
 
   memcached_quit(memc);
-  ((memcached_server_write_instance_st)instance_one)->port= 0;
-  ((memcached_server_write_instance_st)instance_two)->port= 0;
+  ((memcached_server_write_instance_st)instance_one)->port(0);
+  ((memcached_server_write_instance_st)instance_two)->port(0);
 
   /* now retry the command, this time we should have cache misses */
   test_compare(MEMCACHED_SUCCESS,
@@ -4090,8 +4095,8 @@ test_return_t regression_bug_447342(memcached_st *memc)
   test_compare(counter, (unsigned int)(keys.size() >> 1));
 
   /* restore the memc handle */
-  ((memcached_server_write_instance_st)instance_one)->port= port0;
-  ((memcached_server_write_instance_st)instance_two)->port= port2;
+  ((memcached_server_write_instance_st)instance_one)->port(port0);
+  ((memcached_server_write_instance_st)instance_two)->port(port2);
 
   return TEST_SUCCESS;
 }
@@ -4474,6 +4479,27 @@ test_return_t regression_bug_490486(memcached_st *original_memc)
   return TEST_SUCCESS;
 }
 
+test_return_t regression_1021819_TEST(memcached_st *original)
+{
+  memcached_st *memc= memcached_clone(NULL, original);
+  test_true(memc);
+
+  test_compare(memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_SND_TIMEOUT, 2000000), MEMCACHED_SUCCESS);
+  test_compare(memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_RCV_TIMEOUT, 3000000), MEMCACHED_SUCCESS);
+
+  memcached_return_t rc;
+
+  memcached_get(memc,
+                test_literal_param(__func__),
+                NULL, NULL, &rc);
+
+  test_compare(rc, MEMCACHED_NOTFOUND);
+
+  memcached_free(memc);
+
+  return TEST_SUCCESS;
+}
+
 test_return_t regression_bug_583031(memcached_st *)
 {
   memcached_st *memc= memcached_create(NULL);