2 Sample test application.
14 #include "../clients/generator.h"
15 #include "../clients/execute.h"
18 #define INT64_MAX LONG_MAX
21 #define INT32_MAX INT_MAX
27 #define GLOBAL_COUNT 100000
28 #define GLOBAL2_COUNT 1000
29 static uint32_t global_count
;
31 static pairs_st
*global_pairs
;
32 static char *global_keys
[GLOBAL_COUNT
];
33 static size_t global_keys_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 server_sort_test(memcached_st
*ptr
)
64 memcached_server_st
*server_list
;
67 memcached_behavior_set(ptr
, MEMCACHED_BEHAVIOR_SORT_HOSTS
, 1);
69 server_list
= memcached_server_list_append(NULL
, "arg", 0, &rc
);
72 server_list
= memcached_server_list_append(server_list
, "localhost", 0, &rc
);
75 server_list
= memcached_server_list_append(server_list
, "c", 0, &rc
);
78 server_list
= memcached_server_list_append(server_list
, "abba", 0, &rc
);
86 uint8_t allocation_test(memcached_st
*not_used
)
89 memc
= memcached_create(NULL
);
96 uint8_t clone_test(memcached_st
*memc
)
101 clone
= memcached_clone(NULL
, NULL
);
103 memcached_free(clone
);
106 /* Can we init from null? */
109 clone
= memcached_clone(NULL
, memc
);
111 memcached_free(clone
);
114 /* Can we init from struct? */
116 memcached_st declared_clone
;
118 clone
= memcached_clone(&declared_clone
, NULL
);
120 memcached_free(clone
);
123 /* Can we init from struct? */
125 memcached_st declared_clone
;
127 clone
= memcached_clone(&declared_clone
, memc
);
129 memcached_free(clone
);
135 uint8_t connection_test(memcached_st
*memc
)
139 rc
= memcached_server_add(memc
, "localhost", 0);
140 assert(rc
== MEMCACHED_SUCCESS
);
145 uint8_t error_test(memcached_st
*memc
)
149 for (rc
= MEMCACHED_SUCCESS
; rc
< MEMCACHED_MAXIMUM_RETURN
; rc
++)
151 printf("Error %d -> %s\n", rc
, memcached_strerror(memc
, rc
));
157 uint8_t set_test(memcached_st
*memc
)
161 char *value
= "when we sanitize";
163 rc
= memcached_set(memc
, key
, strlen(key
),
164 value
, strlen(value
),
165 (time_t)0, (uint32_t)0);
166 assert(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
);
171 uint8_t append_test(memcached_st
*memc
)
179 rc
= memcached_flush(memc
, 0);
180 assert(rc
== MEMCACHED_SUCCESS
);
182 rc
= memcached_set(memc
, key
, strlen(key
),
183 value
, strlen(value
),
184 (time_t)0, (uint32_t)0);
185 assert(rc
== MEMCACHED_SUCCESS
);
187 rc
= memcached_append(memc
, key
, strlen(key
),
188 " the", strlen(" the"),
189 (time_t)0, (uint32_t)0);
190 assert(rc
== MEMCACHED_SUCCESS
);
192 rc
= memcached_append(memc
, key
, strlen(key
),
193 " people", strlen(" people"),
194 (time_t)0, (uint32_t)0);
195 assert(rc
== MEMCACHED_SUCCESS
);
197 value
= memcached_get(memc
, key
, strlen(key
),
198 &value_length
, &flags
, &rc
);
199 assert(!memcmp(value
, "we the people", strlen("we the people")));
200 assert(strlen("we the people") == value_length
);
201 assert(rc
== MEMCACHED_SUCCESS
);
207 uint8_t append_binary_test(memcached_st
*memc
)
210 char *key
= "numbers";
211 unsigned int *store_ptr
;
212 unsigned int store_list
[] = { 23, 56, 499, 98, 32847, 0 };
218 rc
= memcached_flush(memc
, 0);
219 assert(rc
== MEMCACHED_SUCCESS
);
221 rc
= memcached_set(memc
,
224 (time_t)0, (uint32_t)0);
225 assert(rc
== MEMCACHED_SUCCESS
);
227 for (x
= 0; store_list
[x
] ; x
++)
229 rc
= memcached_append(memc
,
231 (char *)&store_list
[x
], sizeof(unsigned int),
232 (time_t)0, (uint32_t)0);
233 assert(rc
== MEMCACHED_SUCCESS
);
236 value
= memcached_get(memc
, key
, strlen(key
),
237 &value_length
, &flags
, &rc
);
238 assert((value_length
== (sizeof(unsigned int) * x
)));
239 assert(rc
== MEMCACHED_SUCCESS
);
241 store_ptr
= (unsigned int *)value
;
243 while ((size_t)store_ptr
< (size_t)(value
+ value_length
))
245 assert(*store_ptr
== store_list
[x
++]);
253 uint8_t cas2_test(memcached_st
*memc
)
256 char *keys
[]= {"fudge", "son", "food"};
257 size_t key_length
[]= {5, 3, 4};
258 char *value
= "we the people";
259 size_t value_length
= strlen("we the people");
261 memcached_result_st results_obj
;
262 memcached_result_st
*results
;
265 rc
= memcached_flush(memc
, 0);
266 assert(rc
== MEMCACHED_SUCCESS
);
268 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_SUPPORT_CAS
, set
);
270 for (x
= 0; x
< 3; x
++)
272 rc
= memcached_set(memc
, keys
[x
], key_length
[x
],
273 keys
[x
], key_length
[x
],
274 (time_t)50, (uint32_t)9);
275 assert(rc
== MEMCACHED_SUCCESS
);
278 rc
= memcached_mget(memc
, keys
, key_length
, 3);
280 results
= memcached_result_create(memc
, &results_obj
);
282 results
= memcached_fetch_result(memc
, &results_obj
, &rc
);
284 assert(results
->cas
);
285 assert(rc
== MEMCACHED_SUCCESS
);
286 WATCHPOINT_ASSERT(memcached_result_cas(results
));
288 assert(!memcmp(value
, "we the people", strlen("we the people")));
289 assert(strlen("we the people") == value_length
);
290 assert(rc
== MEMCACHED_SUCCESS
);
292 memcached_result_free(&results_obj
);
297 uint8_t cas_test(memcached_st
*memc
)
301 size_t key_length
= strlen("fun");
302 char *value
= "we the people";
303 size_t value_length
= strlen("we the people");
304 memcached_result_st results_obj
;
305 memcached_result_st
*results
;
308 rc
= memcached_flush(memc
, 0);
309 assert(rc
== MEMCACHED_SUCCESS
);
311 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_SUPPORT_CAS
, set
);
313 rc
= memcached_set(memc
, key
, strlen(key
),
314 value
, strlen(value
),
315 (time_t)0, (uint32_t)0);
316 assert(rc
== MEMCACHED_SUCCESS
);
318 rc
= memcached_mget(memc
, &key
, &key_length
, 1);
320 results
= memcached_result_create(memc
, &results_obj
);
322 results
= memcached_fetch_result(memc
, &results_obj
, &rc
);
324 assert(rc
== MEMCACHED_SUCCESS
);
325 WATCHPOINT_ASSERT(memcached_result_cas(results
));
327 assert(!memcmp(value
, "we the people", strlen("we the people")));
328 assert(strlen("we the people") == value_length
);
329 assert(rc
== MEMCACHED_SUCCESS
);
331 rc
= memcached_cas(memc
, key
, key_length
,
332 "change the value", strlen("change the value"),
333 0, 0, memcached_result_cas(results
));
335 assert(rc
== MEMCACHED_SUCCESS
);
337 rc
= memcached_cas(memc
, key
, key_length
,
338 "change the value", strlen("change the value"),
341 assert(rc
== MEMCACHED_DATA_EXISTS
);
344 memcached_result_free(&results_obj
);
349 uint8_t prepend_test(memcached_st
*memc
)
353 char *value
= "people";
357 rc
= memcached_flush(memc
, 0);
358 assert(rc
== MEMCACHED_SUCCESS
);
360 rc
= memcached_set(memc
, key
, strlen(key
),
361 value
, strlen(value
),
362 (time_t)0, (uint32_t)0);
363 assert(rc
== MEMCACHED_SUCCESS
);
365 rc
= memcached_prepend(memc
, key
, strlen(key
),
366 "the ", strlen("the "),
367 (time_t)0, (uint32_t)0);
368 assert(rc
== MEMCACHED_SUCCESS
);
370 rc
= memcached_prepend(memc
, key
, strlen(key
),
371 "we ", strlen("we "),
372 (time_t)0, (uint32_t)0);
373 assert(rc
== MEMCACHED_SUCCESS
);
375 value
= memcached_get(memc
, key
, strlen(key
),
376 &value_length
, &flags
, &rc
);
377 assert(!memcmp(value
, "we the people", strlen("we the people")));
378 assert(strlen("we the people") == value_length
);
379 assert(rc
== MEMCACHED_SUCCESS
);
386 Set the value, then quit to make sure it is flushed.
387 Come back in and test that add fails.
389 uint8_t add_test(memcached_st
*memc
)
393 char *value
= "when we sanitize";
394 unsigned long long setting_value
;
396 setting_value
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_NO_BLOCK
);
398 rc
= memcached_set(memc
, key
, strlen(key
),
399 value
, strlen(value
),
400 (time_t)0, (uint32_t)0);
401 assert(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
);
402 memcached_quit(memc
);
403 rc
= memcached_add(memc
, key
, strlen(key
),
404 value
, strlen(value
),
405 (time_t)0, (uint32_t)0);
407 /* Too many broken OS'es have broken loopback in async, so we can't be sure of the result */
409 assert(rc
== MEMCACHED_NOTSTORED
|| MEMCACHED_STORED
);
411 assert(rc
== MEMCACHED_NOTSTORED
);
416 uint8_t add_wrapper(memcached_st
*memc
)
420 for (x
= 0; x
< 10000; x
++)
426 uint8_t replace_test(memcached_st
*memc
)
430 char *value
= "when we sanitize";
431 char *original
= "first we insert some data";
433 rc
= memcached_set(memc
, key
, strlen(key
),
434 original
, strlen(original
),
435 (time_t)0, (uint32_t)0);
436 assert(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
);
438 rc
= memcached_replace(memc
, key
, strlen(key
),
439 value
, strlen(value
),
440 (time_t)0, (uint32_t)0);
441 assert(rc
== MEMCACHED_SUCCESS
);
446 uint8_t delete_test(memcached_st
*memc
)
450 char *value
= "when we sanitize";
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 rc
= memcached_delete(memc
, key
, strlen(key
), (time_t)0);
458 assert(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
);
463 uint8_t flush_test(memcached_st
*memc
)
467 rc
= memcached_flush(memc
, 0);
468 assert(rc
== MEMCACHED_SUCCESS
);
473 memcached_return
server_function(memcached_st
*ptr
, memcached_server_st
*server
, void *context
)
477 return MEMCACHED_SUCCESS
;
480 uint8_t memcached_server_cursor_test(memcached_st
*memc
)
482 char *context
= "foo bad";
483 memcached_server_function callbacks
[1];
485 callbacks
[0]= server_function
;
486 memcached_server_cursor(memc
, callbacks
, context
, 1);
491 uint8_t bad_key_test(memcached_st
*memc
)
494 char *key
= "foo bad";
496 size_t string_length
;
501 clone
= memcached_clone(NULL
, memc
);
504 (void)memcached_behavior_set(clone
, MEMCACHED_BEHAVIOR_VERIFY_KEY
, set
);
506 string
= memcached_get(clone
, key
, strlen(key
),
507 &string_length
, &flags
, &rc
);
508 assert(rc
== MEMCACHED_BAD_KEY_PROVIDED
);
509 assert(string_length
== 0);
513 (void)memcached_behavior_set(clone
, MEMCACHED_BEHAVIOR_VERIFY_KEY
, set
);
514 string
= memcached_get(clone
, key
, strlen(key
),
515 &string_length
, &flags
, &rc
);
516 assert(rc
== MEMCACHED_NOTFOUND
);
517 assert(string_length
== 0);
520 memcached_free(clone
);
525 #define READ_THROUGH_VALUE "set for me"
526 memcached_return
read_through_trigger(memcached_st
*memc
,
527 char *key
, size_t key_length
,
528 memcached_result_st
*result
)
531 return memcached_result_set_value(result
, READ_THROUGH_VALUE
, strlen(READ_THROUGH_VALUE
));
534 uint8_t read_through(memcached_st
*memc
)
539 size_t string_length
;
542 string
= memcached_get(memc
, key
, strlen(key
),
543 &string_length
, &flags
, &rc
);
545 assert(rc
== MEMCACHED_NOTFOUND
);
546 assert(string_length
== 0);
549 rc
= memcached_callback_set(memc
, MEMCACHED_CALLBACK_GET_FAILURE
, read_through_trigger
);
550 assert(rc
== MEMCACHED_SUCCESS
);
552 string
= memcached_get(memc
, key
, strlen(key
),
553 &string_length
, &flags
, &rc
);
555 assert(rc
== MEMCACHED_SUCCESS
);
556 assert(string_length
== strlen(READ_THROUGH_VALUE
));
557 assert(!strcmp(READ_THROUGH_VALUE
, string
));
559 string
= memcached_get(memc
, key
, strlen(key
),
560 &string_length
, &flags
, &rc
);
562 assert(rc
== MEMCACHED_SUCCESS
);
563 assert(string_length
== strlen(READ_THROUGH_VALUE
));
564 assert(!strcmp(READ_THROUGH_VALUE
, string
));
569 uint8_t get_test(memcached_st
*memc
)
574 size_t string_length
;
577 rc
= memcached_delete(memc
, key
, strlen(key
), (time_t)0);
578 assert(rc
== MEMCACHED_BUFFERED
|| rc
== MEMCACHED_NOTFOUND
);
580 string
= memcached_get(memc
, key
, strlen(key
),
581 &string_length
, &flags
, &rc
);
583 assert(rc
== MEMCACHED_NOTFOUND
);
584 assert(string_length
== 0);
590 uint8_t get_test2(memcached_st
*memc
)
594 char *value
= "when we sanitize";
596 size_t string_length
;
599 rc
= memcached_set(memc
, key
, strlen(key
),
600 value
, strlen(value
),
601 (time_t)0, (uint32_t)0);
602 assert(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
);
604 string
= memcached_get(memc
, key
, strlen(key
),
605 &string_length
, &flags
, &rc
);
608 assert(rc
== MEMCACHED_SUCCESS
);
609 assert(string_length
== strlen(value
));
610 assert(!memcmp(string
, value
, string_length
));
617 uint8_t set_test2(memcached_st
*memc
)
621 char *value
= "train in the brain";
622 size_t value_length
= strlen(value
);
625 for (x
= 0; x
< 10; x
++)
627 rc
= memcached_set(memc
, key
, strlen(key
),
629 (time_t)0, (uint32_t)0);
630 assert(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
);
636 uint8_t set_test3(memcached_st
*memc
)
641 size_t value_length
= 8191;
644 value
= (char*)malloc(value_length
);
647 for (x
= 0; x
< value_length
; x
++)
648 value
[x
] = (char) (x
% 127);
650 for (x
= 0; x
< 1; x
++)
652 rc
= memcached_set(memc
, key
, strlen(key
),
654 (time_t)0, (uint32_t)0);
655 assert(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
);
663 uint8_t get_test3(memcached_st
*memc
)
668 size_t value_length
= 8191;
670 size_t string_length
;
674 value
= (char*)malloc(value_length
);
677 for (x
= 0; x
< value_length
; x
++)
678 value
[x
] = (char) (x
% 127);
680 rc
= memcached_set(memc
, key
, strlen(key
),
682 (time_t)0, (uint32_t)0);
683 assert(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
);
685 string
= memcached_get(memc
, key
, strlen(key
),
686 &string_length
, &flags
, &rc
);
688 assert(rc
== MEMCACHED_SUCCESS
);
690 assert(string_length
== value_length
);
691 assert(!memcmp(string
, value
, string_length
));
699 uint8_t get_test4(memcached_st
*memc
)
704 size_t value_length
= 8191;
706 size_t string_length
;
710 value
= (char*)malloc(value_length
);
713 for (x
= 0; x
< value_length
; x
++)
714 value
[x
] = (char) (x
% 127);
716 rc
= memcached_set(memc
, key
, strlen(key
),
718 (time_t)0, (uint32_t)0);
719 assert(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
);
721 for (x
= 0; x
< 10; x
++)
723 string
= memcached_get(memc
, key
, strlen(key
),
724 &string_length
, &flags
, &rc
);
726 assert(rc
== MEMCACHED_SUCCESS
);
728 assert(string_length
== value_length
);
729 assert(!memcmp(string
, value
, string_length
));
738 /* Do not copy the style of this code, I just access hosts to testthis function */
739 uint8_t stats_servername_test(memcached_st
*memc
)
742 memcached_stat_st stat
;
743 rc
= memcached_stat_servername(&stat
, NULL
,
744 memc
->hosts
[0].hostname
,
745 memc
->hosts
[0].port
);
750 uint8_t increment_test(memcached_st
*memc
)
757 rc
= memcached_set(memc
, key
, strlen(key
),
758 value
, strlen(value
),
759 (time_t)0, (uint32_t)0);
760 assert(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
);
762 rc
= memcached_increment(memc
, key
, strlen(key
),
764 assert(rc
== MEMCACHED_SUCCESS
);
765 assert(new_number
== 1);
767 rc
= memcached_increment(memc
, key
, strlen(key
),
769 assert(rc
== MEMCACHED_SUCCESS
);
770 assert(new_number
== 2);
775 uint8_t decrement_test(memcached_st
*memc
)
782 rc
= memcached_set(memc
, key
, strlen(key
),
783 value
, strlen(value
),
784 (time_t)0, (uint32_t)0);
785 assert(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
);
787 rc
= memcached_decrement(memc
, key
, strlen(key
),
789 assert(rc
== MEMCACHED_SUCCESS
);
790 assert(new_number
== 2);
792 rc
= memcached_decrement(memc
, key
, strlen(key
),
794 assert(rc
== MEMCACHED_SUCCESS
);
795 assert(new_number
== 1);
800 uint8_t quit_test(memcached_st
*memc
)
804 char *value
= "sanford and sun";
806 rc
= memcached_set(memc
, key
, strlen(key
),
807 value
, strlen(value
),
808 (time_t)10, (uint32_t)3);
809 assert(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
);
810 memcached_quit(memc
);
812 rc
= memcached_set(memc
, key
, strlen(key
),
813 value
, strlen(value
),
814 (time_t)50, (uint32_t)9);
815 assert(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
);
820 uint8_t mget_result_test(memcached_st
*memc
)
823 char *keys
[]= {"fudge", "son", "food"};
824 size_t key_length
[]= {5, 3, 4};
827 memcached_result_st results_obj
;
828 memcached_result_st
*results
;
830 results
= memcached_result_create(memc
, &results_obj
);
832 assert(&results_obj
== results
);
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 ((results
= memcached_fetch_result(memc
, &results_obj
, &rc
)) != NULL
)
846 while ((results
= memcached_fetch_result(memc
, &results_obj
, &rc
)) != NULL
)
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
);
861 while ((results
= memcached_fetch_result(memc
, &results_obj
, &rc
)))
864 assert(&results_obj
== results
);
865 assert(rc
== MEMCACHED_SUCCESS
);
866 assert(memcached_result_key_length(results
) == memcached_result_length(results
));
867 assert(!memcmp(memcached_result_key_value(results
),
868 memcached_result_value(results
),
869 memcached_result_length(results
)));
872 memcached_result_free(&results_obj
);
877 uint8_t mget_result_alloc_test(memcached_st
*memc
)
880 char *keys
[]= {"fudge", "son", "food"};
881 size_t key_length
[]= {5, 3, 4};
884 memcached_result_st
*results
;
886 /* We need to empty the server before continueing test */
887 rc
= memcached_flush(memc
, 0);
888 assert(rc
== MEMCACHED_SUCCESS
);
890 rc
= memcached_mget(memc
, keys
, key_length
, 3);
891 assert(rc
== MEMCACHED_SUCCESS
);
893 while ((results
= memcached_fetch_result(memc
, NULL
, &rc
)) != NULL
)
898 assert(rc
== MEMCACHED_END
);
900 for (x
= 0; x
< 3; x
++)
902 rc
= memcached_set(memc
, keys
[x
], key_length
[x
],
903 keys
[x
], key_length
[x
],
904 (time_t)50, (uint32_t)9);
905 assert(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
);
908 rc
= memcached_mget(memc
, keys
, key_length
, 3);
909 assert(rc
== MEMCACHED_SUCCESS
);
912 while ((results
= memcached_fetch_result(memc
, NULL
, &rc
)))
915 assert(rc
== MEMCACHED_SUCCESS
);
916 assert(memcached_result_key_length(results
) == memcached_result_length(results
));
917 assert(!memcmp(memcached_result_key_value(results
),
918 memcached_result_value(results
),
919 memcached_result_length(results
)));
920 memcached_result_free(results
);
927 /* Count the results */
928 unsigned int callback_counter(memcached_st
*ptr
, memcached_result_st
*result
, void *context
)
930 unsigned int *counter
= (unsigned int *)context
;
932 *counter
= *counter
+ 1;
937 uint8_t mget_result_function(memcached_st
*memc
)
940 char *keys
[]= {"fudge", "son", "food"};
941 size_t key_length
[]= {5, 3, 4};
943 unsigned int counter
;
944 memcached_execute_function callbacks
[1];
946 /* We need to empty the server before continueing test */
947 rc
= memcached_flush(memc
, 0);
948 for (x
= 0; x
< 3; x
++)
950 rc
= memcached_set(memc
, keys
[x
], key_length
[x
],
951 keys
[x
], key_length
[x
],
952 (time_t)50, (uint32_t)9);
953 assert(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
);
956 rc
= memcached_mget(memc
, keys
, key_length
, 3);
957 assert(rc
== MEMCACHED_SUCCESS
);
959 callbacks
[0]= &callback_counter
;
961 rc
= memcached_fetch_execute(memc
, callbacks
, (void *)&counter
, 1);
963 assert(counter
== 3);
968 uint8_t mget_test(memcached_st
*memc
)
971 char *keys
[]= {"fudge", "son", "food"};
972 size_t key_length
[]= {5, 3, 4};
976 char return_key
[MEMCACHED_MAX_KEY
];
977 size_t return_key_length
;
979 size_t return_value_length
;
981 /* We need to empty the server before continueing test */
982 rc
= memcached_flush(memc
, 0);
983 assert(rc
== MEMCACHED_SUCCESS
);
985 rc
= memcached_mget(memc
, keys
, key_length
, 3);
986 assert(rc
== MEMCACHED_SUCCESS
);
988 while ((return_value
= memcached_fetch(memc
, return_key
, &return_key_length
,
989 &return_value_length
, &flags
, &rc
)) != NULL
)
991 assert(return_value
);
993 assert(!return_value
);
994 assert(return_value_length
== 0);
995 assert(rc
== MEMCACHED_END
);
997 for (x
= 0; x
< 3; x
++)
999 rc
= memcached_set(memc
, keys
[x
], key_length
[x
],
1000 keys
[x
], key_length
[x
],
1001 (time_t)50, (uint32_t)9);
1002 assert(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
);
1005 rc
= memcached_mget(memc
, keys
, key_length
, 3);
1006 assert(rc
== MEMCACHED_SUCCESS
);
1009 while ((return_value
= memcached_fetch(memc
, return_key
, &return_key_length
,
1010 &return_value_length
, &flags
, &rc
)))
1012 assert(return_value
);
1013 assert(rc
== MEMCACHED_SUCCESS
);
1014 assert(return_key_length
== return_value_length
);
1015 assert(!memcmp(return_value
, return_key
, return_value_length
));
1023 uint8_t get_stats_keys(memcached_st
*memc
)
1027 memcached_stat_st stat
;
1028 memcached_return rc
;
1030 list
= memcached_stat_get_keys(memc
, &stat
, &rc
);
1031 assert(rc
== MEMCACHED_SUCCESS
);
1032 for (ptr
= list
; *ptr
; ptr
++)
1041 uint8_t version_string_test(memcached_st
*memc
)
1043 const char *version_string
;
1045 version_string
= memcached_lib_version();
1047 assert(!strcmp(version_string
, LIBMEMCACHED_VERSION_STRING
));
1052 uint8_t get_stats(memcached_st
*memc
)
1057 memcached_return rc
;
1058 memcached_stat_st
*stat
;
1060 stat
= memcached_stat(memc
, NULL
, &rc
);
1061 assert(rc
== MEMCACHED_SUCCESS
);
1063 assert(rc
== MEMCACHED_SUCCESS
);
1066 for (x
= 0; x
< memcached_server_count(memc
); x
++)
1068 list
= memcached_stat_get_keys(memc
, stat
+x
, &rc
);
1069 assert(rc
== MEMCACHED_SUCCESS
);
1070 for (ptr
= list
; *ptr
; ptr
++);
1075 memcached_stat_free(NULL
, stat
);
1080 uint8_t add_host_test(memcached_st
*memc
)
1083 memcached_server_st
*servers
;
1084 memcached_return rc
;
1085 char servername
[]= "0.example.com";
1087 servers
= memcached_server_list_append(NULL
, servername
, 400, &rc
);
1089 assert(1 == memcached_server_list_count(servers
));
1091 for (x
= 2; x
< 20; x
++)
1093 char buffer
[SMALL_STRING_LEN
];
1095 snprintf(buffer
, SMALL_STRING_LEN
, "%u.example.com", 400+x
);
1096 servers
= memcached_server_list_append(servers
, buffer
, 401,
1098 assert(rc
== MEMCACHED_SUCCESS
);
1099 assert(x
== memcached_server_list_count(servers
));
1102 rc
= memcached_server_push(memc
, servers
);
1103 assert(rc
== MEMCACHED_SUCCESS
);
1104 rc
= memcached_server_push(memc
, servers
);
1105 assert(rc
== MEMCACHED_SUCCESS
);
1107 memcached_server_list_free(servers
);
1112 memcached_return
clone_test_callback(memcached_st
*parent
, memcached_st
*clone
)
1114 return MEMCACHED_SUCCESS
;
1117 memcached_return
cleanup_test_callback(memcached_st
*ptr
)
1119 return MEMCACHED_SUCCESS
;
1122 uint8_t callback_test(memcached_st
*memc
)
1124 /* Test User Data */
1128 memcached_return rc
;
1130 rc
= memcached_callback_set(memc
, MEMCACHED_CALLBACK_USER_DATA
, &x
);
1131 assert(rc
== MEMCACHED_SUCCESS
);
1132 test_ptr
= (int *)memcached_callback_get(memc
, MEMCACHED_CALLBACK_USER_DATA
, &rc
);
1133 assert(*test_ptr
== x
);
1136 /* Test Clone Callback */
1138 memcached_clone_func temp_function
;
1139 memcached_return rc
;
1141 rc
= memcached_callback_set(memc
, MEMCACHED_CALLBACK_CLONE_FUNCTION
, clone_test_callback
);
1142 assert(rc
== MEMCACHED_SUCCESS
);
1143 temp_function
= (memcached_clone_func
)memcached_callback_get(memc
, MEMCACHED_CALLBACK_CLONE_FUNCTION
, &rc
);
1144 assert(temp_function
== clone_test_callback
);
1147 /* Test Cleanup Callback */
1149 memcached_cleanup_func temp_function
;
1150 memcached_return rc
;
1152 rc
= memcached_callback_set(memc
, MEMCACHED_CALLBACK_CLONE_FUNCTION
, cleanup_test_callback
);
1153 assert(rc
== MEMCACHED_SUCCESS
);
1154 temp_function
= (memcached_cleanup_func
)memcached_callback_get(memc
, MEMCACHED_CALLBACK_CLONE_FUNCTION
, &rc
);
1155 assert(temp_function
== cleanup_test_callback
);
1161 /* We don't test the behavior itself, we test the switches */
1162 uint8_t behavior_test(memcached_st
*memc
)
1164 unsigned long long value
;
1165 unsigned int set
= 1;
1167 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NO_BLOCK
, set
);
1168 value
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_NO_BLOCK
);
1171 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_TCP_NODELAY
, set
);
1172 value
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_TCP_NODELAY
);
1175 set
= MEMCACHED_HASH_MD5
;
1176 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_HASH
, set
);
1177 value
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_HASH
);
1178 assert(value
== MEMCACHED_HASH_MD5
);
1182 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NO_BLOCK
, set
);
1183 value
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_NO_BLOCK
);
1186 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_TCP_NODELAY
, set
);
1187 value
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_TCP_NODELAY
);
1190 set
= MEMCACHED_HASH_DEFAULT
;
1191 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_HASH
, set
);
1192 value
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_HASH
);
1193 assert(value
== MEMCACHED_HASH_DEFAULT
);
1195 set
= MEMCACHED_HASH_CRC
;
1196 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_HASH
, set
);
1197 value
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_HASH
);
1198 assert(value
== MEMCACHED_HASH_CRC
);
1200 value
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_SOCKET_SEND_SIZE
);
1203 value
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_SOCKET_RECV_SIZE
);
1209 /* Test case provided by Cal Haldenbrand */
1210 uint8_t user_supplied_bug1(memcached_st
*memc
)
1212 unsigned int setter
= 1;
1215 unsigned long long total
= 0;
1218 char randomstuff
[6 * 1024];
1219 memcached_return rc
;
1221 memset(randomstuff
, 0, 6 * 1024);
1223 /* We just keep looking at the same values over and over */
1226 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NO_BLOCK
, setter
);
1227 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_TCP_NODELAY
, setter
);
1231 for (x
= 0 ; total
< 20 * 1024576 ; x
++ )
1235 size
= (rand() % ( 5 * 1024 ) ) + 400;
1236 memset(randomstuff
, 0, 6 * 1024);
1237 assert(size
< 6 * 1024); /* Being safe here */
1239 for (j
= 0 ; j
< size
;j
++)
1240 randomstuff
[j
] = (char) (rand() % 26) + 97;
1243 sprintf(key
, "%d", x
);
1244 rc
= memcached_set(memc
, key
, strlen(key
),
1245 randomstuff
, strlen(randomstuff
), 10, 0);
1246 /* If we fail, lets try again */
1247 if (rc
!= MEMCACHED_SUCCESS
&& rc
!= MEMCACHED_BUFFERED
)
1248 rc
= memcached_set(memc
, key
, strlen(key
),
1249 randomstuff
, strlen(randomstuff
), 10, 0);
1250 assert(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
);
1256 /* Test case provided by Cal Haldenbrand */
1257 uint8_t user_supplied_bug2(memcached_st
*memc
)
1260 unsigned int setter
;
1262 unsigned long long total
;
1265 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NO_BLOCK
, setter
);
1266 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_TCP_NODELAY
, setter
);
1268 setter
= 20 * 1024576;
1269 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_SOCKET_SEND_SIZE
, setter
);
1270 setter
= 20 * 1024576;
1271 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_SOCKET_RECV_SIZE
, setter
);
1272 getter
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_SOCKET_SEND_SIZE
);
1273 getter
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_SOCKET_RECV_SIZE
);
1275 for (x
= 0, errors
= 0, total
= 0 ; total
< 20 * 1024576 ; x
++)
1278 for (x
= 0, errors
= 0, total
= 0 ; total
< 24576 ; x
++)
1280 memcached_return rc
= MEMCACHED_SUCCESS
;
1281 char buffer
[SMALL_STRING_LEN
];
1286 memset(buffer
, 0, SMALL_STRING_LEN
);
1288 snprintf(buffer
, SMALL_STRING_LEN
, "%u", x
);
1289 getval
= memcached_get(memc
, buffer
, strlen(buffer
),
1290 &val_len
, &flags
, &rc
);
1291 if (rc
!= MEMCACHED_SUCCESS
)
1293 if (rc
== MEMCACHED_NOTFOUND
)
1297 WATCHPOINT_ERROR(rc
);
1311 /* Do a large mget() over all the keys we think exist */
1312 #define KEY_COUNT 3000 // * 1024576
1313 uint8_t user_supplied_bug3(memcached_st
*memc
)
1315 memcached_return rc
;
1316 unsigned int setter
;
1319 size_t key_lengths
[KEY_COUNT
];
1322 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NO_BLOCK
, setter
);
1323 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_TCP_NODELAY
, setter
);
1325 setter
= 20 * 1024576;
1326 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_SOCKET_SEND_SIZE
, setter
);
1327 setter
= 20 * 1024576;
1328 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_SOCKET_RECV_SIZE
, setter
);
1329 getter
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_SOCKET_SEND_SIZE
);
1330 getter
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_SOCKET_RECV_SIZE
);
1333 keys
= (char **)malloc(sizeof(char *) * KEY_COUNT
);
1335 memset(keys
, 0, (sizeof(char *) * KEY_COUNT
));
1336 for (x
= 0; x
< KEY_COUNT
; x
++)
1340 snprintf(buffer
, 30, "%u", x
);
1341 keys
[x
]= strdup(buffer
);
1342 key_lengths
[x
]= strlen(keys
[x
]);
1345 rc
= memcached_mget(memc
, keys
, key_lengths
, KEY_COUNT
);
1346 assert(rc
== MEMCACHED_SUCCESS
);
1348 /* Turn this into a help function */
1350 char return_key
[MEMCACHED_MAX_KEY
];
1351 size_t return_key_length
;
1353 size_t return_value_length
;
1356 while ((return_value
= memcached_fetch(memc
, return_key
, &return_key_length
,
1357 &return_value_length
, &flags
, &rc
)))
1359 assert(return_value
);
1360 assert(rc
== MEMCACHED_SUCCESS
);
1365 for (x
= 0; x
< KEY_COUNT
; x
++)
1372 /* Make sure we behave properly if server list has no values */
1373 uint8_t user_supplied_bug4(memcached_st
*memc
)
1375 memcached_return rc
;
1376 char *keys
[]= {"fudge", "son", "food"};
1377 size_t key_length
[]= {5, 3, 4};
1380 char return_key
[MEMCACHED_MAX_KEY
];
1381 size_t return_key_length
;
1383 size_t return_value_length
;
1385 /* Here we free everything before running a bunch of mget tests */
1387 memcached_server_list_free(memc
->hosts
);
1389 memc
->number_of_hosts
= 0;
1393 /* We need to empty the server before continueing test */
1394 rc
= memcached_flush(memc
, 0);
1395 assert(rc
== MEMCACHED_NO_SERVERS
);
1397 rc
= memcached_mget(memc
, keys
, key_length
, 3);
1398 assert(rc
== MEMCACHED_NO_SERVERS
);
1400 while ((return_value
= memcached_fetch(memc
, return_key
, &return_key_length
,
1401 &return_value_length
, &flags
, &rc
)) != NULL
)
1403 assert(return_value
);
1405 assert(!return_value
);
1406 assert(return_value_length
== 0);
1407 assert(rc
== MEMCACHED_NO_SERVERS
);
1409 for (x
= 0; x
< 3; x
++)
1411 rc
= memcached_set(memc
, keys
[x
], key_length
[x
],
1412 keys
[x
], key_length
[x
],
1413 (time_t)50, (uint32_t)9);
1414 assert(rc
== MEMCACHED_NO_SERVERS
);
1417 rc
= memcached_mget(memc
, keys
, key_length
, 3);
1418 assert(rc
== MEMCACHED_NO_SERVERS
);
1421 while ((return_value
= memcached_fetch(memc
, return_key
, &return_key_length
,
1422 &return_value_length
, &flags
, &rc
)))
1424 assert(return_value
);
1425 assert(rc
== MEMCACHED_SUCCESS
);
1426 assert(return_key_length
== return_value_length
);
1427 assert(!memcmp(return_value
, return_key
, return_value_length
));
1435 #define VALUE_SIZE_BUG5 1048064
1436 uint8_t user_supplied_bug5(memcached_st
*memc
)
1438 memcached_return rc
;
1439 char *keys
[]= {"036790384900", "036790384902", "036790384904", "036790384906"};
1440 size_t key_length
[]= {strlen("036790384900"), strlen("036790384902"), strlen("036790384904"), strlen("036790384906")};
1441 char return_key
[MEMCACHED_MAX_KEY
];
1442 size_t return_key_length
;
1444 size_t value_length
;
1448 char insert_data
[VALUE_SIZE_BUG5
];
1450 for (x
= 0; x
< VALUE_SIZE_BUG5
; x
++)
1451 insert_data
[x
]= rand();
1453 memcached_flush(memc
, 0);
1454 value
= memcached_get(memc
, keys
[0], key_length
[0],
1455 &value_length
, &flags
, &rc
);
1456 assert(value
== NULL
);
1457 rc
= memcached_mget(memc
, keys
, key_length
, 4);
1460 while ((value
= memcached_fetch(memc
, return_key
, &return_key_length
,
1461 &value_length
, &flags
, &rc
)))
1465 for (x
= 0; x
< 4; x
++)
1467 rc
= memcached_set(memc
, keys
[x
], key_length
[x
],
1468 insert_data
, VALUE_SIZE_BUG5
,
1469 (time_t)0, (uint32_t)0);
1470 assert(rc
== MEMCACHED_SUCCESS
);
1473 for (x
= 0; x
< 10; x
++)
1475 value
= memcached_get(memc
, keys
[0], key_length
[0],
1476 &value_length
, &flags
, &rc
);
1480 rc
= memcached_mget(memc
, keys
, key_length
, 4);
1482 while ((value
= memcached_fetch(memc
, return_key
, &return_key_length
,
1483 &value_length
, &flags
, &rc
)))
1494 uint8_t user_supplied_bug6(memcached_st
*memc
)
1496 memcached_return rc
;
1497 char *keys
[]= {"036790384900", "036790384902", "036790384904", "036790384906"};
1498 size_t key_length
[]= {strlen("036790384900"), strlen("036790384902"), strlen("036790384904"), strlen("036790384906")};
1499 char return_key
[MEMCACHED_MAX_KEY
];
1500 size_t return_key_length
;
1502 size_t value_length
;
1506 char insert_data
[VALUE_SIZE_BUG5
];
1508 for (x
= 0; x
< VALUE_SIZE_BUG5
; x
++)
1509 insert_data
[x
]= rand();
1511 memcached_flush(memc
, 0);
1512 value
= memcached_get(memc
, keys
[0], key_length
[0],
1513 &value_length
, &flags
, &rc
);
1514 assert(value
== NULL
);
1515 assert(rc
== MEMCACHED_NOTFOUND
);
1516 rc
= memcached_mget(memc
, keys
, key_length
, 4);
1517 assert(rc
== MEMCACHED_SUCCESS
);
1520 while ((value
= memcached_fetch(memc
, return_key
, &return_key_length
,
1521 &value_length
, &flags
, &rc
)))
1524 assert(rc
== MEMCACHED_END
);
1526 for (x
= 0; x
< 4; x
++)
1528 rc
= memcached_set(memc
, keys
[x
], key_length
[x
],
1529 insert_data
, VALUE_SIZE_BUG5
,
1530 (time_t)0, (uint32_t)0);
1531 assert(rc
== MEMCACHED_SUCCESS
);
1534 for (x
= 0; x
< 2; x
++)
1536 value
= memcached_get(memc
, keys
[0], key_length
[0],
1537 &value_length
, &flags
, &rc
);
1541 rc
= memcached_mget(memc
, keys
, key_length
, 4);
1542 assert(rc
== MEMCACHED_SUCCESS
);
1544 /* We test for purge of partial complete fetches */
1545 for (count
= 3; count
; count
--)
1547 value
= memcached_fetch(memc
, return_key
, &return_key_length
,
1548 &value_length
, &flags
, &rc
);
1549 assert(rc
== MEMCACHED_SUCCESS
);
1550 assert(!(memcmp(value
, insert_data
, value_length
)));
1551 assert(value_length
);
1559 uint8_t user_supplied_bug8(memcached_st
*memc
)
1561 memcached_return rc
;
1563 memcached_st
*clone
;
1565 memcached_server_st
*servers
;
1566 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";
1568 servers
= memcached_servers_parse(server_list
);
1571 mine
= memcached_create(NULL
);
1572 rc
= memcached_server_push(mine
, servers
);
1573 assert(rc
== MEMCACHED_SUCCESS
);
1574 memcached_server_list_free(servers
);
1577 clone
= memcached_clone(NULL
, mine
);
1579 memcached_quit(mine
);
1580 memcached_quit(clone
);
1583 memcached_free(mine
);
1584 memcached_free(clone
);
1589 /* Test flag store/retrieve */
1590 uint8_t user_supplied_bug7(memcached_st
*memc
)
1592 memcached_return rc
;
1593 char *keys
= "036790384900";
1594 size_t key_length
= strlen("036790384900");
1595 char return_key
[MEMCACHED_MAX_KEY
];
1596 size_t return_key_length
;
1598 size_t value_length
;
1601 char insert_data
[VALUE_SIZE_BUG5
];
1603 for (x
= 0; x
< VALUE_SIZE_BUG5
; x
++)
1604 insert_data
[x
]= rand();
1606 memcached_flush(memc
, 0);
1609 rc
= memcached_set(memc
, keys
, key_length
,
1610 insert_data
, VALUE_SIZE_BUG5
,
1612 assert(rc
== MEMCACHED_SUCCESS
);
1615 value
= memcached_get(memc
, keys
, key_length
,
1616 &value_length
, &flags
, &rc
);
1617 assert(flags
== 245);
1621 rc
= memcached_mget(memc
, &keys
, &key_length
, 1);
1624 value
= memcached_fetch(memc
, return_key
, &return_key_length
,
1625 &value_length
, &flags
, &rc
);
1626 assert(flags
== 245);
1634 uint8_t user_supplied_bug9(memcached_st
*memc
)
1636 memcached_return rc
;
1637 char *keys
[]= {"UDATA:edevil@sapo.pt", "fudge&*@#", "for^#@&$not"};
1638 size_t key_length
[3];
1643 char return_key
[MEMCACHED_MAX_KEY
];
1644 size_t return_key_length
;
1646 size_t return_value_length
;
1649 key_length
[0]= strlen("UDATA:edevil@sapo.pt");
1650 key_length
[1]= strlen("fudge&*@#");
1651 key_length
[2]= strlen("for^#@&$not");
1654 for (x
= 0; x
< 3; x
++)
1656 rc
= memcached_set(memc
, keys
[x
], key_length
[x
],
1657 keys
[x
], key_length
[x
],
1658 (time_t)50, (uint32_t)9);
1659 assert(rc
== MEMCACHED_SUCCESS
);
1662 rc
= memcached_mget(memc
, keys
, key_length
, 3);
1663 assert(rc
== MEMCACHED_SUCCESS
);
1665 /* We need to empty the server before continueing test */
1666 while ((return_value
= memcached_fetch(memc
, return_key
, &return_key_length
,
1667 &return_value_length
, &flags
, &rc
)) != NULL
)
1669 assert(return_value
);
1678 /* We are testing with aggressive timeout to get failures */
1679 uint8_t user_supplied_bug10(memcached_st
*memc
)
1683 size_t value_length
= 512;
1686 memcached_return rc
;
1687 unsigned int set
= 1;
1688 memcached_st
*mclone
= memcached_clone(NULL
, memc
);
1691 memcached_behavior_set(mclone
, MEMCACHED_BEHAVIOR_NO_BLOCK
, set
);
1692 memcached_behavior_set(mclone
, MEMCACHED_BEHAVIOR_TCP_NODELAY
, set
);
1694 memcached_behavior_set(mclone
, MEMCACHED_BEHAVIOR_POLL_TIMEOUT
, timeout
);
1696 value
= (char*)malloc(value_length
* sizeof(char));
1698 for (x
= 0; x
< value_length
; x
++)
1699 value
[x
]= (char) (x
% 127);
1701 for (x
= 1; x
<= 100000; ++x
)
1703 rc
= memcached_set(mclone
, key
, key_len
,value
, value_length
, 0, 0);
1705 assert(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_WRITE_FAILURE
|| rc
== MEMCACHED_BUFFERED
);
1707 if (rc
== MEMCACHED_WRITE_FAILURE
)
1712 memcached_free(mclone
);
1718 We are looking failures in the async protocol
1720 uint8_t user_supplied_bug11(memcached_st
*memc
)
1724 size_t value_length
= 512;
1727 memcached_return rc
;
1728 unsigned int set
= 1;
1730 memcached_st
*mclone
= memcached_clone(NULL
, memc
);
1732 memcached_behavior_set(mclone
, MEMCACHED_BEHAVIOR_NO_BLOCK
, set
);
1733 memcached_behavior_set(mclone
, MEMCACHED_BEHAVIOR_TCP_NODELAY
, set
);
1735 memcached_behavior_set(mclone
, MEMCACHED_BEHAVIOR_POLL_TIMEOUT
, timeout
);
1737 timeout
= (int32_t)memcached_behavior_get(mclone
, MEMCACHED_BEHAVIOR_POLL_TIMEOUT
);
1739 assert(timeout
== -1);
1741 value
= (char*)malloc(value_length
* sizeof(char));
1743 for (x
= 0; x
< value_length
; x
++)
1744 value
[x
]= (char) (x
% 127);
1746 for (x
= 1; x
<= 100000; ++x
)
1748 rc
= memcached_set(mclone
, key
, key_len
,value
, value_length
, 0, 0);
1752 memcached_free(mclone
);
1758 Bug found where incr was not returning MEMCACHED_NOTFOUND when object did not exist.
1760 uint8_t user_supplied_bug12(memcached_st
*memc
)
1762 memcached_return rc
;
1764 size_t value_length
;
1766 uint64_t number_value
;
1768 value
= memcached_get(memc
, "autoincrement", strlen("autoincrement"),
1769 &value_length
, &flags
, &rc
);
1770 assert(value
== NULL
);
1771 assert(rc
== MEMCACHED_NOTFOUND
);
1773 rc
= memcached_increment(memc
, "autoincrement", strlen("autoincrement"),
1776 assert(value
== NULL
);
1777 assert(rc
== MEMCACHED_NOTFOUND
);
1779 rc
= memcached_set(memc
, "autoincrement", strlen("autoincrement"), "1", 1, 0, 0);
1781 value
= memcached_get(memc
, "autoincrement", strlen("autoincrement"),
1782 &value_length
, &flags
, &rc
);
1784 assert(rc
== MEMCACHED_SUCCESS
);
1787 rc
= memcached_increment(memc
, "autoincrement", strlen("autoincrement"),
1789 assert(number_value
== 2);
1790 assert(rc
== MEMCACHED_SUCCESS
);
1796 Bug found where command total one more than MEMCACHED_MAX_BUFFER
1797 set key34567890 0 0 8169 \r\n is sent followed by buffer of size 8169, followed by 8169
1799 uint8_t user_supplied_bug13(memcached_st
*memc
)
1801 char key
[] = "key34567890";
1803 memcached_return rc
;
1804 size_t overflowSize
;
1806 char commandFirst
[]= "set key34567890 0 0 ";
1807 char commandLast
[] = " \r\n"; /* first line of command sent to server */
1808 size_t commandLength
;
1811 commandLength
= strlen(commandFirst
) + strlen(commandLast
) + 4; /* 4 is number of characters in size, probably 8196 */
1813 overflowSize
= MEMCACHED_MAX_BUFFER
- commandLength
;
1815 for (testSize
= overflowSize
- 1; testSize
< overflowSize
+ 1; testSize
++)
1817 overflow
= malloc(testSize
);
1818 assert(overflow
!= NULL
);
1820 memset(overflow
, 'x', testSize
);
1821 rc
= memcached_set(memc
, key
, strlen(key
),
1822 overflow
, testSize
, 0, 0);
1823 assert(rc
== MEMCACHED_SUCCESS
);
1832 Test values of many different sizes
1833 Bug found where command total one more than MEMCACHED_MAX_BUFFER
1834 set key34567890 0 0 8169 \r\n
1835 is sent followed by buffer of size 8169, followed by 8169
1837 uint8_t user_supplied_bug14(memcached_st
*memc
)
1840 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_TCP_NODELAY
, setter
);
1841 memcached_return rc
;
1844 size_t value_length
= 18000;
1846 size_t string_length
;
1849 size_t current_length
;
1851 value
= (char*)malloc(value_length
);
1854 for (x
= 0; x
< value_length
; x
++)
1855 value
[x
] = (char) (x
% 127);
1857 for (current_length
= 0; current_length
< value_length
; current_length
++)
1859 rc
= memcached_set(memc
, key
, strlen(key
),
1860 value
, current_length
,
1861 (time_t)0, (uint32_t)0);
1862 assert(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
);
1864 string
= memcached_get(memc
, key
, strlen(key
),
1865 &string_length
, &flags
, &rc
);
1867 assert(rc
== MEMCACHED_SUCCESS
);
1868 if (current_length
> 0)
1870 assert(string_length
== current_length
);
1871 assert(!memcmp(string
, value
, string_length
));
1882 Look for zero length value problems
1884 uint8_t user_supplied_bug15(memcached_st
*memc
)
1887 memcached_return rc
;
1893 for (x
= 0; x
< 2; x
++)
1895 rc
= memcached_set(memc
, key
, strlen(key
),
1897 (time_t)0, (uint32_t)0);
1899 assert(rc
== MEMCACHED_SUCCESS
);
1901 value
= memcached_get(memc
, key
, strlen(key
),
1902 &length
, &flags
, &rc
);
1904 assert(rc
== MEMCACHED_SUCCESS
);
1905 assert(value
== NULL
);
1906 assert(length
== 0);
1909 value
= memcached_get(memc
, key
, strlen(key
),
1910 &length
, &flags
, &rc
);
1912 assert(rc
== MEMCACHED_SUCCESS
);
1913 assert(value
== NULL
);
1914 assert(length
== 0);
1921 uint8_t result_static(memcached_st
*memc
)
1923 memcached_result_st result
;
1924 memcached_result_st
*result_ptr
;
1926 result_ptr
= memcached_result_create(memc
, &result
);
1927 assert(result
.is_allocated
== MEMCACHED_NOT_ALLOCATED
);
1929 memcached_result_free(&result
);
1934 uint8_t result_alloc(memcached_st
*memc
)
1936 memcached_result_st
*result
;
1938 result
= memcached_result_create(memc
, NULL
);
1940 memcached_result_free(result
);
1945 uint8_t string_static_null(memcached_st
*memc
)
1947 memcached_string_st string
;
1948 memcached_string_st
*string_ptr
;
1950 string_ptr
= memcached_string_create(memc
, &string
, 0);
1951 assert(string
.is_allocated
== MEMCACHED_NOT_ALLOCATED
);
1953 memcached_string_free(&string
);
1958 uint8_t string_alloc_null(memcached_st
*memc
)
1960 memcached_string_st
*string
;
1962 string
= memcached_string_create(memc
, NULL
, 0);
1964 memcached_string_free(string
);
1969 uint8_t string_alloc_with_size(memcached_st
*memc
)
1971 memcached_string_st
*string
;
1973 string
= memcached_string_create(memc
, NULL
, 1024);
1975 memcached_string_free(string
);
1980 uint8_t string_alloc_with_size_toobig(memcached_st
*memc
)
1982 memcached_string_st
*string
;
1984 string
= memcached_string_create(memc
, NULL
, INT64_MAX
);
1985 assert(string
== NULL
);
1990 uint8_t string_alloc_append(memcached_st
*memc
)
1993 char buffer
[SMALL_STRING_LEN
];
1994 memcached_string_st
*string
;
1996 /* Ring the bell! */
1997 memset(buffer
, 6, SMALL_STRING_LEN
);
1999 string
= memcached_string_create(memc
, NULL
, 100);
2002 for (x
= 0; x
< 1024; x
++)
2004 memcached_return rc
;
2005 rc
= memcached_string_append(string
, buffer
, SMALL_STRING_LEN
);
2006 assert(rc
== MEMCACHED_SUCCESS
);
2008 memcached_string_free(string
);
2013 uint8_t string_alloc_append_toobig(memcached_st
*memc
)
2015 memcached_return rc
;
2017 char buffer
[SMALL_STRING_LEN
];
2018 memcached_string_st
*string
;
2020 /* Ring the bell! */
2021 memset(buffer
, 6, SMALL_STRING_LEN
);
2023 string
= memcached_string_create(memc
, NULL
, 100);
2026 for (x
= 0; x
< 1024; x
++)
2028 rc
= memcached_string_append(string
, buffer
, SMALL_STRING_LEN
);
2029 assert(rc
== MEMCACHED_SUCCESS
);
2031 rc
= memcached_string_append(string
, buffer
, INT64_MAX
);
2032 assert(rc
== MEMCACHED_MEMORY_ALLOCATION_FAILURE
);
2033 memcached_string_free(string
);
2038 uint8_t cleanup_pairs(memcached_st
*memc
)
2040 pairs_free(global_pairs
);
2045 uint8_t generate_pairs(memcached_st
*memc
)
2047 unsigned long long x
;
2048 global_pairs
= pairs_generate(GLOBAL_COUNT
, 400);
2049 global_count
= GLOBAL_COUNT
;
2051 for (x
= 0; x
< global_count
; x
++)
2053 global_keys
[x
]= global_pairs
[x
].key
;
2054 global_keys_length
[x
]= global_pairs
[x
].key_length
;
2060 uint8_t generate_large_pairs(memcached_st
*memc
)
2062 unsigned long long x
;
2063 global_pairs
= pairs_generate(GLOBAL2_COUNT
, MEMCACHED_MAX_BUFFER
+10);
2064 global_count
= GLOBAL2_COUNT
;
2066 for (x
= 0; x
< global_count
; x
++)
2068 global_keys
[x
]= global_pairs
[x
].key
;
2069 global_keys_length
[x
]= global_pairs
[x
].key_length
;
2075 uint8_t generate_data(memcached_st
*memc
)
2077 execute_set(memc
, global_pairs
, global_count
);
2082 uint8_t generate_buffer_data(memcached_st
*memc
)
2087 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_BUFFER_REQUESTS
, latch
);
2088 generate_data(memc
);
2093 uint8_t get_read(memcached_st
*memc
)
2096 memcached_return rc
;
2100 size_t return_value_length
;
2103 for (x
= 0; x
< global_count
; x
++)
2105 return_value
= memcached_get(memc
, global_keys
[x
], global_keys_length
[x
],
2106 &return_value_length
, &flags
, &rc
);
2108 assert(return_value);
2109 assert(rc == MEMCACHED_SUCCESS);
2111 if (rc
== MEMCACHED_SUCCESS
&& return_value
)
2119 uint8_t mget_read(memcached_st
*memc
)
2121 memcached_return rc
;
2123 rc
= memcached_mget(memc
, global_keys
, global_keys_length
, global_count
);
2124 assert(rc
== MEMCACHED_SUCCESS
);
2125 /* Turn this into a help function */
2127 char return_key
[MEMCACHED_MAX_KEY
];
2128 size_t return_key_length
;
2130 size_t return_value_length
;
2133 while ((return_value
= memcached_fetch(memc
, return_key
, &return_key_length
,
2134 &return_value_length
, &flags
, &rc
)))
2136 assert(return_value
);
2137 assert(rc
== MEMCACHED_SUCCESS
);
2145 uint8_t mget_read_result(memcached_st
*memc
)
2147 memcached_return rc
;
2149 rc
= memcached_mget(memc
, global_keys
, global_keys_length
, global_count
);
2150 assert(rc
== MEMCACHED_SUCCESS
);
2151 /* Turn this into a help function */
2153 memcached_result_st results_obj
;
2154 memcached_result_st
*results
;
2156 results
= memcached_result_create(memc
, &results_obj
);
2158 while ((results
= memcached_fetch_result(memc
, &results_obj
, &rc
)))
2161 assert(rc
== MEMCACHED_SUCCESS
);
2164 memcached_result_free(&results_obj
);
2170 uint8_t mget_read_function(memcached_st
*memc
)
2172 memcached_return rc
;
2173 unsigned int counter
;
2174 unsigned int (*callbacks
[1])(memcached_st
*, memcached_result_st
*, void *);
2176 rc
= memcached_mget(memc
, global_keys
, global_keys_length
, global_count
);
2177 assert(rc
== MEMCACHED_SUCCESS
);
2179 callbacks
[0]= &callback_counter
;
2181 rc
= memcached_fetch_execute(memc
, callbacks
, (void *)&counter
, 1);
2186 uint8_t delete_generate(memcached_st
*memc
)
2190 for (x
= 0; x
< global_count
; x
++)
2192 (void)memcached_delete(memc
, global_keys
[x
], global_keys_length
[x
], (time_t)0);
2198 uint8_t delete_buffer_generate(memcached_st
*memc
)
2204 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_BUFFER_REQUESTS
, latch
);
2206 for (x
= 0; x
< global_count
; x
++)
2208 (void)memcached_delete(memc
, global_keys
[x
], global_keys_length
[x
], (time_t)0);
2214 uint8_t free_data(memcached_st
*memc
)
2216 pairs_free(global_pairs
);
2221 uint8_t add_host_test1(memcached_st
*memc
)
2224 memcached_return rc
;
2225 char servername
[]= "0.example.com";
2226 memcached_server_st
*servers
;
2228 servers
= memcached_server_list_append(NULL
, servername
, 400, &rc
);
2230 assert(1 == memcached_server_list_count(servers
));
2232 for (x
= 2; x
< 20; x
++)
2234 char buffer
[SMALL_STRING_LEN
];
2236 snprintf(buffer
, SMALL_STRING_LEN
, "%u.example.com", 400+x
);
2237 servers
= memcached_server_list_append(servers
, buffer
, 401,
2239 assert(rc
== MEMCACHED_SUCCESS
);
2240 assert(x
== memcached_server_list_count(servers
));
2243 rc
= memcached_server_push(memc
, servers
);
2244 assert(rc
== MEMCACHED_SUCCESS
);
2245 rc
= memcached_server_push(memc
, servers
);
2246 assert(rc
== MEMCACHED_SUCCESS
);
2248 memcached_server_list_free(servers
);
2253 memcached_return
pre_nonblock(memcached_st
*memc
)
2255 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NO_BLOCK
, 0);
2257 return MEMCACHED_SUCCESS
;
2260 memcached_return
pre_murmur(memcached_st
*memc
)
2262 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_HASH
, (uint64_t)MEMCACHED_HASH_MURMUR
);
2264 return MEMCACHED_SUCCESS
;
2267 memcached_return
pre_md5(memcached_st
*memc
)
2269 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_HASH
, (uint64_t)MEMCACHED_HASH_MD5
);
2271 return MEMCACHED_SUCCESS
;
2274 memcached_return
pre_crc(memcached_st
*memc
)
2276 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_HASH
, (uint64_t)MEMCACHED_HASH_CRC
);
2278 return MEMCACHED_SUCCESS
;
2281 memcached_return
pre_hsieh(memcached_st
*memc
)
2283 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_HASH
, (uint64_t)MEMCACHED_HASH_HSIEH
);
2285 return MEMCACHED_SUCCESS
;
2288 memcached_return
pre_hash_fnv1_64(memcached_st
*memc
)
2290 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_HASH
, (uint64_t)MEMCACHED_HASH_FNV1_64
);
2292 return MEMCACHED_SUCCESS
;
2295 memcached_return
pre_hash_fnv1a_64(memcached_st
*memc
)
2297 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_HASH
, (uint64_t)MEMCACHED_HASH_FNV1A_64
);
2299 return MEMCACHED_SUCCESS
;
2302 memcached_return
pre_hash_fnv1_32(memcached_st
*memc
)
2304 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_HASH
, (uint64_t)MEMCACHED_HASH_FNV1_32
);
2306 return MEMCACHED_SUCCESS
;
2309 memcached_return
pre_hash_fnv1a_32(memcached_st
*memc
)
2311 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_HASH
, (uint64_t)MEMCACHED_HASH_FNV1A_32
);
2313 return MEMCACHED_SUCCESS
;
2316 memcached_return
pre_hash_ketama(memcached_st
*memc
)
2318 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_HASH
, (uint64_t)MEMCACHED_HASH_KETAMA
);
2320 return MEMCACHED_SUCCESS
;
2323 void my_free(memcached_st
*ptr
, void *mem
)
2328 void *my_malloc(memcached_st
*ptr
, const size_t size
)
2330 return malloc(size
);
2333 void *my_realloc(memcached_st
*ptr
, void *mem
, const size_t size
)
2335 return realloc(mem
, size
);
2338 memcached_return
set_memory_alloc(memcached_st
*memc
)
2341 memcached_malloc_function test_ptr
;
2342 memcached_return rc
;
2344 rc
= memcached_callback_set(memc
, MEMCACHED_CALLBACK_MALLOC_FUNCTION
, &my_malloc
);
2345 assert(rc
== MEMCACHED_SUCCESS
);
2346 test_ptr
= (memcached_malloc_function
)memcached_callback_get(memc
, MEMCACHED_CALLBACK_MALLOC_FUNCTION
, &rc
);
2347 assert(rc
== MEMCACHED_SUCCESS
);
2348 assert(test_ptr
== my_malloc
);
2352 memcached_realloc_function test_ptr
;
2353 memcached_return rc
;
2355 rc
= memcached_callback_set(memc
, MEMCACHED_CALLBACK_REALLOC_FUNCTION
, &my_realloc
);
2356 assert(rc
== MEMCACHED_SUCCESS
);
2357 test_ptr
= (memcached_realloc_function
)memcached_callback_get(memc
, MEMCACHED_CALLBACK_REALLOC_FUNCTION
, &rc
);
2358 assert(rc
== MEMCACHED_SUCCESS
);
2359 assert(test_ptr
== my_realloc
);
2363 memcached_free_function test_ptr
;
2364 memcached_return rc
;
2366 rc
= memcached_callback_set(memc
, MEMCACHED_CALLBACK_FREE_FUNCTION
, my_free
);
2367 assert(rc
== MEMCACHED_SUCCESS
);
2368 test_ptr
= (memcached_free_function
)memcached_callback_get(memc
, MEMCACHED_CALLBACK_FREE_FUNCTION
, &rc
);
2369 assert(rc
== MEMCACHED_SUCCESS
);
2370 assert(test_ptr
== my_free
);
2373 return MEMCACHED_SUCCESS
;
2376 memcached_return
enable_consistent(memcached_st
*memc
)
2378 memcached_server_distribution value
= MEMCACHED_DISTRIBUTION_CONSISTENT
;
2379 memcached_hash hash
;
2380 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_DISTRIBUTION
, value
);
2383 value
= (memcached_server_distribution
)memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_DISTRIBUTION
);
2384 assert(value
== MEMCACHED_DISTRIBUTION_CONSISTENT
);
2386 hash
= (memcached_hash
)memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_HASH
);
2387 assert(hash
== MEMCACHED_HASH_HSIEH
);
2390 return MEMCACHED_SUCCESS
;
2393 memcached_return
enable_cas(memcached_st
*memc
)
2395 unsigned int set
= 1;
2397 memcached_version(memc
);
2399 if (memc
->hosts
[0].major_version
>= 1 &&
2400 memc
->hosts
[0].minor_version
>= 2 &&
2401 memc
->hosts
[0].micro_version
>= 4)
2403 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_SUPPORT_CAS
, set
);
2405 return MEMCACHED_SUCCESS
;
2408 return MEMCACHED_FAILURE
;
2411 memcached_return
check_for_1_2_3(memcached_st
*memc
)
2413 memcached_version(memc
);
2415 if (memc
->hosts
[0].major_version
>= 1 &&
2416 memc
->hosts
[0].minor_version
>= 2 &&
2417 memc
->hosts
[0].micro_version
>= 4)
2418 return MEMCACHED_SUCCESS
;
2420 return MEMCACHED_FAILURE
;
2423 memcached_return
pre_unix_socket(memcached_st
*memc
)
2425 memcached_return rc
;
2428 memcached_server_list_free(memc
->hosts
);
2430 memc
->number_of_hosts
= 0;
2432 if (stat("/tmp/memcached.socket", &buf
))
2433 return MEMCACHED_FAILURE
;
2435 rc
= memcached_server_add_unix_socket(memc
, "/tmp/memcached.socket");
2440 memcached_return
pre_udp(memcached_st
*memc
)
2442 memcached_return rc
;
2444 memcached_server_list_free(memc
->hosts
);
2446 memc
->number_of_hosts
= 0;
2449 return MEMCACHED_FAILURE
;
2451 rc
= memcached_server_add_udp(memc
, "localhost", MEMCACHED_DEFAULT_PORT
);
2456 memcached_return
pre_nodelay(memcached_st
*memc
)
2458 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NO_BLOCK
, 0);
2459 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_TCP_NODELAY
, 0);
2461 return MEMCACHED_SUCCESS
;
2464 memcached_return
poll_timeout(memcached_st
*memc
)
2470 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_POLL_TIMEOUT
, timeout
);
2472 timeout
= (int32_t)memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_POLL_TIMEOUT
);
2474 assert(timeout
== 100);
2476 return MEMCACHED_SUCCESS
;
2480 /* Clean the server before beginning testing */
2482 {"flush", 0, flush_test
},
2483 {"init", 0, init_test
},
2484 {"allocation", 0, allocation_test
},
2485 {"server_list_null_test", 0, server_list_null_test
},
2486 {"server_sort", 0, server_sort_test
},
2487 {"clone_test", 0, clone_test
},
2488 {"error", 0, error_test
},
2489 {"set", 0, set_test
},
2490 {"set2", 0, set_test2
},
2491 {"set3", 0, set_test3
},
2492 {"add", 1, add_test
},
2493 {"replace", 1, replace_test
},
2494 {"delete", 1, delete_test
},
2495 {"get", 1, get_test
},
2496 {"get2", 0, get_test2
},
2497 {"get3", 0, get_test3
},
2498 {"get4", 0, get_test4
},
2499 {"stats_servername", 0, stats_servername_test
},
2500 {"increment", 0, increment_test
},
2501 {"decrement", 0, decrement_test
},
2502 {"quit", 0, quit_test
},
2503 {"mget", 1, mget_test
},
2504 {"mget_result", 1, mget_result_test
},
2505 {"mget_result_alloc", 1, mget_result_alloc_test
},
2506 {"mget_result_function", 1, mget_result_function
},
2507 {"get_stats", 0, get_stats
},
2508 {"add_host_test", 0, add_host_test
},
2509 {"get_stats_keys", 0, get_stats_keys
},
2510 {"behavior_test", 0, get_stats_keys
},
2511 {"callback_test", 0, get_stats_keys
},
2512 {"version_string_test", 0, version_string_test
},
2513 {"bad_key", 1, bad_key_test
},
2514 {"memcached_server_cursor", 1, memcached_server_cursor_test
},
2515 {"read_through", 1, read_through
},
2519 test_st async_tests
[] ={
2520 {"add", 1, add_wrapper
},
2524 test_st string_tests
[] ={
2525 {"string static with null", 0, string_static_null
},
2526 {"string alloc with null", 0, string_alloc_null
},
2527 {"string alloc with 1K", 0, string_alloc_with_size
},
2528 {"string alloc with malloc failure", 0, string_alloc_with_size_toobig
},
2529 {"string append", 0, string_alloc_append
},
2530 {"string append failure (too big)", 0, string_alloc_append_toobig
},
2534 test_st result_tests
[] ={
2535 {"result static", 0, result_static
},
2536 {"result alloc", 0, result_alloc
},
2540 test_st version_1_2_3
[] ={
2541 {"append", 0, append_test
},
2542 {"prepend", 0, prepend_test
},
2543 {"cas", 0, cas_test
},
2544 {"cas2", 0, cas2_test
},
2545 {"append_binary", 0, append_binary_test
},
2549 test_st user_tests
[] ={
2550 {"user_supplied_bug1", 0, user_supplied_bug1
},
2551 {"user_supplied_bug2", 0, user_supplied_bug2
},
2552 {"user_supplied_bug3", 0, user_supplied_bug3
},
2553 {"user_supplied_bug4", 0, user_supplied_bug4
},
2554 {"user_supplied_bug5", 1, user_supplied_bug5
},
2555 {"user_supplied_bug6", 1, user_supplied_bug6
},
2556 {"user_supplied_bug7", 1, user_supplied_bug7
},
2557 {"user_supplied_bug8", 1, user_supplied_bug8
},
2558 {"user_supplied_bug9", 1, user_supplied_bug9
},
2559 {"user_supplied_bug10", 1, user_supplied_bug10
},
2560 {"user_supplied_bug11", 1, user_supplied_bug11
},
2561 {"user_supplied_bug12", 1, user_supplied_bug12
},
2562 {"user_supplied_bug13", 1, user_supplied_bug13
},
2563 {"user_supplied_bug14", 1, user_supplied_bug14
},
2564 {"user_supplied_bug15", 1, user_supplied_bug15
},
2568 test_st generate_tests
[] ={
2569 {"generate_pairs", 1, generate_pairs
},
2570 {"generate_data", 1, generate_data
},
2571 {"get_read", 0, get_read
},
2572 {"delete_generate", 0, delete_generate
},
2573 {"generate_buffer_data", 1, generate_buffer_data
},
2574 {"delete_buffer", 0, delete_buffer_generate
},
2575 {"generate_data", 1, generate_data
},
2576 {"mget_read", 0, mget_read
},
2577 {"mget_read_result", 0, mget_read_result
},
2578 {"mget_read_function", 0, mget_read_function
},
2579 {"cleanup", 1, cleanup_pairs
},
2580 {"generate_large_pairs", 1, generate_large_pairs
},
2581 {"generate_data", 1, generate_data
},
2582 {"generate_buffer_data", 1, generate_buffer_data
},
2583 {"cleanup", 1, cleanup_pairs
},
2588 collection_st collection
[] ={
2589 {"block", 0, 0, tests
},
2590 {"nonblock", pre_nonblock
, 0, tests
},
2591 {"nodelay", pre_nodelay
, 0, tests
},
2592 {"md5", pre_md5
, 0, tests
},
2593 {"crc", pre_crc
, 0, tests
},
2594 {"hsieh", pre_hsieh
, 0, tests
},
2595 {"fnv1_64", pre_hash_fnv1_64
, 0, tests
},
2596 {"fnv1a_64", pre_hash_fnv1a_64
, 0, tests
},
2597 {"fnv1_32", pre_hash_fnv1_32
, 0, tests
},
2598 {"fnv1a_32", pre_hash_fnv1a_32
, 0, tests
},
2599 {"ketama", pre_hash_ketama
, 0, tests
},
2600 {"unix_socket", pre_unix_socket
, 0, tests
},
2601 {"unix_socket_nodelay", pre_nodelay
, 0, tests
},
2602 {"poll_timeout", poll_timeout
, 0, tests
},
2603 {"gets", enable_cas
, 0, tests
},
2604 {"consistent", enable_consistent
, 0, tests
},
2605 {"memory_allocators", set_memory_alloc
, 0, tests
},
2606 // {"udp", pre_udp, 0, tests},
2607 {"version_1_2_3", check_for_1_2_3
, 0, version_1_2_3
},
2608 {"string", 0, 0, string_tests
},
2609 {"result", 0, 0, result_tests
},
2610 {"async", pre_nonblock
, 0, async_tests
},
2611 {"user", 0, 0, user_tests
},
2612 {"generate", 0, 0, generate_tests
},
2613 {"generate_hsieh", pre_hsieh
, 0, generate_tests
},
2614 {"generate_hsieh_consistent", enable_consistent
, 0, generate_tests
},
2615 {"generate_md5", pre_md5
, 0, generate_tests
},
2616 {"generate_murmur", pre_murmur
, 0, generate_tests
},
2617 {"generate_nonblock", pre_nonblock
, 0, generate_tests
},
2621 #define SERVERS_TO_CREATE 5
2623 void *world_create(void)
2625 server_startup_st
*construct
;
2627 construct
= (server_startup_st
*)malloc(sizeof(server_startup_st
));
2628 memset(construct
, 0, sizeof(server_startup_st
));
2629 construct
->count
= SERVERS_TO_CREATE
;
2631 server_startup(construct
);
2636 void world_destroy(void *p
)
2638 server_startup_st
*construct
= (server_startup_st
*)p
;
2639 memcached_server_st
*servers
= (memcached_server_st
*)construct
->servers
;
2640 memcached_server_list_free(servers
);
2642 server_shutdown(construct
);
2646 void get_world(world_st
*world
)
2648 world
->collections
= collection
;
2649 world
->create
= world_create
;
2650 world
->destroy
= world_destroy
;