2 Sample test application.
10 #include <sys/types.h>
15 #include "../lib/common.h"
16 #include "../src/generator.h"
17 #include "../src/execute.h"
20 #define INT64_MAX LONG_MAX
23 #define INT32_MAX INT_MAX
29 #define GLOBAL_COUNT 100000
30 #define GLOBAL2_COUNT 1000
31 static uint32_t global_count
;
33 static pairs_st
*global_pairs
;
34 static char *global_keys
[GLOBAL_COUNT
];
35 static size_t global_keys_length
[GLOBAL_COUNT
];
37 uint8_t init_test(memcached_st
*not_used
)
41 (void)memcached_create(&memc
);
42 memcached_free(&memc
);
47 uint8_t server_list_null_test(memcached_st
*ptr
)
49 memcached_server_st
*server_list
;
52 server_list
= memcached_server_list_append(NULL
, NULL
, 0, NULL
);
53 assert(server_list
== NULL
);
55 server_list
= memcached_server_list_append(NULL
, "localhost", 0, NULL
);
56 assert(server_list
== NULL
);
58 server_list
= memcached_server_list_append(NULL
, NULL
, 0, &rc
);
59 assert(server_list
== NULL
);
64 uint8_t server_sort_test(memcached_st
*ptr
)
67 memcached_server_st
*server_list
;
71 memcached_behavior_set(ptr
, MEMCACHED_BEHAVIOR_SORT_HOSTS
, &setting
);
73 server_list
= memcached_server_list_append(NULL
, "arg", 0, &rc
);
76 server_list
= memcached_server_list_append(server_list
, "localhost", 0, &rc
);
79 server_list
= memcached_server_list_append(server_list
, "c", 0, &rc
);
82 server_list
= memcached_server_list_append(server_list
, "abba", 0, &rc
);
90 uint8_t allocation_test(memcached_st
*not_used
)
93 memc
= memcached_create(NULL
);
100 uint8_t clone_test(memcached_st
*memc
)
105 clone
= memcached_clone(NULL
, NULL
);
107 memcached_free(clone
);
110 /* Can we init from null? */
113 clone
= memcached_clone(NULL
, memc
);
115 memcached_free(clone
);
118 /* Can we init from struct? */
120 memcached_st declared_clone
;
122 clone
= memcached_clone(&declared_clone
, NULL
);
124 memcached_free(clone
);
127 /* Can we init from struct? */
129 memcached_st declared_clone
;
131 clone
= memcached_clone(&declared_clone
, memc
);
133 memcached_free(clone
);
139 uint8_t connection_test(memcached_st
*memc
)
143 rc
= memcached_server_add(memc
, "localhost", 0);
144 assert(rc
== MEMCACHED_SUCCESS
);
149 uint8_t error_test(memcached_st
*memc
)
153 for (rc
= MEMCACHED_SUCCESS
; rc
< MEMCACHED_MAXIMUM_RETURN
; rc
++)
155 printf("Error %d -> %s\n", rc
, memcached_strerror(memc
, rc
));
161 uint8_t set_test(memcached_st
*memc
)
165 char *value
= "when we sanitize";
167 rc
= memcached_set(memc
, key
, strlen(key
),
168 value
, strlen(value
),
169 (time_t)0, (uint32_t)0);
170 assert(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
);
175 uint8_t append_test(memcached_st
*memc
)
183 rc
= memcached_flush(memc
, 0);
184 assert(rc
== MEMCACHED_SUCCESS
);
186 rc
= memcached_set(memc
, key
, strlen(key
),
187 value
, strlen(value
),
188 (time_t)0, (uint32_t)0);
189 assert(rc
== MEMCACHED_SUCCESS
);
191 rc
= memcached_append(memc
, key
, strlen(key
),
192 " the", strlen(" the"),
193 (time_t)0, (uint32_t)0);
194 assert(rc
== MEMCACHED_SUCCESS
);
196 rc
= memcached_append(memc
, key
, strlen(key
),
197 " people", strlen(" people"),
198 (time_t)0, (uint32_t)0);
199 assert(rc
== MEMCACHED_SUCCESS
);
201 value
= memcached_get(memc
, key
, strlen(key
),
202 &value_length
, &flags
, &rc
);
203 assert(!memcmp(value
, "we the people", strlen("we the people")));
204 assert(strlen("we the people") == value_length
);
205 assert(rc
== MEMCACHED_SUCCESS
);
211 uint8_t append_binary_test(memcached_st
*memc
)
214 char *key
= "numbers";
215 unsigned int *store_ptr
;
216 unsigned int store_list
[] = { 23, 56, 499, 98, 32847, 0 };
222 rc
= memcached_flush(memc
, 0);
223 assert(rc
== MEMCACHED_SUCCESS
);
225 rc
= memcached_set(memc
,
228 (time_t)0, (uint32_t)0);
229 assert(rc
== MEMCACHED_SUCCESS
);
231 for (x
= 0; store_list
[x
] ; x
++)
233 rc
= memcached_append(memc
,
235 (char *)&store_list
[x
], sizeof(unsigned int),
236 (time_t)0, (uint32_t)0);
237 assert(rc
== MEMCACHED_SUCCESS
);
240 value
= memcached_get(memc
, key
, strlen(key
),
241 &value_length
, &flags
, &rc
);
242 assert((value_length
== (sizeof(unsigned int) * x
)));
243 assert(rc
== MEMCACHED_SUCCESS
);
245 store_ptr
= (unsigned int *)value
;
247 while ((size_t)store_ptr
< (size_t)(value
+ value_length
))
249 assert(*store_ptr
== store_list
[x
++]);
257 uint8_t cas2_test(memcached_st
*memc
)
260 char *keys
[]= {"fudge", "son", "food"};
261 size_t key_length
[]= {5, 3, 4};
262 char *value
= "we the people";
263 size_t value_length
= strlen("we the people");
265 memcached_result_st results_obj
;
266 memcached_result_st
*results
;
269 rc
= memcached_flush(memc
, 0);
270 assert(rc
== MEMCACHED_SUCCESS
);
272 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_SUPPORT_CAS
, &set
);
274 for (x
= 0; x
< 3; x
++)
276 rc
= memcached_set(memc
, keys
[x
], key_length
[x
],
277 keys
[x
], key_length
[x
],
278 (time_t)50, (uint32_t)9);
279 assert(rc
== MEMCACHED_SUCCESS
);
282 rc
= memcached_mget(memc
, keys
, key_length
, 3);
284 results
= memcached_result_create(memc
, &results_obj
);
286 results
= memcached_fetch_result(memc
, &results_obj
, &rc
);
288 assert(results
->cas
);
289 assert(rc
== MEMCACHED_SUCCESS
);
290 WATCHPOINT_ASSERT(memcached_result_cas(results
));
292 assert(!memcmp(value
, "we the people", strlen("we the people")));
293 assert(strlen("we the people") == value_length
);
294 assert(rc
== MEMCACHED_SUCCESS
);
296 memcached_result_free(&results_obj
);
301 uint8_t cas_test(memcached_st
*memc
)
305 size_t key_length
= strlen("fun");
306 char *value
= "we the people";
307 size_t value_length
= strlen("we the people");
308 memcached_result_st results_obj
;
309 memcached_result_st
*results
;
312 rc
= memcached_flush(memc
, 0);
313 assert(rc
== MEMCACHED_SUCCESS
);
315 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_SUPPORT_CAS
, &set
);
317 rc
= memcached_set(memc
, key
, strlen(key
),
318 value
, strlen(value
),
319 (time_t)0, (uint32_t)0);
320 assert(rc
== MEMCACHED_SUCCESS
);
322 rc
= memcached_mget(memc
, &key
, &key_length
, 1);
324 results
= memcached_result_create(memc
, &results_obj
);
326 results
= memcached_fetch_result(memc
, &results_obj
, &rc
);
328 assert(rc
== MEMCACHED_SUCCESS
);
329 WATCHPOINT_ASSERT(memcached_result_cas(results
));
331 assert(!memcmp(value
, "we the people", strlen("we the people")));
332 assert(strlen("we the people") == value_length
);
333 assert(rc
== MEMCACHED_SUCCESS
);
335 rc
= memcached_cas(memc
, key
, key_length
,
336 "change the value", strlen("change the value"),
337 0, 0, memcached_result_cas(results
));
339 assert(rc
== MEMCACHED_SUCCESS
);
341 rc
= memcached_cas(memc
, key
, key_length
,
342 "change the value", strlen("change the value"),
345 assert(rc
== MEMCACHED_DATA_EXISTS
);
348 memcached_result_free(&results_obj
);
353 uint8_t prepend_test(memcached_st
*memc
)
357 char *value
= "people";
361 rc
= memcached_flush(memc
, 0);
362 assert(rc
== MEMCACHED_SUCCESS
);
364 rc
= memcached_set(memc
, key
, strlen(key
),
365 value
, strlen(value
),
366 (time_t)0, (uint32_t)0);
367 assert(rc
== MEMCACHED_SUCCESS
);
369 rc
= memcached_prepend(memc
, key
, strlen(key
),
370 "the ", strlen("the "),
371 (time_t)0, (uint32_t)0);
372 assert(rc
== MEMCACHED_SUCCESS
);
374 rc
= memcached_prepend(memc
, key
, strlen(key
),
375 "we ", strlen("we "),
376 (time_t)0, (uint32_t)0);
377 assert(rc
== MEMCACHED_SUCCESS
);
379 value
= memcached_get(memc
, key
, strlen(key
),
380 &value_length
, &flags
, &rc
);
381 assert(!memcmp(value
, "we the people", strlen("we the people")));
382 assert(strlen("we the people") == value_length
);
383 assert(rc
== MEMCACHED_SUCCESS
);
390 Set the value, then quit to make sure it is flushed.
391 Come back in and test that add fails.
393 uint8_t add_test(memcached_st
*memc
)
397 char *value
= "when we sanitize";
398 unsigned long long setting_value
;
400 setting_value
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_NO_BLOCK
);
402 rc
= memcached_set(memc
, key
, strlen(key
),
403 value
, strlen(value
),
404 (time_t)0, (uint32_t)0);
405 assert(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
);
406 memcached_quit(memc
);
407 rc
= memcached_add(memc
, key
, strlen(key
),
408 value
, strlen(value
),
409 (time_t)0, (uint32_t)0);
411 /* Too many broken OS'es have broken loopback in async, so we can't be sure of the result */
413 assert(rc
== MEMCACHED_NOTSTORED
|| MEMCACHED_STORED
);
415 assert(rc
== MEMCACHED_NOTSTORED
);
420 uint8_t add_wrapper(memcached_st
*memc
)
424 for (x
= 0; x
< 10000; x
++)
430 uint8_t replace_test(memcached_st
*memc
)
434 char *value
= "when we sanitize";
435 char *original
= "first we insert some data";
437 rc
= memcached_set(memc
, key
, strlen(key
),
438 original
, strlen(original
),
439 (time_t)0, (uint32_t)0);
440 assert(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
);
442 rc
= memcached_replace(memc
, key
, strlen(key
),
443 value
, strlen(value
),
444 (time_t)0, (uint32_t)0);
445 assert(rc
== MEMCACHED_SUCCESS
);
450 uint8_t delete_test(memcached_st
*memc
)
454 char *value
= "when we sanitize";
456 rc
= memcached_set(memc
, key
, strlen(key
),
457 value
, strlen(value
),
458 (time_t)0, (uint32_t)0);
459 assert(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
);
461 rc
= memcached_delete(memc
, key
, strlen(key
), (time_t)0);
462 assert(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
);
467 uint8_t flush_test(memcached_st
*memc
)
471 rc
= memcached_flush(memc
, 0);
472 assert(rc
== MEMCACHED_SUCCESS
);
477 uint8_t bad_key_test(memcached_st
*memc
)
480 char *key
= "foo bad";
482 size_t string_length
;
487 clone
= memcached_clone(NULL
, memc
);
490 (void)memcached_behavior_set(clone
, MEMCACHED_BEHAVIOR_VERIFY_KEY
, &set
);
492 string
= memcached_get(clone
, key
, strlen(key
),
493 &string_length
, &flags
, &rc
);
494 assert(rc
== MEMCACHED_BAD_KEY_PROVIDED
);
495 assert(string_length
== 0);
499 (void)memcached_behavior_set(clone
, MEMCACHED_BEHAVIOR_VERIFY_KEY
, &set
);
500 string
= memcached_get(clone
, key
, strlen(key
),
501 &string_length
, &flags
, &rc
);
502 assert(rc
== MEMCACHED_NOTFOUND
);
503 assert(string_length
== 0);
506 memcached_free(clone
);
511 uint8_t get_test(memcached_st
*memc
)
516 size_t string_length
;
519 rc
= memcached_delete(memc
, key
, strlen(key
), (time_t)0);
520 assert(rc
== MEMCACHED_BUFFERED
|| rc
== MEMCACHED_NOTFOUND
);
522 string
= memcached_get(memc
, key
, strlen(key
),
523 &string_length
, &flags
, &rc
);
525 assert(rc
== MEMCACHED_NOTFOUND
);
526 assert(string_length
== 0);
532 uint8_t get_test2(memcached_st
*memc
)
536 char *value
= "when we sanitize";
538 size_t string_length
;
541 rc
= memcached_set(memc
, key
, strlen(key
),
542 value
, strlen(value
),
543 (time_t)0, (uint32_t)0);
544 assert(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
);
546 string
= memcached_get(memc
, key
, strlen(key
),
547 &string_length
, &flags
, &rc
);
550 assert(rc
== MEMCACHED_SUCCESS
);
551 assert(string_length
== strlen(value
));
552 assert(!memcmp(string
, value
, string_length
));
559 uint8_t set_test2(memcached_st
*memc
)
563 char *value
= "train in the brain";
564 size_t value_length
= strlen(value
);
567 for (x
= 0; x
< 10; x
++)
569 rc
= memcached_set(memc
, key
, strlen(key
),
571 (time_t)0, (uint32_t)0);
572 WATCHPOINT_ERROR(rc
);
573 assert(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
);
579 uint8_t set_test3(memcached_st
*memc
)
584 size_t value_length
= 8191;
587 value
= (char*)malloc(value_length
);
590 for (x
= 0; x
< value_length
; x
++)
591 value
[x
] = (char) (x
% 127);
593 for (x
= 0; x
< 1; x
++)
595 rc
= memcached_set(memc
, key
, strlen(key
),
597 (time_t)0, (uint32_t)0);
598 assert(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
);
606 uint8_t get_test3(memcached_st
*memc
)
611 size_t value_length
= 8191;
613 size_t string_length
;
617 value
= (char*)malloc(value_length
);
620 for (x
= 0; x
< value_length
; x
++)
621 value
[x
] = (char) (x
% 127);
623 rc
= memcached_set(memc
, key
, strlen(key
),
625 (time_t)0, (uint32_t)0);
626 assert(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
);
628 string
= memcached_get(memc
, key
, strlen(key
),
629 &string_length
, &flags
, &rc
);
631 assert(rc
== MEMCACHED_SUCCESS
);
633 assert(string_length
== value_length
);
634 assert(!memcmp(string
, value
, string_length
));
642 uint8_t get_test4(memcached_st
*memc
)
647 size_t value_length
= 8191;
649 size_t string_length
;
653 value
= (char*)malloc(value_length
);
656 for (x
= 0; x
< value_length
; x
++)
657 value
[x
] = (char) (x
% 127);
659 rc
= memcached_set(memc
, key
, strlen(key
),
661 (time_t)0, (uint32_t)0);
662 assert(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
);
664 for (x
= 0; x
< 10; x
++)
666 string
= memcached_get(memc
, key
, strlen(key
),
667 &string_length
, &flags
, &rc
);
669 assert(rc
== MEMCACHED_SUCCESS
);
671 assert(string_length
== value_length
);
672 assert(!memcmp(string
, value
, string_length
));
681 /* Do not copy the style of this code, I just access hosts to testthis function */
682 uint8_t stats_servername_test(memcached_st
*memc
)
685 memcached_stat_st stat
;
686 rc
= memcached_stat_servername(&stat
, NULL
,
687 memc
->hosts
[0].hostname
,
688 memc
->hosts
[0].port
);
693 uint8_t increment_test(memcached_st
*memc
)
700 rc
= memcached_set(memc
, key
, strlen(key
),
701 value
, strlen(value
),
702 (time_t)0, (uint32_t)0);
703 assert(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
);
705 rc
= memcached_increment(memc
, key
, strlen(key
),
707 assert(rc
== MEMCACHED_SUCCESS
);
708 assert(new_number
== 1);
710 rc
= memcached_increment(memc
, key
, strlen(key
),
712 assert(rc
== MEMCACHED_SUCCESS
);
713 assert(new_number
== 2);
718 uint8_t decrement_test(memcached_st
*memc
)
725 rc
= memcached_set(memc
, key
, strlen(key
),
726 value
, strlen(value
),
727 (time_t)0, (uint32_t)0);
728 assert(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
);
730 rc
= memcached_decrement(memc
, key
, strlen(key
),
732 assert(rc
== MEMCACHED_SUCCESS
);
733 assert(new_number
== 2);
735 rc
= memcached_decrement(memc
, key
, strlen(key
),
737 assert(rc
== MEMCACHED_SUCCESS
);
738 assert(new_number
== 1);
743 uint8_t quit_test(memcached_st
*memc
)
747 char *value
= "sanford and sun";
749 rc
= memcached_set(memc
, key
, strlen(key
),
750 value
, strlen(value
),
751 (time_t)10, (uint32_t)3);
752 assert(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
);
753 memcached_quit(memc
);
755 rc
= memcached_set(memc
, key
, strlen(key
),
756 value
, strlen(value
),
757 (time_t)50, (uint32_t)9);
758 assert(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
);
763 uint8_t mget_result_test(memcached_st
*memc
)
766 char *keys
[]= {"fudge", "son", "food"};
767 size_t key_length
[]= {5, 3, 4};
770 memcached_result_st results_obj
;
771 memcached_result_st
*results
;
773 results
= memcached_result_create(memc
, &results_obj
);
775 assert(&results_obj
== results
);
777 /* We need to empty the server before continueing test */
778 rc
= memcached_flush(memc
, 0);
779 assert(rc
== MEMCACHED_SUCCESS
);
781 rc
= memcached_mget(memc
, keys
, key_length
, 3);
782 assert(rc
== MEMCACHED_SUCCESS
);
784 while ((results
= memcached_fetch_result(memc
, &results_obj
, &rc
)) != NULL
)
789 while ((results
= memcached_fetch_result(memc
, &results_obj
, &rc
)) != NULL
)
791 assert(rc
== MEMCACHED_END
);
793 for (x
= 0; x
< 3; x
++)
795 rc
= memcached_set(memc
, keys
[x
], key_length
[x
],
796 keys
[x
], key_length
[x
],
797 (time_t)50, (uint32_t)9);
798 assert(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
);
801 rc
= memcached_mget(memc
, keys
, key_length
, 3);
802 assert(rc
== MEMCACHED_SUCCESS
);
804 while ((results
= memcached_fetch_result(memc
, &results_obj
, &rc
)))
807 assert(&results_obj
== results
);
808 assert(rc
== MEMCACHED_SUCCESS
);
809 assert(memcached_result_key_length(results
) == memcached_result_length(results
));
810 assert(!memcmp(memcached_result_key_value(results
),
811 memcached_result_value(results
),
812 memcached_result_length(results
)));
815 memcached_result_free(&results_obj
);
820 uint8_t mget_result_alloc_test(memcached_st
*memc
)
823 char *keys
[]= {"fudge", "son", "food"};
824 size_t key_length
[]= {5, 3, 4};
827 memcached_result_st
*results
;
829 /* We need to empty the server before continueing test */
830 rc
= memcached_flush(memc
, 0);
831 assert(rc
== MEMCACHED_SUCCESS
);
833 rc
= memcached_mget(memc
, keys
, key_length
, 3);
834 assert(rc
== MEMCACHED_SUCCESS
);
836 while ((results
= memcached_fetch_result(memc
, NULL
, &rc
)) != NULL
)
841 assert(rc
== MEMCACHED_END
);
843 for (x
= 0; x
< 3; x
++)
845 rc
= memcached_set(memc
, keys
[x
], key_length
[x
],
846 keys
[x
], key_length
[x
],
847 (time_t)50, (uint32_t)9);
848 assert(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
);
851 rc
= memcached_mget(memc
, keys
, key_length
, 3);
852 assert(rc
== MEMCACHED_SUCCESS
);
855 while ((results
= memcached_fetch_result(memc
, NULL
, &rc
)))
858 assert(rc
== MEMCACHED_SUCCESS
);
859 assert(memcached_result_key_length(results
) == memcached_result_length(results
));
860 assert(!memcmp(memcached_result_key_value(results
),
861 memcached_result_value(results
),
862 memcached_result_length(results
)));
863 memcached_result_free(results
);
870 /* Count the results */
871 unsigned int callback_counter(memcached_st
*ptr
, memcached_result_st
*result
, void *context
)
873 unsigned int *counter
= (unsigned int *)context
;
875 *counter
= *counter
+ 1;
880 uint8_t mget_result_function(memcached_st
*memc
)
883 char *keys
[]= {"fudge", "son", "food"};
884 size_t key_length
[]= {5, 3, 4};
886 unsigned int counter
;
887 unsigned int (*callbacks
[1])(memcached_st
*, memcached_result_st
*, void *);
889 /* We need to empty the server before continueing test */
890 rc
= memcached_flush(memc
, 0);
891 for (x
= 0; x
< 3; x
++)
893 rc
= memcached_set(memc
, keys
[x
], key_length
[x
],
894 keys
[x
], key_length
[x
],
895 (time_t)50, (uint32_t)9);
896 assert(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
);
899 rc
= memcached_mget(memc
, keys
, key_length
, 3);
900 assert(rc
== MEMCACHED_SUCCESS
);
902 callbacks
[0]= &callback_counter
;
904 rc
= memcached_fetch_execute(memc
, callbacks
, (void *)&counter
, 1);
906 assert(counter
== 3);
911 uint8_t mget_test(memcached_st
*memc
)
914 char *keys
[]= {"fudge", "son", "food"};
915 size_t key_length
[]= {5, 3, 4};
919 char return_key
[MEMCACHED_MAX_KEY
];
920 size_t return_key_length
;
922 size_t return_value_length
;
924 /* We need to empty the server before continueing test */
925 rc
= memcached_flush(memc
, 0);
926 assert(rc
== MEMCACHED_SUCCESS
);
928 rc
= memcached_mget(memc
, keys
, key_length
, 3);
929 assert(rc
== MEMCACHED_SUCCESS
);
931 while ((return_value
= memcached_fetch(memc
, return_key
, &return_key_length
,
932 &return_value_length
, &flags
, &rc
)) != NULL
)
934 assert(return_value
);
936 assert(!return_value
);
937 assert(return_value_length
== 0);
938 assert(rc
== MEMCACHED_END
);
940 for (x
= 0; x
< 3; x
++)
942 rc
= memcached_set(memc
, keys
[x
], key_length
[x
],
943 keys
[x
], key_length
[x
],
944 (time_t)50, (uint32_t)9);
945 assert(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
);
948 rc
= memcached_mget(memc
, keys
, key_length
, 3);
949 assert(rc
== MEMCACHED_SUCCESS
);
952 while ((return_value
= memcached_fetch(memc
, return_key
, &return_key_length
,
953 &return_value_length
, &flags
, &rc
)))
955 assert(return_value
);
956 assert(rc
== MEMCACHED_SUCCESS
);
957 assert(return_key_length
== return_value_length
);
958 assert(!memcmp(return_value
, return_key
, return_value_length
));
966 uint8_t get_stats_keys(memcached_st
*memc
)
970 memcached_stat_st stat
;
973 list
= memcached_stat_get_keys(memc
, &stat
, &rc
);
974 assert(rc
== MEMCACHED_SUCCESS
);
975 for (ptr
= list
; *ptr
; ptr
++)
984 uint8_t version_string_test(memcached_st
*memc
)
986 const char *version_string
;
988 version_string
= memcached_lib_version();
990 assert(!strcmp(version_string
, LIBMEMCACHED_VERSION_STRING
));
995 uint8_t get_stats(memcached_st
*memc
)
1000 memcached_return rc
;
1001 memcached_stat_st
*stat
;
1003 stat
= memcached_stat(memc
, NULL
, &rc
);
1004 assert(rc
== MEMCACHED_SUCCESS
);
1006 assert(rc
== MEMCACHED_SUCCESS
);
1009 for (x
= 0; x
< memcached_server_count(memc
); x
++)
1011 list
= memcached_stat_get_keys(memc
, stat
+x
, &rc
);
1012 assert(rc
== MEMCACHED_SUCCESS
);
1013 for (ptr
= list
; *ptr
; ptr
++);
1018 memcached_stat_free(NULL
, stat
);
1023 uint8_t add_host_test(memcached_st
*memc
)
1026 memcached_server_st
*servers
;
1027 memcached_return rc
;
1028 char servername
[]= "0.example.com";
1030 servers
= memcached_server_list_append(NULL
, servername
, 400, &rc
);
1032 assert(1 == memcached_server_list_count(servers
));
1034 for (x
= 2; x
< 20; x
++)
1036 char buffer
[SMALL_STRING_LEN
];
1038 snprintf(buffer
, SMALL_STRING_LEN
, "%u.example.com", 400+x
);
1039 servers
= memcached_server_list_append(servers
, buffer
, 401,
1041 assert(rc
== MEMCACHED_SUCCESS
);
1042 assert(x
== memcached_server_list_count(servers
));
1045 rc
= memcached_server_push(memc
, servers
);
1046 assert(rc
== MEMCACHED_SUCCESS
);
1047 rc
= memcached_server_push(memc
, servers
);
1048 assert(rc
== MEMCACHED_SUCCESS
);
1050 memcached_server_list_free(servers
);
1055 memcached_return
clone_test_callback(memcached_st
*parent
, memcached_st
*clone
)
1057 return MEMCACHED_SUCCESS
;
1060 memcached_return
cleanup_test_callback(memcached_st
*ptr
)
1062 return MEMCACHED_SUCCESS
;
1065 uint8_t callback_test(memcached_st
*memc
)
1067 /* Test User Data */
1071 memcached_return rc
;
1073 rc
= memcached_callback_set(memc
, MEMCACHED_CALLBACK_USER_DATA
, &x
);
1074 assert(rc
== MEMCACHED_SUCCESS
);
1075 test_ptr
= (int *)memcached_callback_get(memc
, MEMCACHED_CALLBACK_USER_DATA
, &rc
);
1076 assert(*test_ptr
== x
);
1079 /* Test Clone Callback */
1081 memcached_clone_func temp_function
;
1082 memcached_return rc
;
1084 rc
= memcached_callback_set(memc
, MEMCACHED_CALLBACK_CLONE_FUNCTION
, clone_test_callback
);
1085 assert(rc
== MEMCACHED_SUCCESS
);
1086 temp_function
= (memcached_clone_func
)memcached_callback_get(memc
, MEMCACHED_CALLBACK_CLONE_FUNCTION
, &rc
);
1087 assert(temp_function
== clone_test_callback
);
1090 /* Test Cleanup Callback */
1092 memcached_cleanup_func temp_function
;
1093 memcached_return rc
;
1095 rc
= memcached_callback_set(memc
, MEMCACHED_CALLBACK_CLONE_FUNCTION
, cleanup_test_callback
);
1096 assert(rc
== MEMCACHED_SUCCESS
);
1097 temp_function
= (memcached_cleanup_func
)memcached_callback_get(memc
, MEMCACHED_CALLBACK_CLONE_FUNCTION
, &rc
);
1098 assert(temp_function
== cleanup_test_callback
);
1104 /* We don't test the behavior itself, we test the switches */
1105 uint8_t behavior_test(memcached_st
*memc
)
1107 unsigned long long value
;
1108 unsigned int set
= 1;
1110 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NO_BLOCK
, &set
);
1111 value
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_NO_BLOCK
);
1114 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_TCP_NODELAY
, &set
);
1115 value
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_TCP_NODELAY
);
1118 set
= MEMCACHED_HASH_MD5
;
1119 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_HASH
, &set
);
1120 value
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_HASH
);
1121 assert(value
== MEMCACHED_HASH_MD5
);
1125 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NO_BLOCK
, &set
);
1126 value
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_NO_BLOCK
);
1129 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_TCP_NODELAY
, &set
);
1130 value
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_TCP_NODELAY
);
1133 set
= MEMCACHED_HASH_DEFAULT
;
1134 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_HASH
, &set
);
1135 value
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_HASH
);
1136 assert(value
== MEMCACHED_HASH_DEFAULT
);
1138 set
= MEMCACHED_HASH_CRC
;
1139 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_HASH
, &set
);
1140 value
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_HASH
);
1141 assert(value
== MEMCACHED_HASH_CRC
);
1143 value
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_SOCKET_SEND_SIZE
);
1146 value
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_SOCKET_RECV_SIZE
);
1152 /* Test case provided by Cal Haldenbrand */
1153 uint8_t user_supplied_bug1(memcached_st
*memc
)
1155 unsigned int setter
= 1;
1158 unsigned long long total
= 0;
1161 char randomstuff
[6 * 1024];
1162 memcached_return rc
;
1164 memset(randomstuff
, 0, 6 * 1024);
1166 /* We just keep looking at the same values over and over */
1169 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NO_BLOCK
, &setter
);
1170 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_TCP_NODELAY
, &setter
);
1174 for (x
= 0 ; total
< 20 * 1024576 ; x
++ )
1178 size
= (rand() % ( 5 * 1024 ) ) + 400;
1179 memset(randomstuff
, 0, 6 * 1024);
1180 assert(size
< 6 * 1024); /* Being safe here */
1182 for (j
= 0 ; j
< size
;j
++)
1183 randomstuff
[j
] = (char) (rand() % 26) + 97;
1186 sprintf(key
, "%d", x
);
1187 rc
= memcached_set(memc
, key
, strlen(key
),
1188 randomstuff
, strlen(randomstuff
), 10, 0);
1189 /* If we fail, lets try again */
1190 if (rc
!= MEMCACHED_SUCCESS
&& rc
!= MEMCACHED_BUFFERED
)
1191 rc
= memcached_set(memc
, key
, strlen(key
),
1192 randomstuff
, strlen(randomstuff
), 10, 0);
1193 assert(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
);
1199 /* Test case provided by Cal Haldenbrand */
1200 uint8_t user_supplied_bug2(memcached_st
*memc
)
1203 unsigned int setter
;
1205 unsigned long long total
;
1208 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NO_BLOCK
, &setter
);
1209 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_TCP_NODELAY
, &setter
);
1211 setter
= 20 * 1024576;
1212 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_SOCKET_SEND_SIZE
, &setter
);
1213 setter
= 20 * 1024576;
1214 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_SOCKET_RECV_SIZE
, &setter
);
1215 getter
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_SOCKET_SEND_SIZE
);
1216 getter
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_SOCKET_RECV_SIZE
);
1218 for (x
= 0, errors
= 0, total
= 0 ; total
< 20 * 1024576 ; x
++)
1221 for (x
= 0, errors
= 0, total
= 0 ; total
< 24576 ; x
++)
1223 memcached_return rc
= MEMCACHED_SUCCESS
;
1224 char buffer
[SMALL_STRING_LEN
];
1229 memset(buffer
, 0, SMALL_STRING_LEN
);
1231 snprintf(buffer
, SMALL_STRING_LEN
, "%u", x
);
1232 getval
= memcached_get(memc
, buffer
, strlen(buffer
),
1233 &val_len
, &flags
, &rc
);
1234 if (rc
!= MEMCACHED_SUCCESS
)
1236 if (rc
== MEMCACHED_NOTFOUND
)
1240 WATCHPOINT_ERROR(rc
);
1254 /* Do a large mget() over all the keys we think exist */
1255 #define KEY_COUNT 3000 // * 1024576
1256 uint8_t user_supplied_bug3(memcached_st
*memc
)
1258 memcached_return rc
;
1259 unsigned int setter
;
1262 size_t key_lengths
[KEY_COUNT
];
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
);
1276 keys
= (char **)malloc(sizeof(char *) * KEY_COUNT
);
1278 memset(keys
, 0, (sizeof(char *) * KEY_COUNT
));
1279 for (x
= 0; x
< KEY_COUNT
; x
++)
1283 snprintf(buffer
, 30, "%u", x
);
1284 keys
[x
]= strdup(buffer
);
1285 key_lengths
[x
]= strlen(keys
[x
]);
1288 rc
= memcached_mget(memc
, keys
, key_lengths
, KEY_COUNT
);
1289 assert(rc
== MEMCACHED_SUCCESS
);
1291 /* Turn this into a help function */
1293 char return_key
[MEMCACHED_MAX_KEY
];
1294 size_t return_key_length
;
1296 size_t return_value_length
;
1299 while ((return_value
= memcached_fetch(memc
, return_key
, &return_key_length
,
1300 &return_value_length
, &flags
, &rc
)))
1302 assert(return_value
);
1303 assert(rc
== MEMCACHED_SUCCESS
);
1308 for (x
= 0; x
< KEY_COUNT
; x
++)
1315 /* Make sure we behave properly if server list has no values */
1316 uint8_t user_supplied_bug4(memcached_st
*memc
)
1318 memcached_return rc
;
1319 char *keys
[]= {"fudge", "son", "food"};
1320 size_t key_length
[]= {5, 3, 4};
1323 char return_key
[MEMCACHED_MAX_KEY
];
1324 size_t return_key_length
;
1326 size_t return_value_length
;
1328 /* Here we free everything before running a bunch of mget tests */
1330 memcached_server_list_free(memc
->hosts
);
1332 memc
->number_of_hosts
= 0;
1336 /* We need to empty the server before continueing test */
1337 rc
= memcached_flush(memc
, 0);
1338 assert(rc
== MEMCACHED_NO_SERVERS
);
1340 rc
= memcached_mget(memc
, keys
, key_length
, 3);
1341 assert(rc
== MEMCACHED_NO_SERVERS
);
1343 while ((return_value
= memcached_fetch(memc
, return_key
, &return_key_length
,
1344 &return_value_length
, &flags
, &rc
)) != NULL
)
1346 assert(return_value
);
1348 assert(!return_value
);
1349 assert(return_value_length
== 0);
1350 assert(rc
== MEMCACHED_NO_SERVERS
);
1352 for (x
= 0; x
< 3; x
++)
1354 rc
= memcached_set(memc
, keys
[x
], key_length
[x
],
1355 keys
[x
], key_length
[x
],
1356 (time_t)50, (uint32_t)9);
1357 assert(rc
== MEMCACHED_NO_SERVERS
);
1360 rc
= memcached_mget(memc
, keys
, key_length
, 3);
1361 assert(rc
== MEMCACHED_NO_SERVERS
);
1364 while ((return_value
= memcached_fetch(memc
, return_key
, &return_key_length
,
1365 &return_value_length
, &flags
, &rc
)))
1367 assert(return_value
);
1368 assert(rc
== MEMCACHED_SUCCESS
);
1369 assert(return_key_length
== return_value_length
);
1370 assert(!memcmp(return_value
, return_key
, return_value_length
));
1378 #define VALUE_SIZE_BUG5 1048064
1379 uint8_t user_supplied_bug5(memcached_st
*memc
)
1381 memcached_return rc
;
1382 char *keys
[]= {"036790384900", "036790384902", "036790384904", "036790384906"};
1383 size_t key_length
[]= {strlen("036790384900"), strlen("036790384902"), strlen("036790384904"), strlen("036790384906")};
1384 char return_key
[MEMCACHED_MAX_KEY
];
1385 size_t return_key_length
;
1387 size_t value_length
;
1391 char insert_data
[VALUE_SIZE_BUG5
];
1393 for (x
= 0; x
< VALUE_SIZE_BUG5
; x
++)
1394 insert_data
[x
]= rand();
1396 memcached_flush(memc
, 0);
1397 value
= memcached_get(memc
, keys
[0], key_length
[0],
1398 &value_length
, &flags
, &rc
);
1399 assert(value
== NULL
);
1400 rc
= memcached_mget(memc
, keys
, key_length
, 4);
1403 while ((value
= memcached_fetch(memc
, return_key
, &return_key_length
,
1404 &value_length
, &flags
, &rc
)))
1408 for (x
= 0; x
< 4; x
++)
1410 rc
= memcached_set(memc
, keys
[x
], key_length
[x
],
1411 insert_data
, VALUE_SIZE_BUG5
,
1412 (time_t)0, (uint32_t)0);
1413 assert(rc
== MEMCACHED_SUCCESS
);
1416 for (x
= 0; x
< 10; x
++)
1418 value
= memcached_get(memc
, keys
[0], key_length
[0],
1419 &value_length
, &flags
, &rc
);
1423 rc
= memcached_mget(memc
, keys
, key_length
, 4);
1425 while ((value
= memcached_fetch(memc
, return_key
, &return_key_length
,
1426 &value_length
, &flags
, &rc
)))
1437 uint8_t user_supplied_bug6(memcached_st
*memc
)
1439 memcached_return rc
;
1440 char *keys
[]= {"036790384900", "036790384902", "036790384904", "036790384906"};
1441 size_t key_length
[]= {strlen("036790384900"), strlen("036790384902"), strlen("036790384904"), strlen("036790384906")};
1442 char return_key
[MEMCACHED_MAX_KEY
];
1443 size_t return_key_length
;
1445 size_t value_length
;
1449 char insert_data
[VALUE_SIZE_BUG5
];
1451 for (x
= 0; x
< VALUE_SIZE_BUG5
; x
++)
1452 insert_data
[x
]= rand();
1454 memcached_flush(memc
, 0);
1455 value
= memcached_get(memc
, keys
[0], key_length
[0],
1456 &value_length
, &flags
, &rc
);
1457 assert(value
== NULL
);
1458 assert(rc
== MEMCACHED_NOTFOUND
);
1459 rc
= memcached_mget(memc
, keys
, key_length
, 4);
1460 assert(rc
== MEMCACHED_SUCCESS
);
1463 while ((value
= memcached_fetch(memc
, return_key
, &return_key_length
,
1464 &value_length
, &flags
, &rc
)))
1467 assert(rc
== MEMCACHED_END
);
1469 for (x
= 0; x
< 4; x
++)
1471 rc
= memcached_set(memc
, keys
[x
], key_length
[x
],
1472 insert_data
, VALUE_SIZE_BUG5
,
1473 (time_t)0, (uint32_t)0);
1474 assert(rc
== MEMCACHED_SUCCESS
);
1477 for (x
= 0; x
< 2; x
++)
1479 value
= memcached_get(memc
, keys
[0], key_length
[0],
1480 &value_length
, &flags
, &rc
);
1484 rc
= memcached_mget(memc
, keys
, key_length
, 4);
1485 assert(rc
== MEMCACHED_SUCCESS
);
1487 /* We test for purge of partial complete fetches */
1488 for (count
= 3; count
; count
--)
1490 value
= memcached_fetch(memc
, return_key
, &return_key_length
,
1491 &value_length
, &flags
, &rc
);
1492 assert(rc
== MEMCACHED_SUCCESS
);
1493 assert(!(memcmp(value
, insert_data
, value_length
)));
1494 assert(value_length
);
1502 uint8_t user_supplied_bug8(memcached_st
*memc
)
1504 memcached_return rc
;
1506 memcached_st
*clone
;
1508 memcached_server_st
*servers
;
1509 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";
1511 servers
= memcached_servers_parse(server_list
);
1514 mine
= memcached_create(NULL
);
1515 rc
= memcached_server_push(mine
, servers
);
1516 assert(rc
== MEMCACHED_SUCCESS
);
1517 memcached_server_list_free(servers
);
1520 clone
= memcached_clone(NULL
, mine
);
1522 memcached_quit(mine
);
1523 memcached_quit(clone
);
1526 memcached_free(mine
);
1527 memcached_free(clone
);
1532 /* Test flag store/retrieve */
1533 uint8_t user_supplied_bug7(memcached_st
*memc
)
1535 memcached_return rc
;
1536 char *keys
= "036790384900";
1537 size_t key_length
= strlen("036790384900");
1538 char return_key
[MEMCACHED_MAX_KEY
];
1539 size_t return_key_length
;
1541 size_t value_length
;
1544 char insert_data
[VALUE_SIZE_BUG5
];
1546 for (x
= 0; x
< VALUE_SIZE_BUG5
; x
++)
1547 insert_data
[x
]= rand();
1549 memcached_flush(memc
, 0);
1552 rc
= memcached_set(memc
, keys
, key_length
,
1553 insert_data
, VALUE_SIZE_BUG5
,
1555 assert(rc
== MEMCACHED_SUCCESS
);
1558 value
= memcached_get(memc
, keys
, key_length
,
1559 &value_length
, &flags
, &rc
);
1560 assert(flags
== 245);
1564 rc
= memcached_mget(memc
, &keys
, &key_length
, 1);
1567 value
= memcached_fetch(memc
, return_key
, &return_key_length
,
1568 &value_length
, &flags
, &rc
);
1569 assert(flags
== 245);
1577 uint8_t user_supplied_bug9(memcached_st
*memc
)
1579 memcached_return rc
;
1580 char *keys
[]= {"UDATA:edevil@sapo.pt", "fudge&*@#", "for^#@&$not"};
1581 size_t key_length
[3];
1586 char return_key
[MEMCACHED_MAX_KEY
];
1587 size_t return_key_length
;
1589 size_t return_value_length
;
1592 key_length
[0]= strlen("UDATA:edevil@sapo.pt");
1593 key_length
[1]= strlen("fudge&*@#");
1594 key_length
[2]= strlen("for^#@&$not");
1597 for (x
= 0; x
< 3; x
++)
1599 rc
= memcached_set(memc
, keys
[x
], key_length
[x
],
1600 keys
[x
], key_length
[x
],
1601 (time_t)50, (uint32_t)9);
1602 assert(rc
== MEMCACHED_SUCCESS
);
1605 rc
= memcached_mget(memc
, keys
, key_length
, 3);
1606 assert(rc
== MEMCACHED_SUCCESS
);
1608 /* We need to empty the server before continueing test */
1609 while ((return_value
= memcached_fetch(memc
, return_key
, &return_key_length
,
1610 &return_value_length
, &flags
, &rc
)) != NULL
)
1612 assert(return_value
);
1621 /* We are testing with aggressive timeout to get failures */
1622 uint8_t user_supplied_bug10(memcached_st
*memc
)
1626 size_t value_length
= 512;
1629 memcached_return rc
;
1630 unsigned int set
= 1;
1631 memcached_st
*mclone
= memcached_clone(NULL
, memc
);
1634 memcached_behavior_set(mclone
, MEMCACHED_BEHAVIOR_NO_BLOCK
, &set
);
1635 memcached_behavior_set(mclone
, MEMCACHED_BEHAVIOR_TCP_NODELAY
, &set
);
1637 memcached_behavior_set(mclone
, MEMCACHED_BEHAVIOR_POLL_TIMEOUT
, &timeout
);
1639 value
= (char*)malloc(value_length
* sizeof(char));
1641 for (x
= 0; x
< value_length
; x
++)
1642 value
[x
]= (char) (x
% 127);
1644 for (x
= 1; x
<= 100000; ++x
)
1646 rc
= memcached_set(mclone
, key
, key_len
,value
, value_length
, 0, 0);
1648 assert(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_WRITE_FAILURE
|| rc
== MEMCACHED_BUFFERED
);
1650 if (rc
== MEMCACHED_WRITE_FAILURE
)
1655 memcached_free(mclone
);
1661 We are looking failures in the async protocol
1663 uint8_t user_supplied_bug11(memcached_st
*memc
)
1667 size_t value_length
= 512;
1670 memcached_return rc
;
1671 unsigned int set
= 1;
1673 memcached_st
*mclone
= memcached_clone(NULL
, memc
);
1675 memcached_behavior_set(mclone
, MEMCACHED_BEHAVIOR_NO_BLOCK
, &set
);
1676 memcached_behavior_set(mclone
, MEMCACHED_BEHAVIOR_TCP_NODELAY
, &set
);
1678 memcached_behavior_set(mclone
, MEMCACHED_BEHAVIOR_POLL_TIMEOUT
, &timeout
);
1680 timeout
= (int32_t)memcached_behavior_get(mclone
, MEMCACHED_BEHAVIOR_POLL_TIMEOUT
);
1682 assert(timeout
== -1);
1684 value
= (char*)malloc(value_length
* sizeof(char));
1686 for (x
= 0; x
< value_length
; x
++)
1687 value
[x
]= (char) (x
% 127);
1689 for (x
= 1; x
<= 100000; ++x
)
1691 rc
= memcached_set(mclone
, key
, key_len
,value
, value_length
, 0, 0);
1695 memcached_free(mclone
);
1701 Bug found where incr was not returning MEMCACHED_NOTFOUND when object did not exist.
1703 uint8_t user_supplied_bug12(memcached_st
*memc
)
1705 memcached_return rc
;
1707 size_t value_length
;
1709 uint64_t number_value
;
1711 value
= memcached_get(memc
, "autoincrement", strlen("autoincrement"),
1712 &value_length
, &flags
, &rc
);
1713 assert(value
== NULL
);
1714 assert(rc
== MEMCACHED_NOTFOUND
);
1716 rc
= memcached_increment(memc
, "autoincrement", strlen("autoincrement"),
1719 assert(value
== NULL
);
1720 assert(rc
== MEMCACHED_NOTFOUND
);
1722 rc
= memcached_set(memc
, "autoincrement", strlen("autoincrement"), "1", 1, 0, 0);
1724 value
= memcached_get(memc
, "autoincrement", strlen("autoincrement"),
1725 &value_length
, &flags
, &rc
);
1727 assert(rc
== MEMCACHED_SUCCESS
);
1730 rc
= memcached_increment(memc
, "autoincrement", strlen("autoincrement"),
1732 assert(number_value
== 2);
1733 assert(rc
== MEMCACHED_SUCCESS
);
1739 Bug found where command total one more than MEMCACHED_MAX_BUFFER
1740 set key34567890 0 0 8169 \r\n is sent followed by buffer of size 8169, followed by 8169
1742 uint8_t user_supplied_bug13(memcached_st
*memc
)
1744 char key
[] = "key34567890";
1746 memcached_return rc
;
1747 size_t overflowSize
;
1749 char commandFirst
[]= "set key34567890 0 0 ";
1750 char commandLast
[] = " \r\n"; /* first line of command sent to server */
1751 size_t commandLength
;
1754 commandLength
= strlen(commandFirst
) + strlen(commandLast
) + 4; /* 4 is number of characters in size, probably 8196 */
1756 overflowSize
= MEMCACHED_MAX_BUFFER
- commandLength
;
1758 for (testSize
= overflowSize
- 1; testSize
< overflowSize
+ 1; testSize
++)
1760 overflow
= malloc(testSize
);
1761 assert(overflow
!= NULL
);
1763 memset(overflow
, 'x', testSize
);
1764 rc
= memcached_set(memc
, key
, strlen(key
),
1765 overflow
, testSize
, 0, 0);
1766 assert(rc
== MEMCACHED_SUCCESS
);
1775 Test values of many different sizes
1776 Bug found where command total one more than MEMCACHED_MAX_BUFFER
1777 set key34567890 0 0 8169 \r\n
1778 is sent followed by buffer of size 8169, followed by 8169
1780 uint8_t user_supplied_bug14(memcached_st
*memc
)
1783 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_TCP_NODELAY
, &setter
);
1784 memcached_return rc
;
1787 size_t value_length
= 18000;
1789 size_t string_length
;
1792 size_t current_length
;
1794 value
= (char*)malloc(value_length
);
1797 for (x
= 0; x
< value_length
; x
++)
1798 value
[x
] = (char) (x
% 127);
1800 for (current_length
= 1; current_length
< value_length
; current_length
++)
1802 rc
= memcached_set(memc
, key
, strlen(key
),
1803 value
, current_length
,
1804 (time_t)0, (uint32_t)0);
1805 assert(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
);
1807 string
= memcached_get(memc
, key
, strlen(key
),
1808 &string_length
, &flags
, &rc
);
1810 assert(rc
== MEMCACHED_SUCCESS
);
1812 assert(string_length
== current_length
);
1813 assert(!memcmp(string
, value
, string_length
));
1823 uint8_t result_static(memcached_st
*memc
)
1825 memcached_result_st result
;
1826 memcached_result_st
*result_ptr
;
1828 result_ptr
= memcached_result_create(memc
, &result
);
1829 assert(result
.is_allocated
== MEMCACHED_NOT_ALLOCATED
);
1831 memcached_result_free(&result
);
1836 uint8_t result_alloc(memcached_st
*memc
)
1838 memcached_result_st
*result
;
1840 result
= memcached_result_create(memc
, NULL
);
1842 memcached_result_free(result
);
1847 uint8_t string_static_null(memcached_st
*memc
)
1849 memcached_string_st string
;
1850 memcached_string_st
*string_ptr
;
1852 string_ptr
= memcached_string_create(memc
, &string
, 0);
1853 assert(string
.is_allocated
== MEMCACHED_NOT_ALLOCATED
);
1855 memcached_string_free(&string
);
1860 uint8_t string_alloc_null(memcached_st
*memc
)
1862 memcached_string_st
*string
;
1864 string
= memcached_string_create(memc
, NULL
, 0);
1866 memcached_string_free(string
);
1871 uint8_t string_alloc_with_size(memcached_st
*memc
)
1873 memcached_string_st
*string
;
1875 string
= memcached_string_create(memc
, NULL
, 1024);
1877 memcached_string_free(string
);
1882 uint8_t string_alloc_with_size_toobig(memcached_st
*memc
)
1884 memcached_string_st
*string
;
1886 string
= memcached_string_create(memc
, NULL
, INT64_MAX
);
1887 assert(string
== NULL
);
1892 uint8_t string_alloc_append(memcached_st
*memc
)
1895 char buffer
[SMALL_STRING_LEN
];
1896 memcached_string_st
*string
;
1898 /* Ring the bell! */
1899 memset(buffer
, 6, SMALL_STRING_LEN
);
1901 string
= memcached_string_create(memc
, NULL
, 100);
1904 for (x
= 0; x
< 1024; x
++)
1906 memcached_return rc
;
1907 rc
= memcached_string_append(string
, buffer
, SMALL_STRING_LEN
);
1908 assert(rc
== MEMCACHED_SUCCESS
);
1910 memcached_string_free(string
);
1915 uint8_t string_alloc_append_toobig(memcached_st
*memc
)
1917 memcached_return rc
;
1919 char buffer
[SMALL_STRING_LEN
];
1920 memcached_string_st
*string
;
1922 /* Ring the bell! */
1923 memset(buffer
, 6, SMALL_STRING_LEN
);
1925 string
= memcached_string_create(memc
, NULL
, 100);
1928 for (x
= 0; x
< 1024; x
++)
1930 rc
= memcached_string_append(string
, buffer
, SMALL_STRING_LEN
);
1931 assert(rc
== MEMCACHED_SUCCESS
);
1933 rc
= memcached_string_append(string
, buffer
, INT64_MAX
);
1934 assert(rc
== MEMCACHED_MEMORY_ALLOCATION_FAILURE
);
1935 memcached_string_free(string
);
1940 uint8_t cleanup_pairs(memcached_st
*memc
)
1942 pairs_free(global_pairs
);
1947 uint8_t generate_pairs(memcached_st
*memc
)
1949 unsigned long long x
;
1950 global_pairs
= pairs_generate(GLOBAL_COUNT
, 400);
1951 global_count
= GLOBAL_COUNT
;
1953 for (x
= 0; x
< global_count
; x
++)
1955 global_keys
[x
]= global_pairs
[x
].key
;
1956 global_keys_length
[x
]= global_pairs
[x
].key_length
;
1962 uint8_t generate_large_pairs(memcached_st
*memc
)
1964 unsigned long long x
;
1965 global_pairs
= pairs_generate(GLOBAL2_COUNT
, MEMCACHED_MAX_BUFFER
+10);
1966 global_count
= GLOBAL2_COUNT
;
1968 for (x
= 0; x
< global_count
; x
++)
1970 global_keys
[x
]= global_pairs
[x
].key
;
1971 global_keys_length
[x
]= global_pairs
[x
].key_length
;
1977 uint8_t generate_data(memcached_st
*memc
)
1979 execute_set(memc
, global_pairs
, global_count
);
1984 uint8_t generate_buffer_data(memcached_st
*memc
)
1989 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_BUFFER_REQUESTS
, &latch
);
1990 generate_data(memc
);
1995 uint8_t get_read(memcached_st
*memc
)
1998 memcached_return rc
;
2002 size_t return_value_length
;
2005 for (x
= 0; x
< global_count
; x
++)
2007 return_value
= memcached_get(memc
, global_keys
[x
], global_keys_length
[x
],
2008 &return_value_length
, &flags
, &rc
);
2010 assert(return_value);
2011 assert(rc == MEMCACHED_SUCCESS);
2013 if (rc
== MEMCACHED_SUCCESS
&& return_value
)
2021 uint8_t mget_read(memcached_st
*memc
)
2023 memcached_return rc
;
2025 rc
= memcached_mget(memc
, global_keys
, global_keys_length
, global_count
);
2026 assert(rc
== MEMCACHED_SUCCESS
);
2027 /* Turn this into a help function */
2029 char return_key
[MEMCACHED_MAX_KEY
];
2030 size_t return_key_length
;
2032 size_t return_value_length
;
2035 while ((return_value
= memcached_fetch(memc
, return_key
, &return_key_length
,
2036 &return_value_length
, &flags
, &rc
)))
2038 assert(return_value
);
2039 assert(rc
== MEMCACHED_SUCCESS
);
2047 uint8_t mget_read_result(memcached_st
*memc
)
2049 memcached_return rc
;
2051 rc
= memcached_mget(memc
, global_keys
, global_keys_length
, global_count
);
2052 assert(rc
== MEMCACHED_SUCCESS
);
2053 /* Turn this into a help function */
2055 memcached_result_st results_obj
;
2056 memcached_result_st
*results
;
2058 results
= memcached_result_create(memc
, &results_obj
);
2060 while ((results
= memcached_fetch_result(memc
, &results_obj
, &rc
)))
2063 assert(rc
== MEMCACHED_SUCCESS
);
2066 memcached_result_free(&results_obj
);
2072 uint8_t mget_read_function(memcached_st
*memc
)
2074 memcached_return rc
;
2075 unsigned int counter
;
2076 unsigned int (*callbacks
[1])(memcached_st
*, memcached_result_st
*, void *);
2078 rc
= memcached_mget(memc
, global_keys
, global_keys_length
, global_count
);
2079 assert(rc
== MEMCACHED_SUCCESS
);
2081 callbacks
[0]= &callback_counter
;
2083 rc
= memcached_fetch_execute(memc
, callbacks
, (void *)&counter
, 1);
2088 uint8_t delete_generate(memcached_st
*memc
)
2092 for (x
= 0; x
< global_count
; x
++)
2094 (void)memcached_delete(memc
, global_keys
[x
], global_keys_length
[x
], (time_t)0);
2100 uint8_t delete_buffer_generate(memcached_st
*memc
)
2106 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_BUFFER_REQUESTS
, &latch
);
2108 for (x
= 0; x
< global_count
; x
++)
2110 (void)memcached_delete(memc
, global_keys
[x
], global_keys_length
[x
], (time_t)0);
2116 uint8_t free_data(memcached_st
*memc
)
2118 pairs_free(global_pairs
);
2123 uint8_t add_host_test1(memcached_st
*memc
)
2126 memcached_return rc
;
2127 char servername
[]= "0.example.com";
2128 memcached_server_st
*servers
;
2130 servers
= memcached_server_list_append(NULL
, servername
, 400, &rc
);
2132 assert(1 == memcached_server_list_count(servers
));
2134 for (x
= 2; x
< 20; x
++)
2136 char buffer
[SMALL_STRING_LEN
];
2138 snprintf(buffer
, SMALL_STRING_LEN
, "%u.example.com", 400+x
);
2139 servers
= memcached_server_list_append(servers
, buffer
, 401,
2141 assert(rc
== MEMCACHED_SUCCESS
);
2142 assert(x
== memcached_server_list_count(servers
));
2145 rc
= memcached_server_push(memc
, servers
);
2146 assert(rc
== MEMCACHED_SUCCESS
);
2147 rc
= memcached_server_push(memc
, servers
);
2148 assert(rc
== MEMCACHED_SUCCESS
);
2150 memcached_server_list_free(servers
);
2155 memcached_return
pre_nonblock(memcached_st
*memc
)
2157 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NO_BLOCK
, NULL
);
2159 return MEMCACHED_SUCCESS
;
2162 memcached_return
pre_md5(memcached_st
*memc
)
2164 memcached_hash value
= MEMCACHED_HASH_MD5
;
2165 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_HASH
, &value
);
2167 return MEMCACHED_SUCCESS
;
2170 memcached_return
pre_crc(memcached_st
*memc
)
2172 memcached_hash value
= MEMCACHED_HASH_CRC
;
2173 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_HASH
, &value
);
2175 return MEMCACHED_SUCCESS
;
2178 memcached_return
pre_hsieh(memcached_st
*memc
)
2180 memcached_hash value
= MEMCACHED_HASH_HSIEH
;
2181 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_HASH
, &value
);
2183 return MEMCACHED_SUCCESS
;
2186 memcached_return
pre_hash_fnv1_64(memcached_st
*memc
)
2188 memcached_hash value
= MEMCACHED_HASH_FNV1_64
;
2189 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_HASH
, &value
);
2191 return MEMCACHED_SUCCESS
;
2194 memcached_return
pre_hash_fnv1a_64(memcached_st
*memc
)
2196 memcached_hash value
= MEMCACHED_HASH_FNV1A_64
;
2197 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_HASH
, &value
);
2199 return MEMCACHED_SUCCESS
;
2202 memcached_return
pre_hash_fnv1_32(memcached_st
*memc
)
2204 memcached_hash value
= MEMCACHED_HASH_FNV1_32
;
2205 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_HASH
, &value
);
2207 return MEMCACHED_SUCCESS
;
2210 memcached_return
pre_hash_fnv1a_32(memcached_st
*memc
)
2212 memcached_hash value
= MEMCACHED_HASH_FNV1A_32
;
2213 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_HASH
, &value
);
2215 return MEMCACHED_SUCCESS
;
2218 memcached_return
pre_hash_ketama(memcached_st
*memc
)
2220 memcached_hash value
= MEMCACHED_HASH_KETAMA
;
2221 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_HASH
, &value
);
2223 return MEMCACHED_SUCCESS
;
2226 void my_free(memcached_st
*ptr
, void *mem
)
2231 void *my_malloc(memcached_st
*ptr
, const size_t size
)
2233 return malloc(size
);
2236 void *my_realloc(memcached_st
*ptr
, void *mem
, const size_t size
)
2238 return realloc(mem
, size
);
2241 memcached_return
set_memory_alloc(memcached_st
*memc
)
2244 memcached_malloc_function test_ptr
;
2245 memcached_return rc
;
2247 rc
= memcached_callback_set(memc
, MEMCACHED_CALLBACK_MALLOC_FUNCTION
, &my_malloc
);
2248 assert(rc
== MEMCACHED_SUCCESS
);
2249 test_ptr
= (memcached_malloc_function
)memcached_callback_get(memc
, MEMCACHED_CALLBACK_MALLOC_FUNCTION
, &rc
);
2250 assert(rc
== MEMCACHED_SUCCESS
);
2251 assert(test_ptr
== my_malloc
);
2255 memcached_realloc_function test_ptr
;
2256 memcached_return rc
;
2258 rc
= memcached_callback_set(memc
, MEMCACHED_CALLBACK_REALLOC_FUNCTION
, &my_realloc
);
2259 assert(rc
== MEMCACHED_SUCCESS
);
2260 test_ptr
= (memcached_realloc_function
)memcached_callback_get(memc
, MEMCACHED_CALLBACK_REALLOC_FUNCTION
, &rc
);
2261 assert(rc
== MEMCACHED_SUCCESS
);
2262 assert(test_ptr
== my_realloc
);
2266 memcached_free_function test_ptr
;
2267 memcached_return rc
;
2269 rc
= memcached_callback_set(memc
, MEMCACHED_CALLBACK_FREE_FUNCTION
, my_free
);
2270 assert(rc
== MEMCACHED_SUCCESS
);
2271 test_ptr
= (memcached_free_function
)memcached_callback_get(memc
, MEMCACHED_CALLBACK_FREE_FUNCTION
, &rc
);
2272 assert(rc
== MEMCACHED_SUCCESS
);
2273 assert(test_ptr
== my_free
);
2276 return MEMCACHED_SUCCESS
;
2279 memcached_return
enable_consistent(memcached_st
*memc
)
2281 memcached_server_distribution value
= MEMCACHED_DISTRIBUTION_CONSISTENT
;
2282 memcached_hash hash
;
2283 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_DISTRIBUTION
, &value
);
2286 value
= (memcached_server_distribution
)memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_DISTRIBUTION
);
2287 assert(value
== MEMCACHED_DISTRIBUTION_CONSISTENT
);
2289 hash
= (memcached_hash
)memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_HASH
);
2290 assert(hash
== MEMCACHED_HASH_HSIEH
);
2293 return MEMCACHED_SUCCESS
;
2296 memcached_return
enable_cas(memcached_st
*memc
)
2298 unsigned int set
= 1;
2300 memcached_version(memc
);
2302 if (memc
->hosts
[0].major_version
>= 1 &&
2303 memc
->hosts
[0].minor_version
>= 2 &&
2304 memc
->hosts
[0].micro_version
>= 4)
2306 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_SUPPORT_CAS
, &set
);
2308 return MEMCACHED_SUCCESS
;
2311 return MEMCACHED_FAILURE
;
2314 memcached_return
check_for_1_2_3(memcached_st
*memc
)
2316 memcached_version(memc
);
2318 if (memc
->hosts
[0].major_version
>= 1 &&
2319 memc
->hosts
[0].minor_version
>= 2 &&
2320 memc
->hosts
[0].micro_version
>= 4)
2321 return MEMCACHED_SUCCESS
;
2323 return MEMCACHED_FAILURE
;
2326 memcached_return
pre_unix_socket(memcached_st
*memc
)
2328 memcached_return rc
;
2331 memcached_server_list_free(memc
->hosts
);
2333 memc
->number_of_hosts
= 0;
2335 if (stat("/tmp/memcached.socket", &buf
))
2336 return MEMCACHED_FAILURE
;
2338 rc
= memcached_server_add_unix_socket(memc
, "/tmp/memcached.socket");
2343 memcached_return
pre_udp(memcached_st
*memc
)
2345 memcached_return rc
;
2347 memcached_server_list_free(memc
->hosts
);
2349 memc
->number_of_hosts
= 0;
2352 return MEMCACHED_FAILURE
;
2354 rc
= memcached_server_add_udp(memc
, "localhost", MEMCACHED_DEFAULT_PORT
);
2359 memcached_return
pre_nodelay(memcached_st
*memc
)
2361 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NO_BLOCK
, NULL
);
2362 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_TCP_NODELAY
, NULL
);
2364 return MEMCACHED_SUCCESS
;
2367 memcached_return
poll_timeout(memcached_st
*memc
)
2373 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_POLL_TIMEOUT
, &timeout
);
2375 timeout
= (int32_t)memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_POLL_TIMEOUT
);
2377 assert(timeout
== 100);
2379 return MEMCACHED_SUCCESS
;
2383 /* Clean the server before beginning testing */
2385 {"flush", 0, flush_test
},
2386 {"init", 0, init_test
},
2387 {"allocation", 0, allocation_test
},
2388 {"server_list_null_test", 0, server_list_null_test
},
2389 {"server_sort", 0, server_sort_test
},
2390 {"clone_test", 0, clone_test
},
2391 {"error", 0, error_test
},
2392 {"set", 0, set_test
},
2393 {"set2", 0, set_test2
},
2394 {"set3", 0, set_test3
},
2395 {"add", 1, add_test
},
2396 {"replace", 1, replace_test
},
2397 {"delete", 1, delete_test
},
2398 {"get", 1, get_test
},
2399 {"get2", 0, get_test2
},
2400 {"get3", 0, get_test3
},
2401 {"get4", 0, get_test4
},
2402 {"stats_servername", 0, stats_servername_test
},
2403 {"increment", 0, increment_test
},
2404 {"decrement", 0, decrement_test
},
2405 {"quit", 0, quit_test
},
2406 {"mget", 1, mget_test
},
2407 {"mget_result", 1, mget_result_test
},
2408 {"mget_result_alloc", 1, mget_result_alloc_test
},
2409 {"mget_result_function", 1, mget_result_function
},
2410 {"get_stats", 0, get_stats
},
2411 {"add_host_test", 0, add_host_test
},
2412 {"get_stats_keys", 0, get_stats_keys
},
2413 {"behavior_test", 0, get_stats_keys
},
2414 {"callback_test", 0, get_stats_keys
},
2415 {"version_string_test", 0, version_string_test
},
2416 {"bad_key", 1, bad_key_test
},
2420 test_st async_tests
[] ={
2421 {"add", 1, add_wrapper
},
2425 test_st string_tests
[] ={
2426 {"string static with null", 0, string_static_null
},
2427 {"string alloc with null", 0, string_alloc_null
},
2428 {"string alloc with 1K", 0, string_alloc_with_size
},
2429 {"string alloc with malloc failure", 0, string_alloc_with_size_toobig
},
2430 {"string append", 0, string_alloc_append
},
2431 {"string append failure (too big)", 0, string_alloc_append_toobig
},
2435 test_st result_tests
[] ={
2436 {"result static", 0, result_static
},
2437 {"result alloc", 0, result_alloc
},
2441 test_st version_1_2_3
[] ={
2442 {"append", 0, append_test
},
2443 {"prepend", 0, prepend_test
},
2444 {"cas", 0, cas_test
},
2445 {"cas2", 0, cas2_test
},
2446 {"append_binary", 0, append_binary_test
},
2450 test_st user_tests
[] ={
2451 {"user_supplied_bug1", 0, user_supplied_bug1
},
2452 {"user_supplied_bug2", 0, user_supplied_bug2
},
2453 {"user_supplied_bug3", 0, user_supplied_bug3
},
2454 {"user_supplied_bug4", 0, user_supplied_bug4
},
2455 {"user_supplied_bug5", 1, user_supplied_bug5
},
2456 {"user_supplied_bug6", 1, user_supplied_bug6
},
2457 {"user_supplied_bug7", 1, user_supplied_bug7
},
2458 {"user_supplied_bug8", 1, user_supplied_bug8
},
2459 {"user_supplied_bug9", 1, user_supplied_bug9
},
2460 {"user_supplied_bug10", 1, user_supplied_bug10
},
2461 {"user_supplied_bug11", 1, user_supplied_bug11
},
2462 {"user_supplied_bug12", 1, user_supplied_bug12
},
2463 {"user_supplied_bug13", 1, user_supplied_bug13
},
2464 {"user_supplied_bug14", 1, user_supplied_bug14
},
2468 test_st generate_tests
[] ={
2469 {"generate_pairs", 1, generate_pairs
},
2470 {"generate_data", 1, generate_data
},
2471 {"get_read", 0, get_read
},
2472 {"delete_generate", 0, delete_generate
},
2473 {"generate_buffer_data", 1, generate_buffer_data
},
2474 {"delete_buffer", 0, delete_buffer_generate
},
2475 {"generate_data", 1, generate_data
},
2476 {"mget_read", 0, mget_read
},
2477 {"mget_read_result", 0, mget_read_result
},
2478 {"mget_read_function", 0, mget_read_function
},
2479 {"cleanup", 1, cleanup_pairs
},
2480 {"generate_large_pairs", 1, generate_large_pairs
},
2481 {"generate_data", 1, generate_data
},
2482 {"generate_buffer_data", 1, generate_buffer_data
},
2483 {"cleanup", 1, cleanup_pairs
},
2488 collection_st collection
[] ={
2489 {"block", 0, 0, tests
},
2490 {"nonblock", pre_nonblock
, 0, tests
},
2491 {"nodelay", pre_nodelay
, 0, tests
},
2492 {"md5", pre_md5
, 0, tests
},
2493 {"crc", pre_crc
, 0, tests
},
2494 {"hsieh", pre_hsieh
, 0, tests
},
2495 {"fnv1_64", pre_hash_fnv1_64
, 0, tests
},
2496 {"fnv1a_64", pre_hash_fnv1a_64
, 0, tests
},
2497 {"fnv1_32", pre_hash_fnv1_32
, 0, tests
},
2498 {"fnv1a_32", pre_hash_fnv1a_32
, 0, tests
},
2499 {"ketama", pre_hash_ketama
, 0, tests
},
2500 {"unix_socket", pre_unix_socket
, 0, tests
},
2501 {"unix_socket_nodelay", pre_nodelay
, 0, tests
},
2502 {"poll_timeout", poll_timeout
, 0, tests
},
2503 {"gets", enable_cas
, 0, tests
},
2504 {"consistent", enable_consistent
, 0, tests
},
2505 {"memory_allocators", set_memory_alloc
, 0, tests
},
2506 // {"udp", pre_udp, 0, tests},
2507 {"version_1_2_3", check_for_1_2_3
, 0, version_1_2_3
},
2508 {"string", 0, 0, string_tests
},
2509 {"result", 0, 0, result_tests
},
2510 {"async", pre_nonblock
, 0, async_tests
},
2511 {"user", 0, 0, user_tests
},
2512 {"generate", 0, 0, generate_tests
},
2513 {"generate_hsieh", pre_hsieh
, 0, generate_tests
},
2514 {"generate_hsieh_consistent", enable_consistent
, 0, generate_tests
},
2515 {"generate_md5", pre_md5
, 0, generate_tests
},
2516 {"generate_nonblock", pre_nonblock
, 0, generate_tests
},
2520 #define SERVERS_TO_CREATE 5
2522 void *world_create(void)
2524 server_startup_st
*construct
;
2526 construct
= (server_startup_st
*)malloc(sizeof(server_startup_st
));
2527 memset(construct
, 0, sizeof(server_startup_st
));
2528 construct
->count
= SERVERS_TO_CREATE
;
2530 server_startup(construct
);
2535 void world_destroy(void *p
)
2537 server_startup_st
*construct
= (server_startup_st
*)p
;
2538 memcached_server_st
*servers
= (memcached_server_st
*)construct
->servers
;
2539 memcached_server_list_free(servers
);
2541 server_shutdown(construct
);
2545 void get_world(world_st
*world
)
2547 world
->collections
= collection
;
2548 world
->create
= world_create
;
2549 world
->destroy
= world_destroy
;