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 WATCHPOINT_ERROR(rc
);
106 assert(rc
== MEMCACHED_SUCCESS
);
109 void flush_test(memcached_st
*memc
)
113 rc
= memcached_flush(memc
, 0);
114 assert(rc
== MEMCACHED_SUCCESS
);
117 void get_test(memcached_st
*memc
)
122 size_t string_length
;
125 string
= memcached_get(memc
, key
, strlen(key
),
126 &string_length
, &flags
, &rc
);
128 assert(rc
== MEMCACHED_NOTFOUND
);
129 assert(string_length
== 0);
133 void get_test2(memcached_st
*memc
)
137 char *value
= "when we sanitize";
139 size_t string_length
;
142 rc
= memcached_set(memc
, key
, strlen(key
),
143 value
, strlen(value
),
144 (time_t)0, (uint16_t)0);
145 assert(rc
== MEMCACHED_SUCCESS
);
147 string
= memcached_get(memc
, key
, strlen(key
),
148 &string_length
, &flags
, &rc
);
151 assert(rc
== MEMCACHED_SUCCESS
);
152 assert(string_length
== strlen(value
));
153 assert(!memcmp(string
, value
, string_length
));
158 void set_test2(memcached_st
*memc
)
162 char *value
= "train in the brain";
163 size_t value_length
= strlen(value
);
166 for (x
= 0; x
< 10; x
++)
168 rc
= memcached_set(memc
, key
, strlen(key
),
170 (time_t)0, (uint16_t)0);
171 assert(rc
== MEMCACHED_SUCCESS
);
175 void set_test3(memcached_st
*memc
)
180 size_t value_length
= 8191;
183 value
= (char*)malloc(value_length
);
186 for (x
= 0; x
< value_length
; x
++)
187 value
[x
] = (char) (x
% 127);
189 for (x
= 0; x
< 1; x
++)
191 rc
= memcached_set(memc
, key
, strlen(key
),
193 (time_t)0, (uint16_t)0);
194 assert(rc
== MEMCACHED_SUCCESS
);
200 void get_test3(memcached_st
*memc
)
205 size_t value_length
= 8191;
207 size_t string_length
;
211 value
= (char*)malloc(value_length
);
214 for (x
= 0; x
< value_length
; x
++)
215 value
[x
] = (char) (x
% 127);
217 rc
= memcached_set(memc
, key
, strlen(key
),
219 (time_t)0, (uint16_t)0);
220 assert(rc
== MEMCACHED_SUCCESS
);
222 string
= memcached_get(memc
, key
, strlen(key
),
223 &string_length
, &flags
, &rc
);
225 WATCHPOINT_ERRNO(memc
->my_errno
);
226 WATCHPOINT_ERROR(rc
);
227 assert(rc
== MEMCACHED_SUCCESS
);
229 assert(string_length
== value_length
);
230 assert(!memcmp(string
, value
, string_length
));
236 void get_test4(memcached_st
*memc
)
241 size_t value_length
= 8191;
243 size_t string_length
;
247 value
= (char*)malloc(value_length
);
250 for (x
= 0; x
< value_length
; x
++)
251 value
[x
] = (char) (x
% 127);
253 rc
= memcached_set(memc
, key
, strlen(key
),
255 (time_t)0, (uint16_t)0);
256 assert(rc
== MEMCACHED_SUCCESS
);
258 for (x
= 0; x
< 10; x
++)
260 string
= memcached_get(memc
, key
, strlen(key
),
261 &string_length
, &flags
, &rc
);
263 assert(rc
== MEMCACHED_SUCCESS
);
265 assert(string_length
== value_length
);
266 assert(!memcmp(string
, value
, string_length
));
273 void stats_servername_test(memcached_st
*memc
)
276 memcached_stat_st stat
;
277 rc
= memcached_stat_servername(&stat
, NULL
,
279 MEMCACHED_DEFAULT_PORT
);
282 void increment_test(memcached_st
*memc
)
284 unsigned int new_number
;
289 rc
= memcached_set(memc
, key
, strlen(key
),
290 value
, strlen(value
),
291 (time_t)0, (uint16_t)0);
292 assert(rc
== MEMCACHED_SUCCESS
);
294 rc
= memcached_increment(memc
, key
, strlen(key
),
296 assert(rc
== MEMCACHED_SUCCESS
);
297 assert(new_number
== 1);
299 rc
= memcached_increment(memc
, key
, strlen(key
),
301 assert(rc
== MEMCACHED_SUCCESS
);
302 assert(new_number
== 2);
305 void decrement_test(memcached_st
*memc
)
307 unsigned int new_number
;
312 rc
= memcached_set(memc
, key
, strlen(key
),
313 value
, strlen(value
),
314 (time_t)0, (uint16_t)0);
315 assert(rc
== MEMCACHED_SUCCESS
);
317 rc
= memcached_decrement(memc
, key
, strlen(key
),
319 assert(rc
== MEMCACHED_SUCCESS
);
320 assert(new_number
== 2);
322 rc
= memcached_decrement(memc
, key
, strlen(key
),
324 assert(rc
== MEMCACHED_SUCCESS
);
325 assert(new_number
== 1);
328 void quit_test(memcached_st
*memc
)
332 char *value
= "sanford and sun";
334 rc
= memcached_set(memc
, key
, strlen(key
),
335 value
, strlen(value
),
336 (time_t)10, (uint16_t)3);
337 assert(rc
== MEMCACHED_SUCCESS
);
338 memcached_quit(memc
);
340 rc
= memcached_set(memc
, key
, strlen(key
),
341 value
, strlen(value
),
342 (time_t)50, (uint16_t)9);
343 assert(rc
== MEMCACHED_SUCCESS
);
346 void mget_test(memcached_st
*memc
)
349 char *keys
[]= {"fudge", "son", "food"};
350 size_t key_length
[]= {5, 3, 4};
354 char return_key
[MEMCACHED_MAX_KEY
];
355 size_t return_key_length
;
357 size_t return_value_length
;
359 /* We need to empty the server before continueing test */
360 rc
= memcached_flush(memc
, 0);
361 assert(rc
== MEMCACHED_SUCCESS
);
363 rc
= memcached_mget(memc
, keys
, key_length
, 3);
364 assert(rc
== MEMCACHED_SUCCESS
);
366 while ((return_value
= memcached_fetch(memc
, return_key
, &return_key_length
,
367 &return_value_length
, &flags
, &rc
)) != NULL
)
369 assert(return_value
);
371 assert(!return_value
);
372 assert(return_value_length
== 0);
373 assert(rc
== MEMCACHED_NOTFOUND
);
375 for (x
= 0; x
< 3; x
++)
377 rc
= memcached_set(memc
, keys
[x
], key_length
[x
],
378 keys
[x
], key_length
[x
],
379 (time_t)50, (uint16_t)9);
380 assert(rc
== MEMCACHED_SUCCESS
);
383 rc
= memcached_mget(memc
, keys
, key_length
, 3);
384 assert(rc
== MEMCACHED_SUCCESS
);
387 while ((return_value
= memcached_fetch(memc
, return_key
, &return_key_length
,
388 &return_value_length
, &flags
, &rc
)))
390 assert(return_value
);
391 assert(rc
== MEMCACHED_SUCCESS
);
392 assert(return_key_length
== return_value_length
);
393 assert(!memcmp(return_value
, return_key
, return_value_length
));
399 void get_stats_keys(memcached_st
*memc
)
403 memcached_stat_st stat
;
406 list
= memcached_stat_get_keys(memc
, &stat
, &rc
);
407 assert(rc
== MEMCACHED_SUCCESS
);
408 for (ptr
= list
; *ptr
; ptr
++)
409 printf("Found key %s\n", *ptr
);
415 void get_stats(memcached_st
*memc
)
421 memcached_stat_st
*stat
;
423 stat
= memcached_stat(memc
, NULL
, &rc
);
424 assert(rc
== MEMCACHED_SUCCESS
);
426 assert(rc
== MEMCACHED_SUCCESS
);
429 for (x
= 0; x
< memcached_server_count(memc
); x
++)
431 list
= memcached_stat_get_keys(memc
, &stat
[x
], &rc
);
432 assert(rc
== MEMCACHED_SUCCESS
);
433 for (ptr
= list
; *ptr
; ptr
++)
434 printf("Found key %s\n", *ptr
);
442 void add_host_test(memcached_st
*memc
)
445 memcached_server_st
*servers
;
447 char servername
[]= "0.example.com";
449 servers
= memcached_server_list_append(NULL
, servername
, 400, &rc
);
451 assert(1 == memcached_server_list_count(servers
));
453 for (x
= 2; x
< 20; x
++)
455 char buffer
[SMALL_STRING_LEN
];
457 snprintf(buffer
, SMALL_STRING_LEN
, "%u.example.com", 400+x
);
458 servers
= memcached_server_list_append(servers
, buffer
, 401,
460 assert(rc
== MEMCACHED_SUCCESS
);
461 assert(x
== memcached_server_list_count(servers
));
464 rc
= memcached_server_push(memc
, servers
);
465 assert(rc
== MEMCACHED_SUCCESS
);
466 rc
= memcached_server_push(memc
, servers
);
467 assert(rc
== MEMCACHED_SUCCESS
);
469 memcached_server_list_free(servers
);
472 /* We don't test the behavior itself, we test the switches */
473 void behavior_test(memcached_st
*memc
)
475 unsigned long long value
;
478 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NO_BLOCK
, &set
);
479 value
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_NO_BLOCK
);
482 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_TCP_NODELAY
, &set
);
483 value
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_TCP_NODELAY
);
486 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_MD5_HASHING
, &set
);
487 value
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_MD5_HASHING
);
492 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NO_BLOCK
, &set
);
493 value
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_NO_BLOCK
);
496 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_TCP_NODELAY
, &set
);
497 value
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_TCP_NODELAY
);
500 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_MD5_HASHING
, &set
);
501 value
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_MD5_HASHING
);
505 /* Test case provided by Cal Haldenbrand */
506 void user_supplied_bug1(memcached_st
*memc
)
508 unsigned int setter
= 1;
515 char *randomstuff
= (char *)malloc(6 * 1024);
516 memset(randomstuff
, 0, 6 * 1024);
520 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NO_BLOCK
, &setter
);
521 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_TCP_NODELAY
, &setter
);
525 for (x
= 0 ; total
< 20 * 1024576 ; x
++ )
529 size
= (rand() % ( 5 * 1024 ) ) + 400;
530 memset(randomstuff
, 0, 6 * 1024);
531 assert(size
< 6 * 1024); /* Being safe here */
533 for (j
= 0 ; j
< size
;j
++)
534 randomstuff
[j
] = (char) (rand() % 26) + 97;
537 sprintf(key
, "%d", x
);
538 rc
= memcached_set(memc
, key
, strlen(key
),
539 randomstuff
, strlen(randomstuff
), 10, 0);
540 /* If we fail, lets try again */
541 if (rc
!= MEMCACHED_SUCCESS
)
542 rc
= memcached_set(memc
, key
, strlen(key
),
543 randomstuff
, strlen(randomstuff
), 10, 0);
544 assert(rc
== MEMCACHED_SUCCESS
);
547 void add_host_test1(memcached_st
*memc
)
551 char servername
[]= "0.example.com";
552 memcached_server_st
*servers
;
554 servers
= memcached_server_list_append(NULL
, servername
, 400, &rc
);
556 assert(1 == memcached_server_list_count(servers
));
558 for (x
= 2; x
< 20; x
++)
560 char buffer
[SMALL_STRING_LEN
];
562 snprintf(buffer
, SMALL_STRING_LEN
, "%u.example.com", 400+x
);
563 servers
= memcached_server_list_append(servers
, buffer
, 401,
565 assert(rc
== MEMCACHED_SUCCESS
);
566 assert(x
== memcached_server_list_count(servers
));
569 rc
= memcached_server_push(memc
, servers
);
570 assert(rc
== MEMCACHED_SUCCESS
);
571 rc
= memcached_server_push(memc
, servers
);
572 assert(rc
== MEMCACHED_SUCCESS
);
574 memcached_server_list_free(servers
);
577 typedef struct test_st test_st
;
581 unsigned int requires_flush
;
582 void (*function
)(memcached_st
*memc
);
585 int main(int argc
, char *argv
[])
589 char *test_to_run
= NULL
;
590 char *wildcard
= NULL
;
591 memcached_server_st
*servers
;
594 test_to_run
= argv
[1];
599 if (!(server_list
= getenv("MEMCACHED_SERVERS")))
600 server_list
= "localhost";
602 printf("servers %s\n", server_list
);
605 servers
= memcached_servers_parse(server_list
);
608 for (x
= 0; x
< memcached_server_list_count(servers
); x
++)
610 printf("\t%s : %u\n", servers
[x
].hostname
, servers
[x
].port
);
611 assert(servers
[x
].stack_responses
== 0);
612 assert(servers
[x
].fd
== -1);
613 assert(servers
[x
].cursor_active
== 0);
618 /* Clean the server before beginning testing */
620 {"flush", 0, flush_test
},
621 {"init", 0, init_test
},
622 {"allocation", 0, allocation_test
},
623 {"error", 0, error_test
},
624 {"set", 0, set_test
},
625 {"set2", 0, set_test2
},
626 {"set3", 0, set_test3
},
627 {"add", 0, add_test
},
628 {"replace", 0, replace_test
},
629 {"delete", 1, delete_test
},
630 {"get", 0, get_test
},
631 {"get2", 0, get_test2
},
632 {"get3", 0, get_test3
},
633 {"get4", 0, get_test4
},
634 {"stats_servername", 0, stats_servername_test
},
635 {"increment", 0, increment_test
},
636 {"decrement", 0, decrement_test
},
637 {"quit", 0, quit_test
},
638 {"mget", 0, mget_test
},
639 {"get_stats", 0, get_stats
},
640 {"add_host_test", 0, add_host_test
},
641 {"get_stats_keys", 0, get_stats_keys
},
642 {"behavior_test", 0, get_stats_keys
},
646 test_st user_tests
[] ={
647 {"user_supplied_bug1", 0, user_supplied_bug1
},
651 if ((test_to_run
&& !strcmp(test_to_run
, "block")) || !test_to_run
)
653 fprintf(stderr
, "\nBlock tests\n\n");
654 for (x
= 0; tests
[x
].function_name
; x
++)
657 if (strcmp(wildcard
, tests
[x
].function_name
))
662 struct timeval start_time
, end_time
;
664 memc
= memcached_create(NULL
);
667 rc
= memcached_server_push(memc
, servers
);
668 assert(rc
== MEMCACHED_SUCCESS
);
671 for (loop
= 0; loop
< memcached_server_list_count(servers
); loop
++)
673 assert(memc
->hosts
[loop
].stack_responses
== 0);
674 assert(memc
->hosts
[loop
].fd
== -1);
675 assert(memc
->hosts
[loop
].cursor_active
== 0);
678 fprintf(stderr
, "Testing %s", tests
[x
].function_name
);
679 gettimeofday(&start_time
, NULL
);
680 tests
[x
].function(memc
);
681 gettimeofday(&end_time
, NULL
);
682 long int load_time
= timedif(end_time
, start_time
);
683 fprintf(stderr
, "\t\t\t\t\t %ld.%03ld [ ok ]\n", load_time
/ 1000,
686 memcached_free(memc
);
690 if ((test_to_run
&& !strcmp(test_to_run
, "nonblock")) || !test_to_run
)
692 fprintf(stderr
, "\nNonblock tests\n\n");
693 for (x
= 0; tests
[x
].function_name
; x
++)
696 if (strcmp(wildcard
, tests
[x
].function_name
))
701 struct timeval start_time
, end_time
;
703 memc
= memcached_create(NULL
);
706 rc
= memcached_server_push(memc
, servers
);
707 assert(rc
== MEMCACHED_SUCCESS
);
709 fprintf(stderr
, "Testing %s", tests
[x
].function_name
);
710 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NO_BLOCK
, NULL
);
711 gettimeofday(&start_time
, NULL
);
712 tests
[x
].function(memc
);
713 gettimeofday(&end_time
, NULL
);
714 long int load_time
= timedif(end_time
, start_time
);
715 fprintf(stderr
, "\t\t\t\t\t %ld.%03ld [ ok ]\n", load_time
/ 1000,
718 memcached_free(memc
);
722 if ((test_to_run
&& !strcmp(test_to_run
, "nodelay")) || !test_to_run
)
724 fprintf(stderr
, "\nTCP Nodelay tests\n\n");
725 for (x
= 0; tests
[x
].function_name
; x
++)
728 if (strcmp(wildcard
, tests
[x
].function_name
))
733 struct timeval start_time
, end_time
;
735 memc
= memcached_create(NULL
);
738 rc
= memcached_server_push(memc
, servers
);
739 assert(rc
== MEMCACHED_SUCCESS
);
741 fprintf(stderr
, "Testing %s", tests
[x
].function_name
);
742 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NO_BLOCK
, NULL
);
743 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_TCP_NODELAY
, NULL
);
744 gettimeofday(&start_time
, NULL
);
745 tests
[x
].function(memc
);
746 gettimeofday(&end_time
, NULL
);
747 long int load_time
= timedif(end_time
, start_time
);
748 fprintf(stderr
, "\t\t\t\t\t %ld.%03ld [ ok ]\n", load_time
/ 1000,
751 memcached_free(memc
);
755 if ((test_to_run
&& !strcmp(test_to_run
, "md5")) || !test_to_run
)
757 fprintf(stderr
, "\nMD5 Hashing\n\n");
758 for (x
= 0; tests
[x
].function_name
; x
++)
761 if (strcmp(wildcard
, tests
[x
].function_name
))
766 struct timeval start_time
, end_time
;
768 memc
= memcached_create(NULL
);
771 rc
= memcached_server_push(memc
, servers
);
772 assert(rc
== MEMCACHED_SUCCESS
);
774 fprintf(stderr
, "Testing %s", tests
[x
].function_name
);
775 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_MD5_HASHING
, NULL
);
776 gettimeofday(&start_time
, NULL
);
777 tests
[x
].function(memc
);
778 gettimeofday(&end_time
, NULL
);
779 long int load_time
= timedif(end_time
, start_time
);
780 fprintf(stderr
, "\t\t\t\t\t %ld.%03ld [ ok ]\n", load_time
/ 1000,
783 memcached_free(memc
);
787 if ((test_to_run
&& !strcmp(test_to_run
, "user")) || !test_to_run
)
789 fprintf(stderr
, "\nUser Supplied tests\n\n");
790 for (x
= 0; user_tests
[x
].function_name
; x
++)
793 if (strcmp(wildcard
, tests
[x
].function_name
))
798 struct timeval start_time
, end_time
;
800 memc
= memcached_create(NULL
);
803 rc
= memcached_server_push(memc
, servers
);
804 assert(rc
== MEMCACHED_SUCCESS
);
806 fprintf(stderr
, "Testing %s", user_tests
[x
].function_name
);
807 gettimeofday(&start_time
, NULL
);
808 user_tests
[x
].function(memc
);
809 gettimeofday(&end_time
, NULL
);
810 long int load_time
= timedif(end_time
, start_time
);
811 fprintf(stderr
, "\t\t\t\t\t %ld.%03ld [ ok ]\n", load_time
/ 1000,
814 memcached_free(memc
);
818 /* Clean up whatever we might have left */
821 memc
= memcached_create(NULL
);
824 memcached_free(memc
);
827 fprintf(stderr
, "All tests completed successfully\n\n");