2 Sample test application.
10 void init_test(memcached_st
*not_used
)
14 (void)memcached_create(&memc
);
15 memcached_free(&memc
);
18 void allocation_test(memcached_st
*not_used
)
21 memc
= memcached_create(NULL
);
26 void connection_test(memcached_st
*memc
)
30 rc
= memcached_server_add(memc
, "localhost", 0);
31 assert(rc
== MEMCACHED_SUCCESS
);
34 void error_test(memcached_st
*memc
)
38 for (rc
= MEMCACHED_SUCCESS
; rc
< MEMCACHED_MAXIMUM_RETURN
; rc
++)
40 printf("Error %d -> %s\n", rc
, memcached_strerror(memc
, rc
));
44 void set_test(memcached_st
*memc
)
48 char *value
= "when we sanitize";
50 rc
= memcached_set(memc
, key
, strlen(key
),
52 (time_t)0, (uint16_t)0);
53 assert(rc
== MEMCACHED_SUCCESS
);
56 void add_test(memcached_st
*memc
)
60 char *value
= "when we sanitize";
62 rc
= memcached_add(memc
, key
, strlen(key
),
64 (time_t)0, (uint16_t)0);
65 assert(rc
== MEMCACHED_NOTSTORED
);
68 void replace_test(memcached_st
*memc
)
72 char *value
= "when we sanitize";
74 rc
= memcached_replace(memc
, key
, strlen(key
),
76 (time_t)0, (uint16_t)0);
77 assert(rc
== MEMCACHED_SUCCESS
);
80 void delete_test(memcached_st
*memc
)
84 char *value
= "when we sanitize";
86 rc
= memcached_set(memc
, key
, strlen(key
),
88 (time_t)0, (uint16_t)0);
89 assert(rc
== MEMCACHED_SUCCESS
);
91 rc
= memcached_delete(memc
, key
, strlen(key
), (time_t)0);
92 assert(rc
== MEMCACHED_SUCCESS
);
95 void flush_test(memcached_st
*memc
)
99 rc
= memcached_flush(memc
, 0);
100 assert(rc
== MEMCACHED_SUCCESS
);
103 void get_test(memcached_st
*memc
)
108 size_t string_length
;
111 string
= memcached_get(memc
, key
, strlen(key
),
112 &string_length
, &flags
, &rc
);
114 assert(rc
== MEMCACHED_NOTFOUND
);
115 assert(string_length
== 0);
119 void get_test2(memcached_st
*memc
)
123 char *value
= "when we sanitize";
125 size_t string_length
;
128 rc
= memcached_set(memc
, key
, strlen(key
),
129 value
, strlen(value
),
130 (time_t)0, (uint16_t)0);
131 assert(rc
== MEMCACHED_SUCCESS
);
133 string
= memcached_get(memc
, key
, strlen(key
),
134 &string_length
, &flags
, &rc
);
137 assert(rc
== MEMCACHED_SUCCESS
);
138 assert(string_length
== strlen(value
));
139 assert(!memcmp(string
, value
, string_length
));
144 void set_test2(memcached_st
*memc
)
148 char *value
= "train in the brain";
149 size_t value_length
= strlen(value
);
152 for (x
= 0; x
< 10; x
++)
154 rc
= memcached_set(memc
, key
, strlen(key
),
156 (time_t)0, (uint16_t)0);
157 assert(rc
== MEMCACHED_SUCCESS
);
161 void set_test3(memcached_st
*memc
)
166 size_t value_length
= 8191;
169 value
= (char*)malloc(value_length
);
172 for (x
= 0; x
< value_length
; x
++)
173 value
[x
] = (char) (x
% 127);
175 for (x
= 0; x
< 1; x
++)
177 rc
= memcached_set(memc
, key
, strlen(key
),
179 (time_t)0, (uint16_t)0);
180 assert(rc
== MEMCACHED_SUCCESS
);
186 void get_test3(memcached_st
*memc
)
191 size_t value_length
= 8191;
193 size_t string_length
;
197 value
= (char*)malloc(value_length
);
200 for (x
= 0; x
< value_length
; x
++)
201 value
[x
] = (char) (x
% 127);
203 rc
= memcached_set(memc
, key
, strlen(key
),
205 (time_t)0, (uint16_t)0);
206 assert(rc
== MEMCACHED_SUCCESS
);
208 string
= memcached_get(memc
, key
, strlen(key
),
209 &string_length
, &flags
, &rc
);
211 WATCHPOINT_ERRNO(memc
->my_errno
);
212 WATCHPOINT_ERROR(rc
);
213 assert(rc
== MEMCACHED_SUCCESS
);
215 assert(string_length
== value_length
);
216 assert(!memcmp(string
, value
, string_length
));
222 void get_test4(memcached_st
*memc
)
227 size_t value_length
= 8191;
229 size_t string_length
;
233 value
= (char*)malloc(value_length
);
236 for (x
= 0; x
< value_length
; x
++)
237 value
[x
] = (char) (x
% 127);
239 rc
= memcached_set(memc
, key
, strlen(key
),
241 (time_t)0, (uint16_t)0);
242 assert(rc
== MEMCACHED_SUCCESS
);
244 for (x
= 0; x
< 10; x
++)
246 string
= memcached_get(memc
, key
, strlen(key
),
247 &string_length
, &flags
, &rc
);
249 assert(rc
== MEMCACHED_SUCCESS
);
251 assert(string_length
== value_length
);
252 assert(!memcmp(string
, value
, string_length
));
259 void stats_servername_test(memcached_st
*memc
)
262 memcached_stat_st stat
;
263 rc
= memcached_stat_servername(&stat
, NULL
,
265 MEMCACHED_DEFAULT_PORT
);
268 void increment_test(memcached_st
*memc
)
270 unsigned int new_number
;
275 rc
= memcached_set(memc
, key
, strlen(key
),
276 value
, strlen(value
),
277 (time_t)0, (uint16_t)0);
278 assert(rc
== MEMCACHED_SUCCESS
);
280 rc
= memcached_increment(memc
, key
, strlen(key
),
282 assert(rc
== MEMCACHED_SUCCESS
);
283 assert(new_number
== 1);
285 rc
= memcached_increment(memc
, key
, strlen(key
),
287 assert(rc
== MEMCACHED_SUCCESS
);
288 assert(new_number
== 2);
291 void decrement_test(memcached_st
*memc
)
293 unsigned int new_number
;
298 rc
= memcached_set(memc
, key
, strlen(key
),
299 value
, strlen(value
),
300 (time_t)0, (uint16_t)0);
301 assert(rc
== MEMCACHED_SUCCESS
);
303 rc
= memcached_decrement(memc
, key
, strlen(key
),
305 assert(rc
== MEMCACHED_SUCCESS
);
306 assert(new_number
== 2);
308 rc
= memcached_decrement(memc
, key
, strlen(key
),
310 assert(rc
== MEMCACHED_SUCCESS
);
311 assert(new_number
== 1);
314 void quit_test(memcached_st
*memc
)
318 char *value
= "sanford and sun";
320 rc
= memcached_set(memc
, key
, strlen(key
),
321 value
, strlen(value
),
322 (time_t)10, (uint16_t)3);
323 assert(rc
== MEMCACHED_SUCCESS
);
324 memcached_quit(memc
);
326 rc
= memcached_set(memc
, key
, strlen(key
),
327 value
, strlen(value
),
328 (time_t)50, (uint16_t)9);
329 assert(rc
== MEMCACHED_SUCCESS
);
332 void mget_test(memcached_st
*memc
)
335 char *keys
[]= {"fudge", "son", "food"};
336 size_t key_length
[]= {5, 3, 4};
340 char return_key
[MEMCACHED_MAX_KEY
];
341 size_t return_key_length
;
343 size_t return_value_length
;
345 /* We need to empty the server before continueing test */
346 rc
= memcached_flush(memc
, 0);
347 assert(rc
== MEMCACHED_SUCCESS
);
349 rc
= memcached_mget(memc
, keys
, key_length
, 3);
350 assert(rc
== MEMCACHED_SUCCESS
);
352 while ((return_value
= memcached_fetch(memc
, return_key
, &return_key_length
,
353 &return_value_length
, &flags
, &rc
)) != NULL
)
355 assert(return_value
);
357 assert(!return_value
);
358 assert(return_value_length
== 0);
359 assert(rc
== MEMCACHED_NOTFOUND
);
361 for (x
= 0; x
< 3; x
++)
363 rc
= memcached_set(memc
, keys
[x
], key_length
[x
],
364 keys
[x
], key_length
[x
],
365 (time_t)50, (uint16_t)9);
366 assert(rc
== MEMCACHED_SUCCESS
);
369 rc
= memcached_mget(memc
, keys
, key_length
, 3);
370 assert(rc
== MEMCACHED_SUCCESS
);
373 while ((return_value
= memcached_fetch(memc
, return_key
, &return_key_length
,
374 &return_value_length
, &flags
, &rc
)))
376 assert(return_value
);
377 assert(rc
== MEMCACHED_SUCCESS
);
378 assert(return_key_length
== return_value_length
);
379 assert(!memcmp(return_value
, return_key
, return_value_length
));
385 void get_stats_keys(memcached_st
*memc
)
389 memcached_stat_st stat
;
392 list
= memcached_stat_get_keys(memc
, &stat
, &rc
);
393 assert(rc
== MEMCACHED_SUCCESS
);
394 for (ptr
= list
; *ptr
; ptr
++)
395 printf("Found key %s\n", *ptr
);
401 void get_stats(memcached_st
*memc
)
407 memcached_stat_st
*stat
;
409 stat
= memcached_stat(memc
, NULL
, &rc
);
410 assert(rc
== MEMCACHED_SUCCESS
);
412 assert(rc
== MEMCACHED_SUCCESS
);
415 for (x
= 0; x
< memcached_server_count(memc
); x
++)
417 list
= memcached_stat_get_keys(memc
, &stat
[x
], &rc
);
418 assert(rc
== MEMCACHED_SUCCESS
);
419 for (ptr
= list
; *ptr
; ptr
++)
420 printf("Found key %s\n", *ptr
);
428 void add_host_test(memcached_st
*memc
)
431 memcached_server_st
*servers
;
433 char servername
[]= "0.example.com";
435 servers
= memcached_server_list_append(NULL
, servername
, 400, &rc
);
437 assert(1 == memcached_server_list_count(servers
));
439 for (x
= 2; x
< 20; x
++)
441 char buffer
[SMALL_STRING_LEN
];
443 snprintf(buffer
, SMALL_STRING_LEN
, "%u.example.com", 400+x
);
444 servers
= memcached_server_list_append(servers
, buffer
, 401,
446 assert(rc
== MEMCACHED_SUCCESS
);
447 assert(x
== memcached_server_list_count(servers
));
450 rc
= memcached_server_push(memc
, servers
);
451 assert(rc
== MEMCACHED_SUCCESS
);
452 rc
= memcached_server_push(memc
, servers
);
453 assert(rc
== MEMCACHED_SUCCESS
);
455 memcached_server_list_free(servers
);
458 /* We don't test the behavior itself, we test the switches */
459 void behavior_test(memcached_st
*memc
)
461 unsigned long long value
;
464 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NO_BLOCK
, &set
);
465 value
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_NO_BLOCK
);
468 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_TCP_NODELAY
, &set
);
469 value
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_TCP_NODELAY
);
472 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_MD5_HASHING
, &set
);
473 value
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_MD5_HASHING
);
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
);
491 /* Test case provided by Cal Haldenbrand */
492 void user_supplied_bug1(memcached_st
*memc
)
494 unsigned int setter
= 1;
501 char *randomstuff
= (char *)malloc(6 * 1024);
502 memset(randomstuff
, 0, 6 * 1024);
506 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NO_BLOCK
, &setter
);
507 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_TCP_NODELAY
, &setter
);
511 for (x
= 0 ; total
< 20 * 1024576 ; x
++ )
515 size
= (rand() % ( 5 * 1024 ) ) + 400;
516 memset(randomstuff
, 0, 6 * 1024);
517 assert(size
< 6 * 1024); /* Being safe here */
519 for (j
= 0 ; j
< size
;j
++)
520 randomstuff
[j
] = (char) (rand() % 26) + 97;
523 sprintf(key
, "%d", x
);
524 rc
= memcached_set(memc
, key
, strlen(key
),
525 randomstuff
, strlen(randomstuff
), 10, 0);
526 /* If we fail, lets try again */
527 if (rc
!= MEMCACHED_SUCCESS
)
528 rc
= memcached_set(memc
, key
, strlen(key
),
529 randomstuff
, strlen(randomstuff
), 10, 0);
530 assert(rc
== MEMCACHED_SUCCESS
);
533 void add_host_test1(memcached_st
*memc
)
537 char servername
[]= "0.example.com";
538 memcached_server_st
*servers
;
540 servers
= memcached_server_list_append(NULL
, servername
, 400, &rc
);
542 assert(1 == memcached_server_list_count(servers
));
544 for (x
= 2; x
< 20; x
++)
546 char buffer
[SMALL_STRING_LEN
];
548 snprintf(buffer
, SMALL_STRING_LEN
, "%u.example.com", 400+x
);
549 servers
= memcached_server_list_append(servers
, buffer
, 401,
551 assert(rc
== MEMCACHED_SUCCESS
);
552 assert(x
== memcached_server_list_count(servers
));
555 rc
= memcached_server_push(memc
, servers
);
556 assert(rc
== MEMCACHED_SUCCESS
);
557 rc
= memcached_server_push(memc
, servers
);
558 assert(rc
== MEMCACHED_SUCCESS
);
560 memcached_server_list_free(servers
);
563 typedef struct test_st test_st
;
567 unsigned int requires_flush
;
568 void (*function
)(memcached_st
*memc
);
571 int main(int argc
, char *argv
[])
575 char *wildcard
= NULL
;
576 memcached_server_st
*servers
;
581 if (!(server_list
= getenv("MEMCACHED_SERVERS")))
582 server_list
= "localhost";
584 printf("servers %s\n", server_list
);
587 servers
= memcached_servers_parse(server_list
);
590 for (x
= 0; x
< memcached_server_list_count(servers
); x
++)
592 printf("\t%s : %u\n", servers
[x
].hostname
, servers
[x
].port
);
593 assert(servers
[x
].stack_responses
== 0);
594 assert(servers
[x
].fd
== -1);
595 assert(servers
[x
].cursor_active
== 0);
600 /* Clean the server before beginning testing */
602 {"flush", 0, flush_test
},
603 {"init", 0, init_test
},
604 {"allocation", 0, allocation_test
},
605 {"error", 0, error_test
},
606 {"set", 0, set_test
},
607 {"set2", 0, set_test2
},
608 {"set3", 0, set_test3
},
609 {"add", 0, add_test
},
610 {"replace", 0, replace_test
},
611 {"delete", 1, delete_test
},
612 {"get", 0, get_test
},
613 {"get2", 0, get_test2
},
614 {"get3", 0, get_test3
},
615 {"get4", 0, get_test4
},
616 {"stats_servername", 0, stats_servername_test
},
617 {"increment", 0, increment_test
},
618 {"decrement", 0, decrement_test
},
619 {"quit", 0, quit_test
},
620 {"mget", 0, mget_test
},
621 {"get_stats", 0, get_stats
},
622 {"add_host_test", 0, add_host_test
},
623 {"get_stats_keys", 0, get_stats_keys
},
624 {"behavior_test", 0, get_stats_keys
},
628 test_st user_tests
[] ={
629 {"user_supplied_bug1", 0, user_supplied_bug1
},
633 fprintf(stderr
, "\nBlock tests\n\n");
634 for (x
= 0; tests
[x
].function_name
; x
++)
637 if (strcmp(wildcard
, tests
[x
].function_name
))
642 memc
= memcached_create(NULL
);
645 rc
= memcached_server_push(memc
, servers
);
646 assert(rc
== MEMCACHED_SUCCESS
);
649 for (loop
= 0; loop
< memcached_server_list_count(servers
); loop
++)
651 assert(memc
->hosts
[loop
].stack_responses
== 0);
652 assert(memc
->hosts
[loop
].fd
== -1);
653 assert(memc
->hosts
[loop
].cursor_active
== 0);
656 fprintf(stderr
, "Testing %s", tests
[x
].function_name
);
657 tests
[x
].function(memc
);
658 fprintf(stderr
, "\t\t\t\t\t[ ok ]\n");
660 memcached_free(memc
);
663 fprintf(stderr
, "\nNonblock tests\n\n");
664 for (x
= 0; tests
[x
].function_name
; x
++)
667 if (strcmp(wildcard
, tests
[x
].function_name
))
672 memc
= memcached_create(NULL
);
675 rc
= memcached_server_push(memc
, servers
);
676 assert(rc
== MEMCACHED_SUCCESS
);
678 fprintf(stderr
, "Testing %s", tests
[x
].function_name
);
679 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NO_BLOCK
, NULL
);
680 tests
[x
].function(memc
);
681 fprintf(stderr
, "\t\t\t\t\t[ ok ]\n");
683 memcached_free(memc
);
686 fprintf(stderr
, "\nTCP Nodelay tests\n\n");
687 for (x
= 0; tests
[x
].function_name
; x
++)
690 if (strcmp(wildcard
, tests
[x
].function_name
))
695 memc
= memcached_create(NULL
);
698 rc
= memcached_server_push(memc
, servers
);
699 assert(rc
== MEMCACHED_SUCCESS
);
701 fprintf(stderr
, "Testing %s", tests
[x
].function_name
);
702 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NO_BLOCK
, NULL
);
703 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_TCP_NODELAY
, NULL
);
704 tests
[x
].function(memc
);
705 fprintf(stderr
, "\t\t\t\t\t[ ok ]\n");
707 memcached_free(memc
);
710 fprintf(stderr
, "\nMD5 Hashing\n\n");
711 for (x
= 0; tests
[x
].function_name
; x
++)
714 if (strcmp(wildcard
, tests
[x
].function_name
))
719 memc
= memcached_create(NULL
);
722 rc
= memcached_server_push(memc
, servers
);
723 assert(rc
== MEMCACHED_SUCCESS
);
725 fprintf(stderr
, "Testing %s", tests
[x
].function_name
);
726 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_MD5_HASHING
, NULL
);
727 tests
[x
].function(memc
);
728 fprintf(stderr
, "\t\t\t\t\t[ ok ]\n");
730 memcached_free(memc
);
733 fprintf(stderr
, "\nUser Supplied tests\n\n");
734 for (x
= 0; user_tests
[x
].function_name
; x
++)
737 if (strcmp(wildcard
, tests
[x
].function_name
))
742 memc
= memcached_create(NULL
);
745 rc
= memcached_server_push(memc
, servers
);
746 assert(rc
== MEMCACHED_SUCCESS
);
748 fprintf(stderr
, "Testing %s", user_tests
[x
].function_name
);
749 user_tests
[x
].function(memc
);
750 fprintf(stderr
, "\t\t\t\t\t[ ok ]\n");
752 memcached_free(memc
);
755 /* Clean up whatever we might have left */
758 memc
= memcached_create(NULL
);
761 memcached_free(memc
);
764 fprintf(stderr
, "All tests completed successfully\n\n");