2 Sample test application.
12 long int timedif(struct timeval a
, struct timeval b
)
16 us
= a
.tv_usec
- b
.tv_usec
;
18 s
= a
.tv_sec
- b
.tv_sec
;
23 void init_test(memcached_st
*not_used
)
27 (void)memcached_create(&memc
);
28 memcached_free(&memc
);
31 void allocation_test(memcached_st
*not_used
)
34 memc
= memcached_create(NULL
);
39 void connection_test(memcached_st
*memc
)
43 rc
= memcached_server_add(memc
, "localhost", 0);
44 assert(rc
== MEMCACHED_SUCCESS
);
47 void error_test(memcached_st
*memc
)
51 for (rc
= MEMCACHED_SUCCESS
; rc
< MEMCACHED_MAXIMUM_RETURN
; rc
++)
53 printf("Error %d -> %s\n", rc
, memcached_strerror(memc
, rc
));
57 void set_test(memcached_st
*memc
)
61 char *value
= "when we sanitize";
63 rc
= memcached_set(memc
, key
, strlen(key
),
65 (time_t)0, (uint16_t)0);
66 assert(rc
== MEMCACHED_SUCCESS
);
69 void add_test(memcached_st
*memc
)
73 char *value
= "when we sanitize";
75 rc
= memcached_add(memc
, key
, strlen(key
),
77 (time_t)0, (uint16_t)0);
78 assert(rc
== MEMCACHED_NOTSTORED
);
81 void replace_test(memcached_st
*memc
)
85 char *value
= "when we sanitize";
87 rc
= memcached_replace(memc
, key
, strlen(key
),
89 (time_t)0, (uint16_t)0);
90 assert(rc
== MEMCACHED_SUCCESS
);
93 void delete_test(memcached_st
*memc
)
97 char *value
= "when we sanitize";
99 rc
= memcached_set(memc
, key
, strlen(key
),
100 value
, strlen(value
),
101 (time_t)0, (uint16_t)0);
102 assert(rc
== MEMCACHED_SUCCESS
);
104 rc
= memcached_delete(memc
, key
, strlen(key
), (time_t)0);
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 assert(rc
== MEMCACHED_SUCCESS
);
226 assert(string_length
== value_length
);
227 assert(!memcmp(string
, value
, string_length
));
233 void get_test4(memcached_st
*memc
)
238 size_t value_length
= 8191;
240 size_t string_length
;
244 value
= (char*)malloc(value_length
);
247 for (x
= 0; x
< value_length
; x
++)
248 value
[x
] = (char) (x
% 127);
250 rc
= memcached_set(memc
, key
, strlen(key
),
252 (time_t)0, (uint16_t)0);
253 assert(rc
== MEMCACHED_SUCCESS
);
255 for (x
= 0; x
< 10; x
++)
257 string
= memcached_get(memc
, key
, strlen(key
),
258 &string_length
, &flags
, &rc
);
260 assert(rc
== MEMCACHED_SUCCESS
);
262 assert(string_length
== value_length
);
263 assert(!memcmp(string
, value
, string_length
));
270 void stats_servername_test(memcached_st
*memc
)
273 memcached_stat_st stat
;
274 rc
= memcached_stat_servername(&stat
, NULL
,
276 MEMCACHED_DEFAULT_PORT
);
279 void increment_test(memcached_st
*memc
)
281 unsigned int new_number
;
286 rc
= memcached_set(memc
, key
, strlen(key
),
287 value
, strlen(value
),
288 (time_t)0, (uint16_t)0);
289 assert(rc
== MEMCACHED_SUCCESS
);
291 rc
= memcached_increment(memc
, key
, strlen(key
),
293 assert(rc
== MEMCACHED_SUCCESS
);
294 assert(new_number
== 1);
296 rc
= memcached_increment(memc
, key
, strlen(key
),
298 assert(rc
== MEMCACHED_SUCCESS
);
299 assert(new_number
== 2);
302 void decrement_test(memcached_st
*memc
)
304 unsigned int new_number
;
309 rc
= memcached_set(memc
, key
, strlen(key
),
310 value
, strlen(value
),
311 (time_t)0, (uint16_t)0);
312 assert(rc
== MEMCACHED_SUCCESS
);
314 rc
= memcached_decrement(memc
, key
, strlen(key
),
316 assert(rc
== MEMCACHED_SUCCESS
);
317 assert(new_number
== 2);
319 rc
= memcached_decrement(memc
, key
, strlen(key
),
321 assert(rc
== MEMCACHED_SUCCESS
);
322 assert(new_number
== 1);
325 void quit_test(memcached_st
*memc
)
329 char *value
= "sanford and sun";
331 rc
= memcached_set(memc
, key
, strlen(key
),
332 value
, strlen(value
),
333 (time_t)10, (uint16_t)3);
334 assert(rc
== MEMCACHED_SUCCESS
);
335 memcached_quit(memc
);
337 rc
= memcached_set(memc
, key
, strlen(key
),
338 value
, strlen(value
),
339 (time_t)50, (uint16_t)9);
340 assert(rc
== MEMCACHED_SUCCESS
);
343 void mget_test(memcached_st
*memc
)
346 char *keys
[]= {"fudge", "son", "food"};
347 size_t key_length
[]= {5, 3, 4};
351 char return_key
[MEMCACHED_MAX_KEY
];
352 size_t return_key_length
;
354 size_t return_value_length
;
356 /* We need to empty the server before continueing test */
357 rc
= memcached_flush(memc
, 0);
358 assert(rc
== MEMCACHED_SUCCESS
);
360 rc
= memcached_mget(memc
, keys
, key_length
, 3);
361 assert(rc
== MEMCACHED_SUCCESS
);
363 while ((return_value
= memcached_fetch(memc
, return_key
, &return_key_length
,
364 &return_value_length
, &flags
, &rc
)) != NULL
)
366 assert(return_value
);
368 assert(!return_value
);
369 assert(return_value_length
== 0);
370 assert(rc
== MEMCACHED_NOTFOUND
);
372 for (x
= 0; x
< 3; x
++)
374 rc
= memcached_set(memc
, keys
[x
], key_length
[x
],
375 keys
[x
], key_length
[x
],
376 (time_t)50, (uint16_t)9);
377 assert(rc
== MEMCACHED_SUCCESS
);
380 rc
= memcached_mget(memc
, keys
, key_length
, 3);
381 assert(rc
== MEMCACHED_SUCCESS
);
384 while ((return_value
= memcached_fetch(memc
, return_key
, &return_key_length
,
385 &return_value_length
, &flags
, &rc
)))
387 assert(return_value
);
388 assert(rc
== MEMCACHED_SUCCESS
);
389 assert(return_key_length
== return_value_length
);
390 assert(!memcmp(return_value
, return_key
, return_value_length
));
396 void get_stats_keys(memcached_st
*memc
)
400 memcached_stat_st stat
;
403 list
= memcached_stat_get_keys(memc
, &stat
, &rc
);
404 assert(rc
== MEMCACHED_SUCCESS
);
405 for (ptr
= list
; *ptr
; ptr
++)
406 printf("Found key %s\n", *ptr
);
412 void get_stats(memcached_st
*memc
)
418 memcached_stat_st
*stat
;
420 stat
= memcached_stat(memc
, NULL
, &rc
);
421 assert(rc
== MEMCACHED_SUCCESS
);
423 assert(rc
== MEMCACHED_SUCCESS
);
426 for (x
= 0; x
< memcached_server_count(memc
); x
++)
428 list
= memcached_stat_get_keys(memc
, &stat
[x
], &rc
);
429 assert(rc
== MEMCACHED_SUCCESS
);
430 for (ptr
= list
; *ptr
; ptr
++)
431 printf("Found key %s\n", *ptr
);
439 void add_host_test(memcached_st
*memc
)
442 memcached_server_st
*servers
;
444 char servername
[]= "0.example.com";
446 servers
= memcached_server_list_append(NULL
, servername
, 400, &rc
);
448 assert(1 == memcached_server_list_count(servers
));
450 for (x
= 2; x
< 20; x
++)
452 char buffer
[SMALL_STRING_LEN
];
454 snprintf(buffer
, SMALL_STRING_LEN
, "%u.example.com", 400+x
);
455 servers
= memcached_server_list_append(servers
, buffer
, 401,
457 assert(rc
== MEMCACHED_SUCCESS
);
458 assert(x
== memcached_server_list_count(servers
));
461 rc
= memcached_server_push(memc
, servers
);
462 assert(rc
== MEMCACHED_SUCCESS
);
463 rc
= memcached_server_push(memc
, servers
);
464 assert(rc
== MEMCACHED_SUCCESS
);
466 memcached_server_list_free(servers
);
469 /* We don't test the behavior itself, we test the switches */
470 void behavior_test(memcached_st
*memc
)
472 unsigned long long value
;
475 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NO_BLOCK
, &set
);
476 value
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_NO_BLOCK
);
479 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_TCP_NODELAY
, &set
);
480 value
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_TCP_NODELAY
);
483 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_MD5_HASHING
, &set
);
484 value
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_MD5_HASHING
);
489 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NO_BLOCK
, &set
);
490 value
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_NO_BLOCK
);
493 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_TCP_NODELAY
, &set
);
494 value
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_TCP_NODELAY
);
497 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_MD5_HASHING
, &set
);
498 value
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_MD5_HASHING
);
501 value
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_SOCKET_SEND_SIZE
);
504 value
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_SOCKET_RECV_SIZE
);
508 /* Test case provided by Cal Haldenbrand */
509 void user_supplied_bug1(memcached_st
*memc
)
511 unsigned int setter
= 1;
514 unsigned long long total
= 0;
518 char *randomstuff
= (char *)malloc(6 * 1024);
519 memset(randomstuff
, 0, 6 * 1024);
523 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NO_BLOCK
, &setter
);
524 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_TCP_NODELAY
, &setter
);
528 for (x
= 0 ; total
< 20 * 1024576 ; x
++ )
532 size
= (rand() % ( 5 * 1024 ) ) + 400;
533 memset(randomstuff
, 0, 6 * 1024);
534 assert(size
< 6 * 1024); /* Being safe here */
536 for (j
= 0 ; j
< size
;j
++)
537 randomstuff
[j
] = (char) (rand() % 26) + 97;
540 sprintf(key
, "%d", x
);
541 rc
= memcached_set(memc
, key
, strlen(key
),
542 randomstuff
, strlen(randomstuff
), 10, 0);
543 /* If we fail, lets try again */
544 if (rc
!= MEMCACHED_SUCCESS
)
545 rc
= memcached_set(memc
, key
, strlen(key
),
546 randomstuff
, strlen(randomstuff
), 10, 0);
547 assert(rc
== MEMCACHED_SUCCESS
);
551 /* Test case provided by Cal Haldenbrand */
552 void user_supplied_bug2(memcached_st
*memc
)
557 unsigned long long total
;
561 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NO_BLOCK
, &setter
);
562 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_TCP_NODELAY
, &setter
);
564 setter
= 20 * 1024576;
565 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_SOCKET_SEND_SIZE
, &setter
);
566 setter
= 20 * 1024576;
567 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_SOCKET_RECV_SIZE
, &setter
);
568 getter
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_SOCKET_SEND_SIZE
);
569 getter
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_SOCKET_RECV_SIZE
);
572 for (x
= 0, errors
= 0, total
= 0 ; total
< 20 * 1024576 ; x
++)
575 char buffer
[SMALL_STRING_LEN
];
580 snprintf(buffer
, SMALL_STRING_LEN
, "%u", x
);
581 getval
= memcached_get(memc
, buffer
, strlen(buffer
),
582 &val_len
, &flags
, &rc
);
583 if (rc
!= MEMCACHED_SUCCESS
)
585 WATCHPOINT_ERROR(rc
);
589 fprintf(stderr
, "last: %s: len %zu flags: %u\n", buffer
, val_len
, flags
);
600 void add_host_test1(memcached_st
*memc
)
604 char servername
[]= "0.example.com";
605 memcached_server_st
*servers
;
607 servers
= memcached_server_list_append(NULL
, servername
, 400, &rc
);
609 assert(1 == memcached_server_list_count(servers
));
611 for (x
= 2; x
< 20; x
++)
613 char buffer
[SMALL_STRING_LEN
];
615 snprintf(buffer
, SMALL_STRING_LEN
, "%u.example.com", 400+x
);
616 servers
= memcached_server_list_append(servers
, buffer
, 401,
618 assert(rc
== MEMCACHED_SUCCESS
);
619 assert(x
== memcached_server_list_count(servers
));
622 rc
= memcached_server_push(memc
, servers
);
623 assert(rc
== MEMCACHED_SUCCESS
);
624 rc
= memcached_server_push(memc
, servers
);
625 assert(rc
== MEMCACHED_SUCCESS
);
627 memcached_server_list_free(servers
);
630 typedef struct test_st test_st
;
634 unsigned int requires_flush
;
635 void (*function
)(memcached_st
*memc
);
638 int main(int argc
, char *argv
[])
642 char *test_to_run
= NULL
;
643 char *wildcard
= NULL
;
644 memcached_server_st
*servers
;
647 test_to_run
= argv
[1];
652 if (!(server_list
= getenv("MEMCACHED_SERVERS")))
653 server_list
= "localhost";
655 printf("servers %s\n", server_list
);
658 servers
= memcached_servers_parse(server_list
);
661 for (x
= 0; x
< memcached_server_list_count(servers
); x
++)
663 printf("\t%s : %u\n", servers
[x
].hostname
, servers
[x
].port
);
664 assert(servers
[x
].stack_responses
== 0);
665 assert(servers
[x
].fd
== -1);
666 assert(servers
[x
].cursor_active
== 0);
671 /* Clean the server before beginning testing */
673 {"flush", 0, flush_test
},
674 {"init", 0, init_test
},
675 {"allocation", 0, allocation_test
},
676 {"error", 0, error_test
},
677 {"set", 0, set_test
},
678 {"set2", 0, set_test2
},
679 {"set3", 0, set_test3
},
680 {"add", 0, add_test
},
681 {"replace", 0, replace_test
},
682 {"delete", 1, delete_test
},
683 {"get", 0, get_test
},
684 {"get2", 0, get_test2
},
685 {"get3", 0, get_test3
},
686 {"get4", 0, get_test4
},
687 {"stats_servername", 0, stats_servername_test
},
688 {"increment", 0, increment_test
},
689 {"decrement", 0, decrement_test
},
690 {"quit", 0, quit_test
},
691 {"mget", 0, mget_test
},
692 {"get_stats", 0, get_stats
},
693 {"add_host_test", 0, add_host_test
},
694 {"get_stats_keys", 0, get_stats_keys
},
695 {"behavior_test", 0, get_stats_keys
},
699 test_st user_tests
[] ={
700 {"user_supplied_bug1", 0, user_supplied_bug1
},
701 {"user_supplied_bug2", 0, user_supplied_bug1
},
705 if ((test_to_run
&& !strcmp(test_to_run
, "block")) || !test_to_run
)
707 fprintf(stderr
, "\nBlock tests\n\n");
708 for (x
= 0; tests
[x
].function_name
; x
++)
711 if (strcmp(wildcard
, tests
[x
].function_name
))
716 struct timeval start_time
, end_time
;
718 memc
= memcached_create(NULL
);
721 rc
= memcached_server_push(memc
, servers
);
722 assert(rc
== MEMCACHED_SUCCESS
);
725 for (loop
= 0; loop
< memcached_server_list_count(servers
); loop
++)
727 assert(memc
->hosts
[loop
].stack_responses
== 0);
728 assert(memc
->hosts
[loop
].fd
== -1);
729 assert(memc
->hosts
[loop
].cursor_active
== 0);
732 fprintf(stderr
, "Testing %s", tests
[x
].function_name
);
733 gettimeofday(&start_time
, NULL
);
734 tests
[x
].function(memc
);
735 gettimeofday(&end_time
, NULL
);
736 long int load_time
= timedif(end_time
, start_time
);
737 fprintf(stderr
, "\t\t\t\t\t %ld.%03ld [ ok ]\n", load_time
/ 1000,
740 memcached_free(memc
);
744 if ((test_to_run
&& !strcmp(test_to_run
, "nonblock")) || !test_to_run
)
746 fprintf(stderr
, "\nNonblock tests\n\n");
747 for (x
= 0; tests
[x
].function_name
; x
++)
750 if (strcmp(wildcard
, tests
[x
].function_name
))
755 struct timeval start_time
, end_time
;
757 memc
= memcached_create(NULL
);
760 rc
= memcached_server_push(memc
, servers
);
761 assert(rc
== MEMCACHED_SUCCESS
);
763 fprintf(stderr
, "Testing %s", tests
[x
].function_name
);
764 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NO_BLOCK
, NULL
);
765 gettimeofday(&start_time
, NULL
);
766 tests
[x
].function(memc
);
767 gettimeofday(&end_time
, NULL
);
768 long int load_time
= timedif(end_time
, start_time
);
769 fprintf(stderr
, "\t\t\t\t\t %ld.%03ld [ ok ]\n", load_time
/ 1000,
772 memcached_free(memc
);
776 if ((test_to_run
&& !strcmp(test_to_run
, "nodelay")) || !test_to_run
)
778 fprintf(stderr
, "\nTCP Nodelay tests\n\n");
779 for (x
= 0; tests
[x
].function_name
; x
++)
782 if (strcmp(wildcard
, tests
[x
].function_name
))
787 struct timeval start_time
, end_time
;
789 memc
= memcached_create(NULL
);
792 rc
= memcached_server_push(memc
, servers
);
793 assert(rc
== MEMCACHED_SUCCESS
);
795 fprintf(stderr
, "Testing %s", tests
[x
].function_name
);
796 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NO_BLOCK
, NULL
);
797 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_TCP_NODELAY
, NULL
);
798 gettimeofday(&start_time
, NULL
);
799 tests
[x
].function(memc
);
800 gettimeofday(&end_time
, NULL
);
801 long int load_time
= timedif(end_time
, start_time
);
802 fprintf(stderr
, "\t\t\t\t\t %ld.%03ld [ ok ]\n", load_time
/ 1000,
805 memcached_free(memc
);
809 if ((test_to_run
&& !strcmp(test_to_run
, "md5")) || !test_to_run
)
811 fprintf(stderr
, "\nMD5 Hashing\n\n");
812 for (x
= 0; tests
[x
].function_name
; x
++)
815 if (strcmp(wildcard
, tests
[x
].function_name
))
820 struct timeval start_time
, end_time
;
822 memc
= memcached_create(NULL
);
825 rc
= memcached_server_push(memc
, servers
);
826 assert(rc
== MEMCACHED_SUCCESS
);
828 fprintf(stderr
, "Testing %s", tests
[x
].function_name
);
829 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_MD5_HASHING
, NULL
);
830 gettimeofday(&start_time
, NULL
);
831 tests
[x
].function(memc
);
832 gettimeofday(&end_time
, NULL
);
833 long int load_time
= timedif(end_time
, start_time
);
834 fprintf(stderr
, "\t\t\t\t\t %ld.%03ld [ ok ]\n", load_time
/ 1000,
837 memcached_free(memc
);
841 if ((test_to_run
&& !strcmp(test_to_run
, "user")) || !test_to_run
)
843 fprintf(stderr
, "\nUser Supplied tests\n\n");
844 for (x
= 0; user_tests
[x
].function_name
; x
++)
847 if (strcmp(wildcard
, tests
[x
].function_name
))
852 struct timeval start_time
, end_time
;
854 memc
= memcached_create(NULL
);
857 rc
= memcached_server_push(memc
, servers
);
858 assert(rc
== MEMCACHED_SUCCESS
);
860 fprintf(stderr
, "Testing %s", user_tests
[x
].function_name
);
861 gettimeofday(&start_time
, NULL
);
862 user_tests
[x
].function(memc
);
863 gettimeofday(&end_time
, NULL
);
864 long int load_time
= timedif(end_time
, start_time
);
865 fprintf(stderr
, "\t\t\t\t\t %ld.%03ld [ ok ]\n", load_time
/ 1000,
868 memcached_free(memc
);
872 /* Clean up whatever we might have left */
875 memc
= memcached_create(NULL
);
878 memcached_free(memc
);
881 fprintf(stderr
, "All tests completed successfully\n\n");