X-Git-Url: https://git.m6w6.name/?a=blobdiff_plain;ds=sidebyside;f=tests%2Fmem_functions.c;h=57b1c7b4aa81e70e2c080ac63e08da17261d2bab;hb=3430cb015fb0add207ff733f484dbb4a9fed3655;hp=dca68b121ca891989ca285835aff5873f081e736;hpb=a8b3a32d94383973ca85025e71a7a1331e679c06;p=m6w6%2Flibmemcached

diff --git a/tests/mem_functions.c b/tests/mem_functions.c
index dca68b12..57b1c7b4 100644
--- a/tests/mem_functions.c
+++ b/tests/mem_functions.c
@@ -1939,6 +1939,54 @@ static test_return_t MEMCACHED_BEHAVIOR_CORK_test(memcached_st *memc)
   return TEST_SUCCESS;
 }
 
+
+static test_return_t MEMCACHED_BEHAVIOR_TCP_KEEPALIVE_test(memcached_st *memc)
+{
+  memcached_return_t rc;
+  bool set= true;
+  bool value;
+
+  rc= memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_TCP_KEEPALIVE, set);
+  test_true(rc == MEMCACHED_SUCCESS || rc == MEMCACHED_NOT_SUPPORTED);
+
+  value= (bool)memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_TCP_KEEPALIVE);
+
+  if (rc == MEMCACHED_SUCCESS)
+  {
+    test_true((bool)value == set);
+  }
+  else
+  {
+    test_false((bool)value == set);
+  }
+
+  return TEST_SUCCESS;
+}
+
+
+static test_return_t MEMCACHED_BEHAVIOR_TCP_KEEPIDLE_test(memcached_st *memc)
+{
+  memcached_return_t rc;
+  bool set= true;
+  bool value;
+
+  rc= memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_TCP_KEEPIDLE, set);
+  test_true(rc == MEMCACHED_SUCCESS || rc == MEMCACHED_NOT_SUPPORTED);
+
+  value= (bool)memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_TCP_KEEPIDLE);
+
+  if (rc == MEMCACHED_SUCCESS)
+  {
+    test_true((bool)value == set);
+  }
+  else
+  {
+    test_false((bool)value == set);
+  }
+
+  return TEST_SUCCESS;
+}
+
 static test_return_t fetch_all_results(memcached_st *memc)
 {
   memcached_return_t rc= MEMCACHED_SUCCESS;
@@ -2974,7 +3022,7 @@ static test_return_t auto_eject_hosts(memcached_st *trash)
   for (size_t x= 0; x < 99; x++)
   {
     memcached_autoeject(memc);
-    uint32_t server_idx = memcached_generate_hash(memc, ketama_test_cases[x].key, strlen(ketama_test_cases[x].key));
+    uint32_t server_idx= memcached_generate_hash(memc, ketama_test_cases[x].key, strlen(ketama_test_cases[x].key));
     test_true(server_idx != 2);
   }
 
@@ -4748,7 +4796,7 @@ static test_return_t hsieh_run (memcached_st *memc __attribute__((unused)))
 
 static test_return_t murmur_run (memcached_st *memc __attribute__((unused)))
 {
-#ifdef __sparc
+#ifdef WORDS_BIGENDIAN
   return TEST_SKIPPED;
 #else
   uint32_t x;
@@ -5414,6 +5462,60 @@ static test_return_t test_verbosity(memcached_st *memc)
   return TEST_SUCCESS;
 }
 
+static test_return_t test_server_failure(memcached_st *memc)
+{
+  memcached_st *local_memc;
+  memcached_server_instance_st instance= memcached_server_instance_by_position(memc, 0);
+
+  local_memc= memcached_create(NULL);
+
+  memcached_server_add(local_memc, memcached_server_name(instance), memcached_server_port(instance));
+  memcached_behavior_set(local_memc, MEMCACHED_BEHAVIOR_SERVER_FAILURE_LIMIT, 2);
+
+  uint32_t server_count= memcached_server_count(local_memc);
+
+  test_true(server_count == 1);
+
+  // Disable the server
+  instance= memcached_server_instance_by_position(local_memc, 0);
+  ((memcached_server_write_instance_st)instance)->server_failure_counter= 2;
+
+  memcached_return_t rc;
+  rc= memcached_set(local_memc, "foo", strlen("foo"),
+                    NULL, 0,
+                    (time_t)0, (uint32_t)0);
+  test_true(rc == MEMCACHED_SERVER_MARKED_DEAD);
+
+  ((memcached_server_write_instance_st)instance)->server_failure_counter= 0;
+  rc= memcached_set(local_memc, "foo", strlen("foo"),
+                    NULL, 0,
+                    (time_t)0, (uint32_t)0);
+  test_true(rc == MEMCACHED_SUCCESS);
+
+
+  memcached_free(local_memc);
+
+  return TEST_SUCCESS;
+}
+
+static test_return_t test_cull_servers(memcached_st *memc)
+{
+  uint32_t count = memcached_server_count(memc);
+
+  // Do not do this in your code, it is not supported.
+  memc->servers[1].state.is_dead= true;
+  memc->state.is_time_for_rebuild= true;
+
+  uint32_t new_count= memcached_server_count(memc);
+  test_true(count == new_count);
+
+#if 0
+  test_true(count == new_count + 1 );
+#endif
+
+  return TEST_SUCCESS;
+}
+
 /*
  * This test ensures that the failure counter isn't incremented during
  * normal termination of the memcached instance.
@@ -5545,6 +5647,101 @@ static test_return_t regression_bug_490486(memcached_st *memc)
   return TEST_SUCCESS;
 }
 
+static void memcached_die(memcached_st* mc, memcached_return error, const char* what, int it)
+{
+  fprintf(stderr, "Iteration #%i: ", it);
+
+  if(error == MEMCACHED_ERRNO)
+  {
+    fprintf(stderr, "system error %d from %s: %s\n",
+            errno, what, strerror(errno));
+  }
+  else
+  {
+    fprintf(stderr, "error %d from %s: %s\n", error, what,
+            memcached_strerror(mc, error));
+  }
+
+  abort();
+}
+
+#define TEST_CONSTANT_CREATION 400
+
+static test_return_t regression_bug_(memcached_st *memc)
+{
+  memcached_server_instance_st instance= memcached_server_instance_by_position(memc, 0);
+  const char *servername= memcached_server_name(instance);
+  in_port_t port= memcached_server_port(instance);
+
+  for (uint32_t x= 0; x < TEST_CONSTANT_CREATION; x++) 
+  {
+    memcached_st* mc= memcached_create(NULL);
+    memcached_return rc;
+
+    rc= memcached_behavior_set(mc, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL, 1);
+    if (rc != MEMCACHED_SUCCESS)
+    {
+      memcached_die(mc, rc, "memcached_behavior_set", x);
+    }
+
+    rc= memcached_behavior_set(mc, MEMCACHED_BEHAVIOR_CACHE_LOOKUPS, 1);
+    if (rc != MEMCACHED_SUCCESS)
+    {
+      memcached_die(mc, rc, "memcached_behavior_set", x);
+    }
+
+    rc= memcached_server_add(mc, servername, port);
+    if(rc != MEMCACHED_SUCCESS)
+    {
+      memcached_die(mc, rc, "memcached_server_add", x);
+    }
+
+    const char *set_key= "akey";
+    const size_t set_key_len= strlen(set_key);
+    const char *set_value= "a value";
+    const size_t set_value_len= strlen(set_value);
+
+    char *get_value=NULL;
+    size_t get_value_len=0;
+    uint32_t get_value_flags=0;
+    if (x > 0) 
+    {
+      get_value= memcached_get(mc, set_key, set_key_len, &get_value_len,
+                               &get_value_flags, &rc);
+      if (rc != MEMCACHED_SUCCESS)
+      {
+        memcached_die(mc, rc, "memcached_get", x);
+      }
+
+      if (x != 0 &&
+          (get_value_len != set_value_len
+           || 0!=strncmp(get_value, set_value, get_value_len)))
+      {
+        fprintf(stderr, "Values don't match?\n");
+      }
+      free(get_value);
+      get_value= NULL;
+      get_value_len= 0;
+    }
+
+    rc= memcached_set(mc,
+                      set_key, set_key_len,
+                      set_value, set_value_len,
+                      0, /* time */
+                      0  /* flags */
+                     );
+    if (rc != MEMCACHED_SUCCESS)
+    {
+      memcached_die(mc, rc, "memcached_set", x);
+    }
+
+    memcached_quit(mc);
+    memcached_free(mc);
+  }
+
+  return MEMCACHED_SUCCESS;
+}
+
 /*
  * Test that the sasl authentication works. We cannot use the default
  * pool of servers, because that would require that all servers we want
@@ -5640,12 +5837,16 @@ test_st tests[] ={
 #endif
   {"test_get_last_disconnect", 1, (test_callback_fn)test_get_last_disconnect},
   {"verbosity", 1, (test_callback_fn)test_verbosity},
+  {"test_server_failure", 1, (test_callback_fn)test_server_failure},
+  {"cull_servers", 1, (test_callback_fn)test_cull_servers},
   {0, 0, 0}
 };
 
 test_st behavior_tests[] ={
   {"behavior_test", 0, (test_callback_fn)behavior_test},
   {"MEMCACHED_BEHAVIOR_CORK", 0, (test_callback_fn)MEMCACHED_BEHAVIOR_CORK_test},
+  {"MEMCACHED_BEHAVIOR_TCP_KEEPALIVE", 0, (test_callback_fn)MEMCACHED_BEHAVIOR_TCP_KEEPALIVE_test},
+  {"MEMCACHED_BEHAVIOR_TCP_KEEPIDLE", 0, (test_callback_fn)MEMCACHED_BEHAVIOR_TCP_KEEPIDLE_test},
   {0, 0, 0}
 };
 
@@ -5738,6 +5939,7 @@ test_st regression_tests[]= {
   {"lp:447342", 1, (test_callback_fn)regression_bug_447342 },
   {"lp:463297", 1, (test_callback_fn)regression_bug_463297 },
   {"lp:490486", 1, (test_callback_fn)regression_bug_490486 },
+  {"lp:?", 1, (test_callback_fn)regression_bug_ },
   {0, 0, (test_callback_fn)0}
 };