X-Git-Url: https://git.m6w6.name/?a=blobdiff_plain;f=tests%2Ftest.c;h=16afb65e5905acfc1d73c1948451b34a74fb20c0;hb=c11af7ccccd3260444da4f575022de655d2ffc26;hp=e12df9fc28724075ea7e8bc2e75501df4a2c09df;hpb=85a66fec1e07e874e5410ce56a2976d68fbe14fd;p=m6w6%2Flibmemcached diff --git a/tests/test.c b/tests/test.c index e12df9fc..16afb65e 100644 --- a/tests/test.c +++ b/tests/test.c @@ -6,6 +6,19 @@ #include #include #include +#include +#include + +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) { @@ -47,8 +60,6 @@ void set_test(memcached_st *memc) char *key= "foo"; char *value= "when we sanitize"; - rc= memcached_server_add(memc, "localhost", 0); - assert(rc == MEMCACHED_SUCCESS); rc= memcached_set(memc, key, strlen(key), value, strlen(value), (time_t)0, (uint16_t)0); @@ -61,8 +72,6 @@ void add_test(memcached_st *memc) char *key= "foo"; char *value= "when we sanitize"; - rc= memcached_server_add(memc, "localhost", 0); - assert(rc == MEMCACHED_SUCCESS); rc= memcached_add(memc, key, strlen(key), value, strlen(value), (time_t)0, (uint16_t)0); @@ -75,8 +84,6 @@ void replace_test(memcached_st *memc) char *key= "foo"; char *value= "when we sanitize"; - rc= memcached_server_add(memc, "localhost", 0); - assert(rc == MEMCACHED_SUCCESS); rc= memcached_replace(memc, key, strlen(key), value, strlen(value), (time_t)0, (uint16_t)0); @@ -89,8 +96,6 @@ void delete_test(memcached_st *memc) char *key= "foo"; char *value= "when we sanitize"; - rc= memcached_server_add(memc, "localhost", 0); - assert(rc == MEMCACHED_SUCCESS); rc= memcached_set(memc, key, strlen(key), value, strlen(value), (time_t)0, (uint16_t)0); @@ -104,8 +109,6 @@ void flush_test(memcached_st *memc) { memcached_return rc; - rc= memcached_server_add(memc, "localhost", 0); - assert(rc == MEMCACHED_SUCCESS); rc= memcached_flush(memc, 0); assert(rc == MEMCACHED_SUCCESS); } @@ -118,9 +121,6 @@ void get_test(memcached_st *memc) size_t string_length; uint16_t flags; - rc= memcached_server_add(memc, "localhost", 0); - assert(rc == MEMCACHED_SUCCESS); - string= memcached_get(memc, key, strlen(key), &string_length, &flags, &rc); @@ -138,9 +138,6 @@ void get_test2(memcached_st *memc) size_t string_length; uint16_t flags; - rc= memcached_server_add(memc, "localhost", 0); - assert(rc == MEMCACHED_SUCCESS); - rc= memcached_set(memc, key, strlen(key), value, strlen(value), (time_t)0, (uint16_t)0); @@ -165,9 +162,6 @@ void set_test2(memcached_st *memc) size_t value_length= strlen(value); unsigned int x; - rc= memcached_server_add(memc, "localhost", 0); - assert(rc == MEMCACHED_SUCCESS); - for (x= 0; x < 10; x++) { rc= memcached_set(memc, key, strlen(key), @@ -191,9 +185,6 @@ void set_test3(memcached_st *memc) for (x= 0; x < value_length; x++) value[x] = (char) (x % 127); - rc= memcached_server_add(memc, "localhost", 0); - assert(rc == MEMCACHED_SUCCESS); - for (x= 0; x < 1; x++) { rc= memcached_set(memc, key, strlen(key), @@ -222,9 +213,6 @@ void get_test3(memcached_st *memc) for (x= 0; x < value_length; x++) value[x] = (char) (x % 127); - rc= memcached_server_add(memc, "localhost", 0); - assert(rc == MEMCACHED_SUCCESS); - rc= memcached_set(memc, key, strlen(key), value, value_length, (time_t)0, (uint16_t)0); @@ -259,9 +247,6 @@ void get_test4(memcached_st *memc) for (x= 0; x < value_length; x++) value[x] = (char) (x % 127); - rc= memcached_server_add(memc, "localhost", 0); - assert(rc == MEMCACHED_SUCCESS); - rc= memcached_set(memc, key, strlen(key), value, value_length, (time_t)0, (uint16_t)0); @@ -298,9 +283,6 @@ void increment_test(memcached_st *memc) char *key= "number"; char *value= "0"; - rc= memcached_server_add(memc, "localhost", 0); - assert(rc == MEMCACHED_SUCCESS); - rc= memcached_set(memc, key, strlen(key), value, strlen(value), (time_t)0, (uint16_t)0); @@ -324,9 +306,6 @@ void decrement_test(memcached_st *memc) char *key= "number"; char *value= "3"; - rc= memcached_server_add(memc, "localhost", 0); - assert(rc == MEMCACHED_SUCCESS); - rc= memcached_set(memc, key, strlen(key), value, strlen(value), (time_t)0, (uint16_t)0); @@ -349,9 +328,6 @@ void quit_test(memcached_st *memc) char *key= "fudge"; char *value= "sanford and sun"; - rc= memcached_server_add(memc, "localhost", 0); - assert(rc == MEMCACHED_SUCCESS); - rc= memcached_set(memc, key, strlen(key), value, strlen(value), (time_t)10, (uint16_t)3); @@ -377,9 +353,6 @@ void mget_test(memcached_st *memc) char *return_value; size_t return_value_length; - rc= memcached_server_add(memc, "localhost", 0); - assert(rc == MEMCACHED_SUCCESS); - /* We need to empty the server before continueing test */ rc= memcached_flush(memc, 0); assert(rc == MEMCACHED_SUCCESS); @@ -413,8 +386,8 @@ void mget_test(memcached_st *memc) { assert(return_value); assert(rc == MEMCACHED_SUCCESS); - assert(key_length[x] == return_value_length); - assert(!memcmp(return_value, keys[x], return_value_length)); + assert(return_key_length == return_value_length); + assert(!memcmp(return_value, return_key, return_value_length)); free(return_value); x++; } @@ -431,6 +404,7 @@ void get_stats_keys(memcached_st *memc) assert(rc == MEMCACHED_SUCCESS); for (ptr= list; *ptr; ptr++) printf("Found key %s\n", *ptr); + fflush(stdout); free(list); } @@ -443,41 +417,6 @@ void get_stats(memcached_st *memc) memcached_return rc; memcached_stat_st *stat; - rc= memcached_server_add(memc, "localhost", 0); - assert(rc == MEMCACHED_SUCCESS); - - stat= memcached_stat(memc, NULL, &rc); - assert(rc == MEMCACHED_SUCCESS); - - assert(rc == MEMCACHED_SUCCESS); - assert(stat); - - for (x= 0; x < memcached_server_count(memc); x++) - { - list= memcached_stat_get_keys(memc, &stat[x], &rc); - assert(rc == MEMCACHED_SUCCESS); - for (ptr= list; *ptr; ptr++) - printf("Found key %s\n", *ptr); - - free(list); - } - - free(stat); -} - -void get_stats_multiple(memcached_st *memc) -{ - unsigned int x; - char **list; - char **ptr; - memcached_return rc; - memcached_stat_st *stat; - - rc= memcached_server_add(memc, "localhost", 0); - assert(rc == MEMCACHED_SUCCESS); - rc= memcached_server_add(memc, "localhost", 5555); - assert(rc == MEMCACHED_SUCCESS); - stat= memcached_stat(memc, NULL, &rc); assert(rc == MEMCACHED_SUCCESS); @@ -504,9 +443,6 @@ void add_host_test(memcached_st *memc) memcached_return rc; char servername[]= "0.example.com"; - rc= memcached_server_add(memc, "localhost", 0); - assert(rc == MEMCACHED_SUCCESS); - servers= memcached_server_list_append(NULL, servername, 400, &rc); assert(servers); assert(1 == memcached_server_list_count(servers)); @@ -530,6 +466,87 @@ void add_host_test(memcached_st *memc) memcached_server_list_free(servers); } +/* We don't test the behavior itself, we test the switches */ +void behavior_test(memcached_st *memc) +{ + unsigned long long value; + unsigned int set= 1; + + memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_NO_BLOCK, &set); + value= memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_NO_BLOCK); + assert(value == 1); + + memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_TCP_NODELAY, &set); + 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= 0; + + memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_NO_BLOCK, &set); + value= memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_NO_BLOCK); + assert(value == 0); + + memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_TCP_NODELAY, &set); + 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); + + 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 */ +void user_supplied_bug1(memcached_st *memc) +{ + unsigned int setter= 1; + unsigned int x; + + long total= 0; + int size= 0; + srand(time(NULL)); + char key[10]; + char *randomstuff = (char *)malloc(6 * 1024); + memset(randomstuff, 0, 6 * 1024); + + memcached_return rc; + + memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_NO_BLOCK, &setter); + memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_TCP_NODELAY, &setter); + + + /* add key */ + for (x= 0 ; total < 20 * 1024576 ; x++ ) + { + unsigned int j= 0; + + size= (rand() % ( 5 * 1024 ) ) + 400; + memset(randomstuff, 0, 6 * 1024); + assert(size < 6 * 1024); /* Being safe here */ + + for (j= 0 ; j < size ;j++) + randomstuff[j] = (char) (rand() % 26) + 97; + + total += size; + sprintf(key, "%d", x); + rc = memcached_set(memc, key, strlen(key), + randomstuff, strlen(randomstuff), 10, 0); + /* If we fail, lets try again */ + if (rc != MEMCACHED_SUCCESS) + rc = memcached_set(memc, key, strlen(key), + randomstuff, strlen(randomstuff), 10, 0); + assert(rc == MEMCACHED_SUCCESS); + } +} void add_host_test1(memcached_st *memc) { unsigned int x; @@ -571,6 +588,35 @@ struct test_st { int main(int argc, char *argv[]) { unsigned int x; + char *server_list; + char *test_to_run= NULL; + char *wildcard= NULL; + memcached_server_st *servers; + + if (argc > 2) + test_to_run= argv[1]; + + if (argc == 3) + wildcard= argv[2]; + + if (!(server_list= getenv("MEMCACHED_SERVERS"))) + server_list= "localhost"; + + printf("servers %s\n", server_list); + srandom(time(NULL)); + + servers= memcached_servers_parse(server_list); + assert(servers); + + for (x= 0; x < memcached_server_list_count(servers); x++) + { + printf("\t%s : %u\n", servers[x].hostname, servers[x].port); + assert(servers[x].stack_responses == 0); + assert(servers[x].fd == -1); + assert(servers[x].cursor_active == 0); + } + + printf("\n"); /* Clean the server before beginning testing */ test_st tests[] ={ @@ -596,45 +642,180 @@ int main(int argc, char *argv[]) {"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 }, + {0, 0, 0} + }; + + test_st user_tests[] ={ + {"user_supplied_bug1", 0, user_supplied_bug1 }, {0, 0, 0} }; - fprintf(stderr, "\nBlock tests\n\n"); - for (x= 0; tests[x].function_name; x++) + if ((test_to_run && !strcmp(test_to_run, "block")) || !test_to_run) { - memcached_st *memc; - memc= memcached_create(NULL); - assert(memc); - 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); + 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); + + 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); + } } - fprintf(stderr, "\nNonblock tests\n\n"); - for (x= 0; tests[x].function_name; x++) + if ((test_to_run && !strcmp(test_to_run, "nonblock")) || !test_to_run) { - memcached_st *memc; - memc= memcached_create(NULL); - assert(memc); - 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, "\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); + + 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); + } + } - /* The multiple tests */ - if (argc == 2) + if ((test_to_run && !strcmp(test_to_run, "md5")) || !test_to_run) { - memcached_st *memc; - memc= memcached_create(NULL); - assert(memc); - get_stats_multiple(memc); - memcached_free(memc); + fprintf(stderr, "\nMD5 Hashing\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_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); + } } /* Clean up whatever we might have left */ @@ -645,5 +826,8 @@ int main(int argc, char *argv[]) flush_test(memc); memcached_free(memc); } + + fprintf(stderr, "All tests completed successfully\n\n"); + return 0; }