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
];
32 static char *global_values
[GLOBAL_COUNT
];
33 static size_t global_values_length
[GLOBAL_COUNT
];
35 uint8_t init_test(memcached_st
*not_used
)
39 (void)memcached_create(&memc
);
40 memcached_free(&memc
);
45 uint8_t server_list_null_test(memcached_st
*ptr
)
47 memcached_server_st
*server_list
;
50 server_list
= memcached_server_list_append(NULL
, NULL
, 0, NULL
);
51 assert(server_list
== NULL
);
53 server_list
= memcached_server_list_append(NULL
, "localhost", 0, NULL
);
54 assert(server_list
== NULL
);
56 server_list
= memcached_server_list_append(NULL
, NULL
, 0, &rc
);
57 assert(server_list
== NULL
);
62 uint8_t allocation_test(memcached_st
*not_used
)
65 memc
= memcached_create(NULL
);
72 uint8_t clone_test(memcached_st
*memc
)
77 clone
= memcached_clone(NULL
, NULL
);
79 memcached_free(clone
);
82 /* Can we init from null? */
85 clone
= memcached_clone(NULL
, memc
);
87 memcached_free(clone
);
90 /* Can we init from struct? */
92 memcached_st declared_clone
;
94 clone
= memcached_clone(&declared_clone
, NULL
);
96 memcached_free(clone
);
99 /* Can we init from struct? */
101 memcached_st declared_clone
;
103 clone
= memcached_clone(&declared_clone
, memc
);
105 memcached_free(clone
);
111 uint8_t connection_test(memcached_st
*memc
)
115 rc
= memcached_server_add(memc
, "localhost", 0);
116 assert(rc
== MEMCACHED_SUCCESS
);
121 uint8_t error_test(memcached_st
*memc
)
125 for (rc
= MEMCACHED_SUCCESS
; rc
< MEMCACHED_MAXIMUM_RETURN
; rc
++)
127 printf("Error %d -> %s\n", rc
, memcached_strerror(memc
, rc
));
133 uint8_t set_test(memcached_st
*memc
)
137 char *value
= "when we sanitize";
139 rc
= memcached_set(memc
, key
, strlen(key
),
140 value
, strlen(value
),
141 (time_t)0, (uint32_t)0);
142 assert(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
);
147 uint8_t append_test(memcached_st
*memc
)
155 rc
= memcached_flush(memc
, 0);
156 assert(rc
== MEMCACHED_SUCCESS
);
158 rc
= memcached_set(memc
, key
, strlen(key
),
159 value
, strlen(value
),
160 (time_t)0, (uint32_t)0);
161 assert(rc
== MEMCACHED_SUCCESS
);
163 rc
= memcached_append(memc
, key
, strlen(key
),
164 " the", strlen(" the"),
165 (time_t)0, (uint32_t)0);
166 assert(rc
== MEMCACHED_SUCCESS
);
168 rc
= memcached_append(memc
, key
, strlen(key
),
169 " people", strlen(" people"),
170 (time_t)0, (uint32_t)0);
171 assert(rc
== MEMCACHED_SUCCESS
);
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
);
183 uint8_t append_binary_test(memcached_st
*memc
)
186 char *key
= "numbers";
187 unsigned int *store_ptr
;
188 unsigned int store_list
[] = { 23, 56, 499, 98, 32847, 0 };
194 rc
= memcached_flush(memc
, 0);
195 assert(rc
== MEMCACHED_SUCCESS
);
197 rc
= memcached_set(memc
,
200 (time_t)0, (uint32_t)0);
201 assert(rc
== MEMCACHED_SUCCESS
);
203 for (x
= 0; store_list
[x
] ; x
++)
205 rc
= memcached_append(memc
,
207 (char *)&store_list
[x
], sizeof(unsigned int),
208 (time_t)0, (uint32_t)0);
209 assert(rc
== MEMCACHED_SUCCESS
);
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
);
217 store_ptr
= (unsigned int *)value
;
219 while ((size_t)store_ptr
< (size_t)(value
+ value_length
))
221 assert(*store_ptr
== store_list
[x
++]);
229 uint8_t cas2_test(memcached_st
*memc
)
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");
237 memcached_result_st results_obj
;
238 memcached_result_st
*results
;
241 rc
= memcached_flush(memc
, 0);
242 assert(rc
== MEMCACHED_SUCCESS
);
244 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_SUPPORT_CAS
, &set
);
246 for (x
= 0; x
< 3; x
++)
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
);
254 rc
= memcached_mget(memc
, keys
, key_length
, 3);
256 results
= memcached_result_create(memc
, &results_obj
);
258 results
= memcached_fetch_result(memc
, &results_obj
, &rc
);
260 assert(results
->cas
);
261 assert(rc
== MEMCACHED_SUCCESS
);
262 WATCHPOINT_ASSERT(memcached_result_cas(results
));
264 assert(!memcmp(value
, "we the people", strlen("we the people")));
265 assert(strlen("we the people") == value_length
);
266 assert(rc
== MEMCACHED_SUCCESS
);
268 memcached_result_free(&results_obj
);
273 uint8_t cas_test(memcached_st
*memc
)
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
;
284 rc
= memcached_flush(memc
, 0);
285 assert(rc
== MEMCACHED_SUCCESS
);
287 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_SUPPORT_CAS
, &set
);
289 rc
= memcached_set(memc
, key
, strlen(key
),
290 value
, strlen(value
),
291 (time_t)0, (uint32_t)0);
292 assert(rc
== MEMCACHED_SUCCESS
);
294 rc
= memcached_mget(memc
, &key
, &key_length
, 1);
296 results
= memcached_result_create(memc
, &results_obj
);
298 results
= memcached_fetch_result(memc
, &results_obj
, &rc
);
300 assert(rc
== MEMCACHED_SUCCESS
);
301 WATCHPOINT_ASSERT(memcached_result_cas(results
));
303 assert(!memcmp(value
, "we the people", strlen("we the people")));
304 assert(strlen("we the people") == value_length
);
305 assert(rc
== MEMCACHED_SUCCESS
);
307 memcached_result_free(&results_obj
);
312 uint8_t prepend_test(memcached_st
*memc
)
316 char *value
= "people";
320 rc
= memcached_flush(memc
, 0);
321 assert(rc
== MEMCACHED_SUCCESS
);
323 rc
= memcached_set(memc
, key
, strlen(key
),
324 value
, strlen(value
),
325 (time_t)0, (uint32_t)0);
326 assert(rc
== MEMCACHED_SUCCESS
);
328 rc
= memcached_prepend(memc
, key
, strlen(key
),
329 "the ", strlen("the "),
330 (time_t)0, (uint32_t)0);
331 assert(rc
== MEMCACHED_SUCCESS
);
333 rc
= memcached_prepend(memc
, key
, strlen(key
),
334 "we ", strlen("we "),
335 (time_t)0, (uint32_t)0);
336 assert(rc
== MEMCACHED_SUCCESS
);
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
);
349 Set the value, then quit to make sure it is flushed.
350 Come back in and test that add fails.
352 uint8_t add_test(memcached_st
*memc
)
356 char *value
= "when we sanitize";
358 rc
= memcached_set(memc
, key
, strlen(key
),
359 value
, strlen(value
),
360 (time_t)0, (uint32_t)0);
361 assert(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
);
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
);
371 uint8_t add_wrapper(memcached_st
*memc
)
375 for (x
= 0; x
< 10000; x
++)
381 uint8_t replace_test(memcached_st
*memc
)
385 char *value
= "when we sanitize";
387 rc
= memcached_replace(memc
, key
, strlen(key
),
388 value
, strlen(value
),
389 (time_t)0, (uint32_t)0);
390 assert(rc
== MEMCACHED_SUCCESS
);
395 uint8_t delete_test(memcached_st
*memc
)
399 char *value
= "when we sanitize";
401 rc
= memcached_set(memc
, key
, strlen(key
),
402 value
, strlen(value
),
403 (time_t)0, (uint32_t)0);
404 assert(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
);
406 rc
= memcached_delete(memc
, key
, strlen(key
), (time_t)0);
407 assert(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
);
412 uint8_t flush_test(memcached_st
*memc
)
416 rc
= memcached_flush(memc
, 0);
417 assert(rc
== MEMCACHED_SUCCESS
);
422 uint8_t get_test(memcached_st
*memc
)
427 size_t string_length
;
430 rc
= memcached_delete(memc
, key
, strlen(key
), (time_t)0);
431 assert(rc
== MEMCACHED_BUFFERED
|| rc
== MEMCACHED_NOTFOUND
);
433 string
= memcached_get(memc
, key
, strlen(key
),
434 &string_length
, &flags
, &rc
);
436 assert(rc
== MEMCACHED_NOTFOUND
);
437 assert(string_length
== 0);
443 uint8_t get_test2(memcached_st
*memc
)
447 char *value
= "when we sanitize";
449 size_t string_length
;
452 rc
= memcached_set(memc
, key
, strlen(key
),
453 value
, strlen(value
),
454 (time_t)0, (uint32_t)0);
455 assert(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
);
457 string
= memcached_get(memc
, key
, strlen(key
),
458 &string_length
, &flags
, &rc
);
461 assert(rc
== MEMCACHED_SUCCESS
);
462 assert(string_length
== strlen(value
));
463 assert(!memcmp(string
, value
, string_length
));
470 uint8_t set_test2(memcached_st
*memc
)
474 char *value
= "train in the brain";
475 size_t value_length
= strlen(value
);
478 for (x
= 0; x
< 10; x
++)
480 rc
= memcached_set(memc
, key
, strlen(key
),
482 (time_t)0, (uint32_t)0);
483 assert(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
);
489 uint8_t set_test3(memcached_st
*memc
)
494 size_t value_length
= 8191;
497 value
= (char*)malloc(value_length
);
500 for (x
= 0; x
< value_length
; x
++)
501 value
[x
] = (char) (x
% 127);
503 for (x
= 0; x
< 1; x
++)
505 rc
= memcached_set(memc
, key
, strlen(key
),
507 (time_t)0, (uint32_t)0);
508 assert(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
);
516 uint8_t get_test3(memcached_st
*memc
)
521 size_t value_length
= 8191;
523 size_t string_length
;
527 value
= (char*)malloc(value_length
);
530 for (x
= 0; x
< value_length
; x
++)
531 value
[x
] = (char) (x
% 127);
533 rc
= memcached_set(memc
, key
, strlen(key
),
535 (time_t)0, (uint32_t)0);
536 assert(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
);
538 string
= memcached_get(memc
, key
, strlen(key
),
539 &string_length
, &flags
, &rc
);
541 assert(rc
== MEMCACHED_SUCCESS
);
543 assert(string_length
== value_length
);
544 assert(!memcmp(string
, value
, string_length
));
552 uint8_t get_test4(memcached_st
*memc
)
557 size_t value_length
= 8191;
559 size_t string_length
;
563 value
= (char*)malloc(value_length
);
566 for (x
= 0; x
< value_length
; x
++)
567 value
[x
] = (char) (x
% 127);
569 rc
= memcached_set(memc
, key
, strlen(key
),
571 (time_t)0, (uint32_t)0);
572 assert(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
);
574 for (x
= 0; x
< 10; x
++)
576 string
= memcached_get(memc
, key
, strlen(key
),
577 &string_length
, &flags
, &rc
);
579 assert(rc
== MEMCACHED_SUCCESS
);
581 assert(string_length
== value_length
);
582 assert(!memcmp(string
, value
, string_length
));
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
)
595 memcached_stat_st stat
;
596 rc
= memcached_stat_servername(&stat
, NULL
,
597 memc
->hosts
[0].hostname
,
598 memc
->hosts
[0].port
);
603 uint8_t increment_test(memcached_st
*memc
)
610 rc
= memcached_set(memc
, key
, strlen(key
),
611 value
, strlen(value
),
612 (time_t)0, (uint32_t)0);
613 assert(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
);
615 rc
= memcached_increment(memc
, key
, strlen(key
),
617 assert(rc
== MEMCACHED_SUCCESS
);
618 assert(new_number
== 1);
620 rc
= memcached_increment(memc
, key
, strlen(key
),
622 assert(rc
== MEMCACHED_SUCCESS
);
623 assert(new_number
== 2);
628 uint8_t decrement_test(memcached_st
*memc
)
635 rc
= memcached_set(memc
, key
, strlen(key
),
636 value
, strlen(value
),
637 (time_t)0, (uint32_t)0);
638 assert(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
);
640 rc
= memcached_decrement(memc
, key
, strlen(key
),
642 assert(rc
== MEMCACHED_SUCCESS
);
643 assert(new_number
== 2);
645 rc
= memcached_decrement(memc
, key
, strlen(key
),
647 assert(rc
== MEMCACHED_SUCCESS
);
648 assert(new_number
== 1);
653 uint8_t quit_test(memcached_st
*memc
)
657 char *value
= "sanford and sun";
659 rc
= memcached_set(memc
, key
, strlen(key
),
660 value
, strlen(value
),
661 (time_t)10, (uint32_t)3);
662 assert(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
);
663 memcached_quit(memc
);
665 rc
= memcached_set(memc
, key
, strlen(key
),
666 value
, strlen(value
),
667 (time_t)50, (uint32_t)9);
668 assert(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
);
673 uint8_t mget_result_test(memcached_st
*memc
)
676 char *keys
[]= {"fudge", "son", "food"};
677 size_t key_length
[]= {5, 3, 4};
680 memcached_result_st results_obj
;
681 memcached_result_st
*results
;
683 results
= memcached_result_create(memc
, &results_obj
);
685 assert(&results_obj
== results
);
687 /* We need to empty the server before continueing test */
688 rc
= memcached_flush(memc
, 0);
689 assert(rc
== MEMCACHED_SUCCESS
);
691 rc
= memcached_mget(memc
, keys
, key_length
, 3);
692 assert(rc
== MEMCACHED_SUCCESS
);
694 while ((results
= memcached_fetch_result(memc
, &results_obj
, &rc
)) != NULL
)
699 while ((results
= memcached_fetch_result(memc
, &results_obj
, &rc
)) != NULL
)
701 assert(rc
== MEMCACHED_END
);
703 for (x
= 0; x
< 3; x
++)
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
|| rc
== MEMCACHED_BUFFERED
);
711 rc
= memcached_mget(memc
, keys
, key_length
, 3);
712 assert(rc
== MEMCACHED_SUCCESS
);
714 while ((results
= memcached_fetch_result(memc
, &results_obj
, &rc
)))
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
)));
725 memcached_result_free(&results_obj
);
730 uint8_t mget_result_alloc_test(memcached_st
*memc
)
733 char *keys
[]= {"fudge", "son", "food"};
734 size_t key_length
[]= {5, 3, 4};
737 memcached_result_st
*results
;
739 /* We need to empty the server before continueing test */
740 rc
= memcached_flush(memc
, 0);
741 assert(rc
== MEMCACHED_SUCCESS
);
743 rc
= memcached_mget(memc
, keys
, key_length
, 3);
744 assert(rc
== MEMCACHED_SUCCESS
);
746 while ((results
= memcached_fetch_result(memc
, NULL
, &rc
)) != NULL
)
751 assert(rc
== MEMCACHED_END
);
753 for (x
= 0; x
< 3; x
++)
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
|| rc
== MEMCACHED_BUFFERED
);
761 rc
= memcached_mget(memc
, keys
, key_length
, 3);
762 assert(rc
== MEMCACHED_SUCCESS
);
765 while ((results
= memcached_fetch_result(memc
, NULL
, &rc
)))
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
);
780 /* Count the results */
781 unsigned int callback_counter(memcached_st
*ptr
, memcached_result_st
*result
, void *context
)
783 unsigned int *counter
= (unsigned int *)context
;
785 *counter
= *counter
+ 1;
790 uint8_t mget_result_function(memcached_st
*memc
)
793 char *keys
[]= {"fudge", "son", "food"};
794 size_t key_length
[]= {5, 3, 4};
796 unsigned int counter
;
797 unsigned int (*callbacks
[1])(memcached_st
*, memcached_result_st
*, void *);
799 /* We need to empty the server before continueing test */
800 rc
= memcached_flush(memc
, 0);
801 for (x
= 0; x
< 3; x
++)
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
|| rc
== MEMCACHED_BUFFERED
);
809 rc
= memcached_mget(memc
, keys
, key_length
, 3);
810 assert(rc
== MEMCACHED_SUCCESS
);
812 callbacks
[0]= &callback_counter
;
814 rc
= memcached_fetch_execute(memc
, callbacks
, (void *)&counter
, 1);
816 assert(counter
== 3);
821 uint8_t mget_test(memcached_st
*memc
)
824 char *keys
[]= {"fudge", "son", "food"};
825 size_t key_length
[]= {5, 3, 4};
829 char return_key
[MEMCACHED_MAX_KEY
];
830 size_t return_key_length
;
832 size_t return_value_length
;
834 /* We need to empty the server before continueing test */
835 rc
= memcached_flush(memc
, 0);
836 assert(rc
== MEMCACHED_SUCCESS
);
838 rc
= memcached_mget(memc
, keys
, key_length
, 3);
839 assert(rc
== MEMCACHED_SUCCESS
);
841 while ((return_value
= memcached_fetch(memc
, return_key
, &return_key_length
,
842 &return_value_length
, &flags
, &rc
)) != NULL
)
844 assert(return_value
);
846 assert(!return_value
);
847 assert(return_value_length
== 0);
848 assert(rc
== MEMCACHED_END
);
850 for (x
= 0; x
< 3; x
++)
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
|| rc
== MEMCACHED_BUFFERED
);
858 rc
= memcached_mget(memc
, keys
, key_length
, 3);
859 assert(rc
== MEMCACHED_SUCCESS
);
862 while ((return_value
= memcached_fetch(memc
, return_key
, &return_key_length
,
863 &return_value_length
, &flags
, &rc
)))
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
));
876 uint8_t get_stats_keys(memcached_st
*memc
)
880 memcached_stat_st stat
;
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
);
894 uint8_t get_stats(memcached_st
*memc
)
900 memcached_stat_st
*stat
;
902 stat
= memcached_stat(memc
, NULL
, &rc
);
903 assert(rc
== MEMCACHED_SUCCESS
);
905 assert(rc
== MEMCACHED_SUCCESS
);
908 for (x
= 0; x
< memcached_server_count(memc
); x
++)
910 list
= memcached_stat_get_keys(memc
, stat
+x
, &rc
);
911 assert(rc
== MEMCACHED_SUCCESS
);
912 for (ptr
= list
; *ptr
; ptr
++);
917 memcached_stat_free(NULL
, stat
);
922 uint8_t add_host_test(memcached_st
*memc
)
925 memcached_server_st
*servers
;
927 char servername
[]= "0.example.com";
929 servers
= memcached_server_list_append(NULL
, servername
, 400, &rc
);
931 assert(1 == memcached_server_list_count(servers
));
933 for (x
= 2; x
< 20; x
++)
935 char buffer
[SMALL_STRING_LEN
];
937 snprintf(buffer
, SMALL_STRING_LEN
, "%u.example.com", 400+x
);
938 servers
= memcached_server_list_append(servers
, buffer
, 401,
940 assert(rc
== MEMCACHED_SUCCESS
);
941 assert(x
== memcached_server_list_count(servers
));
944 rc
= memcached_server_push(memc
, servers
);
945 assert(rc
== MEMCACHED_SUCCESS
);
946 rc
= memcached_server_push(memc
, servers
);
947 assert(rc
== MEMCACHED_SUCCESS
);
949 memcached_server_list_free(servers
);
954 /* We don't test the behavior itself, we test the switches */
955 uint8_t behavior_test(memcached_st
*memc
)
957 unsigned long long value
;
960 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NO_BLOCK
, &set
);
961 value
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_NO_BLOCK
);
964 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_TCP_NODELAY
, &set
);
965 value
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_TCP_NODELAY
);
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
);
975 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NO_BLOCK
, &set
);
976 value
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_NO_BLOCK
);
979 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_TCP_NODELAY
, &set
);
980 value
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_TCP_NODELAY
);
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
);
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
);
993 value
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_SOCKET_SEND_SIZE
);
996 value
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_SOCKET_RECV_SIZE
);
1002 /* Test case provided by Cal Haldenbrand */
1003 uint8_t user_supplied_bug1(memcached_st
*memc
)
1005 unsigned int setter
= 1;
1008 unsigned long long total
= 0;
1011 char randomstuff
[6 * 1024];
1012 memcached_return rc
;
1014 memset(randomstuff
, 0, 6 * 1024);
1016 /* We just keep looking at the same values over and over */
1019 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NO_BLOCK
, &setter
);
1020 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_TCP_NODELAY
, &setter
);
1024 for (x
= 0 ; total
< 20 * 1024576 ; x
++ )
1028 size
= (rand() % ( 5 * 1024 ) ) + 400;
1029 memset(randomstuff
, 0, 6 * 1024);
1030 assert(size
< 6 * 1024); /* Being safe here */
1032 for (j
= 0 ; j
< size
;j
++)
1033 randomstuff
[j
] = (char) (rand() % 26) + 97;
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
&& rc
!= MEMCACHED_BUFFERED
)
1041 rc
= memcached_set(memc
, key
, strlen(key
),
1042 randomstuff
, strlen(randomstuff
), 10, 0);
1043 assert(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
);
1049 /* Test case provided by Cal Haldenbrand */
1050 uint8_t user_supplied_bug2(memcached_st
*memc
)
1053 unsigned int setter
;
1055 unsigned long long total
;
1058 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NO_BLOCK
, &setter
);
1059 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_TCP_NODELAY
, &setter
);
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
);
1068 for (x
= 0, errors
= 0, total
= 0 ; total
< 20 * 1024576 ; x
++)
1071 for (x
= 0, errors
= 0, total
= 0 ; total
< 24576 ; x
++)
1073 memcached_return rc
= MEMCACHED_SUCCESS
;
1074 char buffer
[SMALL_STRING_LEN
];
1079 memset(buffer
, 0, SMALL_STRING_LEN
);
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
)
1086 if (rc
== MEMCACHED_NOTFOUND
)
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
)
1105 memcached_return rc
;
1106 unsigned int setter
;
1109 size_t key_lengths
[KEY_COUNT
];
1112 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NO_BLOCK
, &setter
);
1113 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_TCP_NODELAY
, &setter
);
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
);
1123 keys
= (char **)malloc(sizeof(char *) * KEY_COUNT
);
1125 memset(keys
, 0, (sizeof(char *) * KEY_COUNT
));
1126 for (x
= 0; x
< KEY_COUNT
; x
++)
1130 snprintf(buffer
, 30, "%u", x
);
1131 keys
[x
]= strdup(buffer
);
1132 key_lengths
[x
]= strlen(keys
[x
]);
1135 rc
= memcached_mget(memc
, keys
, key_lengths
, KEY_COUNT
);
1136 assert(rc
== MEMCACHED_SUCCESS
);
1138 /* Turn this into a help function */
1140 char return_key
[MEMCACHED_MAX_KEY
];
1141 size_t return_key_length
;
1143 size_t return_value_length
;
1146 while ((return_value
= memcached_fetch(memc
, return_key
, &return_key_length
,
1147 &return_value_length
, &flags
, &rc
)))
1149 assert(return_value
);
1150 assert(rc
== MEMCACHED_SUCCESS
);
1155 for (x
= 0; x
< KEY_COUNT
; x
++)
1162 /* Make sure we behave properly if server list has no values */
1163 uint8_t user_supplied_bug4(memcached_st
*memc
)
1165 memcached_return rc
;
1166 char *keys
[]= {"fudge", "son", "food"};
1167 size_t key_length
[]= {5, 3, 4};
1170 char return_key
[MEMCACHED_MAX_KEY
];
1171 size_t return_key_length
;
1173 size_t return_value_length
;
1175 /* Here we free everything before running a bunch of mget tests */
1177 memcached_server_list_free(memc
->hosts
);
1179 memc
->number_of_hosts
= 0;
1183 /* We need to empty the server before continueing test */
1184 rc
= memcached_flush(memc
, 0);
1185 assert(rc
== MEMCACHED_NO_SERVERS
);
1187 rc
= memcached_mget(memc
, keys
, key_length
, 3);
1188 assert(rc
== MEMCACHED_NO_SERVERS
);
1190 while ((return_value
= memcached_fetch(memc
, return_key
, &return_key_length
,
1191 &return_value_length
, &flags
, &rc
)) != NULL
)
1193 assert(return_value
);
1195 assert(!return_value
);
1196 assert(return_value_length
== 0);
1197 assert(rc
== MEMCACHED_NO_SERVERS
);
1199 for (x
= 0; x
< 3; x
++)
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
);
1207 rc
= memcached_mget(memc
, keys
, key_length
, 3);
1208 assert(rc
== MEMCACHED_NO_SERVERS
);
1211 while ((return_value
= memcached_fetch(memc
, return_key
, &return_key_length
,
1212 &return_value_length
, &flags
, &rc
)))
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
));
1225 #define VALUE_SIZE_BUG5 1048064
1226 uint8_t user_supplied_bug5(memcached_st
*memc
)
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
;
1234 size_t value_length
;
1238 char insert_data
[VALUE_SIZE_BUG5
];
1240 for (x
= 0; x
< VALUE_SIZE_BUG5
; x
++)
1241 insert_data
[x
]= rand();
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);
1250 while ((value
= memcached_fetch(memc
, return_key
, &return_key_length
,
1251 &value_length
, &flags
, &rc
)))
1255 for (x
= 0; x
< 4; x
++)
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
);
1263 for (x
= 0; x
< 10; x
++)
1265 value
= memcached_get(memc
, keys
[0], key_length
[0],
1266 &value_length
, &flags
, &rc
);
1270 rc
= memcached_mget(memc
, keys
, key_length
, 4);
1272 while ((value
= memcached_fetch(memc
, return_key
, &return_key_length
,
1273 &value_length
, &flags
, &rc
)))
1284 uint8_t user_supplied_bug6(memcached_st
*memc
)
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
;
1292 size_t value_length
;
1296 char insert_data
[VALUE_SIZE_BUG5
];
1298 for (x
= 0; x
< VALUE_SIZE_BUG5
; x
++)
1299 insert_data
[x
]= rand();
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
);
1310 while ((value
= memcached_fetch(memc
, return_key
, &return_key_length
,
1311 &value_length
, &flags
, &rc
)))
1314 assert(rc
== MEMCACHED_END
);
1316 for (x
= 0; x
< 4; x
++)
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
);
1324 for (x
= 0; x
< 2; x
++)
1326 value
= memcached_get(memc
, keys
[0], key_length
[0],
1327 &value_length
, &flags
, &rc
);
1331 rc
= memcached_mget(memc
, keys
, key_length
, 4);
1332 assert(rc
== MEMCACHED_SUCCESS
);
1334 /* We test for purge of partial complete fetches */
1335 for (count
= 3; count
; count
--)
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
);
1349 uint8_t user_supplied_bug8(memcached_st
*memc
)
1351 memcached_return rc
;
1353 memcached_st
*clone
;
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";
1358 servers
= memcached_servers_parse(server_list
);
1361 mine
= memcached_create(NULL
);
1362 rc
= memcached_server_push(mine
, servers
);
1363 assert(rc
== MEMCACHED_SUCCESS
);
1364 memcached_server_list_free(servers
);
1367 clone
= memcached_clone(NULL
, mine
);
1369 memcached_quit(mine
);
1370 memcached_quit(clone
);
1373 memcached_free(mine
);
1374 memcached_free(clone
);
1379 /* Test flag store/retrieve */
1380 uint8_t user_supplied_bug7(memcached_st
*memc
)
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
;
1388 size_t value_length
;
1391 char insert_data
[VALUE_SIZE_BUG5
];
1393 for (x
= 0; x
< VALUE_SIZE_BUG5
; x
++)
1394 insert_data
[x
]= rand();
1396 memcached_flush(memc
, 0);
1399 rc
= memcached_set(memc
, keys
, key_length
,
1400 insert_data
, VALUE_SIZE_BUG5
,
1402 assert(rc
== MEMCACHED_SUCCESS
);
1405 value
= memcached_get(memc
, keys
, key_length
,
1406 &value_length
, &flags
, &rc
);
1407 assert(flags
== 245);
1411 rc
= memcached_mget(memc
, &keys
, &key_length
, 1);
1414 value
= memcached_fetch(memc
, return_key
, &return_key_length
,
1415 &value_length
, &flags
, &rc
);
1416 assert(flags
== 245);
1424 uint8_t user_supplied_bug9(memcached_st
*memc
)
1426 memcached_return rc
;
1427 char *keys
[]= {"UDATA:edevil@sapo.pt", "fudge&*@#", "for^#@&$not"};
1428 size_t key_length
[3];
1433 char return_key
[MEMCACHED_MAX_KEY
];
1434 size_t return_key_length
;
1436 size_t return_value_length
;
1439 key_length
[0]= strlen("UDATA:edevil@sapo.pt");
1440 key_length
[1]= strlen("fudge&*@#");
1441 key_length
[2]= strlen("for^#@&$not");
1444 for (x
= 0; x
< 3; x
++)
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
);
1452 rc
= memcached_mget(memc
, keys
, key_length
, 3);
1453 assert(rc
== MEMCACHED_SUCCESS
);
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
)
1459 assert(return_value
);
1468 /* We are testing with aggressive timeout to get failures */
1469 uint8_t user_supplied_bug10(memcached_st
*memc
)
1473 size_t value_length
= 512;
1476 memcached_return rc
;
1477 unsigned int set
= 1;
1478 memcached_st
*mclone
= memcached_clone(NULL
, memc
);
1481 memcached_behavior_set(mclone
, MEMCACHED_BEHAVIOR_NO_BLOCK
, &set
);
1482 memcached_behavior_set(mclone
, MEMCACHED_BEHAVIOR_TCP_NODELAY
, &set
);
1484 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_POLL_TIMEOUT
, &timeout
);
1486 value
= (char*)malloc(value_length
* sizeof(char));
1488 for (x
= 0; x
< value_length
; x
++)
1489 value
[x
]= (char) (x
% 127);
1491 for (x
= 1; x
<= 100000; ++x
)
1493 rc
= memcached_set(mclone
, key
, key_len
,value
, value_length
, 0, 0);
1495 assert(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_WRITE_FAILURE
|| rc
== MEMCACHED_BUFFERED
);
1497 if (rc
== MEMCACHED_WRITE_FAILURE
)
1502 memcached_free(mclone
);
1508 We are looking failures in the async protocol
1510 uint8_t user_supplied_bug11(memcached_st
*memc
)
1514 size_t value_length
= 512;
1517 memcached_return rc
;
1518 unsigned int set
= 1;
1520 memcached_st
*mclone
= memcached_clone(NULL
, memc
);
1522 memcached_behavior_set(mclone
, MEMCACHED_BEHAVIOR_NO_BLOCK
, &set
);
1523 memcached_behavior_set(mclone
, MEMCACHED_BEHAVIOR_TCP_NODELAY
, &set
);
1525 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_POLL_TIMEOUT
, &timeout
);
1527 timeout
= (int32_t)memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_POLL_TIMEOUT
);
1529 assert(timeout
== -1);
1531 value
= (char*)malloc(value_length
* sizeof(char));
1533 for (x
= 0; x
< value_length
; x
++)
1534 value
[x
]= (char) (x
% 127);
1536 for (x
= 1; x
<= 100000; ++x
)
1538 rc
= memcached_set(mclone
, key
, key_len
,value
, value_length
, 0, 0);
1540 WATCHPOINT_IFERROR(rc
);
1544 memcached_free(mclone
);
1549 uint8_t result_static(memcached_st
*memc
)
1551 memcached_result_st result
;
1552 memcached_result_st
*result_ptr
;
1554 result_ptr
= memcached_result_create(memc
, &result
);
1555 assert(result
.is_allocated
== MEMCACHED_NOT_ALLOCATED
);
1557 memcached_result_free(&result
);
1562 uint8_t result_alloc(memcached_st
*memc
)
1564 memcached_result_st
*result
;
1566 result
= memcached_result_create(memc
, NULL
);
1568 memcached_result_free(result
);
1573 uint8_t string_static_null(memcached_st
*memc
)
1575 memcached_string_st string
;
1576 memcached_string_st
*string_ptr
;
1578 string_ptr
= memcached_string_create(memc
, &string
, 0);
1579 assert(string
.is_allocated
== MEMCACHED_NOT_ALLOCATED
);
1581 memcached_string_free(&string
);
1586 uint8_t string_alloc_null(memcached_st
*memc
)
1588 memcached_string_st
*string
;
1590 string
= memcached_string_create(memc
, NULL
, 0);
1592 memcached_string_free(string
);
1597 uint8_t string_alloc_with_size(memcached_st
*memc
)
1599 memcached_string_st
*string
;
1601 string
= memcached_string_create(memc
, NULL
, 1024);
1603 memcached_string_free(string
);
1608 uint8_t string_alloc_with_size_toobig(memcached_st
*memc
)
1610 memcached_string_st
*string
;
1612 string
= memcached_string_create(memc
, NULL
, INT64_MAX
);
1613 assert(string
== NULL
);
1618 uint8_t string_alloc_append(memcached_st
*memc
)
1621 char buffer
[SMALL_STRING_LEN
];
1622 memcached_string_st
*string
;
1624 /* Ring the bell! */
1625 memset(buffer
, 6, SMALL_STRING_LEN
);
1627 string
= memcached_string_create(memc
, NULL
, 100);
1630 for (x
= 0; x
< 1024; x
++)
1632 memcached_return rc
;
1633 rc
= memcached_string_append(string
, buffer
, SMALL_STRING_LEN
);
1634 assert(rc
== MEMCACHED_SUCCESS
);
1636 memcached_string_free(string
);
1641 uint8_t string_alloc_append_toobig(memcached_st
*memc
)
1643 memcached_return rc
;
1645 char buffer
[SMALL_STRING_LEN
];
1646 memcached_string_st
*string
;
1648 /* Ring the bell! */
1649 memset(buffer
, 6, SMALL_STRING_LEN
);
1651 string
= memcached_string_create(memc
, NULL
, 100);
1654 for (x
= 0; x
< 1024; x
++)
1656 rc
= memcached_string_append(string
, buffer
, SMALL_STRING_LEN
);
1657 assert(rc
== MEMCACHED_SUCCESS
);
1659 rc
= memcached_string_append(string
, buffer
, INT64_MAX
);
1660 assert(rc
== MEMCACHED_MEMORY_ALLOCATION_FAILURE
);
1661 memcached_string_free(string
);
1666 uint8_t cleanup_pairs(memcached_st
*memc
)
1668 pairs_free(global_pairs
);
1673 uint8_t generate_data(memcached_st
*memc
)
1675 unsigned long long x
;
1676 global_pairs
= pairs_generate(GLOBAL_COUNT
);
1677 execute_set(memc
, global_pairs
, GLOBAL_COUNT
);
1679 for (x
= 0; x
< GLOBAL_COUNT
; x
++)
1681 global_keys
[x
]= global_pairs
[x
].key
;
1682 global_keys_length
[x
]= global_pairs
[x
].key_length
;
1688 uint8_t generate_buffer_data(memcached_st
*memc
)
1693 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_BUFFER_REQUESTS
, &latch
);
1694 generate_data(memc
);
1700 uint8_t mset_data(memcached_st
*memc
)
1702 unsigned long long x
;
1703 global_pairs
= pairs_generate(GLOBAL_COUNT
);
1705 (void)memcached_delete(memc
, global_keys
[x
], global_keys_length
[x
], (time_t)0);
1707 for (x
= 0; x
< GLOBAL_COUNT
; x
++)
1709 global_keys
[x
]= global_pairs
[x
].key
;
1710 global_keys_length
[x
]= global_pairs
[x
].key_length
;
1717 uint8_t get_read(memcached_st
*memc
)
1720 memcached_return rc
;
1724 size_t return_value_length
;
1727 for (x
= 0; x
< GLOBAL_COUNT
; x
++)
1729 return_value
= memcached_get(memc
, global_keys
[x
], global_keys_length
[x
],
1730 &return_value_length
, &flags
, &rc
);
1732 assert(return_value);
1733 assert(rc == MEMCACHED_SUCCESS);
1735 if (rc
== MEMCACHED_SUCCESS
&& return_value
)
1743 uint8_t mget_read(memcached_st
*memc
)
1745 memcached_return rc
;
1747 rc
= memcached_mget(memc
, global_keys
, global_keys_length
, GLOBAL_COUNT
);
1748 assert(rc
== MEMCACHED_SUCCESS
);
1749 /* Turn this into a help function */
1751 char return_key
[MEMCACHED_MAX_KEY
];
1752 size_t return_key_length
;
1754 size_t return_value_length
;
1757 while ((return_value
= memcached_fetch(memc
, return_key
, &return_key_length
,
1758 &return_value_length
, &flags
, &rc
)))
1760 assert(return_value
);
1761 assert(rc
== MEMCACHED_SUCCESS
);
1769 uint8_t mget_read_result(memcached_st
*memc
)
1771 memcached_return rc
;
1773 rc
= memcached_mget(memc
, global_keys
, global_keys_length
, GLOBAL_COUNT
);
1774 assert(rc
== MEMCACHED_SUCCESS
);
1775 /* Turn this into a help function */
1777 memcached_result_st results_obj
;
1778 memcached_result_st
*results
;
1780 results
= memcached_result_create(memc
, &results_obj
);
1782 while ((results
= memcached_fetch_result(memc
, &results_obj
, &rc
)))
1785 assert(rc
== MEMCACHED_SUCCESS
);
1788 memcached_result_free(&results_obj
);
1794 uint8_t mget_read_function(memcached_st
*memc
)
1796 memcached_return rc
;
1797 unsigned int counter
;
1798 unsigned int (*callbacks
[1])(memcached_st
*, memcached_result_st
*, void *);
1800 rc
= memcached_mget(memc
, global_keys
, global_keys_length
, GLOBAL_COUNT
);
1801 assert(rc
== MEMCACHED_SUCCESS
);
1803 callbacks
[0]= &callback_counter
;
1805 rc
= memcached_fetch_execute(memc
, callbacks
, (void *)&counter
, 1);
1810 uint8_t delete_generate(memcached_st
*memc
)
1814 for (x
= 0; x
< GLOBAL_COUNT
; x
++)
1816 (void)memcached_delete(memc
, global_keys
[x
], global_keys_length
[x
], (time_t)0);
1822 uint8_t delete_buffer_generate(memcached_st
*memc
)
1828 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_BUFFER_REQUESTS
, &latch
);
1830 for (x
= 0; x
< GLOBAL_COUNT
; x
++)
1832 (void)memcached_delete(memc
, global_keys
[x
], global_keys_length
[x
], (time_t)0);
1838 uint8_t mdelete_generate(memcached_st
*memc
)
1840 memcached_return rc
;
1842 rc
= memcached_mdelete(memc
, global_keys
, global_keys_length
, GLOBAL_COUNT
, 0);
1848 uint8_t free_data(memcached_st
*memc
)
1850 pairs_free(global_pairs
);
1855 uint8_t add_host_test1(memcached_st
*memc
)
1858 memcached_return rc
;
1859 char servername
[]= "0.example.com";
1860 memcached_server_st
*servers
;
1862 servers
= memcached_server_list_append(NULL
, servername
, 400, &rc
);
1864 assert(1 == memcached_server_list_count(servers
));
1866 for (x
= 2; x
< 20; x
++)
1868 char buffer
[SMALL_STRING_LEN
];
1870 snprintf(buffer
, SMALL_STRING_LEN
, "%u.example.com", 400+x
);
1871 servers
= memcached_server_list_append(servers
, buffer
, 401,
1873 assert(rc
== MEMCACHED_SUCCESS
);
1874 assert(x
== memcached_server_list_count(servers
));
1877 rc
= memcached_server_push(memc
, servers
);
1878 assert(rc
== MEMCACHED_SUCCESS
);
1879 rc
= memcached_server_push(memc
, servers
);
1880 assert(rc
== MEMCACHED_SUCCESS
);
1882 memcached_server_list_free(servers
);
1887 memcached_return
pre_nonblock(memcached_st
*memc
)
1889 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NO_BLOCK
, NULL
);
1891 return MEMCACHED_SUCCESS
;
1894 memcached_return
pre_md5(memcached_st
*memc
)
1896 memcached_hash value
= MEMCACHED_HASH_MD5
;
1897 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_HASH
, &value
);
1899 return MEMCACHED_SUCCESS
;
1902 memcached_return
pre_crc(memcached_st
*memc
)
1904 memcached_hash value
= MEMCACHED_HASH_CRC
;
1905 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_HASH
, &value
);
1907 return MEMCACHED_SUCCESS
;
1910 memcached_return
pre_hsieh(memcached_st
*memc
)
1912 memcached_hash value
= MEMCACHED_HASH_HSIEH
;
1913 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_HASH
, &value
);
1915 return MEMCACHED_SUCCESS
;
1918 memcached_return
pre_hash_fnv1_64(memcached_st
*memc
)
1920 memcached_hash value
= MEMCACHED_HASH_FNV1_64
;
1921 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_HASH
, &value
);
1923 return MEMCACHED_SUCCESS
;
1926 memcached_return
pre_hash_fnv1a_64(memcached_st
*memc
)
1928 memcached_hash value
= MEMCACHED_HASH_FNV1A_64
;
1929 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_HASH
, &value
);
1931 return MEMCACHED_SUCCESS
;
1934 memcached_return
pre_hash_fnv1_32(memcached_st
*memc
)
1936 memcached_hash value
= MEMCACHED_HASH_FNV1_32
;
1937 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_HASH
, &value
);
1939 return MEMCACHED_SUCCESS
;
1942 memcached_return
pre_hash_fnv1a_32(memcached_st
*memc
)
1944 memcached_hash value
= MEMCACHED_HASH_FNV1A_32
;
1945 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_HASH
, &value
);
1947 return MEMCACHED_SUCCESS
;
1950 memcached_return
pre_hash_ketama(memcached_st
*memc
)
1952 memcached_hash value
= MEMCACHED_HASH_KETAMA
;
1953 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_HASH
, &value
);
1955 return MEMCACHED_SUCCESS
;
1958 memcached_return
enable_consistent(memcached_st
*memc
)
1960 memcached_server_distribution value
= MEMCACHED_DISTRIBUTION_CONSISTENT
;
1961 memcached_hash hash
;
1962 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_DISTRIBUTION
, &value
);
1965 value
= (memcached_server_distribution
)memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_DISTRIBUTION
);
1966 assert(value
== MEMCACHED_DISTRIBUTION_CONSISTENT
);
1968 hash
= (memcached_hash
)memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_HASH
);
1969 assert(hash
== MEMCACHED_HASH_HSIEH
);
1972 return MEMCACHED_SUCCESS
;
1975 memcached_return
enable_cas(memcached_st
*memc
)
1977 unsigned int set
= 1;
1979 memcached_version(memc
);
1981 if (memc
->hosts
[0].major_version
>= 1 &&
1982 memc
->hosts
[0].minor_version
>= 2 &&
1983 memc
->hosts
[0].micro_version
>= 4)
1985 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_SUPPORT_CAS
, &set
);
1987 return MEMCACHED_SUCCESS
;
1990 return MEMCACHED_FAILURE
;
1993 memcached_return
check_for_1_2_3(memcached_st
*memc
)
1995 memcached_version(memc
);
1997 if (memc
->hosts
[0].major_version
>= 1 &&
1998 memc
->hosts
[0].minor_version
>= 2 &&
1999 memc
->hosts
[0].micro_version
>= 4)
2000 return MEMCACHED_SUCCESS
;
2002 return MEMCACHED_FAILURE
;
2005 memcached_return
pre_unix_socket(memcached_st
*memc
)
2007 memcached_return rc
;
2010 memcached_server_list_free(memc
->hosts
);
2012 memc
->number_of_hosts
= 0;
2014 if (stat("/tmp/memcached.socket", &buf
))
2015 return MEMCACHED_FAILURE
;
2017 rc
= memcached_server_add_unix_socket(memc
, "/tmp/memcached.socket");
2022 memcached_return
pre_udp(memcached_st
*memc
)
2024 memcached_return rc
;
2026 memcached_server_list_free(memc
->hosts
);
2028 memc
->number_of_hosts
= 0;
2031 return MEMCACHED_FAILURE
;
2033 rc
= memcached_server_add_udp(memc
, "localhost", MEMCACHED_DEFAULT_PORT
);
2038 memcached_return
pre_nodelay(memcached_st
*memc
)
2040 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NO_BLOCK
, NULL
);
2041 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_TCP_NODELAY
, NULL
);
2043 return MEMCACHED_SUCCESS
;
2046 memcached_return
poll_timeout(memcached_st
*memc
)
2052 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_POLL_TIMEOUT
, &timeout
);
2054 timeout
= (int32_t)memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_POLL_TIMEOUT
);
2056 assert(timeout
== 100);
2058 return MEMCACHED_SUCCESS
;
2062 /* Clean the server before beginning testing */
2064 {"flush", 0, flush_test
},
2065 {"init", 0, init_test
},
2066 {"allocation", 0, allocation_test
},
2067 {"server_list_null_test", 0, server_list_null_test
},
2068 {"clone_test", 0, clone_test
},
2069 {"error", 0, error_test
},
2070 {"set", 0, set_test
},
2071 {"set2", 0, set_test2
},
2072 {"set3", 0, set_test3
},
2073 {"add", 1, add_test
},
2074 {"replace", 0, replace_test
},
2075 {"delete", 1, delete_test
},
2076 {"get", 1, get_test
},
2077 {"get2", 0, get_test2
},
2078 {"get3", 0, get_test3
},
2079 {"get4", 0, get_test4
},
2080 {"stats_servername", 0, stats_servername_test
},
2081 {"increment", 0, increment_test
},
2082 {"decrement", 0, decrement_test
},
2083 {"quit", 0, quit_test
},
2084 {"mget", 1, mget_test
},
2085 {"mget_result", 1, mget_result_test
},
2086 {"mget_result_alloc", 1, mget_result_alloc_test
},
2087 {"mget_result_function", 1, mget_result_function
},
2088 {"get_stats", 0, get_stats
},
2089 {"add_host_test", 0, add_host_test
},
2090 {"get_stats_keys", 0, get_stats_keys
},
2091 {"behavior_test", 0, get_stats_keys
},
2095 test_st async_tests
[] ={
2096 {"add", 1, add_wrapper
},
2100 test_st string_tests
[] ={
2101 {"string static with null", 0, string_static_null
},
2102 {"string alloc with null", 0, string_alloc_null
},
2103 {"string alloc with 1K", 0, string_alloc_with_size
},
2104 {"string alloc with malloc failure", 0, string_alloc_with_size_toobig
},
2105 {"string append", 0, string_alloc_append
},
2106 {"string append failure (too big)", 0, string_alloc_append_toobig
},
2110 test_st result_tests
[] ={
2111 {"result static", 0, result_static
},
2112 {"result alloc", 0, result_alloc
},
2116 test_st version_1_2_3
[] ={
2117 {"append", 0, append_test
},
2118 {"prepend", 0, prepend_test
},
2119 {"cas", 0, cas_test
},
2120 {"cas2", 0, cas2_test
},
2121 {"append_binary", 0, append_binary_test
},
2125 test_st user_tests
[] ={
2126 {"user_supplied_bug1", 0, user_supplied_bug1
},
2127 {"user_supplied_bug2", 0, user_supplied_bug2
},
2128 {"user_supplied_bug3", 0, user_supplied_bug3
},
2129 {"user_supplied_bug4", 0, user_supplied_bug4
},
2130 {"user_supplied_bug5", 1, user_supplied_bug5
},
2131 {"user_supplied_bug6", 1, user_supplied_bug6
},
2132 {"user_supplied_bug7", 1, user_supplied_bug7
},
2133 {"user_supplied_bug8", 1, user_supplied_bug8
},
2134 {"user_supplied_bug9", 1, user_supplied_bug9
},
2135 {"user_supplied_bug10", 1, user_supplied_bug10
},
2136 {"user_supplied_bug11", 1, user_supplied_bug11
},
2140 test_st generate_tests
[] ={
2141 {"generate_data", 1, generate_data
},
2142 {"get_read", 0, get_read
},
2143 {"delete_generate", 0, delete_generate
},
2144 {"generate_buffer_data", 1, generate_buffer_data
},
2145 {"delete_buffer", 0, delete_buffer_generate
},
2146 {"generate_data", 1, generate_data
},
2147 {"mget_read", 0, mget_read
},
2148 {"mget_read_result", 0, mget_read_result
},
2149 {"mget_read_function", 0, mget_read_function
},
2150 {"mdelete_generate", 0, mdelete_generate
},
2151 {"cleanup", 1, cleanup_pairs
},
2156 collection_st collection
[] ={
2157 {"block", 0, 0, tests
},
2158 {"nonblock", pre_nonblock
, 0, tests
},
2159 {"nodelay", pre_nodelay
, 0, tests
},
2160 {"md5", pre_md5
, 0, tests
},
2161 {"crc", pre_crc
, 0, tests
},
2162 {"hsieh", pre_hsieh
, 0, tests
},
2163 {"fnv1_64", pre_hash_fnv1_64
, 0, tests
},
2164 {"fnv1a_64", pre_hash_fnv1a_64
, 0, tests
},
2165 {"fnv1_32", pre_hash_fnv1_32
, 0, tests
},
2166 {"fnv1a_32", pre_hash_fnv1a_32
, 0, tests
},
2167 {"ketama", pre_hash_ketama
, 0, tests
},
2168 {"unix_socket", pre_unix_socket
, 0, tests
},
2169 {"unix_socket_nodelay", pre_nodelay
, 0, tests
},
2170 {"poll_timeout", poll_timeout
, 0, tests
},
2171 {"gets", enable_cas
, 0, tests
},
2172 {"consistent", enable_consistent
, 0, tests
},
2173 // {"udp", pre_udp, 0, tests},
2174 {"version_1_2_3", check_for_1_2_3
, 0, version_1_2_3
},
2175 {"string", 0, 0, string_tests
},
2176 {"result", 0, 0, result_tests
},
2177 {"async", pre_nonblock
, 0, async_tests
},
2178 {"user", 0, 0, user_tests
},
2179 {"generate", 0, 0, generate_tests
},
2180 {"generate_hsieh", pre_hsieh
, 0, generate_tests
},
2181 {"generate_hsieh_consistent", enable_consistent
, 0, generate_tests
},
2182 {"generate_md5", pre_md5
, 0, generate_tests
},
2183 {"generate_nonblock", pre_nonblock
, 0, generate_tests
},
2187 collection_st
*gets_collections(void)