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
);
398 void get_stats(memcached_st
*memc
)
404 memcached_stat_st
*stat
;
406 stat
= memcached_stat(memc
, NULL
, &rc
);
407 assert(rc
== MEMCACHED_SUCCESS
);
409 assert(rc
== MEMCACHED_SUCCESS
);
412 for (x
= 0; x
< memcached_server_count(memc
); x
++)
414 list
= memcached_stat_get_keys(memc
, &stat
[x
], &rc
);
415 assert(rc
== MEMCACHED_SUCCESS
);
416 for (ptr
= list
; *ptr
; ptr
++)
417 printf("Found key %s\n", *ptr
);
425 void add_host_test(memcached_st
*memc
)
428 memcached_server_st
*servers
;
430 char servername
[]= "0.example.com";
432 servers
= memcached_server_list_append(NULL
, servername
, 400, &rc
);
434 assert(1 == memcached_server_list_count(servers
));
436 for (x
= 2; x
< 20; x
++)
438 char buffer
[SMALL_STRING_LEN
];
440 snprintf(buffer
, SMALL_STRING_LEN
, "%u.example.com", 400+x
);
441 servers
= memcached_server_list_append(servers
, buffer
, 401,
443 assert(rc
== MEMCACHED_SUCCESS
);
444 assert(x
== memcached_server_list_count(servers
));
447 rc
= memcached_server_push(memc
, servers
);
448 assert(rc
== MEMCACHED_SUCCESS
);
449 rc
= memcached_server_push(memc
, servers
);
450 assert(rc
== MEMCACHED_SUCCESS
);
452 memcached_server_list_free(servers
);
455 void add_host_test1(memcached_st
*memc
)
459 char servername
[]= "0.example.com";
460 memcached_server_st
*servers
;
462 servers
= memcached_server_list_append(NULL
, servername
, 400, &rc
);
464 assert(1 == memcached_server_list_count(servers
));
466 for (x
= 2; x
< 20; x
++)
468 char buffer
[SMALL_STRING_LEN
];
470 snprintf(buffer
, SMALL_STRING_LEN
, "%u.example.com", 400+x
);
471 servers
= memcached_server_list_append(servers
, buffer
, 401,
473 assert(rc
== MEMCACHED_SUCCESS
);
474 assert(x
== memcached_server_list_count(servers
));
477 rc
= memcached_server_push(memc
, servers
);
478 assert(rc
== MEMCACHED_SUCCESS
);
479 rc
= memcached_server_push(memc
, servers
);
480 assert(rc
== MEMCACHED_SUCCESS
);
482 memcached_server_list_free(servers
);
485 typedef struct test_st test_st
;
489 unsigned int requires_flush
;
490 void (*function
)(memcached_st
*memc
);
493 int main(int argc
, char *argv
[])
497 memcached_server_st
*servers
;
499 if (!(server_list
= getenv("MEMCACHED_SERVERS")))
500 server_list
= "localhost";
502 printf("servers %s\n", server_list
);
504 servers
= memcached_servers_parse(server_list
);
507 /* Clean the server before beginning testing */
509 {"flush", 0, flush_test
},
510 {"init", 0, init_test
},
511 {"allocation", 0, allocation_test
},
512 {"error", 0, error_test
},
513 {"set", 0, set_test
},
514 {"set2", 0, set_test2
},
515 {"set3", 0, set_test3
},
516 {"add", 0, add_test
},
517 {"replace", 0, replace_test
},
518 {"delete", 1, delete_test
},
519 {"get", 0, get_test
},
520 {"get2", 0, get_test2
},
521 {"get3", 0, get_test3
},
522 {"get4", 0, get_test4
},
523 {"stats_servername", 0, stats_servername_test
},
524 {"increment", 0, increment_test
},
525 {"decrement", 0, decrement_test
},
526 {"quit", 0, quit_test
},
527 {"mget", 0, mget_test
},
528 {"get_stats", 0, get_stats
},
529 {"add_host_test", 0, add_host_test
},
530 {"get_stats_keys", 0, get_stats_keys
},
534 fprintf(stderr
, "\nBlock tests\n\n");
535 for (x
= 0; tests
[x
].function_name
; x
++)
539 memc
= memcached_create(NULL
);
542 rc
= memcached_server_push(memc
, servers
);
543 assert(rc
== MEMCACHED_SUCCESS
);
545 fprintf(stderr
, "Testing %s", tests
[x
].function_name
);
546 tests
[x
].function(memc
);
547 fprintf(stderr
, "\t\t\t\t\t[ ok ]\n");
549 memcached_free(memc
);
552 fprintf(stderr
, "\nNonblock tests\n\n");
553 for (x
= 0; tests
[x
].function_name
; x
++)
557 memc
= memcached_create(NULL
);
560 rc
= memcached_server_push(memc
, servers
);
561 assert(rc
== MEMCACHED_SUCCESS
);
563 fprintf(stderr
, "Testing %s", tests
[x
].function_name
);
564 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NO_BLOCK
, NULL
);
565 tests
[x
].function(memc
);
566 fprintf(stderr
, "\t\t\t\t\t[ ok ]\n");
568 memcached_free(memc
);
571 fprintf(stderr
, "\nTCP Nodelay tests\n\n");
572 for (x
= 0; tests
[x
].function_name
; x
++)
576 memc
= memcached_create(NULL
);
579 rc
= memcached_server_push(memc
, servers
);
580 assert(rc
== MEMCACHED_SUCCESS
);
582 fprintf(stderr
, "Testing %s", tests
[x
].function_name
);
583 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NO_BLOCK
, NULL
);
584 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_TCP_NODELAY
, NULL
);
585 tests
[x
].function(memc
);
586 fprintf(stderr
, "\t\t\t\t\t[ ok ]\n");
588 memcached_free(memc
);
591 /* Clean up whatever we might have left */
594 memc
= memcached_create(NULL
);
597 memcached_free(memc
);