X-Git-Url: https://git.m6w6.name/?a=blobdiff_plain;f=tests%2Ftest.c;h=523f303401a5497d8943cb5ded9790afd02c2482;hb=c9f472b091b351b206d34b9fa37e28b6d1e4202c;hp=60c6211a09e86a1dc20936abb99852647f4bb6d2;hpb=a6fa1b62336cfddaf0d9efb7f431490a7c2f3ac9;p=awesomized%2Flibmemcached diff --git a/tests/test.c b/tests/test.c index 60c6211a..523f3034 100644 --- a/tests/test.c +++ b/tests/test.c @@ -7,6 +7,9 @@ #include #include #include +#include +#include +#include #include #include "../lib/common.h" @@ -37,6 +40,43 @@ void allocation_test(memcached_st *not_used) memcached_free(memc); } +void clone_test(memcached_st *memc) +{ + /* All null? */ + { + memcached_st *clone; + clone= memcached_clone(NULL, NULL); + assert(clone); + memcached_free(clone); + } + + /* Can we init from null? */ + { + memcached_st *clone; + clone= memcached_clone(NULL, memc); + assert(clone); + memcached_free(clone); + } + + /* Can we init from struct? */ + { + memcached_st declared_clone; + memcached_st *clone; + clone= memcached_clone(&declared_clone, NULL); + assert(clone); + memcached_free(clone); + } + + /* Can we init from struct? */ + { + memcached_st declared_clone; + memcached_st *clone; + clone= memcached_clone(&declared_clone, memc); + assert(clone); + memcached_free(clone); + } +} + void connection_test(memcached_st *memc) { memcached_return rc; @@ -437,7 +477,7 @@ void get_stats(memcached_st *memc) free(list); } - free(stat); + memcached_stat_free(NULL, stat); } void add_host_test(memcached_st *memc) @@ -484,9 +524,10 @@ void behavior_test(memcached_st *memc) value= memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_TCP_NODELAY); assert(value == 1); - memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_MD5_HASHING, &set); - value= memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_MD5_HASHING); - assert(value == 1); + set= MEMCACHED_HASH_MD5; + memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_HASH, &set); + value= memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_HASH); + assert(value == MEMCACHED_HASH_MD5); set= 0; @@ -498,9 +539,15 @@ void behavior_test(memcached_st *memc) value= memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_TCP_NODELAY); assert(value == 0); - memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_MD5_HASHING, &set); - value= memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_MD5_HASHING); - assert(value == 0); + set= MEMCACHED_HASH_DEFAULT; + memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_HASH, &set); + value= memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_HASH); + assert(value == MEMCACHED_HASH_DEFAULT); + + set= MEMCACHED_HASH_CRC; + memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_HASH, &set); + value= memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_HASH); + assert(value == MEMCACHED_HASH_CRC); value= memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_SOCKET_SEND_SIZE); assert(value > 0); @@ -572,9 +619,11 @@ void user_supplied_bug2(memcached_st *memc) memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_SOCKET_RECV_SIZE, &setter); getter = memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_SOCKET_SEND_SIZE); getter = memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_SOCKET_RECV_SIZE); -#endif for (x= 0, errors= 0, total= 0 ; total < 20 * 1024576 ; x++) +#endif + + for (x= 0, errors= 0, total= 0 ; total < 24576 ; x++) { memcached_return rc= MEMCACHED_SUCCESS; char buffer[SMALL_STRING_LEN]; @@ -641,7 +690,7 @@ void user_supplied_bug3(memcached_st *memc) /* Turn this into a help function */ { - char *return_key; + char return_key[MEMCACHED_MAX_KEY]; size_t return_key_length; char *return_value; size_t return_value_length; @@ -683,7 +732,7 @@ void string_alloc_with_size_toobig(memcached_st *memc) { memcached_string_st *string; - string= memcached_string_create(memc, 1024*100000000000); + string= memcached_string_create(memc, INT64_MAX); assert(string == NULL); } @@ -726,7 +775,7 @@ void string_alloc_append_toobig(memcached_st *memc) rc= memcached_string_append(memc, string, buffer, SMALL_STRING_LEN); assert(rc == MEMCACHED_SUCCESS); } - rc= memcached_string_append(memc, string, buffer, 1024*100000000000); + rc= memcached_string_append(memc, string, buffer, INT64_MAX); assert(rc == MEMCACHED_MEMORY_ALLOCATION_FAILURE); memcached_string_free(memc, string); } @@ -761,24 +810,121 @@ void add_host_test1(memcached_st *memc) memcached_server_list_free(servers); } +memcached_return pre_nonblock(memcached_st *memc) +{ + memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_NO_BLOCK, NULL); + + return MEMCACHED_SUCCESS; +} + +memcached_return pre_md5(memcached_st *memc) +{ + memcached_hash value= MEMCACHED_HASH_MD5; + memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_HASH, &value); + + return MEMCACHED_SUCCESS; +} + +memcached_return pre_crc(memcached_st *memc) +{ + memcached_hash value= MEMCACHED_HASH_CRC; + memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_HASH, &value); + + return MEMCACHED_SUCCESS; +} + +memcached_return pre_hash_fnv1_64(memcached_st *memc) +{ + memcached_hash value= MEMCACHED_HASH_FNV1_64; + memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_HASH, &value); + + return MEMCACHED_SUCCESS; +} + +memcached_return pre_hash_fnv1a_64(memcached_st *memc) +{ + memcached_hash value= MEMCACHED_HASH_FNV1A_64; + memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_HASH, &value); + + return MEMCACHED_SUCCESS; +} + +memcached_return pre_hash_fnv1_32(memcached_st *memc) +{ + memcached_hash value= MEMCACHED_HASH_FNV1_32; + memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_HASH, &value); + + return MEMCACHED_SUCCESS; +} + +memcached_return pre_hash_fnv1a_32(memcached_st *memc) +{ + memcached_hash value= MEMCACHED_HASH_FNV1A_32; + memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_HASH, &value); + + return MEMCACHED_SUCCESS; +} + +memcached_return pre_hash_ketama(memcached_st *memc) +{ + memcached_hash value= MEMCACHED_HASH_KETAMA; + memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_HASH, &value); + + return MEMCACHED_SUCCESS; +} + +memcached_return pre_unix_socket(memcached_st *memc) +{ + memcached_return rc; + struct stat buf; + + memcached_server_list_free(memc->hosts); + memc->hosts= NULL; + memc->number_of_hosts= 0; + + if (stat("/tmp/memcached.socket", &buf)) + return MEMCACHED_FAILURE; + + rc= memcached_server_add_unix_socket(memc, "/tmp/memcached.socket"); + + return rc; +} + +memcached_return pre_nodelay(memcached_st *memc) +{ + memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_NO_BLOCK, NULL); + memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_TCP_NODELAY, NULL); + + return MEMCACHED_SUCCESS; +} + +typedef struct collection_st collection_st; typedef struct test_st test_st; struct test_st { - char *function_name; + char *name; unsigned int requires_flush; void (*function)(memcached_st *memc); }; +struct collection_st { + char *name; + memcached_return (*pre)(memcached_st *memc); + memcached_return (*post)(memcached_st *memc); + test_st *tests; +}; + int main(int argc, char *argv[]) { unsigned int x; char *server_list; - char *test_to_run= NULL; + char *collection_to_run= NULL; char *wildcard= NULL; memcached_server_st *servers; + if (argc > 1) - test_to_run= argv[1]; + collection_to_run= argv[1]; if (argc == 3) wildcard= argv[2]; @@ -807,6 +953,7 @@ int main(int argc, char *argv[]) {"flush", 0, flush_test }, {"init", 0, init_test }, {"allocation", 0, allocation_test }, + {"clone_test", 0, clone_test }, {"error", 0, error_test }, {"set", 0, set_test }, {"set2", 0, set_test2 }, @@ -842,131 +989,47 @@ int main(int argc, char *argv[]) test_st user_tests[] ={ {"user_supplied_bug1", 0, user_supplied_bug1 }, {"user_supplied_bug2", 0, user_supplied_bug2 }, -// {"user_supplied_bug3", 0, user_supplied_bug3 }, + {"user_supplied_bug3", 0, user_supplied_bug3 }, {0, 0, 0} }; - if ((test_to_run && !strcmp(test_to_run, "block")) || !test_to_run) - { - fprintf(stderr, "\nBlock tests\n\n"); - for (x= 0; tests[x].function_name; x++) - { - if (wildcard) - if (strcmp(wildcard, tests[x].function_name)) - continue; - - memcached_st *memc; - memcached_return rc; - struct timeval start_time, end_time; - - memc= memcached_create(NULL); - assert(memc); - - if (tests[x].requires_flush) - memcached_flush(memc, 0); - rc= memcached_server_push(memc, servers); - assert(rc == MEMCACHED_SUCCESS); - - unsigned int loop; - for (loop= 0; loop < memcached_server_list_count(servers); loop++) - { - assert(memc->hosts[loop].stack_responses == 0); - assert(memc->hosts[loop].fd == -1); - assert(memc->hosts[loop].cursor_active == 0); - } - - fprintf(stderr, "Testing %s", tests[x].function_name); - gettimeofday(&start_time, NULL); - tests[x].function(memc); - gettimeofday(&end_time, NULL); - long int load_time= timedif(end_time, start_time); - fprintf(stderr, "\t\t\t\t\t %ld.%03ld [ ok ]\n", load_time / 1000, - load_time % 1000); - assert(memc); - memcached_free(memc); - } - } + collection_st collection[] ={ + {"block", 0, 0, tests}, + {"nonblock", pre_nonblock, 0, tests}, + {"nodelay", pre_nodelay, 0, tests}, + {"md5", pre_md5, 0, tests}, + {"crc", pre_crc, 0, tests}, + {"fnv1_64", pre_hash_fnv1_64, 0, tests}, + {"fnv1a_64", pre_hash_fnv1a_64, 0, tests}, + {"fnv1_32", pre_hash_fnv1_32, 0, tests}, + {"fnv1a_32", pre_hash_fnv1a_32, 0, tests}, + {"ketama", pre_hash_ketama, 0, tests}, + {"unix_socket", pre_unix_socket, 0, tests}, + {"unix_socket_nodelay", pre_nodelay, 0, tests}, + {"string", 0, 0, string_tests}, + {"user", 0, 0, user_tests}, + {0, 0, 0, 0} + }; - if ((test_to_run && !strcmp(test_to_run, "nonblock")) || !test_to_run) + collection_st *next; + for (next= collection; next->name; next++) { - fprintf(stderr, "\nNonblock tests\n\n"); - for (x= 0; tests[x].function_name; x++) - { - if (wildcard) - if (strcmp(wildcard, tests[x].function_name)) - continue; + test_st *run; - memcached_st *memc; - memcached_return rc; - struct timeval start_time, end_time; + run= next->tests; - memc= memcached_create(NULL); - assert(memc); - - if (tests[x].requires_flush) - memcached_flush(memc, 0); + if (collection_to_run && strcmp(collection_to_run, next->name)) + continue; - rc= memcached_server_push(memc, servers); - assert(rc == MEMCACHED_SUCCESS); + fprintf(stderr, "\n%s\n\n", next->name); - fprintf(stderr, "Testing %s", tests[x].function_name); - memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_NO_BLOCK, NULL); - gettimeofday(&start_time, NULL); - tests[x].function(memc); - gettimeofday(&end_time, NULL); - long int load_time= timedif(end_time, start_time); - fprintf(stderr, "\t\t\t\t\t %ld.%03ld [ ok ]\n", load_time / 1000, - load_time % 1000); - assert(memc); - memcached_free(memc); - } - } - - if ((test_to_run && !strcmp(test_to_run, "nodelay")) || !test_to_run) - { - fprintf(stderr, "\nTCP Nodelay tests\n\n"); - for (x= 0; tests[x].function_name; x++) + for (x= 0; run->name; run++) { - if (wildcard) - if (strcmp(wildcard, tests[x].function_name)) - continue; - - memcached_st *memc; - memcached_return rc; - struct timeval start_time, end_time; + if (wildcard && strcmp(wildcard, run->name)) + continue; - memc= memcached_create(NULL); - assert(memc); - - if (tests[x].requires_flush) - memcached_flush(memc, 0); - - rc= memcached_server_push(memc, servers); - assert(rc == MEMCACHED_SUCCESS); - - fprintf(stderr, "Testing %s", tests[x].function_name); - memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_NO_BLOCK, NULL); - memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_TCP_NODELAY, NULL); - gettimeofday(&start_time, NULL); - tests[x].function(memc); - gettimeofday(&end_time, NULL); - long int load_time= timedif(end_time, start_time); - fprintf(stderr, "\t\t\t\t\t %ld.%03ld [ ok ]\n", load_time / 1000, - load_time % 1000); - assert(memc); - memcached_free(memc); - } - } - - if ((test_to_run && !strcmp(test_to_run, "md5")) || !test_to_run) - { - fprintf(stderr, "\nMD5 Hashing\n\n"); - for (x= 0; tests[x].function_name; x++) - { - if (wildcard) - if (strcmp(wildcard, tests[x].function_name)) - continue; + fprintf(stderr, "Testing %s", run->name); memcached_st *memc; memcached_return rc; @@ -975,89 +1038,44 @@ int main(int argc, char *argv[]) memc= memcached_create(NULL); assert(memc); - if (tests[x].requires_flush) + if (run->requires_flush) memcached_flush(memc, 0); rc= memcached_server_push(memc, servers); assert(rc == MEMCACHED_SUCCESS); - fprintf(stderr, "Testing %s", tests[x].function_name); - memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_MD5_HASHING, NULL); - gettimeofday(&start_time, NULL); - tests[x].function(memc); - gettimeofday(&end_time, NULL); - long int load_time= timedif(end_time, start_time); - fprintf(stderr, "\t\t\t\t\t %ld.%03ld [ ok ]\n", load_time / 1000, - load_time % 1000); - assert(memc); - memcached_free(memc); - } - } - - if ((test_to_run && !strcmp(test_to_run, "string")) || !test_to_run) - { - fprintf(stderr, "\nString tests (internal API)\n\n"); - for (x= 0; string_tests[x].function_name; x++) - { - if (wildcard) - if (strcmp(wildcard, string_tests[x].function_name)) - continue; - - memcached_st *memc; - memcached_return rc; - struct timeval start_time, end_time; - - memc= memcached_create(NULL); - assert(memc); - - if (tests[x].requires_flush) - memcached_flush(memc, 0); + unsigned int loop; + for (loop= 0; loop < memcached_server_list_count(servers); loop++) + { + assert(memc->hosts[loop].stack_responses == 0); + assert(memc->hosts[loop].fd == -1); + assert(memc->hosts[loop].cursor_active == 0); + } - rc= memcached_server_push(memc, servers); - assert(rc == MEMCACHED_SUCCESS); + if (next->pre) + { + memcached_return rc; + rc= next->pre(memc); + + if (rc != MEMCACHED_SUCCESS) + { + fprintf(stderr, "\t\t\t\t\t [ skipping ]\n"); + goto error; + } + } - fprintf(stderr, "Testing %s", string_tests[x].function_name); gettimeofday(&start_time, NULL); - string_tests[x].function(memc); + run->function(memc); gettimeofday(&end_time, NULL); long int load_time= timedif(end_time, start_time); fprintf(stderr, "\t\t\t\t\t %ld.%03ld [ ok ]\n", load_time / 1000, load_time % 1000); - assert(memc); - memcached_free(memc); - } - } - if ((test_to_run && !strcmp(test_to_run, "user")) || !test_to_run) - { - fprintf(stderr, "\nUser Supplied tests\n\n"); - for (x= 0; user_tests[x].function_name; x++) - { - if (wildcard) - if (strcmp(wildcard, user_tests[x].function_name)) - continue; - - memcached_st *memc; - memcached_return rc; - struct timeval start_time, end_time; + if (next->post) + (void)next->post(memc); - memc= memcached_create(NULL); - assert(memc); - - if (tests[x].requires_flush) - memcached_flush(memc, 0); - - rc= memcached_server_push(memc, servers); - assert(rc == MEMCACHED_SUCCESS); - - fprintf(stderr, "Testing %s", user_tests[x].function_name); - gettimeofday(&start_time, NULL); - user_tests[x].function(memc); - gettimeofday(&end_time, NULL); - long int load_time= timedif(end_time, start_time); - fprintf(stderr, "\t\t\t\t\t %ld.%03ld [ ok ]\n", load_time / 1000, - load_time % 1000); assert(memc); +error: memcached_free(memc); } }