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 uint8_t get_test(memcached_st
*memc
)
530 size_t string_length
;
533 rc
= memcached_delete(memc
, key
, strlen(key
), (time_t)0);
534 assert(rc
== MEMCACHED_BUFFERED
|| rc
== MEMCACHED_NOTFOUND
);
536 string
= memcached_get(memc
, key
, strlen(key
),
537 &string_length
, &flags
, &rc
);
539 assert(rc
== MEMCACHED_NOTFOUND
);
540 assert(string_length
== 0);
546 uint8_t get_test2(memcached_st
*memc
)
550 char *value
= "when we sanitize";
552 size_t string_length
;
555 rc
= memcached_set(memc
, key
, strlen(key
),
556 value
, strlen(value
),
557 (time_t)0, (uint32_t)0);
558 assert(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
);
560 string
= memcached_get(memc
, key
, strlen(key
),
561 &string_length
, &flags
, &rc
);
564 assert(rc
== MEMCACHED_SUCCESS
);
565 assert(string_length
== strlen(value
));
566 assert(!memcmp(string
, value
, string_length
));
573 uint8_t set_test2(memcached_st
*memc
)
577 char *value
= "train in the brain";
578 size_t value_length
= strlen(value
);
581 for (x
= 0; x
< 10; x
++)
583 rc
= memcached_set(memc
, key
, strlen(key
),
585 (time_t)0, (uint32_t)0);
586 assert(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
);
592 uint8_t set_test3(memcached_st
*memc
)
597 size_t value_length
= 8191;
600 value
= (char*)malloc(value_length
);
603 for (x
= 0; x
< value_length
; x
++)
604 value
[x
] = (char) (x
% 127);
606 for (x
= 0; x
< 1; x
++)
608 rc
= memcached_set(memc
, key
, strlen(key
),
610 (time_t)0, (uint32_t)0);
611 assert(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
);
619 uint8_t get_test3(memcached_st
*memc
)
624 size_t value_length
= 8191;
626 size_t string_length
;
630 value
= (char*)malloc(value_length
);
633 for (x
= 0; x
< value_length
; x
++)
634 value
[x
] = (char) (x
% 127);
636 rc
= memcached_set(memc
, key
, strlen(key
),
638 (time_t)0, (uint32_t)0);
639 assert(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
);
641 string
= memcached_get(memc
, key
, strlen(key
),
642 &string_length
, &flags
, &rc
);
644 assert(rc
== MEMCACHED_SUCCESS
);
646 assert(string_length
== value_length
);
647 assert(!memcmp(string
, value
, string_length
));
655 uint8_t get_test4(memcached_st
*memc
)
660 size_t value_length
= 8191;
662 size_t string_length
;
666 value
= (char*)malloc(value_length
);
669 for (x
= 0; x
< value_length
; x
++)
670 value
[x
] = (char) (x
% 127);
672 rc
= memcached_set(memc
, key
, strlen(key
),
674 (time_t)0, (uint32_t)0);
675 assert(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
);
677 for (x
= 0; x
< 10; x
++)
679 string
= memcached_get(memc
, key
, strlen(key
),
680 &string_length
, &flags
, &rc
);
682 assert(rc
== MEMCACHED_SUCCESS
);
684 assert(string_length
== value_length
);
685 assert(!memcmp(string
, value
, string_length
));
694 /* Do not copy the style of this code, I just access hosts to testthis function */
695 uint8_t stats_servername_test(memcached_st
*memc
)
698 memcached_stat_st stat
;
699 rc
= memcached_stat_servername(&stat
, NULL
,
700 memc
->hosts
[0].hostname
,
701 memc
->hosts
[0].port
);
706 uint8_t increment_test(memcached_st
*memc
)
713 rc
= memcached_set(memc
, key
, strlen(key
),
714 value
, strlen(value
),
715 (time_t)0, (uint32_t)0);
716 assert(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
);
718 rc
= memcached_increment(memc
, key
, strlen(key
),
720 assert(rc
== MEMCACHED_SUCCESS
);
721 assert(new_number
== 1);
723 rc
= memcached_increment(memc
, key
, strlen(key
),
725 assert(rc
== MEMCACHED_SUCCESS
);
726 assert(new_number
== 2);
731 uint8_t decrement_test(memcached_st
*memc
)
738 rc
= memcached_set(memc
, key
, strlen(key
),
739 value
, strlen(value
),
740 (time_t)0, (uint32_t)0);
741 assert(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
);
743 rc
= memcached_decrement(memc
, key
, strlen(key
),
745 assert(rc
== MEMCACHED_SUCCESS
);
746 assert(new_number
== 2);
748 rc
= memcached_decrement(memc
, key
, strlen(key
),
750 assert(rc
== MEMCACHED_SUCCESS
);
751 assert(new_number
== 1);
756 uint8_t quit_test(memcached_st
*memc
)
760 char *value
= "sanford and sun";
762 rc
= memcached_set(memc
, key
, strlen(key
),
763 value
, strlen(value
),
764 (time_t)10, (uint32_t)3);
765 assert(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
);
766 memcached_quit(memc
);
768 rc
= memcached_set(memc
, key
, strlen(key
),
769 value
, strlen(value
),
770 (time_t)50, (uint32_t)9);
771 assert(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
);
776 uint8_t mget_result_test(memcached_st
*memc
)
779 char *keys
[]= {"fudge", "son", "food"};
780 size_t key_length
[]= {5, 3, 4};
783 memcached_result_st results_obj
;
784 memcached_result_st
*results
;
786 results
= memcached_result_create(memc
, &results_obj
);
788 assert(&results_obj
== results
);
790 /* We need to empty the server before continueing test */
791 rc
= memcached_flush(memc
, 0);
792 assert(rc
== MEMCACHED_SUCCESS
);
794 rc
= memcached_mget(memc
, keys
, key_length
, 3);
795 assert(rc
== MEMCACHED_SUCCESS
);
797 while ((results
= memcached_fetch_result(memc
, &results_obj
, &rc
)) != NULL
)
802 while ((results
= memcached_fetch_result(memc
, &results_obj
, &rc
)) != NULL
)
804 assert(rc
== MEMCACHED_END
);
806 for (x
= 0; x
< 3; x
++)
808 rc
= memcached_set(memc
, keys
[x
], key_length
[x
],
809 keys
[x
], key_length
[x
],
810 (time_t)50, (uint32_t)9);
811 assert(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
);
814 rc
= memcached_mget(memc
, keys
, key_length
, 3);
815 assert(rc
== MEMCACHED_SUCCESS
);
817 while ((results
= memcached_fetch_result(memc
, &results_obj
, &rc
)))
820 assert(&results_obj
== results
);
821 assert(rc
== MEMCACHED_SUCCESS
);
822 assert(memcached_result_key_length(results
) == memcached_result_length(results
));
823 assert(!memcmp(memcached_result_key_value(results
),
824 memcached_result_value(results
),
825 memcached_result_length(results
)));
828 memcached_result_free(&results_obj
);
833 uint8_t mget_result_alloc_test(memcached_st
*memc
)
836 char *keys
[]= {"fudge", "son", "food"};
837 size_t key_length
[]= {5, 3, 4};
840 memcached_result_st
*results
;
842 /* We need to empty the server before continueing test */
843 rc
= memcached_flush(memc
, 0);
844 assert(rc
== MEMCACHED_SUCCESS
);
846 rc
= memcached_mget(memc
, keys
, key_length
, 3);
847 assert(rc
== MEMCACHED_SUCCESS
);
849 while ((results
= memcached_fetch_result(memc
, NULL
, &rc
)) != NULL
)
854 assert(rc
== MEMCACHED_END
);
856 for (x
= 0; x
< 3; x
++)
858 rc
= memcached_set(memc
, keys
[x
], key_length
[x
],
859 keys
[x
], key_length
[x
],
860 (time_t)50, (uint32_t)9);
861 assert(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
);
864 rc
= memcached_mget(memc
, keys
, key_length
, 3);
865 assert(rc
== MEMCACHED_SUCCESS
);
868 while ((results
= memcached_fetch_result(memc
, NULL
, &rc
)))
871 assert(rc
== MEMCACHED_SUCCESS
);
872 assert(memcached_result_key_length(results
) == memcached_result_length(results
));
873 assert(!memcmp(memcached_result_key_value(results
),
874 memcached_result_value(results
),
875 memcached_result_length(results
)));
876 memcached_result_free(results
);
883 /* Count the results */
884 unsigned int callback_counter(memcached_st
*ptr
, memcached_result_st
*result
, void *context
)
886 unsigned int *counter
= (unsigned int *)context
;
888 *counter
= *counter
+ 1;
893 uint8_t mget_result_function(memcached_st
*memc
)
896 char *keys
[]= {"fudge", "son", "food"};
897 size_t key_length
[]= {5, 3, 4};
899 unsigned int counter
;
900 memcached_execute_function callbacks
[1];
902 /* We need to empty the server before continueing test */
903 rc
= memcached_flush(memc
, 0);
904 for (x
= 0; x
< 3; x
++)
906 rc
= memcached_set(memc
, keys
[x
], key_length
[x
],
907 keys
[x
], key_length
[x
],
908 (time_t)50, (uint32_t)9);
909 assert(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
);
912 rc
= memcached_mget(memc
, keys
, key_length
, 3);
913 assert(rc
== MEMCACHED_SUCCESS
);
915 callbacks
[0]= &callback_counter
;
917 rc
= memcached_fetch_execute(memc
, callbacks
, (void *)&counter
, 1);
919 assert(counter
== 3);
924 uint8_t mget_test(memcached_st
*memc
)
927 char *keys
[]= {"fudge", "son", "food"};
928 size_t key_length
[]= {5, 3, 4};
932 char return_key
[MEMCACHED_MAX_KEY
];
933 size_t return_key_length
;
935 size_t return_value_length
;
937 /* We need to empty the server before continueing test */
938 rc
= memcached_flush(memc
, 0);
939 assert(rc
== MEMCACHED_SUCCESS
);
941 rc
= memcached_mget(memc
, keys
, key_length
, 3);
942 assert(rc
== MEMCACHED_SUCCESS
);
944 while ((return_value
= memcached_fetch(memc
, return_key
, &return_key_length
,
945 &return_value_length
, &flags
, &rc
)) != NULL
)
947 assert(return_value
);
949 assert(!return_value
);
950 assert(return_value_length
== 0);
951 assert(rc
== MEMCACHED_END
);
953 for (x
= 0; x
< 3; x
++)
955 rc
= memcached_set(memc
, keys
[x
], key_length
[x
],
956 keys
[x
], key_length
[x
],
957 (time_t)50, (uint32_t)9);
958 assert(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
);
961 rc
= memcached_mget(memc
, keys
, key_length
, 3);
962 assert(rc
== MEMCACHED_SUCCESS
);
965 while ((return_value
= memcached_fetch(memc
, return_key
, &return_key_length
,
966 &return_value_length
, &flags
, &rc
)))
968 assert(return_value
);
969 assert(rc
== MEMCACHED_SUCCESS
);
970 assert(return_key_length
== return_value_length
);
971 assert(!memcmp(return_value
, return_key
, return_value_length
));
979 uint8_t get_stats_keys(memcached_st
*memc
)
983 memcached_stat_st stat
;
986 list
= memcached_stat_get_keys(memc
, &stat
, &rc
);
987 assert(rc
== MEMCACHED_SUCCESS
);
988 for (ptr
= list
; *ptr
; ptr
++)
997 uint8_t version_string_test(memcached_st
*memc
)
999 const char *version_string
;
1001 version_string
= memcached_lib_version();
1003 assert(!strcmp(version_string
, LIBMEMCACHED_VERSION_STRING
));
1008 uint8_t get_stats(memcached_st
*memc
)
1013 memcached_return rc
;
1014 memcached_stat_st
*stat
;
1016 stat
= memcached_stat(memc
, NULL
, &rc
);
1017 assert(rc
== MEMCACHED_SUCCESS
);
1019 assert(rc
== MEMCACHED_SUCCESS
);
1022 for (x
= 0; x
< memcached_server_count(memc
); x
++)
1024 list
= memcached_stat_get_keys(memc
, stat
+x
, &rc
);
1025 assert(rc
== MEMCACHED_SUCCESS
);
1026 for (ptr
= list
; *ptr
; ptr
++);
1031 memcached_stat_free(NULL
, stat
);
1036 uint8_t add_host_test(memcached_st
*memc
)
1039 memcached_server_st
*servers
;
1040 memcached_return rc
;
1041 char servername
[]= "0.example.com";
1043 servers
= memcached_server_list_append(NULL
, servername
, 400, &rc
);
1045 assert(1 == memcached_server_list_count(servers
));
1047 for (x
= 2; x
< 20; x
++)
1049 char buffer
[SMALL_STRING_LEN
];
1051 snprintf(buffer
, SMALL_STRING_LEN
, "%u.example.com", 400+x
);
1052 servers
= memcached_server_list_append(servers
, buffer
, 401,
1054 assert(rc
== MEMCACHED_SUCCESS
);
1055 assert(x
== memcached_server_list_count(servers
));
1058 rc
= memcached_server_push(memc
, servers
);
1059 assert(rc
== MEMCACHED_SUCCESS
);
1060 rc
= memcached_server_push(memc
, servers
);
1061 assert(rc
== MEMCACHED_SUCCESS
);
1063 memcached_server_list_free(servers
);
1068 memcached_return
clone_test_callback(memcached_st
*parent
, memcached_st
*clone
)
1070 return MEMCACHED_SUCCESS
;
1073 memcached_return
cleanup_test_callback(memcached_st
*ptr
)
1075 return MEMCACHED_SUCCESS
;
1078 uint8_t callback_test(memcached_st
*memc
)
1080 /* Test User Data */
1084 memcached_return rc
;
1086 rc
= memcached_callback_set(memc
, MEMCACHED_CALLBACK_USER_DATA
, &x
);
1087 assert(rc
== MEMCACHED_SUCCESS
);
1088 test_ptr
= (int *)memcached_callback_get(memc
, MEMCACHED_CALLBACK_USER_DATA
, &rc
);
1089 assert(*test_ptr
== x
);
1092 /* Test Clone Callback */
1094 memcached_clone_func temp_function
;
1095 memcached_return rc
;
1097 rc
= memcached_callback_set(memc
, MEMCACHED_CALLBACK_CLONE_FUNCTION
, clone_test_callback
);
1098 assert(rc
== MEMCACHED_SUCCESS
);
1099 temp_function
= (memcached_clone_func
)memcached_callback_get(memc
, MEMCACHED_CALLBACK_CLONE_FUNCTION
, &rc
);
1100 assert(temp_function
== clone_test_callback
);
1103 /* Test Cleanup Callback */
1105 memcached_cleanup_func temp_function
;
1106 memcached_return rc
;
1108 rc
= memcached_callback_set(memc
, MEMCACHED_CALLBACK_CLONE_FUNCTION
, cleanup_test_callback
);
1109 assert(rc
== MEMCACHED_SUCCESS
);
1110 temp_function
= (memcached_cleanup_func
)memcached_callback_get(memc
, MEMCACHED_CALLBACK_CLONE_FUNCTION
, &rc
);
1111 assert(temp_function
== cleanup_test_callback
);
1117 /* We don't test the behavior itself, we test the switches */
1118 uint8_t behavior_test(memcached_st
*memc
)
1120 unsigned long long value
;
1121 unsigned int set
= 1;
1123 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NO_BLOCK
, set
);
1124 value
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_NO_BLOCK
);
1127 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_TCP_NODELAY
, set
);
1128 value
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_TCP_NODELAY
);
1131 set
= MEMCACHED_HASH_MD5
;
1132 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_HASH
, set
);
1133 value
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_HASH
);
1134 assert(value
== MEMCACHED_HASH_MD5
);
1138 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NO_BLOCK
, set
);
1139 value
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_NO_BLOCK
);
1142 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_TCP_NODELAY
, set
);
1143 value
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_TCP_NODELAY
);
1146 set
= MEMCACHED_HASH_DEFAULT
;
1147 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_HASH
, set
);
1148 value
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_HASH
);
1149 assert(value
== MEMCACHED_HASH_DEFAULT
);
1151 set
= MEMCACHED_HASH_CRC
;
1152 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_HASH
, set
);
1153 value
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_HASH
);
1154 assert(value
== MEMCACHED_HASH_CRC
);
1156 value
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_SOCKET_SEND_SIZE
);
1159 value
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_SOCKET_RECV_SIZE
);
1165 /* Test case provided by Cal Haldenbrand */
1166 uint8_t user_supplied_bug1(memcached_st
*memc
)
1168 unsigned int setter
= 1;
1171 unsigned long long total
= 0;
1174 char randomstuff
[6 * 1024];
1175 memcached_return rc
;
1177 memset(randomstuff
, 0, 6 * 1024);
1179 /* We just keep looking at the same values over and over */
1182 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NO_BLOCK
, setter
);
1183 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_TCP_NODELAY
, setter
);
1187 for (x
= 0 ; total
< 20 * 1024576 ; x
++ )
1191 size
= (rand() % ( 5 * 1024 ) ) + 400;
1192 memset(randomstuff
, 0, 6 * 1024);
1193 assert(size
< 6 * 1024); /* Being safe here */
1195 for (j
= 0 ; j
< size
;j
++)
1196 randomstuff
[j
] = (char) (rand() % 26) + 97;
1199 sprintf(key
, "%d", x
);
1200 rc
= memcached_set(memc
, key
, strlen(key
),
1201 randomstuff
, strlen(randomstuff
), 10, 0);
1202 /* If we fail, lets try again */
1203 if (rc
!= MEMCACHED_SUCCESS
&& rc
!= MEMCACHED_BUFFERED
)
1204 rc
= memcached_set(memc
, key
, strlen(key
),
1205 randomstuff
, strlen(randomstuff
), 10, 0);
1206 assert(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
);
1212 /* Test case provided by Cal Haldenbrand */
1213 uint8_t user_supplied_bug2(memcached_st
*memc
)
1216 unsigned int setter
;
1218 unsigned long long total
;
1221 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NO_BLOCK
, setter
);
1222 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_TCP_NODELAY
, setter
);
1224 setter
= 20 * 1024576;
1225 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_SOCKET_SEND_SIZE
, setter
);
1226 setter
= 20 * 1024576;
1227 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_SOCKET_RECV_SIZE
, setter
);
1228 getter
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_SOCKET_SEND_SIZE
);
1229 getter
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_SOCKET_RECV_SIZE
);
1231 for (x
= 0, errors
= 0, total
= 0 ; total
< 20 * 1024576 ; x
++)
1234 for (x
= 0, errors
= 0, total
= 0 ; total
< 24576 ; x
++)
1236 memcached_return rc
= MEMCACHED_SUCCESS
;
1237 char buffer
[SMALL_STRING_LEN
];
1242 memset(buffer
, 0, SMALL_STRING_LEN
);
1244 snprintf(buffer
, SMALL_STRING_LEN
, "%u", x
);
1245 getval
= memcached_get(memc
, buffer
, strlen(buffer
),
1246 &val_len
, &flags
, &rc
);
1247 if (rc
!= MEMCACHED_SUCCESS
)
1249 if (rc
== MEMCACHED_NOTFOUND
)
1253 WATCHPOINT_ERROR(rc
);
1267 /* Do a large mget() over all the keys we think exist */
1268 #define KEY_COUNT 3000 // * 1024576
1269 uint8_t user_supplied_bug3(memcached_st
*memc
)
1271 memcached_return rc
;
1272 unsigned int setter
;
1275 size_t key_lengths
[KEY_COUNT
];
1278 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NO_BLOCK
, setter
);
1279 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_TCP_NODELAY
, setter
);
1281 setter
= 20 * 1024576;
1282 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_SOCKET_SEND_SIZE
, setter
);
1283 setter
= 20 * 1024576;
1284 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_SOCKET_RECV_SIZE
, setter
);
1285 getter
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_SOCKET_SEND_SIZE
);
1286 getter
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_SOCKET_RECV_SIZE
);
1289 keys
= (char **)malloc(sizeof(char *) * KEY_COUNT
);
1291 memset(keys
, 0, (sizeof(char *) * KEY_COUNT
));
1292 for (x
= 0; x
< KEY_COUNT
; x
++)
1296 snprintf(buffer
, 30, "%u", x
);
1297 keys
[x
]= strdup(buffer
);
1298 key_lengths
[x
]= strlen(keys
[x
]);
1301 rc
= memcached_mget(memc
, keys
, key_lengths
, KEY_COUNT
);
1302 assert(rc
== MEMCACHED_SUCCESS
);
1304 /* Turn this into a help function */
1306 char return_key
[MEMCACHED_MAX_KEY
];
1307 size_t return_key_length
;
1309 size_t return_value_length
;
1312 while ((return_value
= memcached_fetch(memc
, return_key
, &return_key_length
,
1313 &return_value_length
, &flags
, &rc
)))
1315 assert(return_value
);
1316 assert(rc
== MEMCACHED_SUCCESS
);
1321 for (x
= 0; x
< KEY_COUNT
; x
++)
1328 /* Make sure we behave properly if server list has no values */
1329 uint8_t user_supplied_bug4(memcached_st
*memc
)
1331 memcached_return rc
;
1332 char *keys
[]= {"fudge", "son", "food"};
1333 size_t key_length
[]= {5, 3, 4};
1336 char return_key
[MEMCACHED_MAX_KEY
];
1337 size_t return_key_length
;
1339 size_t return_value_length
;
1341 /* Here we free everything before running a bunch of mget tests */
1343 memcached_server_list_free(memc
->hosts
);
1345 memc
->number_of_hosts
= 0;
1349 /* We need to empty the server before continueing test */
1350 rc
= memcached_flush(memc
, 0);
1351 assert(rc
== MEMCACHED_NO_SERVERS
);
1353 rc
= memcached_mget(memc
, keys
, key_length
, 3);
1354 assert(rc
== MEMCACHED_NO_SERVERS
);
1356 while ((return_value
= memcached_fetch(memc
, return_key
, &return_key_length
,
1357 &return_value_length
, &flags
, &rc
)) != NULL
)
1359 assert(return_value
);
1361 assert(!return_value
);
1362 assert(return_value_length
== 0);
1363 assert(rc
== MEMCACHED_NO_SERVERS
);
1365 for (x
= 0; x
< 3; x
++)
1367 rc
= memcached_set(memc
, keys
[x
], key_length
[x
],
1368 keys
[x
], key_length
[x
],
1369 (time_t)50, (uint32_t)9);
1370 assert(rc
== MEMCACHED_NO_SERVERS
);
1373 rc
= memcached_mget(memc
, keys
, key_length
, 3);
1374 assert(rc
== MEMCACHED_NO_SERVERS
);
1377 while ((return_value
= memcached_fetch(memc
, return_key
, &return_key_length
,
1378 &return_value_length
, &flags
, &rc
)))
1380 assert(return_value
);
1381 assert(rc
== MEMCACHED_SUCCESS
);
1382 assert(return_key_length
== return_value_length
);
1383 assert(!memcmp(return_value
, return_key
, return_value_length
));
1391 #define VALUE_SIZE_BUG5 1048064
1392 uint8_t user_supplied_bug5(memcached_st
*memc
)
1394 memcached_return rc
;
1395 char *keys
[]= {"036790384900", "036790384902", "036790384904", "036790384906"};
1396 size_t key_length
[]= {strlen("036790384900"), strlen("036790384902"), strlen("036790384904"), strlen("036790384906")};
1397 char return_key
[MEMCACHED_MAX_KEY
];
1398 size_t return_key_length
;
1400 size_t value_length
;
1404 char insert_data
[VALUE_SIZE_BUG5
];
1406 for (x
= 0; x
< VALUE_SIZE_BUG5
; x
++)
1407 insert_data
[x
]= rand();
1409 memcached_flush(memc
, 0);
1410 value
= memcached_get(memc
, keys
[0], key_length
[0],
1411 &value_length
, &flags
, &rc
);
1412 assert(value
== NULL
);
1413 rc
= memcached_mget(memc
, keys
, key_length
, 4);
1416 while ((value
= memcached_fetch(memc
, return_key
, &return_key_length
,
1417 &value_length
, &flags
, &rc
)))
1421 for (x
= 0; x
< 4; x
++)
1423 rc
= memcached_set(memc
, keys
[x
], key_length
[x
],
1424 insert_data
, VALUE_SIZE_BUG5
,
1425 (time_t)0, (uint32_t)0);
1426 assert(rc
== MEMCACHED_SUCCESS
);
1429 for (x
= 0; x
< 10; x
++)
1431 value
= memcached_get(memc
, keys
[0], key_length
[0],
1432 &value_length
, &flags
, &rc
);
1436 rc
= memcached_mget(memc
, keys
, key_length
, 4);
1438 while ((value
= memcached_fetch(memc
, return_key
, &return_key_length
,
1439 &value_length
, &flags
, &rc
)))
1450 uint8_t user_supplied_bug6(memcached_st
*memc
)
1452 memcached_return rc
;
1453 char *keys
[]= {"036790384900", "036790384902", "036790384904", "036790384906"};
1454 size_t key_length
[]= {strlen("036790384900"), strlen("036790384902"), strlen("036790384904"), strlen("036790384906")};
1455 char return_key
[MEMCACHED_MAX_KEY
];
1456 size_t return_key_length
;
1458 size_t value_length
;
1462 char insert_data
[VALUE_SIZE_BUG5
];
1464 for (x
= 0; x
< VALUE_SIZE_BUG5
; x
++)
1465 insert_data
[x
]= rand();
1467 memcached_flush(memc
, 0);
1468 value
= memcached_get(memc
, keys
[0], key_length
[0],
1469 &value_length
, &flags
, &rc
);
1470 assert(value
== NULL
);
1471 assert(rc
== MEMCACHED_NOTFOUND
);
1472 rc
= memcached_mget(memc
, keys
, key_length
, 4);
1473 assert(rc
== MEMCACHED_SUCCESS
);
1476 while ((value
= memcached_fetch(memc
, return_key
, &return_key_length
,
1477 &value_length
, &flags
, &rc
)))
1480 assert(rc
== MEMCACHED_END
);
1482 for (x
= 0; x
< 4; x
++)
1484 rc
= memcached_set(memc
, keys
[x
], key_length
[x
],
1485 insert_data
, VALUE_SIZE_BUG5
,
1486 (time_t)0, (uint32_t)0);
1487 assert(rc
== MEMCACHED_SUCCESS
);
1490 for (x
= 0; x
< 2; x
++)
1492 value
= memcached_get(memc
, keys
[0], key_length
[0],
1493 &value_length
, &flags
, &rc
);
1497 rc
= memcached_mget(memc
, keys
, key_length
, 4);
1498 assert(rc
== MEMCACHED_SUCCESS
);
1500 /* We test for purge of partial complete fetches */
1501 for (count
= 3; count
; count
--)
1503 value
= memcached_fetch(memc
, return_key
, &return_key_length
,
1504 &value_length
, &flags
, &rc
);
1505 assert(rc
== MEMCACHED_SUCCESS
);
1506 assert(!(memcmp(value
, insert_data
, value_length
)));
1507 assert(value_length
);
1515 uint8_t user_supplied_bug8(memcached_st
*memc
)
1517 memcached_return rc
;
1519 memcached_st
*clone
;
1521 memcached_server_st
*servers
;
1522 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";
1524 servers
= memcached_servers_parse(server_list
);
1527 mine
= memcached_create(NULL
);
1528 rc
= memcached_server_push(mine
, servers
);
1529 assert(rc
== MEMCACHED_SUCCESS
);
1530 memcached_server_list_free(servers
);
1533 clone
= memcached_clone(NULL
, mine
);
1535 memcached_quit(mine
);
1536 memcached_quit(clone
);
1539 memcached_free(mine
);
1540 memcached_free(clone
);
1545 /* Test flag store/retrieve */
1546 uint8_t user_supplied_bug7(memcached_st
*memc
)
1548 memcached_return rc
;
1549 char *keys
= "036790384900";
1550 size_t key_length
= strlen("036790384900");
1551 char return_key
[MEMCACHED_MAX_KEY
];
1552 size_t return_key_length
;
1554 size_t value_length
;
1557 char insert_data
[VALUE_SIZE_BUG5
];
1559 for (x
= 0; x
< VALUE_SIZE_BUG5
; x
++)
1560 insert_data
[x
]= rand();
1562 memcached_flush(memc
, 0);
1565 rc
= memcached_set(memc
, keys
, key_length
,
1566 insert_data
, VALUE_SIZE_BUG5
,
1568 assert(rc
== MEMCACHED_SUCCESS
);
1571 value
= memcached_get(memc
, keys
, key_length
,
1572 &value_length
, &flags
, &rc
);
1573 assert(flags
== 245);
1577 rc
= memcached_mget(memc
, &keys
, &key_length
, 1);
1580 value
= memcached_fetch(memc
, return_key
, &return_key_length
,
1581 &value_length
, &flags
, &rc
);
1582 assert(flags
== 245);
1590 uint8_t user_supplied_bug9(memcached_st
*memc
)
1592 memcached_return rc
;
1593 char *keys
[]= {"UDATA:edevil@sapo.pt", "fudge&*@#", "for^#@&$not"};
1594 size_t key_length
[3];
1599 char return_key
[MEMCACHED_MAX_KEY
];
1600 size_t return_key_length
;
1602 size_t return_value_length
;
1605 key_length
[0]= strlen("UDATA:edevil@sapo.pt");
1606 key_length
[1]= strlen("fudge&*@#");
1607 key_length
[2]= strlen("for^#@&$not");
1610 for (x
= 0; x
< 3; x
++)
1612 rc
= memcached_set(memc
, keys
[x
], key_length
[x
],
1613 keys
[x
], key_length
[x
],
1614 (time_t)50, (uint32_t)9);
1615 assert(rc
== MEMCACHED_SUCCESS
);
1618 rc
= memcached_mget(memc
, keys
, key_length
, 3);
1619 assert(rc
== MEMCACHED_SUCCESS
);
1621 /* We need to empty the server before continueing test */
1622 while ((return_value
= memcached_fetch(memc
, return_key
, &return_key_length
,
1623 &return_value_length
, &flags
, &rc
)) != NULL
)
1625 assert(return_value
);
1634 /* We are testing with aggressive timeout to get failures */
1635 uint8_t user_supplied_bug10(memcached_st
*memc
)
1639 size_t value_length
= 512;
1642 memcached_return rc
;
1643 unsigned int set
= 1;
1644 memcached_st
*mclone
= memcached_clone(NULL
, memc
);
1647 memcached_behavior_set(mclone
, MEMCACHED_BEHAVIOR_NO_BLOCK
, set
);
1648 memcached_behavior_set(mclone
, MEMCACHED_BEHAVIOR_TCP_NODELAY
, set
);
1650 memcached_behavior_set(mclone
, MEMCACHED_BEHAVIOR_POLL_TIMEOUT
, timeout
);
1652 value
= (char*)malloc(value_length
* sizeof(char));
1654 for (x
= 0; x
< value_length
; x
++)
1655 value
[x
]= (char) (x
% 127);
1657 for (x
= 1; x
<= 100000; ++x
)
1659 rc
= memcached_set(mclone
, key
, key_len
,value
, value_length
, 0, 0);
1661 assert(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_WRITE_FAILURE
|| rc
== MEMCACHED_BUFFERED
);
1663 if (rc
== MEMCACHED_WRITE_FAILURE
)
1668 memcached_free(mclone
);
1674 We are looking failures in the async protocol
1676 uint8_t user_supplied_bug11(memcached_st
*memc
)
1680 size_t value_length
= 512;
1683 memcached_return rc
;
1684 unsigned int set
= 1;
1686 memcached_st
*mclone
= memcached_clone(NULL
, memc
);
1688 memcached_behavior_set(mclone
, MEMCACHED_BEHAVIOR_NO_BLOCK
, set
);
1689 memcached_behavior_set(mclone
, MEMCACHED_BEHAVIOR_TCP_NODELAY
, set
);
1691 memcached_behavior_set(mclone
, MEMCACHED_BEHAVIOR_POLL_TIMEOUT
, timeout
);
1693 timeout
= (int32_t)memcached_behavior_get(mclone
, MEMCACHED_BEHAVIOR_POLL_TIMEOUT
);
1695 assert(timeout
== -1);
1697 value
= (char*)malloc(value_length
* sizeof(char));
1699 for (x
= 0; x
< value_length
; x
++)
1700 value
[x
]= (char) (x
% 127);
1702 for (x
= 1; x
<= 100000; ++x
)
1704 rc
= memcached_set(mclone
, key
, key_len
,value
, value_length
, 0, 0);
1708 memcached_free(mclone
);
1714 Bug found where incr was not returning MEMCACHED_NOTFOUND when object did not exist.
1716 uint8_t user_supplied_bug12(memcached_st
*memc
)
1718 memcached_return rc
;
1720 size_t value_length
;
1722 uint64_t number_value
;
1724 value
= memcached_get(memc
, "autoincrement", strlen("autoincrement"),
1725 &value_length
, &flags
, &rc
);
1726 assert(value
== NULL
);
1727 assert(rc
== MEMCACHED_NOTFOUND
);
1729 rc
= memcached_increment(memc
, "autoincrement", strlen("autoincrement"),
1732 assert(value
== NULL
);
1733 assert(rc
== MEMCACHED_NOTFOUND
);
1735 rc
= memcached_set(memc
, "autoincrement", strlen("autoincrement"), "1", 1, 0, 0);
1737 value
= memcached_get(memc
, "autoincrement", strlen("autoincrement"),
1738 &value_length
, &flags
, &rc
);
1740 assert(rc
== MEMCACHED_SUCCESS
);
1743 rc
= memcached_increment(memc
, "autoincrement", strlen("autoincrement"),
1745 assert(number_value
== 2);
1746 assert(rc
== MEMCACHED_SUCCESS
);
1752 Bug found where command total one more than MEMCACHED_MAX_BUFFER
1753 set key34567890 0 0 8169 \r\n is sent followed by buffer of size 8169, followed by 8169
1755 uint8_t user_supplied_bug13(memcached_st
*memc
)
1757 char key
[] = "key34567890";
1759 memcached_return rc
;
1760 size_t overflowSize
;
1762 char commandFirst
[]= "set key34567890 0 0 ";
1763 char commandLast
[] = " \r\n"; /* first line of command sent to server */
1764 size_t commandLength
;
1767 commandLength
= strlen(commandFirst
) + strlen(commandLast
) + 4; /* 4 is number of characters in size, probably 8196 */
1769 overflowSize
= MEMCACHED_MAX_BUFFER
- commandLength
;
1771 for (testSize
= overflowSize
- 1; testSize
< overflowSize
+ 1; testSize
++)
1773 overflow
= malloc(testSize
);
1774 assert(overflow
!= NULL
);
1776 memset(overflow
, 'x', testSize
);
1777 rc
= memcached_set(memc
, key
, strlen(key
),
1778 overflow
, testSize
, 0, 0);
1779 assert(rc
== MEMCACHED_SUCCESS
);
1788 Test values of many different sizes
1789 Bug found where command total one more than MEMCACHED_MAX_BUFFER
1790 set key34567890 0 0 8169 \r\n
1791 is sent followed by buffer of size 8169, followed by 8169
1793 uint8_t user_supplied_bug14(memcached_st
*memc
)
1796 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_TCP_NODELAY
, setter
);
1797 memcached_return rc
;
1800 size_t value_length
= 18000;
1802 size_t string_length
;
1805 size_t current_length
;
1807 value
= (char*)malloc(value_length
);
1810 for (x
= 0; x
< value_length
; x
++)
1811 value
[x
] = (char) (x
% 127);
1813 for (current_length
= 0; current_length
< value_length
; current_length
++)
1815 rc
= memcached_set(memc
, key
, strlen(key
),
1816 value
, current_length
,
1817 (time_t)0, (uint32_t)0);
1818 assert(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
);
1820 string
= memcached_get(memc
, key
, strlen(key
),
1821 &string_length
, &flags
, &rc
);
1823 assert(rc
== MEMCACHED_SUCCESS
);
1825 assert(string_length
== current_length
);
1826 assert(!memcmp(string
, value
, string_length
));
1837 Look for zero length value problems
1839 uint8_t user_supplied_bug15(memcached_st
*memc
)
1842 memcached_return rc
;
1848 for (x
= 0; x
< 2; x
++)
1850 rc
= memcached_set(memc
, key
, strlen(key
),
1852 (time_t)0, (uint32_t)0);
1854 assert(rc
== MEMCACHED_SUCCESS
);
1856 value
= memcached_get(memc
, key
, strlen(key
),
1857 &length
, &flags
, &rc
);
1859 assert(rc
== MEMCACHED_SUCCESS
);
1860 assert(value
== NULL
);
1861 assert(length
== 0);
1864 value
= memcached_get(memc
, key
, strlen(key
),
1865 &length
, &flags
, &rc
);
1867 assert(rc
== MEMCACHED_SUCCESS
);
1868 assert(value
== NULL
);
1869 assert(length
== 0);
1876 uint8_t result_static(memcached_st
*memc
)
1878 memcached_result_st result
;
1879 memcached_result_st
*result_ptr
;
1881 result_ptr
= memcached_result_create(memc
, &result
);
1882 assert(result
.is_allocated
== MEMCACHED_NOT_ALLOCATED
);
1884 memcached_result_free(&result
);
1889 uint8_t result_alloc(memcached_st
*memc
)
1891 memcached_result_st
*result
;
1893 result
= memcached_result_create(memc
, NULL
);
1895 memcached_result_free(result
);
1900 uint8_t string_static_null(memcached_st
*memc
)
1902 memcached_string_st string
;
1903 memcached_string_st
*string_ptr
;
1905 string_ptr
= memcached_string_create(memc
, &string
, 0);
1906 assert(string
.is_allocated
== MEMCACHED_NOT_ALLOCATED
);
1908 memcached_string_free(&string
);
1913 uint8_t string_alloc_null(memcached_st
*memc
)
1915 memcached_string_st
*string
;
1917 string
= memcached_string_create(memc
, NULL
, 0);
1919 memcached_string_free(string
);
1924 uint8_t string_alloc_with_size(memcached_st
*memc
)
1926 memcached_string_st
*string
;
1928 string
= memcached_string_create(memc
, NULL
, 1024);
1930 memcached_string_free(string
);
1935 uint8_t string_alloc_with_size_toobig(memcached_st
*memc
)
1937 memcached_string_st
*string
;
1939 string
= memcached_string_create(memc
, NULL
, INT64_MAX
);
1940 assert(string
== NULL
);
1945 uint8_t string_alloc_append(memcached_st
*memc
)
1948 char buffer
[SMALL_STRING_LEN
];
1949 memcached_string_st
*string
;
1951 /* Ring the bell! */
1952 memset(buffer
, 6, SMALL_STRING_LEN
);
1954 string
= memcached_string_create(memc
, NULL
, 100);
1957 for (x
= 0; x
< 1024; x
++)
1959 memcached_return rc
;
1960 rc
= memcached_string_append(string
, buffer
, SMALL_STRING_LEN
);
1961 assert(rc
== MEMCACHED_SUCCESS
);
1963 memcached_string_free(string
);
1968 uint8_t string_alloc_append_toobig(memcached_st
*memc
)
1970 memcached_return rc
;
1972 char buffer
[SMALL_STRING_LEN
];
1973 memcached_string_st
*string
;
1975 /* Ring the bell! */
1976 memset(buffer
, 6, SMALL_STRING_LEN
);
1978 string
= memcached_string_create(memc
, NULL
, 100);
1981 for (x
= 0; x
< 1024; x
++)
1983 rc
= memcached_string_append(string
, buffer
, SMALL_STRING_LEN
);
1984 assert(rc
== MEMCACHED_SUCCESS
);
1986 rc
= memcached_string_append(string
, buffer
, INT64_MAX
);
1987 assert(rc
== MEMCACHED_MEMORY_ALLOCATION_FAILURE
);
1988 memcached_string_free(string
);
1993 uint8_t cleanup_pairs(memcached_st
*memc
)
1995 pairs_free(global_pairs
);
2000 uint8_t generate_pairs(memcached_st
*memc
)
2002 unsigned long long x
;
2003 global_pairs
= pairs_generate(GLOBAL_COUNT
, 400);
2004 global_count
= GLOBAL_COUNT
;
2006 for (x
= 0; x
< global_count
; x
++)
2008 global_keys
[x
]= global_pairs
[x
].key
;
2009 global_keys_length
[x
]= global_pairs
[x
].key_length
;
2015 uint8_t generate_large_pairs(memcached_st
*memc
)
2017 unsigned long long x
;
2018 global_pairs
= pairs_generate(GLOBAL2_COUNT
, MEMCACHED_MAX_BUFFER
+10);
2019 global_count
= GLOBAL2_COUNT
;
2021 for (x
= 0; x
< global_count
; x
++)
2023 global_keys
[x
]= global_pairs
[x
].key
;
2024 global_keys_length
[x
]= global_pairs
[x
].key_length
;
2030 uint8_t generate_data(memcached_st
*memc
)
2032 execute_set(memc
, global_pairs
, global_count
);
2037 uint8_t generate_buffer_data(memcached_st
*memc
)
2042 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_BUFFER_REQUESTS
, latch
);
2043 generate_data(memc
);
2048 uint8_t get_read(memcached_st
*memc
)
2051 memcached_return rc
;
2055 size_t return_value_length
;
2058 for (x
= 0; x
< global_count
; x
++)
2060 return_value
= memcached_get(memc
, global_keys
[x
], global_keys_length
[x
],
2061 &return_value_length
, &flags
, &rc
);
2063 assert(return_value);
2064 assert(rc == MEMCACHED_SUCCESS);
2066 if (rc
== MEMCACHED_SUCCESS
&& return_value
)
2074 uint8_t mget_read(memcached_st
*memc
)
2076 memcached_return rc
;
2078 rc
= memcached_mget(memc
, global_keys
, global_keys_length
, global_count
);
2079 assert(rc
== MEMCACHED_SUCCESS
);
2080 /* Turn this into a help function */
2082 char return_key
[MEMCACHED_MAX_KEY
];
2083 size_t return_key_length
;
2085 size_t return_value_length
;
2088 while ((return_value
= memcached_fetch(memc
, return_key
, &return_key_length
,
2089 &return_value_length
, &flags
, &rc
)))
2091 assert(return_value
);
2092 assert(rc
== MEMCACHED_SUCCESS
);
2100 uint8_t mget_read_result(memcached_st
*memc
)
2102 memcached_return rc
;
2104 rc
= memcached_mget(memc
, global_keys
, global_keys_length
, global_count
);
2105 assert(rc
== MEMCACHED_SUCCESS
);
2106 /* Turn this into a help function */
2108 memcached_result_st results_obj
;
2109 memcached_result_st
*results
;
2111 results
= memcached_result_create(memc
, &results_obj
);
2113 while ((results
= memcached_fetch_result(memc
, &results_obj
, &rc
)))
2116 assert(rc
== MEMCACHED_SUCCESS
);
2119 memcached_result_free(&results_obj
);
2125 uint8_t mget_read_function(memcached_st
*memc
)
2127 memcached_return rc
;
2128 unsigned int counter
;
2129 unsigned int (*callbacks
[1])(memcached_st
*, memcached_result_st
*, void *);
2131 rc
= memcached_mget(memc
, global_keys
, global_keys_length
, global_count
);
2132 assert(rc
== MEMCACHED_SUCCESS
);
2134 callbacks
[0]= &callback_counter
;
2136 rc
= memcached_fetch_execute(memc
, callbacks
, (void *)&counter
, 1);
2141 uint8_t delete_generate(memcached_st
*memc
)
2145 for (x
= 0; x
< global_count
; x
++)
2147 (void)memcached_delete(memc
, global_keys
[x
], global_keys_length
[x
], (time_t)0);
2153 uint8_t delete_buffer_generate(memcached_st
*memc
)
2159 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_BUFFER_REQUESTS
, latch
);
2161 for (x
= 0; x
< global_count
; x
++)
2163 (void)memcached_delete(memc
, global_keys
[x
], global_keys_length
[x
], (time_t)0);
2169 uint8_t free_data(memcached_st
*memc
)
2171 pairs_free(global_pairs
);
2176 uint8_t add_host_test1(memcached_st
*memc
)
2179 memcached_return rc
;
2180 char servername
[]= "0.example.com";
2181 memcached_server_st
*servers
;
2183 servers
= memcached_server_list_append(NULL
, servername
, 400, &rc
);
2185 assert(1 == memcached_server_list_count(servers
));
2187 for (x
= 2; x
< 20; x
++)
2189 char buffer
[SMALL_STRING_LEN
];
2191 snprintf(buffer
, SMALL_STRING_LEN
, "%u.example.com", 400+x
);
2192 servers
= memcached_server_list_append(servers
, buffer
, 401,
2194 assert(rc
== MEMCACHED_SUCCESS
);
2195 assert(x
== memcached_server_list_count(servers
));
2198 rc
= memcached_server_push(memc
, servers
);
2199 assert(rc
== MEMCACHED_SUCCESS
);
2200 rc
= memcached_server_push(memc
, servers
);
2201 assert(rc
== MEMCACHED_SUCCESS
);
2203 memcached_server_list_free(servers
);
2208 memcached_return
pre_nonblock(memcached_st
*memc
)
2210 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NO_BLOCK
, 0);
2212 return MEMCACHED_SUCCESS
;
2215 memcached_return
pre_murmur(memcached_st
*memc
)
2217 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_HASH
, (uint64_t)MEMCACHED_HASH_MURMUR
);
2219 return MEMCACHED_SUCCESS
;
2222 memcached_return
pre_md5(memcached_st
*memc
)
2224 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_HASH
, (uint64_t)MEMCACHED_HASH_MD5
);
2226 return MEMCACHED_SUCCESS
;
2229 memcached_return
pre_crc(memcached_st
*memc
)
2231 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_HASH
, (uint64_t)MEMCACHED_HASH_CRC
);
2233 return MEMCACHED_SUCCESS
;
2236 memcached_return
pre_hsieh(memcached_st
*memc
)
2238 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_HASH
, (uint64_t)MEMCACHED_HASH_HSIEH
);
2240 return MEMCACHED_SUCCESS
;
2243 memcached_return
pre_hash_fnv1_64(memcached_st
*memc
)
2245 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_HASH
, (uint64_t)MEMCACHED_HASH_FNV1_64
);
2247 return MEMCACHED_SUCCESS
;
2250 memcached_return
pre_hash_fnv1a_64(memcached_st
*memc
)
2252 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_HASH
, (uint64_t)MEMCACHED_HASH_FNV1A_64
);
2254 return MEMCACHED_SUCCESS
;
2257 memcached_return
pre_hash_fnv1_32(memcached_st
*memc
)
2259 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_HASH
, (uint64_t)MEMCACHED_HASH_FNV1_32
);
2261 return MEMCACHED_SUCCESS
;
2264 memcached_return
pre_hash_fnv1a_32(memcached_st
*memc
)
2266 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_HASH
, (uint64_t)MEMCACHED_HASH_FNV1A_32
);
2268 return MEMCACHED_SUCCESS
;
2271 memcached_return
pre_hash_ketama(memcached_st
*memc
)
2273 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_HASH
, (uint64_t)MEMCACHED_HASH_KETAMA
);
2275 return MEMCACHED_SUCCESS
;
2278 void my_free(memcached_st
*ptr
, void *mem
)
2283 void *my_malloc(memcached_st
*ptr
, const size_t size
)
2285 return malloc(size
);
2288 void *my_realloc(memcached_st
*ptr
, void *mem
, const size_t size
)
2290 return realloc(mem
, size
);
2293 memcached_return
set_memory_alloc(memcached_st
*memc
)
2296 memcached_malloc_function test_ptr
;
2297 memcached_return rc
;
2299 rc
= memcached_callback_set(memc
, MEMCACHED_CALLBACK_MALLOC_FUNCTION
, &my_malloc
);
2300 assert(rc
== MEMCACHED_SUCCESS
);
2301 test_ptr
= (memcached_malloc_function
)memcached_callback_get(memc
, MEMCACHED_CALLBACK_MALLOC_FUNCTION
, &rc
);
2302 assert(rc
== MEMCACHED_SUCCESS
);
2303 assert(test_ptr
== my_malloc
);
2307 memcached_realloc_function test_ptr
;
2308 memcached_return rc
;
2310 rc
= memcached_callback_set(memc
, MEMCACHED_CALLBACK_REALLOC_FUNCTION
, &my_realloc
);
2311 assert(rc
== MEMCACHED_SUCCESS
);
2312 test_ptr
= (memcached_realloc_function
)memcached_callback_get(memc
, MEMCACHED_CALLBACK_REALLOC_FUNCTION
, &rc
);
2313 assert(rc
== MEMCACHED_SUCCESS
);
2314 assert(test_ptr
== my_realloc
);
2318 memcached_free_function test_ptr
;
2319 memcached_return rc
;
2321 rc
= memcached_callback_set(memc
, MEMCACHED_CALLBACK_FREE_FUNCTION
, my_free
);
2322 assert(rc
== MEMCACHED_SUCCESS
);
2323 test_ptr
= (memcached_free_function
)memcached_callback_get(memc
, MEMCACHED_CALLBACK_FREE_FUNCTION
, &rc
);
2324 assert(rc
== MEMCACHED_SUCCESS
);
2325 assert(test_ptr
== my_free
);
2328 return MEMCACHED_SUCCESS
;
2331 memcached_return
enable_consistent(memcached_st
*memc
)
2333 memcached_server_distribution value
= MEMCACHED_DISTRIBUTION_CONSISTENT
;
2334 memcached_hash hash
;
2335 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_DISTRIBUTION
, value
);
2338 value
= (memcached_server_distribution
)memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_DISTRIBUTION
);
2339 assert(value
== MEMCACHED_DISTRIBUTION_CONSISTENT
);
2341 hash
= (memcached_hash
)memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_HASH
);
2342 assert(hash
== MEMCACHED_HASH_HSIEH
);
2345 return MEMCACHED_SUCCESS
;
2348 memcached_return
enable_cas(memcached_st
*memc
)
2350 unsigned int set
= 1;
2352 memcached_version(memc
);
2354 if (memc
->hosts
[0].major_version
>= 1 &&
2355 memc
->hosts
[0].minor_version
>= 2 &&
2356 memc
->hosts
[0].micro_version
>= 4)
2358 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_SUPPORT_CAS
, set
);
2360 return MEMCACHED_SUCCESS
;
2363 return MEMCACHED_FAILURE
;
2366 memcached_return
check_for_1_2_3(memcached_st
*memc
)
2368 memcached_version(memc
);
2370 if (memc
->hosts
[0].major_version
>= 1 &&
2371 memc
->hosts
[0].minor_version
>= 2 &&
2372 memc
->hosts
[0].micro_version
>= 4)
2373 return MEMCACHED_SUCCESS
;
2375 return MEMCACHED_FAILURE
;
2378 memcached_return
pre_unix_socket(memcached_st
*memc
)
2380 memcached_return rc
;
2383 memcached_server_list_free(memc
->hosts
);
2385 memc
->number_of_hosts
= 0;
2387 if (stat("/tmp/memcached.socket", &buf
))
2388 return MEMCACHED_FAILURE
;
2390 rc
= memcached_server_add_unix_socket(memc
, "/tmp/memcached.socket");
2395 memcached_return
pre_udp(memcached_st
*memc
)
2397 memcached_return rc
;
2399 memcached_server_list_free(memc
->hosts
);
2401 memc
->number_of_hosts
= 0;
2404 return MEMCACHED_FAILURE
;
2406 rc
= memcached_server_add_udp(memc
, "localhost", MEMCACHED_DEFAULT_PORT
);
2411 memcached_return
pre_nodelay(memcached_st
*memc
)
2413 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NO_BLOCK
, 0);
2414 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_TCP_NODELAY
, 0);
2416 return MEMCACHED_SUCCESS
;
2419 memcached_return
poll_timeout(memcached_st
*memc
)
2425 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_POLL_TIMEOUT
, timeout
);
2427 timeout
= (int32_t)memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_POLL_TIMEOUT
);
2429 assert(timeout
== 100);
2431 return MEMCACHED_SUCCESS
;
2435 /* Clean the server before beginning testing */
2437 {"flush", 0, flush_test
},
2438 {"init", 0, init_test
},
2439 {"allocation", 0, allocation_test
},
2440 {"server_list_null_test", 0, server_list_null_test
},
2441 {"server_sort", 0, server_sort_test
},
2442 {"clone_test", 0, clone_test
},
2443 {"error", 0, error_test
},
2444 {"set", 0, set_test
},
2445 {"set2", 0, set_test2
},
2446 {"set3", 0, set_test3
},
2447 {"add", 1, add_test
},
2448 {"replace", 1, replace_test
},
2449 {"delete", 1, delete_test
},
2450 {"get", 1, get_test
},
2451 {"get2", 0, get_test2
},
2452 {"get3", 0, get_test3
},
2453 {"get4", 0, get_test4
},
2454 {"stats_servername", 0, stats_servername_test
},
2455 {"increment", 0, increment_test
},
2456 {"decrement", 0, decrement_test
},
2457 {"quit", 0, quit_test
},
2458 {"mget", 1, mget_test
},
2459 {"mget_result", 1, mget_result_test
},
2460 {"mget_result_alloc", 1, mget_result_alloc_test
},
2461 {"mget_result_function", 1, mget_result_function
},
2462 {"get_stats", 0, get_stats
},
2463 {"add_host_test", 0, add_host_test
},
2464 {"get_stats_keys", 0, get_stats_keys
},
2465 {"behavior_test", 0, get_stats_keys
},
2466 {"callback_test", 0, get_stats_keys
},
2467 {"version_string_test", 0, version_string_test
},
2468 {"bad_key", 1, bad_key_test
},
2469 {"memcached_server_cursor", 1, memcached_server_cursor_test
},
2473 test_st async_tests
[] ={
2474 {"add", 1, add_wrapper
},
2478 test_st string_tests
[] ={
2479 {"string static with null", 0, string_static_null
},
2480 {"string alloc with null", 0, string_alloc_null
},
2481 {"string alloc with 1K", 0, string_alloc_with_size
},
2482 {"string alloc with malloc failure", 0, string_alloc_with_size_toobig
},
2483 {"string append", 0, string_alloc_append
},
2484 {"string append failure (too big)", 0, string_alloc_append_toobig
},
2488 test_st result_tests
[] ={
2489 {"result static", 0, result_static
},
2490 {"result alloc", 0, result_alloc
},
2494 test_st version_1_2_3
[] ={
2495 {"append", 0, append_test
},
2496 {"prepend", 0, prepend_test
},
2497 {"cas", 0, cas_test
},
2498 {"cas2", 0, cas2_test
},
2499 {"append_binary", 0, append_binary_test
},
2503 test_st user_tests
[] ={
2504 {"user_supplied_bug1", 0, user_supplied_bug1
},
2505 {"user_supplied_bug2", 0, user_supplied_bug2
},
2506 {"user_supplied_bug3", 0, user_supplied_bug3
},
2507 {"user_supplied_bug4", 0, user_supplied_bug4
},
2508 {"user_supplied_bug5", 1, user_supplied_bug5
},
2509 {"user_supplied_bug6", 1, user_supplied_bug6
},
2510 {"user_supplied_bug7", 1, user_supplied_bug7
},
2511 {"user_supplied_bug8", 1, user_supplied_bug8
},
2512 {"user_supplied_bug9", 1, user_supplied_bug9
},
2513 {"user_supplied_bug10", 1, user_supplied_bug10
},
2514 {"user_supplied_bug11", 1, user_supplied_bug11
},
2515 {"user_supplied_bug12", 1, user_supplied_bug12
},
2516 {"user_supplied_bug13", 1, user_supplied_bug13
},
2517 {"user_supplied_bug14", 1, user_supplied_bug14
},
2518 {"user_supplied_bug15", 1, user_supplied_bug15
},
2522 test_st generate_tests
[] ={
2523 {"generate_pairs", 1, generate_pairs
},
2524 {"generate_data", 1, generate_data
},
2525 {"get_read", 0, get_read
},
2526 {"delete_generate", 0, delete_generate
},
2527 {"generate_buffer_data", 1, generate_buffer_data
},
2528 {"delete_buffer", 0, delete_buffer_generate
},
2529 {"generate_data", 1, generate_data
},
2530 {"mget_read", 0, mget_read
},
2531 {"mget_read_result", 0, mget_read_result
},
2532 {"mget_read_function", 0, mget_read_function
},
2533 {"cleanup", 1, cleanup_pairs
},
2534 {"generate_large_pairs", 1, generate_large_pairs
},
2535 {"generate_data", 1, generate_data
},
2536 {"generate_buffer_data", 1, generate_buffer_data
},
2537 {"cleanup", 1, cleanup_pairs
},
2542 collection_st collection
[] ={
2543 {"block", 0, 0, tests
},
2544 {"nonblock", pre_nonblock
, 0, tests
},
2545 {"nodelay", pre_nodelay
, 0, tests
},
2546 {"md5", pre_md5
, 0, tests
},
2547 {"crc", pre_crc
, 0, tests
},
2548 {"hsieh", pre_hsieh
, 0, tests
},
2549 {"fnv1_64", pre_hash_fnv1_64
, 0, tests
},
2550 {"fnv1a_64", pre_hash_fnv1a_64
, 0, tests
},
2551 {"fnv1_32", pre_hash_fnv1_32
, 0, tests
},
2552 {"fnv1a_32", pre_hash_fnv1a_32
, 0, tests
},
2553 {"ketama", pre_hash_ketama
, 0, tests
},
2554 {"unix_socket", pre_unix_socket
, 0, tests
},
2555 {"unix_socket_nodelay", pre_nodelay
, 0, tests
},
2556 {"poll_timeout", poll_timeout
, 0, tests
},
2557 {"gets", enable_cas
, 0, tests
},
2558 {"consistent", enable_consistent
, 0, tests
},
2559 {"memory_allocators", set_memory_alloc
, 0, tests
},
2560 // {"udp", pre_udp, 0, tests},
2561 {"version_1_2_3", check_for_1_2_3
, 0, version_1_2_3
},
2562 {"string", 0, 0, string_tests
},
2563 {"result", 0, 0, result_tests
},
2564 {"async", pre_nonblock
, 0, async_tests
},
2565 {"user", 0, 0, user_tests
},
2566 {"generate", 0, 0, generate_tests
},
2567 {"generate_hsieh", pre_hsieh
, 0, generate_tests
},
2568 {"generate_hsieh_consistent", enable_consistent
, 0, generate_tests
},
2569 {"generate_md5", pre_md5
, 0, generate_tests
},
2570 {"generate_murmur", pre_murmur
, 0, generate_tests
},
2571 {"generate_nonblock", pre_nonblock
, 0, generate_tests
},
2575 #define SERVERS_TO_CREATE 5
2577 void *world_create(void)
2579 server_startup_st
*construct
;
2581 construct
= (server_startup_st
*)malloc(sizeof(server_startup_st
));
2582 memset(construct
, 0, sizeof(server_startup_st
));
2583 construct
->count
= SERVERS_TO_CREATE
;
2585 server_startup(construct
);
2590 void world_destroy(void *p
)
2592 server_startup_st
*construct
= (server_startup_st
*)p
;
2593 memcached_server_st
*servers
= (memcached_server_st
*)construct
->servers
;
2594 memcached_server_list_free(servers
);
2596 server_shutdown(construct
);
2600 void get_world(world_st
*world
)
2602 world
->collections
= collection
;
2603 world
->create
= world_create
;
2604 world
->destroy
= world_destroy
;