X-Git-Url: https://git.m6w6.name/?a=blobdiff_plain;f=tests%2Ftest.c;h=3945df8b077d41c177f151c69b5b5ce55e74dd2c;hb=ffe371b7498a26133a892591c7dc56d3e6212d10;hp=56f66d9479a3fcabe467f3d846f4a18921658dc7;hpb=02c35e9f14dddc82c86f246002b91bf8e25cbaa3;p=awesomized%2Flibmemcached diff --git a/tests/test.c b/tests/test.c index 56f66d94..3945df8b 100644 --- a/tests/test.c +++ b/tests/test.c @@ -8,6 +8,7 @@ #include #include #include +#include "../lib/common.h" long int timedif(struct timeval a, struct timeval b) { @@ -36,6 +37,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; @@ -121,6 +159,9 @@ void get_test(memcached_st *memc) size_t string_length; uint16_t flags; + rc= memcached_delete(memc, key, strlen(key), (time_t)0); + assert(rc == MEMCACHED_SUCCESS || rc == MEMCACHED_NOTFOUND); + string= memcached_get(memc, key, strlen(key), &string_length, &flags, &rc); @@ -568,28 +609,30 @@ 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_return rc= MEMCACHED_SUCCESS; char buffer[SMALL_STRING_LEN]; - uint16_t flags; - size_t val_len; + uint16_t flags= 0; + size_t val_len= 0; char *getval; + memset(buffer, 0, SMALL_STRING_LEN); + snprintf(buffer, SMALL_STRING_LEN, "%u", x); getval= memcached_get(memc, buffer, strlen(buffer), &val_len, &flags, &rc); if (rc != MEMCACHED_SUCCESS) { - WATCHPOINT_ERROR(rc); - errors++; - if ( errors == 10 ) - { - fprintf(stderr, "last: %s: len %zu flags: %u\n", buffer, val_len, flags); + if (rc == MEMCACHED_NOTFOUND) + errors++; + else assert(0); - } + continue; } total+= val_len; @@ -598,6 +641,135 @@ void user_supplied_bug2(memcached_st *memc) } } +/* Do a large mget() over all the keys we think exist */ +#define KEY_COUNT 3000 // * 1024576 +void user_supplied_bug3(memcached_st *memc) +{ + memcached_return rc; + unsigned int setter; + unsigned int x; + char **keys; + size_t key_lengths[KEY_COUNT]; + + setter= 1; + memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_NO_BLOCK, &setter); + memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_TCP_NODELAY, &setter); +#ifdef NOT_YET + setter = 20 * 1024576; + memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_SOCKET_SEND_SIZE, &setter); + setter = 20 * 1024576; + 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 + + keys= (char **)malloc(sizeof(char *) * KEY_COUNT); + assert(keys); + memset(keys, 0, (sizeof(char *) * KEY_COUNT)); + for (x= 0; x < KEY_COUNT; x++) + { + char buffer[30]; + + snprintf(buffer, 30, "%u", x); + keys[x]= strdup(buffer); + key_lengths[x]= strlen(keys[x]); + } + + rc= memcached_mget(memc, keys, key_lengths, KEY_COUNT); + assert(rc == MEMCACHED_SUCCESS); + + /* Turn this into a help function */ + { + char return_key[MEMCACHED_MAX_KEY]; + size_t return_key_length; + char *return_value; + size_t return_value_length; + uint16_t flags; + + while ((return_value= memcached_fetch(memc, return_key, &return_key_length, + &return_value_length, &flags, &rc))) + { + assert(return_value); + assert(rc == MEMCACHED_SUCCESS); + free(return_value); + } + } + + for (x= 0; x < KEY_COUNT; x++) + free(keys[x]); + free(keys); +} + +void string_alloc_null(memcached_st *memc) +{ + memcached_string_st *string; + + string= memcached_string_create(memc, 0); + assert(string); + memcached_string_free(memc, string); +} + +void string_alloc_with_size(memcached_st *memc) +{ + memcached_string_st *string; + + string= memcached_string_create(memc, 1024); + assert(string); + memcached_string_free(memc, string); +} + +void string_alloc_with_size_toobig(memcached_st *memc) +{ + memcached_string_st *string; + + string= memcached_string_create(memc, INT64_MAX); + assert(string == NULL); +} + +void string_alloc_append(memcached_st *memc) +{ + unsigned int x; + char buffer[SMALL_STRING_LEN]; + memcached_string_st *string; + + /* Ring the bell! */ + memset(buffer, 6, SMALL_STRING_LEN); + + string= memcached_string_create(memc, 100); + assert(string); + + for (x= 0; x < 1024; x++) + { + memcached_return rc; + rc= memcached_string_append(memc, string, buffer, SMALL_STRING_LEN); + assert(rc == MEMCACHED_SUCCESS); + } + memcached_string_free(memc, string); +} + +void string_alloc_append_toobig(memcached_st *memc) +{ + memcached_return rc; + unsigned int x; + char buffer[SMALL_STRING_LEN]; + memcached_string_st *string; + + /* Ring the bell! */ + memset(buffer, 6, SMALL_STRING_LEN); + + string= memcached_string_create(memc, 100); + assert(string); + + for (x= 0; x < 1024; x++) + { + rc= memcached_string_append(memc, string, buffer, SMALL_STRING_LEN); + assert(rc == MEMCACHED_SUCCESS); + } + rc= memcached_string_append(memc, string, buffer, INT64_MAX); + assert(rc == MEMCACHED_MEMORY_ALLOCATION_FAILURE); + memcached_string_free(memc, string); +} + void add_host_test1(memcached_st *memc) { unsigned int x; @@ -628,24 +800,54 @@ void add_host_test1(memcached_st *memc) memcached_server_list_free(servers); } +void pre_nonblock(memcached_st *memc) +{ + memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_NO_BLOCK, NULL); +} + +void pre_md5(memcached_st *memc) +{ + memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_MD5_HASHING, NULL); +} + +void pre_crc(memcached_st *memc) +{ + memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_CRC_HASHING, NULL); +} + +void pre_nodelay(memcached_st *memc) +{ + memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_NO_BLOCK, NULL); + memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_TCP_NODELAY, NULL); +} + +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; + void (*pre)(memcached_st *memc); + void (*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 > 2) - test_to_run= argv[1]; + + if (argc > 1) + collection_to_run= argv[1]; if (argc == 3) wildcard= argv[2]; @@ -674,6 +876,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 }, @@ -681,7 +884,7 @@ int main(int argc, char *argv[]) {"add", 0, add_test }, {"replace", 0, replace_test }, {"delete", 1, delete_test }, - {"get", 0, get_test }, + {"get", 1, get_test }, {"get2", 0, get_test2 }, {"get3", 0, get_test3 }, {"get4", 0, get_test4 }, @@ -697,20 +900,52 @@ int main(int argc, char *argv[]) {0, 0, 0} }; + test_st string_tests[] ={ + {"string alloc with null", 0, string_alloc_null }, + {"string alloc with 1K", 0, string_alloc_with_size }, + {"string alloc with malloc failure", 0, string_alloc_with_size_toobig }, + {"string append", 0, string_alloc_append }, + {"string append failure (too big)", 0, string_alloc_append_toobig }, + {0, 0, 0} + }; + test_st user_tests[] ={ {"user_supplied_bug1", 0, user_supplied_bug1 }, - {"user_supplied_bug2", 0, user_supplied_bug1 }, + {"user_supplied_bug2", 0, user_supplied_bug2 }, + {"user_supplied_bug3", 0, user_supplied_bug3 }, {0, 0, 0} }; - if ((test_to_run && !strcmp(test_to_run, "block")) || !test_to_run) + + 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}, + {"string", 0, 0, string_tests}, + {"user", 0, 0, user_tests}, + {0, 0, 0, 0} + }; + + collection_st *next; + for (next= collection; next->name; next++) { - fprintf(stderr, "\nBlock tests\n\n"); - for (x= 0; tests[x].function_name; x++) + test_st *run; + + run= next->tests; + + if (collection_to_run && strcmp(collection_to_run, next->name)) + continue; + + fprintf(stderr, "\n%s\n\n", next->name); + + for (x= 0; run->name; run++) { - if (wildcard) - if (strcmp(wildcard, tests[x].function_name)) - continue; + if (wildcard && strcmp(wildcard, run->name)) + continue; + + fprintf(stderr, "Testing %s", run->name); memcached_st *memc; memcached_return rc; @@ -719,6 +954,9 @@ int main(int argc, char *argv[]) memc= memcached_create(NULL); assert(memc); + if (run->requires_flush) + memcached_flush(memc, 0); + rc= memcached_server_push(memc, servers); assert(rc == MEMCACHED_SUCCESS); @@ -730,141 +968,19 @@ int main(int argc, char *argv[]) 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); - } - } - - if ((test_to_run && !strcmp(test_to_run, "nonblock")) || !test_to_run) - { - fprintf(stderr, "\nNonblock 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); - - 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); - 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++) - { - 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); - - rc= memcached_server_push(memc, servers); - assert(rc == MEMCACHED_SUCCESS); + if (next->pre) + next->pre(memc); - 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); + 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, "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; + if (next->post) + next->post(memc); - memcached_st *memc; - memcached_return rc; - struct timeval start_time, end_time; - - memc= memcached_create(NULL); - assert(memc); - - 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, "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, tests[x].function_name)) - continue; - - memcached_st *memc; - memcached_return rc; - struct timeval start_time, end_time; - - memc= memcached_create(NULL); - assert(memc); - - 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); memcached_free(memc); }