X-Git-Url: https://git.m6w6.name/?a=blobdiff_plain;f=tests%2Ffunction.c;h=9c18645d19422e90b21f1023cd1e037ccd2b4a56;hb=refs%2Ftags%2F0.15;hp=3b1e6d450feafcf0457c2065b94a7eb811c8881b;hpb=5ca41b85020ca9acbf5df62dc4af3557cda89f0e;p=awesomized%2Flibmemcached diff --git a/tests/function.c b/tests/function.c index 3b1e6d45..9c18645d 100644 --- a/tests/function.c +++ b/tests/function.c @@ -26,11 +26,12 @@ #include "test.h" #define GLOBAL_COUNT 100000 +#define GLOBAL2_COUNT 1000 +static uint32_t global_count; + static pairs_st *global_pairs; static char *global_keys[GLOBAL_COUNT]; static size_t global_keys_length[GLOBAL_COUNT]; -static char *global_values[GLOBAL_COUNT]; -static size_t global_values_length[GLOBAL_COUNT]; uint8_t init_test(memcached_st *not_used) { @@ -139,7 +140,7 @@ uint8_t set_test(memcached_st *memc) rc= memcached_set(memc, key, strlen(key), value, strlen(value), (time_t)0, (uint32_t)0); - assert(rc == MEMCACHED_SUCCESS); + assert(rc == MEMCACHED_SUCCESS || rc == MEMCACHED_BUFFERED); return 0; } @@ -354,16 +355,24 @@ uint8_t add_test(memcached_st *memc) memcached_return rc; char *key= "foo"; char *value= "when we sanitize"; + unsigned long long setting_value; + + setting_value= memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_NO_BLOCK); rc= memcached_set(memc, key, strlen(key), value, strlen(value), (time_t)0, (uint32_t)0); - assert(rc == MEMCACHED_SUCCESS); + assert(rc == MEMCACHED_SUCCESS || rc == MEMCACHED_BUFFERED); memcached_quit(memc); rc= memcached_add(memc, key, strlen(key), value, strlen(value), (time_t)0, (uint32_t)0); - assert(rc == MEMCACHED_NOTSTORED); + + /* Too many broken OS'es have broken loopback in async, so we can't be sure of the result */ + if (setting_value) + assert(rc == MEMCACHED_NOTSTORED || MEMCACHED_STORED); + else + assert(rc == MEMCACHED_NOTSTORED); return 0; } @@ -383,6 +392,12 @@ uint8_t replace_test(memcached_st *memc) memcached_return rc; char *key= "foo"; char *value= "when we sanitize"; + char *original= "first we insert some data"; + + rc= memcached_set(memc, key, strlen(key), + original, strlen(original), + (time_t)0, (uint32_t)0); + assert(rc == MEMCACHED_SUCCESS || rc == MEMCACHED_BUFFERED); rc= memcached_replace(memc, key, strlen(key), value, strlen(value), @@ -401,10 +416,10 @@ uint8_t delete_test(memcached_st *memc) rc= memcached_set(memc, key, strlen(key), value, strlen(value), (time_t)0, (uint32_t)0); - assert(rc == MEMCACHED_SUCCESS); + assert(rc == MEMCACHED_SUCCESS || rc == MEMCACHED_BUFFERED); rc= memcached_delete(memc, key, strlen(key), (time_t)0); - assert(rc == MEMCACHED_SUCCESS); + assert(rc == MEMCACHED_SUCCESS || rc == MEMCACHED_BUFFERED); return 0; } @@ -428,7 +443,7 @@ uint8_t get_test(memcached_st *memc) uint32_t flags; rc= memcached_delete(memc, key, strlen(key), (time_t)0); - assert(rc == MEMCACHED_SUCCESS || rc == MEMCACHED_NOTFOUND); + assert(rc == MEMCACHED_BUFFERED || rc == MEMCACHED_NOTFOUND); string= memcached_get(memc, key, strlen(key), &string_length, &flags, &rc); @@ -452,7 +467,7 @@ uint8_t get_test2(memcached_st *memc) rc= memcached_set(memc, key, strlen(key), value, strlen(value), (time_t)0, (uint32_t)0); - assert(rc == MEMCACHED_SUCCESS); + assert(rc == MEMCACHED_SUCCESS || rc == MEMCACHED_BUFFERED); string= memcached_get(memc, key, strlen(key), &string_length, &flags, &rc); @@ -480,7 +495,7 @@ uint8_t set_test2(memcached_st *memc) rc= memcached_set(memc, key, strlen(key), value, value_length, (time_t)0, (uint32_t)0); - assert(rc == MEMCACHED_SUCCESS); + assert(rc == MEMCACHED_SUCCESS || rc == MEMCACHED_BUFFERED); } return 0; @@ -505,7 +520,7 @@ uint8_t set_test3(memcached_st *memc) rc= memcached_set(memc, key, strlen(key), value, value_length, (time_t)0, (uint32_t)0); - assert(rc == MEMCACHED_SUCCESS); + assert(rc == MEMCACHED_SUCCESS || rc == MEMCACHED_BUFFERED); } free(value); @@ -533,7 +548,7 @@ uint8_t get_test3(memcached_st *memc) rc= memcached_set(memc, key, strlen(key), value, value_length, (time_t)0, (uint32_t)0); - assert(rc == MEMCACHED_SUCCESS); + assert(rc == MEMCACHED_SUCCESS || rc == MEMCACHED_BUFFERED); string= memcached_get(memc, key, strlen(key), &string_length, &flags, &rc); @@ -569,7 +584,7 @@ uint8_t get_test4(memcached_st *memc) rc= memcached_set(memc, key, strlen(key), value, value_length, (time_t)0, (uint32_t)0); - assert(rc == MEMCACHED_SUCCESS); + assert(rc == MEMCACHED_SUCCESS || rc == MEMCACHED_BUFFERED); for (x= 0; x < 10; x++) { @@ -610,7 +625,7 @@ uint8_t increment_test(memcached_st *memc) rc= memcached_set(memc, key, strlen(key), value, strlen(value), (time_t)0, (uint32_t)0); - assert(rc == MEMCACHED_SUCCESS); + assert(rc == MEMCACHED_SUCCESS || rc == MEMCACHED_BUFFERED); rc= memcached_increment(memc, key, strlen(key), 1, &new_number); @@ -635,7 +650,7 @@ uint8_t decrement_test(memcached_st *memc) rc= memcached_set(memc, key, strlen(key), value, strlen(value), (time_t)0, (uint32_t)0); - assert(rc == MEMCACHED_SUCCESS); + assert(rc == MEMCACHED_SUCCESS || rc == MEMCACHED_BUFFERED); rc= memcached_decrement(memc, key, strlen(key), 1, &new_number); @@ -659,13 +674,13 @@ uint8_t quit_test(memcached_st *memc) rc= memcached_set(memc, key, strlen(key), value, strlen(value), (time_t)10, (uint32_t)3); - assert(rc == MEMCACHED_SUCCESS); + assert(rc == MEMCACHED_SUCCESS || rc == MEMCACHED_BUFFERED); memcached_quit(memc); rc= memcached_set(memc, key, strlen(key), value, strlen(value), (time_t)50, (uint32_t)9); - assert(rc == MEMCACHED_SUCCESS); + assert(rc == MEMCACHED_SUCCESS || rc == MEMCACHED_BUFFERED); return 0; } @@ -705,7 +720,7 @@ uint8_t mget_result_test(memcached_st *memc) rc= memcached_set(memc, keys[x], key_length[x], keys[x], key_length[x], (time_t)50, (uint32_t)9); - assert(rc == MEMCACHED_SUCCESS); + assert(rc == MEMCACHED_SUCCESS || rc == MEMCACHED_BUFFERED); } rc= memcached_mget(memc, keys, key_length, 3); @@ -755,7 +770,7 @@ uint8_t mget_result_alloc_test(memcached_st *memc) rc= memcached_set(memc, keys[x], key_length[x], keys[x], key_length[x], (time_t)50, (uint32_t)9); - assert(rc == MEMCACHED_SUCCESS); + assert(rc == MEMCACHED_SUCCESS || rc == MEMCACHED_BUFFERED); } rc= memcached_mget(memc, keys, key_length, 3); @@ -777,6 +792,47 @@ uint8_t mget_result_alloc_test(memcached_st *memc) return 0; } +/* Count the results */ +unsigned int callback_counter(memcached_st *ptr, memcached_result_st *result, void *context) +{ + unsigned int *counter= (unsigned int *)context; + + *counter= *counter + 1; + + return 0; +} + +uint8_t mget_result_function(memcached_st *memc) +{ + memcached_return rc; + char *keys[]= {"fudge", "son", "food"}; + size_t key_length[]= {5, 3, 4}; + unsigned int x; + unsigned int counter; + unsigned int (*callbacks[1])(memcached_st *, memcached_result_st *, void *); + + /* We need to empty the server before continueing test */ + rc= memcached_flush(memc, 0); + for (x= 0; x < 3; x++) + { + rc= memcached_set(memc, keys[x], key_length[x], + keys[x], key_length[x], + (time_t)50, (uint32_t)9); + assert(rc == MEMCACHED_SUCCESS || rc == MEMCACHED_BUFFERED); + } + + rc= memcached_mget(memc, keys, key_length, 3); + assert(rc == MEMCACHED_SUCCESS); + + callbacks[0]= &callback_counter; + counter= 0; + rc= memcached_fetch_execute(memc, callbacks, (void *)&counter, 1); + + assert(counter == 3); + + return 0; +} + uint8_t mget_test(memcached_st *memc) { memcached_return rc; @@ -811,7 +867,7 @@ uint8_t mget_test(memcached_st *memc) rc= memcached_set(memc, keys[x], key_length[x], keys[x], key_length[x], (time_t)50, (uint32_t)9); - assert(rc == MEMCACHED_SUCCESS); + assert(rc == MEMCACHED_SUCCESS || rc == MEMCACHED_BUFFERED); } rc= memcached_mget(memc, keys, key_length, 3); @@ -842,7 +898,7 @@ uint8_t get_stats_keys(memcached_st *memc) list= memcached_stat_get_keys(memc, &stat, &rc); assert(rc == MEMCACHED_SUCCESS); for (ptr= list; *ptr; ptr++) - printf("Found key %s\n", *ptr); + assert(*ptr); fflush(stdout); free(list); @@ -850,6 +906,17 @@ uint8_t get_stats_keys(memcached_st *memc) return 0; } +uint8_t version_string_test(memcached_st *memc) +{ + const char *version_string; + + version_string= memcached_lib_version(); + + assert(!strcmp(version_string, LIBMEMCACHED_VERSION_STRING)); + + return 0; +} + uint8_t get_stats(memcached_st *memc) { unsigned int x; @@ -910,6 +977,55 @@ uint8_t add_host_test(memcached_st *memc) return 0; } +memcached_return clone_test_callback(memcached_st *parent, memcached_st *clone) +{ + return MEMCACHED_SUCCESS; +} + +memcached_return cleanup_test_callback(memcached_st *ptr) +{ + return MEMCACHED_SUCCESS; +} + +uint8_t callback_test(memcached_st *memc) +{ + /* Test User Data */ + { + int x= 5; + int *test_ptr; + memcached_return rc; + + rc= memcached_callback_set(memc, MEMCACHED_CALLBACK_USER_DATA, &x); + assert(rc == MEMCACHED_SUCCESS); + test_ptr= (int *)memcached_callback_get(memc, MEMCACHED_CALLBACK_USER_DATA, &rc); + assert(*test_ptr == x); + } + + /* Test Clone Callback */ + { + memcached_clone_func temp_function; + memcached_return rc; + + rc= memcached_callback_set(memc, MEMCACHED_CALLBACK_CLONE_FUNCTION, clone_test_callback); + assert(rc == MEMCACHED_SUCCESS); + temp_function= (memcached_clone_func)memcached_callback_get(memc, MEMCACHED_CALLBACK_CLONE_FUNCTION, &rc); + assert(temp_function == clone_test_callback); + } + + /* Test Cleanup Callback */ + { + memcached_cleanup_func temp_function; + memcached_return rc; + + rc= memcached_callback_set(memc, MEMCACHED_CALLBACK_CLONE_FUNCTION, cleanup_test_callback); + assert(rc == MEMCACHED_SUCCESS); + temp_function= (memcached_cleanup_func)memcached_callback_get(memc, MEMCACHED_CALLBACK_CLONE_FUNCTION, &rc); + assert(temp_function == cleanup_test_callback); + } + + return 0; +} + /* We don't test the behavior itself, we test the switches */ uint8_t behavior_test(memcached_st *memc) { @@ -996,10 +1112,10 @@ uint8_t user_supplied_bug1(memcached_st *memc) rc = memcached_set(memc, key, strlen(key), randomstuff, strlen(randomstuff), 10, 0); /* If we fail, lets try again */ - if (rc != MEMCACHED_SUCCESS) + if (rc != MEMCACHED_SUCCESS && rc != MEMCACHED_BUFFERED) rc = memcached_set(memc, key, strlen(key), randomstuff, strlen(randomstuff), 10, 0); - assert(rc == MEMCACHED_SUCCESS); + assert(rc == MEMCACHED_SUCCESS || rc == MEMCACHED_BUFFERED); } return 0; @@ -1045,7 +1161,10 @@ uint8_t user_supplied_bug2(memcached_st *memc) if (rc == MEMCACHED_NOTFOUND) errors++; else + { + WATCHPOINT_ERROR(rc); assert(0); + } continue; } @@ -1440,7 +1559,7 @@ uint8_t user_supplied_bug10(memcached_st *memc) memcached_behavior_set(mclone, MEMCACHED_BEHAVIOR_NO_BLOCK, &set); memcached_behavior_set(mclone, MEMCACHED_BEHAVIOR_TCP_NODELAY, &set); timeout= 2; - memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_POLL_TIMEOUT, &timeout); + memcached_behavior_set(mclone, MEMCACHED_BEHAVIOR_POLL_TIMEOUT, &timeout); value = (char*)malloc(value_length * sizeof(char)); @@ -1451,7 +1570,7 @@ uint8_t user_supplied_bug10(memcached_st *memc) { rc= memcached_set(mclone, key, key_len,value, value_length, 0, 0); - assert(rc == MEMCACHED_SUCCESS || rc == MEMCACHED_WRITE_FAILURE); + assert(rc == MEMCACHED_SUCCESS || rc == MEMCACHED_WRITE_FAILURE || rc == MEMCACHED_BUFFERED); if (rc == MEMCACHED_WRITE_FAILURE) x--; @@ -1481,9 +1600,9 @@ uint8_t user_supplied_bug11(memcached_st *memc) memcached_behavior_set(mclone, MEMCACHED_BEHAVIOR_NO_BLOCK, &set); memcached_behavior_set(mclone, MEMCACHED_BEHAVIOR_TCP_NODELAY, &set); timeout= -1; - memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_POLL_TIMEOUT, &timeout); + memcached_behavior_set(mclone, MEMCACHED_BEHAVIOR_POLL_TIMEOUT, &timeout); - timeout= (int32_t)memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_POLL_TIMEOUT); + timeout= (int32_t)memcached_behavior_get(mclone, MEMCACHED_BEHAVIOR_POLL_TIMEOUT); assert(timeout == -1); @@ -1495,9 +1614,6 @@ uint8_t user_supplied_bug11(memcached_st *memc) for (x= 1; x <= 100000; ++x) { rc= memcached_set(mclone, key, key_len,value, value_length, 0, 0); - - WATCHPOINT_IFERROR(rc); - //assert(rc == MEMCACHED_SUCCESS); } free(value); @@ -1506,6 +1622,129 @@ uint8_t user_supplied_bug11(memcached_st *memc) return 0; } +/* + Bug found where incr was not returning MEMCACHED_NOTFOUND when object did not exist. +*/ +uint8_t user_supplied_bug12(memcached_st *memc) +{ + memcached_return rc; + uint32_t flags; + size_t value_length; + char *value; + uint64_t number_value; + + value= memcached_get(memc, "autoincrement", strlen("autoincrement"), + &value_length, &flags, &rc); + assert(value == NULL); + assert(rc == MEMCACHED_NOTFOUND); + + rc= memcached_increment(memc, "autoincrement", strlen("autoincrement"), + 1, &number_value); + + assert(value == NULL); + assert(rc == MEMCACHED_NOTFOUND); + + rc= memcached_set(memc, "autoincrement", strlen("autoincrement"), "1", 1, 0, 0); + + value= memcached_get(memc, "autoincrement", strlen("autoincrement"), + &value_length, &flags, &rc); + assert(value); + assert(rc == MEMCACHED_SUCCESS); + free(value); + + rc= memcached_increment(memc, "autoincrement", strlen("autoincrement"), + 1, &number_value); + assert(number_value == 2); + assert(rc == MEMCACHED_SUCCESS); + + return 0; +} + +/* + Bug found where command total one more than MEMCACHED_MAX_BUFFER + set key34567890 0 0 8169 \r\n is sent followed by buffer of size 8169, followed by 8169 + */ +uint8_t user_supplied_bug13(memcached_st *memc) +{ + char key[] = "key34567890"; + char *overflow; + memcached_return rc; + size_t overflowSize; + + char commandFirst[]= "set key34567890 0 0 "; + char commandLast[] = " \r\n"; /* first line of command sent to server */ + size_t commandLength; + size_t testSize; + + commandLength = strlen(commandFirst) + strlen(commandLast) + 4; /* 4 is number of characters in size, probably 8196 */ + + overflowSize = MEMCACHED_MAX_BUFFER - commandLength; + + for (testSize= overflowSize - 1; testSize < overflowSize + 1; testSize++) + { + overflow= malloc(testSize); + assert(overflow != NULL); + + memset(overflow, 'x', testSize); + rc= memcached_set(memc, key, strlen(key), + overflow, testSize, 0, 0); + assert(rc == MEMCACHED_SUCCESS); + free(overflow); + } + + return 0; +} + + +/* + Test values of many different sizes + Bug found where command total one more than MEMCACHED_MAX_BUFFER + set key34567890 0 0 8169 \r\n + is sent followed by buffer of size 8169, followed by 8169 + */ +uint8_t user_supplied_bug14(memcached_st *memc) +{ + int setter= 1; + memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_TCP_NODELAY, &setter); + memcached_return rc; + char *key= "foo"; + char *value; + size_t value_length= 18000; + char *string; + size_t string_length; + uint32_t flags; + unsigned int x; + size_t current_length; + + value = (char*)malloc(value_length); + assert(value); + + for (x= 0; x < value_length; x++) + value[x] = (char) (x % 127); + + for (current_length= 1; current_length < value_length; current_length++) + { + rc= memcached_set(memc, key, strlen(key), + value, current_length, + (time_t)0, (uint32_t)0); + assert(rc == MEMCACHED_SUCCESS || rc == MEMCACHED_BUFFERED); + + string= memcached_get(memc, key, strlen(key), + &string_length, &flags, &rc); + + assert(rc == MEMCACHED_SUCCESS); + assert(string); + assert(string_length == current_length); + assert(!memcmp(string, value, string_length)); + + free(string); + } + + free(value); + + return 0; +} + uint8_t result_static(memcached_st *memc) { memcached_result_st result; @@ -1630,13 +1869,13 @@ uint8_t cleanup_pairs(memcached_st *memc) return 0; } -uint8_t generate_data(memcached_st *memc) +uint8_t generate_pairs(memcached_st *memc) { unsigned long long x; - global_pairs= pairs_generate(GLOBAL_COUNT); - execute_set(memc, global_pairs, GLOBAL_COUNT); + global_pairs= pairs_generate(GLOBAL_COUNT, 400); + global_count= GLOBAL_COUNT; - for (x= 0; x < GLOBAL_COUNT; x++) + for (x= 0; x < global_count; x++) { global_keys[x]= global_pairs[x].key; global_keys_length[x]= global_pairs[x].key_length; @@ -1645,14 +1884,13 @@ uint8_t generate_data(memcached_st *memc) return 0; } -uint8_t mset_data(memcached_st *memc) +uint8_t generate_large_pairs(memcached_st *memc) { unsigned long long x; - global_pairs= pairs_generate(GLOBAL_COUNT); + global_pairs= pairs_generate(GLOBAL2_COUNT, MEMCACHED_MAX_BUFFER+10); + global_count= GLOBAL2_COUNT; - (void)memcached_delete(memc, global_keys[x], global_keys_length[x], (time_t)0); - - for (x= 0; x < GLOBAL_COUNT; x++) + for (x= 0; x < global_count; x++) { global_keys[x]= global_pairs[x].key; global_keys_length[x]= global_pairs[x].key_length; @@ -1661,6 +1899,24 @@ uint8_t mset_data(memcached_st *memc) return 0; } +uint8_t generate_data(memcached_st *memc) +{ + execute_set(memc, global_pairs, global_count); + + return 0; +} + +uint8_t generate_buffer_data(memcached_st *memc) +{ + int latch= 0; + + latch= 1; + memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_BUFFER_REQUESTS, &latch); + generate_data(memc); + + return 0; +} + uint8_t get_read(memcached_st *memc) { unsigned int x; @@ -1671,7 +1927,7 @@ uint8_t get_read(memcached_st *memc) size_t return_value_length; uint32_t flags; - for (x= 0; x < GLOBAL_COUNT; x++) + for (x= 0; x < global_count; x++) { return_value= memcached_get(memc, global_keys[x], global_keys_length[x], &return_value_length, &flags, &rc); @@ -1691,7 +1947,7 @@ uint8_t mget_read(memcached_st *memc) { memcached_return rc; - rc= memcached_mget(memc, global_keys, global_keys_length, GLOBAL_COUNT); + rc= memcached_mget(memc, global_keys, global_keys_length, global_count); assert(rc == MEMCACHED_SUCCESS); /* Turn this into a help function */ { @@ -1717,7 +1973,7 @@ uint8_t mget_read_result(memcached_st *memc) { memcached_return rc; - rc= memcached_mget(memc, global_keys, global_keys_length, GLOBAL_COUNT); + rc= memcached_mget(memc, global_keys, global_keys_length, global_count); assert(rc == MEMCACHED_SUCCESS); /* Turn this into a help function */ { @@ -1738,11 +1994,27 @@ uint8_t mget_read_result(memcached_st *memc) return 0; } +uint8_t mget_read_function(memcached_st *memc) +{ + memcached_return rc; + unsigned int counter; + unsigned int (*callbacks[1])(memcached_st *, memcached_result_st *, void *); + + rc= memcached_mget(memc, global_keys, global_keys_length, global_count); + assert(rc == MEMCACHED_SUCCESS); + + callbacks[0]= &callback_counter; + counter= 0; + rc= memcached_fetch_execute(memc, callbacks, (void *)&counter, 1); + + return 0; +} + uint8_t delete_generate(memcached_st *memc) { unsigned int x; - for (x= 0; x < GLOBAL_COUNT; x++) + for (x= 0; x < global_count; x++) { (void)memcached_delete(memc, global_keys[x], global_keys_length[x], (time_t)0); } @@ -1750,16 +2022,22 @@ uint8_t delete_generate(memcached_st *memc) return 0; } -uint8_t mdelete_generate(memcached_st *memc) +uint8_t delete_buffer_generate(memcached_st *memc) { - memcached_return rc; + int latch= 0; + unsigned int x; - rc= memcached_mdelete(memc, global_keys, global_keys_length, GLOBAL_COUNT, 0); + latch= 1; + memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_BUFFER_REQUESTS, &latch); + + for (x= 0; x < global_count; x++) + { + (void)memcached_delete(memc, global_keys[x], global_keys_length[x], (time_t)0); + } return 0; } - uint8_t free_data(memcached_st *memc) { pairs_free(global_pairs); @@ -1870,6 +2148,59 @@ memcached_return pre_hash_ketama(memcached_st *memc) return MEMCACHED_SUCCESS; } +void my_free(memcached_st *ptr, void *mem) +{ + free(mem); +} + +void *my_malloc(memcached_st *ptr, const size_t size) +{ + return malloc(size); +} + +void *my_realloc(memcached_st *ptr, void *mem, const size_t size) +{ + return realloc(mem, size); +} + +memcached_return set_memory_alloc(memcached_st *memc) +{ + { + memcached_malloc_function test_ptr; + memcached_return rc; + + rc= memcached_callback_set(memc, MEMCACHED_CALLBACK_MALLOC_FUNCTION, &my_malloc); + assert(rc == MEMCACHED_SUCCESS); + test_ptr= (memcached_malloc_function)memcached_callback_get(memc, MEMCACHED_CALLBACK_MALLOC_FUNCTION, &rc); + assert(rc == MEMCACHED_SUCCESS); + assert(test_ptr == my_malloc); + } + + { + memcached_realloc_function test_ptr; + memcached_return rc; + + rc= memcached_callback_set(memc, MEMCACHED_CALLBACK_REALLOC_FUNCTION, &my_realloc); + assert(rc == MEMCACHED_SUCCESS); + test_ptr= (memcached_realloc_function)memcached_callback_get(memc, MEMCACHED_CALLBACK_REALLOC_FUNCTION, &rc); + assert(rc == MEMCACHED_SUCCESS); + assert(test_ptr == my_realloc); + } + + { + memcached_free_function test_ptr; + memcached_return rc; + + rc= memcached_callback_set(memc, MEMCACHED_CALLBACK_FREE_FUNCTION, my_free); + assert(rc == MEMCACHED_SUCCESS); + test_ptr= (memcached_free_function)memcached_callback_get(memc, MEMCACHED_CALLBACK_FREE_FUNCTION, &rc); + assert(rc == MEMCACHED_SUCCESS); + assert(test_ptr == my_free); + } + + return MEMCACHED_SUCCESS; +} + memcached_return enable_consistent(memcached_st *memc) { memcached_server_distribution value= MEMCACHED_DISTRIBUTION_CONSISTENT; @@ -1986,7 +2317,7 @@ test_st tests[] ={ {"set2", 0, set_test2 }, {"set3", 0, set_test3 }, {"add", 1, add_test }, - {"replace", 0, replace_test }, + {"replace", 1, replace_test }, {"delete", 1, delete_test }, {"get", 1, get_test }, {"get2", 0, get_test2 }, @@ -1999,10 +2330,13 @@ test_st tests[] ={ {"mget", 1, mget_test }, {"mget_result", 1, mget_result_test }, {"mget_result_alloc", 1, mget_result_alloc_test }, + {"mget_result_function", 1, mget_result_function }, {"get_stats", 0, get_stats }, {"add_host_test", 0, add_host_test }, {"get_stats_keys", 0, get_stats_keys }, {"behavior_test", 0, get_stats_keys }, + {"callback_test", 0, get_stats_keys }, + {"version_string_test", 0, version_string_test}, {0, 0, 0} }; @@ -2048,18 +2382,28 @@ test_st user_tests[] ={ {"user_supplied_bug9", 1, user_supplied_bug9 }, {"user_supplied_bug10", 1, user_supplied_bug10 }, {"user_supplied_bug11", 1, user_supplied_bug11 }, + {"user_supplied_bug12", 1, user_supplied_bug12 }, + {"user_supplied_bug13", 1, user_supplied_bug13 }, + {"user_supplied_bug14", 1, user_supplied_bug14 }, {0, 0, 0} }; test_st generate_tests[] ={ - {"generate_data", 0, generate_data }, + {"generate_pairs", 1, generate_pairs }, + {"generate_data", 1, generate_data }, {"get_read", 0, get_read }, {"delete_generate", 0, delete_generate }, - {"generate_data", 0, generate_data }, + {"generate_buffer_data", 1, generate_buffer_data }, + {"delete_buffer", 0, delete_buffer_generate}, + {"generate_data", 1, generate_data }, {"mget_read", 0, mget_read }, {"mget_read_result", 0, mget_read_result }, - {"mdelete_generate", 0, mdelete_generate }, - {"cleanup", 0, cleanup_pairs }, + {"mget_read_function", 0, mget_read_function }, + {"cleanup", 1, cleanup_pairs }, + {"generate_large_pairs", 1, generate_large_pairs }, + {"generate_data", 1, generate_data }, + {"generate_buffer_data", 1, generate_buffer_data }, + {"cleanup", 1, cleanup_pairs }, {0, 0, 0} }; @@ -2081,6 +2425,7 @@ collection_st collection[] ={ {"poll_timeout", poll_timeout, 0, tests}, {"gets", enable_cas, 0, tests}, {"consistent", enable_consistent, 0, tests}, + {"memory_allocators", set_memory_alloc, 0, tests}, // {"udp", pre_udp, 0, tests}, {"version_1_2_3", check_for_1_2_3, 0, version_1_2_3}, {"string", 0, 0, string_tests},