2 Sample test application.
14 #include "../libmemcached/common.h"
15 #include "../clients/generator.h"
16 #include "../clients/execute.h"
19 #define INT64_MAX LONG_MAX
22 #define INT32_MAX INT_MAX
28 #define GLOBAL_COUNT 100000
29 #define GLOBAL2_COUNT 1000
30 static uint32_t global_count
;
32 static pairs_st
*global_pairs
;
33 static char *global_keys
[GLOBAL_COUNT
];
34 static size_t global_keys_length
[GLOBAL_COUNT
];
36 uint8_t init_test(memcached_st
*not_used
)
40 (void)memcached_create(&memc
);
41 memcached_free(&memc
);
46 uint8_t server_list_null_test(memcached_st
*ptr
)
48 memcached_server_st
*server_list
;
51 server_list
= memcached_server_list_append(NULL
, NULL
, 0, NULL
);
52 assert(server_list
== NULL
);
54 server_list
= memcached_server_list_append(NULL
, "localhost", 0, NULL
);
55 assert(server_list
== NULL
);
57 server_list
= memcached_server_list_append(NULL
, NULL
, 0, &rc
);
58 assert(server_list
== NULL
);
63 uint8_t server_sort_test(memcached_st
*ptr
)
65 memcached_server_st
*server_list
;
68 memcached_behavior_set(ptr
, MEMCACHED_BEHAVIOR_SORT_HOSTS
, 1);
70 server_list
= memcached_server_list_append(NULL
, "arg", 0, &rc
);
73 server_list
= memcached_server_list_append(server_list
, "localhost", 0, &rc
);
76 server_list
= memcached_server_list_append(server_list
, "c", 0, &rc
);
79 server_list
= memcached_server_list_append(server_list
, "abba", 0, &rc
);
87 uint8_t allocation_test(memcached_st
*not_used
)
90 memc
= memcached_create(NULL
);
97 uint8_t clone_test(memcached_st
*memc
)
102 clone
= memcached_clone(NULL
, NULL
);
104 memcached_free(clone
);
107 /* Can we init from null? */
110 clone
= memcached_clone(NULL
, memc
);
112 memcached_free(clone
);
115 /* Can we init from struct? */
117 memcached_st declared_clone
;
119 clone
= memcached_clone(&declared_clone
, NULL
);
121 memcached_free(clone
);
124 /* Can we init from struct? */
126 memcached_st declared_clone
;
128 clone
= memcached_clone(&declared_clone
, memc
);
130 memcached_free(clone
);
136 uint8_t connection_test(memcached_st
*memc
)
140 rc
= memcached_server_add(memc
, "localhost", 0);
141 assert(rc
== MEMCACHED_SUCCESS
);
146 uint8_t error_test(memcached_st
*memc
)
150 for (rc
= MEMCACHED_SUCCESS
; rc
< MEMCACHED_MAXIMUM_RETURN
; rc
++)
152 printf("Error %d -> %s\n", rc
, memcached_strerror(memc
, rc
));
158 uint8_t set_test(memcached_st
*memc
)
162 char *value
= "when we sanitize";
164 rc
= memcached_set(memc
, key
, strlen(key
),
165 value
, strlen(value
),
166 (time_t)0, (uint32_t)0);
167 assert(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
);
172 uint8_t append_test(memcached_st
*memc
)
180 rc
= memcached_flush(memc
, 0);
181 assert(rc
== MEMCACHED_SUCCESS
);
183 rc
= memcached_set(memc
, key
, strlen(key
),
184 value
, strlen(value
),
185 (time_t)0, (uint32_t)0);
186 assert(rc
== MEMCACHED_SUCCESS
);
188 rc
= memcached_append(memc
, key
, strlen(key
),
189 " the", strlen(" the"),
190 (time_t)0, (uint32_t)0);
191 assert(rc
== MEMCACHED_SUCCESS
);
193 rc
= memcached_append(memc
, key
, strlen(key
),
194 " people", strlen(" people"),
195 (time_t)0, (uint32_t)0);
196 assert(rc
== MEMCACHED_SUCCESS
);
198 value
= memcached_get(memc
, key
, strlen(key
),
199 &value_length
, &flags
, &rc
);
200 assert(!memcmp(value
, "we the people", strlen("we the people")));
201 assert(strlen("we the people") == value_length
);
202 assert(rc
== MEMCACHED_SUCCESS
);
208 uint8_t append_binary_test(memcached_st
*memc
)
211 char *key
= "numbers";
212 unsigned int *store_ptr
;
213 unsigned int store_list
[] = { 23, 56, 499, 98, 32847, 0 };
219 rc
= memcached_flush(memc
, 0);
220 assert(rc
== MEMCACHED_SUCCESS
);
222 rc
= memcached_set(memc
,
225 (time_t)0, (uint32_t)0);
226 assert(rc
== MEMCACHED_SUCCESS
);
228 for (x
= 0; store_list
[x
] ; x
++)
230 rc
= memcached_append(memc
,
232 (char *)&store_list
[x
], sizeof(unsigned int),
233 (time_t)0, (uint32_t)0);
234 assert(rc
== MEMCACHED_SUCCESS
);
237 value
= memcached_get(memc
, key
, strlen(key
),
238 &value_length
, &flags
, &rc
);
239 assert((value_length
== (sizeof(unsigned int) * x
)));
240 assert(rc
== MEMCACHED_SUCCESS
);
242 store_ptr
= (unsigned int *)value
;
244 while ((size_t)store_ptr
< (size_t)(value
+ value_length
))
246 assert(*store_ptr
== store_list
[x
++]);
254 uint8_t cas2_test(memcached_st
*memc
)
257 char *keys
[]= {"fudge", "son", "food"};
258 size_t key_length
[]= {5, 3, 4};
259 char *value
= "we the people";
260 size_t value_length
= strlen("we the people");
262 memcached_result_st results_obj
;
263 memcached_result_st
*results
;
266 rc
= memcached_flush(memc
, 0);
267 assert(rc
== MEMCACHED_SUCCESS
);
269 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_SUPPORT_CAS
, set
);
271 for (x
= 0; x
< 3; x
++)
273 rc
= memcached_set(memc
, keys
[x
], key_length
[x
],
274 keys
[x
], key_length
[x
],
275 (time_t)50, (uint32_t)9);
276 assert(rc
== MEMCACHED_SUCCESS
);
279 rc
= memcached_mget(memc
, keys
, key_length
, 3);
281 results
= memcached_result_create(memc
, &results_obj
);
283 results
= memcached_fetch_result(memc
, &results_obj
, &rc
);
285 assert(results
->cas
);
286 assert(rc
== MEMCACHED_SUCCESS
);
287 WATCHPOINT_ASSERT(memcached_result_cas(results
));
289 assert(!memcmp(value
, "we the people", strlen("we the people")));
290 assert(strlen("we the people") == value_length
);
291 assert(rc
== MEMCACHED_SUCCESS
);
293 memcached_result_free(&results_obj
);
298 uint8_t cas_test(memcached_st
*memc
)
302 size_t key_length
= strlen("fun");
303 char *value
= "we the people";
304 size_t value_length
= strlen("we the people");
305 memcached_result_st results_obj
;
306 memcached_result_st
*results
;
309 rc
= memcached_flush(memc
, 0);
310 assert(rc
== MEMCACHED_SUCCESS
);
312 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_SUPPORT_CAS
, set
);
314 rc
= memcached_set(memc
, key
, strlen(key
),
315 value
, strlen(value
),
316 (time_t)0, (uint32_t)0);
317 assert(rc
== MEMCACHED_SUCCESS
);
319 rc
= memcached_mget(memc
, &key
, &key_length
, 1);
321 results
= memcached_result_create(memc
, &results_obj
);
323 results
= memcached_fetch_result(memc
, &results_obj
, &rc
);
325 assert(rc
== MEMCACHED_SUCCESS
);
326 WATCHPOINT_ASSERT(memcached_result_cas(results
));
328 assert(!memcmp(value
, "we the people", strlen("we the people")));
329 assert(strlen("we the people") == value_length
);
330 assert(rc
== MEMCACHED_SUCCESS
);
332 rc
= memcached_cas(memc
, key
, key_length
,
333 "change the value", strlen("change the value"),
334 0, 0, memcached_result_cas(results
));
336 assert(rc
== MEMCACHED_SUCCESS
);
338 rc
= memcached_cas(memc
, key
, key_length
,
339 "change the value", strlen("change the value"),
342 assert(rc
== MEMCACHED_DATA_EXISTS
);
345 memcached_result_free(&results_obj
);
350 uint8_t prepend_test(memcached_st
*memc
)
354 char *value
= "people";
358 rc
= memcached_flush(memc
, 0);
359 assert(rc
== MEMCACHED_SUCCESS
);
361 rc
= memcached_set(memc
, key
, strlen(key
),
362 value
, strlen(value
),
363 (time_t)0, (uint32_t)0);
364 assert(rc
== MEMCACHED_SUCCESS
);
366 rc
= memcached_prepend(memc
, key
, strlen(key
),
367 "the ", strlen("the "),
368 (time_t)0, (uint32_t)0);
369 assert(rc
== MEMCACHED_SUCCESS
);
371 rc
= memcached_prepend(memc
, key
, strlen(key
),
372 "we ", strlen("we "),
373 (time_t)0, (uint32_t)0);
374 assert(rc
== MEMCACHED_SUCCESS
);
376 value
= memcached_get(memc
, key
, strlen(key
),
377 &value_length
, &flags
, &rc
);
378 assert(!memcmp(value
, "we the people", strlen("we the people")));
379 assert(strlen("we the people") == value_length
);
380 assert(rc
== MEMCACHED_SUCCESS
);
387 Set the value, then quit to make sure it is flushed.
388 Come back in and test that add fails.
390 uint8_t add_test(memcached_st
*memc
)
394 char *value
= "when we sanitize";
395 unsigned long long setting_value
;
397 setting_value
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_NO_BLOCK
);
399 rc
= memcached_set(memc
, key
, strlen(key
),
400 value
, strlen(value
),
401 (time_t)0, (uint32_t)0);
402 assert(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
);
403 memcached_quit(memc
);
404 rc
= memcached_add(memc
, key
, strlen(key
),
405 value
, strlen(value
),
406 (time_t)0, (uint32_t)0);
408 /* Too many broken OS'es have broken loopback in async, so we can't be sure of the result */
410 assert(rc
== MEMCACHED_NOTSTORED
|| MEMCACHED_STORED
);
412 assert(rc
== MEMCACHED_NOTSTORED
);
417 uint8_t add_wrapper(memcached_st
*memc
)
421 for (x
= 0; x
< 10000; x
++)
427 uint8_t replace_test(memcached_st
*memc
)
431 char *value
= "when we sanitize";
432 char *original
= "first we insert some data";
434 rc
= memcached_set(memc
, key
, strlen(key
),
435 original
, strlen(original
),
436 (time_t)0, (uint32_t)0);
437 assert(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
);
439 rc
= memcached_replace(memc
, key
, strlen(key
),
440 value
, strlen(value
),
441 (time_t)0, (uint32_t)0);
442 assert(rc
== MEMCACHED_SUCCESS
);
447 uint8_t delete_test(memcached_st
*memc
)
451 char *value
= "when we sanitize";
453 rc
= memcached_set(memc
, key
, strlen(key
),
454 value
, strlen(value
),
455 (time_t)0, (uint32_t)0);
456 assert(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
);
458 rc
= memcached_delete(memc
, key
, strlen(key
), (time_t)0);
459 assert(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
);
464 uint8_t flush_test(memcached_st
*memc
)
468 rc
= memcached_flush(memc
, 0);
469 assert(rc
== MEMCACHED_SUCCESS
);
474 memcached_return
server_function(memcached_st
*ptr
, memcached_server_st
*server
, void *context
)
478 return MEMCACHED_SUCCESS
;
481 uint8_t memcached_server_cursor_test(memcached_st
*memc
)
483 char *context
= "foo bad";
484 memcached_server_function callbacks
[1];
486 callbacks
[0]= server_function
;
487 memcached_server_cursor(memc
, callbacks
, context
, 1);
492 uint8_t bad_key_test(memcached_st
*memc
)
495 char *key
= "foo bad";
497 size_t string_length
;
502 clone
= memcached_clone(NULL
, memc
);
505 (void)memcached_behavior_set(clone
, MEMCACHED_BEHAVIOR_VERIFY_KEY
, set
);
507 string
= memcached_get(clone
, key
, strlen(key
),
508 &string_length
, &flags
, &rc
);
509 assert(rc
== MEMCACHED_BAD_KEY_PROVIDED
);
510 assert(string_length
== 0);
514 (void)memcached_behavior_set(clone
, MEMCACHED_BEHAVIOR_VERIFY_KEY
, set
);
515 string
= memcached_get(clone
, key
, strlen(key
),
516 &string_length
, &flags
, &rc
);
517 assert(rc
== MEMCACHED_NOTFOUND
);
518 assert(string_length
== 0);
521 memcached_free(clone
);
526 uint8_t get_test(memcached_st
*memc
)
531 size_t string_length
;
534 rc
= memcached_delete(memc
, key
, strlen(key
), (time_t)0);
535 assert(rc
== MEMCACHED_BUFFERED
|| rc
== MEMCACHED_NOTFOUND
);
537 string
= memcached_get(memc
, key
, strlen(key
),
538 &string_length
, &flags
, &rc
);
540 assert(rc
== MEMCACHED_NOTFOUND
);
541 assert(string_length
== 0);
547 uint8_t get_test2(memcached_st
*memc
)
551 char *value
= "when we sanitize";
553 size_t string_length
;
556 rc
= memcached_set(memc
, key
, strlen(key
),
557 value
, strlen(value
),
558 (time_t)0, (uint32_t)0);
559 assert(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
);
561 string
= memcached_get(memc
, key
, strlen(key
),
562 &string_length
, &flags
, &rc
);
565 assert(rc
== MEMCACHED_SUCCESS
);
566 assert(string_length
== strlen(value
));
567 assert(!memcmp(string
, value
, string_length
));
574 uint8_t set_test2(memcached_st
*memc
)
578 char *value
= "train in the brain";
579 size_t value_length
= strlen(value
);
582 for (x
= 0; x
< 10; x
++)
584 rc
= memcached_set(memc
, key
, strlen(key
),
586 (time_t)0, (uint32_t)0);
587 assert(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
);
593 uint8_t set_test3(memcached_st
*memc
)
598 size_t value_length
= 8191;
601 value
= (char*)malloc(value_length
);
604 for (x
= 0; x
< value_length
; x
++)
605 value
[x
] = (char) (x
% 127);
607 for (x
= 0; x
< 1; x
++)
609 rc
= memcached_set(memc
, key
, strlen(key
),
611 (time_t)0, (uint32_t)0);
612 assert(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
);
620 uint8_t get_test3(memcached_st
*memc
)
625 size_t value_length
= 8191;
627 size_t string_length
;
631 value
= (char*)malloc(value_length
);
634 for (x
= 0; x
< value_length
; x
++)
635 value
[x
] = (char) (x
% 127);
637 rc
= memcached_set(memc
, key
, strlen(key
),
639 (time_t)0, (uint32_t)0);
640 assert(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
);
642 string
= memcached_get(memc
, key
, strlen(key
),
643 &string_length
, &flags
, &rc
);
645 assert(rc
== MEMCACHED_SUCCESS
);
647 assert(string_length
== value_length
);
648 assert(!memcmp(string
, value
, string_length
));
656 uint8_t get_test4(memcached_st
*memc
)
661 size_t value_length
= 8191;
663 size_t string_length
;
667 value
= (char*)malloc(value_length
);
670 for (x
= 0; x
< value_length
; x
++)
671 value
[x
] = (char) (x
% 127);
673 rc
= memcached_set(memc
, key
, strlen(key
),
675 (time_t)0, (uint32_t)0);
676 assert(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
);
678 for (x
= 0; x
< 10; x
++)
680 string
= memcached_get(memc
, key
, strlen(key
),
681 &string_length
, &flags
, &rc
);
683 assert(rc
== MEMCACHED_SUCCESS
);
685 assert(string_length
== value_length
);
686 assert(!memcmp(string
, value
, string_length
));
695 /* Do not copy the style of this code, I just access hosts to testthis function */
696 uint8_t stats_servername_test(memcached_st
*memc
)
699 memcached_stat_st stat
;
700 rc
= memcached_stat_servername(&stat
, NULL
,
701 memc
->hosts
[0].hostname
,
702 memc
->hosts
[0].port
);
707 uint8_t increment_test(memcached_st
*memc
)
714 rc
= memcached_set(memc
, key
, strlen(key
),
715 value
, strlen(value
),
716 (time_t)0, (uint32_t)0);
717 assert(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
);
719 rc
= memcached_increment(memc
, key
, strlen(key
),
721 assert(rc
== MEMCACHED_SUCCESS
);
722 assert(new_number
== 1);
724 rc
= memcached_increment(memc
, key
, strlen(key
),
726 assert(rc
== MEMCACHED_SUCCESS
);
727 assert(new_number
== 2);
732 uint8_t decrement_test(memcached_st
*memc
)
739 rc
= memcached_set(memc
, key
, strlen(key
),
740 value
, strlen(value
),
741 (time_t)0, (uint32_t)0);
742 assert(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
);
744 rc
= memcached_decrement(memc
, key
, strlen(key
),
746 assert(rc
== MEMCACHED_SUCCESS
);
747 assert(new_number
== 2);
749 rc
= memcached_decrement(memc
, key
, strlen(key
),
751 assert(rc
== MEMCACHED_SUCCESS
);
752 assert(new_number
== 1);
757 uint8_t quit_test(memcached_st
*memc
)
761 char *value
= "sanford and sun";
763 rc
= memcached_set(memc
, key
, strlen(key
),
764 value
, strlen(value
),
765 (time_t)10, (uint32_t)3);
766 assert(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
);
767 memcached_quit(memc
);
769 rc
= memcached_set(memc
, key
, strlen(key
),
770 value
, strlen(value
),
771 (time_t)50, (uint32_t)9);
772 assert(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
);
777 uint8_t mget_result_test(memcached_st
*memc
)
780 char *keys
[]= {"fudge", "son", "food"};
781 size_t key_length
[]= {5, 3, 4};
784 memcached_result_st results_obj
;
785 memcached_result_st
*results
;
787 results
= memcached_result_create(memc
, &results_obj
);
789 assert(&results_obj
== results
);
791 /* We need to empty the server before continueing test */
792 rc
= memcached_flush(memc
, 0);
793 assert(rc
== MEMCACHED_SUCCESS
);
795 rc
= memcached_mget(memc
, keys
, key_length
, 3);
796 assert(rc
== MEMCACHED_SUCCESS
);
798 while ((results
= memcached_fetch_result(memc
, &results_obj
, &rc
)) != NULL
)
803 while ((results
= memcached_fetch_result(memc
, &results_obj
, &rc
)) != NULL
)
805 assert(rc
== MEMCACHED_END
);
807 for (x
= 0; x
< 3; x
++)
809 rc
= memcached_set(memc
, keys
[x
], key_length
[x
],
810 keys
[x
], key_length
[x
],
811 (time_t)50, (uint32_t)9);
812 assert(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
);
815 rc
= memcached_mget(memc
, keys
, key_length
, 3);
816 assert(rc
== MEMCACHED_SUCCESS
);
818 while ((results
= memcached_fetch_result(memc
, &results_obj
, &rc
)))
821 assert(&results_obj
== results
);
822 assert(rc
== MEMCACHED_SUCCESS
);
823 assert(memcached_result_key_length(results
) == memcached_result_length(results
));
824 assert(!memcmp(memcached_result_key_value(results
),
825 memcached_result_value(results
),
826 memcached_result_length(results
)));
829 memcached_result_free(&results_obj
);
834 uint8_t mget_result_alloc_test(memcached_st
*memc
)
837 char *keys
[]= {"fudge", "son", "food"};
838 size_t key_length
[]= {5, 3, 4};
841 memcached_result_st
*results
;
843 /* We need to empty the server before continueing test */
844 rc
= memcached_flush(memc
, 0);
845 assert(rc
== MEMCACHED_SUCCESS
);
847 rc
= memcached_mget(memc
, keys
, key_length
, 3);
848 assert(rc
== MEMCACHED_SUCCESS
);
850 while ((results
= memcached_fetch_result(memc
, NULL
, &rc
)) != NULL
)
855 assert(rc
== MEMCACHED_END
);
857 for (x
= 0; x
< 3; x
++)
859 rc
= memcached_set(memc
, keys
[x
], key_length
[x
],
860 keys
[x
], key_length
[x
],
861 (time_t)50, (uint32_t)9);
862 assert(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
);
865 rc
= memcached_mget(memc
, keys
, key_length
, 3);
866 assert(rc
== MEMCACHED_SUCCESS
);
869 while ((results
= memcached_fetch_result(memc
, NULL
, &rc
)))
872 assert(rc
== MEMCACHED_SUCCESS
);
873 assert(memcached_result_key_length(results
) == memcached_result_length(results
));
874 assert(!memcmp(memcached_result_key_value(results
),
875 memcached_result_value(results
),
876 memcached_result_length(results
)));
877 memcached_result_free(results
);
884 /* Count the results */
885 unsigned int callback_counter(memcached_st
*ptr
, memcached_result_st
*result
, void *context
)
887 unsigned int *counter
= (unsigned int *)context
;
889 *counter
= *counter
+ 1;
894 uint8_t mget_result_function(memcached_st
*memc
)
897 char *keys
[]= {"fudge", "son", "food"};
898 size_t key_length
[]= {5, 3, 4};
900 unsigned int counter
;
901 memcached_execute_function callbacks
[1];
903 /* We need to empty the server before continueing test */
904 rc
= memcached_flush(memc
, 0);
905 for (x
= 0; x
< 3; x
++)
907 rc
= memcached_set(memc
, keys
[x
], key_length
[x
],
908 keys
[x
], key_length
[x
],
909 (time_t)50, (uint32_t)9);
910 assert(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
);
913 rc
= memcached_mget(memc
, keys
, key_length
, 3);
914 assert(rc
== MEMCACHED_SUCCESS
);
916 callbacks
[0]= &callback_counter
;
918 rc
= memcached_fetch_execute(memc
, callbacks
, (void *)&counter
, 1);
920 assert(counter
== 3);
925 uint8_t mget_test(memcached_st
*memc
)
928 char *keys
[]= {"fudge", "son", "food"};
929 size_t key_length
[]= {5, 3, 4};
933 char return_key
[MEMCACHED_MAX_KEY
];
934 size_t return_key_length
;
936 size_t return_value_length
;
938 /* We need to empty the server before continueing test */
939 rc
= memcached_flush(memc
, 0);
940 assert(rc
== MEMCACHED_SUCCESS
);
942 rc
= memcached_mget(memc
, keys
, key_length
, 3);
943 assert(rc
== MEMCACHED_SUCCESS
);
945 while ((return_value
= memcached_fetch(memc
, return_key
, &return_key_length
,
946 &return_value_length
, &flags
, &rc
)) != NULL
)
948 assert(return_value
);
950 assert(!return_value
);
951 assert(return_value_length
== 0);
952 assert(rc
== MEMCACHED_END
);
954 for (x
= 0; x
< 3; x
++)
956 rc
= memcached_set(memc
, keys
[x
], key_length
[x
],
957 keys
[x
], key_length
[x
],
958 (time_t)50, (uint32_t)9);
959 assert(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
);
962 rc
= memcached_mget(memc
, keys
, key_length
, 3);
963 assert(rc
== MEMCACHED_SUCCESS
);
966 while ((return_value
= memcached_fetch(memc
, return_key
, &return_key_length
,
967 &return_value_length
, &flags
, &rc
)))
969 assert(return_value
);
970 assert(rc
== MEMCACHED_SUCCESS
);
971 assert(return_key_length
== return_value_length
);
972 assert(!memcmp(return_value
, return_key
, return_value_length
));
980 uint8_t get_stats_keys(memcached_st
*memc
)
984 memcached_stat_st stat
;
987 list
= memcached_stat_get_keys(memc
, &stat
, &rc
);
988 assert(rc
== MEMCACHED_SUCCESS
);
989 for (ptr
= list
; *ptr
; ptr
++)
998 uint8_t version_string_test(memcached_st
*memc
)
1000 const char *version_string
;
1002 version_string
= memcached_lib_version();
1004 assert(!strcmp(version_string
, LIBMEMCACHED_VERSION_STRING
));
1009 uint8_t get_stats(memcached_st
*memc
)
1014 memcached_return rc
;
1015 memcached_stat_st
*stat
;
1017 stat
= memcached_stat(memc
, NULL
, &rc
);
1018 assert(rc
== MEMCACHED_SUCCESS
);
1020 assert(rc
== MEMCACHED_SUCCESS
);
1023 for (x
= 0; x
< memcached_server_count(memc
); x
++)
1025 list
= memcached_stat_get_keys(memc
, stat
+x
, &rc
);
1026 assert(rc
== MEMCACHED_SUCCESS
);
1027 for (ptr
= list
; *ptr
; ptr
++);
1032 memcached_stat_free(NULL
, stat
);
1037 uint8_t add_host_test(memcached_st
*memc
)
1040 memcached_server_st
*servers
;
1041 memcached_return rc
;
1042 char servername
[]= "0.example.com";
1044 servers
= memcached_server_list_append(NULL
, servername
, 400, &rc
);
1046 assert(1 == memcached_server_list_count(servers
));
1048 for (x
= 2; x
< 20; x
++)
1050 char buffer
[SMALL_STRING_LEN
];
1052 snprintf(buffer
, SMALL_STRING_LEN
, "%u.example.com", 400+x
);
1053 servers
= memcached_server_list_append(servers
, buffer
, 401,
1055 assert(rc
== MEMCACHED_SUCCESS
);
1056 assert(x
== memcached_server_list_count(servers
));
1059 rc
= memcached_server_push(memc
, servers
);
1060 assert(rc
== MEMCACHED_SUCCESS
);
1061 rc
= memcached_server_push(memc
, servers
);
1062 assert(rc
== MEMCACHED_SUCCESS
);
1064 memcached_server_list_free(servers
);
1069 memcached_return
clone_test_callback(memcached_st
*parent
, memcached_st
*clone
)
1071 return MEMCACHED_SUCCESS
;
1074 memcached_return
cleanup_test_callback(memcached_st
*ptr
)
1076 return MEMCACHED_SUCCESS
;
1079 uint8_t callback_test(memcached_st
*memc
)
1081 /* Test User Data */
1085 memcached_return rc
;
1087 rc
= memcached_callback_set(memc
, MEMCACHED_CALLBACK_USER_DATA
, &x
);
1088 assert(rc
== MEMCACHED_SUCCESS
);
1089 test_ptr
= (int *)memcached_callback_get(memc
, MEMCACHED_CALLBACK_USER_DATA
, &rc
);
1090 assert(*test_ptr
== x
);
1093 /* Test Clone Callback */
1095 memcached_clone_func temp_function
;
1096 memcached_return rc
;
1098 rc
= memcached_callback_set(memc
, MEMCACHED_CALLBACK_CLONE_FUNCTION
, clone_test_callback
);
1099 assert(rc
== MEMCACHED_SUCCESS
);
1100 temp_function
= (memcached_clone_func
)memcached_callback_get(memc
, MEMCACHED_CALLBACK_CLONE_FUNCTION
, &rc
);
1101 assert(temp_function
== clone_test_callback
);
1104 /* Test Cleanup Callback */
1106 memcached_cleanup_func temp_function
;
1107 memcached_return rc
;
1109 rc
= memcached_callback_set(memc
, MEMCACHED_CALLBACK_CLONE_FUNCTION
, cleanup_test_callback
);
1110 assert(rc
== MEMCACHED_SUCCESS
);
1111 temp_function
= (memcached_cleanup_func
)memcached_callback_get(memc
, MEMCACHED_CALLBACK_CLONE_FUNCTION
, &rc
);
1112 assert(temp_function
== cleanup_test_callback
);
1118 /* We don't test the behavior itself, we test the switches */
1119 uint8_t behavior_test(memcached_st
*memc
)
1121 unsigned long long value
;
1122 unsigned int set
= 1;
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_MD5
;
1133 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_HASH
, set
);
1134 value
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_HASH
);
1135 assert(value
== MEMCACHED_HASH_MD5
);
1139 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NO_BLOCK
, set
);
1140 value
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_NO_BLOCK
);
1143 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_TCP_NODELAY
, set
);
1144 value
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_TCP_NODELAY
);
1147 set
= MEMCACHED_HASH_DEFAULT
;
1148 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_HASH
, set
);
1149 value
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_HASH
);
1150 assert(value
== MEMCACHED_HASH_DEFAULT
);
1152 set
= MEMCACHED_HASH_CRC
;
1153 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_HASH
, set
);
1154 value
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_HASH
);
1155 assert(value
== MEMCACHED_HASH_CRC
);
1157 value
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_SOCKET_SEND_SIZE
);
1160 value
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_SOCKET_RECV_SIZE
);
1166 /* Test case provided by Cal Haldenbrand */
1167 uint8_t user_supplied_bug1(memcached_st
*memc
)
1169 unsigned int setter
= 1;
1172 unsigned long long total
= 0;
1175 char randomstuff
[6 * 1024];
1176 memcached_return rc
;
1178 memset(randomstuff
, 0, 6 * 1024);
1180 /* We just keep looking at the same values over and over */
1183 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NO_BLOCK
, setter
);
1184 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_TCP_NODELAY
, setter
);
1188 for (x
= 0 ; total
< 20 * 1024576 ; x
++ )
1192 size
= (rand() % ( 5 * 1024 ) ) + 400;
1193 memset(randomstuff
, 0, 6 * 1024);
1194 assert(size
< 6 * 1024); /* Being safe here */
1196 for (j
= 0 ; j
< size
;j
++)
1197 randomstuff
[j
] = (char) (rand() % 26) + 97;
1200 sprintf(key
, "%d", x
);
1201 rc
= memcached_set(memc
, key
, strlen(key
),
1202 randomstuff
, strlen(randomstuff
), 10, 0);
1203 /* If we fail, lets try again */
1204 if (rc
!= MEMCACHED_SUCCESS
&& rc
!= MEMCACHED_BUFFERED
)
1205 rc
= memcached_set(memc
, key
, strlen(key
),
1206 randomstuff
, strlen(randomstuff
), 10, 0);
1207 assert(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
);
1213 /* Test case provided by Cal Haldenbrand */
1214 uint8_t user_supplied_bug2(memcached_st
*memc
)
1217 unsigned int setter
;
1219 unsigned long long total
;
1222 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NO_BLOCK
, setter
);
1223 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_TCP_NODELAY
, setter
);
1225 setter
= 20 * 1024576;
1226 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_SOCKET_SEND_SIZE
, setter
);
1227 setter
= 20 * 1024576;
1228 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_SOCKET_RECV_SIZE
, setter
);
1229 getter
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_SOCKET_SEND_SIZE
);
1230 getter
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_SOCKET_RECV_SIZE
);
1232 for (x
= 0, errors
= 0, total
= 0 ; total
< 20 * 1024576 ; x
++)
1235 for (x
= 0, errors
= 0, total
= 0 ; total
< 24576 ; x
++)
1237 memcached_return rc
= MEMCACHED_SUCCESS
;
1238 char buffer
[SMALL_STRING_LEN
];
1243 memset(buffer
, 0, SMALL_STRING_LEN
);
1245 snprintf(buffer
, SMALL_STRING_LEN
, "%u", x
);
1246 getval
= memcached_get(memc
, buffer
, strlen(buffer
),
1247 &val_len
, &flags
, &rc
);
1248 if (rc
!= MEMCACHED_SUCCESS
)
1250 if (rc
== MEMCACHED_NOTFOUND
)
1254 WATCHPOINT_ERROR(rc
);
1268 /* Do a large mget() over all the keys we think exist */
1269 #define KEY_COUNT 3000 // * 1024576
1270 uint8_t user_supplied_bug3(memcached_st
*memc
)
1272 memcached_return rc
;
1273 unsigned int setter
;
1276 size_t key_lengths
[KEY_COUNT
];
1279 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NO_BLOCK
, setter
);
1280 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_TCP_NODELAY
, setter
);
1282 setter
= 20 * 1024576;
1283 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_SOCKET_SEND_SIZE
, setter
);
1284 setter
= 20 * 1024576;
1285 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_SOCKET_RECV_SIZE
, setter
);
1286 getter
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_SOCKET_SEND_SIZE
);
1287 getter
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_SOCKET_RECV_SIZE
);
1290 keys
= (char **)malloc(sizeof(char *) * KEY_COUNT
);
1292 memset(keys
, 0, (sizeof(char *) * KEY_COUNT
));
1293 for (x
= 0; x
< KEY_COUNT
; x
++)
1297 snprintf(buffer
, 30, "%u", x
);
1298 keys
[x
]= strdup(buffer
);
1299 key_lengths
[x
]= strlen(keys
[x
]);
1302 rc
= memcached_mget(memc
, keys
, key_lengths
, KEY_COUNT
);
1303 assert(rc
== MEMCACHED_SUCCESS
);
1305 /* Turn this into a help function */
1307 char return_key
[MEMCACHED_MAX_KEY
];
1308 size_t return_key_length
;
1310 size_t return_value_length
;
1313 while ((return_value
= memcached_fetch(memc
, return_key
, &return_key_length
,
1314 &return_value_length
, &flags
, &rc
)))
1316 assert(return_value
);
1317 assert(rc
== MEMCACHED_SUCCESS
);
1322 for (x
= 0; x
< KEY_COUNT
; x
++)
1329 /* Make sure we behave properly if server list has no values */
1330 uint8_t user_supplied_bug4(memcached_st
*memc
)
1332 memcached_return rc
;
1333 char *keys
[]= {"fudge", "son", "food"};
1334 size_t key_length
[]= {5, 3, 4};
1337 char return_key
[MEMCACHED_MAX_KEY
];
1338 size_t return_key_length
;
1340 size_t return_value_length
;
1342 /* Here we free everything before running a bunch of mget tests */
1344 memcached_server_list_free(memc
->hosts
);
1346 memc
->number_of_hosts
= 0;
1350 /* We need to empty the server before continueing test */
1351 rc
= memcached_flush(memc
, 0);
1352 assert(rc
== MEMCACHED_NO_SERVERS
);
1354 rc
= memcached_mget(memc
, keys
, key_length
, 3);
1355 assert(rc
== MEMCACHED_NO_SERVERS
);
1357 while ((return_value
= memcached_fetch(memc
, return_key
, &return_key_length
,
1358 &return_value_length
, &flags
, &rc
)) != NULL
)
1360 assert(return_value
);
1362 assert(!return_value
);
1363 assert(return_value_length
== 0);
1364 assert(rc
== MEMCACHED_NO_SERVERS
);
1366 for (x
= 0; x
< 3; x
++)
1368 rc
= memcached_set(memc
, keys
[x
], key_length
[x
],
1369 keys
[x
], key_length
[x
],
1370 (time_t)50, (uint32_t)9);
1371 assert(rc
== MEMCACHED_NO_SERVERS
);
1374 rc
= memcached_mget(memc
, keys
, key_length
, 3);
1375 assert(rc
== MEMCACHED_NO_SERVERS
);
1378 while ((return_value
= memcached_fetch(memc
, return_key
, &return_key_length
,
1379 &return_value_length
, &flags
, &rc
)))
1381 assert(return_value
);
1382 assert(rc
== MEMCACHED_SUCCESS
);
1383 assert(return_key_length
== return_value_length
);
1384 assert(!memcmp(return_value
, return_key
, return_value_length
));
1392 #define VALUE_SIZE_BUG5 1048064
1393 uint8_t user_supplied_bug5(memcached_st
*memc
)
1395 memcached_return rc
;
1396 char *keys
[]= {"036790384900", "036790384902", "036790384904", "036790384906"};
1397 size_t key_length
[]= {strlen("036790384900"), strlen("036790384902"), strlen("036790384904"), strlen("036790384906")};
1398 char return_key
[MEMCACHED_MAX_KEY
];
1399 size_t return_key_length
;
1401 size_t value_length
;
1405 char insert_data
[VALUE_SIZE_BUG5
];
1407 for (x
= 0; x
< VALUE_SIZE_BUG5
; x
++)
1408 insert_data
[x
]= rand();
1410 memcached_flush(memc
, 0);
1411 value
= memcached_get(memc
, keys
[0], key_length
[0],
1412 &value_length
, &flags
, &rc
);
1413 assert(value
== NULL
);
1414 rc
= memcached_mget(memc
, keys
, key_length
, 4);
1417 while ((value
= memcached_fetch(memc
, return_key
, &return_key_length
,
1418 &value_length
, &flags
, &rc
)))
1422 for (x
= 0; x
< 4; x
++)
1424 rc
= memcached_set(memc
, keys
[x
], key_length
[x
],
1425 insert_data
, VALUE_SIZE_BUG5
,
1426 (time_t)0, (uint32_t)0);
1427 assert(rc
== MEMCACHED_SUCCESS
);
1430 for (x
= 0; x
< 10; x
++)
1432 value
= memcached_get(memc
, keys
[0], key_length
[0],
1433 &value_length
, &flags
, &rc
);
1437 rc
= memcached_mget(memc
, keys
, key_length
, 4);
1439 while ((value
= memcached_fetch(memc
, return_key
, &return_key_length
,
1440 &value_length
, &flags
, &rc
)))
1451 uint8_t user_supplied_bug6(memcached_st
*memc
)
1453 memcached_return rc
;
1454 char *keys
[]= {"036790384900", "036790384902", "036790384904", "036790384906"};
1455 size_t key_length
[]= {strlen("036790384900"), strlen("036790384902"), strlen("036790384904"), strlen("036790384906")};
1456 char return_key
[MEMCACHED_MAX_KEY
];
1457 size_t return_key_length
;
1459 size_t value_length
;
1463 char insert_data
[VALUE_SIZE_BUG5
];
1465 for (x
= 0; x
< VALUE_SIZE_BUG5
; x
++)
1466 insert_data
[x
]= rand();
1468 memcached_flush(memc
, 0);
1469 value
= memcached_get(memc
, keys
[0], key_length
[0],
1470 &value_length
, &flags
, &rc
);
1471 assert(value
== NULL
);
1472 assert(rc
== MEMCACHED_NOTFOUND
);
1473 rc
= memcached_mget(memc
, keys
, key_length
, 4);
1474 assert(rc
== MEMCACHED_SUCCESS
);
1477 while ((value
= memcached_fetch(memc
, return_key
, &return_key_length
,
1478 &value_length
, &flags
, &rc
)))
1481 assert(rc
== MEMCACHED_END
);
1483 for (x
= 0; x
< 4; x
++)
1485 rc
= memcached_set(memc
, keys
[x
], key_length
[x
],
1486 insert_data
, VALUE_SIZE_BUG5
,
1487 (time_t)0, (uint32_t)0);
1488 assert(rc
== MEMCACHED_SUCCESS
);
1491 for (x
= 0; x
< 2; x
++)
1493 value
= memcached_get(memc
, keys
[0], key_length
[0],
1494 &value_length
, &flags
, &rc
);
1498 rc
= memcached_mget(memc
, keys
, key_length
, 4);
1499 assert(rc
== MEMCACHED_SUCCESS
);
1501 /* We test for purge of partial complete fetches */
1502 for (count
= 3; count
; count
--)
1504 value
= memcached_fetch(memc
, return_key
, &return_key_length
,
1505 &value_length
, &flags
, &rc
);
1506 assert(rc
== MEMCACHED_SUCCESS
);
1507 assert(!(memcmp(value
, insert_data
, value_length
)));
1508 assert(value_length
);
1516 uint8_t user_supplied_bug8(memcached_st
*memc
)
1518 memcached_return rc
;
1520 memcached_st
*clone
;
1522 memcached_server_st
*servers
;
1523 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";
1525 servers
= memcached_servers_parse(server_list
);
1528 mine
= memcached_create(NULL
);
1529 rc
= memcached_server_push(mine
, servers
);
1530 assert(rc
== MEMCACHED_SUCCESS
);
1531 memcached_server_list_free(servers
);
1534 clone
= memcached_clone(NULL
, mine
);
1536 memcached_quit(mine
);
1537 memcached_quit(clone
);
1540 memcached_free(mine
);
1541 memcached_free(clone
);
1546 /* Test flag store/retrieve */
1547 uint8_t user_supplied_bug7(memcached_st
*memc
)
1549 memcached_return rc
;
1550 char *keys
= "036790384900";
1551 size_t key_length
= strlen("036790384900");
1552 char return_key
[MEMCACHED_MAX_KEY
];
1553 size_t return_key_length
;
1555 size_t value_length
;
1558 char insert_data
[VALUE_SIZE_BUG5
];
1560 for (x
= 0; x
< VALUE_SIZE_BUG5
; x
++)
1561 insert_data
[x
]= rand();
1563 memcached_flush(memc
, 0);
1566 rc
= memcached_set(memc
, keys
, key_length
,
1567 insert_data
, VALUE_SIZE_BUG5
,
1569 assert(rc
== MEMCACHED_SUCCESS
);
1572 value
= memcached_get(memc
, keys
, key_length
,
1573 &value_length
, &flags
, &rc
);
1574 assert(flags
== 245);
1578 rc
= memcached_mget(memc
, &keys
, &key_length
, 1);
1581 value
= memcached_fetch(memc
, return_key
, &return_key_length
,
1582 &value_length
, &flags
, &rc
);
1583 assert(flags
== 245);
1591 uint8_t user_supplied_bug9(memcached_st
*memc
)
1593 memcached_return rc
;
1594 char *keys
[]= {"UDATA:edevil@sapo.pt", "fudge&*@#", "for^#@&$not"};
1595 size_t key_length
[3];
1600 char return_key
[MEMCACHED_MAX_KEY
];
1601 size_t return_key_length
;
1603 size_t return_value_length
;
1606 key_length
[0]= strlen("UDATA:edevil@sapo.pt");
1607 key_length
[1]= strlen("fudge&*@#");
1608 key_length
[2]= strlen("for^#@&$not");
1611 for (x
= 0; x
< 3; x
++)
1613 rc
= memcached_set(memc
, keys
[x
], key_length
[x
],
1614 keys
[x
], key_length
[x
],
1615 (time_t)50, (uint32_t)9);
1616 assert(rc
== MEMCACHED_SUCCESS
);
1619 rc
= memcached_mget(memc
, keys
, key_length
, 3);
1620 assert(rc
== MEMCACHED_SUCCESS
);
1622 /* We need to empty the server before continueing test */
1623 while ((return_value
= memcached_fetch(memc
, return_key
, &return_key_length
,
1624 &return_value_length
, &flags
, &rc
)) != NULL
)
1626 assert(return_value
);
1635 /* We are testing with aggressive timeout to get failures */
1636 uint8_t user_supplied_bug10(memcached_st
*memc
)
1640 size_t value_length
= 512;
1643 memcached_return rc
;
1644 unsigned int set
= 1;
1645 memcached_st
*mclone
= memcached_clone(NULL
, memc
);
1648 memcached_behavior_set(mclone
, MEMCACHED_BEHAVIOR_NO_BLOCK
, set
);
1649 memcached_behavior_set(mclone
, MEMCACHED_BEHAVIOR_TCP_NODELAY
, set
);
1651 memcached_behavior_set(mclone
, MEMCACHED_BEHAVIOR_POLL_TIMEOUT
, timeout
);
1653 value
= (char*)malloc(value_length
* sizeof(char));
1655 for (x
= 0; x
< value_length
; x
++)
1656 value
[x
]= (char) (x
% 127);
1658 for (x
= 1; x
<= 100000; ++x
)
1660 rc
= memcached_set(mclone
, key
, key_len
,value
, value_length
, 0, 0);
1662 assert(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_WRITE_FAILURE
|| rc
== MEMCACHED_BUFFERED
);
1664 if (rc
== MEMCACHED_WRITE_FAILURE
)
1669 memcached_free(mclone
);
1675 We are looking failures in the async protocol
1677 uint8_t user_supplied_bug11(memcached_st
*memc
)
1681 size_t value_length
= 512;
1684 memcached_return rc
;
1685 unsigned int set
= 1;
1687 memcached_st
*mclone
= memcached_clone(NULL
, memc
);
1689 memcached_behavior_set(mclone
, MEMCACHED_BEHAVIOR_NO_BLOCK
, set
);
1690 memcached_behavior_set(mclone
, MEMCACHED_BEHAVIOR_TCP_NODELAY
, set
);
1692 memcached_behavior_set(mclone
, MEMCACHED_BEHAVIOR_POLL_TIMEOUT
, timeout
);
1694 timeout
= (int32_t)memcached_behavior_get(mclone
, MEMCACHED_BEHAVIOR_POLL_TIMEOUT
);
1696 assert(timeout
== -1);
1698 value
= (char*)malloc(value_length
* sizeof(char));
1700 for (x
= 0; x
< value_length
; x
++)
1701 value
[x
]= (char) (x
% 127);
1703 for (x
= 1; x
<= 100000; ++x
)
1705 rc
= memcached_set(mclone
, key
, key_len
,value
, value_length
, 0, 0);
1709 memcached_free(mclone
);
1715 Bug found where incr was not returning MEMCACHED_NOTFOUND when object did not exist.
1717 uint8_t user_supplied_bug12(memcached_st
*memc
)
1719 memcached_return rc
;
1721 size_t value_length
;
1723 uint64_t number_value
;
1725 value
= memcached_get(memc
, "autoincrement", strlen("autoincrement"),
1726 &value_length
, &flags
, &rc
);
1727 assert(value
== NULL
);
1728 assert(rc
== MEMCACHED_NOTFOUND
);
1730 rc
= memcached_increment(memc
, "autoincrement", strlen("autoincrement"),
1733 assert(value
== NULL
);
1734 assert(rc
== MEMCACHED_NOTFOUND
);
1736 rc
= memcached_set(memc
, "autoincrement", strlen("autoincrement"), "1", 1, 0, 0);
1738 value
= memcached_get(memc
, "autoincrement", strlen("autoincrement"),
1739 &value_length
, &flags
, &rc
);
1741 assert(rc
== MEMCACHED_SUCCESS
);
1744 rc
= memcached_increment(memc
, "autoincrement", strlen("autoincrement"),
1746 assert(number_value
== 2);
1747 assert(rc
== MEMCACHED_SUCCESS
);
1753 Bug found where command total one more than MEMCACHED_MAX_BUFFER
1754 set key34567890 0 0 8169 \r\n is sent followed by buffer of size 8169, followed by 8169
1756 uint8_t user_supplied_bug13(memcached_st
*memc
)
1758 char key
[] = "key34567890";
1760 memcached_return rc
;
1761 size_t overflowSize
;
1763 char commandFirst
[]= "set key34567890 0 0 ";
1764 char commandLast
[] = " \r\n"; /* first line of command sent to server */
1765 size_t commandLength
;
1768 commandLength
= strlen(commandFirst
) + strlen(commandLast
) + 4; /* 4 is number of characters in size, probably 8196 */
1770 overflowSize
= MEMCACHED_MAX_BUFFER
- commandLength
;
1772 for (testSize
= overflowSize
- 1; testSize
< overflowSize
+ 1; testSize
++)
1774 overflow
= malloc(testSize
);
1775 assert(overflow
!= NULL
);
1777 memset(overflow
, 'x', testSize
);
1778 rc
= memcached_set(memc
, key
, strlen(key
),
1779 overflow
, testSize
, 0, 0);
1780 assert(rc
== MEMCACHED_SUCCESS
);
1789 Test values of many different sizes
1790 Bug found where command total one more than MEMCACHED_MAX_BUFFER
1791 set key34567890 0 0 8169 \r\n
1792 is sent followed by buffer of size 8169, followed by 8169
1794 uint8_t user_supplied_bug14(memcached_st
*memc
)
1797 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_TCP_NODELAY
, setter
);
1798 memcached_return rc
;
1801 size_t value_length
= 18000;
1803 size_t string_length
;
1806 size_t current_length
;
1808 value
= (char*)malloc(value_length
);
1811 for (x
= 0; x
< value_length
; x
++)
1812 value
[x
] = (char) (x
% 127);
1814 for (current_length
= 0; current_length
< value_length
; current_length
++)
1816 rc
= memcached_set(memc
, key
, strlen(key
),
1817 value
, current_length
,
1818 (time_t)0, (uint32_t)0);
1819 assert(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
);
1821 string
= memcached_get(memc
, key
, strlen(key
),
1822 &string_length
, &flags
, &rc
);
1824 assert(rc
== MEMCACHED_SUCCESS
);
1826 assert(string_length
== current_length
);
1827 assert(!memcmp(string
, value
, string_length
));
1838 Look for zero length value problems
1840 uint8_t user_supplied_bug15(memcached_st
*memc
)
1843 memcached_return rc
;
1849 for (x
= 0; x
< 2; x
++)
1851 rc
= memcached_set(memc
, key
, strlen(key
),
1853 (time_t)0, (uint32_t)0);
1855 assert(rc
== MEMCACHED_SUCCESS
);
1857 value
= memcached_get(memc
, key
, strlen(key
),
1858 &length
, &flags
, &rc
);
1860 assert(rc
== MEMCACHED_SUCCESS
);
1861 assert(value
== NULL
);
1862 assert(length
== 0);
1865 value
= memcached_get(memc
, key
, strlen(key
),
1866 &length
, &flags
, &rc
);
1868 assert(rc
== MEMCACHED_SUCCESS
);
1869 assert(value
== NULL
);
1870 assert(length
== 0);
1877 uint8_t result_static(memcached_st
*memc
)
1879 memcached_result_st result
;
1880 memcached_result_st
*result_ptr
;
1882 result_ptr
= memcached_result_create(memc
, &result
);
1883 assert(result
.is_allocated
== MEMCACHED_NOT_ALLOCATED
);
1885 memcached_result_free(&result
);
1890 uint8_t result_alloc(memcached_st
*memc
)
1892 memcached_result_st
*result
;
1894 result
= memcached_result_create(memc
, NULL
);
1896 memcached_result_free(result
);
1901 uint8_t string_static_null(memcached_st
*memc
)
1903 memcached_string_st string
;
1904 memcached_string_st
*string_ptr
;
1906 string_ptr
= memcached_string_create(memc
, &string
, 0);
1907 assert(string
.is_allocated
== MEMCACHED_NOT_ALLOCATED
);
1909 memcached_string_free(&string
);
1914 uint8_t string_alloc_null(memcached_st
*memc
)
1916 memcached_string_st
*string
;
1918 string
= memcached_string_create(memc
, NULL
, 0);
1920 memcached_string_free(string
);
1925 uint8_t string_alloc_with_size(memcached_st
*memc
)
1927 memcached_string_st
*string
;
1929 string
= memcached_string_create(memc
, NULL
, 1024);
1931 memcached_string_free(string
);
1936 uint8_t string_alloc_with_size_toobig(memcached_st
*memc
)
1938 memcached_string_st
*string
;
1940 string
= memcached_string_create(memc
, NULL
, INT64_MAX
);
1941 assert(string
== NULL
);
1946 uint8_t string_alloc_append(memcached_st
*memc
)
1949 char buffer
[SMALL_STRING_LEN
];
1950 memcached_string_st
*string
;
1952 /* Ring the bell! */
1953 memset(buffer
, 6, SMALL_STRING_LEN
);
1955 string
= memcached_string_create(memc
, NULL
, 100);
1958 for (x
= 0; x
< 1024; x
++)
1960 memcached_return rc
;
1961 rc
= memcached_string_append(string
, buffer
, SMALL_STRING_LEN
);
1962 assert(rc
== MEMCACHED_SUCCESS
);
1964 memcached_string_free(string
);
1969 uint8_t string_alloc_append_toobig(memcached_st
*memc
)
1971 memcached_return rc
;
1973 char buffer
[SMALL_STRING_LEN
];
1974 memcached_string_st
*string
;
1976 /* Ring the bell! */
1977 memset(buffer
, 6, SMALL_STRING_LEN
);
1979 string
= memcached_string_create(memc
, NULL
, 100);
1982 for (x
= 0; x
< 1024; x
++)
1984 rc
= memcached_string_append(string
, buffer
, SMALL_STRING_LEN
);
1985 assert(rc
== MEMCACHED_SUCCESS
);
1987 rc
= memcached_string_append(string
, buffer
, INT64_MAX
);
1988 assert(rc
== MEMCACHED_MEMORY_ALLOCATION_FAILURE
);
1989 memcached_string_free(string
);
1994 uint8_t cleanup_pairs(memcached_st
*memc
)
1996 pairs_free(global_pairs
);
2001 uint8_t generate_pairs(memcached_st
*memc
)
2003 unsigned long long x
;
2004 global_pairs
= pairs_generate(GLOBAL_COUNT
, 400);
2005 global_count
= GLOBAL_COUNT
;
2007 for (x
= 0; x
< global_count
; x
++)
2009 global_keys
[x
]= global_pairs
[x
].key
;
2010 global_keys_length
[x
]= global_pairs
[x
].key_length
;
2016 uint8_t generate_large_pairs(memcached_st
*memc
)
2018 unsigned long long x
;
2019 global_pairs
= pairs_generate(GLOBAL2_COUNT
, MEMCACHED_MAX_BUFFER
+10);
2020 global_count
= GLOBAL2_COUNT
;
2022 for (x
= 0; x
< global_count
; x
++)
2024 global_keys
[x
]= global_pairs
[x
].key
;
2025 global_keys_length
[x
]= global_pairs
[x
].key_length
;
2031 uint8_t generate_data(memcached_st
*memc
)
2033 execute_set(memc
, global_pairs
, global_count
);
2038 uint8_t generate_buffer_data(memcached_st
*memc
)
2043 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_BUFFER_REQUESTS
, latch
);
2044 generate_data(memc
);
2049 uint8_t get_read(memcached_st
*memc
)
2052 memcached_return rc
;
2056 size_t return_value_length
;
2059 for (x
= 0; x
< global_count
; x
++)
2061 return_value
= memcached_get(memc
, global_keys
[x
], global_keys_length
[x
],
2062 &return_value_length
, &flags
, &rc
);
2064 assert(return_value);
2065 assert(rc == MEMCACHED_SUCCESS);
2067 if (rc
== MEMCACHED_SUCCESS
&& return_value
)
2075 uint8_t mget_read(memcached_st
*memc
)
2077 memcached_return rc
;
2079 rc
= memcached_mget(memc
, global_keys
, global_keys_length
, global_count
);
2080 assert(rc
== MEMCACHED_SUCCESS
);
2081 /* Turn this into a help function */
2083 char return_key
[MEMCACHED_MAX_KEY
];
2084 size_t return_key_length
;
2086 size_t return_value_length
;
2089 while ((return_value
= memcached_fetch(memc
, return_key
, &return_key_length
,
2090 &return_value_length
, &flags
, &rc
)))
2092 assert(return_value
);
2093 assert(rc
== MEMCACHED_SUCCESS
);
2101 uint8_t mget_read_result(memcached_st
*memc
)
2103 memcached_return rc
;
2105 rc
= memcached_mget(memc
, global_keys
, global_keys_length
, global_count
);
2106 assert(rc
== MEMCACHED_SUCCESS
);
2107 /* Turn this into a help function */
2109 memcached_result_st results_obj
;
2110 memcached_result_st
*results
;
2112 results
= memcached_result_create(memc
, &results_obj
);
2114 while ((results
= memcached_fetch_result(memc
, &results_obj
, &rc
)))
2117 assert(rc
== MEMCACHED_SUCCESS
);
2120 memcached_result_free(&results_obj
);
2126 uint8_t mget_read_function(memcached_st
*memc
)
2128 memcached_return rc
;
2129 unsigned int counter
;
2130 unsigned int (*callbacks
[1])(memcached_st
*, memcached_result_st
*, void *);
2132 rc
= memcached_mget(memc
, global_keys
, global_keys_length
, global_count
);
2133 assert(rc
== MEMCACHED_SUCCESS
);
2135 callbacks
[0]= &callback_counter
;
2137 rc
= memcached_fetch_execute(memc
, callbacks
, (void *)&counter
, 1);
2142 uint8_t delete_generate(memcached_st
*memc
)
2146 for (x
= 0; x
< global_count
; x
++)
2148 (void)memcached_delete(memc
, global_keys
[x
], global_keys_length
[x
], (time_t)0);
2154 uint8_t delete_buffer_generate(memcached_st
*memc
)
2160 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_BUFFER_REQUESTS
, latch
);
2162 for (x
= 0; x
< global_count
; x
++)
2164 (void)memcached_delete(memc
, global_keys
[x
], global_keys_length
[x
], (time_t)0);
2170 uint8_t free_data(memcached_st
*memc
)
2172 pairs_free(global_pairs
);
2177 uint8_t add_host_test1(memcached_st
*memc
)
2180 memcached_return rc
;
2181 char servername
[]= "0.example.com";
2182 memcached_server_st
*servers
;
2184 servers
= memcached_server_list_append(NULL
, servername
, 400, &rc
);
2186 assert(1 == memcached_server_list_count(servers
));
2188 for (x
= 2; x
< 20; x
++)
2190 char buffer
[SMALL_STRING_LEN
];
2192 snprintf(buffer
, SMALL_STRING_LEN
, "%u.example.com", 400+x
);
2193 servers
= memcached_server_list_append(servers
, buffer
, 401,
2195 assert(rc
== MEMCACHED_SUCCESS
);
2196 assert(x
== memcached_server_list_count(servers
));
2199 rc
= memcached_server_push(memc
, servers
);
2200 assert(rc
== MEMCACHED_SUCCESS
);
2201 rc
= memcached_server_push(memc
, servers
);
2202 assert(rc
== MEMCACHED_SUCCESS
);
2204 memcached_server_list_free(servers
);
2209 memcached_return
pre_nonblock(memcached_st
*memc
)
2211 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NO_BLOCK
, 0);
2213 return MEMCACHED_SUCCESS
;
2216 memcached_return
pre_murmur(memcached_st
*memc
)
2218 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_HASH
, (uint64_t)MEMCACHED_HASH_MURMUR
);
2220 return MEMCACHED_SUCCESS
;
2223 memcached_return
pre_md5(memcached_st
*memc
)
2225 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_HASH
, (uint64_t)MEMCACHED_HASH_MD5
);
2227 return MEMCACHED_SUCCESS
;
2230 memcached_return
pre_crc(memcached_st
*memc
)
2232 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_HASH
, (uint64_t)MEMCACHED_HASH_CRC
);
2234 return MEMCACHED_SUCCESS
;
2237 memcached_return
pre_hsieh(memcached_st
*memc
)
2239 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_HASH
, (uint64_t)MEMCACHED_HASH_HSIEH
);
2241 return MEMCACHED_SUCCESS
;
2244 memcached_return
pre_hash_fnv1_64(memcached_st
*memc
)
2246 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_HASH
, (uint64_t)MEMCACHED_HASH_FNV1_64
);
2248 return MEMCACHED_SUCCESS
;
2251 memcached_return
pre_hash_fnv1a_64(memcached_st
*memc
)
2253 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_HASH
, (uint64_t)MEMCACHED_HASH_FNV1A_64
);
2255 return MEMCACHED_SUCCESS
;
2258 memcached_return
pre_hash_fnv1_32(memcached_st
*memc
)
2260 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_HASH
, (uint64_t)MEMCACHED_HASH_FNV1_32
);
2262 return MEMCACHED_SUCCESS
;
2265 memcached_return
pre_hash_fnv1a_32(memcached_st
*memc
)
2267 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_HASH
, (uint64_t)MEMCACHED_HASH_FNV1A_32
);
2269 return MEMCACHED_SUCCESS
;
2272 memcached_return
pre_hash_ketama(memcached_st
*memc
)
2274 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_HASH
, (uint64_t)MEMCACHED_HASH_KETAMA
);
2276 return MEMCACHED_SUCCESS
;
2279 void my_free(memcached_st
*ptr
, void *mem
)
2284 void *my_malloc(memcached_st
*ptr
, const size_t size
)
2286 return malloc(size
);
2289 void *my_realloc(memcached_st
*ptr
, void *mem
, const size_t size
)
2291 return realloc(mem
, size
);
2294 memcached_return
set_memory_alloc(memcached_st
*memc
)
2297 memcached_malloc_function test_ptr
;
2298 memcached_return rc
;
2300 rc
= memcached_callback_set(memc
, MEMCACHED_CALLBACK_MALLOC_FUNCTION
, &my_malloc
);
2301 assert(rc
== MEMCACHED_SUCCESS
);
2302 test_ptr
= (memcached_malloc_function
)memcached_callback_get(memc
, MEMCACHED_CALLBACK_MALLOC_FUNCTION
, &rc
);
2303 assert(rc
== MEMCACHED_SUCCESS
);
2304 assert(test_ptr
== my_malloc
);
2308 memcached_realloc_function test_ptr
;
2309 memcached_return rc
;
2311 rc
= memcached_callback_set(memc
, MEMCACHED_CALLBACK_REALLOC_FUNCTION
, &my_realloc
);
2312 assert(rc
== MEMCACHED_SUCCESS
);
2313 test_ptr
= (memcached_realloc_function
)memcached_callback_get(memc
, MEMCACHED_CALLBACK_REALLOC_FUNCTION
, &rc
);
2314 assert(rc
== MEMCACHED_SUCCESS
);
2315 assert(test_ptr
== my_realloc
);
2319 memcached_free_function test_ptr
;
2320 memcached_return rc
;
2322 rc
= memcached_callback_set(memc
, MEMCACHED_CALLBACK_FREE_FUNCTION
, my_free
);
2323 assert(rc
== MEMCACHED_SUCCESS
);
2324 test_ptr
= (memcached_free_function
)memcached_callback_get(memc
, MEMCACHED_CALLBACK_FREE_FUNCTION
, &rc
);
2325 assert(rc
== MEMCACHED_SUCCESS
);
2326 assert(test_ptr
== my_free
);
2329 return MEMCACHED_SUCCESS
;
2332 memcached_return
enable_consistent(memcached_st
*memc
)
2334 memcached_server_distribution value
= MEMCACHED_DISTRIBUTION_CONSISTENT
;
2335 memcached_hash hash
;
2336 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_DISTRIBUTION
, value
);
2339 value
= (memcached_server_distribution
)memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_DISTRIBUTION
);
2340 assert(value
== MEMCACHED_DISTRIBUTION_CONSISTENT
);
2342 hash
= (memcached_hash
)memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_HASH
);
2343 assert(hash
== MEMCACHED_HASH_HSIEH
);
2346 return MEMCACHED_SUCCESS
;
2349 memcached_return
enable_cas(memcached_st
*memc
)
2351 unsigned int set
= 1;
2353 memcached_version(memc
);
2355 if (memc
->hosts
[0].major_version
>= 1 &&
2356 memc
->hosts
[0].minor_version
>= 2 &&
2357 memc
->hosts
[0].micro_version
>= 4)
2359 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_SUPPORT_CAS
, set
);
2361 return MEMCACHED_SUCCESS
;
2364 return MEMCACHED_FAILURE
;
2367 memcached_return
check_for_1_2_3(memcached_st
*memc
)
2369 memcached_version(memc
);
2371 if (memc
->hosts
[0].major_version
>= 1 &&
2372 memc
->hosts
[0].minor_version
>= 2 &&
2373 memc
->hosts
[0].micro_version
>= 4)
2374 return MEMCACHED_SUCCESS
;
2376 return MEMCACHED_FAILURE
;
2379 memcached_return
pre_unix_socket(memcached_st
*memc
)
2381 memcached_return rc
;
2384 memcached_server_list_free(memc
->hosts
);
2386 memc
->number_of_hosts
= 0;
2388 if (stat("/tmp/memcached.socket", &buf
))
2389 return MEMCACHED_FAILURE
;
2391 rc
= memcached_server_add_unix_socket(memc
, "/tmp/memcached.socket");
2396 memcached_return
pre_udp(memcached_st
*memc
)
2398 memcached_return rc
;
2400 memcached_server_list_free(memc
->hosts
);
2402 memc
->number_of_hosts
= 0;
2405 return MEMCACHED_FAILURE
;
2407 rc
= memcached_server_add_udp(memc
, "localhost", MEMCACHED_DEFAULT_PORT
);
2412 memcached_return
pre_nodelay(memcached_st
*memc
)
2414 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NO_BLOCK
, 0);
2415 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_TCP_NODELAY
, 0);
2417 return MEMCACHED_SUCCESS
;
2420 memcached_return
poll_timeout(memcached_st
*memc
)
2426 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_POLL_TIMEOUT
, timeout
);
2428 timeout
= (int32_t)memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_POLL_TIMEOUT
);
2430 assert(timeout
== 100);
2432 return MEMCACHED_SUCCESS
;
2436 /* Clean the server before beginning testing */
2438 {"flush", 0, flush_test
},
2439 {"init", 0, init_test
},
2440 {"allocation", 0, allocation_test
},
2441 {"server_list_null_test", 0, server_list_null_test
},
2442 {"server_sort", 0, server_sort_test
},
2443 {"clone_test", 0, clone_test
},
2444 {"error", 0, error_test
},
2445 {"set", 0, set_test
},
2446 {"set2", 0, set_test2
},
2447 {"set3", 0, set_test3
},
2448 {"add", 1, add_test
},
2449 {"replace", 1, replace_test
},
2450 {"delete", 1, delete_test
},
2451 {"get", 1, get_test
},
2452 {"get2", 0, get_test2
},
2453 {"get3", 0, get_test3
},
2454 {"get4", 0, get_test4
},
2455 {"stats_servername", 0, stats_servername_test
},
2456 {"increment", 0, increment_test
},
2457 {"decrement", 0, decrement_test
},
2458 {"quit", 0, quit_test
},
2459 {"mget", 1, mget_test
},
2460 {"mget_result", 1, mget_result_test
},
2461 {"mget_result_alloc", 1, mget_result_alloc_test
},
2462 {"mget_result_function", 1, mget_result_function
},
2463 {"get_stats", 0, get_stats
},
2464 {"add_host_test", 0, add_host_test
},
2465 {"get_stats_keys", 0, get_stats_keys
},
2466 {"behavior_test", 0, get_stats_keys
},
2467 {"callback_test", 0, get_stats_keys
},
2468 {"version_string_test", 0, version_string_test
},
2469 {"bad_key", 1, bad_key_test
},
2470 {"memcached_server_cursor", 1, memcached_server_cursor_test
},
2474 test_st async_tests
[] ={
2475 {"add", 1, add_wrapper
},
2479 test_st string_tests
[] ={
2480 {"string static with null", 0, string_static_null
},
2481 {"string alloc with null", 0, string_alloc_null
},
2482 {"string alloc with 1K", 0, string_alloc_with_size
},
2483 {"string alloc with malloc failure", 0, string_alloc_with_size_toobig
},
2484 {"string append", 0, string_alloc_append
},
2485 {"string append failure (too big)", 0, string_alloc_append_toobig
},
2489 test_st result_tests
[] ={
2490 {"result static", 0, result_static
},
2491 {"result alloc", 0, result_alloc
},
2495 test_st version_1_2_3
[] ={
2496 {"append", 0, append_test
},
2497 {"prepend", 0, prepend_test
},
2498 {"cas", 0, cas_test
},
2499 {"cas2", 0, cas2_test
},
2500 {"append_binary", 0, append_binary_test
},
2504 test_st user_tests
[] ={
2505 {"user_supplied_bug1", 0, user_supplied_bug1
},
2506 {"user_supplied_bug2", 0, user_supplied_bug2
},
2507 {"user_supplied_bug3", 0, user_supplied_bug3
},
2508 {"user_supplied_bug4", 0, user_supplied_bug4
},
2509 {"user_supplied_bug5", 1, user_supplied_bug5
},
2510 {"user_supplied_bug6", 1, user_supplied_bug6
},
2511 {"user_supplied_bug7", 1, user_supplied_bug7
},
2512 {"user_supplied_bug8", 1, user_supplied_bug8
},
2513 {"user_supplied_bug9", 1, user_supplied_bug9
},
2514 {"user_supplied_bug10", 1, user_supplied_bug10
},
2515 {"user_supplied_bug11", 1, user_supplied_bug11
},
2516 {"user_supplied_bug12", 1, user_supplied_bug12
},
2517 {"user_supplied_bug13", 1, user_supplied_bug13
},
2518 {"user_supplied_bug14", 1, user_supplied_bug14
},
2519 {"user_supplied_bug15", 1, user_supplied_bug15
},
2523 test_st generate_tests
[] ={
2524 {"generate_pairs", 1, generate_pairs
},
2525 {"generate_data", 1, generate_data
},
2526 {"get_read", 0, get_read
},
2527 {"delete_generate", 0, delete_generate
},
2528 {"generate_buffer_data", 1, generate_buffer_data
},
2529 {"delete_buffer", 0, delete_buffer_generate
},
2530 {"generate_data", 1, generate_data
},
2531 {"mget_read", 0, mget_read
},
2532 {"mget_read_result", 0, mget_read_result
},
2533 {"mget_read_function", 0, mget_read_function
},
2534 {"cleanup", 1, cleanup_pairs
},
2535 {"generate_large_pairs", 1, generate_large_pairs
},
2536 {"generate_data", 1, generate_data
},
2537 {"generate_buffer_data", 1, generate_buffer_data
},
2538 {"cleanup", 1, cleanup_pairs
},
2543 collection_st collection
[] ={
2544 {"block", 0, 0, tests
},
2545 {"nonblock", pre_nonblock
, 0, tests
},
2546 {"nodelay", pre_nodelay
, 0, tests
},
2547 {"md5", pre_md5
, 0, tests
},
2548 {"crc", pre_crc
, 0, tests
},
2549 {"hsieh", pre_hsieh
, 0, tests
},
2550 {"fnv1_64", pre_hash_fnv1_64
, 0, tests
},
2551 {"fnv1a_64", pre_hash_fnv1a_64
, 0, tests
},
2552 {"fnv1_32", pre_hash_fnv1_32
, 0, tests
},
2553 {"fnv1a_32", pre_hash_fnv1a_32
, 0, tests
},
2554 {"ketama", pre_hash_ketama
, 0, tests
},
2555 {"unix_socket", pre_unix_socket
, 0, tests
},
2556 {"unix_socket_nodelay", pre_nodelay
, 0, tests
},
2557 {"poll_timeout", poll_timeout
, 0, tests
},
2558 {"gets", enable_cas
, 0, tests
},
2559 {"consistent", enable_consistent
, 0, tests
},
2560 {"memory_allocators", set_memory_alloc
, 0, tests
},
2561 // {"udp", pre_udp, 0, tests},
2562 {"version_1_2_3", check_for_1_2_3
, 0, version_1_2_3
},
2563 {"string", 0, 0, string_tests
},
2564 {"result", 0, 0, result_tests
},
2565 {"async", pre_nonblock
, 0, async_tests
},
2566 {"user", 0, 0, user_tests
},
2567 {"generate", 0, 0, generate_tests
},
2568 {"generate_hsieh", pre_hsieh
, 0, generate_tests
},
2569 {"generate_hsieh_consistent", enable_consistent
, 0, generate_tests
},
2570 {"generate_md5", pre_md5
, 0, generate_tests
},
2571 {"generate_murmur", pre_murmur
, 0, generate_tests
},
2572 {"generate_nonblock", pre_nonblock
, 0, generate_tests
},
2576 #define SERVERS_TO_CREATE 5
2578 void *world_create(void)
2580 server_startup_st
*construct
;
2582 construct
= (server_startup_st
*)malloc(sizeof(server_startup_st
));
2583 memset(construct
, 0, sizeof(server_startup_st
));
2584 construct
->count
= SERVERS_TO_CREATE
;
2586 server_startup(construct
);
2591 void world_destroy(void *p
)
2593 server_startup_st
*construct
= (server_startup_st
*)p
;
2594 memcached_server_st
*servers
= (memcached_server_st
*)construct
->servers
;
2595 memcached_server_list_free(servers
);
2597 server_shutdown(construct
);
2601 void get_world(world_st
*world
)
2603 world
->collections
= collection
;
2604 world
->create
= world_create
;
2605 world
->destroy
= world_destroy
;