2 Sample test application.
11 long int timedif(struct timeval a
, struct timeval b
)
15 us
= a
.tv_usec
- b
.tv_usec
;
17 s
= a
.tv_sec
- b
.tv_sec
;
22 void init_test(memcached_st
*not_used
)
26 (void)memcached_create(&memc
);
27 memcached_free(&memc
);
30 void allocation_test(memcached_st
*not_used
)
33 memc
= memcached_create(NULL
);
38 void connection_test(memcached_st
*memc
)
42 rc
= memcached_server_add(memc
, "localhost", 0);
43 assert(rc
== MEMCACHED_SUCCESS
);
46 void error_test(memcached_st
*memc
)
50 for (rc
= MEMCACHED_SUCCESS
; rc
< MEMCACHED_MAXIMUM_RETURN
; rc
++)
52 printf("Error %d -> %s\n", rc
, memcached_strerror(memc
, rc
));
56 void set_test(memcached_st
*memc
)
60 char *value
= "when we sanitize";
62 rc
= memcached_set(memc
, key
, strlen(key
),
64 (time_t)0, (uint16_t)0);
65 assert(rc
== MEMCACHED_SUCCESS
);
68 void add_test(memcached_st
*memc
)
72 char *value
= "when we sanitize";
74 rc
= memcached_add(memc
, key
, strlen(key
),
76 (time_t)0, (uint16_t)0);
77 assert(rc
== MEMCACHED_NOTSTORED
);
80 void replace_test(memcached_st
*memc
)
84 char *value
= "when we sanitize";
86 rc
= memcached_replace(memc
, key
, strlen(key
),
88 (time_t)0, (uint16_t)0);
89 assert(rc
== MEMCACHED_SUCCESS
);
92 void delete_test(memcached_st
*memc
)
96 char *value
= "when we sanitize";
98 rc
= memcached_set(memc
, key
, strlen(key
),
100 (time_t)0, (uint16_t)0);
101 assert(rc
== MEMCACHED_SUCCESS
);
103 rc
= memcached_delete(memc
, key
, strlen(key
), (time_t)0);
104 assert(rc
== MEMCACHED_SUCCESS
);
107 void flush_test(memcached_st
*memc
)
111 rc
= memcached_flush(memc
, 0);
112 assert(rc
== MEMCACHED_SUCCESS
);
115 void get_test(memcached_st
*memc
)
120 size_t string_length
;
123 string
= memcached_get(memc
, key
, strlen(key
),
124 &string_length
, &flags
, &rc
);
126 assert(rc
== MEMCACHED_NOTFOUND
);
127 assert(string_length
== 0);
131 void get_test2(memcached_st
*memc
)
135 char *value
= "when we sanitize";
137 size_t string_length
;
140 rc
= memcached_set(memc
, key
, strlen(key
),
141 value
, strlen(value
),
142 (time_t)0, (uint16_t)0);
143 assert(rc
== MEMCACHED_SUCCESS
);
145 string
= memcached_get(memc
, key
, strlen(key
),
146 &string_length
, &flags
, &rc
);
149 assert(rc
== MEMCACHED_SUCCESS
);
150 assert(string_length
== strlen(value
));
151 assert(!memcmp(string
, value
, string_length
));
156 void set_test2(memcached_st
*memc
)
160 char *value
= "train in the brain";
161 size_t value_length
= strlen(value
);
164 for (x
= 0; x
< 10; x
++)
166 rc
= memcached_set(memc
, key
, strlen(key
),
168 (time_t)0, (uint16_t)0);
169 assert(rc
== MEMCACHED_SUCCESS
);
173 void set_test3(memcached_st
*memc
)
178 size_t value_length
= 8191;
181 value
= (char*)malloc(value_length
);
184 for (x
= 0; x
< value_length
; x
++)
185 value
[x
] = (char) (x
% 127);
187 for (x
= 0; x
< 1; x
++)
189 rc
= memcached_set(memc
, key
, strlen(key
),
191 (time_t)0, (uint16_t)0);
192 assert(rc
== MEMCACHED_SUCCESS
);
198 void get_test3(memcached_st
*memc
)
203 size_t value_length
= 8191;
205 size_t string_length
;
209 value
= (char*)malloc(value_length
);
212 for (x
= 0; x
< value_length
; x
++)
213 value
[x
] = (char) (x
% 127);
215 rc
= memcached_set(memc
, key
, strlen(key
),
217 (time_t)0, (uint16_t)0);
218 assert(rc
== MEMCACHED_SUCCESS
);
220 string
= memcached_get(memc
, key
, strlen(key
),
221 &string_length
, &flags
, &rc
);
223 WATCHPOINT_ERRNO(memc
->my_errno
);
224 WATCHPOINT_ERROR(rc
);
225 assert(rc
== MEMCACHED_SUCCESS
);
227 assert(string_length
== value_length
);
228 assert(!memcmp(string
, value
, string_length
));
234 void get_test4(memcached_st
*memc
)
239 size_t value_length
= 8191;
241 size_t string_length
;
245 value
= (char*)malloc(value_length
);
248 for (x
= 0; x
< value_length
; x
++)
249 value
[x
] = (char) (x
% 127);
251 rc
= memcached_set(memc
, key
, strlen(key
),
253 (time_t)0, (uint16_t)0);
254 assert(rc
== MEMCACHED_SUCCESS
);
256 for (x
= 0; x
< 10; x
++)
258 string
= memcached_get(memc
, key
, strlen(key
),
259 &string_length
, &flags
, &rc
);
261 assert(rc
== MEMCACHED_SUCCESS
);
263 assert(string_length
== value_length
);
264 assert(!memcmp(string
, value
, string_length
));
271 void stats_servername_test(memcached_st
*memc
)
274 memcached_stat_st stat
;
275 rc
= memcached_stat_servername(&stat
, NULL
,
277 MEMCACHED_DEFAULT_PORT
);
280 void increment_test(memcached_st
*memc
)
282 unsigned int new_number
;
287 rc
= memcached_set(memc
, key
, strlen(key
),
288 value
, strlen(value
),
289 (time_t)0, (uint16_t)0);
290 assert(rc
== MEMCACHED_SUCCESS
);
292 rc
= memcached_increment(memc
, key
, strlen(key
),
294 assert(rc
== MEMCACHED_SUCCESS
);
295 assert(new_number
== 1);
297 rc
= memcached_increment(memc
, key
, strlen(key
),
299 assert(rc
== MEMCACHED_SUCCESS
);
300 assert(new_number
== 2);
303 void decrement_test(memcached_st
*memc
)
305 unsigned int new_number
;
310 rc
= memcached_set(memc
, key
, strlen(key
),
311 value
, strlen(value
),
312 (time_t)0, (uint16_t)0);
313 assert(rc
== MEMCACHED_SUCCESS
);
315 rc
= memcached_decrement(memc
, key
, strlen(key
),
317 assert(rc
== MEMCACHED_SUCCESS
);
318 assert(new_number
== 2);
320 rc
= memcached_decrement(memc
, key
, strlen(key
),
322 assert(rc
== MEMCACHED_SUCCESS
);
323 assert(new_number
== 1);
326 void quit_test(memcached_st
*memc
)
330 char *value
= "sanford and sun";
332 rc
= memcached_set(memc
, key
, strlen(key
),
333 value
, strlen(value
),
334 (time_t)10, (uint16_t)3);
335 assert(rc
== MEMCACHED_SUCCESS
);
336 memcached_quit(memc
);
338 rc
= memcached_set(memc
, key
, strlen(key
),
339 value
, strlen(value
),
340 (time_t)50, (uint16_t)9);
341 assert(rc
== MEMCACHED_SUCCESS
);
344 void mget_test(memcached_st
*memc
)
347 char *keys
[]= {"fudge", "son", "food"};
348 size_t key_length
[]= {5, 3, 4};
352 char return_key
[MEMCACHED_MAX_KEY
];
353 size_t return_key_length
;
355 size_t return_value_length
;
357 /* We need to empty the server before continueing test */
358 rc
= memcached_flush(memc
, 0);
359 assert(rc
== MEMCACHED_SUCCESS
);
361 rc
= memcached_mget(memc
, keys
, key_length
, 3);
362 assert(rc
== MEMCACHED_SUCCESS
);
364 while ((return_value
= memcached_fetch(memc
, return_key
, &return_key_length
,
365 &return_value_length
, &flags
, &rc
)) != NULL
)
367 assert(return_value
);
369 assert(!return_value
);
370 assert(return_value_length
== 0);
371 assert(rc
== MEMCACHED_NOTFOUND
);
373 for (x
= 0; x
< 3; x
++)
375 rc
= memcached_set(memc
, keys
[x
], key_length
[x
],
376 keys
[x
], key_length
[x
],
377 (time_t)50, (uint16_t)9);
378 assert(rc
== MEMCACHED_SUCCESS
);
381 rc
= memcached_mget(memc
, keys
, key_length
, 3);
382 assert(rc
== MEMCACHED_SUCCESS
);
385 while ((return_value
= memcached_fetch(memc
, return_key
, &return_key_length
,
386 &return_value_length
, &flags
, &rc
)))
388 assert(return_value
);
389 assert(rc
== MEMCACHED_SUCCESS
);
390 assert(return_key_length
== return_value_length
);
391 assert(!memcmp(return_value
, return_key
, return_value_length
));
397 void get_stats_keys(memcached_st
*memc
)
401 memcached_stat_st stat
;
404 list
= memcached_stat_get_keys(memc
, &stat
, &rc
);
405 assert(rc
== MEMCACHED_SUCCESS
);
406 for (ptr
= list
; *ptr
; ptr
++)
407 printf("Found key %s\n", *ptr
);
413 void get_stats(memcached_st
*memc
)
419 memcached_stat_st
*stat
;
421 stat
= memcached_stat(memc
, NULL
, &rc
);
422 assert(rc
== MEMCACHED_SUCCESS
);
424 assert(rc
== MEMCACHED_SUCCESS
);
427 for (x
= 0; x
< memcached_server_count(memc
); x
++)
429 list
= memcached_stat_get_keys(memc
, &stat
[x
], &rc
);
430 assert(rc
== MEMCACHED_SUCCESS
);
431 for (ptr
= list
; *ptr
; ptr
++)
432 printf("Found key %s\n", *ptr
);
440 void add_host_test(memcached_st
*memc
)
443 memcached_server_st
*servers
;
445 char servername
[]= "0.example.com";
447 servers
= memcached_server_list_append(NULL
, servername
, 400, &rc
);
449 assert(1 == memcached_server_list_count(servers
));
451 for (x
= 2; x
< 20; x
++)
453 char buffer
[SMALL_STRING_LEN
];
455 snprintf(buffer
, SMALL_STRING_LEN
, "%u.example.com", 400+x
);
456 servers
= memcached_server_list_append(servers
, buffer
, 401,
458 assert(rc
== MEMCACHED_SUCCESS
);
459 assert(x
== memcached_server_list_count(servers
));
462 rc
= memcached_server_push(memc
, servers
);
463 assert(rc
== MEMCACHED_SUCCESS
);
464 rc
= memcached_server_push(memc
, servers
);
465 assert(rc
== MEMCACHED_SUCCESS
);
467 memcached_server_list_free(servers
);
470 /* We don't test the behavior itself, we test the switches */
471 void behavior_test(memcached_st
*memc
)
473 unsigned long long value
;
476 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NO_BLOCK
, &set
);
477 value
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_NO_BLOCK
);
480 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_TCP_NODELAY
, &set
);
481 value
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_TCP_NODELAY
);
484 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_MD5_HASHING
, &set
);
485 value
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_MD5_HASHING
);
490 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NO_BLOCK
, &set
);
491 value
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_NO_BLOCK
);
494 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_TCP_NODELAY
, &set
);
495 value
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_TCP_NODELAY
);
498 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_MD5_HASHING
, &set
);
499 value
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_MD5_HASHING
);
503 /* Test case provided by Cal Haldenbrand */
504 void user_supplied_bug1(memcached_st
*memc
)
506 unsigned int setter
= 1;
513 char *randomstuff
= (char *)malloc(6 * 1024);
514 memset(randomstuff
, 0, 6 * 1024);
518 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NO_BLOCK
, &setter
);
519 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_TCP_NODELAY
, &setter
);
523 for (x
= 0 ; total
< 20 * 1024576 ; x
++ )
527 size
= (rand() % ( 5 * 1024 ) ) + 400;
528 memset(randomstuff
, 0, 6 * 1024);
529 assert(size
< 6 * 1024); /* Being safe here */
531 for (j
= 0 ; j
< size
;j
++)
532 randomstuff
[j
] = (char) (rand() % 26) + 97;
535 sprintf(key
, "%d", x
);
536 rc
= memcached_set(memc
, key
, strlen(key
),
537 randomstuff
, strlen(randomstuff
), 10, 0);
538 /* If we fail, lets try again */
539 if (rc
!= MEMCACHED_SUCCESS
)
540 rc
= memcached_set(memc
, key
, strlen(key
),
541 randomstuff
, strlen(randomstuff
), 10, 0);
542 assert(rc
== MEMCACHED_SUCCESS
);
545 void add_host_test1(memcached_st
*memc
)
549 char servername
[]= "0.example.com";
550 memcached_server_st
*servers
;
552 servers
= memcached_server_list_append(NULL
, servername
, 400, &rc
);
554 assert(1 == memcached_server_list_count(servers
));
556 for (x
= 2; x
< 20; x
++)
558 char buffer
[SMALL_STRING_LEN
];
560 snprintf(buffer
, SMALL_STRING_LEN
, "%u.example.com", 400+x
);
561 servers
= memcached_server_list_append(servers
, buffer
, 401,
563 assert(rc
== MEMCACHED_SUCCESS
);
564 assert(x
== memcached_server_list_count(servers
));
567 rc
= memcached_server_push(memc
, servers
);
568 assert(rc
== MEMCACHED_SUCCESS
);
569 rc
= memcached_server_push(memc
, servers
);
570 assert(rc
== MEMCACHED_SUCCESS
);
572 memcached_server_list_free(servers
);
575 typedef struct test_st test_st
;
579 unsigned int requires_flush
;
580 void (*function
)(memcached_st
*memc
);
583 int main(int argc
, char *argv
[])
587 char *test_to_run
= NULL
;
588 char *wildcard
= NULL
;
589 memcached_server_st
*servers
;
592 test_to_run
= argv
[1];
597 if (!(server_list
= getenv("MEMCACHED_SERVERS")))
598 server_list
= "localhost";
600 printf("servers %s\n", server_list
);
603 servers
= memcached_servers_parse(server_list
);
606 for (x
= 0; x
< memcached_server_list_count(servers
); x
++)
608 printf("\t%s : %u\n", servers
[x
].hostname
, servers
[x
].port
);
609 assert(servers
[x
].stack_responses
== 0);
610 assert(servers
[x
].fd
== -1);
611 assert(servers
[x
].cursor_active
== 0);
616 /* Clean the server before beginning testing */
618 {"flush", 0, flush_test
},
619 {"init", 0, init_test
},
620 {"allocation", 0, allocation_test
},
621 {"error", 0, error_test
},
622 {"set", 0, set_test
},
623 {"set2", 0, set_test2
},
624 {"set3", 0, set_test3
},
625 {"add", 0, add_test
},
626 {"replace", 0, replace_test
},
627 {"delete", 1, delete_test
},
628 {"get", 0, get_test
},
629 {"get2", 0, get_test2
},
630 {"get3", 0, get_test3
},
631 {"get4", 0, get_test4
},
632 {"stats_servername", 0, stats_servername_test
},
633 {"increment", 0, increment_test
},
634 {"decrement", 0, decrement_test
},
635 {"quit", 0, quit_test
},
636 {"mget", 0, mget_test
},
637 {"get_stats", 0, get_stats
},
638 {"add_host_test", 0, add_host_test
},
639 {"get_stats_keys", 0, get_stats_keys
},
640 {"behavior_test", 0, get_stats_keys
},
644 test_st user_tests
[] ={
645 {"user_supplied_bug1", 0, user_supplied_bug1
},
649 if ((test_to_run
&& !strcmp(test_to_run
, "block")) || !test_to_run
)
651 fprintf(stderr
, "\nBlock tests\n\n");
652 for (x
= 0; tests
[x
].function_name
; x
++)
655 if (strcmp(wildcard
, tests
[x
].function_name
))
660 struct timeval start_time
, end_time
;
662 memc
= memcached_create(NULL
);
665 rc
= memcached_server_push(memc
, servers
);
666 assert(rc
== MEMCACHED_SUCCESS
);
669 for (loop
= 0; loop
< memcached_server_list_count(servers
); loop
++)
671 assert(memc
->hosts
[loop
].stack_responses
== 0);
672 assert(memc
->hosts
[loop
].fd
== -1);
673 assert(memc
->hosts
[loop
].cursor_active
== 0);
676 fprintf(stderr
, "Testing %s", tests
[x
].function_name
);
677 gettimeofday(&start_time
, NULL
);
678 tests
[x
].function(memc
);
679 gettimeofday(&end_time
, NULL
);
680 long int load_time
= timedif(end_time
, start_time
);
681 fprintf(stderr
, "\t\t\t\t\t %ld.%03ld [ ok ]\n", load_time
/ 1000,
684 memcached_free(memc
);
688 if ((test_to_run
&& !strcmp(test_to_run
, "nonblock")) || !test_to_run
)
690 fprintf(stderr
, "\nNonblock tests\n\n");
691 for (x
= 0; tests
[x
].function_name
; x
++)
694 if (strcmp(wildcard
, tests
[x
].function_name
))
699 struct timeval start_time
, end_time
;
701 memc
= memcached_create(NULL
);
704 rc
= memcached_server_push(memc
, servers
);
705 assert(rc
== MEMCACHED_SUCCESS
);
707 fprintf(stderr
, "Testing %s", tests
[x
].function_name
);
708 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NO_BLOCK
, NULL
);
709 gettimeofday(&start_time
, NULL
);
710 tests
[x
].function(memc
);
711 gettimeofday(&end_time
, NULL
);
712 long int load_time
= timedif(end_time
, start_time
);
713 fprintf(stderr
, "\t\t\t\t\t %ld.%03ld [ ok ]\n", load_time
/ 1000,
716 memcached_free(memc
);
720 if ((test_to_run
&& !strcmp(test_to_run
, "nodelay")) || !test_to_run
)
722 fprintf(stderr
, "\nTCP Nodelay tests\n\n");
723 for (x
= 0; tests
[x
].function_name
; x
++)
726 if (strcmp(wildcard
, tests
[x
].function_name
))
731 struct timeval start_time
, end_time
;
733 memc
= memcached_create(NULL
);
736 rc
= memcached_server_push(memc
, servers
);
737 assert(rc
== MEMCACHED_SUCCESS
);
739 fprintf(stderr
, "Testing %s", tests
[x
].function_name
);
740 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NO_BLOCK
, NULL
);
741 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_TCP_NODELAY
, NULL
);
742 gettimeofday(&start_time
, NULL
);
743 tests
[x
].function(memc
);
744 gettimeofday(&end_time
, NULL
);
745 long int load_time
= timedif(end_time
, start_time
);
746 fprintf(stderr
, "\t\t\t\t\t %ld.%03ld [ ok ]\n", load_time
/ 1000,
749 memcached_free(memc
);
753 if ((test_to_run
&& !strcmp(test_to_run
, "md5")) || !test_to_run
)
755 fprintf(stderr
, "\nMD5 Hashing\n\n");
756 for (x
= 0; tests
[x
].function_name
; x
++)
759 if (strcmp(wildcard
, tests
[x
].function_name
))
764 struct timeval start_time
, end_time
;
766 memc
= memcached_create(NULL
);
769 rc
= memcached_server_push(memc
, servers
);
770 assert(rc
== MEMCACHED_SUCCESS
);
772 fprintf(stderr
, "Testing %s", tests
[x
].function_name
);
773 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_MD5_HASHING
, NULL
);
774 gettimeofday(&start_time
, NULL
);
775 tests
[x
].function(memc
);
776 gettimeofday(&end_time
, NULL
);
777 long int load_time
= timedif(end_time
, start_time
);
778 fprintf(stderr
, "\t\t\t\t\t %ld.%03ld [ ok ]\n", load_time
/ 1000,
781 memcached_free(memc
);
785 if ((test_to_run
&& !strcmp(test_to_run
, "user")) || !test_to_run
)
787 fprintf(stderr
, "\nUser Supplied tests\n\n");
788 for (x
= 0; user_tests
[x
].function_name
; x
++)
791 if (strcmp(wildcard
, tests
[x
].function_name
))
796 struct timeval start_time
, end_time
;
798 memc
= memcached_create(NULL
);
801 rc
= memcached_server_push(memc
, servers
);
802 assert(rc
== MEMCACHED_SUCCESS
);
804 fprintf(stderr
, "Testing %s", user_tests
[x
].function_name
);
805 gettimeofday(&start_time
, NULL
);
806 user_tests
[x
].function(memc
);
807 gettimeofday(&end_time
, NULL
);
808 long int load_time
= timedif(end_time
, start_time
);
809 fprintf(stderr
, "\t\t\t\t\t %ld.%03ld [ ok ]\n", load_time
/ 1000,
812 memcached_free(memc
);
816 /* Clean up whatever we might have left */
819 memc
= memcached_create(NULL
);
822 memcached_free(memc
);
825 fprintf(stderr
, "All tests completed successfully\n\n");