projects / awesomized / libmemcached / blob
? search:


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