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 #ifdef HAVE_LIBMEMCACHEDUTIL
29 #include "libmemcached/memcached_util.h"
32 #define GLOBAL_COUNT 10000
33 #define GLOBAL2_COUNT 100
34 #define SERVERS_TO_CREATE 5
35 static uint32_t global_count
;
37 static pairs_st
*global_pairs
;
38 static char *global_keys
[GLOBAL_COUNT
];
39 static size_t global_keys_length
[GLOBAL_COUNT
];
41 static test_return
init_test(memcached_st
*not_used
__attribute__((unused
)))
45 (void)memcached_create(&memc
);
46 memcached_free(&memc
);
51 static test_return
server_list_null_test(memcached_st
*ptr
__attribute__((unused
)))
53 memcached_server_st
*server_list
;
56 server_list
= memcached_server_list_append_with_weight(NULL
, NULL
, 0, 0, NULL
);
57 assert(server_list
== NULL
);
59 server_list
= memcached_server_list_append_with_weight(NULL
, "localhost", 0, 0, NULL
);
60 assert(server_list
== NULL
);
62 server_list
= memcached_server_list_append_with_weight(NULL
, NULL
, 0, 0, &rc
);
63 assert(server_list
== NULL
);
68 #define TEST_PORT_COUNT 7
69 uint32_t test_ports
[TEST_PORT_COUNT
];
71 static memcached_return
server_display_function(memcached_st
*ptr
__attribute__((unused
)), memcached_server_st
*server
, void *context
)
74 uint32_t bigger
= *((uint32_t *)(context
));
75 assert(bigger
<= server
->port
);
76 *((uint32_t *)(context
))= server
->port
;
78 return MEMCACHED_SUCCESS
;
81 static test_return
server_sort_test(memcached_st
*ptr
__attribute__((unused
)))
84 uint32_t bigger
= 0; /* Prime the value for the assert in server_display_function */
86 memcached_server_function callbacks
[1];
87 memcached_st
*local_memc
;
89 local_memc
= memcached_create(NULL
);
91 memcached_behavior_set(local_memc
, MEMCACHED_BEHAVIOR_SORT_HOSTS
, 1);
93 for (x
= 0; x
< TEST_PORT_COUNT
; x
++)
95 test_ports
[x
]= random() % 64000;
96 rc
= memcached_server_add_with_weight(local_memc
, "localhost", test_ports
[x
], 0);
97 assert(local_memc
->number_of_hosts
== x
+ 1);
98 assert(local_memc
->hosts
[0].count
== x
+1);
99 assert(rc
== MEMCACHED_SUCCESS
);
102 callbacks
[0]= server_display_function
;
103 memcached_server_cursor(local_memc
, callbacks
, (void *)&bigger
, 1);
106 memcached_free(local_memc
);
111 static test_return
server_sort2_test(memcached_st
*ptr
__attribute__((unused
)))
113 uint32_t bigger
= 0; /* Prime the value for the assert in server_display_function */
115 memcached_server_function callbacks
[1];
116 memcached_st
*local_memc
;
118 local_memc
= memcached_create(NULL
);
120 rc
= memcached_behavior_set(local_memc
, MEMCACHED_BEHAVIOR_SORT_HOSTS
, 1);
121 assert(rc
== MEMCACHED_SUCCESS
);
123 rc
= memcached_server_add_with_weight(local_memc
, "MEMCACHED_BEHAVIOR_SORT_HOSTS", 43043, 0);
124 assert(rc
== MEMCACHED_SUCCESS
);
125 assert(local_memc
->hosts
[0].port
== 43043);
127 rc
= memcached_server_add_with_weight(local_memc
, "MEMCACHED_BEHAVIOR_SORT_HOSTS", 43042, 0);
128 assert(rc
== MEMCACHED_SUCCESS
);
129 assert(local_memc
->hosts
[0].port
== 43042);
130 assert(local_memc
->hosts
[1].port
== 43043);
132 callbacks
[0]= server_display_function
;
133 memcached_server_cursor(local_memc
, callbacks
, (void *)&bigger
, 1);
136 memcached_free(local_memc
);
141 static memcached_return
server_display_unsort_function(memcached_st
*ptr
__attribute__((unused
)), memcached_server_st
*server
, void *context
)
144 uint32_t x
= *((uint32_t *)(context
));
146 assert(test_ports
[x
] == server
->port
);
147 *((uint32_t *)(context
))= ++x
;
149 return MEMCACHED_SUCCESS
;
152 static test_return
server_unsort_test(memcached_st
*ptr
__attribute__((unused
)))
155 uint32_t counter
= 0; /* Prime the value for the assert in server_display_function */
156 uint32_t bigger
= 0; /* Prime the value for the assert in server_display_function */
158 memcached_server_function callbacks
[1];
159 memcached_st
*local_memc
;
161 local_memc
= memcached_create(NULL
);
164 for (x
= 0; x
< TEST_PORT_COUNT
; x
++)
166 test_ports
[x
]= random() % 64000;
167 rc
= memcached_server_add_with_weight(local_memc
, "localhost", test_ports
[x
], 0);
168 assert(local_memc
->number_of_hosts
== x
+1);
169 assert(local_memc
->hosts
[0].count
== x
+1);
170 assert(rc
== MEMCACHED_SUCCESS
);
173 callbacks
[0]= server_display_unsort_function
;
174 memcached_server_cursor(local_memc
, callbacks
, (void *)&counter
, 1);
176 /* Now we sort old data! */
177 memcached_behavior_set(local_memc
, MEMCACHED_BEHAVIOR_SORT_HOSTS
, 1);
178 callbacks
[0]= server_display_function
;
179 memcached_server_cursor(local_memc
, callbacks
, (void *)&bigger
, 1);
182 memcached_free(local_memc
);
187 static test_return
allocation_test(memcached_st
*not_used
__attribute__((unused
)))
190 memc
= memcached_create(NULL
);
192 memcached_free(memc
);
197 static test_return
clone_test(memcached_st
*memc
)
202 clone
= memcached_clone(NULL
, NULL
);
204 memcached_free(clone
);
207 /* Can we init from null? */
210 clone
= memcached_clone(NULL
, memc
);
213 assert(clone
->call_free
== memc
->call_free
);
214 assert(clone
->call_malloc
== memc
->call_malloc
);
215 assert(clone
->call_realloc
== memc
->call_realloc
);
216 assert(clone
->connect_timeout
== memc
->connect_timeout
);
217 assert(clone
->delete_trigger
== memc
->delete_trigger
);
218 assert(clone
->distribution
== memc
->distribution
);
219 assert(clone
->flags
== memc
->flags
);
220 assert(clone
->get_key_failure
== memc
->get_key_failure
);
221 assert(clone
->hash
== memc
->hash
);
222 assert(clone
->hash_continuum
== memc
->hash_continuum
);
223 assert(clone
->io_bytes_watermark
== memc
->io_bytes_watermark
);
224 assert(clone
->io_msg_watermark
== memc
->io_msg_watermark
);
225 assert(clone
->io_key_prefetch
== memc
->io_key_prefetch
);
226 assert(clone
->on_cleanup
== memc
->on_cleanup
);
227 assert(clone
->on_clone
== memc
->on_clone
);
228 assert(clone
->poll_timeout
== memc
->poll_timeout
);
229 assert(clone
->rcv_timeout
== memc
->rcv_timeout
);
230 assert(clone
->recv_size
== memc
->recv_size
);
231 assert(clone
->retry_timeout
== memc
->retry_timeout
);
232 assert(clone
->send_size
== memc
->send_size
);
233 assert(clone
->server_failure_limit
== memc
->server_failure_limit
);
234 assert(clone
->snd_timeout
== memc
->snd_timeout
);
235 assert(clone
->user_data
== memc
->user_data
);
237 memcached_free(clone
);
240 /* Can we init from struct? */
242 memcached_st declared_clone
;
244 memset(&declared_clone
, 0 , sizeof(memcached_st
));
245 clone
= memcached_clone(&declared_clone
, NULL
);
247 memcached_free(clone
);
250 /* Can we init from struct? */
252 memcached_st declared_clone
;
254 memset(&declared_clone
, 0 , sizeof(memcached_st
));
255 clone
= memcached_clone(&declared_clone
, memc
);
257 memcached_free(clone
);
263 static test_return
connection_test(memcached_st
*memc
)
267 rc
= memcached_server_add_with_weight(memc
, "localhost", 0, 0);
268 assert(rc
== MEMCACHED_SUCCESS
);
273 static test_return
error_test(memcached_st
*memc
)
277 for (rc
= MEMCACHED_SUCCESS
; rc
< MEMCACHED_MAXIMUM_RETURN
; rc
++)
279 printf("Error %d -> %s\n", rc
, memcached_strerror(memc
, rc
));
285 static test_return
set_test(memcached_st
*memc
)
289 char *value
= "when we sanitize";
291 rc
= memcached_set(memc
, key
, strlen(key
),
292 value
, strlen(value
),
293 (time_t)0, (uint32_t)0);
294 assert(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
);
299 static test_return
append_test(memcached_st
*memc
)
307 rc
= memcached_flush(memc
, 0);
308 assert(rc
== MEMCACHED_SUCCESS
);
310 rc
= memcached_set(memc
, key
, strlen(key
),
311 value
, strlen(value
),
312 (time_t)0, (uint32_t)0);
313 assert(rc
== MEMCACHED_SUCCESS
);
315 rc
= memcached_append(memc
, key
, strlen(key
),
316 " the", strlen(" the"),
317 (time_t)0, (uint32_t)0);
318 assert(rc
== MEMCACHED_SUCCESS
);
320 rc
= memcached_append(memc
, key
, strlen(key
),
321 " people", strlen(" people"),
322 (time_t)0, (uint32_t)0);
323 assert(rc
== MEMCACHED_SUCCESS
);
325 value
= memcached_get(memc
, key
, strlen(key
),
326 &value_length
, &flags
, &rc
);
327 assert(!memcmp(value
, "we the people", strlen("we the people")));
328 assert(strlen("we the people") == value_length
);
329 assert(rc
== MEMCACHED_SUCCESS
);
335 static test_return
append_binary_test(memcached_st
*memc
)
338 char *key
= "numbers";
339 unsigned int *store_ptr
;
340 unsigned int store_list
[] = { 23, 56, 499, 98, 32847, 0 };
346 rc
= memcached_flush(memc
, 0);
347 assert(rc
== MEMCACHED_SUCCESS
);
349 rc
= memcached_set(memc
,
352 (time_t)0, (uint32_t)0);
353 assert(rc
== MEMCACHED_SUCCESS
);
355 for (x
= 0; store_list
[x
] ; x
++)
357 rc
= memcached_append(memc
,
359 (char *)&store_list
[x
], sizeof(unsigned int),
360 (time_t)0, (uint32_t)0);
361 assert(rc
== MEMCACHED_SUCCESS
);
364 value
= memcached_get(memc
, key
, strlen(key
),
365 &value_length
, &flags
, &rc
);
366 assert((value_length
== (sizeof(unsigned int) * x
)));
367 assert(rc
== MEMCACHED_SUCCESS
);
369 store_ptr
= (unsigned int *)value
;
371 while ((size_t)store_ptr
< (size_t)(value
+ value_length
))
373 assert(*store_ptr
== store_list
[x
++]);
381 static test_return
cas2_test(memcached_st
*memc
)
384 char *keys
[]= {"fudge", "son", "food"};
385 size_t key_length
[]= {5, 3, 4};
386 char *value
= "we the people";
387 size_t value_length
= strlen("we the people");
389 memcached_result_st results_obj
;
390 memcached_result_st
*results
;
393 rc
= memcached_flush(memc
, 0);
394 assert(rc
== MEMCACHED_SUCCESS
);
396 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_SUPPORT_CAS
, set
);
398 for (x
= 0; x
< 3; x
++)
400 rc
= memcached_set(memc
, keys
[x
], key_length
[x
],
401 keys
[x
], key_length
[x
],
402 (time_t)50, (uint32_t)9);
403 assert(rc
== MEMCACHED_SUCCESS
);
406 rc
= memcached_mget(memc
, keys
, key_length
, 3);
408 results
= memcached_result_create(memc
, &results_obj
);
410 results
= memcached_fetch_result(memc
, &results_obj
, &rc
);
412 assert(results
->cas
);
413 assert(rc
== MEMCACHED_SUCCESS
);
414 WATCHPOINT_ASSERT(memcached_result_cas(results
));
416 assert(!memcmp(value
, "we the people", strlen("we the people")));
417 assert(strlen("we the people") == value_length
);
418 assert(rc
== MEMCACHED_SUCCESS
);
420 memcached_result_free(&results_obj
);
425 static test_return
cas_test(memcached_st
*memc
)
428 const char *key
= "fun";
429 size_t key_length
= strlen(key
);
430 const char *value
= "we the people";
431 char* keys
[2] = { (char*)key
, NULL
};
432 size_t keylengths
[2] = { strlen(key
), 0 };
433 size_t value_length
= strlen(value
);
434 const char *value2
= "change the value";
435 size_t value2_length
= strlen(value2
);
437 memcached_result_st results_obj
;
438 memcached_result_st
*results
;
441 rc
= memcached_flush(memc
, 0);
442 assert(rc
== MEMCACHED_SUCCESS
);
444 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_SUPPORT_CAS
, set
);
446 rc
= memcached_set(memc
, key
, strlen(key
),
447 value
, strlen(value
),
448 (time_t)0, (uint32_t)0);
449 assert(rc
== MEMCACHED_SUCCESS
);
451 rc
= memcached_mget(memc
, keys
, keylengths
, 1);
453 results
= memcached_result_create(memc
, &results_obj
);
455 results
= memcached_fetch_result(memc
, &results_obj
, &rc
);
457 assert(rc
== MEMCACHED_SUCCESS
);
458 WATCHPOINT_ASSERT(memcached_result_cas(results
));
459 assert(!memcmp(value
, memcached_result_value(results
), value_length
));
460 assert(strlen(memcached_result_value(results
)) == value_length
);
461 assert(rc
== MEMCACHED_SUCCESS
);
462 uint64_t cas
= memcached_result_cas(results
);
465 results
= memcached_fetch_result(memc
, &results_obj
, &rc
);
466 assert(rc
== MEMCACHED_END
);
467 assert(results
== NULL
);
470 rc
= memcached_cas(memc
, key
, key_length
, value2
, value2_length
, 0, 0, cas
);
471 assert(rc
== MEMCACHED_SUCCESS
);
474 * The item will have a new cas value, so try to set it again with the old
475 * value. This should fail!
477 rc
= memcached_cas(memc
, key
, key_length
, value2
, value2_length
, 0, 0, cas
);
478 assert(rc
== MEMCACHED_DATA_EXISTS
);
480 memcached_result_free(&results_obj
);
485 static test_return
prepend_test(memcached_st
*memc
)
489 char *value
= "people";
493 rc
= memcached_flush(memc
, 0);
494 assert(rc
== MEMCACHED_SUCCESS
);
496 rc
= memcached_set(memc
, key
, strlen(key
),
497 value
, strlen(value
),
498 (time_t)0, (uint32_t)0);
499 assert(rc
== MEMCACHED_SUCCESS
);
501 rc
= memcached_prepend(memc
, key
, strlen(key
),
502 "the ", strlen("the "),
503 (time_t)0, (uint32_t)0);
504 assert(rc
== MEMCACHED_SUCCESS
);
506 rc
= memcached_prepend(memc
, key
, strlen(key
),
507 "we ", strlen("we "),
508 (time_t)0, (uint32_t)0);
509 assert(rc
== MEMCACHED_SUCCESS
);
511 value
= memcached_get(memc
, key
, strlen(key
),
512 &value_length
, &flags
, &rc
);
513 assert(!memcmp(value
, "we the people", strlen("we the people")));
514 assert(strlen("we the people") == value_length
);
515 assert(rc
== MEMCACHED_SUCCESS
);
522 Set the value, then quit to make sure it is flushed.
523 Come back in and test that add fails.
525 static test_return
add_test(memcached_st
*memc
)
529 char *value
= "when we sanitize";
530 unsigned long long setting_value
;
532 setting_value
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_NO_BLOCK
);
534 rc
= memcached_set(memc
, key
, strlen(key
),
535 value
, strlen(value
),
536 (time_t)0, (uint32_t)0);
537 assert(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
);
538 memcached_quit(memc
);
539 rc
= memcached_add(memc
, key
, strlen(key
),
540 value
, strlen(value
),
541 (time_t)0, (uint32_t)0);
543 /* Too many broken OS'es have broken loopback in async, so we can't be sure of the result */
545 assert(rc
== MEMCACHED_NOTSTORED
|| rc
== MEMCACHED_STORED
);
547 assert(rc
== MEMCACHED_NOTSTORED
|| rc
== MEMCACHED_DATA_EXISTS
);
553 ** There was a problem of leaking filedescriptors in the initial release
554 ** of MacOSX 10.5. This test case triggers the problem. On some Solaris
555 ** systems it seems that the kernel is slow on reclaiming the resources
556 ** because the connects starts to time out (the test doesn't do much
557 ** anyway, so just loop 10 iterations)
559 static test_return
add_wrapper(memcached_st
*memc
)
562 unsigned int max
= 10000;
567 for (x
= 0; x
< max
; x
++)
573 static test_return
replace_test(memcached_st
*memc
)
577 char *value
= "when we sanitize";
578 char *original
= "first we insert some data";
580 rc
= memcached_set(memc
, key
, strlen(key
),
581 original
, strlen(original
),
582 (time_t)0, (uint32_t)0);
583 assert(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
);
585 rc
= memcached_replace(memc
, key
, strlen(key
),
586 value
, strlen(value
),
587 (time_t)0, (uint32_t)0);
588 assert(rc
== MEMCACHED_SUCCESS
);
593 static test_return
delete_test(memcached_st
*memc
)
597 char *value
= "when we sanitize";
599 rc
= memcached_set(memc
, key
, strlen(key
),
600 value
, strlen(value
),
601 (time_t)0, (uint32_t)0);
602 assert(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
);
604 rc
= memcached_delete(memc
, key
, strlen(key
), (time_t)0);
605 assert(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
);
610 static test_return
flush_test(memcached_st
*memc
)
614 rc
= memcached_flush(memc
, 0);
615 assert(rc
== MEMCACHED_SUCCESS
);
620 static memcached_return
server_function(memcached_st
*ptr
__attribute__((unused
)),
621 memcached_server_st
*server
__attribute__((unused
)),
622 void *context
__attribute__((unused
)))
626 return MEMCACHED_SUCCESS
;
629 static test_return
memcached_server_cursor_test(memcached_st
*memc
)
631 char *context
= "foo bad";
632 memcached_server_function callbacks
[1];
634 callbacks
[0]= server_function
;
635 memcached_server_cursor(memc
, callbacks
, context
, 1);
640 static test_return
bad_key_test(memcached_st
*memc
)
643 char *key
= "foo bad";
645 size_t string_length
;
649 size_t max_keylen
= 0xffff;
651 clone
= memcached_clone(NULL
, memc
);
654 rc
= memcached_behavior_set(clone
, MEMCACHED_BEHAVIOR_VERIFY_KEY
, set
);
655 assert(rc
== MEMCACHED_SUCCESS
);
657 /* All keys are valid in the binary protocol (except for length) */
658 if (memcached_behavior_get(clone
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
) == 0)
660 string
= memcached_get(clone
, key
, strlen(key
),
661 &string_length
, &flags
, &rc
);
662 assert(rc
== MEMCACHED_BAD_KEY_PROVIDED
);
663 assert(string_length
== 0);
667 rc
= memcached_behavior_set(clone
, MEMCACHED_BEHAVIOR_VERIFY_KEY
, set
);
668 assert(rc
== MEMCACHED_SUCCESS
);
669 string
= memcached_get(clone
, key
, strlen(key
),
670 &string_length
, &flags
, &rc
);
671 assert(rc
== MEMCACHED_NOTFOUND
);
672 assert(string_length
== 0);
675 /* Test multi key for bad keys */
676 char *keys
[] = { "GoodKey", "Bad Key", "NotMine" };
677 size_t key_lengths
[] = { 7, 7, 7 };
679 rc
= memcached_behavior_set(clone
, MEMCACHED_BEHAVIOR_VERIFY_KEY
, set
);
680 assert(rc
== MEMCACHED_SUCCESS
);
682 rc
= memcached_mget(clone
, keys
, key_lengths
, 3);
683 assert(rc
== MEMCACHED_BAD_KEY_PROVIDED
);
685 rc
= memcached_mget_by_key(clone
, "foo daddy", 9, keys
, key_lengths
, 1);
686 assert(rc
== MEMCACHED_BAD_KEY_PROVIDED
);
690 /* The following test should be moved to the end of this function when the
691 memcached server is updated to allow max size length of the keys in the
694 rc
= memcached_callback_set(clone
, MEMCACHED_CALLBACK_PREFIX_KEY
, NULL
);
695 assert(rc
== MEMCACHED_SUCCESS
);
697 char *longkey
= malloc(max_keylen
+ 1);
700 memset(longkey
, 'a', max_keylen
+ 1);
701 string
= memcached_get(clone
, longkey
, max_keylen
,
702 &string_length
, &flags
, &rc
);
703 assert(rc
== MEMCACHED_NOTFOUND
);
704 assert(string_length
== 0);
707 string
= memcached_get(clone
, longkey
, max_keylen
+ 1,
708 &string_length
, &flags
, &rc
);
709 assert(rc
== MEMCACHED_BAD_KEY_PROVIDED
);
710 assert(string_length
== 0);
717 /* Make sure zero length keys are marked as bad */
719 rc
= memcached_behavior_set(clone
, MEMCACHED_BEHAVIOR_VERIFY_KEY
, set
);
720 assert(rc
== MEMCACHED_SUCCESS
);
721 string
= memcached_get(clone
, key
, 0,
722 &string_length
, &flags
, &rc
);
723 assert(rc
== MEMCACHED_BAD_KEY_PROVIDED
);
724 assert(string_length
== 0);
727 memcached_free(clone
);
732 #define READ_THROUGH_VALUE "set for me"
733 static memcached_return
read_through_trigger(memcached_st
*memc
__attribute__((unused
)),
734 char *key
__attribute__((unused
)),
735 size_t key_length
__attribute__((unused
)),
736 memcached_result_st
*result
)
739 return memcached_result_set_value(result
, READ_THROUGH_VALUE
, strlen(READ_THROUGH_VALUE
));
742 static test_return
read_through(memcached_st
*memc
)
747 size_t string_length
;
749 memcached_trigger_key cb
= (memcached_trigger_key
)read_through_trigger
;
751 string
= memcached_get(memc
, key
, strlen(key
),
752 &string_length
, &flags
, &rc
);
754 assert(rc
== MEMCACHED_NOTFOUND
);
755 assert(string_length
== 0);
758 rc
= memcached_callback_set(memc
, MEMCACHED_CALLBACK_GET_FAILURE
,
760 assert(rc
== MEMCACHED_SUCCESS
);
762 string
= memcached_get(memc
, key
, strlen(key
),
763 &string_length
, &flags
, &rc
);
765 assert(rc
== MEMCACHED_SUCCESS
);
766 assert(string_length
== strlen(READ_THROUGH_VALUE
));
767 assert(!strcmp(READ_THROUGH_VALUE
, string
));
770 string
= memcached_get(memc
, key
, strlen(key
),
771 &string_length
, &flags
, &rc
);
773 assert(rc
== MEMCACHED_SUCCESS
);
774 assert(string_length
== strlen(READ_THROUGH_VALUE
));
775 assert(!strcmp(READ_THROUGH_VALUE
, string
));
781 static memcached_return
delete_trigger(memcached_st
*ptr
__attribute__((unused
)),
783 size_t key_length
__attribute__((unused
)))
787 return MEMCACHED_SUCCESS
;
790 static test_return
delete_through(memcached_st
*memc
)
792 memcached_trigger_delete_key callback
;
795 callback
= (memcached_trigger_delete_key
)delete_trigger
;
797 rc
= memcached_callback_set(memc
, MEMCACHED_CALLBACK_DELETE_TRIGGER
, *(void**)&callback
);
798 assert(rc
== MEMCACHED_SUCCESS
);
803 static test_return
get_test(memcached_st
*memc
)
808 size_t string_length
;
811 rc
= memcached_delete(memc
, key
, strlen(key
), (time_t)0);
812 assert(rc
== MEMCACHED_BUFFERED
|| rc
== MEMCACHED_NOTFOUND
);
814 string
= memcached_get(memc
, key
, strlen(key
),
815 &string_length
, &flags
, &rc
);
817 assert(rc
== MEMCACHED_NOTFOUND
);
818 assert(string_length
== 0);
824 static test_return
get_test2(memcached_st
*memc
)
828 char *value
= "when we sanitize";
830 size_t string_length
;
833 rc
= memcached_set(memc
, key
, strlen(key
),
834 value
, strlen(value
),
835 (time_t)0, (uint32_t)0);
836 assert(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
);
838 string
= memcached_get(memc
, key
, strlen(key
),
839 &string_length
, &flags
, &rc
);
842 assert(rc
== MEMCACHED_SUCCESS
);
843 assert(string_length
== strlen(value
));
844 assert(!memcmp(string
, value
, string_length
));
851 static test_return
set_test2(memcached_st
*memc
)
855 char *value
= "train in the brain";
856 size_t value_length
= strlen(value
);
859 for (x
= 0; x
< 10; x
++)
861 rc
= memcached_set(memc
, key
, strlen(key
),
863 (time_t)0, (uint32_t)0);
864 assert(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
);
870 static test_return
set_test3(memcached_st
*memc
)
875 size_t value_length
= 8191;
878 value
= (char*)malloc(value_length
);
881 for (x
= 0; x
< value_length
; x
++)
882 value
[x
] = (char) (x
% 127);
884 for (x
= 0; x
< 1; x
++)
886 rc
= memcached_set(memc
, key
, strlen(key
),
888 (time_t)0, (uint32_t)0);
889 assert(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
);
897 static test_return
get_test3(memcached_st
*memc
)
902 size_t value_length
= 8191;
904 size_t string_length
;
908 value
= (char*)malloc(value_length
);
911 for (x
= 0; x
< value_length
; x
++)
912 value
[x
] = (char) (x
% 127);
914 rc
= memcached_set(memc
, key
, strlen(key
),
916 (time_t)0, (uint32_t)0);
917 assert(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
);
919 string
= memcached_get(memc
, key
, strlen(key
),
920 &string_length
, &flags
, &rc
);
922 assert(rc
== MEMCACHED_SUCCESS
);
924 assert(string_length
== value_length
);
925 assert(!memcmp(string
, value
, string_length
));
933 static test_return
get_test4(memcached_st
*memc
)
938 size_t value_length
= 8191;
940 size_t string_length
;
944 value
= (char*)malloc(value_length
);
947 for (x
= 0; x
< value_length
; x
++)
948 value
[x
] = (char) (x
% 127);
950 rc
= memcached_set(memc
, key
, strlen(key
),
952 (time_t)0, (uint32_t)0);
953 assert(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
);
955 for (x
= 0; x
< 10; x
++)
957 string
= memcached_get(memc
, key
, strlen(key
),
958 &string_length
, &flags
, &rc
);
960 assert(rc
== MEMCACHED_SUCCESS
);
962 assert(string_length
== value_length
);
963 assert(!memcmp(string
, value
, string_length
));
973 * This test verifies that memcached_read_one_response doesn't try to
974 * dereference a NIL-pointer if you issue a multi-get and don't read out all
975 * responses before you execute a storage command.
977 static test_return
get_test5(memcached_st
*memc
)
980 ** Request the same key twice, to ensure that we hash to the same server
981 ** (so that we have multiple response values queued up) ;-)
983 char *keys
[]= { "key", "key" };
984 size_t lengths
[]= { 3, 3 };
988 memcached_return rc
= memcached_set(memc
, keys
[0], lengths
[0],
989 keys
[0], lengths
[0], 0, 0);
990 assert(rc
== MEMCACHED_SUCCESS
);
991 rc
= memcached_mget(memc
, keys
, lengths
, 2);
993 memcached_result_st results_obj
;
994 memcached_result_st
*results
;
995 results
=memcached_result_create(memc
, &results_obj
);
997 results
=memcached_fetch_result(memc
, &results_obj
, &rc
);
999 memcached_result_free(&results_obj
);
1001 /* Don't read out the second result, but issue a set instead.. */
1002 rc
= memcached_set(memc
, keys
[0], lengths
[0], keys
[0], lengths
[0], 0, 0);
1003 assert(rc
== MEMCACHED_SUCCESS
);
1005 char *val
= memcached_get_by_key(memc
, keys
[0], lengths
[0], "yek", 3,
1006 &rlen
, &flags
, &rc
);
1007 assert(val
== NULL
);
1008 assert(rc
== MEMCACHED_NOTFOUND
);
1009 val
= memcached_get(memc
, keys
[0], lengths
[0], &rlen
, &flags
, &rc
);
1010 assert(val
!= NULL
);
1011 assert(rc
== MEMCACHED_SUCCESS
);
1014 return TEST_SUCCESS
;
1017 /* Do not copy the style of this code, I just access hosts to testthis function */
1018 static test_return
stats_servername_test(memcached_st
*memc
)
1020 memcached_return rc
;
1021 memcached_stat_st stat
;
1022 rc
= memcached_stat_servername(&stat
, NULL
,
1023 memc
->hosts
[0].hostname
,
1024 memc
->hosts
[0].port
);
1029 static test_return
increment_test(memcached_st
*memc
)
1031 uint64_t new_number
;
1032 memcached_return rc
;
1033 char *key
= "number";
1036 rc
= memcached_set(memc
, key
, strlen(key
),
1037 value
, strlen(value
),
1038 (time_t)0, (uint32_t)0);
1039 assert(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
);
1041 rc
= memcached_increment(memc
, key
, strlen(key
),
1043 assert(rc
== MEMCACHED_SUCCESS
);
1044 assert(new_number
== 1);
1046 rc
= memcached_increment(memc
, key
, strlen(key
),
1048 assert(rc
== MEMCACHED_SUCCESS
);
1049 assert(new_number
== 2);
1054 static test_return
increment_with_initial_test(memcached_st
*memc
)
1056 if (memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
) != 0)
1058 uint64_t new_number
;
1059 memcached_return rc
;
1060 char *key
= "number";
1061 uint64_t initial
= 0;
1063 rc
= memcached_increment_with_initial(memc
, key
, strlen(key
),
1064 1, initial
, 0, &new_number
);
1065 assert(rc
== MEMCACHED_SUCCESS
);
1066 assert(new_number
== initial
);
1068 rc
= memcached_increment_with_initial(memc
, key
, strlen(key
),
1069 1, initial
, 0, &new_number
);
1070 assert(rc
== MEMCACHED_SUCCESS
);
1071 assert(new_number
== (initial
+ 1));
1076 static test_return
decrement_test(memcached_st
*memc
)
1078 uint64_t new_number
;
1079 memcached_return rc
;
1080 char *key
= "number";
1083 rc
= memcached_set(memc
, key
, strlen(key
),
1084 value
, strlen(value
),
1085 (time_t)0, (uint32_t)0);
1086 assert(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
);
1088 rc
= memcached_decrement(memc
, key
, strlen(key
),
1090 assert(rc
== MEMCACHED_SUCCESS
);
1091 assert(new_number
== 2);
1093 rc
= memcached_decrement(memc
, key
, strlen(key
),
1095 assert(rc
== MEMCACHED_SUCCESS
);
1096 assert(new_number
== 1);
1101 static test_return
decrement_with_initial_test(memcached_st
*memc
)
1103 if (memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
) != 0)
1105 uint64_t new_number
;
1106 memcached_return rc
;
1107 char *key
= "number";
1108 uint64_t initial
= 3;
1110 rc
= memcached_decrement_with_initial(memc
, key
, strlen(key
),
1111 1, initial
, 0, &new_number
);
1112 assert(rc
== MEMCACHED_SUCCESS
);
1113 assert(new_number
== initial
);
1115 rc
= memcached_decrement_with_initial(memc
, key
, strlen(key
),
1116 1, initial
, 0, &new_number
);
1117 assert(rc
== MEMCACHED_SUCCESS
);
1118 assert(new_number
== (initial
- 1));
1123 static test_return
quit_test(memcached_st
*memc
)
1125 memcached_return rc
;
1127 char *value
= "sanford and sun";
1129 rc
= memcached_set(memc
, key
, strlen(key
),
1130 value
, strlen(value
),
1131 (time_t)10, (uint32_t)3);
1132 assert(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
);
1133 memcached_quit(memc
);
1135 rc
= memcached_set(memc
, key
, strlen(key
),
1136 value
, strlen(value
),
1137 (time_t)50, (uint32_t)9);
1138 assert(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
);
1143 static test_return
mget_result_test(memcached_st
*memc
)
1145 memcached_return rc
;
1146 char *keys
[]= {"fudge", "son", "food"};
1147 size_t key_length
[]= {5, 3, 4};
1150 memcached_result_st results_obj
;
1151 memcached_result_st
*results
;
1153 results
= memcached_result_create(memc
, &results_obj
);
1155 assert(&results_obj
== results
);
1157 /* We need to empty the server before continueing test */
1158 rc
= memcached_flush(memc
, 0);
1159 assert(rc
== MEMCACHED_SUCCESS
);
1161 rc
= memcached_mget(memc
, keys
, key_length
, 3);
1162 assert(rc
== MEMCACHED_SUCCESS
);
1164 while ((results
= memcached_fetch_result(memc
, &results_obj
, &rc
)) != NULL
)
1169 while ((results
= memcached_fetch_result(memc
, &results_obj
, &rc
)) != NULL
)
1171 assert(rc
== MEMCACHED_END
);
1173 for (x
= 0; x
< 3; x
++)
1175 rc
= memcached_set(memc
, keys
[x
], key_length
[x
],
1176 keys
[x
], key_length
[x
],
1177 (time_t)50, (uint32_t)9);
1178 assert(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
);
1181 rc
= memcached_mget(memc
, keys
, key_length
, 3);
1182 assert(rc
== MEMCACHED_SUCCESS
);
1184 while ((results
= memcached_fetch_result(memc
, &results_obj
, &rc
)))
1187 assert(&results_obj
== results
);
1188 assert(rc
== MEMCACHED_SUCCESS
);
1189 assert(memcached_result_key_length(results
) == memcached_result_length(results
));
1190 assert(!memcmp(memcached_result_key_value(results
),
1191 memcached_result_value(results
),
1192 memcached_result_length(results
)));
1195 memcached_result_free(&results_obj
);
1200 static test_return
mget_result_alloc_test(memcached_st
*memc
)
1202 memcached_return rc
;
1203 char *keys
[]= {"fudge", "son", "food"};
1204 size_t key_length
[]= {5, 3, 4};
1207 memcached_result_st
*results
;
1209 /* We need to empty the server before continueing test */
1210 rc
= memcached_flush(memc
, 0);
1211 assert(rc
== MEMCACHED_SUCCESS
);
1213 rc
= memcached_mget(memc
, keys
, key_length
, 3);
1214 assert(rc
== MEMCACHED_SUCCESS
);
1216 while ((results
= memcached_fetch_result(memc
, NULL
, &rc
)) != NULL
)
1221 assert(rc
== MEMCACHED_END
);
1223 for (x
= 0; x
< 3; x
++)
1225 rc
= memcached_set(memc
, keys
[x
], key_length
[x
],
1226 keys
[x
], key_length
[x
],
1227 (time_t)50, (uint32_t)9);
1228 assert(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
);
1231 rc
= memcached_mget(memc
, keys
, key_length
, 3);
1232 assert(rc
== MEMCACHED_SUCCESS
);
1235 while ((results
= memcached_fetch_result(memc
, NULL
, &rc
)))
1238 assert(rc
== MEMCACHED_SUCCESS
);
1239 assert(memcached_result_key_length(results
) == memcached_result_length(results
));
1240 assert(!memcmp(memcached_result_key_value(results
),
1241 memcached_result_value(results
),
1242 memcached_result_length(results
)));
1243 memcached_result_free(results
);
1250 /* Count the results */
1251 static memcached_return
callback_counter(memcached_st
*ptr
__attribute__((unused
)),
1252 memcached_result_st
*result
__attribute__((unused
)),
1255 unsigned int *counter
= (unsigned int *)context
;
1257 *counter
= *counter
+ 1;
1259 return MEMCACHED_SUCCESS
;
1262 static test_return
mget_result_function(memcached_st
*memc
)
1264 memcached_return rc
;
1265 char *keys
[]= {"fudge", "son", "food"};
1266 size_t key_length
[]= {5, 3, 4};
1268 unsigned int counter
;
1269 memcached_execute_function callbacks
[1];
1271 /* We need to empty the server before continueing test */
1272 rc
= memcached_flush(memc
, 0);
1273 for (x
= 0; x
< 3; x
++)
1275 rc
= memcached_set(memc
, keys
[x
], key_length
[x
],
1276 keys
[x
], key_length
[x
],
1277 (time_t)50, (uint32_t)9);
1278 assert(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
);
1281 rc
= memcached_mget(memc
, keys
, key_length
, 3);
1282 assert(rc
== MEMCACHED_SUCCESS
);
1284 callbacks
[0]= &callback_counter
;
1286 rc
= memcached_fetch_execute(memc
, callbacks
, (void *)&counter
, 1);
1288 assert(counter
== 3);
1293 static test_return
mget_test(memcached_st
*memc
)
1295 memcached_return rc
;
1296 char *keys
[]= {"fudge", "son", "food"};
1297 size_t key_length
[]= {5, 3, 4};
1301 char return_key
[MEMCACHED_MAX_KEY
];
1302 size_t return_key_length
;
1304 size_t return_value_length
;
1306 /* We need to empty the server before continueing test */
1307 rc
= memcached_flush(memc
, 0);
1308 assert(rc
== MEMCACHED_SUCCESS
);
1310 rc
= memcached_mget(memc
, keys
, key_length
, 3);
1311 assert(rc
== MEMCACHED_SUCCESS
);
1313 while ((return_value
= memcached_fetch(memc
, return_key
, &return_key_length
,
1314 &return_value_length
, &flags
, &rc
)) != NULL
)
1316 assert(return_value
);
1318 assert(!return_value
);
1319 assert(return_value_length
== 0);
1320 assert(rc
== MEMCACHED_END
);
1322 for (x
= 0; x
< 3; x
++)
1324 rc
= memcached_set(memc
, keys
[x
], key_length
[x
],
1325 keys
[x
], key_length
[x
],
1326 (time_t)50, (uint32_t)9);
1327 assert(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
);
1330 rc
= memcached_mget(memc
, keys
, key_length
, 3);
1331 assert(rc
== MEMCACHED_SUCCESS
);
1334 while ((return_value
= memcached_fetch(memc
, return_key
, &return_key_length
,
1335 &return_value_length
, &flags
, &rc
)))
1337 assert(return_value
);
1338 assert(rc
== MEMCACHED_SUCCESS
);
1339 assert(return_key_length
== return_value_length
);
1340 assert(!memcmp(return_value
, return_key
, return_value_length
));
1348 static test_return
get_stats_keys(memcached_st
*memc
)
1352 memcached_stat_st stat
;
1353 memcached_return rc
;
1355 list
= memcached_stat_get_keys(memc
, &stat
, &rc
);
1356 assert(rc
== MEMCACHED_SUCCESS
);
1357 for (ptr
= list
; *ptr
; ptr
++)
1366 static test_return
version_string_test(memcached_st
*memc
__attribute__((unused
)))
1368 const char *version_string
;
1370 version_string
= memcached_lib_version();
1372 assert(!strcmp(version_string
, LIBMEMCACHED_VERSION_STRING
));
1377 static test_return
get_stats(memcached_st
*memc
)
1382 memcached_return rc
;
1383 memcached_stat_st
*stat
;
1385 stat
= memcached_stat(memc
, NULL
, &rc
);
1386 assert(rc
== MEMCACHED_SUCCESS
);
1388 assert(rc
== MEMCACHED_SUCCESS
);
1391 for (x
= 0; x
< memcached_server_count(memc
); x
++)
1393 list
= memcached_stat_get_keys(memc
, stat
+x
, &rc
);
1394 assert(rc
== MEMCACHED_SUCCESS
);
1395 for (ptr
= list
; *ptr
; ptr
++);
1400 memcached_stat_free(NULL
, stat
);
1405 static test_return
add_host_test(memcached_st
*memc
)
1408 memcached_server_st
*servers
;
1409 memcached_return rc
;
1410 char servername
[]= "0.example.com";
1412 servers
= memcached_server_list_append_with_weight(NULL
, servername
, 400, 0, &rc
);
1414 assert(1 == memcached_server_list_count(servers
));
1416 for (x
= 2; x
< 20; x
++)
1418 char buffer
[SMALL_STRING_LEN
];
1420 snprintf(buffer
, SMALL_STRING_LEN
, "%u.example.com", 400+x
);
1421 servers
= memcached_server_list_append_with_weight(servers
, buffer
, 401, 0,
1423 assert(rc
== MEMCACHED_SUCCESS
);
1424 assert(x
== memcached_server_list_count(servers
));
1427 rc
= memcached_server_push(memc
, servers
);
1428 assert(rc
== MEMCACHED_SUCCESS
);
1429 rc
= memcached_server_push(memc
, servers
);
1430 assert(rc
== MEMCACHED_SUCCESS
);
1432 memcached_server_list_free(servers
);
1437 static memcached_return
clone_test_callback(memcached_st
*parent
__attribute__((unused
)), memcached_st
*clone
__attribute__((unused
)))
1439 return MEMCACHED_SUCCESS
;
1442 static memcached_return
cleanup_test_callback(memcached_st
*ptr
__attribute__((unused
)))
1444 return MEMCACHED_SUCCESS
;
1447 static test_return
callback_test(memcached_st
*memc
)
1449 /* Test User Data */
1453 memcached_return rc
;
1455 rc
= memcached_callback_set(memc
, MEMCACHED_CALLBACK_USER_DATA
, &x
);
1456 assert(rc
== MEMCACHED_SUCCESS
);
1457 test_ptr
= (int *)memcached_callback_get(memc
, MEMCACHED_CALLBACK_USER_DATA
, &rc
);
1458 assert(*test_ptr
== x
);
1461 /* Test Clone Callback */
1463 memcached_clone_func clone_cb
= (memcached_clone_func
)clone_test_callback
;
1464 void *clone_cb_ptr
= *(void **)&clone_cb
;
1465 void *temp_function
= NULL
;
1466 memcached_return rc
;
1468 rc
= memcached_callback_set(memc
, MEMCACHED_CALLBACK_CLONE_FUNCTION
,
1470 assert(rc
== MEMCACHED_SUCCESS
);
1471 temp_function
= memcached_callback_get(memc
, MEMCACHED_CALLBACK_CLONE_FUNCTION
, &rc
);
1472 assert(temp_function
== clone_cb_ptr
);
1475 /* Test Cleanup Callback */
1477 memcached_cleanup_func cleanup_cb
=
1478 (memcached_cleanup_func
)cleanup_test_callback
;
1479 void *cleanup_cb_ptr
= *(void **)&cleanup_cb
;
1480 void *temp_function
= NULL
;
1481 memcached_return rc
;
1483 rc
= memcached_callback_set(memc
, MEMCACHED_CALLBACK_CLONE_FUNCTION
,
1485 assert(rc
== MEMCACHED_SUCCESS
);
1486 temp_function
= memcached_callback_get(memc
, MEMCACHED_CALLBACK_CLONE_FUNCTION
, &rc
);
1487 assert(temp_function
== cleanup_cb_ptr
);
1493 /* We don't test the behavior itself, we test the switches */
1494 static test_return
behavior_test(memcached_st
*memc
)
1499 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NO_BLOCK
, set
);
1500 value
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_NO_BLOCK
);
1503 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_TCP_NODELAY
, set
);
1504 value
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_TCP_NODELAY
);
1507 set
= MEMCACHED_HASH_MD5
;
1508 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_HASH
, set
);
1509 value
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_HASH
);
1510 assert(value
== MEMCACHED_HASH_MD5
);
1514 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NO_BLOCK
, set
);
1515 value
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_NO_BLOCK
);
1518 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_TCP_NODELAY
, set
);
1519 value
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_TCP_NODELAY
);
1522 set
= MEMCACHED_HASH_DEFAULT
;
1523 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_HASH
, set
);
1524 value
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_HASH
);
1525 assert(value
== MEMCACHED_HASH_DEFAULT
);
1527 set
= MEMCACHED_HASH_CRC
;
1528 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_HASH
, set
);
1529 value
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_HASH
);
1530 assert(value
== MEMCACHED_HASH_CRC
);
1532 value
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_SOCKET_SEND_SIZE
);
1535 value
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_SOCKET_RECV_SIZE
);
1541 /* Test case provided by Cal Haldenbrand */
1542 static test_return
user_supplied_bug1(memcached_st
*memc
)
1544 unsigned int setter
= 1;
1547 unsigned long long total
= 0;
1550 char randomstuff
[6 * 1024];
1551 memcached_return rc
;
1553 memset(randomstuff
, 0, 6 * 1024);
1555 /* We just keep looking at the same values over and over */
1558 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NO_BLOCK
, setter
);
1559 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_TCP_NODELAY
, setter
);
1563 for (x
= 0 ; total
< 20 * 1024576 ; x
++ )
1567 size
= (rand() % ( 5 * 1024 ) ) + 400;
1568 memset(randomstuff
, 0, 6 * 1024);
1569 assert(size
< 6 * 1024); /* Being safe here */
1571 for (j
= 0 ; j
< size
;j
++)
1572 randomstuff
[j
] = (char) (rand() % 26) + 97;
1575 sprintf(key
, "%d", x
);
1576 rc
= memcached_set(memc
, key
, strlen(key
),
1577 randomstuff
, strlen(randomstuff
), 10, 0);
1578 assert(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
);
1579 /* If we fail, lets try again */
1580 if (rc
!= MEMCACHED_SUCCESS
&& rc
!= MEMCACHED_BUFFERED
)
1581 rc
= memcached_set(memc
, key
, strlen(key
),
1582 randomstuff
, strlen(randomstuff
), 10, 0);
1583 assert(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
);
1589 /* Test case provided by Cal Haldenbrand */
1590 static test_return
user_supplied_bug2(memcached_st
*memc
)
1593 unsigned int setter
;
1595 unsigned long long total
;
1598 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NO_BLOCK
, setter
);
1599 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_TCP_NODELAY
, setter
);
1601 setter
= 20 * 1024576;
1602 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_SOCKET_SEND_SIZE
, setter
);
1603 setter
= 20 * 1024576;
1604 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_SOCKET_RECV_SIZE
, setter
);
1605 getter
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_SOCKET_SEND_SIZE
);
1606 getter
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_SOCKET_RECV_SIZE
);
1608 for (x
= 0, errors
= 0, total
= 0 ; total
< 20 * 1024576 ; x
++)
1611 for (x
= 0, errors
= 0, total
= 0 ; total
< 24576 ; x
++)
1613 memcached_return rc
= MEMCACHED_SUCCESS
;
1614 char buffer
[SMALL_STRING_LEN
];
1619 memset(buffer
, 0, SMALL_STRING_LEN
);
1621 snprintf(buffer
, SMALL_STRING_LEN
, "%u", x
);
1622 getval
= memcached_get(memc
, buffer
, strlen(buffer
),
1623 &val_len
, &flags
, &rc
);
1624 if (rc
!= MEMCACHED_SUCCESS
)
1626 if (rc
== MEMCACHED_NOTFOUND
)
1630 WATCHPOINT_ERROR(rc
);
1644 /* Do a large mget() over all the keys we think exist */
1645 #define KEY_COUNT 3000 // * 1024576
1646 static test_return
user_supplied_bug3(memcached_st
*memc
)
1648 memcached_return rc
;
1649 unsigned int setter
;
1652 size_t key_lengths
[KEY_COUNT
];
1655 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NO_BLOCK
, setter
);
1656 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_TCP_NODELAY
, setter
);
1658 setter
= 20 * 1024576;
1659 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_SOCKET_SEND_SIZE
, setter
);
1660 setter
= 20 * 1024576;
1661 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_SOCKET_RECV_SIZE
, setter
);
1662 getter
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_SOCKET_SEND_SIZE
);
1663 getter
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_SOCKET_RECV_SIZE
);
1666 keys
= (char **)malloc(sizeof(char *) * KEY_COUNT
);
1668 memset(keys
, 0, (sizeof(char *) * KEY_COUNT
));
1669 for (x
= 0; x
< KEY_COUNT
; x
++)
1673 snprintf(buffer
, 30, "%u", x
);
1674 keys
[x
]= strdup(buffer
);
1675 key_lengths
[x
]= strlen(keys
[x
]);
1678 rc
= memcached_mget(memc
, keys
, key_lengths
, KEY_COUNT
);
1679 assert(rc
== MEMCACHED_SUCCESS
);
1681 /* Turn this into a help function */
1683 char return_key
[MEMCACHED_MAX_KEY
];
1684 size_t return_key_length
;
1686 size_t return_value_length
;
1689 while ((return_value
= memcached_fetch(memc
, return_key
, &return_key_length
,
1690 &return_value_length
, &flags
, &rc
)))
1692 assert(return_value
);
1693 assert(rc
== MEMCACHED_SUCCESS
);
1698 for (x
= 0; x
< KEY_COUNT
; x
++)
1705 /* Make sure we behave properly if server list has no values */
1706 static test_return
user_supplied_bug4(memcached_st
*memc
)
1708 memcached_return rc
;
1709 char *keys
[]= {"fudge", "son", "food"};
1710 size_t key_length
[]= {5, 3, 4};
1713 char return_key
[MEMCACHED_MAX_KEY
];
1714 size_t return_key_length
;
1716 size_t return_value_length
;
1718 /* Here we free everything before running a bunch of mget tests */
1720 memcached_server_list_free(memc
->hosts
);
1722 memc
->number_of_hosts
= 0;
1726 /* We need to empty the server before continueing test */
1727 rc
= memcached_flush(memc
, 0);
1728 assert(rc
== MEMCACHED_NO_SERVERS
);
1730 rc
= memcached_mget(memc
, keys
, key_length
, 3);
1731 assert(rc
== MEMCACHED_NO_SERVERS
);
1733 while ((return_value
= memcached_fetch(memc
, return_key
, &return_key_length
,
1734 &return_value_length
, &flags
, &rc
)) != NULL
)
1736 assert(return_value
);
1738 assert(!return_value
);
1739 assert(return_value_length
== 0);
1740 assert(rc
== MEMCACHED_NO_SERVERS
);
1742 for (x
= 0; x
< 3; x
++)
1744 rc
= memcached_set(memc
, keys
[x
], key_length
[x
],
1745 keys
[x
], key_length
[x
],
1746 (time_t)50, (uint32_t)9);
1747 assert(rc
== MEMCACHED_NO_SERVERS
);
1750 rc
= memcached_mget(memc
, keys
, key_length
, 3);
1751 assert(rc
== MEMCACHED_NO_SERVERS
);
1754 while ((return_value
= memcached_fetch(memc
, return_key
, &return_key_length
,
1755 &return_value_length
, &flags
, &rc
)))
1757 assert(return_value
);
1758 assert(rc
== MEMCACHED_SUCCESS
);
1759 assert(return_key_length
== return_value_length
);
1760 assert(!memcmp(return_value
, return_key
, return_value_length
));
1768 #define VALUE_SIZE_BUG5 1048064
1769 static test_return
user_supplied_bug5(memcached_st
*memc
)
1771 memcached_return rc
;
1772 char *keys
[]= {"036790384900", "036790384902", "036790384904", "036790384906"};
1773 size_t key_length
[]= {strlen("036790384900"), strlen("036790384902"), strlen("036790384904"), strlen("036790384906")};
1774 char return_key
[MEMCACHED_MAX_KEY
];
1775 size_t return_key_length
;
1777 size_t value_length
;
1781 char insert_data
[VALUE_SIZE_BUG5
];
1783 for (x
= 0; x
< VALUE_SIZE_BUG5
; x
++)
1784 insert_data
[x
]= rand();
1786 memcached_flush(memc
, 0);
1787 value
= memcached_get(memc
, keys
[0], key_length
[0],
1788 &value_length
, &flags
, &rc
);
1789 assert(value
== NULL
);
1790 rc
= memcached_mget(memc
, keys
, key_length
, 4);
1793 while ((value
= memcached_fetch(memc
, return_key
, &return_key_length
,
1794 &value_length
, &flags
, &rc
)))
1798 for (x
= 0; x
< 4; x
++)
1800 rc
= memcached_set(memc
, keys
[x
], key_length
[x
],
1801 insert_data
, VALUE_SIZE_BUG5
,
1802 (time_t)0, (uint32_t)0);
1803 assert(rc
== MEMCACHED_SUCCESS
);
1806 for (x
= 0; x
< 10; x
++)
1808 value
= memcached_get(memc
, keys
[0], key_length
[0],
1809 &value_length
, &flags
, &rc
);
1813 rc
= memcached_mget(memc
, keys
, key_length
, 4);
1815 while ((value
= memcached_fetch(memc
, return_key
, &return_key_length
,
1816 &value_length
, &flags
, &rc
)))
1827 static test_return
user_supplied_bug6(memcached_st
*memc
)
1829 memcached_return rc
;
1830 char *keys
[]= {"036790384900", "036790384902", "036790384904", "036790384906"};
1831 size_t key_length
[]= {strlen("036790384900"), strlen("036790384902"), strlen("036790384904"), strlen("036790384906")};
1832 char return_key
[MEMCACHED_MAX_KEY
];
1833 size_t return_key_length
;
1835 size_t value_length
;
1839 char insert_data
[VALUE_SIZE_BUG5
];
1841 for (x
= 0; x
< VALUE_SIZE_BUG5
; x
++)
1842 insert_data
[x
]= rand();
1844 memcached_flush(memc
, 0);
1845 value
= memcached_get(memc
, keys
[0], key_length
[0],
1846 &value_length
, &flags
, &rc
);
1847 assert(value
== NULL
);
1848 assert(rc
== MEMCACHED_NOTFOUND
);
1849 rc
= memcached_mget(memc
, keys
, key_length
, 4);
1850 assert(rc
== MEMCACHED_SUCCESS
);
1853 while ((value
= memcached_fetch(memc
, return_key
, &return_key_length
,
1854 &value_length
, &flags
, &rc
)))
1857 assert(rc
== MEMCACHED_END
);
1859 for (x
= 0; x
< 4; x
++)
1861 rc
= memcached_set(memc
, keys
[x
], key_length
[x
],
1862 insert_data
, VALUE_SIZE_BUG5
,
1863 (time_t)0, (uint32_t)0);
1864 assert(rc
== MEMCACHED_SUCCESS
);
1867 for (x
= 0; x
< 2; x
++)
1869 value
= memcached_get(memc
, keys
[0], key_length
[0],
1870 &value_length
, &flags
, &rc
);
1874 rc
= memcached_mget(memc
, keys
, key_length
, 4);
1875 assert(rc
== MEMCACHED_SUCCESS
);
1877 /* We test for purge of partial complete fetches */
1878 for (count
= 3; count
; count
--)
1880 value
= memcached_fetch(memc
, return_key
, &return_key_length
,
1881 &value_length
, &flags
, &rc
);
1882 assert(rc
== MEMCACHED_SUCCESS
);
1883 assert(!(memcmp(value
, insert_data
, value_length
)));
1884 assert(value_length
);
1892 static test_return
user_supplied_bug8(memcached_st
*memc
__attribute__((unused
)))
1894 memcached_return rc
;
1896 memcached_st
*clone
;
1898 memcached_server_st
*servers
;
1899 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";
1901 servers
= memcached_servers_parse(server_list
);
1904 mine
= memcached_create(NULL
);
1905 rc
= memcached_server_push(mine
, servers
);
1906 assert(rc
== MEMCACHED_SUCCESS
);
1907 memcached_server_list_free(servers
);
1910 clone
= memcached_clone(NULL
, mine
);
1912 memcached_quit(mine
);
1913 memcached_quit(clone
);
1916 memcached_free(mine
);
1917 memcached_free(clone
);
1922 /* Test flag store/retrieve */
1923 static test_return
user_supplied_bug7(memcached_st
*memc
)
1925 memcached_return rc
;
1926 char *keys
= "036790384900";
1927 size_t key_length
= strlen("036790384900");
1928 char return_key
[MEMCACHED_MAX_KEY
];
1929 size_t return_key_length
;
1931 size_t value_length
;
1934 char insert_data
[VALUE_SIZE_BUG5
];
1936 for (x
= 0; x
< VALUE_SIZE_BUG5
; x
++)
1937 insert_data
[x
]= rand();
1939 memcached_flush(memc
, 0);
1942 rc
= memcached_set(memc
, keys
, key_length
,
1943 insert_data
, VALUE_SIZE_BUG5
,
1945 assert(rc
== MEMCACHED_SUCCESS
);
1948 value
= memcached_get(memc
, keys
, key_length
,
1949 &value_length
, &flags
, &rc
);
1950 assert(flags
== 245);
1954 rc
= memcached_mget(memc
, &keys
, &key_length
, 1);
1957 value
= memcached_fetch(memc
, return_key
, &return_key_length
,
1958 &value_length
, &flags
, &rc
);
1959 assert(flags
== 245);
1967 static test_return
user_supplied_bug9(memcached_st
*memc
)
1969 memcached_return rc
;
1970 char *keys
[]= {"UDATA:edevil@sapo.pt", "fudge&*@#", "for^#@&$not"};
1971 size_t key_length
[3];
1976 char return_key
[MEMCACHED_MAX_KEY
];
1977 size_t return_key_length
;
1979 size_t return_value_length
;
1982 key_length
[0]= strlen("UDATA:edevil@sapo.pt");
1983 key_length
[1]= strlen("fudge&*@#");
1984 key_length
[2]= strlen("for^#@&$not");
1987 for (x
= 0; x
< 3; x
++)
1989 rc
= memcached_set(memc
, keys
[x
], key_length
[x
],
1990 keys
[x
], key_length
[x
],
1991 (time_t)50, (uint32_t)9);
1992 assert(rc
== MEMCACHED_SUCCESS
);
1995 rc
= memcached_mget(memc
, keys
, key_length
, 3);
1996 assert(rc
== MEMCACHED_SUCCESS
);
1998 /* We need to empty the server before continueing test */
1999 while ((return_value
= memcached_fetch(memc
, return_key
, &return_key_length
,
2000 &return_value_length
, &flags
, &rc
)) != NULL
)
2002 assert(return_value
);
2011 /* We are testing with aggressive timeout to get failures */
2012 static test_return
user_supplied_bug10(memcached_st
*memc
)
2016 size_t value_length
= 512;
2019 memcached_return rc
;
2020 unsigned int set
= 1;
2021 memcached_st
*mclone
= memcached_clone(NULL
, memc
);
2024 memcached_behavior_set(mclone
, MEMCACHED_BEHAVIOR_NO_BLOCK
, set
);
2025 memcached_behavior_set(mclone
, MEMCACHED_BEHAVIOR_TCP_NODELAY
, set
);
2027 memcached_behavior_set(mclone
, MEMCACHED_BEHAVIOR_POLL_TIMEOUT
, timeout
);
2029 value
= (char*)malloc(value_length
* sizeof(char));
2031 for (x
= 0; x
< value_length
; x
++)
2032 value
[x
]= (char) (x
% 127);
2034 for (x
= 1; x
<= 100000; ++x
)
2036 rc
= memcached_set(mclone
, key
, key_len
,value
, value_length
, 0, 0);
2038 assert(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_WRITE_FAILURE
||
2039 rc
== MEMCACHED_BUFFERED
|| rc
== MEMCACHED_TIMEOUT
);
2041 if (rc
== MEMCACHED_WRITE_FAILURE
|| rc
== MEMCACHED_TIMEOUT
)
2046 memcached_free(mclone
);
2052 We are looking failures in the async protocol
2054 static test_return
user_supplied_bug11(memcached_st
*memc
)
2058 size_t value_length
= 512;
2061 memcached_return rc
;
2062 unsigned int set
= 1;
2064 memcached_st
*mclone
= memcached_clone(NULL
, memc
);
2066 memcached_behavior_set(mclone
, MEMCACHED_BEHAVIOR_NO_BLOCK
, set
);
2067 memcached_behavior_set(mclone
, MEMCACHED_BEHAVIOR_TCP_NODELAY
, set
);
2069 memcached_behavior_set(mclone
, MEMCACHED_BEHAVIOR_POLL_TIMEOUT
, timeout
);
2071 timeout
= (int32_t)memcached_behavior_get(mclone
, MEMCACHED_BEHAVIOR_POLL_TIMEOUT
);
2073 assert(timeout
== -1);
2075 value
= (char*)malloc(value_length
* sizeof(char));
2077 for (x
= 0; x
< value_length
; x
++)
2078 value
[x
]= (char) (x
% 127);
2080 for (x
= 1; x
<= 100000; ++x
)
2082 rc
= memcached_set(mclone
, key
, key_len
,value
, value_length
, 0, 0);
2086 memcached_free(mclone
);
2092 Bug found where incr was not returning MEMCACHED_NOTFOUND when object did not exist.
2094 static test_return
user_supplied_bug12(memcached_st
*memc
)
2096 memcached_return rc
;
2098 size_t value_length
;
2100 uint64_t number_value
;
2102 value
= memcached_get(memc
, "autoincrement", strlen("autoincrement"),
2103 &value_length
, &flags
, &rc
);
2104 assert(value
== NULL
);
2105 assert(rc
== MEMCACHED_NOTFOUND
);
2107 rc
= memcached_increment(memc
, "autoincrement", strlen("autoincrement"),
2110 assert(value
== NULL
);
2111 /* The binary protocol will set the key if it doesn't exist */
2112 if (memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
) == 1)
2113 assert(rc
== MEMCACHED_SUCCESS
);
2115 assert(rc
== MEMCACHED_NOTFOUND
);
2117 rc
= memcached_set(memc
, "autoincrement", strlen("autoincrement"), "1", 1, 0, 0);
2119 value
= memcached_get(memc
, "autoincrement", strlen("autoincrement"),
2120 &value_length
, &flags
, &rc
);
2122 assert(rc
== MEMCACHED_SUCCESS
);
2125 rc
= memcached_increment(memc
, "autoincrement", strlen("autoincrement"),
2127 assert(number_value
== 2);
2128 assert(rc
== MEMCACHED_SUCCESS
);
2134 Bug found where command total one more than MEMCACHED_MAX_BUFFER
2135 set key34567890 0 0 8169 \r\n is sent followed by buffer of size 8169, followed by 8169
2137 static test_return
user_supplied_bug13(memcached_st
*memc
)
2139 char key
[] = "key34567890";
2141 memcached_return rc
;
2142 size_t overflowSize
;
2144 char commandFirst
[]= "set key34567890 0 0 ";
2145 char commandLast
[] = " \r\n"; /* first line of command sent to server */
2146 size_t commandLength
;
2149 commandLength
= strlen(commandFirst
) + strlen(commandLast
) + 4; /* 4 is number of characters in size, probably 8196 */
2151 overflowSize
= MEMCACHED_MAX_BUFFER
- commandLength
;
2153 for (testSize
= overflowSize
- 1; testSize
< overflowSize
+ 1; testSize
++)
2155 overflow
= malloc(testSize
);
2156 assert(overflow
!= NULL
);
2158 memset(overflow
, 'x', testSize
);
2159 rc
= memcached_set(memc
, key
, strlen(key
),
2160 overflow
, testSize
, 0, 0);
2161 assert(rc
== MEMCACHED_SUCCESS
);
2170 Test values of many different sizes
2171 Bug found where command total one more than MEMCACHED_MAX_BUFFER
2172 set key34567890 0 0 8169 \r\n
2173 is sent followed by buffer of size 8169, followed by 8169
2175 static test_return
user_supplied_bug14(memcached_st
*memc
)
2178 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_TCP_NODELAY
, setter
);
2179 memcached_return rc
;
2182 size_t value_length
= 18000;
2184 size_t string_length
;
2187 size_t current_length
;
2189 value
= (char*)malloc(value_length
);
2192 for (x
= 0; x
< value_length
; x
++)
2193 value
[x
] = (char) (x
% 127);
2195 for (current_length
= 0; current_length
< value_length
; current_length
++)
2197 rc
= memcached_set(memc
, key
, strlen(key
),
2198 value
, current_length
,
2199 (time_t)0, (uint32_t)0);
2200 assert(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
);
2202 string
= memcached_get(memc
, key
, strlen(key
),
2203 &string_length
, &flags
, &rc
);
2205 assert(rc
== MEMCACHED_SUCCESS
);
2206 assert(string_length
== current_length
);
2207 assert(!memcmp(string
, value
, string_length
));
2218 Look for zero length value problems
2220 static test_return
user_supplied_bug15(memcached_st
*memc
)
2223 memcached_return rc
;
2229 for (x
= 0; x
< 2; x
++)
2231 rc
= memcached_set(memc
, key
, strlen(key
),
2233 (time_t)0, (uint32_t)0);
2235 assert(rc
== MEMCACHED_SUCCESS
);
2237 value
= memcached_get(memc
, key
, strlen(key
),
2238 &length
, &flags
, &rc
);
2240 assert(rc
== MEMCACHED_SUCCESS
);
2241 assert(value
== NULL
);
2242 assert(length
== 0);
2245 value
= memcached_get(memc
, key
, strlen(key
),
2246 &length
, &flags
, &rc
);
2248 assert(rc
== MEMCACHED_SUCCESS
);
2249 assert(value
== NULL
);
2250 assert(length
== 0);
2257 /* Check the return sizes on FLAGS to make sure it stores 32bit unsigned values correctly */
2258 static test_return
user_supplied_bug16(memcached_st
*memc
)
2260 memcached_return rc
;
2266 rc
= memcached_set(memc
, key
, strlen(key
),
2268 (time_t)0, UINT32_MAX
);
2270 assert(rc
== MEMCACHED_SUCCESS
);
2272 value
= memcached_get(memc
, key
, strlen(key
),
2273 &length
, &flags
, &rc
);
2275 assert(rc
== MEMCACHED_SUCCESS
);
2276 assert(value
== NULL
);
2277 assert(length
== 0);
2278 assert(flags
== UINT32_MAX
);
2283 /* Check the validity of chinese key*/
2284 static test_return
user_supplied_bug17(memcached_st
*memc
)
2286 memcached_return rc
;
2288 char *value
="我们在炎热抑郁的夏天无法停止豆瓣";
2293 rc
= memcached_set(memc
, key
, strlen(key
),
2294 value
, strlen(value
),
2297 assert(rc
== MEMCACHED_SUCCESS
);
2299 value2
= memcached_get(memc
, key
, strlen(key
),
2300 &length
, &flags
, &rc
);
2302 assert(length
==strlen(value
));
2303 assert(rc
== MEMCACHED_SUCCESS
);
2304 assert(memcmp(value
, value2
, length
)==0);
2314 test_return
user_supplied_bug19(memcached_st
*memc
)
2317 memcached_server_st
*s
;
2318 memcached_return res
;
2322 m
= memcached_create(NULL
);
2323 memcached_server_add_with_weight(m
, "localhost", 11311, 100);
2324 memcached_server_add_with_weight(m
, "localhost", 11312, 100);
2326 s
= memcached_server_by_key(m
, "a", 1, &res
);
2327 memcached_server_free(s
);
2334 /* CAS test from Andei */
2335 test_return
user_supplied_bug20(memcached_st
*memc
)
2337 memcached_return status
;
2338 memcached_result_st
*result
, result_obj
;
2340 size_t key_len
= strlen("abc");
2341 char *value
= "foobar";
2342 size_t value_len
= strlen(value
);
2344 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_SUPPORT_CAS
, 1);
2346 status
= memcached_set(memc
, key
, key_len
, value
, value_len
, (time_t)0, (uint32_t)0);
2347 assert(status
== MEMCACHED_SUCCESS
);
2349 status
= memcached_mget(memc
, &key
, &key_len
, 1);
2350 assert(status
== MEMCACHED_SUCCESS
);
2352 result
= memcached_result_create(memc
, &result_obj
);
2355 memcached_result_create(memc
, &result_obj
);
2356 result
= memcached_fetch_result(memc
, &result_obj
, &status
);
2359 assert(status
== MEMCACHED_SUCCESS
);
2361 memcached_result_free(result
);
2366 #include "ketama_test_cases.h"
2367 test_return
user_supplied_bug18(memcached_st
*trash
)
2369 memcached_return rc
;
2372 memcached_server_st
*server_pool
;
2377 memc
= memcached_create(NULL
);
2380 rc
= memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_KETAMA_WEIGHTED
, 1);
2381 assert(rc
== MEMCACHED_SUCCESS
);
2383 value
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_KETAMA_WEIGHTED
);
2386 rc
= memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_KETAMA_HASH
, MEMCACHED_HASH_MD5
);
2387 assert(rc
== MEMCACHED_SUCCESS
);
2389 value
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_KETAMA_HASH
);
2390 assert(value
== MEMCACHED_HASH_MD5
);
2392 server_pool
= memcached_servers_parse("10.0.1.1:11211 600,10.0.1.2:11211 300,10.0.1.3:11211 200,10.0.1.4:11211 350,10.0.1.5:11211 1000,10.0.1.6:11211 800,10.0.1.7:11211 950,10.0.1.8:11211 100");
2393 memcached_server_push(memc
, server_pool
);
2395 /* verify that the server list was parsed okay. */
2396 assert(memc
->number_of_hosts
== 8);
2397 assert(strcmp(server_pool
[0].hostname
, "10.0.1.1") == 0);
2398 assert(server_pool
[0].port
== 11211);
2399 assert(server_pool
[0].weight
== 600);
2400 assert(strcmp(server_pool
[2].hostname
, "10.0.1.3") == 0);
2401 assert(server_pool
[2].port
== 11211);
2402 assert(server_pool
[2].weight
== 200);
2403 assert(strcmp(server_pool
[7].hostname
, "10.0.1.8") == 0);
2404 assert(server_pool
[7].port
== 11211);
2405 assert(server_pool
[7].weight
== 100);
2407 /* VDEAAAAA hashes to fffcd1b5, after the last continuum point, and lets
2408 * us test the boundary wraparound.
2410 assert(memcached_generate_hash(memc
, (char *)"VDEAAAAA", 8) == memc
->continuum
[0].index
);
2412 /* verify the standard ketama set. */
2413 for (x
= 0; x
< 99; x
++)
2415 uint32_t server_idx
= memcached_generate_hash(memc
, test_cases
[x
].key
, strlen(test_cases
[x
].key
));
2416 char *hostname
= memc
->hosts
[server_idx
].hostname
;
2417 assert(strcmp(hostname
, test_cases
[x
].server
) == 0);
2420 memcached_server_list_free(server_pool
);
2421 memcached_free(memc
);
2426 test_return
auto_eject_hosts(memcached_st
*trash
)
2430 memcached_return rc
;
2431 memcached_st
*memc
= memcached_create(NULL
);
2434 rc
= memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_KETAMA_WEIGHTED
, 1);
2435 assert(rc
== MEMCACHED_SUCCESS
);
2437 uint64_t value
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_KETAMA_WEIGHTED
);
2440 rc
= memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_KETAMA_HASH
, MEMCACHED_HASH_MD5
);
2441 assert(rc
== MEMCACHED_SUCCESS
);
2443 value
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_KETAMA_HASH
);
2444 assert(value
== MEMCACHED_HASH_MD5
);
2446 /* server should be removed when in delay */
2447 rc
= memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_AUTO_EJECT_HOSTS
, 1);
2448 assert(rc
== MEMCACHED_SUCCESS
);
2450 value
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_AUTO_EJECT_HOSTS
);
2453 memcached_server_st
*server_pool
;
2454 server_pool
= memcached_servers_parse("10.0.1.1:11211 600,10.0.1.2:11211 300,10.0.1.3:11211 200,10.0.1.4:11211 350,10.0.1.5:11211 1000,10.0.1.6:11211 800,10.0.1.7:11211 950,10.0.1.8:11211 100");
2455 memcached_server_push(memc
, server_pool
);
2457 /* verify that the server list was parsed okay. */
2458 assert(memc
->number_of_hosts
== 8);
2459 assert(strcmp(server_pool
[0].hostname
, "10.0.1.1") == 0);
2460 assert(server_pool
[0].port
== 11211);
2461 assert(server_pool
[0].weight
== 600);
2462 assert(strcmp(server_pool
[2].hostname
, "10.0.1.3") == 0);
2463 assert(server_pool
[2].port
== 11211);
2464 assert(server_pool
[2].weight
== 200);
2465 assert(strcmp(server_pool
[7].hostname
, "10.0.1.8") == 0);
2466 assert(server_pool
[7].port
== 11211);
2467 assert(server_pool
[7].weight
== 100);
2469 memc
->hosts
[2].next_retry
= time(NULL
) + 15;
2470 memc
->next_distribution_rebuild
= time(NULL
) - 1;
2472 for (int x
= 0; x
< 99; x
++)
2474 uint32_t server_idx
= memcached_generate_hash(memc
, test_cases
[x
].key
, strlen(test_cases
[x
].key
));
2475 assert(server_idx
!= 2);
2478 /* and re-added when it's back. */
2479 memc
->hosts
[2].next_retry
= time(NULL
) - 1;
2480 memc
->next_distribution_rebuild
= time(NULL
) - 1;
2481 run_distribution(memc
);
2482 for (int x
= 0; x
< 99; x
++)
2484 uint32_t server_idx
= memcached_generate_hash(memc
, test_cases
[x
].key
, strlen(test_cases
[x
].key
));
2485 char *hostname
= memc
->hosts
[server_idx
].hostname
;
2486 assert(strcmp(hostname
, test_cases
[x
].server
) == 0);
2489 memcached_server_list_free(server_pool
);
2490 memcached_free(memc
);
2492 return TEST_SUCCESS
;
2495 static test_return
result_static(memcached_st
*memc
)
2497 memcached_result_st result
;
2498 memcached_result_st
*result_ptr
;
2500 result_ptr
= memcached_result_create(memc
, &result
);
2501 assert(result
.is_allocated
== false);
2503 memcached_result_free(&result
);
2508 static test_return
result_alloc(memcached_st
*memc
)
2510 memcached_result_st
*result
;
2512 result
= memcached_result_create(memc
, NULL
);
2514 memcached_result_free(result
);
2519 static test_return
string_static_null(memcached_st
*memc
)
2521 memcached_string_st string
;
2522 memcached_string_st
*string_ptr
;
2524 string_ptr
= memcached_string_create(memc
, &string
, 0);
2525 assert(string
.is_allocated
== false);
2527 memcached_string_free(&string
);
2532 static test_return
string_alloc_null(memcached_st
*memc
)
2534 memcached_string_st
*string
;
2536 string
= memcached_string_create(memc
, NULL
, 0);
2538 memcached_string_free(string
);
2543 static test_return
string_alloc_with_size(memcached_st
*memc
)
2545 memcached_string_st
*string
;
2547 string
= memcached_string_create(memc
, NULL
, 1024);
2549 memcached_string_free(string
);
2554 static test_return
string_alloc_with_size_toobig(memcached_st
*memc
)
2556 memcached_string_st
*string
;
2558 string
= memcached_string_create(memc
, NULL
, INT64_MAX
);
2559 assert(string
== NULL
);
2564 static test_return
string_alloc_append(memcached_st
*memc
)
2567 char buffer
[SMALL_STRING_LEN
];
2568 memcached_string_st
*string
;
2570 /* Ring the bell! */
2571 memset(buffer
, 6, SMALL_STRING_LEN
);
2573 string
= memcached_string_create(memc
, NULL
, 100);
2576 for (x
= 0; x
< 1024; x
++)
2578 memcached_return rc
;
2579 rc
= memcached_string_append(string
, buffer
, SMALL_STRING_LEN
);
2580 assert(rc
== MEMCACHED_SUCCESS
);
2582 memcached_string_free(string
);
2587 static test_return
string_alloc_append_toobig(memcached_st
*memc
)
2589 memcached_return rc
;
2591 char buffer
[SMALL_STRING_LEN
];
2592 memcached_string_st
*string
;
2594 /* Ring the bell! */
2595 memset(buffer
, 6, SMALL_STRING_LEN
);
2597 string
= memcached_string_create(memc
, NULL
, 100);
2600 for (x
= 0; x
< 1024; x
++)
2602 rc
= memcached_string_append(string
, buffer
, SMALL_STRING_LEN
);
2603 assert(rc
== MEMCACHED_SUCCESS
);
2605 rc
= memcached_string_append(string
, buffer
, INT64_MAX
);
2606 assert(rc
== MEMCACHED_MEMORY_ALLOCATION_FAILURE
);
2607 memcached_string_free(string
);
2612 static test_return
cleanup_pairs(memcached_st
*memc
__attribute__((unused
)))
2614 pairs_free(global_pairs
);
2619 static test_return
generate_pairs(memcached_st
*memc
__attribute__((unused
)))
2621 unsigned long long x
;
2622 global_pairs
= pairs_generate(GLOBAL_COUNT
, 400);
2623 global_count
= GLOBAL_COUNT
;
2625 for (x
= 0; x
< global_count
; x
++)
2627 global_keys
[x
]= global_pairs
[x
].key
;
2628 global_keys_length
[x
]= global_pairs
[x
].key_length
;
2634 static test_return
generate_large_pairs(memcached_st
*memc
__attribute__((unused
)))
2636 unsigned long long x
;
2637 global_pairs
= pairs_generate(GLOBAL2_COUNT
, MEMCACHED_MAX_BUFFER
+10);
2638 global_count
= GLOBAL2_COUNT
;
2640 for (x
= 0; x
< global_count
; x
++)
2642 global_keys
[x
]= global_pairs
[x
].key
;
2643 global_keys_length
[x
]= global_pairs
[x
].key_length
;
2649 static test_return
generate_data(memcached_st
*memc
)
2651 execute_set(memc
, global_pairs
, global_count
);
2656 static test_return
generate_data_with_stats(memcached_st
*memc
)
2658 memcached_stat_st
*stat_p
;
2659 memcached_return rc
;
2660 uint32_t host_index
= 0;
2661 execute_set(memc
, global_pairs
, global_count
);
2663 //TODO: hosts used size stats
2664 stat_p
= memcached_stat(memc
, NULL
, &rc
);
2667 for (host_index
= 0; host_index
< SERVERS_TO_CREATE
; host_index
++)
2669 printf("\nserver %u|%s|%u bytes: %llu\n", host_index
, (memc
->hosts
)[host_index
].hostname
, (memc
->hosts
)[host_index
].port
, (unsigned long long)(stat_p
+ host_index
)->bytes
);
2672 memcached_stat_free(NULL
, stat_p
);
2676 static test_return
generate_buffer_data(memcached_st
*memc
)
2681 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_BUFFER_REQUESTS
, latch
);
2682 generate_data(memc
);
2687 static test_return
get_read_count(memcached_st
*memc
)
2690 memcached_return rc
;
2691 memcached_st
*clone
;
2693 clone
= memcached_clone(NULL
, memc
);
2696 memcached_server_add_with_weight(clone
, "localhost", 6666, 0);
2700 size_t return_value_length
;
2704 for (x
= count
= 0; x
< global_count
; x
++)
2706 return_value
= memcached_get(clone
, global_keys
[x
], global_keys_length
[x
],
2707 &return_value_length
, &flags
, &rc
);
2708 if (rc
== MEMCACHED_SUCCESS
)
2715 fprintf(stderr
, "\t%u -> %u", global_count
, count
);
2718 memcached_free(clone
);
2723 static test_return
get_read(memcached_st
*memc
)
2726 memcached_return rc
;
2730 size_t return_value_length
;
2733 for (x
= 0; x
< global_count
; x
++)
2735 return_value
= memcached_get(memc
, global_keys
[x
], global_keys_length
[x
],
2736 &return_value_length
, &flags
, &rc
);
2738 assert(return_value);
2739 assert(rc == MEMCACHED_SUCCESS);
2741 if (rc
== MEMCACHED_SUCCESS
&& return_value
)
2749 static test_return
mget_read(memcached_st
*memc
)
2751 memcached_return rc
;
2753 rc
= memcached_mget(memc
, global_keys
, global_keys_length
, global_count
);
2754 assert(rc
== MEMCACHED_SUCCESS
);
2755 /* Turn this into a help function */
2757 char return_key
[MEMCACHED_MAX_KEY
];
2758 size_t return_key_length
;
2760 size_t return_value_length
;
2763 while ((return_value
= memcached_fetch(memc
, return_key
, &return_key_length
,
2764 &return_value_length
, &flags
, &rc
)))
2766 assert(return_value
);
2767 assert(rc
== MEMCACHED_SUCCESS
);
2775 static test_return
mget_read_result(memcached_st
*memc
)
2777 memcached_return rc
;
2779 rc
= memcached_mget(memc
, global_keys
, global_keys_length
, global_count
);
2780 assert(rc
== MEMCACHED_SUCCESS
);
2781 /* Turn this into a help function */
2783 memcached_result_st results_obj
;
2784 memcached_result_st
*results
;
2786 results
= memcached_result_create(memc
, &results_obj
);
2788 while ((results
= memcached_fetch_result(memc
, &results_obj
, &rc
)))
2791 assert(rc
== MEMCACHED_SUCCESS
);
2794 memcached_result_free(&results_obj
);
2800 static test_return
mget_read_function(memcached_st
*memc
)
2802 memcached_return rc
;
2803 unsigned int counter
;
2804 memcached_execute_function callbacks
[1];
2806 rc
= memcached_mget(memc
, global_keys
, global_keys_length
, global_count
);
2807 assert(rc
== MEMCACHED_SUCCESS
);
2809 callbacks
[0]= &callback_counter
;
2811 rc
= memcached_fetch_execute(memc
, callbacks
, (void *)&counter
, 1);
2816 static test_return
delete_generate(memcached_st
*memc
)
2820 for (x
= 0; x
< global_count
; x
++)
2822 (void)memcached_delete(memc
, global_keys
[x
], global_keys_length
[x
], (time_t)0);
2828 static test_return
delete_buffer_generate(memcached_st
*memc
)
2834 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_BUFFER_REQUESTS
, latch
);
2836 for (x
= 0; x
< global_count
; x
++)
2838 (void)memcached_delete(memc
, global_keys
[x
], global_keys_length
[x
], (time_t)0);
2844 static test_return
add_host_test1(memcached_st
*memc
)
2847 memcached_return rc
;
2848 char servername
[]= "0.example.com";
2849 memcached_server_st
*servers
;
2851 servers
= memcached_server_list_append_with_weight(NULL
, servername
, 400, 0, &rc
);
2853 assert(1 == memcached_server_list_count(servers
));
2855 for (x
= 2; x
< 20; x
++)
2857 char buffer
[SMALL_STRING_LEN
];
2859 snprintf(buffer
, SMALL_STRING_LEN
, "%u.example.com", 400+x
);
2860 servers
= memcached_server_list_append_with_weight(servers
, buffer
, 401, 0,
2862 assert(rc
== MEMCACHED_SUCCESS
);
2863 assert(x
== memcached_server_list_count(servers
));
2866 rc
= memcached_server_push(memc
, servers
);
2867 assert(rc
== MEMCACHED_SUCCESS
);
2868 rc
= memcached_server_push(memc
, servers
);
2869 assert(rc
== MEMCACHED_SUCCESS
);
2871 memcached_server_list_free(servers
);
2876 static memcached_return
pre_nonblock(memcached_st
*memc
)
2878 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NO_BLOCK
, 0);
2880 return MEMCACHED_SUCCESS
;
2883 static memcached_return
pre_nonblock_binary(memcached_st
*memc
)
2885 memcached_return rc
= MEMCACHED_FAILURE
;
2886 memcached_st
*clone
;
2888 clone
= memcached_clone(NULL
, memc
);
2890 // The memcached_version needs to be done on a clone, because the server
2891 // will not toggle protocol on an connection.
2892 memcached_version(clone
);
2894 if (clone
->hosts
[0].major_version
>= 1 && clone
->hosts
[0].minor_version
> 2)
2896 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NO_BLOCK
, 0);
2897 rc
= memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
, 1);
2898 assert(rc
== MEMCACHED_SUCCESS
);
2899 assert(memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
) == 1);
2902 memcached_free(clone
);
2906 static memcached_return
pre_murmur(memcached_st
*memc
)
2908 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_HASH
, (uint64_t)MEMCACHED_HASH_MURMUR
);
2910 return MEMCACHED_SUCCESS
;
2913 static memcached_return
pre_jenkins(memcached_st
*memc
)
2915 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_HASH
, (uint64_t)MEMCACHED_HASH_JENKINS
);
2917 return MEMCACHED_SUCCESS
;
2921 static memcached_return
pre_md5(memcached_st
*memc
)
2923 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_HASH
, (uint64_t)MEMCACHED_HASH_MD5
);
2925 return MEMCACHED_SUCCESS
;
2928 static memcached_return
pre_crc(memcached_st
*memc
)
2930 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_HASH
, (uint64_t)MEMCACHED_HASH_CRC
);
2932 return MEMCACHED_SUCCESS
;
2935 static memcached_return
pre_hsieh(memcached_st
*memc
)
2937 #ifdef HAVE_HSIEH_HASH
2938 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_HASH
, (uint64_t)MEMCACHED_HASH_HSIEH
);
2939 return MEMCACHED_SUCCESS
;
2942 return MEMCACHED_FAILURE
;
2946 static memcached_return
pre_hash_fnv1_64(memcached_st
*memc
)
2948 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_HASH
, (uint64_t)MEMCACHED_HASH_FNV1_64
);
2950 return MEMCACHED_SUCCESS
;
2953 static memcached_return
pre_hash_fnv1a_64(memcached_st
*memc
)
2955 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_HASH
, (uint64_t)MEMCACHED_HASH_FNV1A_64
);
2957 return MEMCACHED_SUCCESS
;
2960 static memcached_return
pre_hash_fnv1_32(memcached_st
*memc
)
2962 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_HASH
, (uint64_t)MEMCACHED_HASH_FNV1_32
);
2964 return MEMCACHED_SUCCESS
;
2967 static memcached_return
pre_hash_fnv1a_32(memcached_st
*memc
)
2969 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_HASH
, (uint64_t)MEMCACHED_HASH_FNV1A_32
);
2971 return MEMCACHED_SUCCESS
;
2974 static memcached_return
pre_behavior_ketama(memcached_st
*memc
)
2976 memcached_return rc
;
2979 rc
= memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_KETAMA
, 1);
2980 assert(rc
== MEMCACHED_SUCCESS
);
2982 value
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_KETAMA
);
2985 return MEMCACHED_SUCCESS
;
2988 static memcached_return
pre_behavior_ketama_weighted(memcached_st
*memc
)
2990 memcached_return rc
;
2993 rc
= memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_KETAMA_WEIGHTED
, 1);
2994 assert(rc
== MEMCACHED_SUCCESS
);
2996 value
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_KETAMA_WEIGHTED
);
2999 rc
= memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_KETAMA_HASH
, MEMCACHED_HASH_MD5
);
3000 assert(rc
== MEMCACHED_SUCCESS
);
3002 value
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_KETAMA_HASH
);
3003 assert(value
== MEMCACHED_HASH_MD5
);
3004 return MEMCACHED_SUCCESS
;
3007 static memcached_return
pre_binary(memcached_st
*memc
)
3009 memcached_return rc
= MEMCACHED_FAILURE
;
3010 memcached_st
*clone
;
3012 clone
= memcached_clone(NULL
, memc
);
3014 // The memcached_version needs to be done on a clone, because the server
3015 // will not toggle protocol on an connection.
3016 memcached_version(clone
);
3018 if (clone
->hosts
[0].major_version
>= 1 && clone
->hosts
[0].minor_version
> 2)
3020 rc
= memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
, 1);
3021 assert(rc
== MEMCACHED_SUCCESS
);
3022 assert(memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
) == 1);
3025 memcached_free(clone
);
3029 static void my_free(memcached_st
*ptr
__attribute__((unused
)), void *mem
)
3034 static void *my_malloc(memcached_st
*ptr
__attribute__((unused
)), const size_t size
)
3036 return malloc(size
);
3039 static void *my_realloc(memcached_st
*ptr
__attribute__((unused
)), void *mem
, const size_t size
)
3041 return realloc(mem
, size
);
3044 static memcached_return
set_prefix(memcached_st
*memc
)
3046 memcached_return rc
;
3047 const char *key
= "mine";
3050 /* Make sure be default none exists */
3051 value
= memcached_callback_get(memc
, MEMCACHED_CALLBACK_PREFIX_KEY
, &rc
);
3052 assert(rc
== MEMCACHED_FAILURE
);
3054 /* Test a clean set */
3055 rc
= memcached_callback_set(memc
, MEMCACHED_CALLBACK_PREFIX_KEY
, (void *)key
);
3056 assert(rc
== MEMCACHED_SUCCESS
);
3058 value
= memcached_callback_get(memc
, MEMCACHED_CALLBACK_PREFIX_KEY
, &rc
);
3059 assert(memcmp(value
, key
, 4) == 0);
3060 assert(rc
== MEMCACHED_SUCCESS
);
3062 /* Test that we can turn it off */
3063 rc
= memcached_callback_set(memc
, MEMCACHED_CALLBACK_PREFIX_KEY
, NULL
);
3064 assert(rc
== MEMCACHED_SUCCESS
);
3066 value
= memcached_callback_get(memc
, MEMCACHED_CALLBACK_PREFIX_KEY
, &rc
);
3067 assert(rc
== MEMCACHED_FAILURE
);
3069 /* Now setup for main test */
3070 rc
= memcached_callback_set(memc
, MEMCACHED_CALLBACK_PREFIX_KEY
, (void *)key
);
3071 assert(rc
== MEMCACHED_SUCCESS
);
3073 value
= memcached_callback_get(memc
, MEMCACHED_CALLBACK_PREFIX_KEY
, &rc
);
3074 assert(rc
== MEMCACHED_SUCCESS
);
3075 assert(memcmp(value
, key
, 4) == 0);
3077 /* Set to Zero, and then Set to something too large */
3080 rc
= memcached_callback_set(memc
, MEMCACHED_CALLBACK_PREFIX_KEY
, NULL
);
3081 assert(rc
== MEMCACHED_SUCCESS
);
3083 value
= memcached_callback_get(memc
, MEMCACHED_CALLBACK_PREFIX_KEY
, &rc
);
3084 assert(rc
== MEMCACHED_FAILURE
);
3085 assert(value
== NULL
);
3087 /* Test a long key for failure */
3088 /* TODO, extend test to determine based on setting, what result should be */
3089 long_key
= "Thisismorethentheallottednumberofcharacters";
3090 rc
= memcached_callback_set(memc
, MEMCACHED_CALLBACK_PREFIX_KEY
, long_key
);
3091 //assert(rc == MEMCACHED_BAD_KEY_PROVIDED);
3092 assert(rc
== MEMCACHED_SUCCESS
);
3094 /* Now test a key with spaces (which will fail from long key, since bad key is not set) */
3095 long_key
= "This is more then the allotted number of characters";
3096 rc
= memcached_callback_set(memc
, MEMCACHED_CALLBACK_PREFIX_KEY
, long_key
);
3097 assert(rc
== MEMCACHED_BAD_KEY_PROVIDED
);
3099 /* Test for a bad prefix, but with a short key */
3100 rc
= memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_VERIFY_KEY
, 1);
3101 assert(rc
== MEMCACHED_SUCCESS
);
3103 long_key
= "dog cat";
3104 rc
= memcached_callback_set(memc
, MEMCACHED_CALLBACK_PREFIX_KEY
, long_key
);
3105 assert(rc
== MEMCACHED_BAD_KEY_PROVIDED
);
3108 return MEMCACHED_SUCCESS
;
3111 static memcached_return
set_memory_alloc(memcached_st
*memc
)
3113 void *test_ptr
= NULL
;
3116 memcached_malloc_function malloc_cb
=
3117 (memcached_malloc_function
)my_malloc
;
3118 cb_ptr
= *(void **)&malloc_cb
;
3119 memcached_return rc
;
3121 rc
= memcached_callback_set(memc
, MEMCACHED_CALLBACK_MALLOC_FUNCTION
, cb_ptr
);
3122 assert(rc
== MEMCACHED_SUCCESS
);
3123 test_ptr
= memcached_callback_get(memc
, MEMCACHED_CALLBACK_MALLOC_FUNCTION
, &rc
);
3124 assert(rc
== MEMCACHED_SUCCESS
);
3125 assert(test_ptr
== cb_ptr
);
3129 memcached_realloc_function realloc_cb
=
3130 (memcached_realloc_function
)my_realloc
;
3131 cb_ptr
= *(void **)&realloc_cb
;
3132 memcached_return rc
;
3134 rc
= memcached_callback_set(memc
, MEMCACHED_CALLBACK_REALLOC_FUNCTION
, cb_ptr
);
3135 assert(rc
== MEMCACHED_SUCCESS
);
3136 test_ptr
= memcached_callback_get(memc
, MEMCACHED_CALLBACK_REALLOC_FUNCTION
, &rc
);
3137 assert(rc
== MEMCACHED_SUCCESS
);
3138 assert(test_ptr
== cb_ptr
);
3142 memcached_free_function free_cb
=
3143 (memcached_free_function
)my_free
;
3144 cb_ptr
= *(void **)&free_cb
;
3145 memcached_return rc
;
3147 rc
= memcached_callback_set(memc
, MEMCACHED_CALLBACK_FREE_FUNCTION
, cb_ptr
);
3148 assert(rc
== MEMCACHED_SUCCESS
);
3149 test_ptr
= memcached_callback_get(memc
, MEMCACHED_CALLBACK_FREE_FUNCTION
, &rc
);
3150 assert(rc
== MEMCACHED_SUCCESS
);
3151 assert(test_ptr
== cb_ptr
);
3154 return MEMCACHED_SUCCESS
;
3157 static memcached_return
enable_consistent(memcached_st
*memc
)
3159 memcached_server_distribution value
= MEMCACHED_DISTRIBUTION_CONSISTENT
;
3160 memcached_hash hash
;
3161 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_DISTRIBUTION
, value
);
3162 if (pre_hsieh(memc
) != MEMCACHED_SUCCESS
)
3163 return MEMCACHED_FAILURE
;
3165 value
= (memcached_server_distribution
)memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_DISTRIBUTION
);
3166 assert(value
== MEMCACHED_DISTRIBUTION_CONSISTENT
);
3168 hash
= (memcached_hash
)memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_HASH
);
3169 assert(hash
== MEMCACHED_HASH_HSIEH
);
3172 return MEMCACHED_SUCCESS
;
3175 static memcached_return
enable_cas(memcached_st
*memc
)
3177 unsigned int set
= 1;
3179 memcached_version(memc
);
3181 if ((memc
->hosts
[0].major_version
>= 1 && (memc
->hosts
[0].minor_version
== 2 && memc
->hosts
[0].micro_version
>= 4))
3182 || memc
->hosts
[0].minor_version
> 2)
3184 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_SUPPORT_CAS
, set
);
3186 return MEMCACHED_SUCCESS
;
3189 return MEMCACHED_FAILURE
;
3192 static memcached_return
check_for_1_2_3(memcached_st
*memc
)
3194 memcached_version(memc
);
3196 if ((memc
->hosts
[0].major_version
>= 1 && (memc
->hosts
[0].minor_version
== 2 && memc
->hosts
[0].micro_version
>= 4))
3197 || memc
->hosts
[0].minor_version
> 2)
3198 return MEMCACHED_SUCCESS
;
3200 return MEMCACHED_FAILURE
;
3203 static memcached_return
pre_unix_socket(memcached_st
*memc
)
3205 memcached_return rc
;
3208 memcached_server_list_free(memc
->hosts
);
3210 memc
->number_of_hosts
= 0;
3212 if (stat("/tmp/memcached.socket", &buf
))
3213 return MEMCACHED_FAILURE
;
3215 rc
= memcached_server_add_unix_socket_with_weight(memc
, "/tmp/memcached.socket", 0);
3220 static memcached_return
pre_nodelay(memcached_st
*memc
)
3222 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NO_BLOCK
, 0);
3223 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_TCP_NODELAY
, 0);
3225 return MEMCACHED_SUCCESS
;
3228 static memcached_return
pre_settimer(memcached_st
*memc
)
3230 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_SND_TIMEOUT
, 1000);
3231 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_RCV_TIMEOUT
, 1000);
3233 return MEMCACHED_SUCCESS
;
3236 static memcached_return
poll_timeout(memcached_st
*memc
)
3242 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_POLL_TIMEOUT
, timeout
);
3244 timeout
= (int32_t)memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_POLL_TIMEOUT
);
3246 assert(timeout
== 100);
3248 return MEMCACHED_SUCCESS
;
3251 static test_return
noreply_test(memcached_st
*memc
)
3253 memcached_return ret
;
3254 ret
= memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NOREPLY
, 1);
3255 assert(ret
== MEMCACHED_SUCCESS
);
3256 ret
= memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_BUFFER_REQUESTS
, 1);
3257 assert(ret
== MEMCACHED_SUCCESS
);
3258 ret
= memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_SUPPORT_CAS
, 1);
3259 assert(ret
== MEMCACHED_SUCCESS
);
3260 assert(memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_NOREPLY
) == 1);
3261 assert(memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_BUFFER_REQUESTS
) == 1);
3262 assert(memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_SUPPORT_CAS
) == 1);
3264 for (int count
=0; count
< 5; ++count
)
3266 for (int x
=0; x
< 100; ++x
)
3269 size_t len
=sprintf(key
, "%d", x
);
3273 ret
=memcached_add(memc
, key
, len
, key
, len
, 0, 0);
3276 ret
=memcached_replace(memc
, key
, len
, key
, len
, 0, 0);
3279 ret
=memcached_set(memc
, key
, len
, key
, len
, 0, 0);
3282 ret
=memcached_append(memc
, key
, len
, key
, len
, 0, 0);
3285 ret
=memcached_prepend(memc
, key
, len
, key
, len
, 0, 0);
3288 assert(ret
== MEMCACHED_SUCCESS
|| ret
== MEMCACHED_BUFFERED
);
3292 ** NOTE: Don't ever do this in your code! this is not a supported use of the
3293 ** API and is _ONLY_ done this way to verify that the library works the
3294 ** way it is supposed to do!!!!
3297 for (uint32_t x
=0; x
< memc
->number_of_hosts
; ++x
)
3298 no_msg
+=memc
->hosts
[x
].cursor_active
;
3300 assert(no_msg
== 0);
3301 assert(memcached_flush_buffers(memc
) == MEMCACHED_SUCCESS
);
3304 ** Now validate that all items was set properly!
3306 for (int x
=0; x
< 100; ++x
)
3309 size_t len
=sprintf(key
, "%d", x
);
3312 char* value
=memcached_get(memc
, key
, strlen(key
),
3313 &length
, &flags
, &ret
);
3314 assert(ret
== MEMCACHED_SUCCESS
&& value
!= NULL
);
3317 case 0: /* FALLTHROUGH */
3318 case 1: /* FALLTHROUGH */
3320 assert(strncmp(value
, key
, len
) == 0);
3321 assert(len
== length
);
3324 assert(length
== len
* 2);
3327 assert(length
== len
* 3);
3334 /* Try setting an illegal cas value (should not return an error to
3335 * the caller (because we don't expect a return message from the server)
3337 char* keys
[]= {"0"};
3338 size_t lengths
[]= {1};
3341 memcached_result_st results_obj
;
3342 memcached_result_st
*results
;
3343 ret
=memcached_mget(memc
, keys
, lengths
, 1);
3344 assert(ret
== MEMCACHED_SUCCESS
);
3346 results
=memcached_result_create(memc
, &results_obj
);
3348 results
=memcached_fetch_result(memc
, &results_obj
, &ret
);
3350 assert(ret
== MEMCACHED_SUCCESS
);
3351 uint64_t cas
= memcached_result_cas(results
);
3352 memcached_result_free(&results_obj
);
3354 ret
= memcached_cas(memc
, keys
[0], lengths
[0], keys
[0], lengths
[0], 0, 0, cas
);
3355 assert(ret
== MEMCACHED_SUCCESS
);
3358 * The item will have a new cas value, so try to set it again with the old
3359 * value. This should fail!
3361 ret
= memcached_cas(memc
, keys
[0], lengths
[0], keys
[0], lengths
[0], 0, 0, cas
);
3362 assert(ret
== MEMCACHED_SUCCESS
);
3363 assert(memcached_flush_buffers(memc
) == MEMCACHED_SUCCESS
);
3364 char* value
=memcached_get(memc
, keys
[0], lengths
[0], &length
, &flags
, &ret
);
3365 assert(ret
== MEMCACHED_SUCCESS
&& value
!= NULL
);
3368 return TEST_SUCCESS
;
3371 static test_return
analyzer_test(memcached_st
*memc
)
3373 memcached_return rc
;
3374 memcached_stat_st
*stat
;
3375 memcached_analysis_st
*report
;
3377 stat
= memcached_stat(memc
, NULL
, &rc
);
3378 assert(rc
== MEMCACHED_SUCCESS
);
3381 report
= memcached_analyze(memc
, stat
, &rc
);
3382 assert(rc
== MEMCACHED_SUCCESS
);
3386 memcached_stat_free(NULL
, stat
);
3388 return TEST_SUCCESS
;
3391 #ifdef HAVE_LIBMEMCACHEDUTIL
3392 static void* connection_release(void *arg
) {
3394 memcached_pool_st
* pool
;
3399 assert(memcached_pool_push(resource
->pool
, resource
->mmc
) == MEMCACHED_SUCCESS
);
3403 static test_return
connection_pool_test(memcached_st
*memc
)
3405 memcached_pool_st
* pool
= memcached_pool_create(memc
, 5, 10);
3406 assert(pool
!= NULL
);
3407 memcached_st
* mmc
[10];
3408 memcached_return rc
;
3410 for (int x
= 0; x
< 10; ++x
) {
3411 mmc
[x
]= memcached_pool_pop(pool
, false, &rc
);
3412 assert(mmc
[x
] != NULL
);
3413 assert(rc
== MEMCACHED_SUCCESS
);
3416 assert(memcached_pool_pop(pool
, false, &rc
) == NULL
);
3417 assert(rc
== MEMCACHED_SUCCESS
);
3421 memcached_pool_st
* pool
;
3423 } item
= { .pool
= pool
, .mmc
= mmc
[9] };
3424 pthread_create(&tid
, NULL
, connection_release
, &item
);
3425 mmc
[9]= memcached_pool_pop(pool
, true, &rc
);
3426 assert(rc
== MEMCACHED_SUCCESS
);
3427 pthread_join(tid
, NULL
);
3428 assert(mmc
[9] == item
.mmc
);
3429 const char *key
= "key";
3430 size_t keylen
= strlen(key
);
3432 // verify that I can do ops with all connections
3433 rc
= memcached_set(mmc
[0], key
, keylen
, "0", 1, 0, 0);
3434 assert(rc
== MEMCACHED_SUCCESS
);
3436 for (unsigned int x
= 0; x
< 10; ++x
) {
3437 uint64_t number_value
;
3438 rc
= memcached_increment(mmc
[x
], key
, keylen
, 1, &number_value
);
3439 assert(rc
== MEMCACHED_SUCCESS
);
3440 assert(number_value
== (x
+1));
3444 for (int x
= 0; x
< 10; ++x
)
3445 assert(memcached_pool_push(pool
, mmc
[x
]) == MEMCACHED_SUCCESS
);
3447 assert(memcached_pool_destroy(pool
) == memc
);
3448 return TEST_SUCCESS
;
3452 static void increment_request_id(uint16_t *id
)
3455 if ((*id
& UDP_REQUEST_ID_THREAD_MASK
) != 0)
3459 static uint16_t *get_udp_request_ids(memcached_st
*memc
)
3461 uint16_t *ids
= malloc(sizeof(uint16_t) * memc
->number_of_hosts
);
3462 assert(ids
!= NULL
);
3464 for (x
= 0; x
< memc
->number_of_hosts
; x
++)
3465 ids
[x
]= get_udp_datagram_request_id((struct udp_datagram_header_st
*) memc
->hosts
[x
].write_buffer
);
3470 static test_return
post_udp_op_check(memcached_st
*memc
, uint16_t *expected_req_ids
)
3473 memcached_server_st
*cur_server
= memc
->hosts
;
3474 uint16_t *cur_req_ids
= get_udp_request_ids(memc
);
3475 for (x
= 0; x
< memc
->number_of_hosts
; x
++)
3477 assert(cur_server
[x
].cursor_active
== 0);
3478 assert(cur_req_ids
[x
] == expected_req_ids
[x
]);
3480 free(expected_req_ids
);
3482 return TEST_SUCCESS
;
3486 ** There is a little bit of a hack here, instead of removing
3487 ** the servers, I just set num host to 0 and them add then new udp servers
3489 static memcached_return
init_udp(memcached_st
*memc
)
3491 memcached_version(memc
);
3492 /* For the time being, only support udp test for >= 1.2.6 && < 1.3 */
3493 if (memc
->hosts
[0].major_version
!= 1 || memc
->hosts
[0].minor_version
!= 2
3494 || memc
->hosts
[0].micro_version
< 6)
3495 return MEMCACHED_FAILURE
;
3497 uint32_t num_hosts
= memc
->number_of_hosts
;
3499 memcached_server_st servers
[num_hosts
];
3500 memcpy(servers
, memc
->hosts
, sizeof(memcached_server_st
) * num_hosts
);
3501 for (x
= 0; x
< num_hosts
; x
++)
3502 memcached_server_free(&memc
->hosts
[x
]);
3503 memc
->number_of_hosts
= 0;
3504 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_USE_UDP
, 1);
3505 for (x
= 0; x
< num_hosts
; x
++)
3507 assert(memcached_server_add_udp(memc
, servers
[x
].hostname
, servers
[x
].port
) == MEMCACHED_SUCCESS
);
3508 assert(memc
->hosts
[x
].write_buffer_offset
== UDP_DATAGRAM_HEADER_LENGTH
);
3510 return MEMCACHED_SUCCESS
;
3513 static memcached_return
binary_init_udp(memcached_st
*memc
)
3516 return init_udp(memc
);
3519 /* Make sure that I cant add a tcp server to a udp client */
3520 static test_return
add_tcp_server_udp_client_test(memcached_st
*memc
)
3522 memcached_server_st server
;
3523 memcached_server_clone(&server
, &memc
->hosts
[0]);
3524 assert(memcached_server_remove(&(memc
->hosts
[0])) == MEMCACHED_SUCCESS
);
3525 assert(memcached_server_add(memc
, server
.hostname
, server
.port
) == MEMCACHED_INVALID_HOST_PROTOCOL
);
3526 return TEST_SUCCESS
;
3529 /* Make sure that I cant add a udp server to a tcp client */
3530 static test_return
add_udp_server_tcp_client_test(memcached_st
*memc
)
3532 memcached_server_st server
;
3533 memcached_server_clone(&server
, &memc
->hosts
[0]);
3534 assert(memcached_server_remove(&(memc
->hosts
[0])) == MEMCACHED_SUCCESS
);
3536 memcached_st tcp_client
;
3537 memcached_create(&tcp_client
);
3538 assert(memcached_server_add_udp(&tcp_client
, server
.hostname
, server
.port
) == MEMCACHED_INVALID_HOST_PROTOCOL
);
3539 return TEST_SUCCESS
;
3542 static test_return
set_udp_behavior_test(memcached_st
*memc
)
3545 memcached_quit(memc
);
3546 memc
->number_of_hosts
= 0;
3547 run_distribution(memc
);
3548 assert(memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_USE_UDP
, 1) == MEMCACHED_SUCCESS
);
3549 assert(memc
->flags
& MEM_USE_UDP
);
3550 assert(memc
->flags
& MEM_NOREPLY
);;
3552 assert(memc
->number_of_hosts
== 0);
3554 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_USE_UDP
,0);
3555 assert(!(memc
->flags
& MEM_USE_UDP
));
3556 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NOREPLY
,0);
3557 assert(!(memc
->flags
& MEM_NOREPLY
));
3558 return TEST_SUCCESS
;
3561 static test_return
udp_set_test(memcached_st
*memc
)
3564 unsigned int num_iters
= 1025; //request id rolls over at 1024
3565 for (x
= 0; x
< num_iters
;x
++)
3567 memcached_return rc
;
3569 char *value
= "when we sanitize";
3570 uint16_t *expected_ids
= get_udp_request_ids(memc
);
3571 unsigned int server_key
= memcached_generate_hash(memc
,key
,strlen(key
));
3572 size_t init_offset
= memc
->hosts
[server_key
].write_buffer_offset
;
3573 rc
= memcached_set(memc
, key
, strlen(key
),
3574 value
, strlen(value
),
3575 (time_t)0, (uint32_t)0);
3576 assert(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
);
3577 /** NB, the check below assumes that if new write_ptr is less than
3578 * the original write_ptr that we have flushed. For large payloads, this
3579 * maybe an invalid assumption, but for the small payload we have it is OK
3581 if (rc
== MEMCACHED_SUCCESS
||
3582 memc
->hosts
[server_key
].write_buffer_offset
< init_offset
)
3583 increment_request_id(&expected_ids
[server_key
]);
3585 if (rc
== MEMCACHED_SUCCESS
)
3587 assert(memc
->hosts
[server_key
].write_buffer_offset
== UDP_DATAGRAM_HEADER_LENGTH
);
3591 assert(memc
->hosts
[server_key
].write_buffer_offset
!= UDP_DATAGRAM_HEADER_LENGTH
);
3592 assert(memc
->hosts
[server_key
].write_buffer_offset
<= MAX_UDP_DATAGRAM_LENGTH
);
3594 assert(post_udp_op_check(memc
,expected_ids
) == TEST_SUCCESS
);
3596 return TEST_SUCCESS
;
3599 static test_return
udp_buffered_set_test(memcached_st
*memc
)
3601 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_BUFFER_REQUESTS
, 1);
3602 return udp_set_test(memc
);
3605 static test_return
udp_set_too_big_test(memcached_st
*memc
)
3607 memcached_return rc
;
3609 char value
[MAX_UDP_DATAGRAM_LENGTH
];
3610 uint16_t *expected_ids
= get_udp_request_ids(memc
);
3611 rc
= memcached_set(memc
, key
, strlen(key
),
3612 value
, MAX_UDP_DATAGRAM_LENGTH
,
3613 (time_t)0, (uint32_t)0);
3614 assert(rc
== MEMCACHED_WRITE_FAILURE
);
3615 return post_udp_op_check(memc
,expected_ids
);
3618 test_return
udp_delete_test(memcached_st
*memc
)
3621 unsigned int num_iters
= 1025; //request id rolls over at 1024
3622 for (x
= 0; x
< num_iters
;x
++)
3624 memcached_return rc
;
3626 uint16_t *expected_ids
=get_udp_request_ids(memc
);
3627 unsigned int server_key
= memcached_generate_hash(memc
, key
, strlen(key
));
3628 size_t init_offset
= memc
->hosts
[server_key
].write_buffer_offset
;
3629 rc
= memcached_delete(memc
, key
, strlen(key
), 0);
3630 assert(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
);
3631 if (rc
== MEMCACHED_SUCCESS
|| memc
->hosts
[server_key
].write_buffer_offset
< init_offset
)
3632 increment_request_id(&expected_ids
[server_key
]);
3633 if (rc
== MEMCACHED_SUCCESS
)
3634 assert(memc
->hosts
[server_key
].write_buffer_offset
== UDP_DATAGRAM_HEADER_LENGTH
);
3637 assert(memc
->hosts
[server_key
].write_buffer_offset
!= UDP_DATAGRAM_HEADER_LENGTH
);
3638 assert(memc
->hosts
[server_key
].write_buffer_offset
<= MAX_UDP_DATAGRAM_LENGTH
);
3640 assert(post_udp_op_check(memc
,expected_ids
) == TEST_SUCCESS
);
3642 return TEST_SUCCESS
;
3645 static test_return
udp_buffered_delete_test(memcached_st
*memc
)
3647 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_BUFFER_REQUESTS
, 1);
3648 return udp_delete_test(memc
);
3651 test_return
udp_verbosity_test(memcached_st
*memc
)
3653 memcached_return rc
;
3654 uint16_t *expected_ids
= get_udp_request_ids(memc
);
3656 for (x
= 0; x
< memc
->number_of_hosts
;x
++)
3657 increment_request_id(&expected_ids
[x
]);
3659 rc
= memcached_verbosity(memc
,3);
3660 assert(rc
== MEMCACHED_SUCCESS
);
3661 return post_udp_op_check(memc
,expected_ids
);
3664 test_return
udp_quit_test(memcached_st
*memc
)
3666 uint16_t *expected_ids
= get_udp_request_ids(memc
);
3667 memcached_quit(memc
);
3668 return post_udp_op_check(memc
, expected_ids
);
3671 test_return
udp_flush_test(memcached_st
*memc
)
3673 memcached_return rc
;
3674 uint16_t *expected_ids
= get_udp_request_ids(memc
);
3676 for (x
= 0; x
< memc
->number_of_hosts
;x
++)
3677 increment_request_id(&expected_ids
[x
]);
3679 rc
= memcached_flush(memc
,0);
3680 assert(rc
== MEMCACHED_SUCCESS
);
3681 return post_udp_op_check(memc
,expected_ids
);
3684 test_return
udp_incr_test(memcached_st
*memc
)
3686 memcached_return rc
;
3689 rc
= memcached_set(memc
, key
, strlen(key
),
3690 value
, strlen(value
),
3691 (time_t)0, (uint32_t)0);
3693 assert(rc
== MEMCACHED_SUCCESS
);
3694 uint16_t *expected_ids
= get_udp_request_ids(memc
);
3695 unsigned int server_key
= memcached_generate_hash(memc
, key
, strlen(key
));
3696 increment_request_id(&expected_ids
[server_key
]);
3698 rc
= memcached_increment(memc
, key
, strlen(key
), 1, &newvalue
);
3699 assert(rc
== MEMCACHED_SUCCESS
);
3700 return post_udp_op_check(memc
, expected_ids
);
3703 test_return
udp_decr_test(memcached_st
*memc
)
3705 memcached_return rc
;
3708 rc
= memcached_set(memc
, key
, strlen(key
),
3709 value
, strlen(value
),
3710 (time_t)0, (uint32_t)0);
3712 assert(rc
== MEMCACHED_SUCCESS
);
3713 uint16_t *expected_ids
= get_udp_request_ids(memc
);
3714 unsigned int server_key
= memcached_generate_hash(memc
, key
, strlen(key
));
3715 increment_request_id(&expected_ids
[server_key
]);
3717 rc
= memcached_decrement(memc
, key
, strlen(key
), 1, &newvalue
);
3718 assert(rc
== MEMCACHED_SUCCESS
);
3719 return post_udp_op_check(memc
, expected_ids
);
3723 test_return
udp_stat_test(memcached_st
*memc
)
3725 memcached_stat_st
* rv
= NULL
;
3726 memcached_return rc
;
3728 uint16_t *expected_ids
= get_udp_request_ids(memc
);
3729 rv
= memcached_stat(memc
, args
, &rc
);
3731 assert(rc
== MEMCACHED_NOT_SUPPORTED
);
3732 return post_udp_op_check(memc
, expected_ids
);
3735 test_return
udp_version_test(memcached_st
*memc
)
3737 memcached_return rc
;
3738 uint16_t *expected_ids
= get_udp_request_ids(memc
);
3739 rc
= memcached_version(memc
);
3740 assert(rc
== MEMCACHED_NOT_SUPPORTED
);
3741 return post_udp_op_check(memc
, expected_ids
);
3744 test_return
udp_get_test(memcached_st
*memc
)
3746 memcached_return rc
;
3749 uint16_t *expected_ids
= get_udp_request_ids(memc
);
3750 char *val
= memcached_get(memc
, key
, strlen(key
), &vlen
, (uint32_t)0, &rc
);
3751 assert(rc
== MEMCACHED_NOT_SUPPORTED
);
3752 assert(val
== NULL
);
3753 return post_udp_op_check(memc
, expected_ids
);
3756 test_return
udp_mixed_io_test(memcached_st
*memc
)
3759 test_st mixed_io_ops
[] ={
3760 {"udp_set_test", 0, udp_set_test
},
3761 {"udp_set_too_big_test", 0, udp_set_too_big_test
},
3762 {"udp_delete_test", 0, udp_delete_test
},
3763 {"udp_verbosity_test", 0, udp_verbosity_test
},
3764 {"udp_quit_test", 0, udp_quit_test
},
3765 {"udp_flush_test", 0, udp_flush_test
},
3766 {"udp_incr_test", 0, udp_incr_test
},
3767 {"udp_decr_test", 0, udp_decr_test
},
3768 {"udp_version_test", 0, udp_version_test
}
3771 for (x
= 0; x
< 500; x
++)
3773 current_op
= mixed_io_ops
[random() % 9];
3774 assert(current_op
.function(memc
) == TEST_SUCCESS
);
3776 return TEST_SUCCESS
;
3779 test_return
hsieh_avaibility_test (memcached_st
*memc
)
3781 memcached_return expected_rc
= MEMCACHED_FAILURE
;
3782 #ifdef HAVE_HSIEH_HASH
3783 expected_rc
= MEMCACHED_SUCCESS
;
3785 memcached_return rc
= memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_HASH
,
3786 (uint64_t)MEMCACHED_HASH_HSIEH
);
3787 assert(rc
== expected_rc
);
3788 return TEST_SUCCESS
;
3791 test_st udp_setup_server_tests
[] ={
3792 {"set_udp_behavior_test", 0, set_udp_behavior_test
},
3793 {"add_tcp_server_udp_client_test", 0, add_tcp_server_udp_client_test
},
3794 {"add_udp_server_tcp_client_test", 0, add_udp_server_tcp_client_test
},
3798 test_st upd_io_tests
[] ={
3799 {"udp_set_test", 0, udp_set_test
},
3800 {"udp_buffered_set_test", 0, udp_buffered_set_test
},
3801 {"udp_set_too_big_test", 0, udp_set_too_big_test
},
3802 {"udp_delete_test", 0, udp_delete_test
},
3803 {"udp_buffered_delete_test", 0, udp_buffered_delete_test
},
3804 {"udp_verbosity_test", 0, udp_verbosity_test
},
3805 {"udp_quit_test", 0, udp_quit_test
},
3806 {"udp_flush_test", 0, udp_flush_test
},
3807 {"udp_incr_test", 0, udp_incr_test
},
3808 {"udp_decr_test", 0, udp_decr_test
},
3809 {"udp_stat_test", 0, udp_stat_test
},
3810 {"udp_version_test", 0, udp_version_test
},
3811 {"udp_get_test", 0, udp_get_test
},
3812 {"udp_mixed_io_test", 0, udp_mixed_io_test
},
3816 /* Clean the server before beginning testing */
3818 {"flush", 0, flush_test
},
3819 {"init", 0, init_test
},
3820 {"allocation", 0, allocation_test
},
3821 {"server_list_null_test", 0, server_list_null_test
},
3822 {"server_unsort", 0, server_unsort_test
},
3823 {"server_sort", 0, server_sort_test
},
3824 {"server_sort2", 0, server_sort2_test
},
3825 {"clone_test", 0, clone_test
},
3826 {"connection_test", 0, connection_test
},
3827 {"callback_test", 0, callback_test
},
3828 {"behavior_test", 0, behavior_test
},
3829 {"error", 0, error_test
},
3830 {"set", 0, set_test
},
3831 {"set2", 0, set_test2
},
3832 {"set3", 0, set_test3
},
3833 {"add", 1, add_test
},
3834 {"replace", 1, replace_test
},
3835 {"delete", 1, delete_test
},
3836 {"get", 1, get_test
},
3837 {"get2", 0, get_test2
},
3838 {"get3", 0, get_test3
},
3839 {"get4", 0, get_test4
},
3840 {"partial mget", 0, get_test5
},
3841 {"stats_servername", 0, stats_servername_test
},
3842 {"increment", 0, increment_test
},
3843 {"increment_with_initial", 1, increment_with_initial_test
},
3844 {"decrement", 0, decrement_test
},
3845 {"decrement_with_initial", 1, decrement_with_initial_test
},
3846 {"quit", 0, quit_test
},
3847 {"mget", 1, mget_test
},
3848 {"mget_result", 1, mget_result_test
},
3849 {"mget_result_alloc", 1, mget_result_alloc_test
},
3850 {"mget_result_function", 1, mget_result_function
},
3851 {"get_stats", 0, get_stats
},
3852 {"add_host_test", 0, add_host_test
},
3853 {"add_host_test_1", 0, add_host_test1
},
3854 {"get_stats_keys", 0, get_stats_keys
},
3855 {"behavior_test", 0, get_stats_keys
},
3856 {"callback_test", 0, get_stats_keys
},
3857 {"version_string_test", 0, version_string_test
},
3858 {"bad_key", 1, bad_key_test
},
3859 {"memcached_server_cursor", 1, memcached_server_cursor_test
},
3860 {"read_through", 1, read_through
},
3861 {"delete_through", 1, delete_through
},
3862 {"noreply", 1, noreply_test
},
3863 {"analyzer", 1, analyzer_test
},
3864 #ifdef HAVE_LIBMEMCACHEDUTIL
3865 {"connectionpool", 1, connection_pool_test
},
3870 test_st async_tests
[] ={
3871 {"add", 1, add_wrapper
},
3875 test_st string_tests
[] ={
3876 {"string static with null", 0, string_static_null
},
3877 {"string alloc with null", 0, string_alloc_null
},
3878 {"string alloc with 1K", 0, string_alloc_with_size
},
3879 {"string alloc with malloc failure", 0, string_alloc_with_size_toobig
},
3880 {"string append", 0, string_alloc_append
},
3881 {"string append failure (too big)", 0, string_alloc_append_toobig
},
3885 test_st result_tests
[] ={
3886 {"result static", 0, result_static
},
3887 {"result alloc", 0, result_alloc
},
3891 test_st version_1_2_3
[] ={
3892 {"append", 0, append_test
},
3893 {"prepend", 0, prepend_test
},
3894 {"cas", 0, cas_test
},
3895 {"cas2", 0, cas2_test
},
3896 {"append_binary", 0, append_binary_test
},
3900 test_st user_tests
[] ={
3901 {"user_supplied_bug1", 0, user_supplied_bug1
},
3902 {"user_supplied_bug2", 0, user_supplied_bug2
},
3903 {"user_supplied_bug3", 0, user_supplied_bug3
},
3904 {"user_supplied_bug4", 0, user_supplied_bug4
},
3905 {"user_supplied_bug5", 1, user_supplied_bug5
},
3906 {"user_supplied_bug6", 1, user_supplied_bug6
},
3907 {"user_supplied_bug7", 1, user_supplied_bug7
},
3908 {"user_supplied_bug8", 1, user_supplied_bug8
},
3909 {"user_supplied_bug9", 1, user_supplied_bug9
},
3910 {"user_supplied_bug10", 1, user_supplied_bug10
},
3911 {"user_supplied_bug11", 1, user_supplied_bug11
},
3912 {"user_supplied_bug12", 1, user_supplied_bug12
},
3913 {"user_supplied_bug13", 1, user_supplied_bug13
},
3914 {"user_supplied_bug14", 1, user_supplied_bug14
},
3915 {"user_supplied_bug15", 1, user_supplied_bug15
},
3916 {"user_supplied_bug16", 1, user_supplied_bug16
},
3919 ** It seems to be something weird with the character sets..
3920 ** value_fetch is unable to parse the value line (iscntrl "fails"), so I
3921 ** guess I need to find out how this is supposed to work.. Perhaps I need
3922 ** to run the test in a specific locale (I tried zh_CN.UTF-8 without success,
3923 ** so just disable the code for now...).
3925 {"user_supplied_bug17", 1, user_supplied_bug17
},
3927 {"user_supplied_bug18", 1, user_supplied_bug18
},
3928 {"user_supplied_bug19", 1, user_supplied_bug19
},
3929 {"user_supplied_bug20", 1, user_supplied_bug20
},
3933 test_st generate_tests
[] ={
3934 {"generate_pairs", 1, generate_pairs
},
3935 {"generate_data", 1, generate_data
},
3936 {"get_read", 0, get_read
},
3937 {"delete_generate", 0, delete_generate
},
3938 {"generate_buffer_data", 1, generate_buffer_data
},
3939 {"delete_buffer", 0, delete_buffer_generate
},
3940 {"generate_data", 1, generate_data
},
3941 {"mget_read", 0, mget_read
},
3942 {"mget_read_result", 0, mget_read_result
},
3943 {"mget_read_function", 0, mget_read_function
},
3944 {"cleanup", 1, cleanup_pairs
},
3945 {"generate_large_pairs", 1, generate_large_pairs
},
3946 {"generate_data", 1, generate_data
},
3947 {"generate_buffer_data", 1, generate_buffer_data
},
3948 {"cleanup", 1, cleanup_pairs
},
3952 test_st consistent_tests
[] ={
3953 {"generate_pairs", 1, generate_pairs
},
3954 {"generate_data", 1, generate_data
},
3955 {"get_read", 0, get_read_count
},
3956 {"cleanup", 1, cleanup_pairs
},
3960 test_st consistent_weighted_tests
[] ={
3961 {"generate_pairs", 1, generate_pairs
},
3962 {"generate_data", 1, generate_data_with_stats
},
3963 {"get_read", 0, get_read_count
},
3964 {"cleanup", 1, cleanup_pairs
},
3968 test_st hsieh_availability
[] ={
3969 {"hsieh_avaibility_test",0,hsieh_avaibility_test
},
3973 test_st ketama_auto_eject_hosts
[] ={
3974 {"auto_eject_hosts", 1, auto_eject_hosts
},
3978 collection_st collection
[] ={
3979 {"hsieh_availability",0,0,hsieh_availability
},
3980 {"udp_setup", init_udp
, 0, udp_setup_server_tests
},
3981 {"udp_io", init_udp
, 0, upd_io_tests
},
3982 {"udp_binary_io", binary_init_udp
, 0, upd_io_tests
},
3983 {"block", 0, 0, tests
},
3984 {"binary", pre_binary
, 0, tests
},
3985 {"nonblock", pre_nonblock
, 0, tests
},
3986 {"nodelay", pre_nodelay
, 0, tests
},
3987 {"settimer", pre_settimer
, 0, tests
},
3988 {"md5", pre_md5
, 0, tests
},
3989 {"crc", pre_crc
, 0, tests
},
3990 {"hsieh", pre_hsieh
, 0, tests
},
3991 {"jenkins", pre_jenkins
, 0, tests
},
3992 {"fnv1_64", pre_hash_fnv1_64
, 0, tests
},
3993 {"fnv1a_64", pre_hash_fnv1a_64
, 0, tests
},
3994 {"fnv1_32", pre_hash_fnv1_32
, 0, tests
},
3995 {"fnv1a_32", pre_hash_fnv1a_32
, 0, tests
},
3996 {"ketama", pre_behavior_ketama
, 0, tests
},
3997 {"ketama_auto_eject_hosts", pre_behavior_ketama
, 0, ketama_auto_eject_hosts
},
3998 {"unix_socket", pre_unix_socket
, 0, tests
},
3999 {"unix_socket_nodelay", pre_nodelay
, 0, tests
},
4000 {"poll_timeout", poll_timeout
, 0, tests
},
4001 {"gets", enable_cas
, 0, tests
},
4002 {"consistent", enable_consistent
, 0, tests
},
4003 {"memory_allocators", set_memory_alloc
, 0, tests
},
4004 {"prefix", set_prefix
, 0, tests
},
4005 {"version_1_2_3", check_for_1_2_3
, 0, version_1_2_3
},
4006 {"string", 0, 0, string_tests
},
4007 {"result", 0, 0, result_tests
},
4008 {"async", pre_nonblock
, 0, async_tests
},
4009 {"async_binary", pre_nonblock_binary
, 0, async_tests
},
4010 {"user", 0, 0, user_tests
},
4011 {"generate", 0, 0, generate_tests
},
4012 {"generate_hsieh", pre_hsieh
, 0, generate_tests
},
4013 {"generate_ketama", pre_behavior_ketama
, 0, generate_tests
},
4014 {"generate_hsieh_consistent", enable_consistent
, 0, generate_tests
},
4015 {"generate_md5", pre_md5
, 0, generate_tests
},
4016 {"generate_murmur", pre_murmur
, 0, generate_tests
},
4017 {"generate_jenkins", pre_jenkins
, 0, generate_tests
},
4018 {"generate_nonblock", pre_nonblock
, 0, generate_tests
},
4019 {"consistent_not", 0, 0, consistent_tests
},
4020 {"consistent_ketama", pre_behavior_ketama
, 0, consistent_tests
},
4021 {"consistent_ketama_weighted", pre_behavior_ketama_weighted
, 0, consistent_weighted_tests
},
4025 #define SERVERS_TO_CREATE 5
4027 /* Prototypes for functions we will pass to test framework */
4028 void *world_create(void);
4029 void world_destroy(void *p
);
4031 void *world_create(void)
4033 server_startup_st
*construct
;
4035 construct
= (server_startup_st
*)malloc(sizeof(server_startup_st
));
4036 memset(construct
, 0, sizeof(server_startup_st
));
4037 construct
->count
= SERVERS_TO_CREATE
;
4039 server_startup(construct
);
4045 void world_destroy(void *p
)
4047 server_startup_st
*construct
= (server_startup_st
*)p
;
4048 memcached_server_st
*servers
= (memcached_server_st
*)construct
->servers
;
4049 memcached_server_list_free(servers
);
4051 server_shutdown(construct
);
4055 void get_world(world_st
*world
)
4057 world
->collections
= collection
;
4058 world
->create
= world_create
;
4059 world
->destroy
= world_destroy
;