projects / m6w6 / libmemcached / blob
? search:


e717c3b8464592a79622b1647b2f3bf3b89efb61
[m6w6/libmemcached] / tests / function.c
1 /*
2 Sample test application.
3 */
4 #include <assert.h>
5 #include <memcached.h>
6 #include <stdio.h>
7 #include <stdlib.h>
8 #include <string.h>
9 #include <sys/time.h>
10 #include <sys/types.h>
11 #include <sys/stat.h>
12 #include <unistd.h>
13 #include <time.h>
14 #include "../lib/common.h"
15 #include "../src/generator.h"
16 #include "../src/execute.h"
17
18 #ifndef INT64_MAX
19 #define INT64_MAX LONG_MAX
20 #endif
21 #ifndef INT32_MAX
22 #define INT32_MAX INT_MAX
23 #endif
24
25
26 #include "test.h"
27
28 #define GLOBAL_COUNT 100000
29 static pairs_st *global_pairs;
30 static char *global_keys[GLOBAL_COUNT];
31 static size_t global_keys_length[GLOBAL_COUNT];
32
33 uint8_t init_test(memcached_st *not_used)
34 {
35 memcached_st memc;
36
37 (void)memcached_create(&memc);
38 memcached_free(&memc);
39
40 return 0;
41 }
42
43 uint8_t allocation_test(memcached_st *not_used)
44 {
45 memcached_st *memc;
46 memc= memcached_create(NULL);
47 assert(memc);
48 memcached_free(memc);
49
50 return 0;
51 }
52
53 uint8_t clone_test(memcached_st *memc)
54 {
55 /* All null? */
56 {
57 memcached_st *clone;
58 clone= memcached_clone(NULL, NULL);
59 assert(clone);
60 memcached_free(clone);
61 }
62
63 /* Can we init from null? */
64 {
65 memcached_st *clone;
66 clone= memcached_clone(NULL, memc);
67 assert(clone);
68 memcached_free(clone);
69 }
70
71 /* Can we init from struct? */
72 {
73 memcached_st declared_clone;
74 memcached_st *clone;
75 clone= memcached_clone(&declared_clone, NULL);
76 assert(clone);
77 memcached_free(clone);
78 }
79
80 /* Can we init from struct? */
81 {
82 memcached_st declared_clone;
83 memcached_st *clone;
84 clone= memcached_clone(&declared_clone, memc);
85 assert(clone);
86 memcached_free(clone);
87 }
88
89 return 0;
90 }
91
92 uint8_t connection_test(memcached_st *memc)
93 {
94 memcached_return rc;
95
96 rc= memcached_server_add(memc, "localhost", 0);
97 assert(rc == MEMCACHED_SUCCESS);
98
99 return 0;
100 }
101
102 uint8_t error_test(memcached_st *memc)
103 {
104 memcached_return rc;
105
106 for (rc= MEMCACHED_SUCCESS; rc < MEMCACHED_MAXIMUM_RETURN; rc++)
107 {
108 printf("Error %d -> %s\n", rc, memcached_strerror(memc, rc));
109 }
110
111 return 0;
112 }
113
114 uint8_t set_test(memcached_st *memc)
115 {
116 memcached_return rc;
117 char *key= "foo";
118 char *value= "when we sanitize";
119
120 rc= memcached_set(memc, key, strlen(key),
121 value, strlen(value),
122 (time_t)0, (uint32_t)0);
123 assert(rc == MEMCACHED_SUCCESS);
124
125 return 0;
126 }
127
128 uint8_t append_test(memcached_st *memc)
129 {
130 memcached_return rc;
131 char *key= "fig";
132 char *value= "we";
133 size_t value_length;
134 uint32_t flags;
135
136 rc= memcached_flush(memc, 0);
137 assert(rc == MEMCACHED_SUCCESS);
138
139 rc= memcached_set(memc, key, strlen(key),
140 value, strlen(value),
141 (time_t)0, (uint32_t)0);
142 assert(rc == MEMCACHED_SUCCESS);
143
144 rc= memcached_append(memc, key, strlen(key),
145 " the", strlen(" the"),
146 (time_t)0, (uint32_t)0);
147 assert(rc == MEMCACHED_SUCCESS);
148
149 rc= memcached_append(memc, key, strlen(key),
150 " people", strlen(" people"),
151 (time_t)0, (uint32_t)0);
152 assert(rc == MEMCACHED_SUCCESS);
153
154 value= memcached_get(memc, key, strlen(key),
155 &value_length, &flags, &rc);
156 assert(!memcmp(value, "we the people", strlen("we the people")));
157 assert(strlen("we the people") == value_length);
158 assert(rc == MEMCACHED_SUCCESS);
159 free(value);
160
161 return 0;
162 }
163
164 uint8_t append_binary_test(memcached_st *memc)
165 {
166 memcached_return rc;
167 char *key= "numbers";
168 unsigned int *store_ptr;
169 unsigned int store_list[] = { 23, 56, 499, 98, 32847, 0 };
170 char *value;
171 size_t value_length;
172 uint32_t flags;
173 unsigned int x;
174
175 rc= memcached_flush(memc, 0);
176 assert(rc == MEMCACHED_SUCCESS);
177
178 rc= memcached_set(memc,
179 key, strlen(key),
180 NULL, 0,
181 (time_t)0, (uint32_t)0);
182 assert(rc == MEMCACHED_SUCCESS);
183
184 for (x= 0; store_list[x] ; x++)
185 {
186 rc= memcached_append(memc,
187 key, strlen(key),
188 (char *)&store_list[x], sizeof(unsigned int),
189 (time_t)0, (uint32_t)0);
190 assert(rc == MEMCACHED_SUCCESS);
191 }
192
193 value= memcached_get(memc, key, strlen(key),
194 &value_length, &flags, &rc);
195 assert((value_length == (sizeof(unsigned int) * x)));
196 assert(rc == MEMCACHED_SUCCESS);
197
198 store_ptr= (unsigned int *)value;
199 x= 0;
200 while ((size_t)store_ptr < (size_t)(value + value_length))
201 {
202 assert(*store_ptr == store_list[x++]);
203 store_ptr++;
204 }
205 free(value);
206
207 return 0;
208 }
209
210 uint8_t cas2_test(memcached_st *memc)
211 {
212 memcached_return rc;
213 char *keys[]= {"fudge", "son", "food"};
214 size_t key_length[]= {5, 3, 4};
215 char *value= "we the people";
216 size_t value_length= strlen("we the people");
217 unsigned int x;
218 memcached_result_st results_obj;
219 memcached_result_st *results;
220 unsigned int set= 1;
221
222 rc= memcached_flush(memc, 0);
223 assert(rc == MEMCACHED_SUCCESS);
224
225 memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_SUPPORT_CAS, &set);
226
227 for (x= 0; x < 3; x++)
228 {
229 rc= memcached_set(memc, keys[x], key_length[x],
230 keys[x], key_length[x],
231 (time_t)50, (uint32_t)9);
232 assert(rc == MEMCACHED_SUCCESS);
233 }
234
235 rc= memcached_mget(memc, keys, key_length, 3);
236
237 results= memcached_result_create(memc, &results_obj);
238
239 results= memcached_fetch_result(memc, &results_obj, &rc);
240 assert(results);
241 assert(results->cas);
242 assert(rc == MEMCACHED_SUCCESS);
243 WATCHPOINT_ASSERT(memcached_result_cas(results));
244
245 assert(!memcmp(value, "we the people", strlen("we the people")));
246 assert(strlen("we the people") == value_length);
247 assert(rc == MEMCACHED_SUCCESS);
248
249 memcached_result_free(&results_obj);
250
251 return 0;
252 }
253
254 uint8_t cas_test(memcached_st *memc)
255 {
256 memcached_return rc;
257 char *key= "fun";
258 size_t key_length= strlen("fun");
259 char *value= "we the people";
260 size_t value_length= strlen("we the people");
261 memcached_result_st results_obj;
262 memcached_result_st *results;
263 unsigned int set= 1;
264
265 rc= memcached_flush(memc, 0);
266 assert(rc == MEMCACHED_SUCCESS);
267
268 memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_SUPPORT_CAS, &set);
269
270 rc= memcached_set(memc, key, strlen(key),
271 value, strlen(value),
272 (time_t)0, (uint32_t)0);
273 assert(rc == MEMCACHED_SUCCESS);
274
275 rc= memcached_mget(memc, &key, &key_length, 1);
276
277 results= memcached_result_create(memc, &results_obj);
278
279 results= memcached_fetch_result(memc, &results_obj, &rc);
280 assert(results);
281 assert(rc == MEMCACHED_SUCCESS);
282 WATCHPOINT_ASSERT(memcached_result_cas(results));
283
284 assert(!memcmp(value, "we the people", strlen("we the people")));
285 assert(strlen("we the people") == value_length);
286 assert(rc == MEMCACHED_SUCCESS);
287
288 memcached_result_free(&results_obj);
289
290 return 0;
291 }
292
293 uint8_t prepend_test(memcached_st *memc)
294 {
295 memcached_return rc;
296 char *key= "fig";
297 char *value= "people";
298 size_t value_length;
299 uint32_t flags;
300
301 rc= memcached_flush(memc, 0);
302 assert(rc == MEMCACHED_SUCCESS);
303
304 rc= memcached_set(memc, key, strlen(key),
305 value, strlen(value),
306 (time_t)0, (uint32_t)0);
307 assert(rc == MEMCACHED_SUCCESS);
308
309 rc= memcached_prepend(memc, key, strlen(key),
310 "the ", strlen("the "),
311 (time_t)0, (uint32_t)0);
312 assert(rc == MEMCACHED_SUCCESS);
313
314 rc= memcached_prepend(memc, key, strlen(key),
315 "we ", strlen("we "),
316 (time_t)0, (uint32_t)0);
317 assert(rc == MEMCACHED_SUCCESS);
318
319 value= memcached_get(memc, key, strlen(key),
320 &value_length, &flags, &rc);
321 assert(!memcmp(value, "we the people", strlen("we the people")));
322 assert(strlen("we the people") == value_length);
323 assert(rc == MEMCACHED_SUCCESS);
324 free(value);
325
326 return 0;
327 }
328
329 /*
330 Set the value, then quit to make sure it is flushed.
331 Come back in and test that add fails.
332 */
333 uint8_t add_test(memcached_st *memc)
334 {
335 memcached_return rc;
336 char *key= "foo";
337 char *value= "when we sanitize";
338
339 rc= memcached_set(memc, key, strlen(key),
340 value, strlen(value),
341 (time_t)0, (uint32_t)0);
342 assert(rc == MEMCACHED_SUCCESS);
343 memcached_quit(memc);
344 rc= memcached_add(memc, key, strlen(key),
345 value, strlen(value),
346 (time_t)0, (uint32_t)0);
347 assert(rc == MEMCACHED_NOTSTORED);
348
349 return 0;
350 }
351
352 uint8_t add_wrapper(memcached_st *memc)
353 {
354 unsigned int x;
355
356 for (x= 0; x < 10000; x++)
357 add_test(memc);
358
359 return 0;
360 }
361
362 uint8_t replace_test(memcached_st *memc)
363 {
364 memcached_return rc;
365 char *key= "foo";
366 char *value= "when we sanitize";
367
368 rc= memcached_replace(memc, key, strlen(key),
369 value, strlen(value),
370 (time_t)0, (uint32_t)0);
371 assert(rc == MEMCACHED_SUCCESS);
372
373 return 0;
374 }
375
376 uint8_t delete_test(memcached_st *memc)
377 {
378 memcached_return rc;
379 char *key= "foo";
380 char *value= "when we sanitize";
381
382 rc= memcached_set(memc, key, strlen(key),
383 value, strlen(value),
384 (time_t)0, (uint32_t)0);
385 assert(rc == MEMCACHED_SUCCESS);
386
387 rc= memcached_delete(memc, key, strlen(key), (time_t)0);
388 assert(rc == MEMCACHED_SUCCESS);
389
390 return 0;
391 }
392
393 uint8_t flush_test(memcached_st *memc)
394 {
395 memcached_return rc;
396
397 rc= memcached_flush(memc, 0);
398 assert(rc == MEMCACHED_SUCCESS);
399
400 return 0;
401 }
402
403 uint8_t get_test(memcached_st *memc)
404 {
405 memcached_return rc;
406 char *key= "foo";
407 char *string;
408 size_t string_length;
409 uint32_t flags;
410
411 rc= memcached_delete(memc, key, strlen(key), (time_t)0);
412 assert(rc == MEMCACHED_SUCCESS || rc == MEMCACHED_NOTFOUND);
413
414 string= memcached_get(memc, key, strlen(key),
415 &string_length, &flags, &rc);
416
417 assert(rc == MEMCACHED_NOTFOUND);
418 assert(string_length == 0);
419 assert(!string);
420
421 return 0;
422 }
423
424 uint8_t get_test2(memcached_st *memc)
425 {
426 memcached_return rc;
427 char *key= "foo";
428 char *value= "when we sanitize";
429 char *string;
430 size_t string_length;
431 uint32_t flags;
432
433 rc= memcached_set(memc, key, strlen(key),
434 value, strlen(value),
435 (time_t)0, (uint32_t)0);
436 assert(rc == MEMCACHED_SUCCESS);
437
438 string= memcached_get(memc, key, strlen(key),
439 &string_length, &flags, &rc);
440
441 assert(string);
442 assert(rc == MEMCACHED_SUCCESS);
443 assert(string_length == strlen(value));
444 assert(!memcmp(string, value, string_length));
445
446 free(string);
447
448 return 0;
449 }
450
451 uint8_t set_test2(memcached_st *memc)
452 {
453 memcached_return rc;
454 char *key= "foo";
455 char *value= "train in the brain";
456 size_t value_length= strlen(value);
457 unsigned int x;
458
459 for (x= 0; x < 10; x++)
460 {
461 rc= memcached_set(memc, key, strlen(key),
462 value, value_length,
463 (time_t)0, (uint32_t)0);
464 assert(rc == MEMCACHED_SUCCESS);
465 }
466
467 return 0;
468 }
469
470 uint8_t set_test3(memcached_st *memc)
471 {
472 memcached_return rc;
473 char *key= "foo";
474 char *value;
475 size_t value_length= 8191;
476 unsigned int x;
477
478 value = (char*)malloc(value_length);
479 assert(value);
480
481 for (x= 0; x < value_length; x++)
482 value[x] = (char) (x % 127);
483
484 for (x= 0; x < 1; x++)
485 {
486 rc= memcached_set(memc, key, strlen(key),
487 value, value_length,
488 (time_t)0, (uint32_t)0);
489 assert(rc == MEMCACHED_SUCCESS);
490 }
491
492 free(value);
493
494 return 0;
495 }
496
497 uint8_t get_test3(memcached_st *memc)
498 {
499 memcached_return rc;
500 char *key= "foo";
501 char *value;
502 size_t value_length= 8191;
503 char *string;
504 size_t string_length;
505 uint32_t flags;
506 int x;
507
508 value = (char*)malloc(value_length);
509 assert(value);
510
511 for (x= 0; x < value_length; x++)
512 value[x] = (char) (x % 127);
513
514 rc= memcached_set(memc, key, strlen(key),
515 value, value_length,
516 (time_t)0, (uint32_t)0);
517 assert(rc == MEMCACHED_SUCCESS);
518
519 string= memcached_get(memc, key, strlen(key),
520 &string_length, &flags, &rc);
521
522 assert(rc == MEMCACHED_SUCCESS);
523 assert(string);
524 assert(string_length == value_length);
525 assert(!memcmp(string, value, string_length));
526
527 free(string);
528 free(value);
529
530 return 0;
531 }
532
533 uint8_t get_test4(memcached_st *memc)
534 {
535 memcached_return rc;
536 char *key= "foo";
537 char *value;
538 size_t value_length= 8191;
539 char *string;
540 size_t string_length;
541 uint32_t flags;
542 int x;
543
544 value = (char*)malloc(value_length);
545 assert(value);
546
547 for (x= 0; x < value_length; x++)
548 value[x] = (char) (x % 127);
549
550 rc= memcached_set(memc, key, strlen(key),
551 value, value_length,
552 (time_t)0, (uint32_t)0);
553 assert(rc == MEMCACHED_SUCCESS);
554
555 for (x= 0; x < 10; x++)
556 {
557 string= memcached_get(memc, key, strlen(key),
558 &string_length, &flags, &rc);
559
560 assert(rc == MEMCACHED_SUCCESS);
561 assert(string);
562 assert(string_length == value_length);
563 assert(!memcmp(string, value, string_length));
564 free(string);
565 }
566
567 free(value);
568
569 return 0;
570 }
571
572 /* Do not copy the style of this code, I just access hosts to testthis function */
573 uint8_t stats_servername_test(memcached_st *memc)
574 {
575 memcached_return rc;
576 memcached_stat_st stat;
577 rc= memcached_stat_servername(&stat, NULL,
578 memc->hosts[0].hostname,
579 memc->hosts[0].port);
580
581 return 0;
582 }
583
584 uint8_t increment_test(memcached_st *memc)
585 {
586 uint64_t new_number;
587 memcached_return rc;
588 char *key= "number";
589 char *value= "0";
590
591 rc= memcached_set(memc, key, strlen(key),
592 value, strlen(value),
593 (time_t)0, (uint32_t)0);
594 assert(rc == MEMCACHED_SUCCESS);
595
596 rc= memcached_increment(memc, key, strlen(key),
597 1, &new_number);
598 assert(rc == MEMCACHED_SUCCESS);
599 assert(new_number == 1);
600
601 rc= memcached_increment(memc, key, strlen(key),
602 1, &new_number);
603 assert(rc == MEMCACHED_SUCCESS);
604 assert(new_number == 2);
605
606 return 0;
607 }
608
609 uint8_t decrement_test(memcached_st *memc)
610 {
611 uint64_t new_number;
612 memcached_return rc;
613 char *key= "number";
614 char *value= "3";
615
616 rc= memcached_set(memc, key, strlen(key),
617 value, strlen(value),
618 (time_t)0, (uint32_t)0);
619 assert(rc == MEMCACHED_SUCCESS);
620
621 rc= memcached_decrement(memc, key, strlen(key),
622 1, &new_number);
623 assert(rc == MEMCACHED_SUCCESS);
624 assert(new_number == 2);
625
626 rc= memcached_decrement(memc, key, strlen(key),
627 1, &new_number);
628 assert(rc == MEMCACHED_SUCCESS);
629 assert(new_number == 1);
630
631 return 0;
632 }
633
634 uint8_t quit_test(memcached_st *memc)
635 {
636 memcached_return rc;
637 char *key= "fudge";
638 char *value= "sanford and sun";
639
640 rc= memcached_set(memc, key, strlen(key),
641 value, strlen(value),
642 (time_t)10, (uint32_t)3);
643 assert(rc == MEMCACHED_SUCCESS);
644 memcached_quit(memc);
645
646 rc= memcached_set(memc, key, strlen(key),
647 value, strlen(value),
648 (time_t)50, (uint32_t)9);
649 assert(rc == MEMCACHED_SUCCESS);
650
651 return 0;
652 }
653
654 uint8_t mget_result_test(memcached_st *memc)
655 {
656 memcached_return rc;
657 char *keys[]= {"fudge", "son", "food"};
658 size_t key_length[]= {5, 3, 4};
659 unsigned int x;
660
661 memcached_result_st results_obj;
662 memcached_result_st *results;
663
664 results= memcached_result_create(memc, &results_obj);
665 assert(results);
666 assert(&results_obj == results);
667
668 /* We need to empty the server before continueing test */
669 rc= memcached_flush(memc, 0);
670 assert(rc == MEMCACHED_SUCCESS);
671
672 rc= memcached_mget(memc, keys, key_length, 3);
673 assert(rc == MEMCACHED_SUCCESS);
674
675 while ((results= memcached_fetch_result(memc, &results_obj, &rc)) != NULL)
676 {
677 assert(results);
678 }
679
680 while ((results= memcached_fetch_result(memc, &results_obj, &rc)) != NULL)
681 assert(!results);
682 assert(rc == MEMCACHED_END);
683
684 for (x= 0; x < 3; x++)
685 {
686 rc= memcached_set(memc, keys[x], key_length[x],
687 keys[x], key_length[x],
688 (time_t)50, (uint32_t)9);
689 assert(rc == MEMCACHED_SUCCESS);
690 }
691
692 rc= memcached_mget(memc, keys, key_length, 3);
693 assert(rc == MEMCACHED_SUCCESS);
694
695 while ((results= memcached_fetch_result(memc, &results_obj, &rc)))
696 {
697 assert(results);
698 assert(&results_obj == results);
699 assert(rc == MEMCACHED_SUCCESS);
700 assert(memcached_result_key_length(results) == memcached_result_length(results));
701 assert(!memcmp(memcached_result_key_value(results),
702 memcached_result_value(results),
703 memcached_result_length(results)));
704 }
705
706 memcached_result_free(&results_obj);
707
708 return 0;
709 }
710
711 uint8_t mget_result_alloc_test(memcached_st *memc)
712 {
713 memcached_return rc;
714 char *keys[]= {"fudge", "son", "food"};
715 size_t key_length[]= {5, 3, 4};
716 unsigned int x;
717
718 memcached_result_st *results;
719
720 /* We need to empty the server before continueing test */
721 rc= memcached_flush(memc, 0);
722 assert(rc == MEMCACHED_SUCCESS);
723
724 rc= memcached_mget(memc, keys, key_length, 3);
725 assert(rc == MEMCACHED_SUCCESS);
726
727 while ((results= memcached_fetch_result(memc, NULL, &rc)) != NULL)
728 {
729 assert(results);
730 }
731 assert(!results);
732 assert(rc == MEMCACHED_END);
733
734 for (x= 0; x < 3; x++)
735 {
736 rc= memcached_set(memc, keys[x], key_length[x],
737 keys[x], key_length[x],
738 (time_t)50, (uint32_t)9);
739 assert(rc == MEMCACHED_SUCCESS);
740 }
741
742 rc= memcached_mget(memc, keys, key_length, 3);
743 assert(rc == MEMCACHED_SUCCESS);
744
745 x= 0;
746 while ((results= memcached_fetch_result(memc, NULL, &rc)))
747 {
748 assert(results);
749 assert(rc == MEMCACHED_SUCCESS);
750 assert(memcached_result_key_length(results) == memcached_result_length(results));
751 assert(!memcmp(memcached_result_key_value(results),
752 memcached_result_value(results),
753 memcached_result_length(results)));
754 memcached_result_free(results);
755 x++;
756 }
757
758 return 0;
759 }
760
761 uint8_t mget_test(memcached_st *memc)
762 {
763 memcached_return rc;
764 char *keys[]= {"fudge", "son", "food"};
765 size_t key_length[]= {5, 3, 4};
766 unsigned int x;
767 uint32_t flags;
768
769 char return_key[MEMCACHED_MAX_KEY];
770 size_t return_key_length;
771 char *return_value;
772 size_t return_value_length;
773
774 /* We need to empty the server before continueing test */
775 rc= memcached_flush(memc, 0);
776 assert(rc == MEMCACHED_SUCCESS);
777
778 rc= memcached_mget(memc, keys, key_length, 3);
779 assert(rc == MEMCACHED_SUCCESS);
780
781 while ((return_value= memcached_fetch(memc, return_key, &return_key_length,
782 &return_value_length, &flags, &rc)) != NULL)
783 {
784 assert(return_value);
785 }
786 assert(!return_value);
787 assert(return_value_length == 0);
788 assert(rc == MEMCACHED_END);
789
790 for (x= 0; x < 3; x++)
791 {
792 rc= memcached_set(memc, keys[x], key_length[x],
793 keys[x], key_length[x],
794 (time_t)50, (uint32_t)9);
795 assert(rc == MEMCACHED_SUCCESS);
796 }
797
798 rc= memcached_mget(memc, keys, key_length, 3);
799 assert(rc == MEMCACHED_SUCCESS);
800
801 x= 0;
802 while ((return_value= memcached_fetch(memc, return_key, &return_key_length,
803 &return_value_length, &flags, &rc)))
804 {
805 assert(return_value);
806 assert(rc == MEMCACHED_SUCCESS);
807 assert(return_key_length == return_value_length);
808 assert(!memcmp(return_value, return_key, return_value_length));
809 free(return_value);
810 x++;
811 }
812
813 return 0;
814 }
815
816 uint8_t get_stats_keys(memcached_st *memc)
817 {
818 char **list;
819 char **ptr;
820 memcached_stat_st stat;
821 memcached_return rc;
822
823 list= memcached_stat_get_keys(memc, &stat, &rc);
824 assert(rc == MEMCACHED_SUCCESS);
825 for (ptr= list; *ptr; ptr++)
826 printf("Found key %s\n", *ptr);
827 fflush(stdout);
828
829 free(list);
830
831 return 0;
832 }
833
834 uint8_t get_stats(memcached_st *memc)
835 {
836 unsigned int x;
837 char **list;
838 char **ptr;
839 memcached_return rc;
840 memcached_stat_st *stat;
841
842 stat= memcached_stat(memc, NULL, &rc);
843 assert(rc == MEMCACHED_SUCCESS);
844
845 assert(rc == MEMCACHED_SUCCESS);
846 assert(stat);
847
848 for (x= 0; x < memcached_server_count(memc); x++)
849 {
850 list= memcached_stat_get_keys(memc, stat+x, &rc);
851 assert(rc == MEMCACHED_SUCCESS);
852 for (ptr= list; *ptr; ptr++);
853
854 free(list);
855 }
856
857 memcached_stat_free(NULL, stat);
858
859 return 0;
860 }
861
862 uint8_t add_host_test(memcached_st *memc)
863 {
864 unsigned int x;
865 memcached_server_st *servers;
866 memcached_return rc;
867 char servername[]= "0.example.com";
868
869 servers= memcached_server_list_append(NULL, servername, 400, &rc);
870 assert(servers);
871 assert(1 == memcached_server_list_count(servers));
872
873 for (x= 2; x < 20; x++)
874 {
875 char buffer[SMALL_STRING_LEN];
876
877 snprintf(buffer, SMALL_STRING_LEN, "%u.example.com", 400+x);
878 servers= memcached_server_list_append(servers, buffer, 401,
879 &rc);
880 assert(rc == MEMCACHED_SUCCESS);
881 assert(x == memcached_server_list_count(servers));
882 }
883
884 rc= memcached_server_push(memc, servers);
885 assert(rc == MEMCACHED_SUCCESS);
886 rc= memcached_server_push(memc, servers);
887 assert(rc == MEMCACHED_SUCCESS);
888
889 memcached_server_list_free(servers);
890
891 return 0;
892 }
893
894 /* We don't test the behavior itself, we test the switches */
895 uint8_t behavior_test(memcached_st *memc)
896 {
897 unsigned long long value;
898 unsigned int set= 1;
899
900 memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_NO_BLOCK, &set);
901 value= memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_NO_BLOCK);
902 assert(value == 1);
903
904 memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_TCP_NODELAY, &set);
905 value= memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_TCP_NODELAY);
906 assert(value == 1);
907
908 set= MEMCACHED_HASH_MD5;
909 memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_HASH, &set);
910 value= memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_HASH);
911 assert(value == MEMCACHED_HASH_MD5);
912
913 set= 0;
914
915 memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_NO_BLOCK, &set);
916 value= memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_NO_BLOCK);
917 assert(value == 0);
918
919 memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_TCP_NODELAY, &set);
920 value= memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_TCP_NODELAY);
921 assert(value == 0);
922
923 set= MEMCACHED_HASH_DEFAULT;
924 memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_HASH, &set);
925 value= memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_HASH);
926 assert(value == MEMCACHED_HASH_DEFAULT);
927
928 set= MEMCACHED_HASH_CRC;
929 memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_HASH, &set);
930 value= memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_HASH);
931 assert(value == MEMCACHED_HASH_CRC);
932
933 value= memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_SOCKET_SEND_SIZE);
934 assert(value > 0);
935
936 value= memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_SOCKET_RECV_SIZE);
937 assert(value > 0);
938
939 return 0;
940 }
941
942 /* Test case provided by Cal Haldenbrand */
943 uint8_t user_supplied_bug1(memcached_st *memc)
944 {
945 unsigned int setter= 1;
946 unsigned int x;
947
948 unsigned long long total= 0;
949 int size= 0;
950 char key[10];
951 char randomstuff[6 * 1024];
952 memcached_return rc;
953
954 memset(randomstuff, 0, 6 * 1024);
955
956 /* We just keep looking at the same values over and over */
957 srandom(10);
958
959 memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_NO_BLOCK, &setter);
960 memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_TCP_NODELAY, &setter);
961
962
963 /* add key */
964 for (x= 0 ; total < 20 * 1024576 ; x++ )
965 {
966 unsigned int j= 0;
967
968 size= (rand() % ( 5 * 1024 ) ) + 400;
969 memset(randomstuff, 0, 6 * 1024);
970 assert(size < 6 * 1024); /* Being safe here */
971
972 for (j= 0 ; j < size ;j++)
973 randomstuff[j] = (char) (rand() % 26) + 97;
974
975 total += size;
976 sprintf(key, "%d", x);
977 rc = memcached_set(memc, key, strlen(key),
978 randomstuff, strlen(randomstuff), 10, 0);
979 /* If we fail, lets try again */
980 if (rc != MEMCACHED_SUCCESS)
981 rc = memcached_set(memc, key, strlen(key),
982 randomstuff, strlen(randomstuff), 10, 0);
983 assert(rc == MEMCACHED_SUCCESS);
984 }
985
986 return 0;
987 }
988
989 /* Test case provided by Cal Haldenbrand */
990 uint8_t user_supplied_bug2(memcached_st *memc)
991 {
992 int errors;
993 unsigned int setter;
994 unsigned int x;
995 unsigned long long total;
996
997 setter= 1;
998 memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_NO_BLOCK, &setter);
999 memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_TCP_NODELAY, &setter);
1000 #ifdef NOT_YET
1001 setter = 20 * 1024576;
1002 memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_SOCKET_SEND_SIZE, &setter);
1003 setter = 20 * 1024576;
1004 memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_SOCKET_RECV_SIZE, &setter);
1005 getter = memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_SOCKET_SEND_SIZE);
1006 getter = memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_SOCKET_RECV_SIZE);
1007
1008 for (x= 0, errors= 0, total= 0 ; total < 20 * 1024576 ; x++)
1009 #endif
1010
1011 for (x= 0, errors= 0, total= 0 ; total < 24576 ; x++)
1012 {
1013 memcached_return rc= MEMCACHED_SUCCESS;
1014 char buffer[SMALL_STRING_LEN];
1015 uint32_t flags= 0;
1016 size_t val_len= 0;
1017 char *getval;
1018
1019 memset(buffer, 0, SMALL_STRING_LEN);
1020
1021 snprintf(buffer, SMALL_STRING_LEN, "%u", x);
1022 getval= memcached_get(memc, buffer, strlen(buffer),
1023 &val_len, &flags, &rc);
1024 if (rc != MEMCACHED_SUCCESS)
1025 {
1026 if (rc == MEMCACHED_NOTFOUND)
1027 errors++;
1028 else
1029 assert(0);
1030
1031 continue;
1032 }
1033 total+= val_len;
1034 errors= 0;
1035 free(getval);
1036 }
1037
1038 return 0;
1039 }
1040
1041 /* Do a large mget() over all the keys we think exist */
1042 #define KEY_COUNT 3000 // * 1024576
1043 uint8_t user_supplied_bug3(memcached_st *memc)
1044 {
1045 memcached_return rc;
1046 unsigned int setter;
1047 unsigned int x;
1048 char **keys;
1049 size_t key_lengths[KEY_COUNT];
1050
1051 setter= 1;
1052 memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_NO_BLOCK, &setter);
1053 memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_TCP_NODELAY, &setter);
1054 #ifdef NOT_YET
1055 setter = 20 * 1024576;
1056 memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_SOCKET_SEND_SIZE, &setter);
1057 setter = 20 * 1024576;
1058 memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_SOCKET_RECV_SIZE, &setter);
1059 getter = memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_SOCKET_SEND_SIZE);
1060 getter = memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_SOCKET_RECV_SIZE);
1061 #endif
1062
1063 keys= (char **)malloc(sizeof(char *) * KEY_COUNT);
1064 assert(keys);
1065 memset(keys, 0, (sizeof(char *) * KEY_COUNT));
1066 for (x= 0; x < KEY_COUNT; x++)
1067 {
1068 char buffer[30];
1069
1070 snprintf(buffer, 30, "%u", x);
1071 keys[x]= strdup(buffer);
1072 key_lengths[x]= strlen(keys[x]);
1073 }
1074
1075 rc= memcached_mget(memc, keys, key_lengths, KEY_COUNT);
1076 assert(rc == MEMCACHED_SUCCESS);
1077
1078 /* Turn this into a help function */
1079 {
1080 char return_key[MEMCACHED_MAX_KEY];
1081 size_t return_key_length;
1082 char *return_value;
1083 size_t return_value_length;
1084 uint32_t flags;
1085
1086 while ((return_value= memcached_fetch(memc, return_key, &return_key_length,
1087 &return_value_length, &flags, &rc)))
1088 {
1089 assert(return_value);
1090 assert(rc == MEMCACHED_SUCCESS);
1091 free(return_value);
1092 }
1093 }
1094
1095 for (x= 0; x < KEY_COUNT; x++)
1096 free(keys[x]);
1097 free(keys);
1098
1099 return 0;
1100 }
1101
1102 /* Make sure we behave properly if server list has no values */
1103 uint8_t user_supplied_bug4(memcached_st *memc)
1104 {
1105 memcached_return rc;
1106 char *keys[]= {"fudge", "son", "food"};
1107 size_t key_length[]= {5, 3, 4};
1108 unsigned int x;
1109 uint32_t flags;
1110 char return_key[MEMCACHED_MAX_KEY];
1111 size_t return_key_length;
1112 char *return_value;
1113 size_t return_value_length;
1114
1115 /* Here we free everything before running a bunch of mget tests */
1116 {
1117 memcached_server_list_free(memc->hosts);
1118 memc->hosts= NULL;
1119 memc->number_of_hosts= 0;
1120 }
1121
1122
1123 /* We need to empty the server before continueing test */
1124 rc= memcached_flush(memc, 0);
1125 assert(rc == MEMCACHED_NO_SERVERS);
1126
1127 rc= memcached_mget(memc, keys, key_length, 3);
1128 assert(rc == MEMCACHED_NO_SERVERS);
1129
1130 while ((return_value= memcached_fetch(memc, return_key, &return_key_length,
1131 &return_value_length, &flags, &rc)) != NULL)
1132 {
1133 assert(return_value);
1134 }
1135 assert(!return_value);
1136 assert(return_value_length == 0);
1137 assert(rc == MEMCACHED_NO_SERVERS);
1138
1139 for (x= 0; x < 3; x++)
1140 {
1141 rc= memcached_set(memc, keys[x], key_length[x],
1142 keys[x], key_length[x],
1143 (time_t)50, (uint32_t)9);
1144 assert(rc == MEMCACHED_NO_SERVERS);
1145 }
1146
1147 rc= memcached_mget(memc, keys, key_length, 3);
1148 assert(rc == MEMCACHED_NO_SERVERS);
1149
1150 x= 0;
1151 while ((return_value= memcached_fetch(memc, return_key, &return_key_length,
1152 &return_value_length, &flags, &rc)))
1153 {
1154 assert(return_value);
1155 assert(rc == MEMCACHED_SUCCESS);
1156 assert(return_key_length == return_value_length);
1157 assert(!memcmp(return_value, return_key, return_value_length));
1158 free(return_value);
1159 x++;
1160 }
1161
1162 return 0;
1163 }
1164
1165 #define VALUE_SIZE_BUG5 1048064
1166 uint8_t user_supplied_bug5(memcached_st *memc)
1167 {
1168 memcached_return rc;
1169 char *keys[]= {"036790384900", "036790384902", "036790384904", "036790384906"};
1170 size_t key_length[]= {strlen("036790384900"), strlen("036790384902"), strlen("036790384904"), strlen("036790384906")};
1171 char return_key[MEMCACHED_MAX_KEY];
1172 size_t return_key_length;
1173 char *value;
1174 size_t value_length;
1175 uint32_t flags;
1176 unsigned int count;
1177 unsigned int x;
1178 char insert_data[VALUE_SIZE_BUG5];
1179
1180 for (x= 0; x < VALUE_SIZE_BUG5; x++)
1181 insert_data[x]= rand();
1182
1183 memcached_flush(memc, 0);
1184 value= memcached_get(memc, keys[0], key_length[0],
1185 &value_length, &flags, &rc);
1186 assert(value == NULL);
1187 rc= memcached_mget(memc, keys, key_length, 4);
1188
1189 count= 0;
1190 while ((value= memcached_fetch(memc, return_key, &return_key_length,
1191 &value_length, &flags, &rc)))
1192 count++;
1193 assert(count == 0);
1194
1195 for (x= 0; x < 4; x++)
1196 {
1197 rc= memcached_set(memc, keys[x], key_length[x],
1198 insert_data, VALUE_SIZE_BUG5,
1199 (time_t)0, (uint32_t)0);
1200 assert(rc == MEMCACHED_SUCCESS);
1201 }
1202
1203 for (x= 0; x < 10; x++)
1204 {
1205 value= memcached_get(memc, keys[0], key_length[0],
1206 &value_length, &flags, &rc);
1207 assert(value);
1208 free(value);
1209
1210 rc= memcached_mget(memc, keys, key_length, 4);
1211 count= 0;
1212 while ((value= memcached_fetch(memc, return_key, &return_key_length,
1213 &value_length, &flags, &rc)))
1214 {
1215 count++;
1216 free(value);
1217 }
1218 assert(count == 4);
1219 }
1220
1221 return 0;
1222 }
1223
1224 uint8_t user_supplied_bug6(memcached_st *memc)
1225 {
1226 memcached_return rc;
1227 char *keys[]= {"036790384900", "036790384902", "036790384904", "036790384906"};
1228 size_t key_length[]= {strlen("036790384900"), strlen("036790384902"), strlen("036790384904"), strlen("036790384906")};
1229 char return_key[MEMCACHED_MAX_KEY];
1230 size_t return_key_length;
1231 char *value;
1232 size_t value_length;
1233 uint32_t flags;
1234 unsigned int count;
1235 unsigned int x;
1236 char insert_data[VALUE_SIZE_BUG5];
1237
1238 for (x= 0; x < VALUE_SIZE_BUG5; x++)
1239 insert_data[x]= rand();
1240
1241 memcached_flush(memc, 0);
1242 value= memcached_get(memc, keys[0], key_length[0],
1243 &value_length, &flags, &rc);
1244 assert(value == NULL);
1245 assert(rc == MEMCACHED_NOTFOUND);
1246 rc= memcached_mget(memc, keys, key_length, 4);
1247 assert(rc == MEMCACHED_SUCCESS);
1248
1249 count= 0;
1250 while ((value= memcached_fetch(memc, return_key, &return_key_length,
1251 &value_length, &flags, &rc)))
1252 count++;
1253 assert(count == 0);
1254 assert(rc == MEMCACHED_END);
1255
1256 for (x= 0; x < 4; x++)
1257 {
1258 rc= memcached_set(memc, keys[x], key_length[x],
1259 insert_data, VALUE_SIZE_BUG5,
1260 (time_t)0, (uint32_t)0);
1261 assert(rc == MEMCACHED_SUCCESS);
1262 }
1263
1264 for (x= 0; x < 2; x++)
1265 {
1266 value= memcached_get(memc, keys[0], key_length[0],
1267 &value_length, &flags, &rc);
1268 assert(value);
1269 free(value);
1270
1271 rc= memcached_mget(memc, keys, key_length, 4);
1272 assert(rc == MEMCACHED_SUCCESS);
1273 count= 3;
1274 /* We test for purge of partial complete fetches */
1275 for (count= 3; count; count--)
1276 {
1277 value= memcached_fetch(memc, return_key, &return_key_length,
1278 &value_length, &flags, &rc);
1279 assert(rc == MEMCACHED_SUCCESS);
1280 assert(!(memcmp(value, insert_data, value_length)));
1281 assert(value_length);
1282 free(value);
1283 }
1284 }
1285
1286 return 0;
1287 }
1288
1289 uint8_t user_supplied_bug8(memcached_st *memc)
1290 {
1291 memcached_return rc;
1292 memcached_st *mine;
1293 memcached_st *clone;
1294
1295 memcached_server_st *servers;
1296 char *server_list= "memcache1.memcache.bk.sapo.pt:11211, memcache1.memcache.bk.sapo.pt:11212, memcache1.memcache.bk.sapo.pt:11213, memcache1.memcache.bk.sapo.pt:11214, memcache2.memcache.bk.sapo.pt:11211, memcache2.memcache.bk.sapo.pt:11212, memcache2.memcache.bk.sapo.pt:11213, memcache2.memcache.bk.sapo.pt:11214";
1297
1298 servers= memcached_servers_parse(server_list);
1299 assert(servers);
1300
1301 mine= memcached_create(NULL);
1302 rc= memcached_server_push(mine, servers);
1303 assert(rc == MEMCACHED_SUCCESS);
1304 memcached_server_list_free(servers);
1305
1306 assert(mine);
1307 clone= memcached_clone(NULL, mine);
1308
1309 memcached_quit(mine);
1310 memcached_quit(clone);
1311
1312
1313 memcached_free(mine);
1314 memcached_free(clone);
1315
1316 return 0;
1317 }
1318
1319 /* Test flag store/retrieve */
1320 uint8_t user_supplied_bug7(memcached_st *memc)
1321 {
1322 memcached_return rc;
1323 char *keys= "036790384900";
1324 size_t key_length= strlen("036790384900");
1325 char return_key[MEMCACHED_MAX_KEY];
1326 size_t return_key_length;
1327 char *value;
1328 size_t value_length;
1329 uint32_t flags;
1330 unsigned int x;
1331 char insert_data[VALUE_SIZE_BUG5];
1332
1333 for (x= 0; x < VALUE_SIZE_BUG5; x++)
1334 insert_data[x]= rand();
1335
1336 memcached_flush(memc, 0);
1337
1338 flags= 245;
1339 rc= memcached_set(memc, keys, key_length,
1340 insert_data, VALUE_SIZE_BUG5,
1341 (time_t)0, flags);
1342 assert(rc == MEMCACHED_SUCCESS);
1343
1344 flags= 0;
1345 value= memcached_get(memc, keys, key_length,
1346 &value_length, &flags, &rc);
1347 assert(flags == 245);
1348 assert(value);
1349 free(value);
1350
1351 rc= memcached_mget(memc, &keys, &key_length, 1);
1352
1353 flags= 0;
1354 value= memcached_fetch(memc, return_key, &return_key_length,
1355 &value_length, &flags, &rc);
1356 assert(flags == 245);
1357 assert(value);
1358 free(value);
1359
1360
1361 return 0;
1362 }
1363
1364 uint8_t user_supplied_bug9(memcached_st *memc)
1365 {
1366 memcached_return rc;
1367 char *keys[]= {"UDATA:edevil@sapo.pt", "fudge&*@#", "for^#@&$not"};
1368 size_t key_length[3];
1369 unsigned int x;
1370 uint32_t flags;
1371 unsigned count= 0;
1372
1373 char return_key[MEMCACHED_MAX_KEY];
1374 size_t return_key_length;
1375 char *return_value;
1376 size_t return_value_length;
1377
1378
1379 key_length[0]= strlen("UDATA:edevil@sapo.pt");
1380 key_length[1]= strlen("fudge&*@#");
1381 key_length[2]= strlen("for^#@&$not");
1382
1383
1384 for (x= 0; x < 3; x++)
1385 {
1386 rc= memcached_set(memc, keys[x], key_length[x],
1387 keys[x], key_length[x],
1388 (time_t)50, (uint32_t)9);
1389 assert(rc == MEMCACHED_SUCCESS);
1390 }
1391
1392 rc= memcached_mget(memc, keys, key_length, 3);
1393 assert(rc == MEMCACHED_SUCCESS);
1394
1395 /* We need to empty the server before continueing test */
1396 while ((return_value= memcached_fetch(memc, return_key, &return_key_length,
1397 &return_value_length, &flags, &rc)) != NULL)
1398 {
1399 assert(return_value);
1400 free(return_value);
1401 count++;
1402 }
1403 assert(count == 3);
1404
1405 return 0;
1406 }
1407
1408 /* We are testing with aggressive timeout to get failures */
1409 uint8_t user_supplied_bug10(memcached_st *memc)
1410 {
1411 char *key= "foo";
1412 char *value;
1413 size_t value_length= 512;
1414 unsigned int x;
1415 int key_len= 3;
1416 memcached_return rc;
1417 unsigned int set= 1;
1418 memcached_st *mclone= memcached_clone(NULL, memc);
1419 int32_t timeout;
1420
1421 memcached_behavior_set(mclone, MEMCACHED_BEHAVIOR_NO_BLOCK, &set);
1422 memcached_behavior_set(mclone, MEMCACHED_BEHAVIOR_TCP_NODELAY, &set);
1423 timeout= 2;
1424 memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_POLL_TIMEOUT, &timeout);
1425
1426 value = (char*)malloc(value_length * sizeof(char));
1427
1428 for (x= 0; x < value_length; x++)
1429 value[x]= (char) (x % 127);
1430
1431 for (x= 1; x <= 100000; ++x)
1432 {
1433 rc= memcached_set(mclone, key, key_len,value, value_length, 0, 0);
1434
1435 assert(rc == MEMCACHED_SUCCESS || rc == MEMCACHED_WRITE_FAILURE);
1436
1437 if (rc == MEMCACHED_WRITE_FAILURE)
1438 x--;
1439 }
1440
1441 free(value);
1442 memcached_free(mclone);
1443
1444 return 0;
1445 }
1446
1447 /*
1448 We are looking failures in the async protocol
1449 */
1450 uint8_t user_supplied_bug11(memcached_st *memc)
1451 {
1452 char *key= "foo";
1453 char *value;
1454 size_t value_length= 512;
1455 unsigned int x;
1456 int key_len= 3;
1457 memcached_return rc;
1458 unsigned int set= 1;
1459 int32_t timeout;
1460 memcached_st *mclone= memcached_clone(NULL, memc);
1461
1462 memcached_behavior_set(mclone, MEMCACHED_BEHAVIOR_NO_BLOCK, &set);
1463 memcached_behavior_set(mclone, MEMCACHED_BEHAVIOR_TCP_NODELAY, &set);
1464 timeout= -1;
1465 memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_POLL_TIMEOUT, &timeout);
1466
1467 timeout= (int32_t)memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_POLL_TIMEOUT);
1468
1469 assert(timeout == -1);
1470
1471 value = (char*)malloc(value_length * sizeof(char));
1472
1473 for (x= 0; x < value_length; x++)
1474 value[x]= (char) (x % 127);
1475
1476 for (x= 1; x <= 100000; ++x)
1477 {
1478 rc= memcached_set(mclone, key, key_len,value, value_length, 0, 0);
1479
1480 WATCHPOINT_IFERROR(rc);
1481 //assert(rc == MEMCACHED_SUCCESS);
1482 }
1483
1484 free(value);
1485 memcached_free(mclone);
1486
1487 return 0;
1488 }
1489
1490 uint8_t result_static(memcached_st *memc)
1491 {
1492 memcached_result_st result;
1493 memcached_result_st *result_ptr;
1494
1495 result_ptr= memcached_result_create(memc, &result);
1496 assert(result.is_allocated == MEMCACHED_NOT_ALLOCATED);
1497 assert(result_ptr);
1498 memcached_result_free(&result);
1499
1500 return 0;
1501 }
1502
1503 uint8_t result_alloc(memcached_st *memc)
1504 {
1505 memcached_result_st *result;
1506
1507 result= memcached_result_create(memc, NULL);
1508 assert(result);
1509 memcached_result_free(result);
1510
1511 return 0;
1512 }
1513
1514 uint8_t string_static_null(memcached_st *memc)
1515 {
1516 memcached_string_st string;
1517 memcached_string_st *string_ptr;
1518
1519 string_ptr= memcached_string_create(memc, &string, 0);
1520 assert(string.is_allocated == MEMCACHED_NOT_ALLOCATED);
1521 assert(string_ptr);
1522 memcached_string_free(&string);
1523
1524 return 0;
1525 }
1526
1527 uint8_t string_alloc_null(memcached_st *memc)
1528 {
1529 memcached_string_st *string;
1530
1531 string= memcached_string_create(memc, NULL, 0);
1532 assert(string);
1533 memcached_string_free(string);
1534
1535 return 0;
1536 }
1537
1538 uint8_t string_alloc_with_size(memcached_st *memc)
1539 {
1540 memcached_string_st *string;
1541
1542 string= memcached_string_create(memc, NULL, 1024);
1543 assert(string);
1544 memcached_string_free(string);
1545
1546 return 0;
1547 }
1548
1549 uint8_t string_alloc_with_size_toobig(memcached_st *memc)
1550 {
1551 memcached_string_st *string;
1552
1553 string= memcached_string_create(memc, NULL, INT64_MAX);
1554 assert(string == NULL);
1555
1556 return 0;
1557 }
1558
1559 uint8_t string_alloc_append(memcached_st *memc)
1560 {
1561 unsigned int x;
1562 char buffer[SMALL_STRING_LEN];
1563 memcached_string_st *string;
1564
1565 /* Ring the bell! */
1566 memset(buffer, 6, SMALL_STRING_LEN);
1567
1568 string= memcached_string_create(memc, NULL, 100);
1569 assert(string);
1570
1571 for (x= 0; x < 1024; x++)
1572 {
1573 memcached_return rc;
1574 rc= memcached_string_append(string, buffer, SMALL_STRING_LEN);
1575 assert(rc == MEMCACHED_SUCCESS);
1576 }
1577 memcached_string_free(string);
1578
1579 return 0;
1580 }
1581
1582 uint8_t string_alloc_append_toobig(memcached_st *memc)
1583 {
1584 memcached_return rc;
1585 unsigned int x;
1586 char buffer[SMALL_STRING_LEN];
1587 memcached_string_st *string;
1588
1589 /* Ring the bell! */
1590 memset(buffer, 6, SMALL_STRING_LEN);
1591
1592 string= memcached_string_create(memc, NULL, 100);
1593 assert(string);
1594
1595 for (x= 0; x < 1024; x++)
1596 {
1597 rc= memcached_string_append(string, buffer, SMALL_STRING_LEN);
1598 assert(rc == MEMCACHED_SUCCESS);
1599 }
1600 rc= memcached_string_append(string, buffer, INT64_MAX);
1601 assert(rc == MEMCACHED_MEMORY_ALLOCATION_FAILURE);
1602 memcached_string_free(string);
1603
1604 return 0;
1605 }
1606
1607 uint8_t cleanup_pairs(memcached_st *memc)
1608 {
1609 pairs_free(global_pairs);
1610
1611 return 0;
1612 }
1613
1614 uint8_t generate_data(memcached_st *memc)
1615 {
1616 unsigned long long x;
1617 global_pairs= pairs_generate(GLOBAL_COUNT);
1618 execute_set(memc, global_pairs, GLOBAL_COUNT);
1619
1620 for (x= 0; x < GLOBAL_COUNT; x++)
1621 {
1622 global_keys[x]= global_pairs[x].key;
1623 global_keys_length[x]= global_pairs[x].key_length;
1624 }
1625
1626 return 0;
1627 }
1628
1629 uint8_t get_read(memcached_st *memc)
1630 {
1631 unsigned int x;
1632 memcached_return rc;
1633
1634 {
1635 char *return_value;
1636 size_t return_value_length;
1637 uint32_t flags;
1638
1639 for (x= 0; x < GLOBAL_COUNT; x++)
1640 {
1641 return_value= memcached_get(memc, global_keys[x], global_keys_length[x],
1642 &return_value_length, &flags, &rc);
1643 /*
1644 assert(return_value);
1645 assert(rc == MEMCACHED_SUCCESS);
1646 */
1647 if (rc == MEMCACHED_SUCCESS && return_value)
1648 free(return_value);
1649 }
1650 }
1651
1652 return 0;
1653 }
1654
1655 uint8_t mget_read(memcached_st *memc)
1656 {
1657 memcached_return rc;
1658
1659 rc= memcached_mget(memc, global_keys, global_keys_length, GLOBAL_COUNT);
1660 assert(rc == MEMCACHED_SUCCESS);
1661 /* Turn this into a help function */
1662 {
1663 char return_key[MEMCACHED_MAX_KEY];
1664 size_t return_key_length;
1665 char *return_value;
1666 size_t return_value_length;
1667 uint32_t flags;
1668
1669 while ((return_value= memcached_fetch(memc, return_key, &return_key_length,
1670 &return_value_length, &flags, &rc)))
1671 {
1672 assert(return_value);
1673 assert(rc == MEMCACHED_SUCCESS);
1674 free(return_value);
1675 }
1676 }
1677
1678 return 0;
1679 }
1680
1681 uint8_t mget_read_result(memcached_st *memc)
1682 {
1683 memcached_return rc;
1684
1685 rc= memcached_mget(memc, global_keys, global_keys_length, GLOBAL_COUNT);
1686 assert(rc == MEMCACHED_SUCCESS);
1687 /* Turn this into a help function */
1688 {
1689 memcached_result_st results_obj;
1690 memcached_result_st *results;
1691
1692 results= memcached_result_create(memc, &results_obj);
1693
1694 while ((results= memcached_fetch_result(memc, &results_obj, &rc)))
1695 {
1696 assert(results);
1697 assert(rc == MEMCACHED_SUCCESS);
1698 }
1699
1700 memcached_result_free(&results_obj);
1701 }
1702
1703 return 0;
1704 }
1705
1706 uint8_t free_data(memcached_st *memc)
1707 {
1708 pairs_free(global_pairs);
1709
1710 return 0;
1711 }
1712
1713 uint8_t add_host_test1(memcached_st *memc)
1714 {
1715 unsigned int x;
1716 memcached_return rc;
1717 char servername[]= "0.example.com";
1718 memcached_server_st *servers;
1719
1720 servers= memcached_server_list_append(NULL, servername, 400, &rc);
1721 assert(servers);
1722 assert(1 == memcached_server_list_count(servers));
1723
1724 for (x= 2; x < 20; x++)
1725 {
1726 char buffer[SMALL_STRING_LEN];
1727
1728 snprintf(buffer, SMALL_STRING_LEN, "%u.example.com", 400+x);
1729 servers= memcached_server_list_append(servers, buffer, 401,
1730 &rc);
1731 assert(rc == MEMCACHED_SUCCESS);
1732 assert(x == memcached_server_list_count(servers));
1733 }
1734
1735 rc= memcached_server_push(memc, servers);
1736 assert(rc == MEMCACHED_SUCCESS);
1737 rc= memcached_server_push(memc, servers);
1738 assert(rc == MEMCACHED_SUCCESS);
1739
1740 memcached_server_list_free(servers);
1741
1742 return 0;
1743 }
1744
1745 memcached_return pre_nonblock(memcached_st *memc)
1746 {
1747 memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_NO_BLOCK, NULL);
1748
1749 return MEMCACHED_SUCCESS;
1750 }
1751
1752 memcached_return pre_md5(memcached_st *memc)
1753 {
1754 memcached_hash value= MEMCACHED_HASH_MD5;
1755 memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_HASH, &value);
1756
1757 return MEMCACHED_SUCCESS;
1758 }
1759
1760 memcached_return pre_crc(memcached_st *memc)
1761 {
1762 memcached_hash value= MEMCACHED_HASH_CRC;
1763 memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_HASH, &value);
1764
1765 return MEMCACHED_SUCCESS;
1766 }
1767
1768 memcached_return pre_hsieh(memcached_st *memc)
1769 {
1770 memcached_hash value= MEMCACHED_HASH_HSIEH;
1771 memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_HASH, &value);
1772
1773 return MEMCACHED_SUCCESS;
1774 }
1775
1776 memcached_return pre_hash_fnv1_64(memcached_st *memc)
1777 {
1778 memcached_hash value= MEMCACHED_HASH_FNV1_64;
1779 memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_HASH, &value);
1780
1781 return MEMCACHED_SUCCESS;
1782 }
1783
1784 memcached_return pre_hash_fnv1a_64(memcached_st *memc)
1785 {
1786 memcached_hash value= MEMCACHED_HASH_FNV1A_64;
1787 memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_HASH, &value);
1788
1789 return MEMCACHED_SUCCESS;
1790 }
1791
1792 memcached_return pre_hash_fnv1_32(memcached_st *memc)
1793 {
1794 memcached_hash value= MEMCACHED_HASH_FNV1_32;
1795 memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_HASH, &value);
1796
1797 return MEMCACHED_SUCCESS;
1798 }
1799
1800 memcached_return pre_hash_fnv1a_32(memcached_st *memc)
1801 {
1802 memcached_hash value= MEMCACHED_HASH_FNV1A_32;
1803 memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_HASH, &value);
1804
1805 return MEMCACHED_SUCCESS;
1806 }
1807
1808 memcached_return pre_hash_ketama(memcached_st *memc)
1809 {
1810 memcached_hash value= MEMCACHED_HASH_KETAMA;
1811 memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_HASH, &value);
1812
1813 return MEMCACHED_SUCCESS;
1814 }
1815
1816 memcached_return enable_consistent(memcached_st *memc)
1817 {
1818 memcached_server_distribution value= MEMCACHED_DISTRIBUTION_CONSISTENT;
1819 memcached_hash hash;
1820 memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_DISTRIBUTION, &value);
1821 pre_hsieh(memc);
1822
1823 value= (memcached_server_distribution)memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_DISTRIBUTION);
1824 assert(value == MEMCACHED_DISTRIBUTION_CONSISTENT);
1825
1826 hash= (memcached_hash)memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_HASH);
1827 assert(hash == MEMCACHED_HASH_HSIEH);
1828
1829
1830 return MEMCACHED_SUCCESS;
1831 }
1832
1833 memcached_return enable_cas(memcached_st *memc)
1834 {
1835 unsigned int set= 1;
1836
1837 memcached_version(memc);
1838
1839 if (memc->hosts[0].major_version >= 1 &&
1840 memc->hosts[0].minor_version >= 2 &&
1841 memc->hosts[0].micro_version >= 4)
1842 {
1843 memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_SUPPORT_CAS, &set);
1844
1845 return MEMCACHED_SUCCESS;
1846 }
1847
1848 return MEMCACHED_FAILURE;
1849 }
1850
1851 memcached_return check_for_1_2_3(memcached_st *memc)
1852 {
1853 memcached_version(memc);
1854
1855 if (memc->hosts[0].major_version >= 1 &&
1856 memc->hosts[0].minor_version >= 2 &&
1857 memc->hosts[0].micro_version >= 4)
1858 return MEMCACHED_SUCCESS;
1859
1860 return MEMCACHED_FAILURE;
1861 }
1862
1863 memcached_return pre_unix_socket(memcached_st *memc)
1864 {
1865 memcached_return rc;
1866 struct stat buf;
1867
1868 memcached_server_list_free(memc->hosts);
1869 memc->hosts= NULL;
1870 memc->number_of_hosts= 0;
1871
1872 if (stat("/tmp/memcached.socket", &buf))
1873 return MEMCACHED_FAILURE;
1874
1875 rc= memcached_server_add_unix_socket(memc, "/tmp/memcached.socket");
1876
1877 return rc;
1878 }
1879
1880 memcached_return pre_udp(memcached_st *memc)
1881 {
1882 memcached_return rc;
1883
1884 memcached_server_list_free(memc->hosts);
1885 memc->hosts= NULL;
1886 memc->number_of_hosts= 0;
1887
1888 if (0)
1889 return MEMCACHED_FAILURE;
1890
1891 rc= memcached_server_add_udp(memc, "localhost", MEMCACHED_DEFAULT_PORT);
1892
1893 return rc;
1894 }
1895
1896 memcached_return pre_nodelay(memcached_st *memc)
1897 {
1898 memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_NO_BLOCK, NULL);
1899 memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_TCP_NODELAY, NULL);
1900
1901 return MEMCACHED_SUCCESS;
1902 }
1903
1904 memcached_return poll_timeout(memcached_st *memc)
1905 {
1906 int32_t timeout;
1907
1908 timeout= 100;
1909
1910 memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_POLL_TIMEOUT, &timeout);
1911
1912 timeout= (int32_t)memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_POLL_TIMEOUT);
1913
1914 assert(timeout == 100);
1915
1916 return MEMCACHED_SUCCESS;
1917 }
1918
1919
1920 /* Clean the server before beginning testing */
1921 test_st tests[] ={
1922 {"flush", 0, flush_test },
1923 {"init", 0, init_test },
1924 {"allocation", 0, allocation_test },
1925 {"clone_test", 0, clone_test },
1926 {"error", 0, error_test },
1927 {"set", 0, set_test },
1928 {"set2", 0, set_test2 },
1929 {"set3", 0, set_test3 },
1930 {"add", 1, add_test },
1931 {"replace", 0, replace_test },
1932 {"delete", 1, delete_test },
1933 {"get", 1, get_test },
1934 {"get2", 0, get_test2 },
1935 {"get3", 0, get_test3 },
1936 {"get4", 0, get_test4 },
1937 {"stats_servername", 0, stats_servername_test },
1938 {"increment", 0, increment_test },
1939 {"decrement", 0, decrement_test },
1940 {"quit", 0, quit_test },
1941 {"mget", 1, mget_test },
1942 {"mget_result", 1, mget_result_test },
1943 {"mget_result_alloc", 1, mget_result_alloc_test },
1944 {"get_stats", 0, get_stats },
1945 {"add_host_test", 0, add_host_test },
1946 {"get_stats_keys", 0, get_stats_keys },
1947 {"behavior_test", 0, get_stats_keys },
1948 {0, 0, 0}
1949 };
1950
1951 test_st async_tests[] ={
1952 {"add", 1, add_wrapper },
1953 {0, 0, 0}
1954 };
1955
1956 test_st string_tests[] ={
1957 {"string static with null", 0, string_static_null },
1958 {"string alloc with null", 0, string_alloc_null },
1959 {"string alloc with 1K", 0, string_alloc_with_size },
1960 {"string alloc with malloc failure", 0, string_alloc_with_size_toobig },
1961 {"string append", 0, string_alloc_append },
1962 {"string append failure (too big)", 0, string_alloc_append_toobig },
1963 {0, 0, 0}
1964 };
1965
1966 test_st result_tests[] ={
1967 {"result static", 0, result_static},
1968 {"result alloc", 0, result_alloc},
1969 {0, 0, 0}
1970 };
1971
1972 test_st version_1_2_3[] ={
1973 {"append", 0, append_test },
1974 {"prepend", 0, prepend_test },
1975 {"cas", 0, cas_test },
1976 {"cas2", 0, cas2_test },
1977 {"append_binary", 0, append_binary_test },
1978 {0, 0, 0}
1979 };
1980
1981 test_st user_tests[] ={
1982 {"user_supplied_bug1", 0, user_supplied_bug1 },
1983 {"user_supplied_bug2", 0, user_supplied_bug2 },
1984 {"user_supplied_bug3", 0, user_supplied_bug3 },
1985 {"user_supplied_bug4", 0, user_supplied_bug4 },
1986 {"user_supplied_bug5", 1, user_supplied_bug5 },
1987 {"user_supplied_bug6", 1, user_supplied_bug6 },
1988 {"user_supplied_bug7", 1, user_supplied_bug7 },
1989 {"user_supplied_bug8", 1, user_supplied_bug8 },
1990 {"user_supplied_bug9", 1, user_supplied_bug9 },
1991 {"user_supplied_bug10", 1, user_supplied_bug10 },
1992 {"user_supplied_bug11", 1, user_supplied_bug11 },
1993 {0, 0, 0}
1994 };
1995
1996 test_st generate_tests[] ={
1997 {"generate_data", 0, generate_data },
1998 {"get_read", 0, get_read },
1999 {"mget_read", 0, mget_read },
2000 {"mget_read_result", 0, mget_read_result },
2001 {"cleanup", 0, cleanup_pairs },
2002 {0, 0, 0}
2003 };
2004
2005
2006 collection_st collection[] ={
2007 {"block", 0, 0, tests},
2008 {"nonblock", pre_nonblock, 0, tests},
2009 {"nodelay", pre_nodelay, 0, tests},
2010 {"md5", pre_md5, 0, tests},
2011 {"crc", pre_crc, 0, tests},
2012 {"hsieh", pre_hsieh, 0, tests},
2013 {"fnv1_64", pre_hash_fnv1_64, 0, tests},
2014 {"fnv1a_64", pre_hash_fnv1a_64, 0, tests},
2015 {"fnv1_32", pre_hash_fnv1_32, 0, tests},
2016 {"fnv1a_32", pre_hash_fnv1a_32, 0, tests},
2017 {"ketama", pre_hash_ketama, 0, tests},
2018 {"unix_socket", pre_unix_socket, 0, tests},
2019 {"unix_socket_nodelay", pre_nodelay, 0, tests},
2020 {"poll_timeout", poll_timeout, 0, tests},
2021 {"gets", enable_cas, 0, tests},
2022 {"consistent", enable_consistent, 0, tests},
2023 // {"udp", pre_udp, 0, tests},
2024 {"version_1_2_3", check_for_1_2_3, 0, version_1_2_3},
2025 {"string", 0, 0, string_tests},
2026 {"result", 0, 0, result_tests},
2027 {"async", pre_nonblock, 0, async_tests},
2028 {"user", 0, 0, user_tests},
2029 {"generate", 0, 0, generate_tests},
2030 {"generate_hsieh", pre_hsieh, 0, generate_tests},
2031 {"generate_hsieh_consistent", enable_consistent, 0, generate_tests},
2032 {"generate_md5", pre_md5, 0, generate_tests},
2033 {"generate_nonblock", pre_nonblock, 0, generate_tests},
2034 {0, 0, 0, 0}
2035 };
2036
2037 collection_st *gets_collections(void)
2038 {
2039 return collection;
2040 }
Resurrection of libmemcached https://launchpad.net/libmemcached