2 Sample test application.
10 #include <sys/types.h>
14 #include "../lib/common.h"
15 #include "../src/generator.h"
16 #include "../src/execute.h"
19 #define INT64_MAX LONG_MAX
22 #define INT32_MAX INT_MAX
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
];
33 uint8_t init_test(memcached_st
*not_used
)
37 (void)memcached_create(&memc
);
38 memcached_free(&memc
);
43 uint8_t server_list_null_test(memcached_st
*ptr
)
45 memcached_server_st
*server_list
;
48 server_list
= memcached_server_list_append(NULL
, NULL
, 0, NULL
);
49 assert(server_list
== NULL
);
51 server_list
= memcached_server_list_append(NULL
, "localhost", 0, NULL
);
52 assert(server_list
== NULL
);
54 server_list
= memcached_server_list_append(NULL
, NULL
, 0, &rc
);
55 assert(server_list
== NULL
);
60 uint8_t allocation_test(memcached_st
*not_used
)
63 memc
= memcached_create(NULL
);
70 uint8_t clone_test(memcached_st
*memc
)
75 clone
= memcached_clone(NULL
, NULL
);
77 memcached_free(clone
);
80 /* Can we init from null? */
83 clone
= memcached_clone(NULL
, memc
);
85 memcached_free(clone
);
88 /* Can we init from struct? */
90 memcached_st declared_clone
;
92 clone
= memcached_clone(&declared_clone
, NULL
);
94 memcached_free(clone
);
97 /* Can we init from struct? */
99 memcached_st declared_clone
;
101 clone
= memcached_clone(&declared_clone
, memc
);
103 memcached_free(clone
);
109 uint8_t connection_test(memcached_st
*memc
)
113 rc
= memcached_server_add(memc
, "localhost", 0);
114 assert(rc
== MEMCACHED_SUCCESS
);
119 uint8_t error_test(memcached_st
*memc
)
123 for (rc
= MEMCACHED_SUCCESS
; rc
< MEMCACHED_MAXIMUM_RETURN
; rc
++)
125 printf("Error %d -> %s\n", rc
, memcached_strerror(memc
, rc
));
131 uint8_t set_test(memcached_st
*memc
)
135 char *value
= "when we sanitize";
137 rc
= memcached_set(memc
, key
, strlen(key
),
138 value
, strlen(value
),
139 (time_t)0, (uint32_t)0);
140 assert(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
);
145 uint8_t append_test(memcached_st
*memc
)
153 rc
= memcached_flush(memc
, 0);
154 assert(rc
== MEMCACHED_SUCCESS
);
156 rc
= memcached_set(memc
, key
, strlen(key
),
157 value
, strlen(value
),
158 (time_t)0, (uint32_t)0);
159 assert(rc
== MEMCACHED_SUCCESS
);
161 rc
= memcached_append(memc
, key
, strlen(key
),
162 " the", strlen(" the"),
163 (time_t)0, (uint32_t)0);
164 assert(rc
== MEMCACHED_SUCCESS
);
166 rc
= memcached_append(memc
, key
, strlen(key
),
167 " people", strlen(" people"),
168 (time_t)0, (uint32_t)0);
169 assert(rc
== MEMCACHED_SUCCESS
);
171 value
= memcached_get(memc
, key
, strlen(key
),
172 &value_length
, &flags
, &rc
);
173 assert(!memcmp(value
, "we the people", strlen("we the people")));
174 assert(strlen("we the people") == value_length
);
175 assert(rc
== MEMCACHED_SUCCESS
);
181 uint8_t append_binary_test(memcached_st
*memc
)
184 char *key
= "numbers";
185 unsigned int *store_ptr
;
186 unsigned int store_list
[] = { 23, 56, 499, 98, 32847, 0 };
192 rc
= memcached_flush(memc
, 0);
193 assert(rc
== MEMCACHED_SUCCESS
);
195 rc
= memcached_set(memc
,
198 (time_t)0, (uint32_t)0);
199 assert(rc
== MEMCACHED_SUCCESS
);
201 for (x
= 0; store_list
[x
] ; x
++)
203 rc
= memcached_append(memc
,
205 (char *)&store_list
[x
], sizeof(unsigned int),
206 (time_t)0, (uint32_t)0);
207 assert(rc
== MEMCACHED_SUCCESS
);
210 value
= memcached_get(memc
, key
, strlen(key
),
211 &value_length
, &flags
, &rc
);
212 assert((value_length
== (sizeof(unsigned int) * x
)));
213 assert(rc
== MEMCACHED_SUCCESS
);
215 store_ptr
= (unsigned int *)value
;
217 while ((size_t)store_ptr
< (size_t)(value
+ value_length
))
219 assert(*store_ptr
== store_list
[x
++]);
227 uint8_t cas2_test(memcached_st
*memc
)
230 char *keys
[]= {"fudge", "son", "food"};
231 size_t key_length
[]= {5, 3, 4};
232 char *value
= "we the people";
233 size_t value_length
= strlen("we the people");
235 memcached_result_st results_obj
;
236 memcached_result_st
*results
;
239 rc
= memcached_flush(memc
, 0);
240 assert(rc
== MEMCACHED_SUCCESS
);
242 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_SUPPORT_CAS
, &set
);
244 for (x
= 0; x
< 3; x
++)
246 rc
= memcached_set(memc
, keys
[x
], key_length
[x
],
247 keys
[x
], key_length
[x
],
248 (time_t)50, (uint32_t)9);
249 assert(rc
== MEMCACHED_SUCCESS
);
252 rc
= memcached_mget(memc
, keys
, key_length
, 3);
254 results
= memcached_result_create(memc
, &results_obj
);
256 results
= memcached_fetch_result(memc
, &results_obj
, &rc
);
258 assert(results
->cas
);
259 assert(rc
== MEMCACHED_SUCCESS
);
260 WATCHPOINT_ASSERT(memcached_result_cas(results
));
262 assert(!memcmp(value
, "we the people", strlen("we the people")));
263 assert(strlen("we the people") == value_length
);
264 assert(rc
== MEMCACHED_SUCCESS
);
266 memcached_result_free(&results_obj
);
271 uint8_t cas_test(memcached_st
*memc
)
275 size_t key_length
= strlen("fun");
276 char *value
= "we the people";
277 size_t value_length
= strlen("we the people");
278 memcached_result_st results_obj
;
279 memcached_result_st
*results
;
282 rc
= memcached_flush(memc
, 0);
283 assert(rc
== MEMCACHED_SUCCESS
);
285 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_SUPPORT_CAS
, &set
);
287 rc
= memcached_set(memc
, key
, strlen(key
),
288 value
, strlen(value
),
289 (time_t)0, (uint32_t)0);
290 assert(rc
== MEMCACHED_SUCCESS
);
292 rc
= memcached_mget(memc
, &key
, &key_length
, 1);
294 results
= memcached_result_create(memc
, &results_obj
);
296 results
= memcached_fetch_result(memc
, &results_obj
, &rc
);
298 assert(rc
== MEMCACHED_SUCCESS
);
299 WATCHPOINT_ASSERT(memcached_result_cas(results
));
301 assert(!memcmp(value
, "we the people", strlen("we the people")));
302 assert(strlen("we the people") == value_length
);
303 assert(rc
== MEMCACHED_SUCCESS
);
305 memcached_result_free(&results_obj
);
310 uint8_t prepend_test(memcached_st
*memc
)
314 char *value
= "people";
318 rc
= memcached_flush(memc
, 0);
319 assert(rc
== MEMCACHED_SUCCESS
);
321 rc
= memcached_set(memc
, key
, strlen(key
),
322 value
, strlen(value
),
323 (time_t)0, (uint32_t)0);
324 assert(rc
== MEMCACHED_SUCCESS
);
326 rc
= memcached_prepend(memc
, key
, strlen(key
),
327 "the ", strlen("the "),
328 (time_t)0, (uint32_t)0);
329 assert(rc
== MEMCACHED_SUCCESS
);
331 rc
= memcached_prepend(memc
, key
, strlen(key
),
332 "we ", strlen("we "),
333 (time_t)0, (uint32_t)0);
334 assert(rc
== MEMCACHED_SUCCESS
);
336 value
= memcached_get(memc
, key
, strlen(key
),
337 &value_length
, &flags
, &rc
);
338 assert(!memcmp(value
, "we the people", strlen("we the people")));
339 assert(strlen("we the people") == value_length
);
340 assert(rc
== MEMCACHED_SUCCESS
);
347 Set the value, then quit to make sure it is flushed.
348 Come back in and test that add fails.
350 uint8_t add_test(memcached_st
*memc
)
354 char *value
= "when we sanitize";
356 rc
= memcached_set(memc
, key
, strlen(key
),
357 value
, strlen(value
),
358 (time_t)0, (uint32_t)0);
359 assert(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
);
360 memcached_quit(memc
);
361 rc
= memcached_add(memc
, key
, strlen(key
),
362 value
, strlen(value
),
363 (time_t)0, (uint32_t)0);
364 WATCHPOINT_ERROR(rc
);
365 assert(rc
== MEMCACHED_NOTSTORED
);
370 uint8_t add_wrapper(memcached_st
*memc
)
374 for (x
= 0; x
< 10000; x
++)
380 uint8_t replace_test(memcached_st
*memc
)
384 char *value
= "when we sanitize";
386 rc
= memcached_replace(memc
, key
, strlen(key
),
387 value
, strlen(value
),
388 (time_t)0, (uint32_t)0);
389 assert(rc
== MEMCACHED_SUCCESS
);
394 uint8_t delete_test(memcached_st
*memc
)
398 char *value
= "when we sanitize";
400 rc
= memcached_set(memc
, key
, strlen(key
),
401 value
, strlen(value
),
402 (time_t)0, (uint32_t)0);
403 assert(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
);
405 rc
= memcached_delete(memc
, key
, strlen(key
), (time_t)0);
406 assert(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
);
411 uint8_t flush_test(memcached_st
*memc
)
415 rc
= memcached_flush(memc
, 0);
416 assert(rc
== MEMCACHED_SUCCESS
);
421 uint8_t get_test(memcached_st
*memc
)
426 size_t string_length
;
429 rc
= memcached_delete(memc
, key
, strlen(key
), (time_t)0);
430 assert(rc
== MEMCACHED_BUFFERED
|| rc
== MEMCACHED_NOTFOUND
);
432 string
= memcached_get(memc
, key
, strlen(key
),
433 &string_length
, &flags
, &rc
);
435 assert(rc
== MEMCACHED_NOTFOUND
);
436 assert(string_length
== 0);
442 uint8_t get_test2(memcached_st
*memc
)
446 char *value
= "when we sanitize";
448 size_t string_length
;
451 rc
= memcached_set(memc
, key
, strlen(key
),
452 value
, strlen(value
),
453 (time_t)0, (uint32_t)0);
454 assert(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
);
456 string
= memcached_get(memc
, key
, strlen(key
),
457 &string_length
, &flags
, &rc
);
460 assert(rc
== MEMCACHED_SUCCESS
);
461 assert(string_length
== strlen(value
));
462 assert(!memcmp(string
, value
, string_length
));
469 uint8_t set_test2(memcached_st
*memc
)
473 char *value
= "train in the brain";
474 size_t value_length
= strlen(value
);
477 for (x
= 0; x
< 10; x
++)
479 rc
= memcached_set(memc
, key
, strlen(key
),
481 (time_t)0, (uint32_t)0);
482 assert(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
);
488 uint8_t set_test3(memcached_st
*memc
)
493 size_t value_length
= 8191;
496 value
= (char*)malloc(value_length
);
499 for (x
= 0; x
< value_length
; x
++)
500 value
[x
] = (char) (x
% 127);
502 for (x
= 0; x
< 1; x
++)
504 rc
= memcached_set(memc
, key
, strlen(key
),
506 (time_t)0, (uint32_t)0);
507 assert(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
);
515 uint8_t get_test3(memcached_st
*memc
)
520 size_t value_length
= 8191;
522 size_t string_length
;
526 value
= (char*)malloc(value_length
);
529 for (x
= 0; x
< value_length
; x
++)
530 value
[x
] = (char) (x
% 127);
532 rc
= memcached_set(memc
, key
, strlen(key
),
534 (time_t)0, (uint32_t)0);
535 assert(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
);
537 string
= memcached_get(memc
, key
, strlen(key
),
538 &string_length
, &flags
, &rc
);
540 assert(rc
== MEMCACHED_SUCCESS
);
542 assert(string_length
== value_length
);
543 assert(!memcmp(string
, value
, string_length
));
551 uint8_t get_test4(memcached_st
*memc
)
556 size_t value_length
= 8191;
558 size_t string_length
;
562 value
= (char*)malloc(value_length
);
565 for (x
= 0; x
< value_length
; x
++)
566 value
[x
] = (char) (x
% 127);
568 rc
= memcached_set(memc
, key
, strlen(key
),
570 (time_t)0, (uint32_t)0);
571 assert(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
);
573 for (x
= 0; x
< 10; x
++)
575 string
= memcached_get(memc
, key
, strlen(key
),
576 &string_length
, &flags
, &rc
);
578 assert(rc
== MEMCACHED_SUCCESS
);
580 assert(string_length
== value_length
);
581 assert(!memcmp(string
, value
, string_length
));
590 /* Do not copy the style of this code, I just access hosts to testthis function */
591 uint8_t stats_servername_test(memcached_st
*memc
)
594 memcached_stat_st stat
;
595 rc
= memcached_stat_servername(&stat
, NULL
,
596 memc
->hosts
[0].hostname
,
597 memc
->hosts
[0].port
);
602 uint8_t increment_test(memcached_st
*memc
)
609 rc
= memcached_set(memc
, key
, strlen(key
),
610 value
, strlen(value
),
611 (time_t)0, (uint32_t)0);
612 assert(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
);
614 rc
= memcached_increment(memc
, key
, strlen(key
),
616 assert(rc
== MEMCACHED_SUCCESS
);
617 assert(new_number
== 1);
619 rc
= memcached_increment(memc
, key
, strlen(key
),
621 assert(rc
== MEMCACHED_SUCCESS
);
622 assert(new_number
== 2);
627 uint8_t decrement_test(memcached_st
*memc
)
634 rc
= memcached_set(memc
, key
, strlen(key
),
635 value
, strlen(value
),
636 (time_t)0, (uint32_t)0);
637 assert(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
);
639 rc
= memcached_decrement(memc
, key
, strlen(key
),
641 assert(rc
== MEMCACHED_SUCCESS
);
642 assert(new_number
== 2);
644 rc
= memcached_decrement(memc
, key
, strlen(key
),
646 assert(rc
== MEMCACHED_SUCCESS
);
647 assert(new_number
== 1);
652 uint8_t quit_test(memcached_st
*memc
)
656 char *value
= "sanford and sun";
658 rc
= memcached_set(memc
, key
, strlen(key
),
659 value
, strlen(value
),
660 (time_t)10, (uint32_t)3);
661 assert(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
);
662 memcached_quit(memc
);
664 rc
= memcached_set(memc
, key
, strlen(key
),
665 value
, strlen(value
),
666 (time_t)50, (uint32_t)9);
667 assert(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
);
672 uint8_t mget_result_test(memcached_st
*memc
)
675 char *keys
[]= {"fudge", "son", "food"};
676 size_t key_length
[]= {5, 3, 4};
679 memcached_result_st results_obj
;
680 memcached_result_st
*results
;
682 results
= memcached_result_create(memc
, &results_obj
);
684 assert(&results_obj
== results
);
686 /* We need to empty the server before continueing test */
687 rc
= memcached_flush(memc
, 0);
688 assert(rc
== MEMCACHED_SUCCESS
);
690 rc
= memcached_mget(memc
, keys
, key_length
, 3);
691 assert(rc
== MEMCACHED_SUCCESS
);
693 while ((results
= memcached_fetch_result(memc
, &results_obj
, &rc
)) != NULL
)
698 while ((results
= memcached_fetch_result(memc
, &results_obj
, &rc
)) != NULL
)
700 assert(rc
== MEMCACHED_END
);
702 for (x
= 0; x
< 3; x
++)
704 rc
= memcached_set(memc
, keys
[x
], key_length
[x
],
705 keys
[x
], key_length
[x
],
706 (time_t)50, (uint32_t)9);
707 assert(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
);
710 rc
= memcached_mget(memc
, keys
, key_length
, 3);
711 assert(rc
== MEMCACHED_SUCCESS
);
713 while ((results
= memcached_fetch_result(memc
, &results_obj
, &rc
)))
716 assert(&results_obj
== results
);
717 assert(rc
== MEMCACHED_SUCCESS
);
718 assert(memcached_result_key_length(results
) == memcached_result_length(results
));
719 assert(!memcmp(memcached_result_key_value(results
),
720 memcached_result_value(results
),
721 memcached_result_length(results
)));
724 memcached_result_free(&results_obj
);
729 uint8_t mget_result_alloc_test(memcached_st
*memc
)
732 char *keys
[]= {"fudge", "son", "food"};
733 size_t key_length
[]= {5, 3, 4};
736 memcached_result_st
*results
;
738 /* We need to empty the server before continueing test */
739 rc
= memcached_flush(memc
, 0);
740 assert(rc
== MEMCACHED_SUCCESS
);
742 rc
= memcached_mget(memc
, keys
, key_length
, 3);
743 assert(rc
== MEMCACHED_SUCCESS
);
745 while ((results
= memcached_fetch_result(memc
, NULL
, &rc
)) != NULL
)
750 assert(rc
== MEMCACHED_END
);
752 for (x
= 0; x
< 3; x
++)
754 rc
= memcached_set(memc
, keys
[x
], key_length
[x
],
755 keys
[x
], key_length
[x
],
756 (time_t)50, (uint32_t)9);
757 assert(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
);
760 rc
= memcached_mget(memc
, keys
, key_length
, 3);
761 assert(rc
== MEMCACHED_SUCCESS
);
764 while ((results
= memcached_fetch_result(memc
, NULL
, &rc
)))
767 assert(rc
== MEMCACHED_SUCCESS
);
768 assert(memcached_result_key_length(results
) == memcached_result_length(results
));
769 assert(!memcmp(memcached_result_key_value(results
),
770 memcached_result_value(results
),
771 memcached_result_length(results
)));
772 memcached_result_free(results
);
779 /* Count the results */
780 unsigned int callback_counter(memcached_st
*ptr
, memcached_result_st
*result
, void *context
)
782 unsigned int *counter
= (unsigned int *)context
;
784 *counter
= *counter
+ 1;
789 uint8_t mget_result_function(memcached_st
*memc
)
792 char *keys
[]= {"fudge", "son", "food"};
793 size_t key_length
[]= {5, 3, 4};
795 unsigned int counter
;
796 unsigned int (*callbacks
[1])(memcached_st
*, memcached_result_st
*, void *);
798 /* We need to empty the server before continueing test */
799 rc
= memcached_flush(memc
, 0);
800 for (x
= 0; x
< 3; x
++)
802 rc
= memcached_set(memc
, keys
[x
], key_length
[x
],
803 keys
[x
], key_length
[x
],
804 (time_t)50, (uint32_t)9);
805 assert(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
);
808 rc
= memcached_mget(memc
, keys
, key_length
, 3);
809 assert(rc
== MEMCACHED_SUCCESS
);
811 callbacks
[0]= &callback_counter
;
813 rc
= memcached_fetch_execute(memc
, callbacks
, (void *)&counter
, 1);
815 assert(counter
== 3);
820 uint8_t mget_test(memcached_st
*memc
)
823 char *keys
[]= {"fudge", "son", "food"};
824 size_t key_length
[]= {5, 3, 4};
828 char return_key
[MEMCACHED_MAX_KEY
];
829 size_t return_key_length
;
831 size_t return_value_length
;
833 /* We need to empty the server before continueing test */
834 rc
= memcached_flush(memc
, 0);
835 assert(rc
== MEMCACHED_SUCCESS
);
837 rc
= memcached_mget(memc
, keys
, key_length
, 3);
838 assert(rc
== MEMCACHED_SUCCESS
);
840 while ((return_value
= memcached_fetch(memc
, return_key
, &return_key_length
,
841 &return_value_length
, &flags
, &rc
)) != NULL
)
843 assert(return_value
);
845 assert(!return_value
);
846 assert(return_value_length
== 0);
847 assert(rc
== MEMCACHED_END
);
849 for (x
= 0; x
< 3; x
++)
851 rc
= memcached_set(memc
, keys
[x
], key_length
[x
],
852 keys
[x
], key_length
[x
],
853 (time_t)50, (uint32_t)9);
854 assert(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
);
857 rc
= memcached_mget(memc
, keys
, key_length
, 3);
858 assert(rc
== MEMCACHED_SUCCESS
);
861 while ((return_value
= memcached_fetch(memc
, return_key
, &return_key_length
,
862 &return_value_length
, &flags
, &rc
)))
864 assert(return_value
);
865 assert(rc
== MEMCACHED_SUCCESS
);
866 assert(return_key_length
== return_value_length
);
867 assert(!memcmp(return_value
, return_key
, return_value_length
));
875 uint8_t get_stats_keys(memcached_st
*memc
)
879 memcached_stat_st stat
;
882 list
= memcached_stat_get_keys(memc
, &stat
, &rc
);
883 assert(rc
== MEMCACHED_SUCCESS
);
884 for (ptr
= list
; *ptr
; ptr
++)
885 printf("Found key %s\n", *ptr
);
893 uint8_t get_stats(memcached_st
*memc
)
899 memcached_stat_st
*stat
;
901 stat
= memcached_stat(memc
, NULL
, &rc
);
902 assert(rc
== MEMCACHED_SUCCESS
);
904 assert(rc
== MEMCACHED_SUCCESS
);
907 for (x
= 0; x
< memcached_server_count(memc
); x
++)
909 list
= memcached_stat_get_keys(memc
, stat
+x
, &rc
);
910 assert(rc
== MEMCACHED_SUCCESS
);
911 for (ptr
= list
; *ptr
; ptr
++);
916 memcached_stat_free(NULL
, stat
);
921 uint8_t add_host_test(memcached_st
*memc
)
924 memcached_server_st
*servers
;
926 char servername
[]= "0.example.com";
928 servers
= memcached_server_list_append(NULL
, servername
, 400, &rc
);
930 assert(1 == memcached_server_list_count(servers
));
932 for (x
= 2; x
< 20; x
++)
934 char buffer
[SMALL_STRING_LEN
];
936 snprintf(buffer
, SMALL_STRING_LEN
, "%u.example.com", 400+x
);
937 servers
= memcached_server_list_append(servers
, buffer
, 401,
939 assert(rc
== MEMCACHED_SUCCESS
);
940 assert(x
== memcached_server_list_count(servers
));
943 rc
= memcached_server_push(memc
, servers
);
944 assert(rc
== MEMCACHED_SUCCESS
);
945 rc
= memcached_server_push(memc
, servers
);
946 assert(rc
== MEMCACHED_SUCCESS
);
948 memcached_server_list_free(servers
);
953 /* We don't test the behavior itself, we test the switches */
954 uint8_t behavior_test(memcached_st
*memc
)
956 unsigned long long value
;
959 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NO_BLOCK
, &set
);
960 value
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_NO_BLOCK
);
963 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_TCP_NODELAY
, &set
);
964 value
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_TCP_NODELAY
);
967 set
= MEMCACHED_HASH_MD5
;
968 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_HASH
, &set
);
969 value
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_HASH
);
970 assert(value
== MEMCACHED_HASH_MD5
);
974 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NO_BLOCK
, &set
);
975 value
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_NO_BLOCK
);
978 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_TCP_NODELAY
, &set
);
979 value
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_TCP_NODELAY
);
982 set
= MEMCACHED_HASH_DEFAULT
;
983 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_HASH
, &set
);
984 value
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_HASH
);
985 assert(value
== MEMCACHED_HASH_DEFAULT
);
987 set
= MEMCACHED_HASH_CRC
;
988 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_HASH
, &set
);
989 value
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_HASH
);
990 assert(value
== MEMCACHED_HASH_CRC
);
992 value
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_SOCKET_SEND_SIZE
);
995 value
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_SOCKET_RECV_SIZE
);
1001 /* Test case provided by Cal Haldenbrand */
1002 uint8_t user_supplied_bug1(memcached_st
*memc
)
1004 unsigned int setter
= 1;
1007 unsigned long long total
= 0;
1010 char randomstuff
[6 * 1024];
1011 memcached_return rc
;
1013 memset(randomstuff
, 0, 6 * 1024);
1015 /* We just keep looking at the same values over and over */
1018 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NO_BLOCK
, &setter
);
1019 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_TCP_NODELAY
, &setter
);
1023 for (x
= 0 ; total
< 20 * 1024576 ; x
++ )
1027 size
= (rand() % ( 5 * 1024 ) ) + 400;
1028 memset(randomstuff
, 0, 6 * 1024);
1029 assert(size
< 6 * 1024); /* Being safe here */
1031 for (j
= 0 ; j
< size
;j
++)
1032 randomstuff
[j
] = (char) (rand() % 26) + 97;
1035 sprintf(key
, "%d", x
);
1036 rc
= memcached_set(memc
, key
, strlen(key
),
1037 randomstuff
, strlen(randomstuff
), 10, 0);
1038 /* If we fail, lets try again */
1039 if (rc
!= MEMCACHED_SUCCESS
&& rc
!= MEMCACHED_BUFFERED
)
1040 rc
= memcached_set(memc
, key
, strlen(key
),
1041 randomstuff
, strlen(randomstuff
), 10, 0);
1042 assert(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
);
1048 /* Test case provided by Cal Haldenbrand */
1049 uint8_t user_supplied_bug2(memcached_st
*memc
)
1052 unsigned int setter
;
1054 unsigned long long total
;
1057 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NO_BLOCK
, &setter
);
1058 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_TCP_NODELAY
, &setter
);
1060 setter
= 20 * 1024576;
1061 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_SOCKET_SEND_SIZE
, &setter
);
1062 setter
= 20 * 1024576;
1063 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_SOCKET_RECV_SIZE
, &setter
);
1064 getter
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_SOCKET_SEND_SIZE
);
1065 getter
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_SOCKET_RECV_SIZE
);
1067 for (x
= 0, errors
= 0, total
= 0 ; total
< 20 * 1024576 ; x
++)
1070 for (x
= 0, errors
= 0, total
= 0 ; total
< 24576 ; x
++)
1072 memcached_return rc
= MEMCACHED_SUCCESS
;
1073 char buffer
[SMALL_STRING_LEN
];
1078 memset(buffer
, 0, SMALL_STRING_LEN
);
1080 snprintf(buffer
, SMALL_STRING_LEN
, "%u", x
);
1081 getval
= memcached_get(memc
, buffer
, strlen(buffer
),
1082 &val_len
, &flags
, &rc
);
1083 if (rc
!= MEMCACHED_SUCCESS
)
1085 if (rc
== MEMCACHED_NOTFOUND
)
1100 /* Do a large mget() over all the keys we think exist */
1101 #define KEY_COUNT 3000 // * 1024576
1102 uint8_t user_supplied_bug3(memcached_st
*memc
)
1104 memcached_return rc
;
1105 unsigned int setter
;
1108 size_t key_lengths
[KEY_COUNT
];
1111 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NO_BLOCK
, &setter
);
1112 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_TCP_NODELAY
, &setter
);
1114 setter
= 20 * 1024576;
1115 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_SOCKET_SEND_SIZE
, &setter
);
1116 setter
= 20 * 1024576;
1117 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_SOCKET_RECV_SIZE
, &setter
);
1118 getter
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_SOCKET_SEND_SIZE
);
1119 getter
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_SOCKET_RECV_SIZE
);
1122 keys
= (char **)malloc(sizeof(char *) * KEY_COUNT
);
1124 memset(keys
, 0, (sizeof(char *) * KEY_COUNT
));
1125 for (x
= 0; x
< KEY_COUNT
; x
++)
1129 snprintf(buffer
, 30, "%u", x
);
1130 keys
[x
]= strdup(buffer
);
1131 key_lengths
[x
]= strlen(keys
[x
]);
1134 rc
= memcached_mget(memc
, keys
, key_lengths
, KEY_COUNT
);
1135 assert(rc
== MEMCACHED_SUCCESS
);
1137 /* Turn this into a help function */
1139 char return_key
[MEMCACHED_MAX_KEY
];
1140 size_t return_key_length
;
1142 size_t return_value_length
;
1145 while ((return_value
= memcached_fetch(memc
, return_key
, &return_key_length
,
1146 &return_value_length
, &flags
, &rc
)))
1148 assert(return_value
);
1149 assert(rc
== MEMCACHED_SUCCESS
);
1154 for (x
= 0; x
< KEY_COUNT
; x
++)
1161 /* Make sure we behave properly if server list has no values */
1162 uint8_t user_supplied_bug4(memcached_st
*memc
)
1164 memcached_return rc
;
1165 char *keys
[]= {"fudge", "son", "food"};
1166 size_t key_length
[]= {5, 3, 4};
1169 char return_key
[MEMCACHED_MAX_KEY
];
1170 size_t return_key_length
;
1172 size_t return_value_length
;
1174 /* Here we free everything before running a bunch of mget tests */
1176 memcached_server_list_free(memc
->hosts
);
1178 memc
->number_of_hosts
= 0;
1182 /* We need to empty the server before continueing test */
1183 rc
= memcached_flush(memc
, 0);
1184 assert(rc
== MEMCACHED_NO_SERVERS
);
1186 rc
= memcached_mget(memc
, keys
, key_length
, 3);
1187 assert(rc
== MEMCACHED_NO_SERVERS
);
1189 while ((return_value
= memcached_fetch(memc
, return_key
, &return_key_length
,
1190 &return_value_length
, &flags
, &rc
)) != NULL
)
1192 assert(return_value
);
1194 assert(!return_value
);
1195 assert(return_value_length
== 0);
1196 assert(rc
== MEMCACHED_NO_SERVERS
);
1198 for (x
= 0; x
< 3; x
++)
1200 rc
= memcached_set(memc
, keys
[x
], key_length
[x
],
1201 keys
[x
], key_length
[x
],
1202 (time_t)50, (uint32_t)9);
1203 assert(rc
== MEMCACHED_NO_SERVERS
);
1206 rc
= memcached_mget(memc
, keys
, key_length
, 3);
1207 assert(rc
== MEMCACHED_NO_SERVERS
);
1210 while ((return_value
= memcached_fetch(memc
, return_key
, &return_key_length
,
1211 &return_value_length
, &flags
, &rc
)))
1213 assert(return_value
);
1214 assert(rc
== MEMCACHED_SUCCESS
);
1215 assert(return_key_length
== return_value_length
);
1216 assert(!memcmp(return_value
, return_key
, return_value_length
));
1224 #define VALUE_SIZE_BUG5 1048064
1225 uint8_t user_supplied_bug5(memcached_st
*memc
)
1227 memcached_return rc
;
1228 char *keys
[]= {"036790384900", "036790384902", "036790384904", "036790384906"};
1229 size_t key_length
[]= {strlen("036790384900"), strlen("036790384902"), strlen("036790384904"), strlen("036790384906")};
1230 char return_key
[MEMCACHED_MAX_KEY
];
1231 size_t return_key_length
;
1233 size_t value_length
;
1237 char insert_data
[VALUE_SIZE_BUG5
];
1239 for (x
= 0; x
< VALUE_SIZE_BUG5
; x
++)
1240 insert_data
[x
]= rand();
1242 memcached_flush(memc
, 0);
1243 value
= memcached_get(memc
, keys
[0], key_length
[0],
1244 &value_length
, &flags
, &rc
);
1245 assert(value
== NULL
);
1246 rc
= memcached_mget(memc
, keys
, key_length
, 4);
1249 while ((value
= memcached_fetch(memc
, return_key
, &return_key_length
,
1250 &value_length
, &flags
, &rc
)))
1254 for (x
= 0; x
< 4; x
++)
1256 rc
= memcached_set(memc
, keys
[x
], key_length
[x
],
1257 insert_data
, VALUE_SIZE_BUG5
,
1258 (time_t)0, (uint32_t)0);
1259 assert(rc
== MEMCACHED_SUCCESS
);
1262 for (x
= 0; x
< 10; x
++)
1264 value
= memcached_get(memc
, keys
[0], key_length
[0],
1265 &value_length
, &flags
, &rc
);
1269 rc
= memcached_mget(memc
, keys
, key_length
, 4);
1271 while ((value
= memcached_fetch(memc
, return_key
, &return_key_length
,
1272 &value_length
, &flags
, &rc
)))
1283 uint8_t user_supplied_bug6(memcached_st
*memc
)
1285 memcached_return rc
;
1286 char *keys
[]= {"036790384900", "036790384902", "036790384904", "036790384906"};
1287 size_t key_length
[]= {strlen("036790384900"), strlen("036790384902"), strlen("036790384904"), strlen("036790384906")};
1288 char return_key
[MEMCACHED_MAX_KEY
];
1289 size_t return_key_length
;
1291 size_t value_length
;
1295 char insert_data
[VALUE_SIZE_BUG5
];
1297 for (x
= 0; x
< VALUE_SIZE_BUG5
; x
++)
1298 insert_data
[x
]= rand();
1300 memcached_flush(memc
, 0);
1301 value
= memcached_get(memc
, keys
[0], key_length
[0],
1302 &value_length
, &flags
, &rc
);
1303 assert(value
== NULL
);
1304 assert(rc
== MEMCACHED_NOTFOUND
);
1305 rc
= memcached_mget(memc
, keys
, key_length
, 4);
1306 assert(rc
== MEMCACHED_SUCCESS
);
1309 while ((value
= memcached_fetch(memc
, return_key
, &return_key_length
,
1310 &value_length
, &flags
, &rc
)))
1313 assert(rc
== MEMCACHED_END
);
1315 for (x
= 0; x
< 4; x
++)
1317 rc
= memcached_set(memc
, keys
[x
], key_length
[x
],
1318 insert_data
, VALUE_SIZE_BUG5
,
1319 (time_t)0, (uint32_t)0);
1320 assert(rc
== MEMCACHED_SUCCESS
);
1323 for (x
= 0; x
< 2; x
++)
1325 value
= memcached_get(memc
, keys
[0], key_length
[0],
1326 &value_length
, &flags
, &rc
);
1330 rc
= memcached_mget(memc
, keys
, key_length
, 4);
1331 assert(rc
== MEMCACHED_SUCCESS
);
1333 /* We test for purge of partial complete fetches */
1334 for (count
= 3; count
; count
--)
1336 value
= memcached_fetch(memc
, return_key
, &return_key_length
,
1337 &value_length
, &flags
, &rc
);
1338 assert(rc
== MEMCACHED_SUCCESS
);
1339 assert(!(memcmp(value
, insert_data
, value_length
)));
1340 assert(value_length
);
1348 uint8_t user_supplied_bug8(memcached_st
*memc
)
1350 memcached_return rc
;
1352 memcached_st
*clone
;
1354 memcached_server_st
*servers
;
1355 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 servers
= memcached_servers_parse(server_list
);
1360 mine
= memcached_create(NULL
);
1361 rc
= memcached_server_push(mine
, servers
);
1362 assert(rc
== MEMCACHED_SUCCESS
);
1363 memcached_server_list_free(servers
);
1366 clone
= memcached_clone(NULL
, mine
);
1368 memcached_quit(mine
);
1369 memcached_quit(clone
);
1372 memcached_free(mine
);
1373 memcached_free(clone
);
1378 /* Test flag store/retrieve */
1379 uint8_t user_supplied_bug7(memcached_st
*memc
)
1381 memcached_return rc
;
1382 char *keys
= "036790384900";
1383 size_t key_length
= strlen("036790384900");
1384 char return_key
[MEMCACHED_MAX_KEY
];
1385 size_t return_key_length
;
1387 size_t value_length
;
1390 char insert_data
[VALUE_SIZE_BUG5
];
1392 for (x
= 0; x
< VALUE_SIZE_BUG5
; x
++)
1393 insert_data
[x
]= rand();
1395 memcached_flush(memc
, 0);
1398 rc
= memcached_set(memc
, keys
, key_length
,
1399 insert_data
, VALUE_SIZE_BUG5
,
1401 assert(rc
== MEMCACHED_SUCCESS
);
1404 value
= memcached_get(memc
, keys
, key_length
,
1405 &value_length
, &flags
, &rc
);
1406 assert(flags
== 245);
1410 rc
= memcached_mget(memc
, &keys
, &key_length
, 1);
1413 value
= memcached_fetch(memc
, return_key
, &return_key_length
,
1414 &value_length
, &flags
, &rc
);
1415 assert(flags
== 245);
1423 uint8_t user_supplied_bug9(memcached_st
*memc
)
1425 memcached_return rc
;
1426 char *keys
[]= {"UDATA:edevil@sapo.pt", "fudge&*@#", "for^#@&$not"};
1427 size_t key_length
[3];
1432 char return_key
[MEMCACHED_MAX_KEY
];
1433 size_t return_key_length
;
1435 size_t return_value_length
;
1438 key_length
[0]= strlen("UDATA:edevil@sapo.pt");
1439 key_length
[1]= strlen("fudge&*@#");
1440 key_length
[2]= strlen("for^#@&$not");
1443 for (x
= 0; x
< 3; x
++)
1445 rc
= memcached_set(memc
, keys
[x
], key_length
[x
],
1446 keys
[x
], key_length
[x
],
1447 (time_t)50, (uint32_t)9);
1448 assert(rc
== MEMCACHED_SUCCESS
);
1451 rc
= memcached_mget(memc
, keys
, key_length
, 3);
1452 assert(rc
== MEMCACHED_SUCCESS
);
1454 /* We need to empty the server before continueing test */
1455 while ((return_value
= memcached_fetch(memc
, return_key
, &return_key_length
,
1456 &return_value_length
, &flags
, &rc
)) != NULL
)
1458 assert(return_value
);
1467 /* We are testing with aggressive timeout to get failures */
1468 uint8_t user_supplied_bug10(memcached_st
*memc
)
1472 size_t value_length
= 512;
1475 memcached_return rc
;
1476 unsigned int set
= 1;
1477 memcached_st
*mclone
= memcached_clone(NULL
, memc
);
1480 memcached_behavior_set(mclone
, MEMCACHED_BEHAVIOR_NO_BLOCK
, &set
);
1481 memcached_behavior_set(mclone
, MEMCACHED_BEHAVIOR_TCP_NODELAY
, &set
);
1483 memcached_behavior_set(mclone
, MEMCACHED_BEHAVIOR_POLL_TIMEOUT
, &timeout
);
1485 value
= (char*)malloc(value_length
* sizeof(char));
1487 for (x
= 0; x
< value_length
; x
++)
1488 value
[x
]= (char) (x
% 127);
1490 for (x
= 1; x
<= 100000; ++x
)
1492 rc
= memcached_set(mclone
, key
, key_len
,value
, value_length
, 0, 0);
1494 assert(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_WRITE_FAILURE
|| rc
== MEMCACHED_BUFFERED
);
1496 if (rc
== MEMCACHED_WRITE_FAILURE
)
1501 memcached_free(mclone
);
1507 We are looking failures in the async protocol
1509 uint8_t user_supplied_bug11(memcached_st
*memc
)
1513 size_t value_length
= 512;
1516 memcached_return rc
;
1517 unsigned int set
= 1;
1519 memcached_st
*mclone
= memcached_clone(NULL
, memc
);
1521 memcached_behavior_set(mclone
, MEMCACHED_BEHAVIOR_NO_BLOCK
, &set
);
1522 memcached_behavior_set(mclone
, MEMCACHED_BEHAVIOR_TCP_NODELAY
, &set
);
1524 memcached_behavior_set(mclone
, MEMCACHED_BEHAVIOR_POLL_TIMEOUT
, &timeout
);
1526 timeout
= (int32_t)memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_POLL_TIMEOUT
);
1528 assert(timeout
== -1);
1530 value
= (char*)malloc(value_length
* sizeof(char));
1532 for (x
= 0; x
< value_length
; x
++)
1533 value
[x
]= (char) (x
% 127);
1535 for (x
= 1; x
<= 100000; ++x
)
1537 rc
= memcached_set(mclone
, key
, key_len
,value
, value_length
, 0, 0);
1539 WATCHPOINT_IFERROR(rc
);
1543 memcached_free(mclone
);
1548 uint8_t result_static(memcached_st
*memc
)
1550 memcached_result_st result
;
1551 memcached_result_st
*result_ptr
;
1553 result_ptr
= memcached_result_create(memc
, &result
);
1554 assert(result
.is_allocated
== MEMCACHED_NOT_ALLOCATED
);
1556 memcached_result_free(&result
);
1561 uint8_t result_alloc(memcached_st
*memc
)
1563 memcached_result_st
*result
;
1565 result
= memcached_result_create(memc
, NULL
);
1567 memcached_result_free(result
);
1572 uint8_t string_static_null(memcached_st
*memc
)
1574 memcached_string_st string
;
1575 memcached_string_st
*string_ptr
;
1577 string_ptr
= memcached_string_create(memc
, &string
, 0);
1578 assert(string
.is_allocated
== MEMCACHED_NOT_ALLOCATED
);
1580 memcached_string_free(&string
);
1585 uint8_t string_alloc_null(memcached_st
*memc
)
1587 memcached_string_st
*string
;
1589 string
= memcached_string_create(memc
, NULL
, 0);
1591 memcached_string_free(string
);
1596 uint8_t string_alloc_with_size(memcached_st
*memc
)
1598 memcached_string_st
*string
;
1600 string
= memcached_string_create(memc
, NULL
, 1024);
1602 memcached_string_free(string
);
1607 uint8_t string_alloc_with_size_toobig(memcached_st
*memc
)
1609 memcached_string_st
*string
;
1611 string
= memcached_string_create(memc
, NULL
, INT64_MAX
);
1612 assert(string
== NULL
);
1617 uint8_t string_alloc_append(memcached_st
*memc
)
1620 char buffer
[SMALL_STRING_LEN
];
1621 memcached_string_st
*string
;
1623 /* Ring the bell! */
1624 memset(buffer
, 6, SMALL_STRING_LEN
);
1626 string
= memcached_string_create(memc
, NULL
, 100);
1629 for (x
= 0; x
< 1024; x
++)
1631 memcached_return rc
;
1632 rc
= memcached_string_append(string
, buffer
, SMALL_STRING_LEN
);
1633 assert(rc
== MEMCACHED_SUCCESS
);
1635 memcached_string_free(string
);
1640 uint8_t string_alloc_append_toobig(memcached_st
*memc
)
1642 memcached_return rc
;
1644 char buffer
[SMALL_STRING_LEN
];
1645 memcached_string_st
*string
;
1647 /* Ring the bell! */
1648 memset(buffer
, 6, SMALL_STRING_LEN
);
1650 string
= memcached_string_create(memc
, NULL
, 100);
1653 for (x
= 0; x
< 1024; x
++)
1655 rc
= memcached_string_append(string
, buffer
, SMALL_STRING_LEN
);
1656 assert(rc
== MEMCACHED_SUCCESS
);
1658 rc
= memcached_string_append(string
, buffer
, INT64_MAX
);
1659 assert(rc
== MEMCACHED_MEMORY_ALLOCATION_FAILURE
);
1660 memcached_string_free(string
);
1665 uint8_t cleanup_pairs(memcached_st
*memc
)
1667 pairs_free(global_pairs
);
1672 uint8_t generate_data(memcached_st
*memc
)
1674 unsigned long long x
;
1675 global_pairs
= pairs_generate(GLOBAL_COUNT
);
1676 execute_set(memc
, global_pairs
, GLOBAL_COUNT
);
1678 for (x
= 0; x
< GLOBAL_COUNT
; x
++)
1680 global_keys
[x
]= global_pairs
[x
].key
;
1681 global_keys_length
[x
]= global_pairs
[x
].key_length
;
1687 uint8_t generate_buffer_data(memcached_st
*memc
)
1692 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_BUFFER_REQUESTS
, &latch
);
1693 generate_data(memc
);
1699 uint8_t mset_data(memcached_st
*memc
)
1701 unsigned long long x
;
1702 global_pairs
= pairs_generate(GLOBAL_COUNT
);
1704 (void)memcached_delete(memc
, global_keys
[x
], global_keys_length
[x
], (time_t)0);
1706 for (x
= 0; x
< GLOBAL_COUNT
; x
++)
1708 global_keys
[x
]= global_pairs
[x
].key
;
1709 global_keys_length
[x
]= global_pairs
[x
].key_length
;
1716 uint8_t get_read(memcached_st
*memc
)
1719 memcached_return rc
;
1723 size_t return_value_length
;
1726 for (x
= 0; x
< GLOBAL_COUNT
; x
++)
1728 return_value
= memcached_get(memc
, global_keys
[x
], global_keys_length
[x
],
1729 &return_value_length
, &flags
, &rc
);
1731 assert(return_value);
1732 assert(rc == MEMCACHED_SUCCESS);
1734 if (rc
== MEMCACHED_SUCCESS
&& return_value
)
1742 uint8_t mget_read(memcached_st
*memc
)
1744 memcached_return rc
;
1746 rc
= memcached_mget(memc
, global_keys
, global_keys_length
, GLOBAL_COUNT
);
1747 assert(rc
== MEMCACHED_SUCCESS
);
1748 /* Turn this into a help function */
1750 char return_key
[MEMCACHED_MAX_KEY
];
1751 size_t return_key_length
;
1753 size_t return_value_length
;
1756 while ((return_value
= memcached_fetch(memc
, return_key
, &return_key_length
,
1757 &return_value_length
, &flags
, &rc
)))
1759 assert(return_value
);
1760 assert(rc
== MEMCACHED_SUCCESS
);
1768 uint8_t mget_read_result(memcached_st
*memc
)
1770 memcached_return rc
;
1772 rc
= memcached_mget(memc
, global_keys
, global_keys_length
, GLOBAL_COUNT
);
1773 assert(rc
== MEMCACHED_SUCCESS
);
1774 /* Turn this into a help function */
1776 memcached_result_st results_obj
;
1777 memcached_result_st
*results
;
1779 results
= memcached_result_create(memc
, &results_obj
);
1781 while ((results
= memcached_fetch_result(memc
, &results_obj
, &rc
)))
1784 assert(rc
== MEMCACHED_SUCCESS
);
1787 memcached_result_free(&results_obj
);
1793 uint8_t mget_read_function(memcached_st
*memc
)
1795 memcached_return rc
;
1796 unsigned int counter
;
1797 unsigned int (*callbacks
[1])(memcached_st
*, memcached_result_st
*, void *);
1799 rc
= memcached_mget(memc
, global_keys
, global_keys_length
, GLOBAL_COUNT
);
1800 assert(rc
== MEMCACHED_SUCCESS
);
1802 callbacks
[0]= &callback_counter
;
1804 rc
= memcached_fetch_execute(memc
, callbacks
, (void *)&counter
, 1);
1809 uint8_t delete_generate(memcached_st
*memc
)
1813 for (x
= 0; x
< GLOBAL_COUNT
; x
++)
1815 (void)memcached_delete(memc
, global_keys
[x
], global_keys_length
[x
], (time_t)0);
1821 uint8_t delete_buffer_generate(memcached_st
*memc
)
1827 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_BUFFER_REQUESTS
, &latch
);
1829 for (x
= 0; x
< GLOBAL_COUNT
; x
++)
1831 (void)memcached_delete(memc
, global_keys
[x
], global_keys_length
[x
], (time_t)0);
1837 uint8_t free_data(memcached_st
*memc
)
1839 pairs_free(global_pairs
);
1844 uint8_t add_host_test1(memcached_st
*memc
)
1847 memcached_return rc
;
1848 char servername
[]= "0.example.com";
1849 memcached_server_st
*servers
;
1851 servers
= memcached_server_list_append(NULL
, servername
, 400, &rc
);
1853 assert(1 == memcached_server_list_count(servers
));
1855 for (x
= 2; x
< 20; x
++)
1857 char buffer
[SMALL_STRING_LEN
];
1859 snprintf(buffer
, SMALL_STRING_LEN
, "%u.example.com", 400+x
);
1860 servers
= memcached_server_list_append(servers
, buffer
, 401,
1862 assert(rc
== MEMCACHED_SUCCESS
);
1863 assert(x
== memcached_server_list_count(servers
));
1866 rc
= memcached_server_push(memc
, servers
);
1867 assert(rc
== MEMCACHED_SUCCESS
);
1868 rc
= memcached_server_push(memc
, servers
);
1869 assert(rc
== MEMCACHED_SUCCESS
);
1871 memcached_server_list_free(servers
);
1876 memcached_return
pre_nonblock(memcached_st
*memc
)
1878 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NO_BLOCK
, NULL
);
1880 return MEMCACHED_SUCCESS
;
1883 memcached_return
pre_md5(memcached_st
*memc
)
1885 memcached_hash value
= MEMCACHED_HASH_MD5
;
1886 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_HASH
, &value
);
1888 return MEMCACHED_SUCCESS
;
1891 memcached_return
pre_crc(memcached_st
*memc
)
1893 memcached_hash value
= MEMCACHED_HASH_CRC
;
1894 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_HASH
, &value
);
1896 return MEMCACHED_SUCCESS
;
1899 memcached_return
pre_hsieh(memcached_st
*memc
)
1901 memcached_hash value
= MEMCACHED_HASH_HSIEH
;
1902 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_HASH
, &value
);
1904 return MEMCACHED_SUCCESS
;
1907 memcached_return
pre_hash_fnv1_64(memcached_st
*memc
)
1909 memcached_hash value
= MEMCACHED_HASH_FNV1_64
;
1910 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_HASH
, &value
);
1912 return MEMCACHED_SUCCESS
;
1915 memcached_return
pre_hash_fnv1a_64(memcached_st
*memc
)
1917 memcached_hash value
= MEMCACHED_HASH_FNV1A_64
;
1918 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_HASH
, &value
);
1920 return MEMCACHED_SUCCESS
;
1923 memcached_return
pre_hash_fnv1_32(memcached_st
*memc
)
1925 memcached_hash value
= MEMCACHED_HASH_FNV1_32
;
1926 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_HASH
, &value
);
1928 return MEMCACHED_SUCCESS
;
1931 memcached_return
pre_hash_fnv1a_32(memcached_st
*memc
)
1933 memcached_hash value
= MEMCACHED_HASH_FNV1A_32
;
1934 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_HASH
, &value
);
1936 return MEMCACHED_SUCCESS
;
1939 memcached_return
pre_hash_ketama(memcached_st
*memc
)
1941 memcached_hash value
= MEMCACHED_HASH_KETAMA
;
1942 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_HASH
, &value
);
1944 return MEMCACHED_SUCCESS
;
1947 memcached_return
enable_consistent(memcached_st
*memc
)
1949 memcached_server_distribution value
= MEMCACHED_DISTRIBUTION_CONSISTENT
;
1950 memcached_hash hash
;
1951 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_DISTRIBUTION
, &value
);
1954 value
= (memcached_server_distribution
)memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_DISTRIBUTION
);
1955 assert(value
== MEMCACHED_DISTRIBUTION_CONSISTENT
);
1957 hash
= (memcached_hash
)memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_HASH
);
1958 assert(hash
== MEMCACHED_HASH_HSIEH
);
1961 return MEMCACHED_SUCCESS
;
1964 memcached_return
enable_cas(memcached_st
*memc
)
1966 unsigned int set
= 1;
1968 memcached_version(memc
);
1970 if (memc
->hosts
[0].major_version
>= 1 &&
1971 memc
->hosts
[0].minor_version
>= 2 &&
1972 memc
->hosts
[0].micro_version
>= 4)
1974 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_SUPPORT_CAS
, &set
);
1976 return MEMCACHED_SUCCESS
;
1979 return MEMCACHED_FAILURE
;
1982 memcached_return
check_for_1_2_3(memcached_st
*memc
)
1984 memcached_version(memc
);
1986 if (memc
->hosts
[0].major_version
>= 1 &&
1987 memc
->hosts
[0].minor_version
>= 2 &&
1988 memc
->hosts
[0].micro_version
>= 4)
1989 return MEMCACHED_SUCCESS
;
1991 return MEMCACHED_FAILURE
;
1994 memcached_return
pre_unix_socket(memcached_st
*memc
)
1996 memcached_return rc
;
1999 memcached_server_list_free(memc
->hosts
);
2001 memc
->number_of_hosts
= 0;
2003 if (stat("/tmp/memcached.socket", &buf
))
2004 return MEMCACHED_FAILURE
;
2006 rc
= memcached_server_add_unix_socket(memc
, "/tmp/memcached.socket");
2011 memcached_return
pre_udp(memcached_st
*memc
)
2013 memcached_return rc
;
2015 memcached_server_list_free(memc
->hosts
);
2017 memc
->number_of_hosts
= 0;
2020 return MEMCACHED_FAILURE
;
2022 rc
= memcached_server_add_udp(memc
, "localhost", MEMCACHED_DEFAULT_PORT
);
2027 memcached_return
pre_nodelay(memcached_st
*memc
)
2029 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NO_BLOCK
, NULL
);
2030 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_TCP_NODELAY
, NULL
);
2032 return MEMCACHED_SUCCESS
;
2035 memcached_return
poll_timeout(memcached_st
*memc
)
2041 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_POLL_TIMEOUT
, &timeout
);
2043 timeout
= (int32_t)memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_POLL_TIMEOUT
);
2045 assert(timeout
== 100);
2047 return MEMCACHED_SUCCESS
;
2051 /* Clean the server before beginning testing */
2053 {"flush", 0, flush_test
},
2054 {"init", 0, init_test
},
2055 {"allocation", 0, allocation_test
},
2056 {"server_list_null_test", 0, server_list_null_test
},
2057 {"clone_test", 0, clone_test
},
2058 {"error", 0, error_test
},
2059 {"set", 0, set_test
},
2060 {"set2", 0, set_test2
},
2061 {"set3", 0, set_test3
},
2062 {"add", 1, add_test
},
2063 {"replace", 0, replace_test
},
2064 {"delete", 1, delete_test
},
2065 {"get", 1, get_test
},
2066 {"get2", 0, get_test2
},
2067 {"get3", 0, get_test3
},
2068 {"get4", 0, get_test4
},
2069 {"stats_servername", 0, stats_servername_test
},
2070 {"increment", 0, increment_test
},
2071 {"decrement", 0, decrement_test
},
2072 {"quit", 0, quit_test
},
2073 {"mget", 1, mget_test
},
2074 {"mget_result", 1, mget_result_test
},
2075 {"mget_result_alloc", 1, mget_result_alloc_test
},
2076 {"mget_result_function", 1, mget_result_function
},
2077 {"get_stats", 0, get_stats
},
2078 {"add_host_test", 0, add_host_test
},
2079 {"get_stats_keys", 0, get_stats_keys
},
2080 {"behavior_test", 0, get_stats_keys
},
2084 test_st async_tests
[] ={
2085 {"add", 1, add_wrapper
},
2089 test_st string_tests
[] ={
2090 {"string static with null", 0, string_static_null
},
2091 {"string alloc with null", 0, string_alloc_null
},
2092 {"string alloc with 1K", 0, string_alloc_with_size
},
2093 {"string alloc with malloc failure", 0, string_alloc_with_size_toobig
},
2094 {"string append", 0, string_alloc_append
},
2095 {"string append failure (too big)", 0, string_alloc_append_toobig
},
2099 test_st result_tests
[] ={
2100 {"result static", 0, result_static
},
2101 {"result alloc", 0, result_alloc
},
2105 test_st version_1_2_3
[] ={
2106 {"append", 0, append_test
},
2107 {"prepend", 0, prepend_test
},
2108 {"cas", 0, cas_test
},
2109 {"cas2", 0, cas2_test
},
2110 {"append_binary", 0, append_binary_test
},
2114 test_st user_tests
[] ={
2115 {"user_supplied_bug1", 0, user_supplied_bug1
},
2116 {"user_supplied_bug2", 0, user_supplied_bug2
},
2117 {"user_supplied_bug3", 0, user_supplied_bug3
},
2118 {"user_supplied_bug4", 0, user_supplied_bug4
},
2119 {"user_supplied_bug5", 1, user_supplied_bug5
},
2120 {"user_supplied_bug6", 1, user_supplied_bug6
},
2121 {"user_supplied_bug7", 1, user_supplied_bug7
},
2122 {"user_supplied_bug8", 1, user_supplied_bug8
},
2123 {"user_supplied_bug9", 1, user_supplied_bug9
},
2124 {"user_supplied_bug10", 1, user_supplied_bug10
},
2125 {"user_supplied_bug11", 1, user_supplied_bug11
},
2129 test_st generate_tests
[] ={
2130 {"generate_data", 1, generate_data
},
2131 {"get_read", 0, get_read
},
2132 {"delete_generate", 0, delete_generate
},
2133 {"generate_buffer_data", 1, generate_buffer_data
},
2134 {"delete_buffer", 0, delete_buffer_generate
},
2135 {"generate_data", 1, generate_data
},
2136 {"mget_read", 0, mget_read
},
2137 {"mget_read_result", 0, mget_read_result
},
2138 {"mget_read_function", 0, mget_read_function
},
2139 {"cleanup", 1, cleanup_pairs
},
2144 collection_st collection
[] ={
2145 {"block", 0, 0, tests
},
2146 {"nonblock", pre_nonblock
, 0, tests
},
2147 {"nodelay", pre_nodelay
, 0, tests
},
2148 {"md5", pre_md5
, 0, tests
},
2149 {"crc", pre_crc
, 0, tests
},
2150 {"hsieh", pre_hsieh
, 0, tests
},
2151 {"fnv1_64", pre_hash_fnv1_64
, 0, tests
},
2152 {"fnv1a_64", pre_hash_fnv1a_64
, 0, tests
},
2153 {"fnv1_32", pre_hash_fnv1_32
, 0, tests
},
2154 {"fnv1a_32", pre_hash_fnv1a_32
, 0, tests
},
2155 {"ketama", pre_hash_ketama
, 0, tests
},
2156 {"unix_socket", pre_unix_socket
, 0, tests
},
2157 {"unix_socket_nodelay", pre_nodelay
, 0, tests
},
2158 {"poll_timeout", poll_timeout
, 0, tests
},
2159 {"gets", enable_cas
, 0, tests
},
2160 {"consistent", enable_consistent
, 0, tests
},
2161 // {"udp", pre_udp, 0, tests},
2162 {"version_1_2_3", check_for_1_2_3
, 0, version_1_2_3
},
2163 {"string", 0, 0, string_tests
},
2164 {"result", 0, 0, result_tests
},
2165 {"async", pre_nonblock
, 0, async_tests
},
2166 {"user", 0, 0, user_tests
},
2167 {"generate", 0, 0, generate_tests
},
2168 {"generate_hsieh", pre_hsieh
, 0, generate_tests
},
2169 {"generate_hsieh_consistent", enable_consistent
, 0, generate_tests
},
2170 {"generate_md5", pre_md5
, 0, generate_tests
},
2171 {"generate_nonblock", pre_nonblock
, 0, generate_tests
},
2175 collection_st
*gets_collections(void)