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 assert(rc
== MEMCACHED_SUCCESS
);
213 assert(string_length
== value_length
);
214 assert(!memcmp(string
, value
, string_length
));
220 void get_test4(memcached_st
*memc
)
225 size_t value_length
= 8191;
227 size_t string_length
;
231 value
= (char*)malloc(value_length
);
234 for (x
= 0; x
< value_length
; x
++)
235 value
[x
] = (char) (x
% 127);
237 rc
= memcached_set(memc
, key
, strlen(key
),
239 (time_t)0, (uint16_t)0);
240 assert(rc
== MEMCACHED_SUCCESS
);
242 for (x
= 0; x
< 10; x
++)
244 string
= memcached_get(memc
, key
, strlen(key
),
245 &string_length
, &flags
, &rc
);
247 assert(rc
== MEMCACHED_SUCCESS
);
249 assert(string_length
== value_length
);
250 assert(!memcmp(string
, value
, string_length
));
257 void stats_servername_test(memcached_st
*memc
)
260 memcached_stat_st stat
;
261 rc
= memcached_stat_servername(&stat
, NULL
,
263 MEMCACHED_DEFAULT_PORT
);
266 void increment_test(memcached_st
*memc
)
268 unsigned int new_number
;
273 rc
= memcached_set(memc
, key
, strlen(key
),
274 value
, strlen(value
),
275 (time_t)0, (uint16_t)0);
276 assert(rc
== MEMCACHED_SUCCESS
);
278 rc
= memcached_increment(memc
, key
, strlen(key
),
280 assert(rc
== MEMCACHED_SUCCESS
);
281 assert(new_number
== 1);
283 rc
= memcached_increment(memc
, key
, strlen(key
),
285 assert(rc
== MEMCACHED_SUCCESS
);
286 assert(new_number
== 2);
289 void decrement_test(memcached_st
*memc
)
291 unsigned int new_number
;
296 rc
= memcached_set(memc
, key
, strlen(key
),
297 value
, strlen(value
),
298 (time_t)0, (uint16_t)0);
299 assert(rc
== MEMCACHED_SUCCESS
);
301 rc
= memcached_decrement(memc
, key
, strlen(key
),
303 assert(rc
== MEMCACHED_SUCCESS
);
304 assert(new_number
== 2);
306 rc
= memcached_decrement(memc
, key
, strlen(key
),
308 assert(rc
== MEMCACHED_SUCCESS
);
309 assert(new_number
== 1);
312 void quit_test(memcached_st
*memc
)
316 char *value
= "sanford and sun";
318 rc
= memcached_set(memc
, key
, strlen(key
),
319 value
, strlen(value
),
320 (time_t)10, (uint16_t)3);
321 assert(rc
== MEMCACHED_SUCCESS
);
322 memcached_quit(memc
);
324 rc
= memcached_set(memc
, key
, strlen(key
),
325 value
, strlen(value
),
326 (time_t)50, (uint16_t)9);
327 assert(rc
== MEMCACHED_SUCCESS
);
330 void mget_test(memcached_st
*memc
)
333 char *keys
[]= {"fudge", "son", "food"};
334 size_t key_length
[]= {5, 3, 4};
338 char return_key
[MEMCACHED_MAX_KEY
];
339 size_t return_key_length
;
341 size_t return_value_length
;
343 /* We need to empty the server before continueing test */
344 rc
= memcached_flush(memc
, 0);
345 assert(rc
== MEMCACHED_SUCCESS
);
347 rc
= memcached_mget(memc
, keys
, key_length
, 3);
348 assert(rc
== MEMCACHED_SUCCESS
);
350 while ((return_value
= memcached_fetch(memc
, return_key
, &return_key_length
,
351 &return_value_length
, &flags
, &rc
)) != NULL
)
353 assert(return_value
);
355 assert(!return_value
);
356 assert(return_value_length
== 0);
357 assert(rc
== MEMCACHED_NOTFOUND
);
359 for (x
= 0; x
< 3; x
++)
361 rc
= memcached_set(memc
, keys
[x
], key_length
[x
],
362 keys
[x
], key_length
[x
],
363 (time_t)50, (uint16_t)9);
364 assert(rc
== MEMCACHED_SUCCESS
);
367 rc
= memcached_mget(memc
, keys
, key_length
, 3);
368 assert(rc
== MEMCACHED_SUCCESS
);
371 while ((return_value
= memcached_fetch(memc
, return_key
, &return_key_length
,
372 &return_value_length
, &flags
, &rc
)))
374 assert(return_value
);
375 assert(rc
== MEMCACHED_SUCCESS
);
376 assert(return_key_length
== return_value_length
);
377 assert(!memcmp(return_value
, return_key
, return_value_length
));
383 void get_stats_keys(memcached_st
*memc
)
387 memcached_stat_st stat
;
390 list
= memcached_stat_get_keys(memc
, &stat
, &rc
);
391 assert(rc
== MEMCACHED_SUCCESS
);
392 for (ptr
= list
; *ptr
; ptr
++)
393 printf("Found key %s\n", *ptr
);
399 void get_stats(memcached_st
*memc
)
405 memcached_stat_st
*stat
;
407 stat
= memcached_stat(memc
, NULL
, &rc
);
408 assert(rc
== MEMCACHED_SUCCESS
);
410 assert(rc
== MEMCACHED_SUCCESS
);
413 for (x
= 0; x
< memcached_server_count(memc
); x
++)
415 list
= memcached_stat_get_keys(memc
, &stat
[x
], &rc
);
416 assert(rc
== MEMCACHED_SUCCESS
);
417 for (ptr
= list
; *ptr
; ptr
++)
418 printf("Found key %s\n", *ptr
);
426 void add_host_test(memcached_st
*memc
)
429 memcached_server_st
*servers
;
431 char servername
[]= "0.example.com";
433 servers
= memcached_server_list_append(NULL
, servername
, 400, &rc
);
435 assert(1 == memcached_server_list_count(servers
));
437 for (x
= 2; x
< 20; x
++)
439 char buffer
[SMALL_STRING_LEN
];
441 snprintf(buffer
, SMALL_STRING_LEN
, "%u.example.com", 400+x
);
442 servers
= memcached_server_list_append(servers
, buffer
, 401,
444 assert(rc
== MEMCACHED_SUCCESS
);
445 assert(x
== memcached_server_list_count(servers
));
448 rc
= memcached_server_push(memc
, servers
);
449 assert(rc
== MEMCACHED_SUCCESS
);
450 rc
= memcached_server_push(memc
, servers
);
451 assert(rc
== MEMCACHED_SUCCESS
);
453 memcached_server_list_free(servers
);
456 /* We don't test the behavior itself, we test the switches */
457 void behavior_test(memcached_st
*memc
)
459 unsigned long long value
;
462 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NO_BLOCK
, &set
);
463 value
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_NO_BLOCK
);
466 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_TCP_NODELAY
, &set
);
467 value
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_TCP_NODELAY
);
470 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_MD5_HASHING
, &set
);
471 value
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_MD5_HASHING
);
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
);
489 /* Test case provided by Cal Haldenbrand */
490 void user_supplied_bug1(memcached_st
*memc
)
492 unsigned int setter
= 1;
499 char *randomstuff
= (char *)malloc(6 * 1024);
500 memset(randomstuff
, 0, 6 * 1024);
504 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NO_BLOCK
, &setter
);
505 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_TCP_NODELAY
, &setter
);
509 for (x
= 0 ; total
< 20 * 1024576 ; x
++ )
513 size
= (rand() % ( 5 * 1024 ) ) + 400;
514 memset(randomstuff
, 0, 6 * 1024);
515 assert(size
< 6 * 1024); /* Being safe here */
517 for (j
= 0 ; j
< size
;j
++)
518 randomstuff
[j
] = (char) (rand() % 26) + 97;
521 sprintf(key
, "%d", x
);
522 rc
= memcached_set(memc
, key
, strlen(key
),
523 randomstuff
, strlen(randomstuff
), 10, 0);
524 /* If we fail, lets try again */
525 if (rc
!= MEMCACHED_SUCCESS
)
526 rc
= memcached_set(memc
, key
, strlen(key
),
527 randomstuff
, strlen(randomstuff
), 10, 0);
528 assert(rc
== MEMCACHED_SUCCESS
);
531 void add_host_test1(memcached_st
*memc
)
535 char servername
[]= "0.example.com";
536 memcached_server_st
*servers
;
538 servers
= memcached_server_list_append(NULL
, servername
, 400, &rc
);
540 assert(1 == memcached_server_list_count(servers
));
542 for (x
= 2; x
< 20; x
++)
544 char buffer
[SMALL_STRING_LEN
];
546 snprintf(buffer
, SMALL_STRING_LEN
, "%u.example.com", 400+x
);
547 servers
= memcached_server_list_append(servers
, buffer
, 401,
549 assert(rc
== MEMCACHED_SUCCESS
);
550 assert(x
== memcached_server_list_count(servers
));
553 rc
= memcached_server_push(memc
, servers
);
554 assert(rc
== MEMCACHED_SUCCESS
);
555 rc
= memcached_server_push(memc
, servers
);
556 assert(rc
== MEMCACHED_SUCCESS
);
558 memcached_server_list_free(servers
);
561 typedef struct test_st test_st
;
565 unsigned int requires_flush
;
566 void (*function
)(memcached_st
*memc
);
569 int main(int argc
, char *argv
[])
573 memcached_server_st
*servers
;
575 if (!(server_list
= getenv("MEMCACHED_SERVERS")))
576 server_list
= "localhost";
578 printf("servers %s\n", server_list
);
581 servers
= memcached_servers_parse(server_list
);
584 /* Clean the server before beginning testing */
586 {"flush", 0, flush_test
},
587 {"init", 0, init_test
},
588 {"allocation", 0, allocation_test
},
589 {"error", 0, error_test
},
590 {"set", 0, set_test
},
591 {"set2", 0, set_test2
},
592 {"set3", 0, set_test3
},
593 {"add", 0, add_test
},
594 {"replace", 0, replace_test
},
595 {"delete", 1, delete_test
},
596 {"get", 0, get_test
},
597 {"get2", 0, get_test2
},
598 {"get3", 0, get_test3
},
599 {"get4", 0, get_test4
},
600 {"stats_servername", 0, stats_servername_test
},
601 {"increment", 0, increment_test
},
602 {"decrement", 0, decrement_test
},
603 {"quit", 0, quit_test
},
604 {"mget", 0, mget_test
},
605 {"get_stats", 0, get_stats
},
606 {"add_host_test", 0, add_host_test
},
607 {"get_stats_keys", 0, get_stats_keys
},
608 {"behavior_test", 0, get_stats_keys
},
612 test_st user_tests
[] ={
613 {"user_supplied_bug1", 0, user_supplied_bug1
},
617 fprintf(stderr
, "\nBlock tests\n\n");
618 for (x
= 0; tests
[x
].function_name
; x
++)
622 memc
= memcached_create(NULL
);
625 rc
= memcached_server_push(memc
, servers
);
626 assert(rc
== MEMCACHED_SUCCESS
);
628 fprintf(stderr
, "Testing %s", tests
[x
].function_name
);
629 tests
[x
].function(memc
);
630 fprintf(stderr
, "\t\t\t\t\t[ ok ]\n");
632 memcached_free(memc
);
635 fprintf(stderr
, "\nNonblock tests\n\n");
636 for (x
= 0; tests
[x
].function_name
; x
++)
640 memc
= memcached_create(NULL
);
643 rc
= memcached_server_push(memc
, servers
);
644 assert(rc
== MEMCACHED_SUCCESS
);
646 fprintf(stderr
, "Testing %s", tests
[x
].function_name
);
647 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NO_BLOCK
, NULL
);
648 tests
[x
].function(memc
);
649 fprintf(stderr
, "\t\t\t\t\t[ ok ]\n");
651 memcached_free(memc
);
654 fprintf(stderr
, "\nTCP Nodelay tests\n\n");
655 for (x
= 0; tests
[x
].function_name
; x
++)
659 memc
= memcached_create(NULL
);
662 rc
= memcached_server_push(memc
, servers
);
663 assert(rc
== MEMCACHED_SUCCESS
);
665 fprintf(stderr
, "Testing %s", tests
[x
].function_name
);
666 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NO_BLOCK
, NULL
);
667 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_TCP_NODELAY
, NULL
);
668 tests
[x
].function(memc
);
669 fprintf(stderr
, "\t\t\t\t\t[ ok ]\n");
671 memcached_free(memc
);
674 fprintf(stderr
, "\nMD5 Hashing\n\n");
675 for (x
= 0; tests
[x
].function_name
; x
++)
679 memc
= memcached_create(NULL
);
682 rc
= memcached_server_push(memc
, servers
);
683 assert(rc
== MEMCACHED_SUCCESS
);
685 fprintf(stderr
, "Testing %s", tests
[x
].function_name
);
686 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_MD5_HASHING
, NULL
);
687 tests
[x
].function(memc
);
688 fprintf(stderr
, "\t\t\t\t\t[ ok ]\n");
690 memcached_free(memc
);
693 fprintf(stderr
, "\nUser Supplied tests\n\n");
694 for (x
= 0; user_tests
[x
].function_name
; x
++)
698 memc
= memcached_create(NULL
);
701 rc
= memcached_server_push(memc
, servers
);
702 assert(rc
== MEMCACHED_SUCCESS
);
704 fprintf(stderr
, "Testing %s", user_tests
[x
].function_name
);
705 user_tests
[x
].function(memc
);
706 fprintf(stderr
, "\t\t\t\t\t[ ok ]\n");
708 memcached_free(memc
);
711 /* Clean up whatever we might have left */
714 memc
= memcached_create(NULL
);
717 memcached_free(memc
);
720 fprintf(stderr
, "All tests completed successfully\n\n");