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 WATCHPOINT_ERROR(rc
);
105 assert(rc
== MEMCACHED_SUCCESS
);
108 void flush_test(memcached_st
*memc
)
112 rc
= memcached_flush(memc
, 0);
113 assert(rc
== MEMCACHED_SUCCESS
);
116 void get_test(memcached_st
*memc
)
121 size_t string_length
;
124 string
= memcached_get(memc
, key
, strlen(key
),
125 &string_length
, &flags
, &rc
);
127 assert(rc
== MEMCACHED_NOTFOUND
);
128 assert(string_length
== 0);
132 void get_test2(memcached_st
*memc
)
136 char *value
= "when we sanitize";
138 size_t string_length
;
141 rc
= memcached_set(memc
, key
, strlen(key
),
142 value
, strlen(value
),
143 (time_t)0, (uint16_t)0);
144 assert(rc
== MEMCACHED_SUCCESS
);
146 string
= memcached_get(memc
, key
, strlen(key
),
147 &string_length
, &flags
, &rc
);
150 assert(rc
== MEMCACHED_SUCCESS
);
151 assert(string_length
== strlen(value
));
152 assert(!memcmp(string
, value
, string_length
));
157 void set_test2(memcached_st
*memc
)
161 char *value
= "train in the brain";
162 size_t value_length
= strlen(value
);
165 for (x
= 0; x
< 10; x
++)
167 rc
= memcached_set(memc
, key
, strlen(key
),
169 (time_t)0, (uint16_t)0);
170 assert(rc
== MEMCACHED_SUCCESS
);
174 void set_test3(memcached_st
*memc
)
179 size_t value_length
= 8191;
182 value
= (char*)malloc(value_length
);
185 for (x
= 0; x
< value_length
; x
++)
186 value
[x
] = (char) (x
% 127);
188 for (x
= 0; x
< 1; x
++)
190 rc
= memcached_set(memc
, key
, strlen(key
),
192 (time_t)0, (uint16_t)0);
193 assert(rc
== MEMCACHED_SUCCESS
);
199 void get_test3(memcached_st
*memc
)
204 size_t value_length
= 8191;
206 size_t string_length
;
210 value
= (char*)malloc(value_length
);
213 for (x
= 0; x
< value_length
; x
++)
214 value
[x
] = (char) (x
% 127);
216 rc
= memcached_set(memc
, key
, strlen(key
),
218 (time_t)0, (uint16_t)0);
219 assert(rc
== MEMCACHED_SUCCESS
);
221 string
= memcached_get(memc
, key
, strlen(key
),
222 &string_length
, &flags
, &rc
);
224 WATCHPOINT_ERRNO(memc
->my_errno
);
225 WATCHPOINT_ERROR(rc
);
226 assert(rc
== MEMCACHED_SUCCESS
);
228 assert(string_length
== value_length
);
229 assert(!memcmp(string
, value
, string_length
));
235 void get_test4(memcached_st
*memc
)
240 size_t value_length
= 8191;
242 size_t string_length
;
246 value
= (char*)malloc(value_length
);
249 for (x
= 0; x
< value_length
; x
++)
250 value
[x
] = (char) (x
% 127);
252 rc
= memcached_set(memc
, key
, strlen(key
),
254 (time_t)0, (uint16_t)0);
255 assert(rc
== MEMCACHED_SUCCESS
);
257 for (x
= 0; x
< 10; x
++)
259 string
= memcached_get(memc
, key
, strlen(key
),
260 &string_length
, &flags
, &rc
);
262 assert(rc
== MEMCACHED_SUCCESS
);
264 assert(string_length
== value_length
);
265 assert(!memcmp(string
, value
, string_length
));
272 void stats_servername_test(memcached_st
*memc
)
275 memcached_stat_st stat
;
276 rc
= memcached_stat_servername(&stat
, NULL
,
278 MEMCACHED_DEFAULT_PORT
);
281 void increment_test(memcached_st
*memc
)
283 unsigned int new_number
;
288 rc
= memcached_set(memc
, key
, strlen(key
),
289 value
, strlen(value
),
290 (time_t)0, (uint16_t)0);
291 assert(rc
== MEMCACHED_SUCCESS
);
293 rc
= memcached_increment(memc
, key
, strlen(key
),
295 assert(rc
== MEMCACHED_SUCCESS
);
296 assert(new_number
== 1);
298 rc
= memcached_increment(memc
, key
, strlen(key
),
300 assert(rc
== MEMCACHED_SUCCESS
);
301 assert(new_number
== 2);
304 void decrement_test(memcached_st
*memc
)
306 unsigned int new_number
;
311 rc
= memcached_set(memc
, key
, strlen(key
),
312 value
, strlen(value
),
313 (time_t)0, (uint16_t)0);
314 assert(rc
== MEMCACHED_SUCCESS
);
316 rc
= memcached_decrement(memc
, key
, strlen(key
),
318 assert(rc
== MEMCACHED_SUCCESS
);
319 assert(new_number
== 2);
321 rc
= memcached_decrement(memc
, key
, strlen(key
),
323 assert(rc
== MEMCACHED_SUCCESS
);
324 assert(new_number
== 1);
327 void quit_test(memcached_st
*memc
)
331 char *value
= "sanford and sun";
333 rc
= memcached_set(memc
, key
, strlen(key
),
334 value
, strlen(value
),
335 (time_t)10, (uint16_t)3);
336 assert(rc
== MEMCACHED_SUCCESS
);
337 memcached_quit(memc
);
339 rc
= memcached_set(memc
, key
, strlen(key
),
340 value
, strlen(value
),
341 (time_t)50, (uint16_t)9);
342 assert(rc
== MEMCACHED_SUCCESS
);
345 void mget_test(memcached_st
*memc
)
348 char *keys
[]= {"fudge", "son", "food"};
349 size_t key_length
[]= {5, 3, 4};
353 char return_key
[MEMCACHED_MAX_KEY
];
354 size_t return_key_length
;
356 size_t return_value_length
;
358 /* We need to empty the server before continueing test */
359 rc
= memcached_flush(memc
, 0);
360 assert(rc
== MEMCACHED_SUCCESS
);
362 rc
= memcached_mget(memc
, keys
, key_length
, 3);
363 assert(rc
== MEMCACHED_SUCCESS
);
365 while ((return_value
= memcached_fetch(memc
, return_key
, &return_key_length
,
366 &return_value_length
, &flags
, &rc
)) != NULL
)
368 assert(return_value
);
370 assert(!return_value
);
371 assert(return_value_length
== 0);
372 assert(rc
== MEMCACHED_NOTFOUND
);
374 for (x
= 0; x
< 3; x
++)
376 rc
= memcached_set(memc
, keys
[x
], key_length
[x
],
377 keys
[x
], key_length
[x
],
378 (time_t)50, (uint16_t)9);
379 assert(rc
== MEMCACHED_SUCCESS
);
382 rc
= memcached_mget(memc
, keys
, key_length
, 3);
383 assert(rc
== MEMCACHED_SUCCESS
);
386 while ((return_value
= memcached_fetch(memc
, return_key
, &return_key_length
,
387 &return_value_length
, &flags
, &rc
)))
389 assert(return_value
);
390 assert(rc
== MEMCACHED_SUCCESS
);
391 assert(return_key_length
== return_value_length
);
392 assert(!memcmp(return_value
, return_key
, return_value_length
));
398 void get_stats_keys(memcached_st
*memc
)
402 memcached_stat_st stat
;
405 list
= memcached_stat_get_keys(memc
, &stat
, &rc
);
406 assert(rc
== MEMCACHED_SUCCESS
);
407 for (ptr
= list
; *ptr
; ptr
++)
408 printf("Found key %s\n", *ptr
);
414 void get_stats(memcached_st
*memc
)
420 memcached_stat_st
*stat
;
422 stat
= memcached_stat(memc
, NULL
, &rc
);
423 assert(rc
== MEMCACHED_SUCCESS
);
425 assert(rc
== MEMCACHED_SUCCESS
);
428 for (x
= 0; x
< memcached_server_count(memc
); x
++)
430 list
= memcached_stat_get_keys(memc
, &stat
[x
], &rc
);
431 assert(rc
== MEMCACHED_SUCCESS
);
432 for (ptr
= list
; *ptr
; ptr
++)
433 printf("Found key %s\n", *ptr
);
441 void add_host_test(memcached_st
*memc
)
444 memcached_server_st
*servers
;
446 char servername
[]= "0.example.com";
448 servers
= memcached_server_list_append(NULL
, servername
, 400, &rc
);
450 assert(1 == memcached_server_list_count(servers
));
452 for (x
= 2; x
< 20; x
++)
454 char buffer
[SMALL_STRING_LEN
];
456 snprintf(buffer
, SMALL_STRING_LEN
, "%u.example.com", 400+x
);
457 servers
= memcached_server_list_append(servers
, buffer
, 401,
459 assert(rc
== MEMCACHED_SUCCESS
);
460 assert(x
== memcached_server_list_count(servers
));
463 rc
= memcached_server_push(memc
, servers
);
464 assert(rc
== MEMCACHED_SUCCESS
);
465 rc
= memcached_server_push(memc
, servers
);
466 assert(rc
== MEMCACHED_SUCCESS
);
468 memcached_server_list_free(servers
);
471 /* We don't test the behavior itself, we test the switches */
472 void behavior_test(memcached_st
*memc
)
474 unsigned long long value
;
477 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NO_BLOCK
, &set
);
478 value
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_NO_BLOCK
);
481 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_TCP_NODELAY
, &set
);
482 value
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_TCP_NODELAY
);
485 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_MD5_HASHING
, &set
);
486 value
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_MD5_HASHING
);
491 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NO_BLOCK
, &set
);
492 value
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_NO_BLOCK
);
495 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_TCP_NODELAY
, &set
);
496 value
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_TCP_NODELAY
);
499 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_MD5_HASHING
, &set
);
500 value
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_MD5_HASHING
);
504 /* Test case provided by Cal Haldenbrand */
505 void user_supplied_bug1(memcached_st
*memc
)
507 unsigned int setter
= 1;
514 char *randomstuff
= (char *)malloc(6 * 1024);
515 memset(randomstuff
, 0, 6 * 1024);
519 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NO_BLOCK
, &setter
);
520 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_TCP_NODELAY
, &setter
);
524 for (x
= 0 ; total
< 20 * 1024576 ; x
++ )
528 size
= (rand() % ( 5 * 1024 ) ) + 400;
529 memset(randomstuff
, 0, 6 * 1024);
530 assert(size
< 6 * 1024); /* Being safe here */
532 for (j
= 0 ; j
< size
;j
++)
533 randomstuff
[j
] = (char) (rand() % 26) + 97;
536 sprintf(key
, "%d", x
);
537 rc
= memcached_set(memc
, key
, strlen(key
),
538 randomstuff
, strlen(randomstuff
), 10, 0);
539 /* If we fail, lets try again */
540 if (rc
!= MEMCACHED_SUCCESS
)
541 rc
= memcached_set(memc
, key
, strlen(key
),
542 randomstuff
, strlen(randomstuff
), 10, 0);
543 assert(rc
== MEMCACHED_SUCCESS
);
546 void add_host_test1(memcached_st
*memc
)
550 char servername
[]= "0.example.com";
551 memcached_server_st
*servers
;
553 servers
= memcached_server_list_append(NULL
, servername
, 400, &rc
);
555 assert(1 == memcached_server_list_count(servers
));
557 for (x
= 2; x
< 20; x
++)
559 char buffer
[SMALL_STRING_LEN
];
561 snprintf(buffer
, SMALL_STRING_LEN
, "%u.example.com", 400+x
);
562 servers
= memcached_server_list_append(servers
, buffer
, 401,
564 assert(rc
== MEMCACHED_SUCCESS
);
565 assert(x
== memcached_server_list_count(servers
));
568 rc
= memcached_server_push(memc
, servers
);
569 assert(rc
== MEMCACHED_SUCCESS
);
570 rc
= memcached_server_push(memc
, servers
);
571 assert(rc
== MEMCACHED_SUCCESS
);
573 memcached_server_list_free(servers
);
576 typedef struct test_st test_st
;
580 unsigned int requires_flush
;
581 void (*function
)(memcached_st
*memc
);
584 int main(int argc
, char *argv
[])
588 char *test_to_run
= NULL
;
589 char *wildcard
= NULL
;
590 memcached_server_st
*servers
;
593 test_to_run
= argv
[1];
598 if (!(server_list
= getenv("MEMCACHED_SERVERS")))
599 server_list
= "localhost";
601 printf("servers %s\n", server_list
);
604 servers
= memcached_servers_parse(server_list
);
607 for (x
= 0; x
< memcached_server_list_count(servers
); x
++)
609 printf("\t%s : %u\n", servers
[x
].hostname
, servers
[x
].port
);
610 assert(servers
[x
].stack_responses
== 0);
611 assert(servers
[x
].fd
== -1);
612 assert(servers
[x
].cursor_active
== 0);
617 /* Clean the server before beginning testing */
619 {"flush", 0, flush_test
},
620 {"init", 0, init_test
},
621 {"allocation", 0, allocation_test
},
622 {"error", 0, error_test
},
623 {"set", 0, set_test
},
624 {"set2", 0, set_test2
},
625 {"set3", 0, set_test3
},
626 {"add", 0, add_test
},
627 {"replace", 0, replace_test
},
628 {"delete", 1, delete_test
},
629 {"get", 0, get_test
},
630 {"get2", 0, get_test2
},
631 {"get3", 0, get_test3
},
632 {"get4", 0, get_test4
},
633 {"stats_servername", 0, stats_servername_test
},
634 {"increment", 0, increment_test
},
635 {"decrement", 0, decrement_test
},
636 {"quit", 0, quit_test
},
637 {"mget", 0, mget_test
},
638 {"get_stats", 0, get_stats
},
639 {"add_host_test", 0, add_host_test
},
640 {"get_stats_keys", 0, get_stats_keys
},
641 {"behavior_test", 0, get_stats_keys
},
645 test_st user_tests
[] ={
646 {"user_supplied_bug1", 0, user_supplied_bug1
},
650 if ((test_to_run
&& !strcmp(test_to_run
, "block")) || !test_to_run
)
652 fprintf(stderr
, "\nBlock tests\n\n");
653 for (x
= 0; tests
[x
].function_name
; x
++)
656 if (strcmp(wildcard
, tests
[x
].function_name
))
661 struct timeval start_time
, end_time
;
663 memc
= memcached_create(NULL
);
666 rc
= memcached_server_push(memc
, servers
);
667 assert(rc
== MEMCACHED_SUCCESS
);
670 for (loop
= 0; loop
< memcached_server_list_count(servers
); loop
++)
672 assert(memc
->hosts
[loop
].stack_responses
== 0);
673 assert(memc
->hosts
[loop
].fd
== -1);
674 assert(memc
->hosts
[loop
].cursor_active
== 0);
677 fprintf(stderr
, "Testing %s", tests
[x
].function_name
);
678 gettimeofday(&start_time
, NULL
);
679 tests
[x
].function(memc
);
680 gettimeofday(&end_time
, NULL
);
681 long int load_time
= timedif(end_time
, start_time
);
682 fprintf(stderr
, "\t\t\t\t\t %ld.%03ld [ ok ]\n", load_time
/ 1000,
685 memcached_free(memc
);
689 if ((test_to_run
&& !strcmp(test_to_run
, "nonblock")) || !test_to_run
)
691 fprintf(stderr
, "\nNonblock tests\n\n");
692 for (x
= 0; tests
[x
].function_name
; x
++)
695 if (strcmp(wildcard
, tests
[x
].function_name
))
700 struct timeval start_time
, end_time
;
702 memc
= memcached_create(NULL
);
705 rc
= memcached_server_push(memc
, servers
);
706 assert(rc
== MEMCACHED_SUCCESS
);
708 fprintf(stderr
, "Testing %s", tests
[x
].function_name
);
709 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NO_BLOCK
, NULL
);
710 gettimeofday(&start_time
, NULL
);
711 tests
[x
].function(memc
);
712 gettimeofday(&end_time
, NULL
);
713 long int load_time
= timedif(end_time
, start_time
);
714 fprintf(stderr
, "\t\t\t\t\t %ld.%03ld [ ok ]\n", load_time
/ 1000,
717 memcached_free(memc
);
721 if ((test_to_run
&& !strcmp(test_to_run
, "nodelay")) || !test_to_run
)
723 fprintf(stderr
, "\nTCP Nodelay tests\n\n");
724 for (x
= 0; tests
[x
].function_name
; x
++)
727 if (strcmp(wildcard
, tests
[x
].function_name
))
732 struct timeval start_time
, end_time
;
734 memc
= memcached_create(NULL
);
737 rc
= memcached_server_push(memc
, servers
);
738 assert(rc
== MEMCACHED_SUCCESS
);
740 fprintf(stderr
, "Testing %s", tests
[x
].function_name
);
741 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NO_BLOCK
, NULL
);
742 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_TCP_NODELAY
, NULL
);
743 gettimeofday(&start_time
, NULL
);
744 tests
[x
].function(memc
);
745 gettimeofday(&end_time
, NULL
);
746 long int load_time
= timedif(end_time
, start_time
);
747 fprintf(stderr
, "\t\t\t\t\t %ld.%03ld [ ok ]\n", load_time
/ 1000,
750 memcached_free(memc
);
754 if ((test_to_run
&& !strcmp(test_to_run
, "md5")) || !test_to_run
)
756 fprintf(stderr
, "\nMD5 Hashing\n\n");
757 for (x
= 0; tests
[x
].function_name
; x
++)
760 if (strcmp(wildcard
, tests
[x
].function_name
))
765 struct timeval start_time
, end_time
;
767 memc
= memcached_create(NULL
);
770 rc
= memcached_server_push(memc
, servers
);
771 assert(rc
== MEMCACHED_SUCCESS
);
773 fprintf(stderr
, "Testing %s", tests
[x
].function_name
);
774 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_MD5_HASHING
, NULL
);
775 gettimeofday(&start_time
, NULL
);
776 tests
[x
].function(memc
);
777 gettimeofday(&end_time
, NULL
);
778 long int load_time
= timedif(end_time
, start_time
);
779 fprintf(stderr
, "\t\t\t\t\t %ld.%03ld [ ok ]\n", load_time
/ 1000,
782 memcached_free(memc
);
786 if ((test_to_run
&& !strcmp(test_to_run
, "user")) || !test_to_run
)
788 fprintf(stderr
, "\nUser Supplied tests\n\n");
789 for (x
= 0; user_tests
[x
].function_name
; x
++)
792 if (strcmp(wildcard
, tests
[x
].function_name
))
797 struct timeval start_time
, end_time
;
799 memc
= memcached_create(NULL
);
802 rc
= memcached_server_push(memc
, servers
);
803 assert(rc
== MEMCACHED_SUCCESS
);
805 fprintf(stderr
, "Testing %s", user_tests
[x
].function_name
);
806 gettimeofday(&start_time
, NULL
);
807 user_tests
[x
].function(memc
);
808 gettimeofday(&end_time
, NULL
);
809 long int load_time
= timedif(end_time
, start_time
);
810 fprintf(stderr
, "\t\t\t\t\t %ld.%03ld [ ok ]\n", load_time
/ 1000,
813 memcached_free(memc
);
817 /* Clean up whatever we might have left */
820 memc
= memcached_create(NULL
);
823 memcached_free(memc
);
826 fprintf(stderr
, "All tests completed successfully\n\n");