2 Sample test application.
14 #include "../clients/generator.h"
15 #include "../clients/execute.h"
18 #define INT64_MAX LONG_MAX
21 #define INT32_MAX INT_MAX
27 #define GLOBAL_COUNT 100000
28 #define GLOBAL2_COUNT 1000
29 static uint32_t global_count
;
31 static pairs_st
*global_pairs
;
32 static char *global_keys
[GLOBAL_COUNT
];
33 static size_t global_keys_length
[GLOBAL_COUNT
];
35 uint8_t init_test(memcached_st
*not_used
)
39 (void)memcached_create(&memc
);
40 memcached_free(&memc
);
45 uint8_t server_list_null_test(memcached_st
*ptr
)
47 memcached_server_st
*server_list
;
50 server_list
= memcached_server_list_append(NULL
, NULL
, 0, NULL
);
51 assert(server_list
== NULL
);
53 server_list
= memcached_server_list_append(NULL
, "localhost", 0, NULL
);
54 assert(server_list
== NULL
);
56 server_list
= memcached_server_list_append(NULL
, NULL
, 0, &rc
);
57 assert(server_list
== NULL
);
62 #define TEST_PORT_COUNT 7
63 uint32_t test_ports
[TEST_PORT_COUNT
];
65 memcached_return
server_display_function(memcached_st
*ptr
, memcached_server_st
*server
, void *context
)
68 uint32_t *bigger
= (uint32_t *)context
;
69 assert(*bigger
<= server
->port
);
71 return MEMCACHED_SUCCESS
;
74 uint8_t server_sort_test(memcached_st
*ptr
)
77 uint32_t bigger
= 0; /* Prime the value for the assert in server_display_function */
79 memcached_server_function callbacks
[1];
80 memcached_st
*local_memc
;
82 local_memc
= memcached_create(NULL
);
84 memcached_behavior_set(local_memc
, MEMCACHED_BEHAVIOR_SORT_HOSTS
, 1);
86 for (x
= 0; x
< TEST_PORT_COUNT
; x
++)
88 test_ports
[x
]= random() % 64000;
89 rc
= memcached_server_add(local_memc
, "localhost", test_ports
[x
]);
90 assert(rc
== MEMCACHED_SUCCESS
);
93 callbacks
[0]= server_display_function
;
94 memcached_server_cursor(local_memc
, callbacks
, (void *)&bigger
, 1);
97 memcached_free(local_memc
);
102 uint8_t allocation_test(memcached_st
*not_used
)
105 memc
= memcached_create(NULL
);
107 memcached_free(memc
);
112 uint8_t clone_test(memcached_st
*memc
)
117 clone
= memcached_clone(NULL
, NULL
);
119 memcached_free(clone
);
122 /* Can we init from null? */
125 clone
= memcached_clone(NULL
, memc
);
127 memcached_free(clone
);
130 /* Can we init from struct? */
132 memcached_st declared_clone
;
134 clone
= memcached_clone(&declared_clone
, NULL
);
136 memcached_free(clone
);
139 /* Can we init from struct? */
141 memcached_st declared_clone
;
143 clone
= memcached_clone(&declared_clone
, memc
);
145 memcached_free(clone
);
151 uint8_t connection_test(memcached_st
*memc
)
155 rc
= memcached_server_add(memc
, "localhost", 0);
156 assert(rc
== MEMCACHED_SUCCESS
);
161 uint8_t error_test(memcached_st
*memc
)
165 for (rc
= MEMCACHED_SUCCESS
; rc
< MEMCACHED_MAXIMUM_RETURN
; rc
++)
167 printf("Error %d -> %s\n", rc
, memcached_strerror(memc
, rc
));
173 uint8_t set_test(memcached_st
*memc
)
177 char *value
= "when we sanitize";
179 rc
= memcached_set(memc
, key
, strlen(key
),
180 value
, strlen(value
),
181 (time_t)0, (uint32_t)0);
182 assert(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
);
187 uint8_t append_test(memcached_st
*memc
)
195 rc
= memcached_flush(memc
, 0);
196 assert(rc
== MEMCACHED_SUCCESS
);
198 rc
= memcached_set(memc
, key
, strlen(key
),
199 value
, strlen(value
),
200 (time_t)0, (uint32_t)0);
201 assert(rc
== MEMCACHED_SUCCESS
);
203 rc
= memcached_append(memc
, key
, strlen(key
),
204 " the", strlen(" the"),
205 (time_t)0, (uint32_t)0);
206 assert(rc
== MEMCACHED_SUCCESS
);
208 rc
= memcached_append(memc
, key
, strlen(key
),
209 " people", strlen(" people"),
210 (time_t)0, (uint32_t)0);
211 assert(rc
== MEMCACHED_SUCCESS
);
213 value
= memcached_get(memc
, key
, strlen(key
),
214 &value_length
, &flags
, &rc
);
215 assert(!memcmp(value
, "we the people", strlen("we the people")));
216 assert(strlen("we the people") == value_length
);
217 assert(rc
== MEMCACHED_SUCCESS
);
223 uint8_t append_binary_test(memcached_st
*memc
)
226 char *key
= "numbers";
227 unsigned int *store_ptr
;
228 unsigned int store_list
[] = { 23, 56, 499, 98, 32847, 0 };
234 rc
= memcached_flush(memc
, 0);
235 assert(rc
== MEMCACHED_SUCCESS
);
237 rc
= memcached_set(memc
,
240 (time_t)0, (uint32_t)0);
241 assert(rc
== MEMCACHED_SUCCESS
);
243 for (x
= 0; store_list
[x
] ; x
++)
245 rc
= memcached_append(memc
,
247 (char *)&store_list
[x
], sizeof(unsigned int),
248 (time_t)0, (uint32_t)0);
249 assert(rc
== MEMCACHED_SUCCESS
);
252 value
= memcached_get(memc
, key
, strlen(key
),
253 &value_length
, &flags
, &rc
);
254 assert((value_length
== (sizeof(unsigned int) * x
)));
255 assert(rc
== MEMCACHED_SUCCESS
);
257 store_ptr
= (unsigned int *)value
;
259 while ((size_t)store_ptr
< (size_t)(value
+ value_length
))
261 assert(*store_ptr
== store_list
[x
++]);
269 uint8_t cas2_test(memcached_st
*memc
)
272 char *keys
[]= {"fudge", "son", "food"};
273 size_t key_length
[]= {5, 3, 4};
274 char *value
= "we the people";
275 size_t value_length
= strlen("we the people");
277 memcached_result_st results_obj
;
278 memcached_result_st
*results
;
281 rc
= memcached_flush(memc
, 0);
282 assert(rc
== MEMCACHED_SUCCESS
);
284 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_SUPPORT_CAS
, set
);
286 for (x
= 0; x
< 3; x
++)
288 rc
= memcached_set(memc
, keys
[x
], key_length
[x
],
289 keys
[x
], key_length
[x
],
290 (time_t)50, (uint32_t)9);
291 assert(rc
== MEMCACHED_SUCCESS
);
294 rc
= memcached_mget(memc
, keys
, key_length
, 3);
296 results
= memcached_result_create(memc
, &results_obj
);
298 results
= memcached_fetch_result(memc
, &results_obj
, &rc
);
300 assert(results
->cas
);
301 assert(rc
== MEMCACHED_SUCCESS
);
302 WATCHPOINT_ASSERT(memcached_result_cas(results
));
304 assert(!memcmp(value
, "we the people", strlen("we the people")));
305 assert(strlen("we the people") == value_length
);
306 assert(rc
== MEMCACHED_SUCCESS
);
308 memcached_result_free(&results_obj
);
313 uint8_t cas_test(memcached_st
*memc
)
317 size_t key_length
= strlen("fun");
318 char *value
= "we the people";
319 size_t value_length
= strlen("we the people");
320 memcached_result_st results_obj
;
321 memcached_result_st
*results
;
324 rc
= memcached_flush(memc
, 0);
325 assert(rc
== MEMCACHED_SUCCESS
);
327 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_SUPPORT_CAS
, set
);
329 rc
= memcached_set(memc
, key
, strlen(key
),
330 value
, strlen(value
),
331 (time_t)0, (uint32_t)0);
332 assert(rc
== MEMCACHED_SUCCESS
);
334 rc
= memcached_mget(memc
, &key
, &key_length
, 1);
336 results
= memcached_result_create(memc
, &results_obj
);
338 results
= memcached_fetch_result(memc
, &results_obj
, &rc
);
340 assert(rc
== MEMCACHED_SUCCESS
);
341 WATCHPOINT_ASSERT(memcached_result_cas(results
));
343 assert(!memcmp(value
, "we the people", strlen("we the people")));
344 assert(strlen("we the people") == value_length
);
345 assert(rc
== MEMCACHED_SUCCESS
);
347 rc
= memcached_cas(memc
, key
, key_length
,
348 "change the value", strlen("change the value"),
349 0, 0, memcached_result_cas(results
));
351 assert(rc
== MEMCACHED_SUCCESS
);
353 rc
= memcached_cas(memc
, key
, key_length
,
354 "change the value", strlen("change the value"),
357 assert(rc
== MEMCACHED_DATA_EXISTS
);
360 memcached_result_free(&results_obj
);
365 uint8_t prepend_test(memcached_st
*memc
)
369 char *value
= "people";
373 rc
= memcached_flush(memc
, 0);
374 assert(rc
== MEMCACHED_SUCCESS
);
376 rc
= memcached_set(memc
, key
, strlen(key
),
377 value
, strlen(value
),
378 (time_t)0, (uint32_t)0);
379 assert(rc
== MEMCACHED_SUCCESS
);
381 rc
= memcached_prepend(memc
, key
, strlen(key
),
382 "the ", strlen("the "),
383 (time_t)0, (uint32_t)0);
384 assert(rc
== MEMCACHED_SUCCESS
);
386 rc
= memcached_prepend(memc
, key
, strlen(key
),
387 "we ", strlen("we "),
388 (time_t)0, (uint32_t)0);
389 assert(rc
== MEMCACHED_SUCCESS
);
391 value
= memcached_get(memc
, key
, strlen(key
),
392 &value_length
, &flags
, &rc
);
393 assert(!memcmp(value
, "we the people", strlen("we the people")));
394 assert(strlen("we the people") == value_length
);
395 assert(rc
== MEMCACHED_SUCCESS
);
402 Set the value, then quit to make sure it is flushed.
403 Come back in and test that add fails.
405 uint8_t add_test(memcached_st
*memc
)
409 char *value
= "when we sanitize";
410 unsigned long long setting_value
;
412 setting_value
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_NO_BLOCK
);
414 rc
= memcached_set(memc
, key
, strlen(key
),
415 value
, strlen(value
),
416 (time_t)0, (uint32_t)0);
417 assert(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
);
418 memcached_quit(memc
);
419 rc
= memcached_add(memc
, key
, strlen(key
),
420 value
, strlen(value
),
421 (time_t)0, (uint32_t)0);
423 /* Too many broken OS'es have broken loopback in async, so we can't be sure of the result */
425 assert(rc
== MEMCACHED_NOTSTORED
|| MEMCACHED_STORED
);
427 assert(rc
== MEMCACHED_NOTSTORED
);
432 uint8_t add_wrapper(memcached_st
*memc
)
436 for (x
= 0; x
< 10000; x
++)
442 uint8_t replace_test(memcached_st
*memc
)
446 char *value
= "when we sanitize";
447 char *original
= "first we insert some data";
449 rc
= memcached_set(memc
, key
, strlen(key
),
450 original
, strlen(original
),
451 (time_t)0, (uint32_t)0);
452 assert(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
);
454 rc
= memcached_replace(memc
, key
, strlen(key
),
455 value
, strlen(value
),
456 (time_t)0, (uint32_t)0);
457 assert(rc
== MEMCACHED_SUCCESS
);
462 uint8_t delete_test(memcached_st
*memc
)
466 char *value
= "when we sanitize";
468 rc
= memcached_set(memc
, key
, strlen(key
),
469 value
, strlen(value
),
470 (time_t)0, (uint32_t)0);
471 assert(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
);
473 rc
= memcached_delete(memc
, key
, strlen(key
), (time_t)0);
474 assert(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
);
479 uint8_t flush_test(memcached_st
*memc
)
483 rc
= memcached_flush(memc
, 0);
484 assert(rc
== MEMCACHED_SUCCESS
);
489 memcached_return
server_function(memcached_st
*ptr
, memcached_server_st
*server
, void *context
)
493 return MEMCACHED_SUCCESS
;
496 uint8_t memcached_server_cursor_test(memcached_st
*memc
)
498 char *context
= "foo bad";
499 memcached_server_function callbacks
[1];
501 callbacks
[0]= server_function
;
502 memcached_server_cursor(memc
, callbacks
, context
, 1);
507 uint8_t bad_key_test(memcached_st
*memc
)
510 char *key
= "foo bad";
512 size_t string_length
;
517 clone
= memcached_clone(NULL
, memc
);
520 (void)memcached_behavior_set(clone
, MEMCACHED_BEHAVIOR_VERIFY_KEY
, set
);
522 string
= memcached_get(clone
, key
, strlen(key
),
523 &string_length
, &flags
, &rc
);
524 assert(rc
== MEMCACHED_BAD_KEY_PROVIDED
);
525 assert(string_length
== 0);
529 (void)memcached_behavior_set(clone
, MEMCACHED_BEHAVIOR_VERIFY_KEY
, set
);
530 string
= memcached_get(clone
, key
, strlen(key
),
531 &string_length
, &flags
, &rc
);
532 assert(rc
== MEMCACHED_NOTFOUND
);
533 assert(string_length
== 0);
536 memcached_free(clone
);
541 #define READ_THROUGH_VALUE "set for me"
542 memcached_return
read_through_trigger(memcached_st
*memc
,
543 char *key
, size_t key_length
,
544 memcached_result_st
*result
)
547 return memcached_result_set_value(result
, READ_THROUGH_VALUE
, strlen(READ_THROUGH_VALUE
));
550 uint8_t read_through(memcached_st
*memc
)
555 size_t string_length
;
558 string
= memcached_get(memc
, key
, strlen(key
),
559 &string_length
, &flags
, &rc
);
561 assert(rc
== MEMCACHED_NOTFOUND
);
562 assert(string_length
== 0);
565 rc
= memcached_callback_set(memc
, MEMCACHED_CALLBACK_GET_FAILURE
, read_through_trigger
);
566 assert(rc
== MEMCACHED_SUCCESS
);
568 string
= memcached_get(memc
, key
, strlen(key
),
569 &string_length
, &flags
, &rc
);
571 assert(rc
== MEMCACHED_SUCCESS
);
572 assert(string_length
== strlen(READ_THROUGH_VALUE
));
573 assert(!strcmp(READ_THROUGH_VALUE
, string
));
575 string
= memcached_get(memc
, key
, strlen(key
),
576 &string_length
, &flags
, &rc
);
578 assert(rc
== MEMCACHED_SUCCESS
);
579 assert(string_length
== strlen(READ_THROUGH_VALUE
));
580 assert(!strcmp(READ_THROUGH_VALUE
, string
));
585 uint8_t get_test(memcached_st
*memc
)
590 size_t string_length
;
593 rc
= memcached_delete(memc
, key
, strlen(key
), (time_t)0);
594 assert(rc
== MEMCACHED_BUFFERED
|| rc
== MEMCACHED_NOTFOUND
);
596 string
= memcached_get(memc
, key
, strlen(key
),
597 &string_length
, &flags
, &rc
);
599 assert(rc
== MEMCACHED_NOTFOUND
);
600 assert(string_length
== 0);
606 uint8_t get_test2(memcached_st
*memc
)
610 char *value
= "when we sanitize";
612 size_t string_length
;
615 rc
= memcached_set(memc
, key
, strlen(key
),
616 value
, strlen(value
),
617 (time_t)0, (uint32_t)0);
618 assert(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
);
620 string
= memcached_get(memc
, key
, strlen(key
),
621 &string_length
, &flags
, &rc
);
624 assert(rc
== MEMCACHED_SUCCESS
);
625 assert(string_length
== strlen(value
));
626 assert(!memcmp(string
, value
, string_length
));
633 uint8_t set_test2(memcached_st
*memc
)
637 char *value
= "train in the brain";
638 size_t value_length
= strlen(value
);
641 for (x
= 0; x
< 10; x
++)
643 rc
= memcached_set(memc
, key
, strlen(key
),
645 (time_t)0, (uint32_t)0);
646 assert(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
);
652 uint8_t set_test3(memcached_st
*memc
)
657 size_t value_length
= 8191;
660 value
= (char*)malloc(value_length
);
663 for (x
= 0; x
< value_length
; x
++)
664 value
[x
] = (char) (x
% 127);
666 for (x
= 0; x
< 1; x
++)
668 rc
= memcached_set(memc
, key
, strlen(key
),
670 (time_t)0, (uint32_t)0);
671 assert(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
);
679 uint8_t get_test3(memcached_st
*memc
)
684 size_t value_length
= 8191;
686 size_t string_length
;
690 value
= (char*)malloc(value_length
);
693 for (x
= 0; x
< value_length
; x
++)
694 value
[x
] = (char) (x
% 127);
696 rc
= memcached_set(memc
, key
, strlen(key
),
698 (time_t)0, (uint32_t)0);
699 assert(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
);
701 string
= memcached_get(memc
, key
, strlen(key
),
702 &string_length
, &flags
, &rc
);
704 assert(rc
== MEMCACHED_SUCCESS
);
706 assert(string_length
== value_length
);
707 assert(!memcmp(string
, value
, string_length
));
715 uint8_t get_test4(memcached_st
*memc
)
720 size_t value_length
= 8191;
722 size_t string_length
;
726 value
= (char*)malloc(value_length
);
729 for (x
= 0; x
< value_length
; x
++)
730 value
[x
] = (char) (x
% 127);
732 rc
= memcached_set(memc
, key
, strlen(key
),
734 (time_t)0, (uint32_t)0);
735 assert(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
);
737 for (x
= 0; x
< 10; x
++)
739 string
= memcached_get(memc
, key
, strlen(key
),
740 &string_length
, &flags
, &rc
);
742 assert(rc
== MEMCACHED_SUCCESS
);
744 assert(string_length
== value_length
);
745 assert(!memcmp(string
, value
, string_length
));
754 /* Do not copy the style of this code, I just access hosts to testthis function */
755 uint8_t stats_servername_test(memcached_st
*memc
)
758 memcached_stat_st stat
;
759 rc
= memcached_stat_servername(&stat
, NULL
,
760 memc
->hosts
[0].hostname
,
761 memc
->hosts
[0].port
);
766 uint8_t increment_test(memcached_st
*memc
)
773 rc
= memcached_set(memc
, key
, strlen(key
),
774 value
, strlen(value
),
775 (time_t)0, (uint32_t)0);
776 assert(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
);
778 rc
= memcached_increment(memc
, key
, strlen(key
),
780 assert(rc
== MEMCACHED_SUCCESS
);
781 assert(new_number
== 1);
783 rc
= memcached_increment(memc
, key
, strlen(key
),
785 assert(rc
== MEMCACHED_SUCCESS
);
786 assert(new_number
== 2);
791 uint8_t decrement_test(memcached_st
*memc
)
798 rc
= memcached_set(memc
, key
, strlen(key
),
799 value
, strlen(value
),
800 (time_t)0, (uint32_t)0);
801 assert(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
);
803 rc
= memcached_decrement(memc
, key
, strlen(key
),
805 assert(rc
== MEMCACHED_SUCCESS
);
806 assert(new_number
== 2);
808 rc
= memcached_decrement(memc
, key
, strlen(key
),
810 assert(rc
== MEMCACHED_SUCCESS
);
811 assert(new_number
== 1);
816 uint8_t quit_test(memcached_st
*memc
)
820 char *value
= "sanford and sun";
822 rc
= memcached_set(memc
, key
, strlen(key
),
823 value
, strlen(value
),
824 (time_t)10, (uint32_t)3);
825 assert(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
);
826 memcached_quit(memc
);
828 rc
= memcached_set(memc
, key
, strlen(key
),
829 value
, strlen(value
),
830 (time_t)50, (uint32_t)9);
831 assert(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
);
836 uint8_t mget_result_test(memcached_st
*memc
)
839 char *keys
[]= {"fudge", "son", "food"};
840 size_t key_length
[]= {5, 3, 4};
843 memcached_result_st results_obj
;
844 memcached_result_st
*results
;
846 results
= memcached_result_create(memc
, &results_obj
);
848 assert(&results_obj
== results
);
850 /* We need to empty the server before continueing test */
851 rc
= memcached_flush(memc
, 0);
852 assert(rc
== MEMCACHED_SUCCESS
);
854 rc
= memcached_mget(memc
, keys
, key_length
, 3);
855 assert(rc
== MEMCACHED_SUCCESS
);
857 while ((results
= memcached_fetch_result(memc
, &results_obj
, &rc
)) != NULL
)
862 while ((results
= memcached_fetch_result(memc
, &results_obj
, &rc
)) != NULL
)
864 assert(rc
== MEMCACHED_END
);
866 for (x
= 0; x
< 3; x
++)
868 rc
= memcached_set(memc
, keys
[x
], key_length
[x
],
869 keys
[x
], key_length
[x
],
870 (time_t)50, (uint32_t)9);
871 assert(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
);
874 rc
= memcached_mget(memc
, keys
, key_length
, 3);
875 assert(rc
== MEMCACHED_SUCCESS
);
877 while ((results
= memcached_fetch_result(memc
, &results_obj
, &rc
)))
880 assert(&results_obj
== results
);
881 assert(rc
== MEMCACHED_SUCCESS
);
882 assert(memcached_result_key_length(results
) == memcached_result_length(results
));
883 assert(!memcmp(memcached_result_key_value(results
),
884 memcached_result_value(results
),
885 memcached_result_length(results
)));
888 memcached_result_free(&results_obj
);
893 uint8_t mget_result_alloc_test(memcached_st
*memc
)
896 char *keys
[]= {"fudge", "son", "food"};
897 size_t key_length
[]= {5, 3, 4};
900 memcached_result_st
*results
;
902 /* We need to empty the server before continueing test */
903 rc
= memcached_flush(memc
, 0);
904 assert(rc
== MEMCACHED_SUCCESS
);
906 rc
= memcached_mget(memc
, keys
, key_length
, 3);
907 assert(rc
== MEMCACHED_SUCCESS
);
909 while ((results
= memcached_fetch_result(memc
, NULL
, &rc
)) != NULL
)
914 assert(rc
== MEMCACHED_END
);
916 for (x
= 0; x
< 3; x
++)
918 rc
= memcached_set(memc
, keys
[x
], key_length
[x
],
919 keys
[x
], key_length
[x
],
920 (time_t)50, (uint32_t)9);
921 assert(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
);
924 rc
= memcached_mget(memc
, keys
, key_length
, 3);
925 assert(rc
== MEMCACHED_SUCCESS
);
928 while ((results
= memcached_fetch_result(memc
, NULL
, &rc
)))
931 assert(rc
== MEMCACHED_SUCCESS
);
932 assert(memcached_result_key_length(results
) == memcached_result_length(results
));
933 assert(!memcmp(memcached_result_key_value(results
),
934 memcached_result_value(results
),
935 memcached_result_length(results
)));
936 memcached_result_free(results
);
943 /* Count the results */
944 unsigned int callback_counter(memcached_st
*ptr
, memcached_result_st
*result
, void *context
)
946 unsigned int *counter
= (unsigned int *)context
;
948 *counter
= *counter
+ 1;
953 uint8_t mget_result_function(memcached_st
*memc
)
956 char *keys
[]= {"fudge", "son", "food"};
957 size_t key_length
[]= {5, 3, 4};
959 unsigned int counter
;
960 memcached_execute_function callbacks
[1];
962 /* We need to empty the server before continueing test */
963 rc
= memcached_flush(memc
, 0);
964 for (x
= 0; x
< 3; x
++)
966 rc
= memcached_set(memc
, keys
[x
], key_length
[x
],
967 keys
[x
], key_length
[x
],
968 (time_t)50, (uint32_t)9);
969 assert(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
);
972 rc
= memcached_mget(memc
, keys
, key_length
, 3);
973 assert(rc
== MEMCACHED_SUCCESS
);
975 callbacks
[0]= &callback_counter
;
977 rc
= memcached_fetch_execute(memc
, callbacks
, (void *)&counter
, 1);
979 assert(counter
== 3);
984 uint8_t mget_test(memcached_st
*memc
)
987 char *keys
[]= {"fudge", "son", "food"};
988 size_t key_length
[]= {5, 3, 4};
992 char return_key
[MEMCACHED_MAX_KEY
];
993 size_t return_key_length
;
995 size_t return_value_length
;
997 /* We need to empty the server before continueing test */
998 rc
= memcached_flush(memc
, 0);
999 assert(rc
== MEMCACHED_SUCCESS
);
1001 rc
= memcached_mget(memc
, keys
, key_length
, 3);
1002 assert(rc
== MEMCACHED_SUCCESS
);
1004 while ((return_value
= memcached_fetch(memc
, return_key
, &return_key_length
,
1005 &return_value_length
, &flags
, &rc
)) != NULL
)
1007 assert(return_value
);
1009 assert(!return_value
);
1010 assert(return_value_length
== 0);
1011 assert(rc
== MEMCACHED_END
);
1013 for (x
= 0; x
< 3; x
++)
1015 rc
= memcached_set(memc
, keys
[x
], key_length
[x
],
1016 keys
[x
], key_length
[x
],
1017 (time_t)50, (uint32_t)9);
1018 assert(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
);
1021 rc
= memcached_mget(memc
, keys
, key_length
, 3);
1022 assert(rc
== MEMCACHED_SUCCESS
);
1025 while ((return_value
= memcached_fetch(memc
, return_key
, &return_key_length
,
1026 &return_value_length
, &flags
, &rc
)))
1028 assert(return_value
);
1029 assert(rc
== MEMCACHED_SUCCESS
);
1030 assert(return_key_length
== return_value_length
);
1031 assert(!memcmp(return_value
, return_key
, return_value_length
));
1039 uint8_t get_stats_keys(memcached_st
*memc
)
1043 memcached_stat_st stat
;
1044 memcached_return rc
;
1046 list
= memcached_stat_get_keys(memc
, &stat
, &rc
);
1047 assert(rc
== MEMCACHED_SUCCESS
);
1048 for (ptr
= list
; *ptr
; ptr
++)
1057 uint8_t version_string_test(memcached_st
*memc
)
1059 const char *version_string
;
1061 version_string
= memcached_lib_version();
1063 assert(!strcmp(version_string
, LIBMEMCACHED_VERSION_STRING
));
1068 uint8_t get_stats(memcached_st
*memc
)
1073 memcached_return rc
;
1074 memcached_stat_st
*stat
;
1076 stat
= memcached_stat(memc
, NULL
, &rc
);
1077 assert(rc
== MEMCACHED_SUCCESS
);
1079 assert(rc
== MEMCACHED_SUCCESS
);
1082 for (x
= 0; x
< memcached_server_count(memc
); x
++)
1084 list
= memcached_stat_get_keys(memc
, stat
+x
, &rc
);
1085 assert(rc
== MEMCACHED_SUCCESS
);
1086 for (ptr
= list
; *ptr
; ptr
++);
1091 memcached_stat_free(NULL
, stat
);
1096 uint8_t add_host_test(memcached_st
*memc
)
1099 memcached_server_st
*servers
;
1100 memcached_return rc
;
1101 char servername
[]= "0.example.com";
1103 servers
= memcached_server_list_append(NULL
, servername
, 400, &rc
);
1105 assert(1 == memcached_server_list_count(servers
));
1107 for (x
= 2; x
< 20; x
++)
1109 char buffer
[SMALL_STRING_LEN
];
1111 snprintf(buffer
, SMALL_STRING_LEN
, "%u.example.com", 400+x
);
1112 servers
= memcached_server_list_append(servers
, buffer
, 401,
1114 assert(rc
== MEMCACHED_SUCCESS
);
1115 assert(x
== memcached_server_list_count(servers
));
1118 rc
= memcached_server_push(memc
, servers
);
1119 assert(rc
== MEMCACHED_SUCCESS
);
1120 rc
= memcached_server_push(memc
, servers
);
1121 assert(rc
== MEMCACHED_SUCCESS
);
1123 memcached_server_list_free(servers
);
1128 memcached_return
clone_test_callback(memcached_st
*parent
, memcached_st
*clone
)
1130 return MEMCACHED_SUCCESS
;
1133 memcached_return
cleanup_test_callback(memcached_st
*ptr
)
1135 return MEMCACHED_SUCCESS
;
1138 uint8_t callback_test(memcached_st
*memc
)
1140 /* Test User Data */
1144 memcached_return rc
;
1146 rc
= memcached_callback_set(memc
, MEMCACHED_CALLBACK_USER_DATA
, &x
);
1147 assert(rc
== MEMCACHED_SUCCESS
);
1148 test_ptr
= (int *)memcached_callback_get(memc
, MEMCACHED_CALLBACK_USER_DATA
, &rc
);
1149 assert(*test_ptr
== x
);
1152 /* Test Clone Callback */
1154 memcached_clone_func temp_function
;
1155 memcached_return rc
;
1157 rc
= memcached_callback_set(memc
, MEMCACHED_CALLBACK_CLONE_FUNCTION
, clone_test_callback
);
1158 assert(rc
== MEMCACHED_SUCCESS
);
1159 temp_function
= (memcached_clone_func
)memcached_callback_get(memc
, MEMCACHED_CALLBACK_CLONE_FUNCTION
, &rc
);
1160 assert(temp_function
== clone_test_callback
);
1163 /* Test Cleanup Callback */
1165 memcached_cleanup_func temp_function
;
1166 memcached_return rc
;
1168 rc
= memcached_callback_set(memc
, MEMCACHED_CALLBACK_CLONE_FUNCTION
, cleanup_test_callback
);
1169 assert(rc
== MEMCACHED_SUCCESS
);
1170 temp_function
= (memcached_cleanup_func
)memcached_callback_get(memc
, MEMCACHED_CALLBACK_CLONE_FUNCTION
, &rc
);
1171 assert(temp_function
== cleanup_test_callback
);
1177 /* We don't test the behavior itself, we test the switches */
1178 uint8_t behavior_test(memcached_st
*memc
)
1180 unsigned long long value
;
1181 unsigned int set
= 1;
1183 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NO_BLOCK
, set
);
1184 value
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_NO_BLOCK
);
1187 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_TCP_NODELAY
, set
);
1188 value
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_TCP_NODELAY
);
1191 set
= MEMCACHED_HASH_MD5
;
1192 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_HASH
, set
);
1193 value
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_HASH
);
1194 assert(value
== MEMCACHED_HASH_MD5
);
1198 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NO_BLOCK
, set
);
1199 value
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_NO_BLOCK
);
1202 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_TCP_NODELAY
, set
);
1203 value
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_TCP_NODELAY
);
1206 set
= MEMCACHED_HASH_DEFAULT
;
1207 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_HASH
, set
);
1208 value
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_HASH
);
1209 assert(value
== MEMCACHED_HASH_DEFAULT
);
1211 set
= MEMCACHED_HASH_CRC
;
1212 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_HASH
, set
);
1213 value
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_HASH
);
1214 assert(value
== MEMCACHED_HASH_CRC
);
1216 value
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_SOCKET_SEND_SIZE
);
1219 value
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_SOCKET_RECV_SIZE
);
1225 /* Test case provided by Cal Haldenbrand */
1226 uint8_t user_supplied_bug1(memcached_st
*memc
)
1228 unsigned int setter
= 1;
1231 unsigned long long total
= 0;
1234 char randomstuff
[6 * 1024];
1235 memcached_return rc
;
1237 memset(randomstuff
, 0, 6 * 1024);
1239 /* We just keep looking at the same values over and over */
1242 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NO_BLOCK
, setter
);
1243 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_TCP_NODELAY
, setter
);
1247 for (x
= 0 ; total
< 20 * 1024576 ; x
++ )
1251 size
= (rand() % ( 5 * 1024 ) ) + 400;
1252 memset(randomstuff
, 0, 6 * 1024);
1253 assert(size
< 6 * 1024); /* Being safe here */
1255 for (j
= 0 ; j
< size
;j
++)
1256 randomstuff
[j
] = (char) (rand() % 26) + 97;
1259 sprintf(key
, "%d", x
);
1260 rc
= memcached_set(memc
, key
, strlen(key
),
1261 randomstuff
, strlen(randomstuff
), 10, 0);
1262 /* If we fail, lets try again */
1263 if (rc
!= MEMCACHED_SUCCESS
&& rc
!= MEMCACHED_BUFFERED
)
1264 rc
= memcached_set(memc
, key
, strlen(key
),
1265 randomstuff
, strlen(randomstuff
), 10, 0);
1266 assert(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
);
1272 /* Test case provided by Cal Haldenbrand */
1273 uint8_t user_supplied_bug2(memcached_st
*memc
)
1276 unsigned int setter
;
1278 unsigned long long total
;
1281 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NO_BLOCK
, setter
);
1282 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_TCP_NODELAY
, setter
);
1284 setter
= 20 * 1024576;
1285 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_SOCKET_SEND_SIZE
, setter
);
1286 setter
= 20 * 1024576;
1287 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_SOCKET_RECV_SIZE
, setter
);
1288 getter
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_SOCKET_SEND_SIZE
);
1289 getter
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_SOCKET_RECV_SIZE
);
1291 for (x
= 0, errors
= 0, total
= 0 ; total
< 20 * 1024576 ; x
++)
1294 for (x
= 0, errors
= 0, total
= 0 ; total
< 24576 ; x
++)
1296 memcached_return rc
= MEMCACHED_SUCCESS
;
1297 char buffer
[SMALL_STRING_LEN
];
1302 memset(buffer
, 0, SMALL_STRING_LEN
);
1304 snprintf(buffer
, SMALL_STRING_LEN
, "%u", x
);
1305 getval
= memcached_get(memc
, buffer
, strlen(buffer
),
1306 &val_len
, &flags
, &rc
);
1307 if (rc
!= MEMCACHED_SUCCESS
)
1309 if (rc
== MEMCACHED_NOTFOUND
)
1313 WATCHPOINT_ERROR(rc
);
1327 /* Do a large mget() over all the keys we think exist */
1328 #define KEY_COUNT 3000 // * 1024576
1329 uint8_t user_supplied_bug3(memcached_st
*memc
)
1331 memcached_return rc
;
1332 unsigned int setter
;
1335 size_t key_lengths
[KEY_COUNT
];
1338 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NO_BLOCK
, setter
);
1339 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_TCP_NODELAY
, setter
);
1341 setter
= 20 * 1024576;
1342 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_SOCKET_SEND_SIZE
, setter
);
1343 setter
= 20 * 1024576;
1344 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_SOCKET_RECV_SIZE
, setter
);
1345 getter
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_SOCKET_SEND_SIZE
);
1346 getter
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_SOCKET_RECV_SIZE
);
1349 keys
= (char **)malloc(sizeof(char *) * KEY_COUNT
);
1351 memset(keys
, 0, (sizeof(char *) * KEY_COUNT
));
1352 for (x
= 0; x
< KEY_COUNT
; x
++)
1356 snprintf(buffer
, 30, "%u", x
);
1357 keys
[x
]= strdup(buffer
);
1358 key_lengths
[x
]= strlen(keys
[x
]);
1361 rc
= memcached_mget(memc
, keys
, key_lengths
, KEY_COUNT
);
1362 assert(rc
== MEMCACHED_SUCCESS
);
1364 /* Turn this into a help function */
1366 char return_key
[MEMCACHED_MAX_KEY
];
1367 size_t return_key_length
;
1369 size_t return_value_length
;
1372 while ((return_value
= memcached_fetch(memc
, return_key
, &return_key_length
,
1373 &return_value_length
, &flags
, &rc
)))
1375 assert(return_value
);
1376 assert(rc
== MEMCACHED_SUCCESS
);
1381 for (x
= 0; x
< KEY_COUNT
; x
++)
1388 /* Make sure we behave properly if server list has no values */
1389 uint8_t user_supplied_bug4(memcached_st
*memc
)
1391 memcached_return rc
;
1392 char *keys
[]= {"fudge", "son", "food"};
1393 size_t key_length
[]= {5, 3, 4};
1396 char return_key
[MEMCACHED_MAX_KEY
];
1397 size_t return_key_length
;
1399 size_t return_value_length
;
1401 /* Here we free everything before running a bunch of mget tests */
1403 memcached_server_list_free(memc
->hosts
);
1405 memc
->number_of_hosts
= 0;
1409 /* We need to empty the server before continueing test */
1410 rc
= memcached_flush(memc
, 0);
1411 assert(rc
== MEMCACHED_NO_SERVERS
);
1413 rc
= memcached_mget(memc
, keys
, key_length
, 3);
1414 assert(rc
== MEMCACHED_NO_SERVERS
);
1416 while ((return_value
= memcached_fetch(memc
, return_key
, &return_key_length
,
1417 &return_value_length
, &flags
, &rc
)) != NULL
)
1419 assert(return_value
);
1421 assert(!return_value
);
1422 assert(return_value_length
== 0);
1423 assert(rc
== MEMCACHED_NO_SERVERS
);
1425 for (x
= 0; x
< 3; x
++)
1427 rc
= memcached_set(memc
, keys
[x
], key_length
[x
],
1428 keys
[x
], key_length
[x
],
1429 (time_t)50, (uint32_t)9);
1430 assert(rc
== MEMCACHED_NO_SERVERS
);
1433 rc
= memcached_mget(memc
, keys
, key_length
, 3);
1434 assert(rc
== MEMCACHED_NO_SERVERS
);
1437 while ((return_value
= memcached_fetch(memc
, return_key
, &return_key_length
,
1438 &return_value_length
, &flags
, &rc
)))
1440 assert(return_value
);
1441 assert(rc
== MEMCACHED_SUCCESS
);
1442 assert(return_key_length
== return_value_length
);
1443 assert(!memcmp(return_value
, return_key
, return_value_length
));
1451 #define VALUE_SIZE_BUG5 1048064
1452 uint8_t user_supplied_bug5(memcached_st
*memc
)
1454 memcached_return rc
;
1455 char *keys
[]= {"036790384900", "036790384902", "036790384904", "036790384906"};
1456 size_t key_length
[]= {strlen("036790384900"), strlen("036790384902"), strlen("036790384904"), strlen("036790384906")};
1457 char return_key
[MEMCACHED_MAX_KEY
];
1458 size_t return_key_length
;
1460 size_t value_length
;
1464 char insert_data
[VALUE_SIZE_BUG5
];
1466 for (x
= 0; x
< VALUE_SIZE_BUG5
; x
++)
1467 insert_data
[x
]= rand();
1469 memcached_flush(memc
, 0);
1470 value
= memcached_get(memc
, keys
[0], key_length
[0],
1471 &value_length
, &flags
, &rc
);
1472 assert(value
== NULL
);
1473 rc
= memcached_mget(memc
, keys
, key_length
, 4);
1476 while ((value
= memcached_fetch(memc
, return_key
, &return_key_length
,
1477 &value_length
, &flags
, &rc
)))
1481 for (x
= 0; x
< 4; x
++)
1483 rc
= memcached_set(memc
, keys
[x
], key_length
[x
],
1484 insert_data
, VALUE_SIZE_BUG5
,
1485 (time_t)0, (uint32_t)0);
1486 assert(rc
== MEMCACHED_SUCCESS
);
1489 for (x
= 0; x
< 10; x
++)
1491 value
= memcached_get(memc
, keys
[0], key_length
[0],
1492 &value_length
, &flags
, &rc
);
1496 rc
= memcached_mget(memc
, keys
, key_length
, 4);
1498 while ((value
= memcached_fetch(memc
, return_key
, &return_key_length
,
1499 &value_length
, &flags
, &rc
)))
1510 uint8_t user_supplied_bug6(memcached_st
*memc
)
1512 memcached_return rc
;
1513 char *keys
[]= {"036790384900", "036790384902", "036790384904", "036790384906"};
1514 size_t key_length
[]= {strlen("036790384900"), strlen("036790384902"), strlen("036790384904"), strlen("036790384906")};
1515 char return_key
[MEMCACHED_MAX_KEY
];
1516 size_t return_key_length
;
1518 size_t value_length
;
1522 char insert_data
[VALUE_SIZE_BUG5
];
1524 for (x
= 0; x
< VALUE_SIZE_BUG5
; x
++)
1525 insert_data
[x
]= rand();
1527 memcached_flush(memc
, 0);
1528 value
= memcached_get(memc
, keys
[0], key_length
[0],
1529 &value_length
, &flags
, &rc
);
1530 assert(value
== NULL
);
1531 assert(rc
== MEMCACHED_NOTFOUND
);
1532 rc
= memcached_mget(memc
, keys
, key_length
, 4);
1533 assert(rc
== MEMCACHED_SUCCESS
);
1536 while ((value
= memcached_fetch(memc
, return_key
, &return_key_length
,
1537 &value_length
, &flags
, &rc
)))
1540 assert(rc
== MEMCACHED_END
);
1542 for (x
= 0; x
< 4; x
++)
1544 rc
= memcached_set(memc
, keys
[x
], key_length
[x
],
1545 insert_data
, VALUE_SIZE_BUG5
,
1546 (time_t)0, (uint32_t)0);
1547 assert(rc
== MEMCACHED_SUCCESS
);
1550 for (x
= 0; x
< 2; x
++)
1552 value
= memcached_get(memc
, keys
[0], key_length
[0],
1553 &value_length
, &flags
, &rc
);
1557 rc
= memcached_mget(memc
, keys
, key_length
, 4);
1558 assert(rc
== MEMCACHED_SUCCESS
);
1560 /* We test for purge of partial complete fetches */
1561 for (count
= 3; count
; count
--)
1563 value
= memcached_fetch(memc
, return_key
, &return_key_length
,
1564 &value_length
, &flags
, &rc
);
1565 assert(rc
== MEMCACHED_SUCCESS
);
1566 assert(!(memcmp(value
, insert_data
, value_length
)));
1567 assert(value_length
);
1575 uint8_t user_supplied_bug8(memcached_st
*memc
)
1577 memcached_return rc
;
1579 memcached_st
*clone
;
1581 memcached_server_st
*servers
;
1582 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";
1584 servers
= memcached_servers_parse(server_list
);
1587 mine
= memcached_create(NULL
);
1588 rc
= memcached_server_push(mine
, servers
);
1589 assert(rc
== MEMCACHED_SUCCESS
);
1590 memcached_server_list_free(servers
);
1593 clone
= memcached_clone(NULL
, mine
);
1595 memcached_quit(mine
);
1596 memcached_quit(clone
);
1599 memcached_free(mine
);
1600 memcached_free(clone
);
1605 /* Test flag store/retrieve */
1606 uint8_t user_supplied_bug7(memcached_st
*memc
)
1608 memcached_return rc
;
1609 char *keys
= "036790384900";
1610 size_t key_length
= strlen("036790384900");
1611 char return_key
[MEMCACHED_MAX_KEY
];
1612 size_t return_key_length
;
1614 size_t value_length
;
1617 char insert_data
[VALUE_SIZE_BUG5
];
1619 for (x
= 0; x
< VALUE_SIZE_BUG5
; x
++)
1620 insert_data
[x
]= rand();
1622 memcached_flush(memc
, 0);
1625 rc
= memcached_set(memc
, keys
, key_length
,
1626 insert_data
, VALUE_SIZE_BUG5
,
1628 assert(rc
== MEMCACHED_SUCCESS
);
1631 value
= memcached_get(memc
, keys
, key_length
,
1632 &value_length
, &flags
, &rc
);
1633 assert(flags
== 245);
1637 rc
= memcached_mget(memc
, &keys
, &key_length
, 1);
1640 value
= memcached_fetch(memc
, return_key
, &return_key_length
,
1641 &value_length
, &flags
, &rc
);
1642 assert(flags
== 245);
1650 uint8_t user_supplied_bug9(memcached_st
*memc
)
1652 memcached_return rc
;
1653 char *keys
[]= {"UDATA:edevil@sapo.pt", "fudge&*@#", "for^#@&$not"};
1654 size_t key_length
[3];
1659 char return_key
[MEMCACHED_MAX_KEY
];
1660 size_t return_key_length
;
1662 size_t return_value_length
;
1665 key_length
[0]= strlen("UDATA:edevil@sapo.pt");
1666 key_length
[1]= strlen("fudge&*@#");
1667 key_length
[2]= strlen("for^#@&$not");
1670 for (x
= 0; x
< 3; x
++)
1672 rc
= memcached_set(memc
, keys
[x
], key_length
[x
],
1673 keys
[x
], key_length
[x
],
1674 (time_t)50, (uint32_t)9);
1675 assert(rc
== MEMCACHED_SUCCESS
);
1678 rc
= memcached_mget(memc
, keys
, key_length
, 3);
1679 assert(rc
== MEMCACHED_SUCCESS
);
1681 /* We need to empty the server before continueing test */
1682 while ((return_value
= memcached_fetch(memc
, return_key
, &return_key_length
,
1683 &return_value_length
, &flags
, &rc
)) != NULL
)
1685 assert(return_value
);
1694 /* We are testing with aggressive timeout to get failures */
1695 uint8_t user_supplied_bug10(memcached_st
*memc
)
1699 size_t value_length
= 512;
1702 memcached_return rc
;
1703 unsigned int set
= 1;
1704 memcached_st
*mclone
= memcached_clone(NULL
, memc
);
1707 memcached_behavior_set(mclone
, MEMCACHED_BEHAVIOR_NO_BLOCK
, set
);
1708 memcached_behavior_set(mclone
, MEMCACHED_BEHAVIOR_TCP_NODELAY
, set
);
1710 memcached_behavior_set(mclone
, MEMCACHED_BEHAVIOR_POLL_TIMEOUT
, timeout
);
1712 value
= (char*)malloc(value_length
* sizeof(char));
1714 for (x
= 0; x
< value_length
; x
++)
1715 value
[x
]= (char) (x
% 127);
1717 for (x
= 1; x
<= 100000; ++x
)
1719 rc
= memcached_set(mclone
, key
, key_len
,value
, value_length
, 0, 0);
1721 assert(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_WRITE_FAILURE
|| rc
== MEMCACHED_BUFFERED
);
1723 if (rc
== MEMCACHED_WRITE_FAILURE
)
1728 memcached_free(mclone
);
1734 We are looking failures in the async protocol
1736 uint8_t user_supplied_bug11(memcached_st
*memc
)
1740 size_t value_length
= 512;
1743 memcached_return rc
;
1744 unsigned int set
= 1;
1746 memcached_st
*mclone
= memcached_clone(NULL
, memc
);
1748 memcached_behavior_set(mclone
, MEMCACHED_BEHAVIOR_NO_BLOCK
, set
);
1749 memcached_behavior_set(mclone
, MEMCACHED_BEHAVIOR_TCP_NODELAY
, set
);
1751 memcached_behavior_set(mclone
, MEMCACHED_BEHAVIOR_POLL_TIMEOUT
, timeout
);
1753 timeout
= (int32_t)memcached_behavior_get(mclone
, MEMCACHED_BEHAVIOR_POLL_TIMEOUT
);
1755 assert(timeout
== -1);
1757 value
= (char*)malloc(value_length
* sizeof(char));
1759 for (x
= 0; x
< value_length
; x
++)
1760 value
[x
]= (char) (x
% 127);
1762 for (x
= 1; x
<= 100000; ++x
)
1764 rc
= memcached_set(mclone
, key
, key_len
,value
, value_length
, 0, 0);
1768 memcached_free(mclone
);
1774 Bug found where incr was not returning MEMCACHED_NOTFOUND when object did not exist.
1776 uint8_t user_supplied_bug12(memcached_st
*memc
)
1778 memcached_return rc
;
1780 size_t value_length
;
1782 uint64_t number_value
;
1784 value
= memcached_get(memc
, "autoincrement", strlen("autoincrement"),
1785 &value_length
, &flags
, &rc
);
1786 assert(value
== NULL
);
1787 assert(rc
== MEMCACHED_NOTFOUND
);
1789 rc
= memcached_increment(memc
, "autoincrement", strlen("autoincrement"),
1792 assert(value
== NULL
);
1793 assert(rc
== MEMCACHED_NOTFOUND
);
1795 rc
= memcached_set(memc
, "autoincrement", strlen("autoincrement"), "1", 1, 0, 0);
1797 value
= memcached_get(memc
, "autoincrement", strlen("autoincrement"),
1798 &value_length
, &flags
, &rc
);
1800 assert(rc
== MEMCACHED_SUCCESS
);
1803 rc
= memcached_increment(memc
, "autoincrement", strlen("autoincrement"),
1805 assert(number_value
== 2);
1806 assert(rc
== MEMCACHED_SUCCESS
);
1812 Bug found where command total one more than MEMCACHED_MAX_BUFFER
1813 set key34567890 0 0 8169 \r\n is sent followed by buffer of size 8169, followed by 8169
1815 uint8_t user_supplied_bug13(memcached_st
*memc
)
1817 char key
[] = "key34567890";
1819 memcached_return rc
;
1820 size_t overflowSize
;
1822 char commandFirst
[]= "set key34567890 0 0 ";
1823 char commandLast
[] = " \r\n"; /* first line of command sent to server */
1824 size_t commandLength
;
1827 commandLength
= strlen(commandFirst
) + strlen(commandLast
) + 4; /* 4 is number of characters in size, probably 8196 */
1829 overflowSize
= MEMCACHED_MAX_BUFFER
- commandLength
;
1831 for (testSize
= overflowSize
- 1; testSize
< overflowSize
+ 1; testSize
++)
1833 overflow
= malloc(testSize
);
1834 assert(overflow
!= NULL
);
1836 memset(overflow
, 'x', testSize
);
1837 rc
= memcached_set(memc
, key
, strlen(key
),
1838 overflow
, testSize
, 0, 0);
1839 assert(rc
== MEMCACHED_SUCCESS
);
1848 Test values of many different sizes
1849 Bug found where command total one more than MEMCACHED_MAX_BUFFER
1850 set key34567890 0 0 8169 \r\n
1851 is sent followed by buffer of size 8169, followed by 8169
1853 uint8_t user_supplied_bug14(memcached_st
*memc
)
1856 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_TCP_NODELAY
, setter
);
1857 memcached_return rc
;
1860 size_t value_length
= 18000;
1862 size_t string_length
;
1865 size_t current_length
;
1867 value
= (char*)malloc(value_length
);
1870 for (x
= 0; x
< value_length
; x
++)
1871 value
[x
] = (char) (x
% 127);
1873 for (current_length
= 0; current_length
< value_length
; current_length
++)
1875 rc
= memcached_set(memc
, key
, strlen(key
),
1876 value
, current_length
,
1877 (time_t)0, (uint32_t)0);
1878 assert(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
);
1880 string
= memcached_get(memc
, key
, strlen(key
),
1881 &string_length
, &flags
, &rc
);
1883 assert(rc
== MEMCACHED_SUCCESS
);
1884 if (current_length
> 0)
1886 assert(string_length
== current_length
);
1887 assert(!memcmp(string
, value
, string_length
));
1898 Look for zero length value problems
1900 uint8_t user_supplied_bug15(memcached_st
*memc
)
1903 memcached_return rc
;
1909 for (x
= 0; x
< 2; x
++)
1911 rc
= memcached_set(memc
, key
, strlen(key
),
1913 (time_t)0, (uint32_t)0);
1915 assert(rc
== MEMCACHED_SUCCESS
);
1917 value
= memcached_get(memc
, key
, strlen(key
),
1918 &length
, &flags
, &rc
);
1920 assert(rc
== MEMCACHED_SUCCESS
);
1921 assert(value
== NULL
);
1922 assert(length
== 0);
1925 value
= memcached_get(memc
, key
, strlen(key
),
1926 &length
, &flags
, &rc
);
1928 assert(rc
== MEMCACHED_SUCCESS
);
1929 assert(value
== NULL
);
1930 assert(length
== 0);
1937 uint8_t result_static(memcached_st
*memc
)
1939 memcached_result_st result
;
1940 memcached_result_st
*result_ptr
;
1942 result_ptr
= memcached_result_create(memc
, &result
);
1943 assert(result
.is_allocated
== MEMCACHED_NOT_ALLOCATED
);
1945 memcached_result_free(&result
);
1950 uint8_t result_alloc(memcached_st
*memc
)
1952 memcached_result_st
*result
;
1954 result
= memcached_result_create(memc
, NULL
);
1956 memcached_result_free(result
);
1961 uint8_t string_static_null(memcached_st
*memc
)
1963 memcached_string_st string
;
1964 memcached_string_st
*string_ptr
;
1966 string_ptr
= memcached_string_create(memc
, &string
, 0);
1967 assert(string
.is_allocated
== MEMCACHED_NOT_ALLOCATED
);
1969 memcached_string_free(&string
);
1974 uint8_t string_alloc_null(memcached_st
*memc
)
1976 memcached_string_st
*string
;
1978 string
= memcached_string_create(memc
, NULL
, 0);
1980 memcached_string_free(string
);
1985 uint8_t string_alloc_with_size(memcached_st
*memc
)
1987 memcached_string_st
*string
;
1989 string
= memcached_string_create(memc
, NULL
, 1024);
1991 memcached_string_free(string
);
1996 uint8_t string_alloc_with_size_toobig(memcached_st
*memc
)
1998 memcached_string_st
*string
;
2000 string
= memcached_string_create(memc
, NULL
, INT64_MAX
);
2001 assert(string
== NULL
);
2006 uint8_t string_alloc_append(memcached_st
*memc
)
2009 char buffer
[SMALL_STRING_LEN
];
2010 memcached_string_st
*string
;
2012 /* Ring the bell! */
2013 memset(buffer
, 6, SMALL_STRING_LEN
);
2015 string
= memcached_string_create(memc
, NULL
, 100);
2018 for (x
= 0; x
< 1024; x
++)
2020 memcached_return rc
;
2021 rc
= memcached_string_append(string
, buffer
, SMALL_STRING_LEN
);
2022 assert(rc
== MEMCACHED_SUCCESS
);
2024 memcached_string_free(string
);
2029 uint8_t string_alloc_append_toobig(memcached_st
*memc
)
2031 memcached_return rc
;
2033 char buffer
[SMALL_STRING_LEN
];
2034 memcached_string_st
*string
;
2036 /* Ring the bell! */
2037 memset(buffer
, 6, SMALL_STRING_LEN
);
2039 string
= memcached_string_create(memc
, NULL
, 100);
2042 for (x
= 0; x
< 1024; x
++)
2044 rc
= memcached_string_append(string
, buffer
, SMALL_STRING_LEN
);
2045 assert(rc
== MEMCACHED_SUCCESS
);
2047 rc
= memcached_string_append(string
, buffer
, INT64_MAX
);
2048 assert(rc
== MEMCACHED_MEMORY_ALLOCATION_FAILURE
);
2049 memcached_string_free(string
);
2054 uint8_t cleanup_pairs(memcached_st
*memc
)
2056 pairs_free(global_pairs
);
2061 uint8_t generate_pairs(memcached_st
*memc
)
2063 unsigned long long x
;
2064 global_pairs
= pairs_generate(GLOBAL_COUNT
, 400);
2065 global_count
= GLOBAL_COUNT
;
2067 for (x
= 0; x
< global_count
; x
++)
2069 global_keys
[x
]= global_pairs
[x
].key
;
2070 global_keys_length
[x
]= global_pairs
[x
].key_length
;
2076 uint8_t generate_large_pairs(memcached_st
*memc
)
2078 unsigned long long x
;
2079 global_pairs
= pairs_generate(GLOBAL2_COUNT
, MEMCACHED_MAX_BUFFER
+10);
2080 global_count
= GLOBAL2_COUNT
;
2082 for (x
= 0; x
< global_count
; x
++)
2084 global_keys
[x
]= global_pairs
[x
].key
;
2085 global_keys_length
[x
]= global_pairs
[x
].key_length
;
2091 uint8_t generate_data(memcached_st
*memc
)
2093 execute_set(memc
, global_pairs
, global_count
);
2098 uint8_t generate_buffer_data(memcached_st
*memc
)
2103 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_BUFFER_REQUESTS
, latch
);
2104 generate_data(memc
);
2109 uint8_t get_read(memcached_st
*memc
)
2112 memcached_return rc
;
2116 size_t return_value_length
;
2119 for (x
= 0; x
< global_count
; x
++)
2121 return_value
= memcached_get(memc
, global_keys
[x
], global_keys_length
[x
],
2122 &return_value_length
, &flags
, &rc
);
2124 assert(return_value);
2125 assert(rc == MEMCACHED_SUCCESS);
2127 if (rc
== MEMCACHED_SUCCESS
&& return_value
)
2135 uint8_t mget_read(memcached_st
*memc
)
2137 memcached_return rc
;
2139 rc
= memcached_mget(memc
, global_keys
, global_keys_length
, global_count
);
2140 assert(rc
== MEMCACHED_SUCCESS
);
2141 /* Turn this into a help function */
2143 char return_key
[MEMCACHED_MAX_KEY
];
2144 size_t return_key_length
;
2146 size_t return_value_length
;
2149 while ((return_value
= memcached_fetch(memc
, return_key
, &return_key_length
,
2150 &return_value_length
, &flags
, &rc
)))
2152 assert(return_value
);
2153 assert(rc
== MEMCACHED_SUCCESS
);
2161 uint8_t mget_read_result(memcached_st
*memc
)
2163 memcached_return rc
;
2165 rc
= memcached_mget(memc
, global_keys
, global_keys_length
, global_count
);
2166 assert(rc
== MEMCACHED_SUCCESS
);
2167 /* Turn this into a help function */
2169 memcached_result_st results_obj
;
2170 memcached_result_st
*results
;
2172 results
= memcached_result_create(memc
, &results_obj
);
2174 while ((results
= memcached_fetch_result(memc
, &results_obj
, &rc
)))
2177 assert(rc
== MEMCACHED_SUCCESS
);
2180 memcached_result_free(&results_obj
);
2186 uint8_t mget_read_function(memcached_st
*memc
)
2188 memcached_return rc
;
2189 unsigned int counter
;
2190 unsigned int (*callbacks
[1])(memcached_st
*, memcached_result_st
*, void *);
2192 rc
= memcached_mget(memc
, global_keys
, global_keys_length
, global_count
);
2193 assert(rc
== MEMCACHED_SUCCESS
);
2195 callbacks
[0]= &callback_counter
;
2197 rc
= memcached_fetch_execute(memc
, callbacks
, (void *)&counter
, 1);
2202 uint8_t delete_generate(memcached_st
*memc
)
2206 for (x
= 0; x
< global_count
; x
++)
2208 (void)memcached_delete(memc
, global_keys
[x
], global_keys_length
[x
], (time_t)0);
2214 uint8_t delete_buffer_generate(memcached_st
*memc
)
2220 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_BUFFER_REQUESTS
, latch
);
2222 for (x
= 0; x
< global_count
; x
++)
2224 (void)memcached_delete(memc
, global_keys
[x
], global_keys_length
[x
], (time_t)0);
2230 uint8_t free_data(memcached_st
*memc
)
2232 pairs_free(global_pairs
);
2237 uint8_t add_host_test1(memcached_st
*memc
)
2240 memcached_return rc
;
2241 char servername
[]= "0.example.com";
2242 memcached_server_st
*servers
;
2244 servers
= memcached_server_list_append(NULL
, servername
, 400, &rc
);
2246 assert(1 == memcached_server_list_count(servers
));
2248 for (x
= 2; x
< 20; x
++)
2250 char buffer
[SMALL_STRING_LEN
];
2252 snprintf(buffer
, SMALL_STRING_LEN
, "%u.example.com", 400+x
);
2253 servers
= memcached_server_list_append(servers
, buffer
, 401,
2255 assert(rc
== MEMCACHED_SUCCESS
);
2256 assert(x
== memcached_server_list_count(servers
));
2259 rc
= memcached_server_push(memc
, servers
);
2260 assert(rc
== MEMCACHED_SUCCESS
);
2261 rc
= memcached_server_push(memc
, servers
);
2262 assert(rc
== MEMCACHED_SUCCESS
);
2264 memcached_server_list_free(servers
);
2269 memcached_return
pre_nonblock(memcached_st
*memc
)
2271 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NO_BLOCK
, 0);
2273 return MEMCACHED_SUCCESS
;
2276 memcached_return
pre_murmur(memcached_st
*memc
)
2278 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_HASH
, (uint64_t)MEMCACHED_HASH_MURMUR
);
2280 return MEMCACHED_SUCCESS
;
2283 memcached_return
pre_md5(memcached_st
*memc
)
2285 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_HASH
, (uint64_t)MEMCACHED_HASH_MD5
);
2287 return MEMCACHED_SUCCESS
;
2290 memcached_return
pre_crc(memcached_st
*memc
)
2292 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_HASH
, (uint64_t)MEMCACHED_HASH_CRC
);
2294 return MEMCACHED_SUCCESS
;
2297 memcached_return
pre_hsieh(memcached_st
*memc
)
2299 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_HASH
, (uint64_t)MEMCACHED_HASH_HSIEH
);
2301 return MEMCACHED_SUCCESS
;
2304 memcached_return
pre_hash_fnv1_64(memcached_st
*memc
)
2306 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_HASH
, (uint64_t)MEMCACHED_HASH_FNV1_64
);
2308 return MEMCACHED_SUCCESS
;
2311 memcached_return
pre_hash_fnv1a_64(memcached_st
*memc
)
2313 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_HASH
, (uint64_t)MEMCACHED_HASH_FNV1A_64
);
2315 return MEMCACHED_SUCCESS
;
2318 memcached_return
pre_hash_fnv1_32(memcached_st
*memc
)
2320 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_HASH
, (uint64_t)MEMCACHED_HASH_FNV1_32
);
2322 return MEMCACHED_SUCCESS
;
2325 memcached_return
pre_hash_fnv1a_32(memcached_st
*memc
)
2327 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_HASH
, (uint64_t)MEMCACHED_HASH_FNV1A_32
);
2329 return MEMCACHED_SUCCESS
;
2332 memcached_return
pre_hash_ketama(memcached_st
*memc
)
2334 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_HASH
, (uint64_t)MEMCACHED_HASH_KETAMA
);
2336 return MEMCACHED_SUCCESS
;
2339 void my_free(memcached_st
*ptr
, void *mem
)
2344 void *my_malloc(memcached_st
*ptr
, const size_t size
)
2346 return malloc(size
);
2349 void *my_realloc(memcached_st
*ptr
, void *mem
, const size_t size
)
2351 return realloc(mem
, size
);
2354 memcached_return
set_memory_alloc(memcached_st
*memc
)
2357 memcached_malloc_function test_ptr
;
2358 memcached_return rc
;
2360 rc
= memcached_callback_set(memc
, MEMCACHED_CALLBACK_MALLOC_FUNCTION
, &my_malloc
);
2361 assert(rc
== MEMCACHED_SUCCESS
);
2362 test_ptr
= (memcached_malloc_function
)memcached_callback_get(memc
, MEMCACHED_CALLBACK_MALLOC_FUNCTION
, &rc
);
2363 assert(rc
== MEMCACHED_SUCCESS
);
2364 assert(test_ptr
== my_malloc
);
2368 memcached_realloc_function test_ptr
;
2369 memcached_return rc
;
2371 rc
= memcached_callback_set(memc
, MEMCACHED_CALLBACK_REALLOC_FUNCTION
, &my_realloc
);
2372 assert(rc
== MEMCACHED_SUCCESS
);
2373 test_ptr
= (memcached_realloc_function
)memcached_callback_get(memc
, MEMCACHED_CALLBACK_REALLOC_FUNCTION
, &rc
);
2374 assert(rc
== MEMCACHED_SUCCESS
);
2375 assert(test_ptr
== my_realloc
);
2379 memcached_free_function test_ptr
;
2380 memcached_return rc
;
2382 rc
= memcached_callback_set(memc
, MEMCACHED_CALLBACK_FREE_FUNCTION
, my_free
);
2383 assert(rc
== MEMCACHED_SUCCESS
);
2384 test_ptr
= (memcached_free_function
)memcached_callback_get(memc
, MEMCACHED_CALLBACK_FREE_FUNCTION
, &rc
);
2385 assert(rc
== MEMCACHED_SUCCESS
);
2386 assert(test_ptr
== my_free
);
2389 return MEMCACHED_SUCCESS
;
2392 memcached_return
enable_consistent(memcached_st
*memc
)
2394 memcached_server_distribution value
= MEMCACHED_DISTRIBUTION_CONSISTENT
;
2395 memcached_hash hash
;
2396 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_DISTRIBUTION
, value
);
2399 value
= (memcached_server_distribution
)memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_DISTRIBUTION
);
2400 assert(value
== MEMCACHED_DISTRIBUTION_CONSISTENT
);
2402 hash
= (memcached_hash
)memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_HASH
);
2403 assert(hash
== MEMCACHED_HASH_HSIEH
);
2406 return MEMCACHED_SUCCESS
;
2409 memcached_return
enable_cas(memcached_st
*memc
)
2411 unsigned int set
= 1;
2413 memcached_version(memc
);
2415 if (memc
->hosts
[0].major_version
>= 1 &&
2416 memc
->hosts
[0].minor_version
>= 2 &&
2417 memc
->hosts
[0].micro_version
>= 4)
2419 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_SUPPORT_CAS
, set
);
2421 return MEMCACHED_SUCCESS
;
2424 return MEMCACHED_FAILURE
;
2427 memcached_return
check_for_1_2_3(memcached_st
*memc
)
2429 memcached_version(memc
);
2431 if (memc
->hosts
[0].major_version
>= 1 &&
2432 memc
->hosts
[0].minor_version
>= 2 &&
2433 memc
->hosts
[0].micro_version
>= 4)
2434 return MEMCACHED_SUCCESS
;
2436 return MEMCACHED_FAILURE
;
2439 memcached_return
pre_unix_socket(memcached_st
*memc
)
2441 memcached_return rc
;
2444 memcached_server_list_free(memc
->hosts
);
2446 memc
->number_of_hosts
= 0;
2448 if (stat("/tmp/memcached.socket", &buf
))
2449 return MEMCACHED_FAILURE
;
2451 rc
= memcached_server_add_unix_socket(memc
, "/tmp/memcached.socket");
2456 memcached_return
pre_udp(memcached_st
*memc
)
2458 memcached_return rc
;
2460 memcached_server_list_free(memc
->hosts
);
2462 memc
->number_of_hosts
= 0;
2465 return MEMCACHED_FAILURE
;
2467 rc
= memcached_server_add_udp(memc
, "localhost", MEMCACHED_DEFAULT_PORT
);
2472 memcached_return
pre_nodelay(memcached_st
*memc
)
2474 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NO_BLOCK
, 0);
2475 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_TCP_NODELAY
, 0);
2477 return MEMCACHED_SUCCESS
;
2480 memcached_return
poll_timeout(memcached_st
*memc
)
2486 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_POLL_TIMEOUT
, timeout
);
2488 timeout
= (int32_t)memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_POLL_TIMEOUT
);
2490 assert(timeout
== 100);
2492 return MEMCACHED_SUCCESS
;
2496 /* Clean the server before beginning testing */
2498 {"flush", 0, flush_test
},
2499 {"init", 0, init_test
},
2500 {"allocation", 0, allocation_test
},
2501 {"server_list_null_test", 0, server_list_null_test
},
2502 {"server_sort", 0, server_sort_test
},
2503 {"clone_test", 0, clone_test
},
2504 {"error", 0, error_test
},
2505 {"set", 0, set_test
},
2506 {"set2", 0, set_test2
},
2507 {"set3", 0, set_test3
},
2508 {"add", 1, add_test
},
2509 {"replace", 1, replace_test
},
2510 {"delete", 1, delete_test
},
2511 {"get", 1, get_test
},
2512 {"get2", 0, get_test2
},
2513 {"get3", 0, get_test3
},
2514 {"get4", 0, get_test4
},
2515 {"stats_servername", 0, stats_servername_test
},
2516 {"increment", 0, increment_test
},
2517 {"decrement", 0, decrement_test
},
2518 {"quit", 0, quit_test
},
2519 {"mget", 1, mget_test
},
2520 {"mget_result", 1, mget_result_test
},
2521 {"mget_result_alloc", 1, mget_result_alloc_test
},
2522 {"mget_result_function", 1, mget_result_function
},
2523 {"get_stats", 0, get_stats
},
2524 {"add_host_test", 0, add_host_test
},
2525 {"get_stats_keys", 0, get_stats_keys
},
2526 {"behavior_test", 0, get_stats_keys
},
2527 {"callback_test", 0, get_stats_keys
},
2528 {"version_string_test", 0, version_string_test
},
2529 {"bad_key", 1, bad_key_test
},
2530 {"memcached_server_cursor", 1, memcached_server_cursor_test
},
2531 {"read_through", 1, read_through
},
2535 test_st async_tests
[] ={
2536 {"add", 1, add_wrapper
},
2540 test_st string_tests
[] ={
2541 {"string static with null", 0, string_static_null
},
2542 {"string alloc with null", 0, string_alloc_null
},
2543 {"string alloc with 1K", 0, string_alloc_with_size
},
2544 {"string alloc with malloc failure", 0, string_alloc_with_size_toobig
},
2545 {"string append", 0, string_alloc_append
},
2546 {"string append failure (too big)", 0, string_alloc_append_toobig
},
2550 test_st result_tests
[] ={
2551 {"result static", 0, result_static
},
2552 {"result alloc", 0, result_alloc
},
2556 test_st version_1_2_3
[] ={
2557 {"append", 0, append_test
},
2558 {"prepend", 0, prepend_test
},
2559 {"cas", 0, cas_test
},
2560 {"cas2", 0, cas2_test
},
2561 {"append_binary", 0, append_binary_test
},
2565 test_st user_tests
[] ={
2566 {"user_supplied_bug1", 0, user_supplied_bug1
},
2567 {"user_supplied_bug2", 0, user_supplied_bug2
},
2568 {"user_supplied_bug3", 0, user_supplied_bug3
},
2569 {"user_supplied_bug4", 0, user_supplied_bug4
},
2570 {"user_supplied_bug5", 1, user_supplied_bug5
},
2571 {"user_supplied_bug6", 1, user_supplied_bug6
},
2572 {"user_supplied_bug7", 1, user_supplied_bug7
},
2573 {"user_supplied_bug8", 1, user_supplied_bug8
},
2574 {"user_supplied_bug9", 1, user_supplied_bug9
},
2575 {"user_supplied_bug10", 1, user_supplied_bug10
},
2576 {"user_supplied_bug11", 1, user_supplied_bug11
},
2577 {"user_supplied_bug12", 1, user_supplied_bug12
},
2578 {"user_supplied_bug13", 1, user_supplied_bug13
},
2579 {"user_supplied_bug14", 1, user_supplied_bug14
},
2580 {"user_supplied_bug15", 1, user_supplied_bug15
},
2584 test_st generate_tests
[] ={
2585 {"generate_pairs", 1, generate_pairs
},
2586 {"generate_data", 1, generate_data
},
2587 {"get_read", 0, get_read
},
2588 {"delete_generate", 0, delete_generate
},
2589 {"generate_buffer_data", 1, generate_buffer_data
},
2590 {"delete_buffer", 0, delete_buffer_generate
},
2591 {"generate_data", 1, generate_data
},
2592 {"mget_read", 0, mget_read
},
2593 {"mget_read_result", 0, mget_read_result
},
2594 {"mget_read_function", 0, mget_read_function
},
2595 {"cleanup", 1, cleanup_pairs
},
2596 {"generate_large_pairs", 1, generate_large_pairs
},
2597 {"generate_data", 1, generate_data
},
2598 {"generate_buffer_data", 1, generate_buffer_data
},
2599 {"cleanup", 1, cleanup_pairs
},
2604 collection_st collection
[] ={
2605 {"block", 0, 0, tests
},
2606 {"nonblock", pre_nonblock
, 0, tests
},
2607 {"nodelay", pre_nodelay
, 0, tests
},
2608 {"md5", pre_md5
, 0, tests
},
2609 {"crc", pre_crc
, 0, tests
},
2610 {"hsieh", pre_hsieh
, 0, tests
},
2611 {"fnv1_64", pre_hash_fnv1_64
, 0, tests
},
2612 {"fnv1a_64", pre_hash_fnv1a_64
, 0, tests
},
2613 {"fnv1_32", pre_hash_fnv1_32
, 0, tests
},
2614 {"fnv1a_32", pre_hash_fnv1a_32
, 0, tests
},
2615 {"ketama", pre_hash_ketama
, 0, tests
},
2616 {"unix_socket", pre_unix_socket
, 0, tests
},
2617 {"unix_socket_nodelay", pre_nodelay
, 0, tests
},
2618 {"poll_timeout", poll_timeout
, 0, tests
},
2619 {"gets", enable_cas
, 0, tests
},
2620 {"consistent", enable_consistent
, 0, tests
},
2621 {"memory_allocators", set_memory_alloc
, 0, tests
},
2622 // {"udp", pre_udp, 0, tests},
2623 {"version_1_2_3", check_for_1_2_3
, 0, version_1_2_3
},
2624 {"string", 0, 0, string_tests
},
2625 {"result", 0, 0, result_tests
},
2626 {"async", pre_nonblock
, 0, async_tests
},
2627 {"user", 0, 0, user_tests
},
2628 {"generate", 0, 0, generate_tests
},
2629 {"generate_hsieh", pre_hsieh
, 0, generate_tests
},
2630 {"generate_hsieh_consistent", enable_consistent
, 0, generate_tests
},
2631 {"generate_md5", pre_md5
, 0, generate_tests
},
2632 {"generate_murmur", pre_murmur
, 0, generate_tests
},
2633 {"generate_nonblock", pre_nonblock
, 0, generate_tests
},
2637 #define SERVERS_TO_CREATE 5
2639 void *world_create(void)
2641 server_startup_st
*construct
;
2643 construct
= (server_startup_st
*)malloc(sizeof(server_startup_st
));
2644 memset(construct
, 0, sizeof(server_startup_st
));
2645 construct
->count
= SERVERS_TO_CREATE
;
2647 server_startup(construct
);
2652 void world_destroy(void *p
)
2654 server_startup_st
*construct
= (server_startup_st
*)p
;
2655 memcached_server_st
*servers
= (memcached_server_st
*)construct
->servers
;
2656 memcached_server_list_free(servers
);
2658 server_shutdown(construct
);
2662 void get_world(world_st
*world
)
2664 world
->collections
= collection
;
2665 world
->create
= world_create
;
2666 world
->destroy
= world_destroy
;