Merging replication

[m6w6/libmemcached] / tests / function.c

diff --git a/tests/function.c b/tests/function.c
index 3113fb1f5943aa98f186b4d5751611e2e99547df..5f83e1ea2a16a05d8f5133c189aff8a212fbe172 100644 (file)
--- a/tests/function.c
+++ b/tests/function.c
@@ -215,6 +215,7 @@ static test_return  clone_test(memcached_st *memc)
     assert(clone->call_free == memc->call_free);
     assert(clone->call_malloc == memc->call_malloc);
     assert(clone->call_realloc == memc->call_realloc);
+    assert(clone->call_calloc == memc->call_calloc);
     assert(clone->connect_timeout == memc->connect_timeout);
     assert(clone->delete_trigger == memc->delete_trigger);
     assert(clone->distribution == memc->distribution);
@@ -263,6 +264,16 @@ static test_return  clone_test(memcached_st *memc)
   return 0;
 }
 
+static test_return userdata_test(memcached_st *memc)
+{
+  void* foo;
+  assert(memcached_set_user_data(memc, foo) == NULL);
+  assert(memcached_get_user_data(memc) == foo);
+  assert(memcached_set_user_data(memc, NULL) == foo);
+  
+  return TEST_SUCCESS;
+}
+
 static test_return  connection_test(memcached_st *memc)
 {
   memcached_return rc;
@@ -3065,7 +3076,11 @@ static void my_free(memcached_st *ptr __attribute__((unused)), void *mem)
 
 static void *my_malloc(memcached_st *ptr __attribute__((unused)), const size_t size)
 {
-  return calloc(1, size);
+  void *ret= malloc(size);
+  if (ret != NULL)
+    memset(ret, 0xff, size);
+
+  return ret;
 }
 
 static void *my_realloc(memcached_st *ptr __attribute__((unused)), void *mem, const size_t size)
@@ -3073,6 +3088,11 @@ static void *my_realloc(memcached_st *ptr __attribute__((unused)), void *mem, co
   return realloc(mem, size);
 }
 
+static void *my_calloc(memcached_st *ptr __attribute__((unused)), size_t nelem, const size_t size)
+{
+  return calloc(nelem, size);
+}
+
 static memcached_return set_prefix(memcached_st *memc)
 {
   memcached_return rc;
@@ -3140,7 +3160,7 @@ static memcached_return set_prefix(memcached_st *memc)
   return MEMCACHED_SUCCESS;
 }
 
-static memcached_return  set_memory_alloc(memcached_st *memc)
+static memcached_return deprecated_set_memory_alloc(memcached_st *memc)
 {
   void *test_ptr= NULL;
   void *cb_ptr= NULL;
@@ -3182,6 +3202,30 @@ static memcached_return  set_memory_alloc(memcached_st *memc)
     assert(rc == MEMCACHED_SUCCESS);
     assert(test_ptr == cb_ptr);
   }
+  return MEMCACHED_SUCCESS;
+}
+
+static memcached_return set_memory_alloc(memcached_st *memc)
+{
+  memcached_return rc;
+  rc= memcached_set_memory_allocators(memc, NULL, my_free, 
+                                      my_realloc, my_calloc);
+  assert(rc == MEMCACHED_FAILURE);
+
+  rc= memcached_set_memory_allocators(memc, my_malloc, my_free, 
+                                      my_realloc, my_calloc);
+  
+  memcached_malloc_function mem_malloc;
+  memcached_free_function mem_free;
+  memcached_realloc_function mem_realloc;
+  memcached_calloc_function mem_calloc;
+  memcached_get_memory_allocators(memc, &mem_malloc, &mem_free, 
+                                  &mem_realloc, &mem_calloc);   
+
+  assert(mem_malloc == my_malloc);
+  assert(mem_realloc == my_realloc);
+  assert(mem_calloc == my_calloc);
+  assert(mem_free == my_free);
 
   return MEMCACHED_SUCCESS;
 }
@@ -3604,7 +3648,8 @@ static test_return replication_mget_test(memcached_st *memc)
    * This is to verify correct behavior in the library
    */
   memcached_result_st result_obj;
-  for (int host= 0; host < clone->number_of_hosts; ++host) {
+  for (int host= 0; host < clone->number_of_hosts; ++host) 
+  {
     memcached_st *clone= memcached_clone(NULL, memc);
     clone->hosts[host].port= 0;
 
@@ -3621,7 +3666,7 @@ static test_return replication_mget_test(memcached_st *memc)
       int hits= 0;
       while ((results= memcached_fetch_result(clone, &result_obj, &rc)) != NULL)
       {
-        ++hits;
+        hits++;
       }
       assert(hits == 4);
       memcached_result_free(&result_obj);
@@ -3664,7 +3709,8 @@ static test_return replication_delete_test(memcached_st *memc)
   }
 
   memcached_result_st result_obj;
-  for (int host= 0; host < clone->number_of_hosts; ++host) {
+  for (int host= 0; host < clone->number_of_hosts; ++host) 
+  {
     for (int x= 'a'; x <= 'z'; ++x)
     {
       char key[2]= { [0]= (char)x };
@@ -3701,6 +3747,7 @@ static uint16_t *get_udp_request_ids(memcached_st *memc)
   uint16_t *ids= malloc(sizeof(uint16_t) * memc->number_of_hosts);
   assert(ids != NULL);
   unsigned int x;
+
   for (x= 0; x < memc->number_of_hosts; x++)
     ids[x]= get_udp_datagram_request_id((struct udp_datagram_header_st *) memc->hosts[x].write_buffer);
 
@@ -3712,6 +3759,7 @@ static test_return post_udp_op_check(memcached_st *memc, uint16_t *expected_req_
   unsigned int x;
   memcached_server_st *cur_server = memc->hosts;
   uint16_t *cur_req_ids = get_udp_request_ids(memc);
+
   for (x= 0; x < memc->number_of_hosts; x++)
   {
     assert(cur_server[x].cursor_active == 0);
@@ -3719,6 +3767,7 @@ static test_return post_udp_op_check(memcached_st *memc, uint16_t *expected_req_
   }
   free(expected_req_ids);
   free(cur_req_ids);
+
   return TEST_SUCCESS;
 }
 
@@ -3740,6 +3789,7 @@ static memcached_return init_udp(memcached_st *memc)
   memcpy(servers, memc->hosts, sizeof(memcached_server_st) * num_hosts);
   for (x= 0; x < num_hosts; x++)
     memcached_server_free(&memc->hosts[x]);
+
   memc->number_of_hosts= 0;
   memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_USE_UDP, 1);
   for (x= 0; x < num_hosts; x++)
@@ -3747,6 +3797,7 @@ static memcached_return init_udp(memcached_st *memc)
     assert(memcached_server_add_udp(memc, servers[x].hostname, servers[x].port) == MEMCACHED_SUCCESS);
     assert(memc->hosts[x].write_buffer_offset == UDP_DATAGRAM_HEADER_LENGTH);
   }
+
   return MEMCACHED_SUCCESS;
 }
 
@@ -4288,6 +4339,7 @@ test_st tests[] ={
   {"connection_test", 0, connection_test},
   {"callback_test", 0, callback_test},
   {"behavior_test", 0, behavior_test},
+  {"userdata_test", 0, userdata_test},
   {"error", 0, error_test },
   {"set", 0, set_test },
   {"set2", 0, set_test2 },
@@ -4484,6 +4536,7 @@ collection_st collection[] ={
   {"poll_timeout", poll_timeout, 0, tests},
   {"gets", enable_cas, 0, tests},
   {"consistent", enable_consistent, 0, tests},
+  {"deprecated_memory_allocators", deprecated_set_memory_alloc, 0, tests},
   {"memory_allocators", set_memory_alloc, 0, tests},
   {"prefix", set_prefix, 0, tests},
   {"version_1_2_3", check_for_1_2_3, 0, version_1_2_3},