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 assert(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
);
578 uint8_t set_test3(memcached_st
*memc
)
583 size_t value_length
= 8191;
586 value
= (char*)malloc(value_length
);
589 for (x
= 0; x
< value_length
; x
++)
590 value
[x
] = (char) (x
% 127);
592 for (x
= 0; x
< 1; x
++)
594 rc
= memcached_set(memc
, key
, strlen(key
),
596 (time_t)0, (uint32_t)0);
597 assert(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
);
605 uint8_t get_test3(memcached_st
*memc
)
610 size_t value_length
= 8191;
612 size_t string_length
;
616 value
= (char*)malloc(value_length
);
619 for (x
= 0; x
< value_length
; x
++)
620 value
[x
] = (char) (x
% 127);
622 rc
= memcached_set(memc
, key
, strlen(key
),
624 (time_t)0, (uint32_t)0);
625 assert(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
);
627 string
= memcached_get(memc
, key
, strlen(key
),
628 &string_length
, &flags
, &rc
);
630 assert(rc
== MEMCACHED_SUCCESS
);
632 assert(string_length
== value_length
);
633 assert(!memcmp(string
, value
, string_length
));
641 uint8_t get_test4(memcached_st
*memc
)
646 size_t value_length
= 8191;
648 size_t string_length
;
652 value
= (char*)malloc(value_length
);
655 for (x
= 0; x
< value_length
; x
++)
656 value
[x
] = (char) (x
% 127);
658 rc
= memcached_set(memc
, key
, strlen(key
),
660 (time_t)0, (uint32_t)0);
661 assert(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
);
663 for (x
= 0; x
< 10; x
++)
665 string
= memcached_get(memc
, key
, strlen(key
),
666 &string_length
, &flags
, &rc
);
668 assert(rc
== MEMCACHED_SUCCESS
);
670 assert(string_length
== value_length
);
671 assert(!memcmp(string
, value
, string_length
));
680 /* Do not copy the style of this code, I just access hosts to testthis function */
681 uint8_t stats_servername_test(memcached_st
*memc
)
684 memcached_stat_st stat
;
685 rc
= memcached_stat_servername(&stat
, NULL
,
686 memc
->hosts
[0].hostname
,
687 memc
->hosts
[0].port
);
692 uint8_t increment_test(memcached_st
*memc
)
699 rc
= memcached_set(memc
, key
, strlen(key
),
700 value
, strlen(value
),
701 (time_t)0, (uint32_t)0);
702 assert(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
);
704 rc
= memcached_increment(memc
, key
, strlen(key
),
706 assert(rc
== MEMCACHED_SUCCESS
);
707 assert(new_number
== 1);
709 rc
= memcached_increment(memc
, key
, strlen(key
),
711 assert(rc
== MEMCACHED_SUCCESS
);
712 assert(new_number
== 2);
717 uint8_t decrement_test(memcached_st
*memc
)
724 rc
= memcached_set(memc
, key
, strlen(key
),
725 value
, strlen(value
),
726 (time_t)0, (uint32_t)0);
727 assert(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
);
729 rc
= memcached_decrement(memc
, key
, strlen(key
),
731 assert(rc
== MEMCACHED_SUCCESS
);
732 assert(new_number
== 2);
734 rc
= memcached_decrement(memc
, key
, strlen(key
),
736 assert(rc
== MEMCACHED_SUCCESS
);
737 assert(new_number
== 1);
742 uint8_t quit_test(memcached_st
*memc
)
746 char *value
= "sanford and sun";
748 rc
= memcached_set(memc
, key
, strlen(key
),
749 value
, strlen(value
),
750 (time_t)10, (uint32_t)3);
751 assert(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
);
752 memcached_quit(memc
);
754 rc
= memcached_set(memc
, key
, strlen(key
),
755 value
, strlen(value
),
756 (time_t)50, (uint32_t)9);
757 assert(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
);
762 uint8_t mget_result_test(memcached_st
*memc
)
765 char *keys
[]= {"fudge", "son", "food"};
766 size_t key_length
[]= {5, 3, 4};
769 memcached_result_st results_obj
;
770 memcached_result_st
*results
;
772 results
= memcached_result_create(memc
, &results_obj
);
774 assert(&results_obj
== results
);
776 /* We need to empty the server before continueing test */
777 rc
= memcached_flush(memc
, 0);
778 assert(rc
== MEMCACHED_SUCCESS
);
780 rc
= memcached_mget(memc
, keys
, key_length
, 3);
781 assert(rc
== MEMCACHED_SUCCESS
);
783 while ((results
= memcached_fetch_result(memc
, &results_obj
, &rc
)) != NULL
)
788 while ((results
= memcached_fetch_result(memc
, &results_obj
, &rc
)) != NULL
)
790 assert(rc
== MEMCACHED_END
);
792 for (x
= 0; x
< 3; x
++)
794 rc
= memcached_set(memc
, keys
[x
], key_length
[x
],
795 keys
[x
], key_length
[x
],
796 (time_t)50, (uint32_t)9);
797 assert(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
);
800 rc
= memcached_mget(memc
, keys
, key_length
, 3);
801 assert(rc
== MEMCACHED_SUCCESS
);
803 while ((results
= memcached_fetch_result(memc
, &results_obj
, &rc
)))
806 assert(&results_obj
== results
);
807 assert(rc
== MEMCACHED_SUCCESS
);
808 assert(memcached_result_key_length(results
) == memcached_result_length(results
));
809 assert(!memcmp(memcached_result_key_value(results
),
810 memcached_result_value(results
),
811 memcached_result_length(results
)));
814 memcached_result_free(&results_obj
);
819 uint8_t mget_result_alloc_test(memcached_st
*memc
)
822 char *keys
[]= {"fudge", "son", "food"};
823 size_t key_length
[]= {5, 3, 4};
826 memcached_result_st
*results
;
828 /* We need to empty the server before continueing test */
829 rc
= memcached_flush(memc
, 0);
830 assert(rc
== MEMCACHED_SUCCESS
);
832 rc
= memcached_mget(memc
, keys
, key_length
, 3);
833 assert(rc
== MEMCACHED_SUCCESS
);
835 while ((results
= memcached_fetch_result(memc
, NULL
, &rc
)) != NULL
)
840 assert(rc
== MEMCACHED_END
);
842 for (x
= 0; x
< 3; x
++)
844 rc
= memcached_set(memc
, keys
[x
], key_length
[x
],
845 keys
[x
], key_length
[x
],
846 (time_t)50, (uint32_t)9);
847 assert(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
);
850 rc
= memcached_mget(memc
, keys
, key_length
, 3);
851 assert(rc
== MEMCACHED_SUCCESS
);
854 while ((results
= memcached_fetch_result(memc
, NULL
, &rc
)))
857 assert(rc
== MEMCACHED_SUCCESS
);
858 assert(memcached_result_key_length(results
) == memcached_result_length(results
));
859 assert(!memcmp(memcached_result_key_value(results
),
860 memcached_result_value(results
),
861 memcached_result_length(results
)));
862 memcached_result_free(results
);
869 /* Count the results */
870 unsigned int callback_counter(memcached_st
*ptr
, memcached_result_st
*result
, void *context
)
872 unsigned int *counter
= (unsigned int *)context
;
874 *counter
= *counter
+ 1;
879 uint8_t mget_result_function(memcached_st
*memc
)
882 char *keys
[]= {"fudge", "son", "food"};
883 size_t key_length
[]= {5, 3, 4};
885 unsigned int counter
;
886 unsigned int (*callbacks
[1])(memcached_st
*, memcached_result_st
*, void *);
888 /* We need to empty the server before continueing test */
889 rc
= memcached_flush(memc
, 0);
890 for (x
= 0; x
< 3; x
++)
892 rc
= memcached_set(memc
, keys
[x
], key_length
[x
],
893 keys
[x
], key_length
[x
],
894 (time_t)50, (uint32_t)9);
895 assert(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
);
898 rc
= memcached_mget(memc
, keys
, key_length
, 3);
899 assert(rc
== MEMCACHED_SUCCESS
);
901 callbacks
[0]= &callback_counter
;
903 rc
= memcached_fetch_execute(memc
, callbacks
, (void *)&counter
, 1);
905 assert(counter
== 3);
910 uint8_t mget_test(memcached_st
*memc
)
913 char *keys
[]= {"fudge", "son", "food"};
914 size_t key_length
[]= {5, 3, 4};
918 char return_key
[MEMCACHED_MAX_KEY
];
919 size_t return_key_length
;
921 size_t return_value_length
;
923 /* We need to empty the server before continueing test */
924 rc
= memcached_flush(memc
, 0);
925 assert(rc
== MEMCACHED_SUCCESS
);
927 rc
= memcached_mget(memc
, keys
, key_length
, 3);
928 assert(rc
== MEMCACHED_SUCCESS
);
930 while ((return_value
= memcached_fetch(memc
, return_key
, &return_key_length
,
931 &return_value_length
, &flags
, &rc
)) != NULL
)
933 assert(return_value
);
935 assert(!return_value
);
936 assert(return_value_length
== 0);
937 assert(rc
== MEMCACHED_END
);
939 for (x
= 0; x
< 3; x
++)
941 rc
= memcached_set(memc
, keys
[x
], key_length
[x
],
942 keys
[x
], key_length
[x
],
943 (time_t)50, (uint32_t)9);
944 assert(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
);
947 rc
= memcached_mget(memc
, keys
, key_length
, 3);
948 assert(rc
== MEMCACHED_SUCCESS
);
951 while ((return_value
= memcached_fetch(memc
, return_key
, &return_key_length
,
952 &return_value_length
, &flags
, &rc
)))
954 assert(return_value
);
955 assert(rc
== MEMCACHED_SUCCESS
);
956 assert(return_key_length
== return_value_length
);
957 assert(!memcmp(return_value
, return_key
, return_value_length
));
965 uint8_t get_stats_keys(memcached_st
*memc
)
969 memcached_stat_st stat
;
972 list
= memcached_stat_get_keys(memc
, &stat
, &rc
);
973 assert(rc
== MEMCACHED_SUCCESS
);
974 for (ptr
= list
; *ptr
; ptr
++)
983 uint8_t version_string_test(memcached_st
*memc
)
985 const char *version_string
;
987 version_string
= memcached_lib_version();
989 assert(!strcmp(version_string
, LIBMEMCACHED_VERSION_STRING
));
994 uint8_t get_stats(memcached_st
*memc
)
1000 memcached_stat_st
*stat
;
1002 stat
= memcached_stat(memc
, NULL
, &rc
);
1003 assert(rc
== MEMCACHED_SUCCESS
);
1005 assert(rc
== MEMCACHED_SUCCESS
);
1008 for (x
= 0; x
< memcached_server_count(memc
); x
++)
1010 list
= memcached_stat_get_keys(memc
, stat
+x
, &rc
);
1011 assert(rc
== MEMCACHED_SUCCESS
);
1012 for (ptr
= list
; *ptr
; ptr
++);
1017 memcached_stat_free(NULL
, stat
);
1022 uint8_t add_host_test(memcached_st
*memc
)
1025 memcached_server_st
*servers
;
1026 memcached_return rc
;
1027 char servername
[]= "0.example.com";
1029 servers
= memcached_server_list_append(NULL
, servername
, 400, &rc
);
1031 assert(1 == memcached_server_list_count(servers
));
1033 for (x
= 2; x
< 20; x
++)
1035 char buffer
[SMALL_STRING_LEN
];
1037 snprintf(buffer
, SMALL_STRING_LEN
, "%u.example.com", 400+x
);
1038 servers
= memcached_server_list_append(servers
, buffer
, 401,
1040 assert(rc
== MEMCACHED_SUCCESS
);
1041 assert(x
== memcached_server_list_count(servers
));
1044 rc
= memcached_server_push(memc
, servers
);
1045 assert(rc
== MEMCACHED_SUCCESS
);
1046 rc
= memcached_server_push(memc
, servers
);
1047 assert(rc
== MEMCACHED_SUCCESS
);
1049 memcached_server_list_free(servers
);
1054 memcached_return
clone_test_callback(memcached_st
*parent
, memcached_st
*clone
)
1056 return MEMCACHED_SUCCESS
;
1059 memcached_return
cleanup_test_callback(memcached_st
*ptr
)
1061 return MEMCACHED_SUCCESS
;
1064 uint8_t callback_test(memcached_st
*memc
)
1066 /* Test User Data */
1070 memcached_return rc
;
1072 rc
= memcached_callback_set(memc
, MEMCACHED_CALLBACK_USER_DATA
, &x
);
1073 assert(rc
== MEMCACHED_SUCCESS
);
1074 test_ptr
= (int *)memcached_callback_get(memc
, MEMCACHED_CALLBACK_USER_DATA
, &rc
);
1075 assert(*test_ptr
== x
);
1078 /* Test Clone Callback */
1080 memcached_clone_func temp_function
;
1081 memcached_return rc
;
1083 rc
= memcached_callback_set(memc
, MEMCACHED_CALLBACK_CLONE_FUNCTION
, clone_test_callback
);
1084 assert(rc
== MEMCACHED_SUCCESS
);
1085 temp_function
= (memcached_clone_func
)memcached_callback_get(memc
, MEMCACHED_CALLBACK_CLONE_FUNCTION
, &rc
);
1086 assert(temp_function
== clone_test_callback
);
1089 /* Test Cleanup Callback */
1091 memcached_cleanup_func temp_function
;
1092 memcached_return rc
;
1094 rc
= memcached_callback_set(memc
, MEMCACHED_CALLBACK_CLONE_FUNCTION
, cleanup_test_callback
);
1095 assert(rc
== MEMCACHED_SUCCESS
);
1096 temp_function
= (memcached_cleanup_func
)memcached_callback_get(memc
, MEMCACHED_CALLBACK_CLONE_FUNCTION
, &rc
);
1097 assert(temp_function
== cleanup_test_callback
);
1103 /* We don't test the behavior itself, we test the switches */
1104 uint8_t behavior_test(memcached_st
*memc
)
1106 unsigned long long value
;
1107 unsigned int set
= 1;
1109 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NO_BLOCK
, &set
);
1110 value
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_NO_BLOCK
);
1113 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_TCP_NODELAY
, &set
);
1114 value
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_TCP_NODELAY
);
1117 set
= MEMCACHED_HASH_MD5
;
1118 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_HASH
, &set
);
1119 value
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_HASH
);
1120 assert(value
== MEMCACHED_HASH_MD5
);
1124 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NO_BLOCK
, &set
);
1125 value
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_NO_BLOCK
);
1128 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_TCP_NODELAY
, &set
);
1129 value
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_TCP_NODELAY
);
1132 set
= MEMCACHED_HASH_DEFAULT
;
1133 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_HASH
, &set
);
1134 value
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_HASH
);
1135 assert(value
== MEMCACHED_HASH_DEFAULT
);
1137 set
= MEMCACHED_HASH_CRC
;
1138 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_HASH
, &set
);
1139 value
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_HASH
);
1140 assert(value
== MEMCACHED_HASH_CRC
);
1142 value
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_SOCKET_SEND_SIZE
);
1145 value
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_SOCKET_RECV_SIZE
);
1151 /* Test case provided by Cal Haldenbrand */
1152 uint8_t user_supplied_bug1(memcached_st
*memc
)
1154 unsigned int setter
= 1;
1157 unsigned long long total
= 0;
1160 char randomstuff
[6 * 1024];
1161 memcached_return rc
;
1163 memset(randomstuff
, 0, 6 * 1024);
1165 /* We just keep looking at the same values over and over */
1168 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NO_BLOCK
, &setter
);
1169 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_TCP_NODELAY
, &setter
);
1173 for (x
= 0 ; total
< 20 * 1024576 ; x
++ )
1177 size
= (rand() % ( 5 * 1024 ) ) + 400;
1178 memset(randomstuff
, 0, 6 * 1024);
1179 assert(size
< 6 * 1024); /* Being safe here */
1181 for (j
= 0 ; j
< size
;j
++)
1182 randomstuff
[j
] = (char) (rand() % 26) + 97;
1185 sprintf(key
, "%d", x
);
1186 rc
= memcached_set(memc
, key
, strlen(key
),
1187 randomstuff
, strlen(randomstuff
), 10, 0);
1188 /* If we fail, lets try again */
1189 if (rc
!= MEMCACHED_SUCCESS
&& rc
!= MEMCACHED_BUFFERED
)
1190 rc
= memcached_set(memc
, key
, strlen(key
),
1191 randomstuff
, strlen(randomstuff
), 10, 0);
1192 assert(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
);
1198 /* Test case provided by Cal Haldenbrand */
1199 uint8_t user_supplied_bug2(memcached_st
*memc
)
1202 unsigned int setter
;
1204 unsigned long long total
;
1207 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NO_BLOCK
, &setter
);
1208 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_TCP_NODELAY
, &setter
);
1210 setter
= 20 * 1024576;
1211 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_SOCKET_SEND_SIZE
, &setter
);
1212 setter
= 20 * 1024576;
1213 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_SOCKET_RECV_SIZE
, &setter
);
1214 getter
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_SOCKET_SEND_SIZE
);
1215 getter
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_SOCKET_RECV_SIZE
);
1217 for (x
= 0, errors
= 0, total
= 0 ; total
< 20 * 1024576 ; x
++)
1220 for (x
= 0, errors
= 0, total
= 0 ; total
< 24576 ; x
++)
1222 memcached_return rc
= MEMCACHED_SUCCESS
;
1223 char buffer
[SMALL_STRING_LEN
];
1228 memset(buffer
, 0, SMALL_STRING_LEN
);
1230 snprintf(buffer
, SMALL_STRING_LEN
, "%u", x
);
1231 getval
= memcached_get(memc
, buffer
, strlen(buffer
),
1232 &val_len
, &flags
, &rc
);
1233 if (rc
!= MEMCACHED_SUCCESS
)
1235 if (rc
== MEMCACHED_NOTFOUND
)
1239 WATCHPOINT_ERROR(rc
);
1253 /* Do a large mget() over all the keys we think exist */
1254 #define KEY_COUNT 3000 // * 1024576
1255 uint8_t user_supplied_bug3(memcached_st
*memc
)
1257 memcached_return rc
;
1258 unsigned int setter
;
1261 size_t key_lengths
[KEY_COUNT
];
1264 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NO_BLOCK
, &setter
);
1265 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_TCP_NODELAY
, &setter
);
1267 setter
= 20 * 1024576;
1268 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_SOCKET_SEND_SIZE
, &setter
);
1269 setter
= 20 * 1024576;
1270 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_SOCKET_RECV_SIZE
, &setter
);
1271 getter
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_SOCKET_SEND_SIZE
);
1272 getter
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_SOCKET_RECV_SIZE
);
1275 keys
= (char **)malloc(sizeof(char *) * KEY_COUNT
);
1277 memset(keys
, 0, (sizeof(char *) * KEY_COUNT
));
1278 for (x
= 0; x
< KEY_COUNT
; x
++)
1282 snprintf(buffer
, 30, "%u", x
);
1283 keys
[x
]= strdup(buffer
);
1284 key_lengths
[x
]= strlen(keys
[x
]);
1287 rc
= memcached_mget(memc
, keys
, key_lengths
, KEY_COUNT
);
1288 assert(rc
== MEMCACHED_SUCCESS
);
1290 /* Turn this into a help function */
1292 char return_key
[MEMCACHED_MAX_KEY
];
1293 size_t return_key_length
;
1295 size_t return_value_length
;
1298 while ((return_value
= memcached_fetch(memc
, return_key
, &return_key_length
,
1299 &return_value_length
, &flags
, &rc
)))
1301 assert(return_value
);
1302 assert(rc
== MEMCACHED_SUCCESS
);
1307 for (x
= 0; x
< KEY_COUNT
; x
++)
1314 /* Make sure we behave properly if server list has no values */
1315 uint8_t user_supplied_bug4(memcached_st
*memc
)
1317 memcached_return rc
;
1318 char *keys
[]= {"fudge", "son", "food"};
1319 size_t key_length
[]= {5, 3, 4};
1322 char return_key
[MEMCACHED_MAX_KEY
];
1323 size_t return_key_length
;
1325 size_t return_value_length
;
1327 /* Here we free everything before running a bunch of mget tests */
1329 memcached_server_list_free(memc
->hosts
);
1331 memc
->number_of_hosts
= 0;
1335 /* We need to empty the server before continueing test */
1336 rc
= memcached_flush(memc
, 0);
1337 assert(rc
== MEMCACHED_NO_SERVERS
);
1339 rc
= memcached_mget(memc
, keys
, key_length
, 3);
1340 assert(rc
== MEMCACHED_NO_SERVERS
);
1342 while ((return_value
= memcached_fetch(memc
, return_key
, &return_key_length
,
1343 &return_value_length
, &flags
, &rc
)) != NULL
)
1345 assert(return_value
);
1347 assert(!return_value
);
1348 assert(return_value_length
== 0);
1349 assert(rc
== MEMCACHED_NO_SERVERS
);
1351 for (x
= 0; x
< 3; x
++)
1353 rc
= memcached_set(memc
, keys
[x
], key_length
[x
],
1354 keys
[x
], key_length
[x
],
1355 (time_t)50, (uint32_t)9);
1356 assert(rc
== MEMCACHED_NO_SERVERS
);
1359 rc
= memcached_mget(memc
, keys
, key_length
, 3);
1360 assert(rc
== MEMCACHED_NO_SERVERS
);
1363 while ((return_value
= memcached_fetch(memc
, return_key
, &return_key_length
,
1364 &return_value_length
, &flags
, &rc
)))
1366 assert(return_value
);
1367 assert(rc
== MEMCACHED_SUCCESS
);
1368 assert(return_key_length
== return_value_length
);
1369 assert(!memcmp(return_value
, return_key
, return_value_length
));
1377 #define VALUE_SIZE_BUG5 1048064
1378 uint8_t user_supplied_bug5(memcached_st
*memc
)
1380 memcached_return rc
;
1381 char *keys
[]= {"036790384900", "036790384902", "036790384904", "036790384906"};
1382 size_t key_length
[]= {strlen("036790384900"), strlen("036790384902"), strlen("036790384904"), strlen("036790384906")};
1383 char return_key
[MEMCACHED_MAX_KEY
];
1384 size_t return_key_length
;
1386 size_t value_length
;
1390 char insert_data
[VALUE_SIZE_BUG5
];
1392 for (x
= 0; x
< VALUE_SIZE_BUG5
; x
++)
1393 insert_data
[x
]= rand();
1395 memcached_flush(memc
, 0);
1396 value
= memcached_get(memc
, keys
[0], key_length
[0],
1397 &value_length
, &flags
, &rc
);
1398 assert(value
== NULL
);
1399 rc
= memcached_mget(memc
, keys
, key_length
, 4);
1402 while ((value
= memcached_fetch(memc
, return_key
, &return_key_length
,
1403 &value_length
, &flags
, &rc
)))
1407 for (x
= 0; x
< 4; x
++)
1409 rc
= memcached_set(memc
, keys
[x
], key_length
[x
],
1410 insert_data
, VALUE_SIZE_BUG5
,
1411 (time_t)0, (uint32_t)0);
1412 assert(rc
== MEMCACHED_SUCCESS
);
1415 for (x
= 0; x
< 10; x
++)
1417 value
= memcached_get(memc
, keys
[0], key_length
[0],
1418 &value_length
, &flags
, &rc
);
1422 rc
= memcached_mget(memc
, keys
, key_length
, 4);
1424 while ((value
= memcached_fetch(memc
, return_key
, &return_key_length
,
1425 &value_length
, &flags
, &rc
)))
1436 uint8_t user_supplied_bug6(memcached_st
*memc
)
1438 memcached_return rc
;
1439 char *keys
[]= {"036790384900", "036790384902", "036790384904", "036790384906"};
1440 size_t key_length
[]= {strlen("036790384900"), strlen("036790384902"), strlen("036790384904"), strlen("036790384906")};
1441 char return_key
[MEMCACHED_MAX_KEY
];
1442 size_t return_key_length
;
1444 size_t value_length
;
1448 char insert_data
[VALUE_SIZE_BUG5
];
1450 for (x
= 0; x
< VALUE_SIZE_BUG5
; x
++)
1451 insert_data
[x
]= rand();
1453 memcached_flush(memc
, 0);
1454 value
= memcached_get(memc
, keys
[0], key_length
[0],
1455 &value_length
, &flags
, &rc
);
1456 assert(value
== NULL
);
1457 assert(rc
== MEMCACHED_NOTFOUND
);
1458 rc
= memcached_mget(memc
, keys
, key_length
, 4);
1459 assert(rc
== MEMCACHED_SUCCESS
);
1462 while ((value
= memcached_fetch(memc
, return_key
, &return_key_length
,
1463 &value_length
, &flags
, &rc
)))
1466 assert(rc
== MEMCACHED_END
);
1468 for (x
= 0; x
< 4; x
++)
1470 rc
= memcached_set(memc
, keys
[x
], key_length
[x
],
1471 insert_data
, VALUE_SIZE_BUG5
,
1472 (time_t)0, (uint32_t)0);
1473 assert(rc
== MEMCACHED_SUCCESS
);
1476 for (x
= 0; x
< 2; x
++)
1478 value
= memcached_get(memc
, keys
[0], key_length
[0],
1479 &value_length
, &flags
, &rc
);
1483 rc
= memcached_mget(memc
, keys
, key_length
, 4);
1484 assert(rc
== MEMCACHED_SUCCESS
);
1486 /* We test for purge of partial complete fetches */
1487 for (count
= 3; count
; count
--)
1489 value
= memcached_fetch(memc
, return_key
, &return_key_length
,
1490 &value_length
, &flags
, &rc
);
1491 assert(rc
== MEMCACHED_SUCCESS
);
1492 assert(!(memcmp(value
, insert_data
, value_length
)));
1493 assert(value_length
);
1501 uint8_t user_supplied_bug8(memcached_st
*memc
)
1503 memcached_return rc
;
1505 memcached_st
*clone
;
1507 memcached_server_st
*servers
;
1508 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";
1510 servers
= memcached_servers_parse(server_list
);
1513 mine
= memcached_create(NULL
);
1514 rc
= memcached_server_push(mine
, servers
);
1515 assert(rc
== MEMCACHED_SUCCESS
);
1516 memcached_server_list_free(servers
);
1519 clone
= memcached_clone(NULL
, mine
);
1521 memcached_quit(mine
);
1522 memcached_quit(clone
);
1525 memcached_free(mine
);
1526 memcached_free(clone
);
1531 /* Test flag store/retrieve */
1532 uint8_t user_supplied_bug7(memcached_st
*memc
)
1534 memcached_return rc
;
1535 char *keys
= "036790384900";
1536 size_t key_length
= strlen("036790384900");
1537 char return_key
[MEMCACHED_MAX_KEY
];
1538 size_t return_key_length
;
1540 size_t value_length
;
1543 char insert_data
[VALUE_SIZE_BUG5
];
1545 for (x
= 0; x
< VALUE_SIZE_BUG5
; x
++)
1546 insert_data
[x
]= rand();
1548 memcached_flush(memc
, 0);
1551 rc
= memcached_set(memc
, keys
, key_length
,
1552 insert_data
, VALUE_SIZE_BUG5
,
1554 assert(rc
== MEMCACHED_SUCCESS
);
1557 value
= memcached_get(memc
, keys
, key_length
,
1558 &value_length
, &flags
, &rc
);
1559 assert(flags
== 245);
1563 rc
= memcached_mget(memc
, &keys
, &key_length
, 1);
1566 value
= memcached_fetch(memc
, return_key
, &return_key_length
,
1567 &value_length
, &flags
, &rc
);
1568 assert(flags
== 245);
1576 uint8_t user_supplied_bug9(memcached_st
*memc
)
1578 memcached_return rc
;
1579 char *keys
[]= {"UDATA:edevil@sapo.pt", "fudge&*@#", "for^#@&$not"};
1580 size_t key_length
[3];
1585 char return_key
[MEMCACHED_MAX_KEY
];
1586 size_t return_key_length
;
1588 size_t return_value_length
;
1591 key_length
[0]= strlen("UDATA:edevil@sapo.pt");
1592 key_length
[1]= strlen("fudge&*@#");
1593 key_length
[2]= strlen("for^#@&$not");
1596 for (x
= 0; x
< 3; x
++)
1598 rc
= memcached_set(memc
, keys
[x
], key_length
[x
],
1599 keys
[x
], key_length
[x
],
1600 (time_t)50, (uint32_t)9);
1601 assert(rc
== MEMCACHED_SUCCESS
);
1604 rc
= memcached_mget(memc
, keys
, key_length
, 3);
1605 assert(rc
== MEMCACHED_SUCCESS
);
1607 /* We need to empty the server before continueing test */
1608 while ((return_value
= memcached_fetch(memc
, return_key
, &return_key_length
,
1609 &return_value_length
, &flags
, &rc
)) != NULL
)
1611 assert(return_value
);
1620 /* We are testing with aggressive timeout to get failures */
1621 uint8_t user_supplied_bug10(memcached_st
*memc
)
1625 size_t value_length
= 512;
1628 memcached_return rc
;
1629 unsigned int set
= 1;
1630 memcached_st
*mclone
= memcached_clone(NULL
, memc
);
1633 memcached_behavior_set(mclone
, MEMCACHED_BEHAVIOR_NO_BLOCK
, &set
);
1634 memcached_behavior_set(mclone
, MEMCACHED_BEHAVIOR_TCP_NODELAY
, &set
);
1636 memcached_behavior_set(mclone
, MEMCACHED_BEHAVIOR_POLL_TIMEOUT
, &timeout
);
1638 value
= (char*)malloc(value_length
* sizeof(char));
1640 for (x
= 0; x
< value_length
; x
++)
1641 value
[x
]= (char) (x
% 127);
1643 for (x
= 1; x
<= 100000; ++x
)
1645 rc
= memcached_set(mclone
, key
, key_len
,value
, value_length
, 0, 0);
1647 assert(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_WRITE_FAILURE
|| rc
== MEMCACHED_BUFFERED
);
1649 if (rc
== MEMCACHED_WRITE_FAILURE
)
1654 memcached_free(mclone
);
1660 We are looking failures in the async protocol
1662 uint8_t user_supplied_bug11(memcached_st
*memc
)
1666 size_t value_length
= 512;
1669 memcached_return rc
;
1670 unsigned int set
= 1;
1672 memcached_st
*mclone
= memcached_clone(NULL
, memc
);
1674 memcached_behavior_set(mclone
, MEMCACHED_BEHAVIOR_NO_BLOCK
, &set
);
1675 memcached_behavior_set(mclone
, MEMCACHED_BEHAVIOR_TCP_NODELAY
, &set
);
1677 memcached_behavior_set(mclone
, MEMCACHED_BEHAVIOR_POLL_TIMEOUT
, &timeout
);
1679 timeout
= (int32_t)memcached_behavior_get(mclone
, MEMCACHED_BEHAVIOR_POLL_TIMEOUT
);
1681 assert(timeout
== -1);
1683 value
= (char*)malloc(value_length
* sizeof(char));
1685 for (x
= 0; x
< value_length
; x
++)
1686 value
[x
]= (char) (x
% 127);
1688 for (x
= 1; x
<= 100000; ++x
)
1690 rc
= memcached_set(mclone
, key
, key_len
,value
, value_length
, 0, 0);
1694 memcached_free(mclone
);
1700 Bug found where incr was not returning MEMCACHED_NOTFOUND when object did not exist.
1702 uint8_t user_supplied_bug12(memcached_st
*memc
)
1704 memcached_return rc
;
1706 size_t value_length
;
1708 uint64_t number_value
;
1710 value
= memcached_get(memc
, "autoincrement", strlen("autoincrement"),
1711 &value_length
, &flags
, &rc
);
1712 assert(value
== NULL
);
1713 assert(rc
== MEMCACHED_NOTFOUND
);
1715 rc
= memcached_increment(memc
, "autoincrement", strlen("autoincrement"),
1718 assert(value
== NULL
);
1719 assert(rc
== MEMCACHED_NOTFOUND
);
1721 rc
= memcached_set(memc
, "autoincrement", strlen("autoincrement"), "1", 1, 0, 0);
1723 value
= memcached_get(memc
, "autoincrement", strlen("autoincrement"),
1724 &value_length
, &flags
, &rc
);
1726 assert(rc
== MEMCACHED_SUCCESS
);
1729 rc
= memcached_increment(memc
, "autoincrement", strlen("autoincrement"),
1731 assert(number_value
== 2);
1732 assert(rc
== MEMCACHED_SUCCESS
);
1738 Bug found where command total one more than MEMCACHED_MAX_BUFFER
1739 set key34567890 0 0 8169 \r\n is sent followed by buffer of size 8169, followed by 8169
1741 uint8_t user_supplied_bug13(memcached_st
*memc
)
1743 char key
[] = "key34567890";
1745 memcached_return rc
;
1746 size_t overflowSize
;
1748 char commandFirst
[]= "set key34567890 0 0 ";
1749 char commandLast
[] = " \r\n"; /* first line of command sent to server */
1750 size_t commandLength
;
1753 commandLength
= strlen(commandFirst
) + strlen(commandLast
) + 4; /* 4 is number of characters in size, probably 8196 */
1755 overflowSize
= MEMCACHED_MAX_BUFFER
- commandLength
;
1757 for (testSize
= overflowSize
- 1; testSize
< overflowSize
+ 1; testSize
++)
1759 overflow
= malloc(testSize
);
1760 assert(overflow
!= NULL
);
1762 memset(overflow
, 'x', testSize
);
1763 rc
= memcached_set(memc
, key
, strlen(key
),
1764 overflow
, testSize
, 0, 0);
1765 assert(rc
== MEMCACHED_SUCCESS
);
1774 Test values of many different sizes
1775 Bug found where command total one more than MEMCACHED_MAX_BUFFER
1776 set key34567890 0 0 8169 \r\n
1777 is sent followed by buffer of size 8169, followed by 8169
1779 uint8_t user_supplied_bug14(memcached_st
*memc
)
1782 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_TCP_NODELAY
, &setter
);
1783 memcached_return rc
;
1786 size_t value_length
= 18000;
1788 size_t string_length
;
1791 size_t current_length
;
1793 value
= (char*)malloc(value_length
);
1796 for (x
= 0; x
< value_length
; x
++)
1797 value
[x
] = (char) (x
% 127);
1799 for (current_length
= 1; current_length
< value_length
; current_length
++)
1801 rc
= memcached_set(memc
, key
, strlen(key
),
1802 value
, current_length
,
1803 (time_t)0, (uint32_t)0);
1804 assert(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
);
1806 string
= memcached_get(memc
, key
, strlen(key
),
1807 &string_length
, &flags
, &rc
);
1809 assert(rc
== MEMCACHED_SUCCESS
);
1811 assert(string_length
== current_length
);
1812 assert(!memcmp(string
, value
, string_length
));
1822 uint8_t result_static(memcached_st
*memc
)
1824 memcached_result_st result
;
1825 memcached_result_st
*result_ptr
;
1827 result_ptr
= memcached_result_create(memc
, &result
);
1828 assert(result
.is_allocated
== MEMCACHED_NOT_ALLOCATED
);
1830 memcached_result_free(&result
);
1835 uint8_t result_alloc(memcached_st
*memc
)
1837 memcached_result_st
*result
;
1839 result
= memcached_result_create(memc
, NULL
);
1841 memcached_result_free(result
);
1846 uint8_t string_static_null(memcached_st
*memc
)
1848 memcached_string_st string
;
1849 memcached_string_st
*string_ptr
;
1851 string_ptr
= memcached_string_create(memc
, &string
, 0);
1852 assert(string
.is_allocated
== MEMCACHED_NOT_ALLOCATED
);
1854 memcached_string_free(&string
);
1859 uint8_t string_alloc_null(memcached_st
*memc
)
1861 memcached_string_st
*string
;
1863 string
= memcached_string_create(memc
, NULL
, 0);
1865 memcached_string_free(string
);
1870 uint8_t string_alloc_with_size(memcached_st
*memc
)
1872 memcached_string_st
*string
;
1874 string
= memcached_string_create(memc
, NULL
, 1024);
1876 memcached_string_free(string
);
1881 uint8_t string_alloc_with_size_toobig(memcached_st
*memc
)
1883 memcached_string_st
*string
;
1885 string
= memcached_string_create(memc
, NULL
, INT64_MAX
);
1886 assert(string
== NULL
);
1891 uint8_t string_alloc_append(memcached_st
*memc
)
1894 char buffer
[SMALL_STRING_LEN
];
1895 memcached_string_st
*string
;
1897 /* Ring the bell! */
1898 memset(buffer
, 6, SMALL_STRING_LEN
);
1900 string
= memcached_string_create(memc
, NULL
, 100);
1903 for (x
= 0; x
< 1024; x
++)
1905 memcached_return rc
;
1906 rc
= memcached_string_append(string
, buffer
, SMALL_STRING_LEN
);
1907 assert(rc
== MEMCACHED_SUCCESS
);
1909 memcached_string_free(string
);
1914 uint8_t string_alloc_append_toobig(memcached_st
*memc
)
1916 memcached_return rc
;
1918 char buffer
[SMALL_STRING_LEN
];
1919 memcached_string_st
*string
;
1921 /* Ring the bell! */
1922 memset(buffer
, 6, SMALL_STRING_LEN
);
1924 string
= memcached_string_create(memc
, NULL
, 100);
1927 for (x
= 0; x
< 1024; x
++)
1929 rc
= memcached_string_append(string
, buffer
, SMALL_STRING_LEN
);
1930 assert(rc
== MEMCACHED_SUCCESS
);
1932 rc
= memcached_string_append(string
, buffer
, INT64_MAX
);
1933 assert(rc
== MEMCACHED_MEMORY_ALLOCATION_FAILURE
);
1934 memcached_string_free(string
);
1939 uint8_t cleanup_pairs(memcached_st
*memc
)
1941 pairs_free(global_pairs
);
1946 uint8_t generate_pairs(memcached_st
*memc
)
1948 unsigned long long x
;
1949 global_pairs
= pairs_generate(GLOBAL_COUNT
, 400);
1950 global_count
= GLOBAL_COUNT
;
1952 for (x
= 0; x
< global_count
; x
++)
1954 global_keys
[x
]= global_pairs
[x
].key
;
1955 global_keys_length
[x
]= global_pairs
[x
].key_length
;
1961 uint8_t generate_large_pairs(memcached_st
*memc
)
1963 unsigned long long x
;
1964 global_pairs
= pairs_generate(GLOBAL2_COUNT
, MEMCACHED_MAX_BUFFER
+10);
1965 global_count
= GLOBAL2_COUNT
;
1967 for (x
= 0; x
< global_count
; x
++)
1969 global_keys
[x
]= global_pairs
[x
].key
;
1970 global_keys_length
[x
]= global_pairs
[x
].key_length
;
1976 uint8_t generate_data(memcached_st
*memc
)
1978 execute_set(memc
, global_pairs
, global_count
);
1983 uint8_t generate_buffer_data(memcached_st
*memc
)
1988 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_BUFFER_REQUESTS
, &latch
);
1989 generate_data(memc
);
1994 uint8_t get_read(memcached_st
*memc
)
1997 memcached_return rc
;
2001 size_t return_value_length
;
2004 for (x
= 0; x
< global_count
; x
++)
2006 return_value
= memcached_get(memc
, global_keys
[x
], global_keys_length
[x
],
2007 &return_value_length
, &flags
, &rc
);
2009 assert(return_value);
2010 assert(rc == MEMCACHED_SUCCESS);
2012 if (rc
== MEMCACHED_SUCCESS
&& return_value
)
2020 uint8_t mget_read(memcached_st
*memc
)
2022 memcached_return rc
;
2024 rc
= memcached_mget(memc
, global_keys
, global_keys_length
, global_count
);
2025 assert(rc
== MEMCACHED_SUCCESS
);
2026 /* Turn this into a help function */
2028 char return_key
[MEMCACHED_MAX_KEY
];
2029 size_t return_key_length
;
2031 size_t return_value_length
;
2034 while ((return_value
= memcached_fetch(memc
, return_key
, &return_key_length
,
2035 &return_value_length
, &flags
, &rc
)))
2037 assert(return_value
);
2038 assert(rc
== MEMCACHED_SUCCESS
);
2046 uint8_t mget_read_result(memcached_st
*memc
)
2048 memcached_return rc
;
2050 rc
= memcached_mget(memc
, global_keys
, global_keys_length
, global_count
);
2051 assert(rc
== MEMCACHED_SUCCESS
);
2052 /* Turn this into a help function */
2054 memcached_result_st results_obj
;
2055 memcached_result_st
*results
;
2057 results
= memcached_result_create(memc
, &results_obj
);
2059 while ((results
= memcached_fetch_result(memc
, &results_obj
, &rc
)))
2062 assert(rc
== MEMCACHED_SUCCESS
);
2065 memcached_result_free(&results_obj
);
2071 uint8_t mget_read_function(memcached_st
*memc
)
2073 memcached_return rc
;
2074 unsigned int counter
;
2075 unsigned int (*callbacks
[1])(memcached_st
*, memcached_result_st
*, void *);
2077 rc
= memcached_mget(memc
, global_keys
, global_keys_length
, global_count
);
2078 assert(rc
== MEMCACHED_SUCCESS
);
2080 callbacks
[0]= &callback_counter
;
2082 rc
= memcached_fetch_execute(memc
, callbacks
, (void *)&counter
, 1);
2087 uint8_t delete_generate(memcached_st
*memc
)
2091 for (x
= 0; x
< global_count
; x
++)
2093 (void)memcached_delete(memc
, global_keys
[x
], global_keys_length
[x
], (time_t)0);
2099 uint8_t delete_buffer_generate(memcached_st
*memc
)
2105 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_BUFFER_REQUESTS
, &latch
);
2107 for (x
= 0; x
< global_count
; x
++)
2109 (void)memcached_delete(memc
, global_keys
[x
], global_keys_length
[x
], (time_t)0);
2115 uint8_t free_data(memcached_st
*memc
)
2117 pairs_free(global_pairs
);
2122 uint8_t add_host_test1(memcached_st
*memc
)
2125 memcached_return rc
;
2126 char servername
[]= "0.example.com";
2127 memcached_server_st
*servers
;
2129 servers
= memcached_server_list_append(NULL
, servername
, 400, &rc
);
2131 assert(1 == memcached_server_list_count(servers
));
2133 for (x
= 2; x
< 20; x
++)
2135 char buffer
[SMALL_STRING_LEN
];
2137 snprintf(buffer
, SMALL_STRING_LEN
, "%u.example.com", 400+x
);
2138 servers
= memcached_server_list_append(servers
, buffer
, 401,
2140 assert(rc
== MEMCACHED_SUCCESS
);
2141 assert(x
== memcached_server_list_count(servers
));
2144 rc
= memcached_server_push(memc
, servers
);
2145 assert(rc
== MEMCACHED_SUCCESS
);
2146 rc
= memcached_server_push(memc
, servers
);
2147 assert(rc
== MEMCACHED_SUCCESS
);
2149 memcached_server_list_free(servers
);
2154 memcached_return
pre_nonblock(memcached_st
*memc
)
2156 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NO_BLOCK
, NULL
);
2158 return MEMCACHED_SUCCESS
;
2161 memcached_return
pre_md5(memcached_st
*memc
)
2163 memcached_hash value
= MEMCACHED_HASH_MD5
;
2164 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_HASH
, &value
);
2166 return MEMCACHED_SUCCESS
;
2169 memcached_return
pre_crc(memcached_st
*memc
)
2171 memcached_hash value
= MEMCACHED_HASH_CRC
;
2172 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_HASH
, &value
);
2174 return MEMCACHED_SUCCESS
;
2177 memcached_return
pre_hsieh(memcached_st
*memc
)
2179 memcached_hash value
= MEMCACHED_HASH_HSIEH
;
2180 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_HASH
, &value
);
2182 return MEMCACHED_SUCCESS
;
2185 memcached_return
pre_hash_fnv1_64(memcached_st
*memc
)
2187 memcached_hash value
= MEMCACHED_HASH_FNV1_64
;
2188 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_HASH
, &value
);
2190 return MEMCACHED_SUCCESS
;
2193 memcached_return
pre_hash_fnv1a_64(memcached_st
*memc
)
2195 memcached_hash value
= MEMCACHED_HASH_FNV1A_64
;
2196 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_HASH
, &value
);
2198 return MEMCACHED_SUCCESS
;
2201 memcached_return
pre_hash_fnv1_32(memcached_st
*memc
)
2203 memcached_hash value
= MEMCACHED_HASH_FNV1_32
;
2204 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_HASH
, &value
);
2206 return MEMCACHED_SUCCESS
;
2209 memcached_return
pre_hash_fnv1a_32(memcached_st
*memc
)
2211 memcached_hash value
= MEMCACHED_HASH_FNV1A_32
;
2212 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_HASH
, &value
);
2214 return MEMCACHED_SUCCESS
;
2217 memcached_return
pre_hash_ketama(memcached_st
*memc
)
2219 memcached_hash value
= MEMCACHED_HASH_KETAMA
;
2220 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_HASH
, &value
);
2222 return MEMCACHED_SUCCESS
;
2225 void my_free(memcached_st
*ptr
, void *mem
)
2230 void *my_malloc(memcached_st
*ptr
, const size_t size
)
2232 return malloc(size
);
2235 void *my_realloc(memcached_st
*ptr
, void *mem
, const size_t size
)
2237 return realloc(mem
, size
);
2240 memcached_return
set_memory_alloc(memcached_st
*memc
)
2243 memcached_malloc_function test_ptr
;
2244 memcached_return rc
;
2246 rc
= memcached_callback_set(memc
, MEMCACHED_CALLBACK_MALLOC_FUNCTION
, &my_malloc
);
2247 assert(rc
== MEMCACHED_SUCCESS
);
2248 test_ptr
= (memcached_malloc_function
)memcached_callback_get(memc
, MEMCACHED_CALLBACK_MALLOC_FUNCTION
, &rc
);
2249 assert(rc
== MEMCACHED_SUCCESS
);
2250 assert(test_ptr
== my_malloc
);
2254 memcached_realloc_function test_ptr
;
2255 memcached_return rc
;
2257 rc
= memcached_callback_set(memc
, MEMCACHED_CALLBACK_REALLOC_FUNCTION
, &my_realloc
);
2258 assert(rc
== MEMCACHED_SUCCESS
);
2259 test_ptr
= (memcached_realloc_function
)memcached_callback_get(memc
, MEMCACHED_CALLBACK_REALLOC_FUNCTION
, &rc
);
2260 assert(rc
== MEMCACHED_SUCCESS
);
2261 assert(test_ptr
== my_realloc
);
2265 memcached_free_function test_ptr
;
2266 memcached_return rc
;
2268 rc
= memcached_callback_set(memc
, MEMCACHED_CALLBACK_FREE_FUNCTION
, my_free
);
2269 assert(rc
== MEMCACHED_SUCCESS
);
2270 test_ptr
= (memcached_free_function
)memcached_callback_get(memc
, MEMCACHED_CALLBACK_FREE_FUNCTION
, &rc
);
2271 assert(rc
== MEMCACHED_SUCCESS
);
2272 assert(test_ptr
== my_free
);
2275 return MEMCACHED_SUCCESS
;
2278 memcached_return
enable_consistent(memcached_st
*memc
)
2280 memcached_server_distribution value
= MEMCACHED_DISTRIBUTION_CONSISTENT
;
2281 memcached_hash hash
;
2282 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_DISTRIBUTION
, &value
);
2285 value
= (memcached_server_distribution
)memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_DISTRIBUTION
);
2286 assert(value
== MEMCACHED_DISTRIBUTION_CONSISTENT
);
2288 hash
= (memcached_hash
)memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_HASH
);
2289 assert(hash
== MEMCACHED_HASH_HSIEH
);
2292 return MEMCACHED_SUCCESS
;
2295 memcached_return
enable_cas(memcached_st
*memc
)
2297 unsigned int set
= 1;
2299 memcached_version(memc
);
2301 if (memc
->hosts
[0].major_version
>= 1 &&
2302 memc
->hosts
[0].minor_version
>= 2 &&
2303 memc
->hosts
[0].micro_version
>= 4)
2305 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_SUPPORT_CAS
, &set
);
2307 return MEMCACHED_SUCCESS
;
2310 return MEMCACHED_FAILURE
;
2313 memcached_return
check_for_1_2_3(memcached_st
*memc
)
2315 memcached_version(memc
);
2317 if (memc
->hosts
[0].major_version
>= 1 &&
2318 memc
->hosts
[0].minor_version
>= 2 &&
2319 memc
->hosts
[0].micro_version
>= 4)
2320 return MEMCACHED_SUCCESS
;
2322 return MEMCACHED_FAILURE
;
2325 memcached_return
pre_unix_socket(memcached_st
*memc
)
2327 memcached_return rc
;
2330 memcached_server_list_free(memc
->hosts
);
2332 memc
->number_of_hosts
= 0;
2334 if (stat("/tmp/memcached.socket", &buf
))
2335 return MEMCACHED_FAILURE
;
2337 rc
= memcached_server_add_unix_socket(memc
, "/tmp/memcached.socket");
2342 memcached_return
pre_udp(memcached_st
*memc
)
2344 memcached_return rc
;
2346 memcached_server_list_free(memc
->hosts
);
2348 memc
->number_of_hosts
= 0;
2351 return MEMCACHED_FAILURE
;
2353 rc
= memcached_server_add_udp(memc
, "localhost", MEMCACHED_DEFAULT_PORT
);
2358 memcached_return
pre_nodelay(memcached_st
*memc
)
2360 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NO_BLOCK
, NULL
);
2361 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_TCP_NODELAY
, NULL
);
2363 return MEMCACHED_SUCCESS
;
2366 memcached_return
poll_timeout(memcached_st
*memc
)
2372 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_POLL_TIMEOUT
, &timeout
);
2374 timeout
= (int32_t)memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_POLL_TIMEOUT
);
2376 assert(timeout
== 100);
2378 return MEMCACHED_SUCCESS
;
2382 /* Clean the server before beginning testing */
2384 {"flush", 0, flush_test
},
2385 {"init", 0, init_test
},
2386 {"allocation", 0, allocation_test
},
2387 {"server_list_null_test", 0, server_list_null_test
},
2388 {"server_sort", 0, server_sort_test
},
2389 {"clone_test", 0, clone_test
},
2390 {"error", 0, error_test
},
2391 {"set", 0, set_test
},
2392 {"set2", 0, set_test2
},
2393 {"set3", 0, set_test3
},
2394 {"add", 1, add_test
},
2395 {"replace", 1, replace_test
},
2396 {"delete", 1, delete_test
},
2397 {"get", 1, get_test
},
2398 {"get2", 0, get_test2
},
2399 {"get3", 0, get_test3
},
2400 {"get4", 0, get_test4
},
2401 {"stats_servername", 0, stats_servername_test
},
2402 {"increment", 0, increment_test
},
2403 {"decrement", 0, decrement_test
},
2404 {"quit", 0, quit_test
},
2405 {"mget", 1, mget_test
},
2406 {"mget_result", 1, mget_result_test
},
2407 {"mget_result_alloc", 1, mget_result_alloc_test
},
2408 {"mget_result_function", 1, mget_result_function
},
2409 {"get_stats", 0, get_stats
},
2410 {"add_host_test", 0, add_host_test
},
2411 {"get_stats_keys", 0, get_stats_keys
},
2412 {"behavior_test", 0, get_stats_keys
},
2413 {"callback_test", 0, get_stats_keys
},
2414 {"version_string_test", 0, version_string_test
},
2415 {"bad_key", 1, bad_key_test
},
2419 test_st async_tests
[] ={
2420 {"add", 1, add_wrapper
},
2424 test_st string_tests
[] ={
2425 {"string static with null", 0, string_static_null
},
2426 {"string alloc with null", 0, string_alloc_null
},
2427 {"string alloc with 1K", 0, string_alloc_with_size
},
2428 {"string alloc with malloc failure", 0, string_alloc_with_size_toobig
},
2429 {"string append", 0, string_alloc_append
},
2430 {"string append failure (too big)", 0, string_alloc_append_toobig
},
2434 test_st result_tests
[] ={
2435 {"result static", 0, result_static
},
2436 {"result alloc", 0, result_alloc
},
2440 test_st version_1_2_3
[] ={
2441 {"append", 0, append_test
},
2442 {"prepend", 0, prepend_test
},
2443 {"cas", 0, cas_test
},
2444 {"cas2", 0, cas2_test
},
2445 {"append_binary", 0, append_binary_test
},
2449 test_st user_tests
[] ={
2450 {"user_supplied_bug1", 0, user_supplied_bug1
},
2451 {"user_supplied_bug2", 0, user_supplied_bug2
},
2452 {"user_supplied_bug3", 0, user_supplied_bug3
},
2453 {"user_supplied_bug4", 0, user_supplied_bug4
},
2454 {"user_supplied_bug5", 1, user_supplied_bug5
},
2455 {"user_supplied_bug6", 1, user_supplied_bug6
},
2456 {"user_supplied_bug7", 1, user_supplied_bug7
},
2457 {"user_supplied_bug8", 1, user_supplied_bug8
},
2458 {"user_supplied_bug9", 1, user_supplied_bug9
},
2459 {"user_supplied_bug10", 1, user_supplied_bug10
},
2460 {"user_supplied_bug11", 1, user_supplied_bug11
},
2461 {"user_supplied_bug12", 1, user_supplied_bug12
},
2462 {"user_supplied_bug13", 1, user_supplied_bug13
},
2463 {"user_supplied_bug14", 1, user_supplied_bug14
},
2467 test_st generate_tests
[] ={
2468 {"generate_pairs", 1, generate_pairs
},
2469 {"generate_data", 1, generate_data
},
2470 {"get_read", 0, get_read
},
2471 {"delete_generate", 0, delete_generate
},
2472 {"generate_buffer_data", 1, generate_buffer_data
},
2473 {"delete_buffer", 0, delete_buffer_generate
},
2474 {"generate_data", 1, generate_data
},
2475 {"mget_read", 0, mget_read
},
2476 {"mget_read_result", 0, mget_read_result
},
2477 {"mget_read_function", 0, mget_read_function
},
2478 {"cleanup", 1, cleanup_pairs
},
2479 {"generate_large_pairs", 1, generate_large_pairs
},
2480 {"generate_data", 1, generate_data
},
2481 {"generate_buffer_data", 1, generate_buffer_data
},
2482 {"cleanup", 1, cleanup_pairs
},
2487 collection_st collection
[] ={
2488 {"block", 0, 0, tests
},
2489 {"nonblock", pre_nonblock
, 0, tests
},
2490 {"nodelay", pre_nodelay
, 0, tests
},
2491 {"md5", pre_md5
, 0, tests
},
2492 {"crc", pre_crc
, 0, tests
},
2493 {"hsieh", pre_hsieh
, 0, tests
},
2494 {"fnv1_64", pre_hash_fnv1_64
, 0, tests
},
2495 {"fnv1a_64", pre_hash_fnv1a_64
, 0, tests
},
2496 {"fnv1_32", pre_hash_fnv1_32
, 0, tests
},
2497 {"fnv1a_32", pre_hash_fnv1a_32
, 0, tests
},
2498 {"ketama", pre_hash_ketama
, 0, tests
},
2499 {"unix_socket", pre_unix_socket
, 0, tests
},
2500 {"unix_socket_nodelay", pre_nodelay
, 0, tests
},
2501 {"poll_timeout", poll_timeout
, 0, tests
},
2502 {"gets", enable_cas
, 0, tests
},
2503 {"consistent", enable_consistent
, 0, tests
},
2504 {"memory_allocators", set_memory_alloc
, 0, tests
},
2505 // {"udp", pre_udp, 0, tests},
2506 {"version_1_2_3", check_for_1_2_3
, 0, version_1_2_3
},
2507 {"string", 0, 0, string_tests
},
2508 {"result", 0, 0, result_tests
},
2509 {"async", pre_nonblock
, 0, async_tests
},
2510 {"user", 0, 0, user_tests
},
2511 {"generate", 0, 0, generate_tests
},
2512 {"generate_hsieh", pre_hsieh
, 0, generate_tests
},
2513 {"generate_hsieh_consistent", enable_consistent
, 0, generate_tests
},
2514 {"generate_md5", pre_md5
, 0, generate_tests
},
2515 {"generate_nonblock", pre_nonblock
, 0, generate_tests
},
2519 #define SERVERS_TO_CREATE 5
2521 void *world_create(void)
2523 server_startup_st
*construct
;
2525 construct
= (server_startup_st
*)malloc(sizeof(server_startup_st
));
2526 memset(construct
, 0, sizeof(server_startup_st
));
2527 construct
->count
= SERVERS_TO_CREATE
;
2529 server_startup(construct
);
2534 void world_destroy(void *p
)
2536 server_startup_st
*construct
= (server_startup_st
*)p
;
2537 memcached_server_st
*servers
= (memcached_server_st
*)construct
->servers
;
2538 memcached_server_list_free(servers
);
2540 server_shutdown(construct
);
2544 void get_world(world_st
*world
)
2546 world
->collections
= collection
;
2547 world
->create
= world_create
;
2548 world
->destroy
= world_destroy
;