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
);
70 *((uint32_t *)(context
))= server
->port
;
72 return MEMCACHED_SUCCESS
;
75 uint8_t server_sort_test(memcached_st
*ptr
)
78 uint32_t bigger
= 0; /* Prime the value for the assert in server_display_function */
80 memcached_server_function callbacks
[1];
81 memcached_st
*local_memc
;
83 local_memc
= memcached_create(NULL
);
85 memcached_behavior_set(local_memc
, MEMCACHED_BEHAVIOR_SORT_HOSTS
, 1);
87 for (x
= 0; x
< TEST_PORT_COUNT
; x
++)
89 test_ports
[x
]= random() % 64000;
90 rc
= memcached_server_add(local_memc
, "localhost", test_ports
[x
]);
91 assert(local_memc
->number_of_hosts
== x
+1);
92 assert(local_memc
->hosts
[0].count
== x
+1);
93 assert(rc
== MEMCACHED_SUCCESS
);
96 callbacks
[0]= server_display_function
;
97 memcached_server_cursor(local_memc
, callbacks
, (void *)&bigger
, 1);
100 memcached_free(local_memc
);
105 memcached_return
server_display_unsort_function(memcached_st
*ptr
, memcached_server_st
*server
, void *context
)
108 uint32_t x
= *((uint32_t *)(context
));
110 assert(test_ports
[x
] == server
->port
);
111 *((uint32_t *)(context
))= ++x
;
113 return MEMCACHED_SUCCESS
;
116 uint8_t server_unsort_test(memcached_st
*ptr
)
119 uint32_t counter
= 0; /* Prime the value for the assert in server_display_function */
121 memcached_server_function callbacks
[1];
122 memcached_st
*local_memc
;
124 local_memc
= memcached_create(NULL
);
127 for (x
= 0; x
< TEST_PORT_COUNT
; x
++)
129 test_ports
[x
]= random() % 64000;
130 rc
= memcached_server_add(local_memc
, "localhost", test_ports
[x
]);
131 assert(local_memc
->number_of_hosts
== x
+1);
132 assert(local_memc
->hosts
[0].count
== x
+1);
133 assert(rc
== MEMCACHED_SUCCESS
);
136 callbacks
[0]= server_display_unsort_function
;
137 memcached_server_cursor(local_memc
, callbacks
, (void *)&counter
, 1);
140 memcached_free(local_memc
);
145 uint8_t allocation_test(memcached_st
*not_used
)
148 memc
= memcached_create(NULL
);
150 memcached_free(memc
);
155 uint8_t clone_test(memcached_st
*memc
)
160 clone
= memcached_clone(NULL
, NULL
);
162 memcached_free(clone
);
165 /* Can we init from null? */
168 clone
= memcached_clone(NULL
, memc
);
170 memcached_free(clone
);
173 /* Can we init from struct? */
175 memcached_st declared_clone
;
177 clone
= memcached_clone(&declared_clone
, NULL
);
179 memcached_free(clone
);
182 /* Can we init from struct? */
184 memcached_st declared_clone
;
186 clone
= memcached_clone(&declared_clone
, memc
);
188 memcached_free(clone
);
194 uint8_t connection_test(memcached_st
*memc
)
198 rc
= memcached_server_add(memc
, "localhost", 0);
199 assert(rc
== MEMCACHED_SUCCESS
);
204 uint8_t error_test(memcached_st
*memc
)
208 for (rc
= MEMCACHED_SUCCESS
; rc
< MEMCACHED_MAXIMUM_RETURN
; rc
++)
210 printf("Error %d -> %s\n", rc
, memcached_strerror(memc
, rc
));
216 uint8_t set_test(memcached_st
*memc
)
220 char *value
= "when we sanitize";
222 rc
= memcached_set(memc
, key
, strlen(key
),
223 value
, strlen(value
),
224 (time_t)0, (uint32_t)0);
225 assert(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
);
230 uint8_t append_test(memcached_st
*memc
)
238 rc
= memcached_flush(memc
, 0);
239 assert(rc
== MEMCACHED_SUCCESS
);
241 rc
= memcached_set(memc
, key
, strlen(key
),
242 value
, strlen(value
),
243 (time_t)0, (uint32_t)0);
244 assert(rc
== MEMCACHED_SUCCESS
);
246 rc
= memcached_append(memc
, key
, strlen(key
),
247 " the", strlen(" the"),
248 (time_t)0, (uint32_t)0);
249 assert(rc
== MEMCACHED_SUCCESS
);
251 rc
= memcached_append(memc
, key
, strlen(key
),
252 " people", strlen(" people"),
253 (time_t)0, (uint32_t)0);
254 assert(rc
== MEMCACHED_SUCCESS
);
256 value
= memcached_get(memc
, key
, strlen(key
),
257 &value_length
, &flags
, &rc
);
258 assert(!memcmp(value
, "we the people", strlen("we the people")));
259 assert(strlen("we the people") == value_length
);
260 assert(rc
== MEMCACHED_SUCCESS
);
266 uint8_t append_binary_test(memcached_st
*memc
)
269 char *key
= "numbers";
270 unsigned int *store_ptr
;
271 unsigned int store_list
[] = { 23, 56, 499, 98, 32847, 0 };
277 rc
= memcached_flush(memc
, 0);
278 assert(rc
== MEMCACHED_SUCCESS
);
280 rc
= memcached_set(memc
,
283 (time_t)0, (uint32_t)0);
284 assert(rc
== MEMCACHED_SUCCESS
);
286 for (x
= 0; store_list
[x
] ; x
++)
288 rc
= memcached_append(memc
,
290 (char *)&store_list
[x
], sizeof(unsigned int),
291 (time_t)0, (uint32_t)0);
292 assert(rc
== MEMCACHED_SUCCESS
);
295 value
= memcached_get(memc
, key
, strlen(key
),
296 &value_length
, &flags
, &rc
);
297 assert((value_length
== (sizeof(unsigned int) * x
)));
298 assert(rc
== MEMCACHED_SUCCESS
);
300 store_ptr
= (unsigned int *)value
;
302 while ((size_t)store_ptr
< (size_t)(value
+ value_length
))
304 assert(*store_ptr
== store_list
[x
++]);
312 uint8_t cas2_test(memcached_st
*memc
)
315 char *keys
[]= {"fudge", "son", "food"};
316 size_t key_length
[]= {5, 3, 4};
317 char *value
= "we the people";
318 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 for (x
= 0; x
< 3; x
++)
331 rc
= memcached_set(memc
, keys
[x
], key_length
[x
],
332 keys
[x
], key_length
[x
],
333 (time_t)50, (uint32_t)9);
334 assert(rc
== MEMCACHED_SUCCESS
);
337 rc
= memcached_mget(memc
, keys
, key_length
, 3);
339 results
= memcached_result_create(memc
, &results_obj
);
341 results
= memcached_fetch_result(memc
, &results_obj
, &rc
);
343 assert(results
->cas
);
344 assert(rc
== MEMCACHED_SUCCESS
);
345 WATCHPOINT_ASSERT(memcached_result_cas(results
));
347 assert(!memcmp(value
, "we the people", strlen("we the people")));
348 assert(strlen("we the people") == value_length
);
349 assert(rc
== MEMCACHED_SUCCESS
);
351 memcached_result_free(&results_obj
);
356 uint8_t cas_test(memcached_st
*memc
)
360 size_t key_length
= strlen("fun");
361 char *value
= "we the people";
362 size_t value_length
= strlen("we the people");
363 memcached_result_st results_obj
;
364 memcached_result_st
*results
;
367 rc
= memcached_flush(memc
, 0);
368 assert(rc
== MEMCACHED_SUCCESS
);
370 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_SUPPORT_CAS
, set
);
372 rc
= memcached_set(memc
, key
, strlen(key
),
373 value
, strlen(value
),
374 (time_t)0, (uint32_t)0);
375 assert(rc
== MEMCACHED_SUCCESS
);
377 rc
= memcached_mget(memc
, &key
, &key_length
, 1);
379 results
= memcached_result_create(memc
, &results_obj
);
381 results
= memcached_fetch_result(memc
, &results_obj
, &rc
);
383 assert(rc
== MEMCACHED_SUCCESS
);
384 WATCHPOINT_ASSERT(memcached_result_cas(results
));
386 assert(!memcmp(value
, "we the people", strlen("we the people")));
387 assert(strlen("we the people") == value_length
);
388 assert(rc
== MEMCACHED_SUCCESS
);
390 rc
= memcached_cas(memc
, key
, key_length
,
391 "change the value", strlen("change the value"),
392 0, 0, memcached_result_cas(results
));
394 assert(rc
== MEMCACHED_SUCCESS
);
396 rc
= memcached_cas(memc
, key
, key_length
,
397 "change the value", strlen("change the value"),
400 assert(rc
== MEMCACHED_DATA_EXISTS
);
403 memcached_result_free(&results_obj
);
408 uint8_t prepend_test(memcached_st
*memc
)
412 char *value
= "people";
416 rc
= memcached_flush(memc
, 0);
417 assert(rc
== MEMCACHED_SUCCESS
);
419 rc
= memcached_set(memc
, key
, strlen(key
),
420 value
, strlen(value
),
421 (time_t)0, (uint32_t)0);
422 assert(rc
== MEMCACHED_SUCCESS
);
424 rc
= memcached_prepend(memc
, key
, strlen(key
),
425 "the ", strlen("the "),
426 (time_t)0, (uint32_t)0);
427 assert(rc
== MEMCACHED_SUCCESS
);
429 rc
= memcached_prepend(memc
, key
, strlen(key
),
430 "we ", strlen("we "),
431 (time_t)0, (uint32_t)0);
432 assert(rc
== MEMCACHED_SUCCESS
);
434 value
= memcached_get(memc
, key
, strlen(key
),
435 &value_length
, &flags
, &rc
);
436 assert(!memcmp(value
, "we the people", strlen("we the people")));
437 assert(strlen("we the people") == value_length
);
438 assert(rc
== MEMCACHED_SUCCESS
);
445 Set the value, then quit to make sure it is flushed.
446 Come back in and test that add fails.
448 uint8_t add_test(memcached_st
*memc
)
452 char *value
= "when we sanitize";
453 unsigned long long setting_value
;
455 setting_value
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_NO_BLOCK
);
457 rc
= memcached_set(memc
, key
, strlen(key
),
458 value
, strlen(value
),
459 (time_t)0, (uint32_t)0);
460 assert(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
);
461 memcached_quit(memc
);
462 rc
= memcached_add(memc
, key
, strlen(key
),
463 value
, strlen(value
),
464 (time_t)0, (uint32_t)0);
466 /* Too many broken OS'es have broken loopback in async, so we can't be sure of the result */
468 assert(rc
== MEMCACHED_NOTSTORED
|| MEMCACHED_STORED
);
470 assert(rc
== MEMCACHED_NOTSTORED
);
475 uint8_t add_wrapper(memcached_st
*memc
)
479 for (x
= 0; x
< 10000; x
++)
485 uint8_t replace_test(memcached_st
*memc
)
489 char *value
= "when we sanitize";
490 char *original
= "first we insert some data";
492 rc
= memcached_set(memc
, key
, strlen(key
),
493 original
, strlen(original
),
494 (time_t)0, (uint32_t)0);
495 assert(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
);
497 rc
= memcached_replace(memc
, key
, strlen(key
),
498 value
, strlen(value
),
499 (time_t)0, (uint32_t)0);
500 assert(rc
== MEMCACHED_SUCCESS
);
505 uint8_t delete_test(memcached_st
*memc
)
509 char *value
= "when we sanitize";
511 rc
= memcached_set(memc
, key
, strlen(key
),
512 value
, strlen(value
),
513 (time_t)0, (uint32_t)0);
514 assert(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
);
516 rc
= memcached_delete(memc
, key
, strlen(key
), (time_t)0);
517 assert(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
);
522 uint8_t flush_test(memcached_st
*memc
)
526 rc
= memcached_flush(memc
, 0);
527 assert(rc
== MEMCACHED_SUCCESS
);
532 memcached_return
server_function(memcached_st
*ptr
, memcached_server_st
*server
, void *context
)
536 return MEMCACHED_SUCCESS
;
539 uint8_t memcached_server_cursor_test(memcached_st
*memc
)
541 char *context
= "foo bad";
542 memcached_server_function callbacks
[1];
544 callbacks
[0]= server_function
;
545 memcached_server_cursor(memc
, callbacks
, context
, 1);
550 uint8_t bad_key_test(memcached_st
*memc
)
553 char *key
= "foo bad";
555 size_t string_length
;
560 clone
= memcached_clone(NULL
, memc
);
563 (void)memcached_behavior_set(clone
, MEMCACHED_BEHAVIOR_VERIFY_KEY
, set
);
565 string
= memcached_get(clone
, key
, strlen(key
),
566 &string_length
, &flags
, &rc
);
567 assert(rc
== MEMCACHED_BAD_KEY_PROVIDED
);
568 assert(string_length
== 0);
572 (void)memcached_behavior_set(clone
, MEMCACHED_BEHAVIOR_VERIFY_KEY
, set
);
573 string
= memcached_get(clone
, key
, strlen(key
),
574 &string_length
, &flags
, &rc
);
575 assert(rc
== MEMCACHED_NOTFOUND
);
576 assert(string_length
== 0);
579 memcached_free(clone
);
584 #define READ_THROUGH_VALUE "set for me"
585 memcached_return
read_through_trigger(memcached_st
*memc
,
586 char *key
, size_t key_length
,
587 memcached_result_st
*result
)
590 return memcached_result_set_value(result
, READ_THROUGH_VALUE
, strlen(READ_THROUGH_VALUE
));
593 uint8_t read_through(memcached_st
*memc
)
598 size_t string_length
;
601 string
= memcached_get(memc
, key
, strlen(key
),
602 &string_length
, &flags
, &rc
);
604 assert(rc
== MEMCACHED_NOTFOUND
);
605 assert(string_length
== 0);
608 rc
= memcached_callback_set(memc
, MEMCACHED_CALLBACK_GET_FAILURE
, read_through_trigger
);
609 assert(rc
== MEMCACHED_SUCCESS
);
611 string
= memcached_get(memc
, key
, strlen(key
),
612 &string_length
, &flags
, &rc
);
614 assert(rc
== MEMCACHED_SUCCESS
);
615 assert(string_length
== strlen(READ_THROUGH_VALUE
));
616 assert(!strcmp(READ_THROUGH_VALUE
, string
));
618 string
= memcached_get(memc
, key
, strlen(key
),
619 &string_length
, &flags
, &rc
);
621 assert(rc
== MEMCACHED_SUCCESS
);
622 assert(string_length
== strlen(READ_THROUGH_VALUE
));
623 assert(!strcmp(READ_THROUGH_VALUE
, string
));
628 memcached_return
delete_trigger(memcached_st
*ptr
, char *key
, size_t key_length
)
632 return MEMCACHED_SUCCESS
;
635 uint8_t delete_through(memcached_st
*memc
)
637 memcached_trigger_delete_key callback
;
640 callback
= delete_trigger
;
642 rc
= memcached_callback_set(memc
, MEMCACHED_CALLBACK_DELETE_TRIGGER
, callback
);
643 assert(rc
== MEMCACHED_SUCCESS
);
648 uint8_t get_test(memcached_st
*memc
)
653 size_t string_length
;
656 rc
= memcached_delete(memc
, key
, strlen(key
), (time_t)0);
657 assert(rc
== MEMCACHED_BUFFERED
|| rc
== MEMCACHED_NOTFOUND
);
659 string
= memcached_get(memc
, key
, strlen(key
),
660 &string_length
, &flags
, &rc
);
662 assert(rc
== MEMCACHED_NOTFOUND
);
663 assert(string_length
== 0);
669 uint8_t get_test2(memcached_st
*memc
)
673 char *value
= "when we sanitize";
675 size_t string_length
;
678 rc
= memcached_set(memc
, key
, strlen(key
),
679 value
, strlen(value
),
680 (time_t)0, (uint32_t)0);
681 assert(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
);
683 string
= memcached_get(memc
, key
, strlen(key
),
684 &string_length
, &flags
, &rc
);
687 assert(rc
== MEMCACHED_SUCCESS
);
688 assert(string_length
== strlen(value
));
689 assert(!memcmp(string
, value
, string_length
));
696 uint8_t set_test2(memcached_st
*memc
)
700 char *value
= "train in the brain";
701 size_t value_length
= strlen(value
);
704 for (x
= 0; x
< 10; x
++)
706 rc
= memcached_set(memc
, key
, strlen(key
),
708 (time_t)0, (uint32_t)0);
709 assert(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
);
715 uint8_t set_test3(memcached_st
*memc
)
720 size_t value_length
= 8191;
723 value
= (char*)malloc(value_length
);
726 for (x
= 0; x
< value_length
; x
++)
727 value
[x
] = (char) (x
% 127);
729 for (x
= 0; x
< 1; x
++)
731 rc
= memcached_set(memc
, key
, strlen(key
),
733 (time_t)0, (uint32_t)0);
734 assert(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
);
742 uint8_t get_test3(memcached_st
*memc
)
747 size_t value_length
= 8191;
749 size_t string_length
;
753 value
= (char*)malloc(value_length
);
756 for (x
= 0; x
< value_length
; x
++)
757 value
[x
] = (char) (x
% 127);
759 rc
= memcached_set(memc
, key
, strlen(key
),
761 (time_t)0, (uint32_t)0);
762 assert(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
);
764 string
= memcached_get(memc
, key
, strlen(key
),
765 &string_length
, &flags
, &rc
);
767 assert(rc
== MEMCACHED_SUCCESS
);
769 assert(string_length
== value_length
);
770 assert(!memcmp(string
, value
, string_length
));
778 uint8_t get_test4(memcached_st
*memc
)
783 size_t value_length
= 8191;
785 size_t string_length
;
789 value
= (char*)malloc(value_length
);
792 for (x
= 0; x
< value_length
; x
++)
793 value
[x
] = (char) (x
% 127);
795 rc
= memcached_set(memc
, key
, strlen(key
),
797 (time_t)0, (uint32_t)0);
798 assert(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
);
800 for (x
= 0; x
< 10; x
++)
802 string
= memcached_get(memc
, key
, strlen(key
),
803 &string_length
, &flags
, &rc
);
805 assert(rc
== MEMCACHED_SUCCESS
);
807 assert(string_length
== value_length
);
808 assert(!memcmp(string
, value
, string_length
));
817 /* Do not copy the style of this code, I just access hosts to testthis function */
818 uint8_t stats_servername_test(memcached_st
*memc
)
821 memcached_stat_st stat
;
822 rc
= memcached_stat_servername(&stat
, NULL
,
823 memc
->hosts
[0].hostname
,
824 memc
->hosts
[0].port
);
829 uint8_t increment_test(memcached_st
*memc
)
836 rc
= memcached_set(memc
, key
, strlen(key
),
837 value
, strlen(value
),
838 (time_t)0, (uint32_t)0);
839 assert(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
);
841 rc
= memcached_increment(memc
, key
, strlen(key
),
843 assert(rc
== MEMCACHED_SUCCESS
);
844 assert(new_number
== 1);
846 rc
= memcached_increment(memc
, key
, strlen(key
),
848 assert(rc
== MEMCACHED_SUCCESS
);
849 assert(new_number
== 2);
854 uint8_t decrement_test(memcached_st
*memc
)
861 rc
= memcached_set(memc
, key
, strlen(key
),
862 value
, strlen(value
),
863 (time_t)0, (uint32_t)0);
864 assert(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
);
866 rc
= memcached_decrement(memc
, key
, strlen(key
),
868 assert(rc
== MEMCACHED_SUCCESS
);
869 assert(new_number
== 2);
871 rc
= memcached_decrement(memc
, key
, strlen(key
),
873 assert(rc
== MEMCACHED_SUCCESS
);
874 assert(new_number
== 1);
879 uint8_t quit_test(memcached_st
*memc
)
883 char *value
= "sanford and sun";
885 rc
= memcached_set(memc
, key
, strlen(key
),
886 value
, strlen(value
),
887 (time_t)10, (uint32_t)3);
888 assert(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
);
889 memcached_quit(memc
);
891 rc
= memcached_set(memc
, key
, strlen(key
),
892 value
, strlen(value
),
893 (time_t)50, (uint32_t)9);
894 assert(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
);
899 uint8_t mget_result_test(memcached_st
*memc
)
902 char *keys
[]= {"fudge", "son", "food"};
903 size_t key_length
[]= {5, 3, 4};
906 memcached_result_st results_obj
;
907 memcached_result_st
*results
;
909 results
= memcached_result_create(memc
, &results_obj
);
911 assert(&results_obj
== results
);
913 /* We need to empty the server before continueing test */
914 rc
= memcached_flush(memc
, 0);
915 assert(rc
== MEMCACHED_SUCCESS
);
917 rc
= memcached_mget(memc
, keys
, key_length
, 3);
918 assert(rc
== MEMCACHED_SUCCESS
);
920 while ((results
= memcached_fetch_result(memc
, &results_obj
, &rc
)) != NULL
)
925 while ((results
= memcached_fetch_result(memc
, &results_obj
, &rc
)) != NULL
)
927 assert(rc
== MEMCACHED_END
);
929 for (x
= 0; x
< 3; x
++)
931 rc
= memcached_set(memc
, keys
[x
], key_length
[x
],
932 keys
[x
], key_length
[x
],
933 (time_t)50, (uint32_t)9);
934 assert(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
);
937 rc
= memcached_mget(memc
, keys
, key_length
, 3);
938 assert(rc
== MEMCACHED_SUCCESS
);
940 while ((results
= memcached_fetch_result(memc
, &results_obj
, &rc
)))
943 assert(&results_obj
== results
);
944 assert(rc
== MEMCACHED_SUCCESS
);
945 assert(memcached_result_key_length(results
) == memcached_result_length(results
));
946 assert(!memcmp(memcached_result_key_value(results
),
947 memcached_result_value(results
),
948 memcached_result_length(results
)));
951 memcached_result_free(&results_obj
);
956 uint8_t mget_result_alloc_test(memcached_st
*memc
)
959 char *keys
[]= {"fudge", "son", "food"};
960 size_t key_length
[]= {5, 3, 4};
963 memcached_result_st
*results
;
965 /* We need to empty the server before continueing test */
966 rc
= memcached_flush(memc
, 0);
967 assert(rc
== MEMCACHED_SUCCESS
);
969 rc
= memcached_mget(memc
, keys
, key_length
, 3);
970 assert(rc
== MEMCACHED_SUCCESS
);
972 while ((results
= memcached_fetch_result(memc
, NULL
, &rc
)) != NULL
)
977 assert(rc
== MEMCACHED_END
);
979 for (x
= 0; x
< 3; x
++)
981 rc
= memcached_set(memc
, keys
[x
], key_length
[x
],
982 keys
[x
], key_length
[x
],
983 (time_t)50, (uint32_t)9);
984 assert(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
);
987 rc
= memcached_mget(memc
, keys
, key_length
, 3);
988 assert(rc
== MEMCACHED_SUCCESS
);
991 while ((results
= memcached_fetch_result(memc
, NULL
, &rc
)))
994 assert(rc
== MEMCACHED_SUCCESS
);
995 assert(memcached_result_key_length(results
) == memcached_result_length(results
));
996 assert(!memcmp(memcached_result_key_value(results
),
997 memcached_result_value(results
),
998 memcached_result_length(results
)));
999 memcached_result_free(results
);
1006 /* Count the results */
1007 unsigned int callback_counter(memcached_st
*ptr
, memcached_result_st
*result
, void *context
)
1009 unsigned int *counter
= (unsigned int *)context
;
1011 *counter
= *counter
+ 1;
1016 uint8_t mget_result_function(memcached_st
*memc
)
1018 memcached_return rc
;
1019 char *keys
[]= {"fudge", "son", "food"};
1020 size_t key_length
[]= {5, 3, 4};
1022 unsigned int counter
;
1023 memcached_execute_function callbacks
[1];
1025 /* We need to empty the server before continueing test */
1026 rc
= memcached_flush(memc
, 0);
1027 for (x
= 0; x
< 3; x
++)
1029 rc
= memcached_set(memc
, keys
[x
], key_length
[x
],
1030 keys
[x
], key_length
[x
],
1031 (time_t)50, (uint32_t)9);
1032 assert(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
);
1035 rc
= memcached_mget(memc
, keys
, key_length
, 3);
1036 assert(rc
== MEMCACHED_SUCCESS
);
1038 callbacks
[0]= &callback_counter
;
1040 rc
= memcached_fetch_execute(memc
, callbacks
, (void *)&counter
, 1);
1042 assert(counter
== 3);
1047 uint8_t mget_test(memcached_st
*memc
)
1049 memcached_return rc
;
1050 char *keys
[]= {"fudge", "son", "food"};
1051 size_t key_length
[]= {5, 3, 4};
1055 char return_key
[MEMCACHED_MAX_KEY
];
1056 size_t return_key_length
;
1058 size_t return_value_length
;
1060 /* We need to empty the server before continueing test */
1061 rc
= memcached_flush(memc
, 0);
1062 assert(rc
== MEMCACHED_SUCCESS
);
1064 rc
= memcached_mget(memc
, keys
, key_length
, 3);
1065 assert(rc
== MEMCACHED_SUCCESS
);
1067 while ((return_value
= memcached_fetch(memc
, return_key
, &return_key_length
,
1068 &return_value_length
, &flags
, &rc
)) != NULL
)
1070 assert(return_value
);
1072 assert(!return_value
);
1073 assert(return_value_length
== 0);
1074 assert(rc
== MEMCACHED_END
);
1076 for (x
= 0; x
< 3; x
++)
1078 rc
= memcached_set(memc
, keys
[x
], key_length
[x
],
1079 keys
[x
], key_length
[x
],
1080 (time_t)50, (uint32_t)9);
1081 assert(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
);
1084 rc
= memcached_mget(memc
, keys
, key_length
, 3);
1085 assert(rc
== MEMCACHED_SUCCESS
);
1088 while ((return_value
= memcached_fetch(memc
, return_key
, &return_key_length
,
1089 &return_value_length
, &flags
, &rc
)))
1091 assert(return_value
);
1092 assert(rc
== MEMCACHED_SUCCESS
);
1093 assert(return_key_length
== return_value_length
);
1094 assert(!memcmp(return_value
, return_key
, return_value_length
));
1102 uint8_t get_stats_keys(memcached_st
*memc
)
1106 memcached_stat_st stat
;
1107 memcached_return rc
;
1109 list
= memcached_stat_get_keys(memc
, &stat
, &rc
);
1110 assert(rc
== MEMCACHED_SUCCESS
);
1111 for (ptr
= list
; *ptr
; ptr
++)
1120 uint8_t version_string_test(memcached_st
*memc
)
1122 const char *version_string
;
1124 version_string
= memcached_lib_version();
1126 assert(!strcmp(version_string
, LIBMEMCACHED_VERSION_STRING
));
1131 uint8_t get_stats(memcached_st
*memc
)
1136 memcached_return rc
;
1137 memcached_stat_st
*stat
;
1139 stat
= memcached_stat(memc
, NULL
, &rc
);
1140 assert(rc
== MEMCACHED_SUCCESS
);
1142 assert(rc
== MEMCACHED_SUCCESS
);
1145 for (x
= 0; x
< memcached_server_count(memc
); x
++)
1147 list
= memcached_stat_get_keys(memc
, stat
+x
, &rc
);
1148 assert(rc
== MEMCACHED_SUCCESS
);
1149 for (ptr
= list
; *ptr
; ptr
++);
1154 memcached_stat_free(NULL
, stat
);
1159 uint8_t add_host_test(memcached_st
*memc
)
1162 memcached_server_st
*servers
;
1163 memcached_return rc
;
1164 char servername
[]= "0.example.com";
1166 servers
= memcached_server_list_append(NULL
, servername
, 400, &rc
);
1168 assert(1 == memcached_server_list_count(servers
));
1170 for (x
= 2; x
< 20; x
++)
1172 char buffer
[SMALL_STRING_LEN
];
1174 snprintf(buffer
, SMALL_STRING_LEN
, "%u.example.com", 400+x
);
1175 servers
= memcached_server_list_append(servers
, buffer
, 401,
1177 assert(rc
== MEMCACHED_SUCCESS
);
1178 assert(x
== memcached_server_list_count(servers
));
1181 rc
= memcached_server_push(memc
, servers
);
1182 assert(rc
== MEMCACHED_SUCCESS
);
1183 rc
= memcached_server_push(memc
, servers
);
1184 assert(rc
== MEMCACHED_SUCCESS
);
1186 memcached_server_list_free(servers
);
1191 memcached_return
clone_test_callback(memcached_st
*parent
, memcached_st
*clone
)
1193 return MEMCACHED_SUCCESS
;
1196 memcached_return
cleanup_test_callback(memcached_st
*ptr
)
1198 return MEMCACHED_SUCCESS
;
1201 uint8_t callback_test(memcached_st
*memc
)
1203 /* Test User Data */
1207 memcached_return rc
;
1209 rc
= memcached_callback_set(memc
, MEMCACHED_CALLBACK_USER_DATA
, &x
);
1210 assert(rc
== MEMCACHED_SUCCESS
);
1211 test_ptr
= (int *)memcached_callback_get(memc
, MEMCACHED_CALLBACK_USER_DATA
, &rc
);
1212 assert(*test_ptr
== x
);
1215 /* Test Clone Callback */
1217 memcached_clone_func temp_function
;
1218 memcached_return rc
;
1220 rc
= memcached_callback_set(memc
, MEMCACHED_CALLBACK_CLONE_FUNCTION
, clone_test_callback
);
1221 assert(rc
== MEMCACHED_SUCCESS
);
1222 temp_function
= (memcached_clone_func
)memcached_callback_get(memc
, MEMCACHED_CALLBACK_CLONE_FUNCTION
, &rc
);
1223 assert(temp_function
== clone_test_callback
);
1226 /* Test Cleanup Callback */
1228 memcached_cleanup_func temp_function
;
1229 memcached_return rc
;
1231 rc
= memcached_callback_set(memc
, MEMCACHED_CALLBACK_CLONE_FUNCTION
, cleanup_test_callback
);
1232 assert(rc
== MEMCACHED_SUCCESS
);
1233 temp_function
= (memcached_cleanup_func
)memcached_callback_get(memc
, MEMCACHED_CALLBACK_CLONE_FUNCTION
, &rc
);
1234 assert(temp_function
== cleanup_test_callback
);
1240 /* We don't test the behavior itself, we test the switches */
1241 uint8_t behavior_test(memcached_st
*memc
)
1243 unsigned long long value
;
1244 unsigned int set
= 1;
1246 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NO_BLOCK
, set
);
1247 value
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_NO_BLOCK
);
1250 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_TCP_NODELAY
, set
);
1251 value
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_TCP_NODELAY
);
1254 set
= MEMCACHED_HASH_MD5
;
1255 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_HASH
, set
);
1256 value
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_HASH
);
1257 assert(value
== MEMCACHED_HASH_MD5
);
1261 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NO_BLOCK
, set
);
1262 value
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_NO_BLOCK
);
1265 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_TCP_NODELAY
, set
);
1266 value
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_TCP_NODELAY
);
1269 set
= MEMCACHED_HASH_DEFAULT
;
1270 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_HASH
, set
);
1271 value
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_HASH
);
1272 assert(value
== MEMCACHED_HASH_DEFAULT
);
1274 set
= MEMCACHED_HASH_CRC
;
1275 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_HASH
, set
);
1276 value
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_HASH
);
1277 assert(value
== MEMCACHED_HASH_CRC
);
1279 value
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_SOCKET_SEND_SIZE
);
1282 value
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_SOCKET_RECV_SIZE
);
1288 /* Test case provided by Cal Haldenbrand */
1289 uint8_t user_supplied_bug1(memcached_st
*memc
)
1291 unsigned int setter
= 1;
1294 unsigned long long total
= 0;
1297 char randomstuff
[6 * 1024];
1298 memcached_return rc
;
1300 memset(randomstuff
, 0, 6 * 1024);
1302 /* We just keep looking at the same values over and over */
1305 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NO_BLOCK
, setter
);
1306 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_TCP_NODELAY
, setter
);
1310 for (x
= 0 ; total
< 20 * 1024576 ; x
++ )
1314 size
= (rand() % ( 5 * 1024 ) ) + 400;
1315 memset(randomstuff
, 0, 6 * 1024);
1316 assert(size
< 6 * 1024); /* Being safe here */
1318 for (j
= 0 ; j
< size
;j
++)
1319 randomstuff
[j
] = (char) (rand() % 26) + 97;
1322 sprintf(key
, "%d", x
);
1323 rc
= memcached_set(memc
, key
, strlen(key
),
1324 randomstuff
, strlen(randomstuff
), 10, 0);
1325 /* If we fail, lets try again */
1326 if (rc
!= MEMCACHED_SUCCESS
&& rc
!= MEMCACHED_BUFFERED
)
1327 rc
= memcached_set(memc
, key
, strlen(key
),
1328 randomstuff
, strlen(randomstuff
), 10, 0);
1329 assert(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
);
1335 /* Test case provided by Cal Haldenbrand */
1336 uint8_t user_supplied_bug2(memcached_st
*memc
)
1339 unsigned int setter
;
1341 unsigned long long total
;
1344 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NO_BLOCK
, setter
);
1345 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_TCP_NODELAY
, setter
);
1347 setter
= 20 * 1024576;
1348 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_SOCKET_SEND_SIZE
, setter
);
1349 setter
= 20 * 1024576;
1350 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_SOCKET_RECV_SIZE
, setter
);
1351 getter
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_SOCKET_SEND_SIZE
);
1352 getter
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_SOCKET_RECV_SIZE
);
1354 for (x
= 0, errors
= 0, total
= 0 ; total
< 20 * 1024576 ; x
++)
1357 for (x
= 0, errors
= 0, total
= 0 ; total
< 24576 ; x
++)
1359 memcached_return rc
= MEMCACHED_SUCCESS
;
1360 char buffer
[SMALL_STRING_LEN
];
1365 memset(buffer
, 0, SMALL_STRING_LEN
);
1367 snprintf(buffer
, SMALL_STRING_LEN
, "%u", x
);
1368 getval
= memcached_get(memc
, buffer
, strlen(buffer
),
1369 &val_len
, &flags
, &rc
);
1370 if (rc
!= MEMCACHED_SUCCESS
)
1372 if (rc
== MEMCACHED_NOTFOUND
)
1376 WATCHPOINT_ERROR(rc
);
1390 /* Do a large mget() over all the keys we think exist */
1391 #define KEY_COUNT 3000 // * 1024576
1392 uint8_t user_supplied_bug3(memcached_st
*memc
)
1394 memcached_return rc
;
1395 unsigned int setter
;
1398 size_t key_lengths
[KEY_COUNT
];
1401 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NO_BLOCK
, setter
);
1402 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_TCP_NODELAY
, setter
);
1404 setter
= 20 * 1024576;
1405 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_SOCKET_SEND_SIZE
, setter
);
1406 setter
= 20 * 1024576;
1407 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_SOCKET_RECV_SIZE
, setter
);
1408 getter
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_SOCKET_SEND_SIZE
);
1409 getter
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_SOCKET_RECV_SIZE
);
1412 keys
= (char **)malloc(sizeof(char *) * KEY_COUNT
);
1414 memset(keys
, 0, (sizeof(char *) * KEY_COUNT
));
1415 for (x
= 0; x
< KEY_COUNT
; x
++)
1419 snprintf(buffer
, 30, "%u", x
);
1420 keys
[x
]= strdup(buffer
);
1421 key_lengths
[x
]= strlen(keys
[x
]);
1424 rc
= memcached_mget(memc
, keys
, key_lengths
, KEY_COUNT
);
1425 assert(rc
== MEMCACHED_SUCCESS
);
1427 /* Turn this into a help function */
1429 char return_key
[MEMCACHED_MAX_KEY
];
1430 size_t return_key_length
;
1432 size_t return_value_length
;
1435 while ((return_value
= memcached_fetch(memc
, return_key
, &return_key_length
,
1436 &return_value_length
, &flags
, &rc
)))
1438 assert(return_value
);
1439 assert(rc
== MEMCACHED_SUCCESS
);
1444 for (x
= 0; x
< KEY_COUNT
; x
++)
1451 /* Make sure we behave properly if server list has no values */
1452 uint8_t user_supplied_bug4(memcached_st
*memc
)
1454 memcached_return rc
;
1455 char *keys
[]= {"fudge", "son", "food"};
1456 size_t key_length
[]= {5, 3, 4};
1459 char return_key
[MEMCACHED_MAX_KEY
];
1460 size_t return_key_length
;
1462 size_t return_value_length
;
1464 /* Here we free everything before running a bunch of mget tests */
1466 memcached_server_list_free(memc
->hosts
);
1468 memc
->number_of_hosts
= 0;
1472 /* We need to empty the server before continueing test */
1473 rc
= memcached_flush(memc
, 0);
1474 assert(rc
== MEMCACHED_NO_SERVERS
);
1476 rc
= memcached_mget(memc
, keys
, key_length
, 3);
1477 assert(rc
== MEMCACHED_NO_SERVERS
);
1479 while ((return_value
= memcached_fetch(memc
, return_key
, &return_key_length
,
1480 &return_value_length
, &flags
, &rc
)) != NULL
)
1482 assert(return_value
);
1484 assert(!return_value
);
1485 assert(return_value_length
== 0);
1486 assert(rc
== MEMCACHED_NO_SERVERS
);
1488 for (x
= 0; x
< 3; x
++)
1490 rc
= memcached_set(memc
, keys
[x
], key_length
[x
],
1491 keys
[x
], key_length
[x
],
1492 (time_t)50, (uint32_t)9);
1493 assert(rc
== MEMCACHED_NO_SERVERS
);
1496 rc
= memcached_mget(memc
, keys
, key_length
, 3);
1497 assert(rc
== MEMCACHED_NO_SERVERS
);
1500 while ((return_value
= memcached_fetch(memc
, return_key
, &return_key_length
,
1501 &return_value_length
, &flags
, &rc
)))
1503 assert(return_value
);
1504 assert(rc
== MEMCACHED_SUCCESS
);
1505 assert(return_key_length
== return_value_length
);
1506 assert(!memcmp(return_value
, return_key
, return_value_length
));
1514 #define VALUE_SIZE_BUG5 1048064
1515 uint8_t user_supplied_bug5(memcached_st
*memc
)
1517 memcached_return rc
;
1518 char *keys
[]= {"036790384900", "036790384902", "036790384904", "036790384906"};
1519 size_t key_length
[]= {strlen("036790384900"), strlen("036790384902"), strlen("036790384904"), strlen("036790384906")};
1520 char return_key
[MEMCACHED_MAX_KEY
];
1521 size_t return_key_length
;
1523 size_t value_length
;
1527 char insert_data
[VALUE_SIZE_BUG5
];
1529 for (x
= 0; x
< VALUE_SIZE_BUG5
; x
++)
1530 insert_data
[x
]= rand();
1532 memcached_flush(memc
, 0);
1533 value
= memcached_get(memc
, keys
[0], key_length
[0],
1534 &value_length
, &flags
, &rc
);
1535 assert(value
== NULL
);
1536 rc
= memcached_mget(memc
, keys
, key_length
, 4);
1539 while ((value
= memcached_fetch(memc
, return_key
, &return_key_length
,
1540 &value_length
, &flags
, &rc
)))
1544 for (x
= 0; x
< 4; x
++)
1546 rc
= memcached_set(memc
, keys
[x
], key_length
[x
],
1547 insert_data
, VALUE_SIZE_BUG5
,
1548 (time_t)0, (uint32_t)0);
1549 assert(rc
== MEMCACHED_SUCCESS
);
1552 for (x
= 0; x
< 10; x
++)
1554 value
= memcached_get(memc
, keys
[0], key_length
[0],
1555 &value_length
, &flags
, &rc
);
1559 rc
= memcached_mget(memc
, keys
, key_length
, 4);
1561 while ((value
= memcached_fetch(memc
, return_key
, &return_key_length
,
1562 &value_length
, &flags
, &rc
)))
1573 uint8_t user_supplied_bug6(memcached_st
*memc
)
1575 memcached_return rc
;
1576 char *keys
[]= {"036790384900", "036790384902", "036790384904", "036790384906"};
1577 size_t key_length
[]= {strlen("036790384900"), strlen("036790384902"), strlen("036790384904"), strlen("036790384906")};
1578 char return_key
[MEMCACHED_MAX_KEY
];
1579 size_t return_key_length
;
1581 size_t value_length
;
1585 char insert_data
[VALUE_SIZE_BUG5
];
1587 for (x
= 0; x
< VALUE_SIZE_BUG5
; x
++)
1588 insert_data
[x
]= rand();
1590 memcached_flush(memc
, 0);
1591 value
= memcached_get(memc
, keys
[0], key_length
[0],
1592 &value_length
, &flags
, &rc
);
1593 assert(value
== NULL
);
1594 assert(rc
== MEMCACHED_NOTFOUND
);
1595 rc
= memcached_mget(memc
, keys
, key_length
, 4);
1596 assert(rc
== MEMCACHED_SUCCESS
);
1599 while ((value
= memcached_fetch(memc
, return_key
, &return_key_length
,
1600 &value_length
, &flags
, &rc
)))
1603 assert(rc
== MEMCACHED_END
);
1605 for (x
= 0; x
< 4; x
++)
1607 rc
= memcached_set(memc
, keys
[x
], key_length
[x
],
1608 insert_data
, VALUE_SIZE_BUG5
,
1609 (time_t)0, (uint32_t)0);
1610 assert(rc
== MEMCACHED_SUCCESS
);
1613 for (x
= 0; x
< 2; x
++)
1615 value
= memcached_get(memc
, keys
[0], key_length
[0],
1616 &value_length
, &flags
, &rc
);
1620 rc
= memcached_mget(memc
, keys
, key_length
, 4);
1621 assert(rc
== MEMCACHED_SUCCESS
);
1623 /* We test for purge of partial complete fetches */
1624 for (count
= 3; count
; count
--)
1626 value
= memcached_fetch(memc
, return_key
, &return_key_length
,
1627 &value_length
, &flags
, &rc
);
1628 assert(rc
== MEMCACHED_SUCCESS
);
1629 assert(!(memcmp(value
, insert_data
, value_length
)));
1630 assert(value_length
);
1638 uint8_t user_supplied_bug8(memcached_st
*memc
)
1640 memcached_return rc
;
1642 memcached_st
*clone
;
1644 memcached_server_st
*servers
;
1645 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";
1647 servers
= memcached_servers_parse(server_list
);
1650 mine
= memcached_create(NULL
);
1651 rc
= memcached_server_push(mine
, servers
);
1652 assert(rc
== MEMCACHED_SUCCESS
);
1653 memcached_server_list_free(servers
);
1656 clone
= memcached_clone(NULL
, mine
);
1658 memcached_quit(mine
);
1659 memcached_quit(clone
);
1662 memcached_free(mine
);
1663 memcached_free(clone
);
1668 /* Test flag store/retrieve */
1669 uint8_t user_supplied_bug7(memcached_st
*memc
)
1671 memcached_return rc
;
1672 char *keys
= "036790384900";
1673 size_t key_length
= strlen("036790384900");
1674 char return_key
[MEMCACHED_MAX_KEY
];
1675 size_t return_key_length
;
1677 size_t value_length
;
1680 char insert_data
[VALUE_SIZE_BUG5
];
1682 for (x
= 0; x
< VALUE_SIZE_BUG5
; x
++)
1683 insert_data
[x
]= rand();
1685 memcached_flush(memc
, 0);
1688 rc
= memcached_set(memc
, keys
, key_length
,
1689 insert_data
, VALUE_SIZE_BUG5
,
1691 assert(rc
== MEMCACHED_SUCCESS
);
1694 value
= memcached_get(memc
, keys
, key_length
,
1695 &value_length
, &flags
, &rc
);
1696 assert(flags
== 245);
1700 rc
= memcached_mget(memc
, &keys
, &key_length
, 1);
1703 value
= memcached_fetch(memc
, return_key
, &return_key_length
,
1704 &value_length
, &flags
, &rc
);
1705 assert(flags
== 245);
1713 uint8_t user_supplied_bug9(memcached_st
*memc
)
1715 memcached_return rc
;
1716 char *keys
[]= {"UDATA:edevil@sapo.pt", "fudge&*@#", "for^#@&$not"};
1717 size_t key_length
[3];
1722 char return_key
[MEMCACHED_MAX_KEY
];
1723 size_t return_key_length
;
1725 size_t return_value_length
;
1728 key_length
[0]= strlen("UDATA:edevil@sapo.pt");
1729 key_length
[1]= strlen("fudge&*@#");
1730 key_length
[2]= strlen("for^#@&$not");
1733 for (x
= 0; x
< 3; x
++)
1735 rc
= memcached_set(memc
, keys
[x
], key_length
[x
],
1736 keys
[x
], key_length
[x
],
1737 (time_t)50, (uint32_t)9);
1738 assert(rc
== MEMCACHED_SUCCESS
);
1741 rc
= memcached_mget(memc
, keys
, key_length
, 3);
1742 assert(rc
== MEMCACHED_SUCCESS
);
1744 /* We need to empty the server before continueing test */
1745 while ((return_value
= memcached_fetch(memc
, return_key
, &return_key_length
,
1746 &return_value_length
, &flags
, &rc
)) != NULL
)
1748 assert(return_value
);
1757 /* We are testing with aggressive timeout to get failures */
1758 uint8_t user_supplied_bug10(memcached_st
*memc
)
1762 size_t value_length
= 512;
1765 memcached_return rc
;
1766 unsigned int set
= 1;
1767 memcached_st
*mclone
= memcached_clone(NULL
, memc
);
1770 memcached_behavior_set(mclone
, MEMCACHED_BEHAVIOR_NO_BLOCK
, set
);
1771 memcached_behavior_set(mclone
, MEMCACHED_BEHAVIOR_TCP_NODELAY
, set
);
1773 memcached_behavior_set(mclone
, MEMCACHED_BEHAVIOR_POLL_TIMEOUT
, timeout
);
1775 value
= (char*)malloc(value_length
* sizeof(char));
1777 for (x
= 0; x
< value_length
; x
++)
1778 value
[x
]= (char) (x
% 127);
1780 for (x
= 1; x
<= 100000; ++x
)
1782 rc
= memcached_set(mclone
, key
, key_len
,value
, value_length
, 0, 0);
1784 assert(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_WRITE_FAILURE
|| rc
== MEMCACHED_BUFFERED
);
1786 if (rc
== MEMCACHED_WRITE_FAILURE
)
1791 memcached_free(mclone
);
1797 We are looking failures in the async protocol
1799 uint8_t user_supplied_bug11(memcached_st
*memc
)
1803 size_t value_length
= 512;
1806 memcached_return rc
;
1807 unsigned int set
= 1;
1809 memcached_st
*mclone
= memcached_clone(NULL
, memc
);
1811 memcached_behavior_set(mclone
, MEMCACHED_BEHAVIOR_NO_BLOCK
, set
);
1812 memcached_behavior_set(mclone
, MEMCACHED_BEHAVIOR_TCP_NODELAY
, set
);
1814 memcached_behavior_set(mclone
, MEMCACHED_BEHAVIOR_POLL_TIMEOUT
, timeout
);
1816 timeout
= (int32_t)memcached_behavior_get(mclone
, MEMCACHED_BEHAVIOR_POLL_TIMEOUT
);
1818 assert(timeout
== -1);
1820 value
= (char*)malloc(value_length
* sizeof(char));
1822 for (x
= 0; x
< value_length
; x
++)
1823 value
[x
]= (char) (x
% 127);
1825 for (x
= 1; x
<= 100000; ++x
)
1827 rc
= memcached_set(mclone
, key
, key_len
,value
, value_length
, 0, 0);
1831 memcached_free(mclone
);
1837 Bug found where incr was not returning MEMCACHED_NOTFOUND when object did not exist.
1839 uint8_t user_supplied_bug12(memcached_st
*memc
)
1841 memcached_return rc
;
1843 size_t value_length
;
1845 uint64_t number_value
;
1847 value
= memcached_get(memc
, "autoincrement", strlen("autoincrement"),
1848 &value_length
, &flags
, &rc
);
1849 assert(value
== NULL
);
1850 assert(rc
== MEMCACHED_NOTFOUND
);
1852 rc
= memcached_increment(memc
, "autoincrement", strlen("autoincrement"),
1855 assert(value
== NULL
);
1856 assert(rc
== MEMCACHED_NOTFOUND
);
1858 rc
= memcached_set(memc
, "autoincrement", strlen("autoincrement"), "1", 1, 0, 0);
1860 value
= memcached_get(memc
, "autoincrement", strlen("autoincrement"),
1861 &value_length
, &flags
, &rc
);
1863 assert(rc
== MEMCACHED_SUCCESS
);
1866 rc
= memcached_increment(memc
, "autoincrement", strlen("autoincrement"),
1868 assert(number_value
== 2);
1869 assert(rc
== MEMCACHED_SUCCESS
);
1875 Bug found where command total one more than MEMCACHED_MAX_BUFFER
1876 set key34567890 0 0 8169 \r\n is sent followed by buffer of size 8169, followed by 8169
1878 uint8_t user_supplied_bug13(memcached_st
*memc
)
1880 char key
[] = "key34567890";
1882 memcached_return rc
;
1883 size_t overflowSize
;
1885 char commandFirst
[]= "set key34567890 0 0 ";
1886 char commandLast
[] = " \r\n"; /* first line of command sent to server */
1887 size_t commandLength
;
1890 commandLength
= strlen(commandFirst
) + strlen(commandLast
) + 4; /* 4 is number of characters in size, probably 8196 */
1892 overflowSize
= MEMCACHED_MAX_BUFFER
- commandLength
;
1894 for (testSize
= overflowSize
- 1; testSize
< overflowSize
+ 1; testSize
++)
1896 overflow
= malloc(testSize
);
1897 assert(overflow
!= NULL
);
1899 memset(overflow
, 'x', testSize
);
1900 rc
= memcached_set(memc
, key
, strlen(key
),
1901 overflow
, testSize
, 0, 0);
1902 assert(rc
== MEMCACHED_SUCCESS
);
1911 Test values of many different sizes
1912 Bug found where command total one more than MEMCACHED_MAX_BUFFER
1913 set key34567890 0 0 8169 \r\n
1914 is sent followed by buffer of size 8169, followed by 8169
1916 uint8_t user_supplied_bug14(memcached_st
*memc
)
1919 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_TCP_NODELAY
, setter
);
1920 memcached_return rc
;
1923 size_t value_length
= 18000;
1925 size_t string_length
;
1928 size_t current_length
;
1930 value
= (char*)malloc(value_length
);
1933 for (x
= 0; x
< value_length
; x
++)
1934 value
[x
] = (char) (x
% 127);
1936 for (current_length
= 0; current_length
< value_length
; current_length
++)
1938 rc
= memcached_set(memc
, key
, strlen(key
),
1939 value
, current_length
,
1940 (time_t)0, (uint32_t)0);
1941 assert(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
);
1943 string
= memcached_get(memc
, key
, strlen(key
),
1944 &string_length
, &flags
, &rc
);
1946 assert(rc
== MEMCACHED_SUCCESS
);
1947 if (current_length
> 0)
1949 assert(string_length
== current_length
);
1950 assert(!memcmp(string
, value
, string_length
));
1961 Look for zero length value problems
1963 uint8_t user_supplied_bug15(memcached_st
*memc
)
1966 memcached_return rc
;
1972 for (x
= 0; x
< 2; x
++)
1974 rc
= memcached_set(memc
, key
, strlen(key
),
1976 (time_t)0, (uint32_t)0);
1978 assert(rc
== MEMCACHED_SUCCESS
);
1980 value
= memcached_get(memc
, key
, strlen(key
),
1981 &length
, &flags
, &rc
);
1983 assert(rc
== MEMCACHED_SUCCESS
);
1984 assert(value
== NULL
);
1985 assert(length
== 0);
1988 value
= memcached_get(memc
, key
, strlen(key
),
1989 &length
, &flags
, &rc
);
1991 assert(rc
== MEMCACHED_SUCCESS
);
1992 assert(value
== NULL
);
1993 assert(length
== 0);
2000 uint8_t result_static(memcached_st
*memc
)
2002 memcached_result_st result
;
2003 memcached_result_st
*result_ptr
;
2005 result_ptr
= memcached_result_create(memc
, &result
);
2006 assert(result
.is_allocated
== MEMCACHED_NOT_ALLOCATED
);
2008 memcached_result_free(&result
);
2013 uint8_t result_alloc(memcached_st
*memc
)
2015 memcached_result_st
*result
;
2017 result
= memcached_result_create(memc
, NULL
);
2019 memcached_result_free(result
);
2024 uint8_t string_static_null(memcached_st
*memc
)
2026 memcached_string_st string
;
2027 memcached_string_st
*string_ptr
;
2029 string_ptr
= memcached_string_create(memc
, &string
, 0);
2030 assert(string
.is_allocated
== MEMCACHED_NOT_ALLOCATED
);
2032 memcached_string_free(&string
);
2037 uint8_t string_alloc_null(memcached_st
*memc
)
2039 memcached_string_st
*string
;
2041 string
= memcached_string_create(memc
, NULL
, 0);
2043 memcached_string_free(string
);
2048 uint8_t string_alloc_with_size(memcached_st
*memc
)
2050 memcached_string_st
*string
;
2052 string
= memcached_string_create(memc
, NULL
, 1024);
2054 memcached_string_free(string
);
2059 uint8_t string_alloc_with_size_toobig(memcached_st
*memc
)
2061 memcached_string_st
*string
;
2063 string
= memcached_string_create(memc
, NULL
, INT64_MAX
);
2064 assert(string
== NULL
);
2069 uint8_t string_alloc_append(memcached_st
*memc
)
2072 char buffer
[SMALL_STRING_LEN
];
2073 memcached_string_st
*string
;
2075 /* Ring the bell! */
2076 memset(buffer
, 6, SMALL_STRING_LEN
);
2078 string
= memcached_string_create(memc
, NULL
, 100);
2081 for (x
= 0; x
< 1024; x
++)
2083 memcached_return rc
;
2084 rc
= memcached_string_append(string
, buffer
, SMALL_STRING_LEN
);
2085 assert(rc
== MEMCACHED_SUCCESS
);
2087 memcached_string_free(string
);
2092 uint8_t string_alloc_append_toobig(memcached_st
*memc
)
2094 memcached_return rc
;
2096 char buffer
[SMALL_STRING_LEN
];
2097 memcached_string_st
*string
;
2099 /* Ring the bell! */
2100 memset(buffer
, 6, SMALL_STRING_LEN
);
2102 string
= memcached_string_create(memc
, NULL
, 100);
2105 for (x
= 0; x
< 1024; x
++)
2107 rc
= memcached_string_append(string
, buffer
, SMALL_STRING_LEN
);
2108 assert(rc
== MEMCACHED_SUCCESS
);
2110 rc
= memcached_string_append(string
, buffer
, INT64_MAX
);
2111 assert(rc
== MEMCACHED_MEMORY_ALLOCATION_FAILURE
);
2112 memcached_string_free(string
);
2117 uint8_t cleanup_pairs(memcached_st
*memc
)
2119 pairs_free(global_pairs
);
2124 uint8_t generate_pairs(memcached_st
*memc
)
2126 unsigned long long x
;
2127 global_pairs
= pairs_generate(GLOBAL_COUNT
, 400);
2128 global_count
= GLOBAL_COUNT
;
2130 for (x
= 0; x
< global_count
; x
++)
2132 global_keys
[x
]= global_pairs
[x
].key
;
2133 global_keys_length
[x
]= global_pairs
[x
].key_length
;
2139 uint8_t generate_large_pairs(memcached_st
*memc
)
2141 unsigned long long x
;
2142 global_pairs
= pairs_generate(GLOBAL2_COUNT
, MEMCACHED_MAX_BUFFER
+10);
2143 global_count
= GLOBAL2_COUNT
;
2145 for (x
= 0; x
< global_count
; x
++)
2147 global_keys
[x
]= global_pairs
[x
].key
;
2148 global_keys_length
[x
]= global_pairs
[x
].key_length
;
2154 uint8_t generate_data(memcached_st
*memc
)
2156 execute_set(memc
, global_pairs
, global_count
);
2161 uint8_t generate_buffer_data(memcached_st
*memc
)
2166 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_BUFFER_REQUESTS
, latch
);
2167 generate_data(memc
);
2172 uint8_t get_read(memcached_st
*memc
)
2175 memcached_return rc
;
2179 size_t return_value_length
;
2182 for (x
= 0; x
< global_count
; x
++)
2184 return_value
= memcached_get(memc
, global_keys
[x
], global_keys_length
[x
],
2185 &return_value_length
, &flags
, &rc
);
2187 assert(return_value);
2188 assert(rc == MEMCACHED_SUCCESS);
2190 if (rc
== MEMCACHED_SUCCESS
&& return_value
)
2198 uint8_t mget_read(memcached_st
*memc
)
2200 memcached_return rc
;
2202 rc
= memcached_mget(memc
, global_keys
, global_keys_length
, global_count
);
2203 assert(rc
== MEMCACHED_SUCCESS
);
2204 /* Turn this into a help function */
2206 char return_key
[MEMCACHED_MAX_KEY
];
2207 size_t return_key_length
;
2209 size_t return_value_length
;
2212 while ((return_value
= memcached_fetch(memc
, return_key
, &return_key_length
,
2213 &return_value_length
, &flags
, &rc
)))
2215 assert(return_value
);
2216 assert(rc
== MEMCACHED_SUCCESS
);
2224 uint8_t mget_read_result(memcached_st
*memc
)
2226 memcached_return rc
;
2228 rc
= memcached_mget(memc
, global_keys
, global_keys_length
, global_count
);
2229 assert(rc
== MEMCACHED_SUCCESS
);
2230 /* Turn this into a help function */
2232 memcached_result_st results_obj
;
2233 memcached_result_st
*results
;
2235 results
= memcached_result_create(memc
, &results_obj
);
2237 while ((results
= memcached_fetch_result(memc
, &results_obj
, &rc
)))
2240 assert(rc
== MEMCACHED_SUCCESS
);
2243 memcached_result_free(&results_obj
);
2249 uint8_t mget_read_function(memcached_st
*memc
)
2251 memcached_return rc
;
2252 unsigned int counter
;
2253 unsigned int (*callbacks
[1])(memcached_st
*, memcached_result_st
*, void *);
2255 rc
= memcached_mget(memc
, global_keys
, global_keys_length
, global_count
);
2256 assert(rc
== MEMCACHED_SUCCESS
);
2258 callbacks
[0]= &callback_counter
;
2260 rc
= memcached_fetch_execute(memc
, callbacks
, (void *)&counter
, 1);
2265 uint8_t delete_generate(memcached_st
*memc
)
2269 for (x
= 0; x
< global_count
; x
++)
2271 (void)memcached_delete(memc
, global_keys
[x
], global_keys_length
[x
], (time_t)0);
2277 uint8_t delete_buffer_generate(memcached_st
*memc
)
2283 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_BUFFER_REQUESTS
, latch
);
2285 for (x
= 0; x
< global_count
; x
++)
2287 (void)memcached_delete(memc
, global_keys
[x
], global_keys_length
[x
], (time_t)0);
2293 uint8_t free_data(memcached_st
*memc
)
2295 pairs_free(global_pairs
);
2300 uint8_t add_host_test1(memcached_st
*memc
)
2303 memcached_return rc
;
2304 char servername
[]= "0.example.com";
2305 memcached_server_st
*servers
;
2307 servers
= memcached_server_list_append(NULL
, servername
, 400, &rc
);
2309 assert(1 == memcached_server_list_count(servers
));
2311 for (x
= 2; x
< 20; x
++)
2313 char buffer
[SMALL_STRING_LEN
];
2315 snprintf(buffer
, SMALL_STRING_LEN
, "%u.example.com", 400+x
);
2316 servers
= memcached_server_list_append(servers
, buffer
, 401,
2318 assert(rc
== MEMCACHED_SUCCESS
);
2319 assert(x
== memcached_server_list_count(servers
));
2322 rc
= memcached_server_push(memc
, servers
);
2323 assert(rc
== MEMCACHED_SUCCESS
);
2324 rc
= memcached_server_push(memc
, servers
);
2325 assert(rc
== MEMCACHED_SUCCESS
);
2327 memcached_server_list_free(servers
);
2332 memcached_return
pre_nonblock(memcached_st
*memc
)
2334 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NO_BLOCK
, 0);
2336 return MEMCACHED_SUCCESS
;
2339 memcached_return
pre_murmur(memcached_st
*memc
)
2341 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_HASH
, (uint64_t)MEMCACHED_HASH_MURMUR
);
2343 return MEMCACHED_SUCCESS
;
2346 memcached_return
pre_md5(memcached_st
*memc
)
2348 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_HASH
, (uint64_t)MEMCACHED_HASH_MD5
);
2350 return MEMCACHED_SUCCESS
;
2353 memcached_return
pre_crc(memcached_st
*memc
)
2355 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_HASH
, (uint64_t)MEMCACHED_HASH_CRC
);
2357 return MEMCACHED_SUCCESS
;
2360 memcached_return
pre_hsieh(memcached_st
*memc
)
2362 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_HASH
, (uint64_t)MEMCACHED_HASH_HSIEH
);
2364 return MEMCACHED_SUCCESS
;
2367 memcached_return
pre_hash_fnv1_64(memcached_st
*memc
)
2369 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_HASH
, (uint64_t)MEMCACHED_HASH_FNV1_64
);
2371 return MEMCACHED_SUCCESS
;
2374 memcached_return
pre_hash_fnv1a_64(memcached_st
*memc
)
2376 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_HASH
, (uint64_t)MEMCACHED_HASH_FNV1A_64
);
2378 return MEMCACHED_SUCCESS
;
2381 memcached_return
pre_hash_fnv1_32(memcached_st
*memc
)
2383 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_HASH
, (uint64_t)MEMCACHED_HASH_FNV1_32
);
2385 return MEMCACHED_SUCCESS
;
2388 memcached_return
pre_hash_fnv1a_32(memcached_st
*memc
)
2390 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_HASH
, (uint64_t)MEMCACHED_HASH_FNV1A_32
);
2392 return MEMCACHED_SUCCESS
;
2395 memcached_return
pre_hash_ketama(memcached_st
*memc
)
2397 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_HASH
, (uint64_t)MEMCACHED_HASH_KETAMA
);
2399 return MEMCACHED_SUCCESS
;
2402 void my_free(memcached_st
*ptr
, void *mem
)
2407 void *my_malloc(memcached_st
*ptr
, const size_t size
)
2409 return malloc(size
);
2412 void *my_realloc(memcached_st
*ptr
, void *mem
, const size_t size
)
2414 return realloc(mem
, size
);
2417 memcached_return
set_memory_alloc(memcached_st
*memc
)
2420 memcached_malloc_function test_ptr
;
2421 memcached_return rc
;
2423 rc
= memcached_callback_set(memc
, MEMCACHED_CALLBACK_MALLOC_FUNCTION
, &my_malloc
);
2424 assert(rc
== MEMCACHED_SUCCESS
);
2425 test_ptr
= (memcached_malloc_function
)memcached_callback_get(memc
, MEMCACHED_CALLBACK_MALLOC_FUNCTION
, &rc
);
2426 assert(rc
== MEMCACHED_SUCCESS
);
2427 assert(test_ptr
== my_malloc
);
2431 memcached_realloc_function test_ptr
;
2432 memcached_return rc
;
2434 rc
= memcached_callback_set(memc
, MEMCACHED_CALLBACK_REALLOC_FUNCTION
, &my_realloc
);
2435 assert(rc
== MEMCACHED_SUCCESS
);
2436 test_ptr
= (memcached_realloc_function
)memcached_callback_get(memc
, MEMCACHED_CALLBACK_REALLOC_FUNCTION
, &rc
);
2437 assert(rc
== MEMCACHED_SUCCESS
);
2438 assert(test_ptr
== my_realloc
);
2442 memcached_free_function test_ptr
;
2443 memcached_return rc
;
2445 rc
= memcached_callback_set(memc
, MEMCACHED_CALLBACK_FREE_FUNCTION
, my_free
);
2446 assert(rc
== MEMCACHED_SUCCESS
);
2447 test_ptr
= (memcached_free_function
)memcached_callback_get(memc
, MEMCACHED_CALLBACK_FREE_FUNCTION
, &rc
);
2448 assert(rc
== MEMCACHED_SUCCESS
);
2449 assert(test_ptr
== my_free
);
2452 return MEMCACHED_SUCCESS
;
2455 memcached_return
enable_consistent(memcached_st
*memc
)
2457 memcached_server_distribution value
= MEMCACHED_DISTRIBUTION_CONSISTENT
;
2458 memcached_hash hash
;
2459 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_DISTRIBUTION
, value
);
2462 value
= (memcached_server_distribution
)memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_DISTRIBUTION
);
2463 assert(value
== MEMCACHED_DISTRIBUTION_CONSISTENT
);
2465 hash
= (memcached_hash
)memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_HASH
);
2466 assert(hash
== MEMCACHED_HASH_HSIEH
);
2469 return MEMCACHED_SUCCESS
;
2472 memcached_return
enable_cas(memcached_st
*memc
)
2474 unsigned int set
= 1;
2476 memcached_version(memc
);
2478 if (memc
->hosts
[0].major_version
>= 1 &&
2479 memc
->hosts
[0].minor_version
>= 2 &&
2480 memc
->hosts
[0].micro_version
>= 4)
2482 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_SUPPORT_CAS
, set
);
2484 return MEMCACHED_SUCCESS
;
2487 return MEMCACHED_FAILURE
;
2490 memcached_return
check_for_1_2_3(memcached_st
*memc
)
2492 memcached_version(memc
);
2494 if (memc
->hosts
[0].major_version
>= 1 &&
2495 memc
->hosts
[0].minor_version
>= 2 &&
2496 memc
->hosts
[0].micro_version
>= 4)
2497 return MEMCACHED_SUCCESS
;
2499 return MEMCACHED_FAILURE
;
2502 memcached_return
pre_unix_socket(memcached_st
*memc
)
2504 memcached_return rc
;
2507 memcached_server_list_free(memc
->hosts
);
2509 memc
->number_of_hosts
= 0;
2511 if (stat("/tmp/memcached.socket", &buf
))
2512 return MEMCACHED_FAILURE
;
2514 rc
= memcached_server_add_unix_socket(memc
, "/tmp/memcached.socket");
2519 memcached_return
pre_udp(memcached_st
*memc
)
2521 memcached_return rc
;
2523 memcached_server_list_free(memc
->hosts
);
2525 memc
->number_of_hosts
= 0;
2528 return MEMCACHED_FAILURE
;
2530 rc
= memcached_server_add_udp(memc
, "localhost", MEMCACHED_DEFAULT_PORT
);
2535 memcached_return
pre_nodelay(memcached_st
*memc
)
2537 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NO_BLOCK
, 0);
2538 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_TCP_NODELAY
, 0);
2540 return MEMCACHED_SUCCESS
;
2543 memcached_return
poll_timeout(memcached_st
*memc
)
2549 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_POLL_TIMEOUT
, timeout
);
2551 timeout
= (int32_t)memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_POLL_TIMEOUT
);
2553 assert(timeout
== 100);
2555 return MEMCACHED_SUCCESS
;
2559 /* Clean the server before beginning testing */
2561 {"flush", 0, flush_test
},
2562 {"init", 0, init_test
},
2563 {"allocation", 0, allocation_test
},
2564 {"server_list_null_test", 0, server_list_null_test
},
2565 {"server_unsort", 0, server_unsort_test
},
2566 {"server_sort", 0, server_sort_test
},
2567 {"clone_test", 0, clone_test
},
2568 {"error", 0, error_test
},
2569 {"set", 0, set_test
},
2570 {"set2", 0, set_test2
},
2571 {"set3", 0, set_test3
},
2572 {"add", 1, add_test
},
2573 {"replace", 1, replace_test
},
2574 {"delete", 1, delete_test
},
2575 {"get", 1, get_test
},
2576 {"get2", 0, get_test2
},
2577 {"get3", 0, get_test3
},
2578 {"get4", 0, get_test4
},
2579 {"stats_servername", 0, stats_servername_test
},
2580 {"increment", 0, increment_test
},
2581 {"decrement", 0, decrement_test
},
2582 {"quit", 0, quit_test
},
2583 {"mget", 1, mget_test
},
2584 {"mget_result", 1, mget_result_test
},
2585 {"mget_result_alloc", 1, mget_result_alloc_test
},
2586 {"mget_result_function", 1, mget_result_function
},
2587 {"get_stats", 0, get_stats
},
2588 {"add_host_test", 0, add_host_test
},
2589 {"get_stats_keys", 0, get_stats_keys
},
2590 {"behavior_test", 0, get_stats_keys
},
2591 {"callback_test", 0, get_stats_keys
},
2592 {"version_string_test", 0, version_string_test
},
2593 {"bad_key", 1, bad_key_test
},
2594 {"memcached_server_cursor", 1, memcached_server_cursor_test
},
2595 {"read_through", 1, read_through
},
2596 {"delete_through", 1, delete_through
},
2600 test_st async_tests
[] ={
2601 {"add", 1, add_wrapper
},
2605 test_st string_tests
[] ={
2606 {"string static with null", 0, string_static_null
},
2607 {"string alloc with null", 0, string_alloc_null
},
2608 {"string alloc with 1K", 0, string_alloc_with_size
},
2609 {"string alloc with malloc failure", 0, string_alloc_with_size_toobig
},
2610 {"string append", 0, string_alloc_append
},
2611 {"string append failure (too big)", 0, string_alloc_append_toobig
},
2615 test_st result_tests
[] ={
2616 {"result static", 0, result_static
},
2617 {"result alloc", 0, result_alloc
},
2621 test_st version_1_2_3
[] ={
2622 {"append", 0, append_test
},
2623 {"prepend", 0, prepend_test
},
2624 {"cas", 0, cas_test
},
2625 {"cas2", 0, cas2_test
},
2626 {"append_binary", 0, append_binary_test
},
2630 test_st user_tests
[] ={
2631 {"user_supplied_bug1", 0, user_supplied_bug1
},
2632 {"user_supplied_bug2", 0, user_supplied_bug2
},
2633 {"user_supplied_bug3", 0, user_supplied_bug3
},
2634 {"user_supplied_bug4", 0, user_supplied_bug4
},
2635 {"user_supplied_bug5", 1, user_supplied_bug5
},
2636 {"user_supplied_bug6", 1, user_supplied_bug6
},
2637 {"user_supplied_bug7", 1, user_supplied_bug7
},
2638 {"user_supplied_bug8", 1, user_supplied_bug8
},
2639 {"user_supplied_bug9", 1, user_supplied_bug9
},
2640 {"user_supplied_bug10", 1, user_supplied_bug10
},
2641 {"user_supplied_bug11", 1, user_supplied_bug11
},
2642 {"user_supplied_bug12", 1, user_supplied_bug12
},
2643 {"user_supplied_bug13", 1, user_supplied_bug13
},
2644 {"user_supplied_bug14", 1, user_supplied_bug14
},
2645 {"user_supplied_bug15", 1, user_supplied_bug15
},
2649 test_st generate_tests
[] ={
2650 {"generate_pairs", 1, generate_pairs
},
2651 {"generate_data", 1, generate_data
},
2652 {"get_read", 0, get_read
},
2653 {"delete_generate", 0, delete_generate
},
2654 {"generate_buffer_data", 1, generate_buffer_data
},
2655 {"delete_buffer", 0, delete_buffer_generate
},
2656 {"generate_data", 1, generate_data
},
2657 {"mget_read", 0, mget_read
},
2658 {"mget_read_result", 0, mget_read_result
},
2659 {"mget_read_function", 0, mget_read_function
},
2660 {"cleanup", 1, cleanup_pairs
},
2661 {"generate_large_pairs", 1, generate_large_pairs
},
2662 {"generate_data", 1, generate_data
},
2663 {"generate_buffer_data", 1, generate_buffer_data
},
2664 {"cleanup", 1, cleanup_pairs
},
2669 collection_st collection
[] ={
2670 {"block", 0, 0, tests
},
2671 {"nonblock", pre_nonblock
, 0, tests
},
2672 {"nodelay", pre_nodelay
, 0, tests
},
2673 {"md5", pre_md5
, 0, tests
},
2674 {"crc", pre_crc
, 0, tests
},
2675 {"hsieh", pre_hsieh
, 0, tests
},
2676 {"fnv1_64", pre_hash_fnv1_64
, 0, tests
},
2677 {"fnv1a_64", pre_hash_fnv1a_64
, 0, tests
},
2678 {"fnv1_32", pre_hash_fnv1_32
, 0, tests
},
2679 {"fnv1a_32", pre_hash_fnv1a_32
, 0, tests
},
2680 {"ketama", pre_hash_ketama
, 0, tests
},
2681 {"unix_socket", pre_unix_socket
, 0, tests
},
2682 {"unix_socket_nodelay", pre_nodelay
, 0, tests
},
2683 {"poll_timeout", poll_timeout
, 0, tests
},
2684 {"gets", enable_cas
, 0, tests
},
2685 {"consistent", enable_consistent
, 0, tests
},
2686 {"memory_allocators", set_memory_alloc
, 0, tests
},
2687 // {"udp", pre_udp, 0, tests},
2688 {"version_1_2_3", check_for_1_2_3
, 0, version_1_2_3
},
2689 {"string", 0, 0, string_tests
},
2690 {"result", 0, 0, result_tests
},
2691 {"async", pre_nonblock
, 0, async_tests
},
2692 {"user", 0, 0, user_tests
},
2693 {"generate", 0, 0, generate_tests
},
2694 {"generate_hsieh", pre_hsieh
, 0, generate_tests
},
2695 {"generate_hsieh_consistent", enable_consistent
, 0, generate_tests
},
2696 {"generate_md5", pre_md5
, 0, generate_tests
},
2697 {"generate_murmur", pre_murmur
, 0, generate_tests
},
2698 {"generate_nonblock", pre_nonblock
, 0, generate_tests
},
2702 #define SERVERS_TO_CREATE 5
2704 void *world_create(void)
2706 server_startup_st
*construct
;
2708 construct
= (server_startup_st
*)malloc(sizeof(server_startup_st
));
2709 memset(construct
, 0, sizeof(server_startup_st
));
2710 construct
->count
= SERVERS_TO_CREATE
;
2712 server_startup(construct
);
2717 void world_destroy(void *p
)
2719 server_startup_st
*construct
= (server_startup_st
*)p
;
2720 memcached_server_st
*servers
= (memcached_server_st
*)construct
->servers
;
2721 memcached_server_list_free(servers
);
2723 server_shutdown(construct
);
2727 void get_world(world_st
*world
)
2729 world
->collections
= collection
;
2730 world
->create
= world_create
;
2731 world
->destroy
= world_destroy
;