X-Git-Url: https://git.m6w6.name/?a=blobdiff_plain;f=tests%2Ffunction.c;h=514fe3c2fb8673f3977fc49053a353801e48b605;hb=fcd2bce48451825f32f05add83ced0923794d19a;hp=ae2ec0324852523bf60ab3163fbc5315e48bc062;hpb=0f665e1d72ff2466dae6de01331b2cfb5a4d3caa;p=m6w6%2Flibmemcached diff --git a/tests/function.c b/tests/function.c index ae2ec032..514fe3c2 100644 --- a/tests/function.c +++ b/tests/function.c @@ -40,6 +40,23 @@ uint8_t init_test(memcached_st *not_used) return 0; } +uint8_t server_list_null_test(memcached_st *ptr) +{ + memcached_server_st *server_list; + memcached_return rc; + + server_list= memcached_server_list_append(NULL, NULL, 0, NULL); + assert(server_list == NULL); + + server_list= memcached_server_list_append(NULL, "localhost", 0, NULL); + assert(server_list == NULL); + + server_list= memcached_server_list_append(NULL, NULL, 0, &rc); + assert(server_list == NULL); + + return 0; +} + uint8_t allocation_test(memcached_st *not_used) { memcached_st *memc; @@ -120,7 +137,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; } @@ -339,7 +356,7 @@ uint8_t add_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); memcached_quit(memc); rc= memcached_add(memc, key, strlen(key), value, strlen(value), @@ -382,10 +399,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; } @@ -409,7 +426,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); @@ -433,7 +450,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); @@ -461,7 +478,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; @@ -486,7 +503,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); @@ -514,7 +531,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); @@ -550,7 +567,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++) { @@ -591,7 +608,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); @@ -616,7 +633,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); @@ -640,13 +657,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; } @@ -686,7 +703,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); @@ -736,7 +753,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); @@ -758,6 +775,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; @@ -792,7 +850,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); @@ -823,7 +881,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); @@ -831,6 +889,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; @@ -891,6 +960,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) { @@ -977,10 +1095,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; @@ -1421,7 +1539,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)); @@ -1432,7 +1550,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--; @@ -1462,9 +1580,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); @@ -1476,9 +1594,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); @@ -1487,6 +1602,44 @@ 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; +} + uint8_t result_static(memcached_st *memc) { memcached_result_st result; @@ -1626,6 +1779,35 @@ uint8_t generate_data(memcached_st *memc) 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; +} + +#ifdef NOT_DONE +uint8_t mset_data(memcached_st *memc) +{ + unsigned long long x; + global_pairs= pairs_generate(GLOBAL_COUNT); + + (void)memcached_delete(memc, global_keys[x], global_keys_length[x], (time_t)0); + + for (x= 0; x < GLOBAL_COUNT; x++) + { + global_keys[x]= global_pairs[x].key; + global_keys_length[x]= global_pairs[x].key_length; + } + + return 0; +} +#endif + uint8_t get_read(memcached_st *memc) { unsigned int x; @@ -1703,6 +1885,22 @@ 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; @@ -1715,16 +1913,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); @@ -1835,6 +2039,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; @@ -1944,6 +2201,7 @@ test_st tests[] ={ {"flush", 0, flush_test }, {"init", 0, init_test }, {"allocation", 0, allocation_test }, + {"server_list_null_test", 0, server_list_null_test}, {"clone_test", 0, clone_test }, {"error", 0, error_test }, {"set", 0, set_test }, @@ -1963,10 +2221,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} }; @@ -2012,17 +2273,21 @@ 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 }, {0, 0, 0} }; test_st generate_tests[] ={ - {"generate_data", 0, generate_data }, + {"generate_data", 1, generate_data }, {"get_read", 0, get_read }, + {"delete_generate", 0, delete_generate }, + {"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 }, - {"delete_generate", 0, delete_generate }, - {"cleanup", 0, cleanup_pairs }, + {"mget_read_function", 0, mget_read_function }, + {"cleanup", 1, cleanup_pairs }, {0, 0, 0} }; @@ -2044,6 +2309,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},