Merge lp:~tangent-org/libmemcached/1.0-build/ Build: jenkins-Libmemcached-170

[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 3b1701e8315da782714a59810861b44c7720f3b2..068d5197414368f5a84b6f5befb3a105106dc541 100644 (file)
--- a/tests/libmemcached-1.0/mem_functions.cc
+++ b/tests/libmemcached-1.0/mem_functions.cc
@@ -35,7 +35,7 @@
  *
  */
 
-#include <config.h>
+#include <mem_config.h>
 #include <libtest/test.hpp>
 
 #if defined(HAVE_LIBUUID) && HAVE_LIBUUID
@@ -76,7 +76,7 @@
 
 using namespace libtest;
 
-#include <libmemcached/util.h>
+#include <libmemcachedutil-1.0/util.h>
 
 #include "tests/hash_results.h"
 
@@ -86,12 +86,13 @@ using namespace libtest;
 #include "tests/libmemcached-1.0/setup_and_teardowns.h"
 #include "tests/print.h"
 #include "tests/debug.h"
+#include "tests/memc.hpp"
 
 #define UUID_STRING_MAXLENGTH 36
 
 #include "tests/keys.hpp"
 
-#include "libmemcached/instance.h"
+#include "libmemcached/instance.hpp"
 
 static memcached_st * create_single_instance_memcached(const memcached_st *original_memc, const char *options)
 {
@@ -598,7 +599,7 @@ test_return_t append_binary_test(memcached_st *memc)
   test_compare(value_length, sizeof(uint32_t) * count);
   test_compare(MEMCACHED_SUCCESS, rc);
 
-  for (uint32_t counter= count, *ptr= value; counter; counter--)
+  for (uint32_t counter= uint32_t(count), *ptr= value; counter; counter--)
   {
     test_compare(*ptr, store_list[count - counter]);
     ptr++;
@@ -644,7 +645,7 @@ test_return_t memcached_mget_mixed_memcached_get_TEST(memcached_st *memc)
     }
     else
     {
-      int which_key= random() %keys.size();
+      int which_key= random() % int(keys.size());
       size_t value_length;
       uint32_t flags;
       memcached_return_t rc;
@@ -823,6 +824,34 @@ test_return_t memcached_add_SUCCESS_TEST(memcached_st *memc)
   return TEST_SUCCESS;
 }
 
+test_return_t regression_1067242_TEST(memcached_st *memc)
+{
+  test_compare(MEMCACHED_SUCCESS, memcached_set(memc,
+                                                test_literal_param(__func__), 
+                                                test_literal_param("-2"),
+                                                0, 0));
+
+  memcached_return_t rc;
+  char* value;
+  test_true((value= memcached_get(memc, test_literal_param(__func__), NULL, NULL, &rc)));
+  test_compare(MEMCACHED_SUCCESS, rc);
+  free(value);
+
+  for (size_t x= 0; x < 10; x++)
+  {
+    uint64_t new_number;
+    test_compare(MEMCACHED_CLIENT_ERROR,
+                 memcached_increment(memc, 
+                                     test_literal_param(__func__), 1, &new_number));
+    test_compare(MEMCACHED_CLIENT_ERROR, memcached_last_error(memc));
+    test_true((value= memcached_get(memc, test_literal_param(__func__), NULL, NULL, &rc)));
+    test_compare(MEMCACHED_SUCCESS, rc);
+    free(value);
+  }
+
+  return TEST_SUCCESS;
+}
+
 /*
   Set the value, then quit to make sure it is flushed.
   Come back in and test that add fails.
@@ -1754,6 +1783,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);
   }
@@ -1840,6 +1874,34 @@ test_return_t add_host_test(memcached_st *memc)
   return TEST_SUCCESS;
 }
 
+test_return_t regression_1048945_TEST(memcached_st*)
+{
+  memcached_return status;
+
+  memcached_server_st* list= memcached_server_list_append_with_weight(NULL, "a", 11211, 0, &status);
+  test_compare(status, MEMCACHED_SUCCESS);
+
+  list= memcached_server_list_append_with_weight(list, "b", 11211, 0, &status);
+  test_compare(status, MEMCACHED_SUCCESS);
+
+  list= memcached_server_list_append_with_weight(list, "c", 11211, 0, &status);
+  test_compare(status, MEMCACHED_SUCCESS);
+
+  memcached_st* memc= memcached_create(NULL);
+
+  status= memcached_server_push(memc, list);
+  memcached_server_list_free(list);
+  test_compare(status, MEMCACHED_SUCCESS);
+
+  memcached_server_instance_st server= memcached_server_by_key(memc, test_literal_param(__func__), &status);
+  test_true(server);
+  test_compare(status, MEMCACHED_SUCCESS);
+
+  memcached_free(memc);
+
+  return TEST_SUCCESS;
+}
+
 test_return_t memcached_fetch_result_NOT_FOUND(memcached_st *memc)
 {
   memcached_return_t rc;
@@ -2629,7 +2691,7 @@ test_return_t user_supplied_bug20(memcached_st *memc)
  */
 
 /* sighandler_t function that always asserts false */
-static void fail(int)
+static __attribute__((noreturn)) void fail(int)
 {
   fatal_assert(0);
 }
@@ -2703,6 +2765,25 @@ test_return_t user_supplied_bug21(memcached_st *memc)
   return TEST_SUCCESS;
 }
 
+test_return_t ketama_TEST(memcached_st *)
+{
+  test::Memc memc("--server=10.0.1.1:11211 --server=10.0.1.2:11211");
+
+  test_compare(MEMCACHED_SUCCESS,
+               memcached_behavior_set(&memc, MEMCACHED_BEHAVIOR_KETAMA_WEIGHTED, true));
+
+  test_compare(memcached_behavior_get(&memc, MEMCACHED_BEHAVIOR_KETAMA_WEIGHTED), uint64_t(1));
+
+  test_compare(memcached_behavior_set(&memc, MEMCACHED_BEHAVIOR_KETAMA_HASH, MEMCACHED_HASH_MD5), MEMCACHED_SUCCESS);
+
+  test_compare(memcached_behavior_get(&memc, MEMCACHED_BEHAVIOR_KETAMA_HASH), MEMCACHED_HASH_MD5);
+
+  test_compare(memcached_behavior_set_distribution(&memc, MEMCACHED_DISTRIBUTION_CONSISTENT_KETAMA_SPY), MEMCACHED_SUCCESS);
+
+
+  return TEST_SUCCESS;
+}
+
 test_return_t output_ketama_weighted_keys(memcached_st *)
 {
   memcached_st *memc= memcached_create(NULL);
@@ -3162,7 +3243,7 @@ test_return_t noreply_test(memcached_st *memc)
     for (size_t x= 0; x < 100; ++x)
     {
       char key[MEMCACHED_MAXIMUM_INTEGER_DISPLAY_LENGTH +1];
-      int check_length= (size_t)snprintf(key, sizeof(key), "%lu", (unsigned long)x);
+      int check_length= 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;
@@ -3217,7 +3298,7 @@ test_return_t noreply_test(memcached_st *memc)
     {
       char key[10];
 
-      int check_length= (size_t)snprintf(key, sizeof(key), "%lu", (unsigned long)x);
+      int check_length= snprintf(key, sizeof(key), "%lu", (unsigned long)x);
 
       test_false((size_t)check_length >= sizeof(key) || check_length < 0);
 
@@ -3312,7 +3393,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);
@@ -3622,6 +3703,27 @@ test_return_t murmur_run (memcached_st *)
 #endif
 }
 
+test_return_t murmur3_TEST(hashkit_st *)
+{
+  test_skip(true, libhashkit_has_algorithm(HASHKIT_HASH_MURMUR3));
+
+#ifdef WORDS_BIGENDIAN
+  (void)murmur3_values;
+  return TEST_SKIPPED;
+#else
+  uint32_t x;
+  const char **ptr;
+
+  for (ptr= list_to_hash, x= 0; *ptr; ptr++, x++)
+  {
+    test_compare(murmur3_values[x],
+                 memcached_generate_hash_value(*ptr, strlen(*ptr), MEMCACHED_HASH_MURMUR3));
+  }
+
+  return TEST_SUCCESS;
+#endif
+}
+
 test_return_t jenkins_run (memcached_st *)
 {
   uint32_t x;
@@ -4678,6 +4780,10 @@ test_return_t regression_994772_TEST(memcached_st* memc)
   uint64_t cas_value= memcached_result_cas(results);
   test_true(cas_value);
 
+  char* take_value= memcached_result_take_value(results);
+  test_strcmp(__func__, take_value);
+  free(take_value);
+
   memcached_result_free(results);
 
   // Bad cas value, sanity check