X-Git-Url: https://git.m6w6.name/?a=blobdiff_plain;f=tests%2Ftest.c;h=a625206981a400ac0fb29514b9245252ec121c21;hb=1bd637f6eccc1064a4e19e40b14a340818d1ccf3;hp=047ed29a95d31d7528dc88a77c54835ca1adee02;hpb=7ef83f5c1f71a8527a5f3001d72772ac692bcf14;p=m6w6%2Flibmemcached diff --git a/tests/test.c b/tests/test.c index 047ed29a..a6252069 100644 --- a/tests/test.c +++ b/tests/test.c @@ -6,6 +6,20 @@ #include #include #include +#include +#include +#include "../lib/common.h" + +long int timedif(struct timeval a, struct timeval b) +{ + register int us, s; + + us = a.tv_usec - b.tv_usec; + us /= 1000; + s = a.tv_sec - b.tv_sec; + s *= 1000; + return s + us; +} void init_test(memcached_st *not_used) { @@ -108,6 +122,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); @@ -208,8 +225,6 @@ void get_test3(memcached_st *memc) string= memcached_get(memc, key, strlen(key), &string_length, &flags, &rc); - WATCHPOINT_ERRNO(memc->my_errno); - WATCHPOINT_ERROR(rc); assert(rc == MEMCACHED_SUCCESS); assert(string); assert(string_length == value_length); @@ -486,6 +501,12 @@ void behavior_test(memcached_st *memc) memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_MD5_HASHING, &set); value= memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_MD5_HASHING); assert(value == 0); + + value= memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_SOCKET_SEND_SIZE); + assert(value > 0); + + value= memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_SOCKET_RECV_SIZE); + assert(value > 0); } /* Test case provided by Cal Haldenbrand */ @@ -494,14 +515,16 @@ void user_supplied_bug1(memcached_st *memc) unsigned int setter= 1; unsigned int x; - long total= 0; + unsigned long long total= 0; int size= 0; - srand(time(NULL)); char key[10]; - char *randomstuff = (char *)malloc(6 * 1024); + char randomstuff[6 * 1024]; + memcached_return rc; + memset(randomstuff, 0, 6 * 1024); - memcached_return rc; + /* We just keep looking at the same values over and over */ + srandom(10); memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_NO_BLOCK, &setter); memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_TCP_NODELAY, &setter); @@ -530,6 +553,184 @@ void user_supplied_bug1(memcached_st *memc) assert(rc == MEMCACHED_SUCCESS); } } + +/* Test case provided by Cal Haldenbrand */ +void user_supplied_bug2(memcached_st *memc) +{ + int errors; + unsigned int setter; + unsigned int x; + unsigned long long total; + + 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 + + for (x= 0, errors= 0, total= 0 ; total < 20 * 1024576 ; x++) + { + memcached_return rc= MEMCACHED_SUCCESS; + char buffer[SMALL_STRING_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) + { + if (rc == MEMCACHED_NOTFOUND) + errors++; + else + assert(0); + + continue; + } + total+= val_len; + errors= 0; + free(getval); + } +} + +/* 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; @@ -560,23 +761,52 @@ 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_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 *collection_to_run= NULL; char *wildcard= NULL; memcached_server_st *servers; - if (argc == 2) - wildcard= argv[1]; + + if (argc > 1) + collection_to_run= argv[1]; + + if (argc == 3) + wildcard= argv[2]; if (!(server_list= getenv("MEMCACHED_SERVERS"))) server_list= "localhost"; @@ -609,7 +839,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 }, @@ -625,131 +855,93 @@ 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_bug2 }, + {"user_supplied_bug3", 0, user_supplied_bug3 }, {0, 0, 0} }; - 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; - memc= memcached_create(NULL); - assert(memc); - - 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); - tests[x].function(memc); - fprintf(stderr, "\t\t\t\t\t[ ok ]\n"); - 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}, + {"string", 0, 0, string_tests}, + {"user", 0, 0, user_tests}, + {0, 0, 0, 0} + }; - fprintf(stderr, "\nNonblock tests\n\n"); - for (x= 0; tests[x].function_name; x++) + /* + unsigned int next; + for (next= 0; collection[next].name; next++) +*/ + collection_st *next; + for (next= collection; next->name; next++) { - if (wildcard) - if (strcmp(wildcard, tests[x].function_name)) - continue; + test_st *run; - memcached_st *memc; - memcached_return rc; - memc= memcached_create(NULL); - assert(memc); + run= next->tests; - rc= memcached_server_push(memc, servers); - assert(rc == MEMCACHED_SUCCESS); + if (collection_to_run && strcmp(collection_to_run, next->name)) + continue; - fprintf(stderr, "Testing %s", tests[x].function_name); - memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_NO_BLOCK, NULL); - tests[x].function(memc); - fprintf(stderr, "\t\t\t\t\t[ ok ]\n"); - assert(memc); - memcached_free(memc); - } + fprintf(stderr, "\n%s\n\n", next->name); - fprintf(stderr, "\nTCP Nodelay tests\n\n"); - for (x= 0; tests[x].function_name; x++) - { - if (wildcard) - if (strcmp(wildcard, tests[x].function_name)) + for (x= 0; run->name; run++) + { + if (wildcard && strcmp(wildcard, run->name)) continue; - memcached_st *memc; - memcached_return rc; - memc= memcached_create(NULL); - assert(memc); - - rc= memcached_server_push(memc, servers); - assert(rc == MEMCACHED_SUCCESS); + fprintf(stderr, "Testing %s", run->name); - 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); - tests[x].function(memc); - fprintf(stderr, "\t\t\t\t\t[ ok ]\n"); - assert(memc); - memcached_free(memc); - } + memcached_st *memc; + memcached_return rc; + struct timeval start_time, end_time; - fprintf(stderr, "\nMD5 Hashing\n\n"); - for (x= 0; tests[x].function_name; x++) - { - if (wildcard) - if (strcmp(wildcard, tests[x].function_name)) - continue; + memc= memcached_create(NULL); + assert(memc); - memcached_st *memc; - memcached_return rc; - memc= memcached_create(NULL); - assert(memc); + if (run->requires_flush) + memcached_flush(memc, 0); - rc= memcached_server_push(memc, servers); - assert(rc == MEMCACHED_SUCCESS); + 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); - tests[x].function(memc); - fprintf(stderr, "\t\t\t\t\t[ ok ]\n"); - assert(memc); - memcached_free(memc); - } + 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, "\nUser Supplied tests\n\n"); - for (x= 0; user_tests[x].function_name; x++) - { - if (wildcard) - if (strcmp(wildcard, tests[x].function_name)) - continue; + if (next->pre) + next->pre(memc); - memcached_st *memc; - memcached_return rc; - memc= memcached_create(NULL); - assert(memc); + gettimeofday(&start_time, NULL); + 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); - rc= memcached_server_push(memc, servers); - assert(rc == MEMCACHED_SUCCESS); + if (next->post) + next->post(memc); - fprintf(stderr, "Testing %s", user_tests[x].function_name); - user_tests[x].function(memc); - fprintf(stderr, "\t\t\t\t\t[ ok ]\n"); - assert(memc); - memcached_free(memc); + assert(memc); + memcached_free(memc); + } } /* Clean up whatever we might have left */ @@ -763,5 +955,7 @@ int main(int argc, char *argv[]) fprintf(stderr, "All tests completed successfully\n\n"); + memcached_server_list_free(servers); + return 0; }