X-Git-Url: https://git.m6w6.name/?a=blobdiff_plain;f=tests%2Ffunction.c;h=fadd41cd91de481c92db54ecd047d543d8e2cb89;hb=3936140765093cf4e3b28e0a4b837a67b79c1cbf;hp=c62e25c49416486503c84b85252507c446b5ac55;hpb=3d88ffa13ef86218ab0244e8e6490f4038cc193b;p=awesomized%2Flibmemcached

diff --git a/tests/function.c b/tests/function.c
index c62e25c4..fadd41cd 100644
--- a/tests/function.c
+++ b/tests/function.c
@@ -800,16 +800,16 @@ static test_return_t  bad_key_test(memcached_st *memc)
 }
 
 #define READ_THROUGH_VALUE "set for me"
-static memcached_return_t  read_through_trigger(memcached_st *memc __attribute__((unused)),
-                                                char *key __attribute__((unused)),
-                                                size_t key_length __attribute__((unused)),
-                                                memcached_result_st *result)
+static memcached_return_t read_through_trigger(memcached_st *memc __attribute__((unused)),
+                                               char *key __attribute__((unused)),
+                                               size_t key_length __attribute__((unused)),
+                                               memcached_result_st *result)
 {
 
   return memcached_result_set_value(result, READ_THROUGH_VALUE, strlen(READ_THROUGH_VALUE));
 }
 
-static test_return_t  read_through(memcached_st *memc)
+static test_return_t read_through(memcached_st *memc)
 {
   memcached_return_t rc;
   const char *key= "foo";
@@ -822,8 +822,8 @@ static test_return_t  read_through(memcached_st *memc)
                         &string_length, &flags, &rc);
 
   test_truth(rc == MEMCACHED_NOTFOUND);
-  test_truth(string_length ==  0);
-  test_truth(!string);
+  test_false(string_length);
+  test_false(string);
 
   rc= memcached_callback_set(memc, MEMCACHED_CALLBACK_GET_FAILURE,
                              *(void **)&cb);
@@ -834,7 +834,7 @@ static test_return_t  read_through(memcached_st *memc)
 
   test_truth(rc == MEMCACHED_SUCCESS);
   test_truth(string_length ==  strlen(READ_THROUGH_VALUE));
-  test_truth(!strcmp(READ_THROUGH_VALUE, string));
+  test_strcmp(READ_THROUGH_VALUE, string);
   free(string);
 
   string= memcached_get(memc, key, strlen(key),
@@ -885,8 +885,8 @@ static test_return_t  get_test(memcached_st *memc)
                         &string_length, &flags, &rc);
 
   test_truth(rc == MEMCACHED_NOTFOUND);
-  test_truth(string_length ==  0);
-  test_truth(!string);
+  test_false(string_length);
+  test_false(string);
 
   return TEST_SUCCESS;
 }
@@ -1158,8 +1158,8 @@ static test_return_t  stats_servername_test(memcached_st *memc)
   memcached_return_t rc;
   memcached_stat_st memc_stat;
   rc= memcached_stat_servername(&memc_stat, NULL,
-                                 memc->hosts[0].hostname,
-                                 memc->hosts[0].port);
+                                memc->hosts[0].hostname,
+                                memc->hosts[0].port);
 
   return TEST_SUCCESS;
 }
@@ -1664,7 +1664,6 @@ static test_return_t  get_stats_keys(memcached_st *memc)
  test_truth(rc == MEMCACHED_SUCCESS);
  for (ptr= stat_list; *ptr; ptr++)
    test_truth(*ptr);
- fflush(stdout);
 
  free(stat_list);
 
@@ -1846,6 +1845,7 @@ static test_return_t  behavior_test(memcached_st *memc)
   value= memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_NUMBER_OF_REPLICAS);
   memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_NUMBER_OF_REPLICAS, value + 1);
   test_truth((value + 1) == memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_NUMBER_OF_REPLICAS));
+
   return TEST_SUCCESS;
 }
 
@@ -3521,6 +3521,7 @@ static test_return_t pre_binary(memcached_st *memc)
   return rc == MEMCACHED_SUCCESS ? TEST_SUCCESS : TEST_SKIPPED;
 }
 
+
 static test_return_t pre_replication(memcached_st *memc)
 {
   test_return_t test_rc;
@@ -3542,40 +3543,88 @@ static test_return_t pre_replication(memcached_st *memc)
   return rc == MEMCACHED_SUCCESS ? TEST_SUCCESS : TEST_SKIPPED;
 }
 
+
 static test_return_t pre_replication_noblock(memcached_st *memc)
 {
-  test_return_t rc= MEMCACHED_FAILURE;
-  if (pre_replication(memc) == TEST_SUCCESS &&
-      pre_nonblock(memc) == TEST_SUCCESS)
-    rc= TEST_SUCCESS;
+  test_return_t rc;
+
+  rc= pre_replication(memc);
+  if (rc != TEST_SUCCESS)
+    return rc;
+
+  rc= pre_nonblock(memc);
 
   return rc;
 }
 
+
 static void my_free(memcached_st *ptr __attribute__((unused)), void *mem)
 {
+#ifdef HARD_MALLOC_TESTS
+  void *real_ptr= (mem == NULL) ? mem : (void*)((caddr_t)mem - 8);
+  free(real_ptr);
+#else
   free(mem);
+#endif
 }
 
+
 static void *my_malloc(memcached_st *ptr __attribute__((unused)), const size_t size)
 {
+#ifdef HARD_MALLOC_TESTS
+  void *ret= malloc(size + 8);
+  if (ret != NULL)
+  {
+    ret= (void*)((caddr_t)ret + 8);
+  }
+#else
   void *ret= malloc(size);
+#endif
+
   if (ret != NULL)
+  {
     memset(ret, 0xff, size);
+  }
 
   return ret;
 }
 
+
 static void *my_realloc(memcached_st *ptr __attribute__((unused)), void *mem, const size_t size)
 {
+#ifdef HARD_MALLOC_TESTS
+  void *real_ptr= (mem == NULL) ? NULL : (void*)((caddr_t)mem - 8);
+  void *nmem= realloc(real_ptr, size + 8);
+
+  void *ret= NULL;
+  if (nmem != NULL)
+  {
+    ret= (void*)((caddr_t)nmem + 8);
+  }
+
+  return ret;
+#else
   return realloc(mem, size);
+#endif
 }
 
+
 static void *my_calloc(memcached_st *ptr __attribute__((unused)), size_t nelem, const size_t size)
 {
+#ifdef HARD_MALLOC_TESTS
+  void *mem= my_malloc(ptr, nelem * size);
+  if (mem)
+  {
+    memset(mem, 0, nelem * size);
+  }
+
+  return mem;
+#else
   return calloc(nelem, size);
+#endif
 }
 
+
 static test_return_t set_prefix(memcached_st *memc)
 {
   memcached_return_t rc;
@@ -3645,6 +3694,7 @@ static test_return_t set_prefix(memcached_st *memc)
   return TEST_SUCCESS;
 }
 
+
 #ifdef MEMCACHED_ENABLE_DEPRECATED
 static test_return_t deprecated_set_memory_alloc(memcached_st *memc)
 {
@@ -3693,6 +3743,7 @@ static test_return_t deprecated_set_memory_alloc(memcached_st *memc)
 }
 #endif
 
+
 static test_return_t set_memory_alloc(memcached_st *memc)
 {
   memcached_return_t rc;
@@ -3718,7 +3769,27 @@ static test_return_t set_memory_alloc(memcached_st *memc)
   return TEST_SUCCESS;
 }
 
-static test_return_t enable_consistent(memcached_st *memc)
+static test_return_t enable_consistent_crc(memcached_st *memc)
+{
+  test_return_t rc;
+  memcached_server_distribution_t value= MEMCACHED_DISTRIBUTION_CONSISTENT;
+  memcached_hash_t hash;
+  memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_DISTRIBUTION, value);
+  if ((rc= pre_crc(memc)) != TEST_SUCCESS)
+    return rc;
+
+  value= (memcached_server_distribution_t)memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_DISTRIBUTION);
+  test_truth(value == MEMCACHED_DISTRIBUTION_CONSISTENT);
+
+  hash= (memcached_hash_t)memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_HASH);
+
+  if (hash != MEMCACHED_HASH_CRC)
+    return TEST_SKIPPED;
+
+  return TEST_SUCCESS;
+}
+
+static test_return_t enable_consistent_hsieh(memcached_st *memc)
 {
   test_return_t rc;
   memcached_server_distribution_t value= MEMCACHED_DISTRIBUTION_CONSISTENT;
@@ -5462,7 +5533,6 @@ test_st tests[] ={
   {"clone_test", 0, (test_callback_fn)clone_test },
   {"connection_test", 0, (test_callback_fn)connection_test},
   {"callback_test", 0, (test_callback_fn)callback_test},
-  {"behavior_test", 0, (test_callback_fn)behavior_test},
   {"userdata_test", 0, (test_callback_fn)userdata_test},
   {"error", 0, (test_callback_fn)error_test },
   {"set", 0, (test_callback_fn)set_test },
@@ -5497,8 +5567,6 @@ test_st tests[] ={
   {"add_host_test", 0, (test_callback_fn)add_host_test },
   {"add_host_test_1", 0, (test_callback_fn)add_host_test1 },
   {"get_stats_keys", 0, (test_callback_fn)get_stats_keys },
-  {"behavior_test", 0, (test_callback_fn)get_stats_keys },
-  {"callback_test", 0, (test_callback_fn)get_stats_keys },
   {"version_string_test", 0, (test_callback_fn)version_string_test},
   {"bad_key", 1, (test_callback_fn)bad_key_test },
   {"memcached_server_cursor", 1, (test_callback_fn)memcached_server_cursor_test },
@@ -5513,6 +5581,11 @@ test_st tests[] ={
   {0, 0, 0}
 };
 
+test_st behavior_tests[] ={
+  {"behavior_test", 0, (test_callback_fn)behavior_test},
+  {0, 0, 0}
+};
+
 test_st async_tests[] ={
   {"add", 1, (test_callback_fn)add_wrapper },
   {0, 0, 0}
@@ -5703,7 +5776,8 @@ collection_st collection[] ={
   {"unix_socket_nodelay", (test_callback_fn)pre_nodelay, 0, tests},
   {"poll_timeout", (test_callback_fn)poll_timeout, 0, tests},
   {"gets", (test_callback_fn)enable_cas, 0, tests},
-  {"consistent", (test_callback_fn)enable_consistent, 0, tests},
+  {"consistent_crc", (test_callback_fn)enable_consistent_crc, 0, tests},
+  {"consistent_hsieh", (test_callback_fn)enable_consistent_hsieh, 0, tests},
 #ifdef MEMCACHED_ENABLE_DEPRECATED
   {"deprecated_memory_allocators", (test_callback_fn)deprecated_set_memory_alloc, 0, tests},
 #endif
@@ -5718,7 +5792,7 @@ collection_st collection[] ={
   {"generate", 0, 0, generate_tests},
   {"generate_hsieh", (test_callback_fn)pre_hsieh, 0, generate_tests},
   {"generate_ketama", (test_callback_fn)pre_behavior_ketama, 0, generate_tests},
-  {"generate_hsieh_consistent", (test_callback_fn)enable_consistent, 0, generate_tests},
+  {"generate_hsieh_consistent", (test_callback_fn)enable_consistent_hsieh, 0, generate_tests},
   {"generate_md5", (test_callback_fn)pre_md5, 0, generate_tests},
   {"generate_murmur", (test_callback_fn)pre_murmur, 0, generate_tests},
   {"generate_jenkins", (test_callback_fn)pre_jenkins, 0, generate_tests},
@@ -5731,6 +5805,7 @@ collection_st collection[] ={
   {"replication", (test_callback_fn)pre_replication, 0, replication_tests},
   {"replication_noblock", (test_callback_fn)pre_replication_noblock, 0, replication_tests},
   {"regression", 0, 0, regression_tests},
+  {"behaviors", 0, 0, behavior_tests},
   {0, 0, 0, 0}
 };