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
;
750 string
= memcached_get(memc
, key
, strlen(key
),
751 &string_length
, &flags
, &rc
);
753 assert(rc
== MEMCACHED_NOTFOUND
);
754 assert(string_length
== 0);
757 rc
= memcached_callback_set(memc
, MEMCACHED_CALLBACK_GET_FAILURE
, (void *)read_through_trigger
);
758 assert(rc
== MEMCACHED_SUCCESS
);
760 string
= memcached_get(memc
, key
, strlen(key
),
761 &string_length
, &flags
, &rc
);
763 assert(rc
== MEMCACHED_SUCCESS
);
764 assert(string_length
== strlen(READ_THROUGH_VALUE
));
765 assert(!strcmp(READ_THROUGH_VALUE
, string
));
768 string
= memcached_get(memc
, key
, strlen(key
),
769 &string_length
, &flags
, &rc
);
771 assert(rc
== MEMCACHED_SUCCESS
);
772 assert(string_length
== strlen(READ_THROUGH_VALUE
));
773 assert(!strcmp(READ_THROUGH_VALUE
, string
));
779 static memcached_return
delete_trigger(memcached_st
*ptr
__attribute__((unused
)),
781 size_t key_length
__attribute__((unused
)))
785 return MEMCACHED_SUCCESS
;
788 static test_return
delete_through(memcached_st
*memc
)
790 memcached_trigger_delete_key callback
;
793 callback
= delete_trigger
;
795 rc
= memcached_callback_set(memc
, MEMCACHED_CALLBACK_DELETE_TRIGGER
, (void*)callback
);
796 assert(rc
== MEMCACHED_SUCCESS
);
801 static test_return
get_test(memcached_st
*memc
)
806 size_t string_length
;
809 rc
= memcached_delete(memc
, key
, strlen(key
), (time_t)0);
810 assert(rc
== MEMCACHED_BUFFERED
|| rc
== MEMCACHED_NOTFOUND
);
812 string
= memcached_get(memc
, key
, strlen(key
),
813 &string_length
, &flags
, &rc
);
815 assert(rc
== MEMCACHED_NOTFOUND
);
816 assert(string_length
== 0);
822 static test_return
get_test2(memcached_st
*memc
)
826 char *value
= "when we sanitize";
828 size_t string_length
;
831 rc
= memcached_set(memc
, key
, strlen(key
),
832 value
, strlen(value
),
833 (time_t)0, (uint32_t)0);
834 assert(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
);
836 string
= memcached_get(memc
, key
, strlen(key
),
837 &string_length
, &flags
, &rc
);
840 assert(rc
== MEMCACHED_SUCCESS
);
841 assert(string_length
== strlen(value
));
842 assert(!memcmp(string
, value
, string_length
));
849 static test_return
set_test2(memcached_st
*memc
)
853 char *value
= "train in the brain";
854 size_t value_length
= strlen(value
);
857 for (x
= 0; x
< 10; x
++)
859 rc
= memcached_set(memc
, key
, strlen(key
),
861 (time_t)0, (uint32_t)0);
862 assert(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
);
868 static test_return
set_test3(memcached_st
*memc
)
873 size_t value_length
= 8191;
876 value
= (char*)malloc(value_length
);
879 for (x
= 0; x
< value_length
; x
++)
880 value
[x
] = (char) (x
% 127);
882 for (x
= 0; x
< 1; x
++)
884 rc
= memcached_set(memc
, key
, strlen(key
),
886 (time_t)0, (uint32_t)0);
887 assert(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
);
895 static test_return
get_test3(memcached_st
*memc
)
900 size_t value_length
= 8191;
902 size_t string_length
;
906 value
= (char*)malloc(value_length
);
909 for (x
= 0; x
< value_length
; x
++)
910 value
[x
] = (char) (x
% 127);
912 rc
= memcached_set(memc
, key
, strlen(key
),
914 (time_t)0, (uint32_t)0);
915 assert(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
);
917 string
= memcached_get(memc
, key
, strlen(key
),
918 &string_length
, &flags
, &rc
);
920 assert(rc
== MEMCACHED_SUCCESS
);
922 assert(string_length
== value_length
);
923 assert(!memcmp(string
, value
, string_length
));
931 static test_return
get_test4(memcached_st
*memc
)
936 size_t value_length
= 8191;
938 size_t string_length
;
942 value
= (char*)malloc(value_length
);
945 for (x
= 0; x
< value_length
; x
++)
946 value
[x
] = (char) (x
% 127);
948 rc
= memcached_set(memc
, key
, strlen(key
),
950 (time_t)0, (uint32_t)0);
951 assert(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
);
953 for (x
= 0; x
< 10; x
++)
955 string
= memcached_get(memc
, key
, strlen(key
),
956 &string_length
, &flags
, &rc
);
958 assert(rc
== MEMCACHED_SUCCESS
);
960 assert(string_length
== value_length
);
961 assert(!memcmp(string
, value
, string_length
));
971 * This test verifies that memcached_read_one_response doesn't try to
972 * dereference a NIL-pointer if you issue a multi-get and don't read out all
973 * responses before you execute a storage command.
975 static test_return
get_test5(memcached_st
*memc
)
978 ** Request the same key twice, to ensure that we hash to the same server
979 ** (so that we have multiple response values queued up) ;-)
981 char *keys
[]= { "key", "key" };
982 size_t lengths
[]= { 3, 3 };
986 memcached_return rc
= memcached_set(memc
, keys
[0], lengths
[0],
987 keys
[0], lengths
[0], 0, 0);
988 assert(rc
== MEMCACHED_SUCCESS
);
989 rc
= memcached_mget(memc
, keys
, lengths
, 2);
991 memcached_result_st results_obj
;
992 memcached_result_st
*results
;
993 results
=memcached_result_create(memc
, &results_obj
);
995 results
=memcached_fetch_result(memc
, &results_obj
, &rc
);
997 memcached_result_free(&results_obj
);
999 /* Don't read out the second result, but issue a set instead.. */
1000 rc
= memcached_set(memc
, keys
[0], lengths
[0], keys
[0], lengths
[0], 0, 0);
1001 assert(rc
== MEMCACHED_SUCCESS
);
1003 char *val
= memcached_get_by_key(memc
, keys
[0], lengths
[0], "yek", 3,
1004 &rlen
, &flags
, &rc
);
1005 assert(val
== NULL
);
1006 assert(rc
== MEMCACHED_NOTFOUND
);
1007 val
= memcached_get(memc
, keys
[0], lengths
[0], &rlen
, &flags
, &rc
);
1008 assert(val
!= NULL
);
1009 assert(rc
== MEMCACHED_SUCCESS
);
1012 return TEST_SUCCESS
;
1015 /* Do not copy the style of this code, I just access hosts to testthis function */
1016 static test_return
stats_servername_test(memcached_st
*memc
)
1018 memcached_return rc
;
1019 memcached_stat_st stat
;
1020 rc
= memcached_stat_servername(&stat
, NULL
,
1021 memc
->hosts
[0].hostname
,
1022 memc
->hosts
[0].port
);
1027 static test_return
increment_test(memcached_st
*memc
)
1029 uint64_t new_number
;
1030 memcached_return rc
;
1031 char *key
= "number";
1034 rc
= memcached_set(memc
, key
, strlen(key
),
1035 value
, strlen(value
),
1036 (time_t)0, (uint32_t)0);
1037 assert(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
);
1039 rc
= memcached_increment(memc
, key
, strlen(key
),
1041 assert(rc
== MEMCACHED_SUCCESS
);
1042 assert(new_number
== 1);
1044 rc
= memcached_increment(memc
, key
, strlen(key
),
1046 assert(rc
== MEMCACHED_SUCCESS
);
1047 assert(new_number
== 2);
1052 static test_return
increment_with_initial_test(memcached_st
*memc
)
1054 if (memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
) != 0)
1056 uint64_t new_number
;
1057 memcached_return rc
;
1058 char *key
= "number";
1059 uint64_t initial
= 0;
1061 rc
= memcached_increment_with_initial(memc
, key
, strlen(key
),
1062 1, initial
, 0, &new_number
);
1063 assert(rc
== MEMCACHED_SUCCESS
);
1064 assert(new_number
== initial
);
1066 rc
= memcached_increment_with_initial(memc
, key
, strlen(key
),
1067 1, initial
, 0, &new_number
);
1068 assert(rc
== MEMCACHED_SUCCESS
);
1069 assert(new_number
== (initial
+ 1));
1074 static test_return
decrement_test(memcached_st
*memc
)
1076 uint64_t new_number
;
1077 memcached_return rc
;
1078 char *key
= "number";
1081 rc
= memcached_set(memc
, key
, strlen(key
),
1082 value
, strlen(value
),
1083 (time_t)0, (uint32_t)0);
1084 assert(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
);
1086 rc
= memcached_decrement(memc
, key
, strlen(key
),
1088 assert(rc
== MEMCACHED_SUCCESS
);
1089 assert(new_number
== 2);
1091 rc
= memcached_decrement(memc
, key
, strlen(key
),
1093 assert(rc
== MEMCACHED_SUCCESS
);
1094 assert(new_number
== 1);
1099 static test_return
decrement_with_initial_test(memcached_st
*memc
)
1101 if (memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
) != 0)
1103 uint64_t new_number
;
1104 memcached_return rc
;
1105 char *key
= "number";
1106 uint64_t initial
= 3;
1108 rc
= memcached_decrement_with_initial(memc
, key
, strlen(key
),
1109 1, initial
, 0, &new_number
);
1110 assert(rc
== MEMCACHED_SUCCESS
);
1111 assert(new_number
== initial
);
1113 rc
= memcached_decrement_with_initial(memc
, key
, strlen(key
),
1114 1, initial
, 0, &new_number
);
1115 assert(rc
== MEMCACHED_SUCCESS
);
1116 assert(new_number
== (initial
- 1));
1121 static test_return
quit_test(memcached_st
*memc
)
1123 memcached_return rc
;
1125 char *value
= "sanford and sun";
1127 rc
= memcached_set(memc
, key
, strlen(key
),
1128 value
, strlen(value
),
1129 (time_t)10, (uint32_t)3);
1130 assert(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
);
1131 memcached_quit(memc
);
1133 rc
= memcached_set(memc
, key
, strlen(key
),
1134 value
, strlen(value
),
1135 (time_t)50, (uint32_t)9);
1136 assert(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
);
1141 static test_return
mget_result_test(memcached_st
*memc
)
1143 memcached_return rc
;
1144 char *keys
[]= {"fudge", "son", "food"};
1145 size_t key_length
[]= {5, 3, 4};
1148 memcached_result_st results_obj
;
1149 memcached_result_st
*results
;
1151 results
= memcached_result_create(memc
, &results_obj
);
1153 assert(&results_obj
== results
);
1155 /* We need to empty the server before continueing test */
1156 rc
= memcached_flush(memc
, 0);
1157 assert(rc
== MEMCACHED_SUCCESS
);
1159 rc
= memcached_mget(memc
, keys
, key_length
, 3);
1160 assert(rc
== MEMCACHED_SUCCESS
);
1162 while ((results
= memcached_fetch_result(memc
, &results_obj
, &rc
)) != NULL
)
1167 while ((results
= memcached_fetch_result(memc
, &results_obj
, &rc
)) != NULL
)
1169 assert(rc
== MEMCACHED_END
);
1171 for (x
= 0; x
< 3; x
++)
1173 rc
= memcached_set(memc
, keys
[x
], key_length
[x
],
1174 keys
[x
], key_length
[x
],
1175 (time_t)50, (uint32_t)9);
1176 assert(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
);
1179 rc
= memcached_mget(memc
, keys
, key_length
, 3);
1180 assert(rc
== MEMCACHED_SUCCESS
);
1182 while ((results
= memcached_fetch_result(memc
, &results_obj
, &rc
)))
1185 assert(&results_obj
== results
);
1186 assert(rc
== MEMCACHED_SUCCESS
);
1187 assert(memcached_result_key_length(results
) == memcached_result_length(results
));
1188 assert(!memcmp(memcached_result_key_value(results
),
1189 memcached_result_value(results
),
1190 memcached_result_length(results
)));
1193 memcached_result_free(&results_obj
);
1198 static test_return
mget_result_alloc_test(memcached_st
*memc
)
1200 memcached_return rc
;
1201 char *keys
[]= {"fudge", "son", "food"};
1202 size_t key_length
[]= {5, 3, 4};
1205 memcached_result_st
*results
;
1207 /* We need to empty the server before continueing test */
1208 rc
= memcached_flush(memc
, 0);
1209 assert(rc
== MEMCACHED_SUCCESS
);
1211 rc
= memcached_mget(memc
, keys
, key_length
, 3);
1212 assert(rc
== MEMCACHED_SUCCESS
);
1214 while ((results
= memcached_fetch_result(memc
, NULL
, &rc
)) != NULL
)
1219 assert(rc
== MEMCACHED_END
);
1221 for (x
= 0; x
< 3; x
++)
1223 rc
= memcached_set(memc
, keys
[x
], key_length
[x
],
1224 keys
[x
], key_length
[x
],
1225 (time_t)50, (uint32_t)9);
1226 assert(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
);
1229 rc
= memcached_mget(memc
, keys
, key_length
, 3);
1230 assert(rc
== MEMCACHED_SUCCESS
);
1233 while ((results
= memcached_fetch_result(memc
, NULL
, &rc
)))
1236 assert(rc
== MEMCACHED_SUCCESS
);
1237 assert(memcached_result_key_length(results
) == memcached_result_length(results
));
1238 assert(!memcmp(memcached_result_key_value(results
),
1239 memcached_result_value(results
),
1240 memcached_result_length(results
)));
1241 memcached_result_free(results
);
1248 /* Count the results */
1249 static memcached_return
callback_counter(memcached_st
*ptr
__attribute__((unused
)),
1250 memcached_result_st
*result
__attribute__((unused
)),
1253 unsigned int *counter
= (unsigned int *)context
;
1255 *counter
= *counter
+ 1;
1257 return MEMCACHED_SUCCESS
;
1260 static test_return
mget_result_function(memcached_st
*memc
)
1262 memcached_return rc
;
1263 char *keys
[]= {"fudge", "son", "food"};
1264 size_t key_length
[]= {5, 3, 4};
1266 unsigned int counter
;
1267 memcached_execute_function callbacks
[1];
1269 /* We need to empty the server before continueing test */
1270 rc
= memcached_flush(memc
, 0);
1271 for (x
= 0; x
< 3; x
++)
1273 rc
= memcached_set(memc
, keys
[x
], key_length
[x
],
1274 keys
[x
], key_length
[x
],
1275 (time_t)50, (uint32_t)9);
1276 assert(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
);
1279 rc
= memcached_mget(memc
, keys
, key_length
, 3);
1280 assert(rc
== MEMCACHED_SUCCESS
);
1282 callbacks
[0]= &callback_counter
;
1284 rc
= memcached_fetch_execute(memc
, callbacks
, (void *)&counter
, 1);
1286 assert(counter
== 3);
1291 static test_return
mget_test(memcached_st
*memc
)
1293 memcached_return rc
;
1294 char *keys
[]= {"fudge", "son", "food"};
1295 size_t key_length
[]= {5, 3, 4};
1299 char return_key
[MEMCACHED_MAX_KEY
];
1300 size_t return_key_length
;
1302 size_t return_value_length
;
1304 /* We need to empty the server before continueing test */
1305 rc
= memcached_flush(memc
, 0);
1306 assert(rc
== MEMCACHED_SUCCESS
);
1308 rc
= memcached_mget(memc
, keys
, key_length
, 3);
1309 assert(rc
== MEMCACHED_SUCCESS
);
1311 while ((return_value
= memcached_fetch(memc
, return_key
, &return_key_length
,
1312 &return_value_length
, &flags
, &rc
)) != NULL
)
1314 assert(return_value
);
1316 assert(!return_value
);
1317 assert(return_value_length
== 0);
1318 assert(rc
== MEMCACHED_END
);
1320 for (x
= 0; x
< 3; x
++)
1322 rc
= memcached_set(memc
, keys
[x
], key_length
[x
],
1323 keys
[x
], key_length
[x
],
1324 (time_t)50, (uint32_t)9);
1325 assert(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
);
1328 rc
= memcached_mget(memc
, keys
, key_length
, 3);
1329 assert(rc
== MEMCACHED_SUCCESS
);
1332 while ((return_value
= memcached_fetch(memc
, return_key
, &return_key_length
,
1333 &return_value_length
, &flags
, &rc
)))
1335 assert(return_value
);
1336 assert(rc
== MEMCACHED_SUCCESS
);
1337 assert(return_key_length
== return_value_length
);
1338 assert(!memcmp(return_value
, return_key
, return_value_length
));
1346 static test_return
get_stats_keys(memcached_st
*memc
)
1350 memcached_stat_st stat
;
1351 memcached_return rc
;
1353 list
= memcached_stat_get_keys(memc
, &stat
, &rc
);
1354 assert(rc
== MEMCACHED_SUCCESS
);
1355 for (ptr
= list
; *ptr
; ptr
++)
1364 static test_return
version_string_test(memcached_st
*memc
__attribute__((unused
)))
1366 const char *version_string
;
1368 version_string
= memcached_lib_version();
1370 assert(!strcmp(version_string
, LIBMEMCACHED_VERSION_STRING
));
1375 static test_return
get_stats(memcached_st
*memc
)
1380 memcached_return rc
;
1381 memcached_stat_st
*stat
;
1383 stat
= memcached_stat(memc
, NULL
, &rc
);
1384 assert(rc
== MEMCACHED_SUCCESS
);
1386 assert(rc
== MEMCACHED_SUCCESS
);
1389 for (x
= 0; x
< memcached_server_count(memc
); x
++)
1391 list
= memcached_stat_get_keys(memc
, stat
+x
, &rc
);
1392 assert(rc
== MEMCACHED_SUCCESS
);
1393 for (ptr
= list
; *ptr
; ptr
++);
1398 memcached_stat_free(NULL
, stat
);
1403 static test_return
add_host_test(memcached_st
*memc
)
1406 memcached_server_st
*servers
;
1407 memcached_return rc
;
1408 char servername
[]= "0.example.com";
1410 servers
= memcached_server_list_append_with_weight(NULL
, servername
, 400, 0, &rc
);
1412 assert(1 == memcached_server_list_count(servers
));
1414 for (x
= 2; x
< 20; x
++)
1416 char buffer
[SMALL_STRING_LEN
];
1418 snprintf(buffer
, SMALL_STRING_LEN
, "%u.example.com", 400+x
);
1419 servers
= memcached_server_list_append_with_weight(servers
, buffer
, 401, 0,
1421 assert(rc
== MEMCACHED_SUCCESS
);
1422 assert(x
== memcached_server_list_count(servers
));
1425 rc
= memcached_server_push(memc
, servers
);
1426 assert(rc
== MEMCACHED_SUCCESS
);
1427 rc
= memcached_server_push(memc
, servers
);
1428 assert(rc
== MEMCACHED_SUCCESS
);
1430 memcached_server_list_free(servers
);
1435 static memcached_return
clone_test_callback(memcached_st
*parent
__attribute__((unused
)), memcached_st
*clone
__attribute__((unused
)))
1437 return MEMCACHED_SUCCESS
;
1440 static memcached_return
cleanup_test_callback(memcached_st
*ptr
__attribute__((unused
)))
1442 return MEMCACHED_SUCCESS
;
1445 static test_return
callback_test(memcached_st
*memc
)
1447 /* Test User Data */
1451 memcached_return rc
;
1453 rc
= memcached_callback_set(memc
, MEMCACHED_CALLBACK_USER_DATA
, &x
);
1454 assert(rc
== MEMCACHED_SUCCESS
);
1455 test_ptr
= (int *)memcached_callback_get(memc
, MEMCACHED_CALLBACK_USER_DATA
, &rc
);
1456 assert(*test_ptr
== x
);
1459 /* Test Clone Callback */
1461 memcached_clone_func temp_function
;
1462 memcached_return rc
;
1464 rc
= memcached_callback_set(memc
, MEMCACHED_CALLBACK_CLONE_FUNCTION
, (void*)clone_test_callback
);
1465 assert(rc
== MEMCACHED_SUCCESS
);
1466 temp_function
= (memcached_clone_func
)memcached_callback_get(memc
, MEMCACHED_CALLBACK_CLONE_FUNCTION
, &rc
);
1467 assert(temp_function
== clone_test_callback
);
1470 /* Test Cleanup Callback */
1472 memcached_cleanup_func temp_function
;
1473 memcached_return rc
;
1475 rc
= memcached_callback_set(memc
, MEMCACHED_CALLBACK_CLONE_FUNCTION
, (void*)cleanup_test_callback
);
1476 assert(rc
== MEMCACHED_SUCCESS
);
1477 temp_function
= (memcached_cleanup_func
)memcached_callback_get(memc
, MEMCACHED_CALLBACK_CLONE_FUNCTION
, &rc
);
1478 assert(temp_function
== cleanup_test_callback
);
1484 /* We don't test the behavior itself, we test the switches */
1485 static test_return
behavior_test(memcached_st
*memc
)
1490 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NO_BLOCK
, set
);
1491 value
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_NO_BLOCK
);
1494 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_TCP_NODELAY
, set
);
1495 value
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_TCP_NODELAY
);
1498 set
= MEMCACHED_HASH_MD5
;
1499 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_HASH
, set
);
1500 value
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_HASH
);
1501 assert(value
== MEMCACHED_HASH_MD5
);
1505 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NO_BLOCK
, set
);
1506 value
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_NO_BLOCK
);
1509 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_TCP_NODELAY
, set
);
1510 value
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_TCP_NODELAY
);
1513 set
= MEMCACHED_HASH_DEFAULT
;
1514 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_HASH
, set
);
1515 value
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_HASH
);
1516 assert(value
== MEMCACHED_HASH_DEFAULT
);
1518 set
= MEMCACHED_HASH_CRC
;
1519 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_HASH
, set
);
1520 value
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_HASH
);
1521 assert(value
== MEMCACHED_HASH_CRC
);
1523 value
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_SOCKET_SEND_SIZE
);
1526 value
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_SOCKET_RECV_SIZE
);
1532 /* Test case provided by Cal Haldenbrand */
1533 static test_return
user_supplied_bug1(memcached_st
*memc
)
1535 unsigned int setter
= 1;
1538 unsigned long long total
= 0;
1541 char randomstuff
[6 * 1024];
1542 memcached_return rc
;
1544 memset(randomstuff
, 0, 6 * 1024);
1546 /* We just keep looking at the same values over and over */
1549 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NO_BLOCK
, setter
);
1550 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_TCP_NODELAY
, setter
);
1554 for (x
= 0 ; total
< 20 * 1024576 ; x
++ )
1558 size
= (rand() % ( 5 * 1024 ) ) + 400;
1559 memset(randomstuff
, 0, 6 * 1024);
1560 assert(size
< 6 * 1024); /* Being safe here */
1562 for (j
= 0 ; j
< size
;j
++)
1563 randomstuff
[j
] = (char) (rand() % 26) + 97;
1566 sprintf(key
, "%d", x
);
1567 rc
= memcached_set(memc
, key
, strlen(key
),
1568 randomstuff
, strlen(randomstuff
), 10, 0);
1569 assert(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
);
1570 /* If we fail, lets try again */
1571 if (rc
!= MEMCACHED_SUCCESS
&& rc
!= MEMCACHED_BUFFERED
)
1572 rc
= memcached_set(memc
, key
, strlen(key
),
1573 randomstuff
, strlen(randomstuff
), 10, 0);
1574 assert(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
);
1580 /* Test case provided by Cal Haldenbrand */
1581 static test_return
user_supplied_bug2(memcached_st
*memc
)
1584 unsigned int setter
;
1586 unsigned long long total
;
1589 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NO_BLOCK
, setter
);
1590 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_TCP_NODELAY
, setter
);
1592 setter
= 20 * 1024576;
1593 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_SOCKET_SEND_SIZE
, setter
);
1594 setter
= 20 * 1024576;
1595 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_SOCKET_RECV_SIZE
, setter
);
1596 getter
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_SOCKET_SEND_SIZE
);
1597 getter
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_SOCKET_RECV_SIZE
);
1599 for (x
= 0, errors
= 0, total
= 0 ; total
< 20 * 1024576 ; x
++)
1602 for (x
= 0, errors
= 0, total
= 0 ; total
< 24576 ; x
++)
1604 memcached_return rc
= MEMCACHED_SUCCESS
;
1605 char buffer
[SMALL_STRING_LEN
];
1610 memset(buffer
, 0, SMALL_STRING_LEN
);
1612 snprintf(buffer
, SMALL_STRING_LEN
, "%u", x
);
1613 getval
= memcached_get(memc
, buffer
, strlen(buffer
),
1614 &val_len
, &flags
, &rc
);
1615 if (rc
!= MEMCACHED_SUCCESS
)
1617 if (rc
== MEMCACHED_NOTFOUND
)
1621 WATCHPOINT_ERROR(rc
);
1635 /* Do a large mget() over all the keys we think exist */
1636 #define KEY_COUNT 3000 // * 1024576
1637 static test_return
user_supplied_bug3(memcached_st
*memc
)
1639 memcached_return rc
;
1640 unsigned int setter
;
1643 size_t key_lengths
[KEY_COUNT
];
1646 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NO_BLOCK
, setter
);
1647 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_TCP_NODELAY
, setter
);
1649 setter
= 20 * 1024576;
1650 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_SOCKET_SEND_SIZE
, setter
);
1651 setter
= 20 * 1024576;
1652 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_SOCKET_RECV_SIZE
, setter
);
1653 getter
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_SOCKET_SEND_SIZE
);
1654 getter
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_SOCKET_RECV_SIZE
);
1657 keys
= (char **)malloc(sizeof(char *) * KEY_COUNT
);
1659 memset(keys
, 0, (sizeof(char *) * KEY_COUNT
));
1660 for (x
= 0; x
< KEY_COUNT
; x
++)
1664 snprintf(buffer
, 30, "%u", x
);
1665 keys
[x
]= strdup(buffer
);
1666 key_lengths
[x
]= strlen(keys
[x
]);
1669 rc
= memcached_mget(memc
, keys
, key_lengths
, KEY_COUNT
);
1670 assert(rc
== MEMCACHED_SUCCESS
);
1672 /* Turn this into a help function */
1674 char return_key
[MEMCACHED_MAX_KEY
];
1675 size_t return_key_length
;
1677 size_t return_value_length
;
1680 while ((return_value
= memcached_fetch(memc
, return_key
, &return_key_length
,
1681 &return_value_length
, &flags
, &rc
)))
1683 assert(return_value
);
1684 assert(rc
== MEMCACHED_SUCCESS
);
1689 for (x
= 0; x
< KEY_COUNT
; x
++)
1696 /* Make sure we behave properly if server list has no values */
1697 static test_return
user_supplied_bug4(memcached_st
*memc
)
1699 memcached_return rc
;
1700 char *keys
[]= {"fudge", "son", "food"};
1701 size_t key_length
[]= {5, 3, 4};
1704 char return_key
[MEMCACHED_MAX_KEY
];
1705 size_t return_key_length
;
1707 size_t return_value_length
;
1709 /* Here we free everything before running a bunch of mget tests */
1711 memcached_server_list_free(memc
->hosts
);
1713 memc
->number_of_hosts
= 0;
1717 /* We need to empty the server before continueing test */
1718 rc
= memcached_flush(memc
, 0);
1719 assert(rc
== MEMCACHED_NO_SERVERS
);
1721 rc
= memcached_mget(memc
, keys
, key_length
, 3);
1722 assert(rc
== MEMCACHED_NO_SERVERS
);
1724 while ((return_value
= memcached_fetch(memc
, return_key
, &return_key_length
,
1725 &return_value_length
, &flags
, &rc
)) != NULL
)
1727 assert(return_value
);
1729 assert(!return_value
);
1730 assert(return_value_length
== 0);
1731 assert(rc
== MEMCACHED_NO_SERVERS
);
1733 for (x
= 0; x
< 3; x
++)
1735 rc
= memcached_set(memc
, keys
[x
], key_length
[x
],
1736 keys
[x
], key_length
[x
],
1737 (time_t)50, (uint32_t)9);
1738 assert(rc
== MEMCACHED_NO_SERVERS
);
1741 rc
= memcached_mget(memc
, keys
, key_length
, 3);
1742 assert(rc
== MEMCACHED_NO_SERVERS
);
1745 while ((return_value
= memcached_fetch(memc
, return_key
, &return_key_length
,
1746 &return_value_length
, &flags
, &rc
)))
1748 assert(return_value
);
1749 assert(rc
== MEMCACHED_SUCCESS
);
1750 assert(return_key_length
== return_value_length
);
1751 assert(!memcmp(return_value
, return_key
, return_value_length
));
1759 #define VALUE_SIZE_BUG5 1048064
1760 static test_return
user_supplied_bug5(memcached_st
*memc
)
1762 memcached_return rc
;
1763 char *keys
[]= {"036790384900", "036790384902", "036790384904", "036790384906"};
1764 size_t key_length
[]= {strlen("036790384900"), strlen("036790384902"), strlen("036790384904"), strlen("036790384906")};
1765 char return_key
[MEMCACHED_MAX_KEY
];
1766 size_t return_key_length
;
1768 size_t value_length
;
1772 char insert_data
[VALUE_SIZE_BUG5
];
1774 for (x
= 0; x
< VALUE_SIZE_BUG5
; x
++)
1775 insert_data
[x
]= rand();
1777 memcached_flush(memc
, 0);
1778 value
= memcached_get(memc
, keys
[0], key_length
[0],
1779 &value_length
, &flags
, &rc
);
1780 assert(value
== NULL
);
1781 rc
= memcached_mget(memc
, keys
, key_length
, 4);
1784 while ((value
= memcached_fetch(memc
, return_key
, &return_key_length
,
1785 &value_length
, &flags
, &rc
)))
1789 for (x
= 0; x
< 4; x
++)
1791 rc
= memcached_set(memc
, keys
[x
], key_length
[x
],
1792 insert_data
, VALUE_SIZE_BUG5
,
1793 (time_t)0, (uint32_t)0);
1794 assert(rc
== MEMCACHED_SUCCESS
);
1797 for (x
= 0; x
< 10; x
++)
1799 value
= memcached_get(memc
, keys
[0], key_length
[0],
1800 &value_length
, &flags
, &rc
);
1804 rc
= memcached_mget(memc
, keys
, key_length
, 4);
1806 while ((value
= memcached_fetch(memc
, return_key
, &return_key_length
,
1807 &value_length
, &flags
, &rc
)))
1818 static test_return
user_supplied_bug6(memcached_st
*memc
)
1820 memcached_return rc
;
1821 char *keys
[]= {"036790384900", "036790384902", "036790384904", "036790384906"};
1822 size_t key_length
[]= {strlen("036790384900"), strlen("036790384902"), strlen("036790384904"), strlen("036790384906")};
1823 char return_key
[MEMCACHED_MAX_KEY
];
1824 size_t return_key_length
;
1826 size_t value_length
;
1830 char insert_data
[VALUE_SIZE_BUG5
];
1832 for (x
= 0; x
< VALUE_SIZE_BUG5
; x
++)
1833 insert_data
[x
]= rand();
1835 memcached_flush(memc
, 0);
1836 value
= memcached_get(memc
, keys
[0], key_length
[0],
1837 &value_length
, &flags
, &rc
);
1838 assert(value
== NULL
);
1839 assert(rc
== MEMCACHED_NOTFOUND
);
1840 rc
= memcached_mget(memc
, keys
, key_length
, 4);
1841 assert(rc
== MEMCACHED_SUCCESS
);
1844 while ((value
= memcached_fetch(memc
, return_key
, &return_key_length
,
1845 &value_length
, &flags
, &rc
)))
1848 assert(rc
== MEMCACHED_END
);
1850 for (x
= 0; x
< 4; x
++)
1852 rc
= memcached_set(memc
, keys
[x
], key_length
[x
],
1853 insert_data
, VALUE_SIZE_BUG5
,
1854 (time_t)0, (uint32_t)0);
1855 assert(rc
== MEMCACHED_SUCCESS
);
1858 for (x
= 0; x
< 2; x
++)
1860 value
= memcached_get(memc
, keys
[0], key_length
[0],
1861 &value_length
, &flags
, &rc
);
1865 rc
= memcached_mget(memc
, keys
, key_length
, 4);
1866 assert(rc
== MEMCACHED_SUCCESS
);
1868 /* We test for purge of partial complete fetches */
1869 for (count
= 3; count
; count
--)
1871 value
= memcached_fetch(memc
, return_key
, &return_key_length
,
1872 &value_length
, &flags
, &rc
);
1873 assert(rc
== MEMCACHED_SUCCESS
);
1874 assert(!(memcmp(value
, insert_data
, value_length
)));
1875 assert(value_length
);
1883 static test_return
user_supplied_bug8(memcached_st
*memc
__attribute__((unused
)))
1885 memcached_return rc
;
1887 memcached_st
*clone
;
1889 memcached_server_st
*servers
;
1890 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";
1892 servers
= memcached_servers_parse(server_list
);
1895 mine
= memcached_create(NULL
);
1896 rc
= memcached_server_push(mine
, servers
);
1897 assert(rc
== MEMCACHED_SUCCESS
);
1898 memcached_server_list_free(servers
);
1901 clone
= memcached_clone(NULL
, mine
);
1903 memcached_quit(mine
);
1904 memcached_quit(clone
);
1907 memcached_free(mine
);
1908 memcached_free(clone
);
1913 /* Test flag store/retrieve */
1914 static test_return
user_supplied_bug7(memcached_st
*memc
)
1916 memcached_return rc
;
1917 char *keys
= "036790384900";
1918 size_t key_length
= strlen("036790384900");
1919 char return_key
[MEMCACHED_MAX_KEY
];
1920 size_t return_key_length
;
1922 size_t value_length
;
1925 char insert_data
[VALUE_SIZE_BUG5
];
1927 for (x
= 0; x
< VALUE_SIZE_BUG5
; x
++)
1928 insert_data
[x
]= rand();
1930 memcached_flush(memc
, 0);
1933 rc
= memcached_set(memc
, keys
, key_length
,
1934 insert_data
, VALUE_SIZE_BUG5
,
1936 assert(rc
== MEMCACHED_SUCCESS
);
1939 value
= memcached_get(memc
, keys
, key_length
,
1940 &value_length
, &flags
, &rc
);
1941 assert(flags
== 245);
1945 rc
= memcached_mget(memc
, &keys
, &key_length
, 1);
1948 value
= memcached_fetch(memc
, return_key
, &return_key_length
,
1949 &value_length
, &flags
, &rc
);
1950 assert(flags
== 245);
1958 static test_return
user_supplied_bug9(memcached_st
*memc
)
1960 memcached_return rc
;
1961 char *keys
[]= {"UDATA:edevil@sapo.pt", "fudge&*@#", "for^#@&$not"};
1962 size_t key_length
[3];
1967 char return_key
[MEMCACHED_MAX_KEY
];
1968 size_t return_key_length
;
1970 size_t return_value_length
;
1973 key_length
[0]= strlen("UDATA:edevil@sapo.pt");
1974 key_length
[1]= strlen("fudge&*@#");
1975 key_length
[2]= strlen("for^#@&$not");
1978 for (x
= 0; x
< 3; x
++)
1980 rc
= memcached_set(memc
, keys
[x
], key_length
[x
],
1981 keys
[x
], key_length
[x
],
1982 (time_t)50, (uint32_t)9);
1983 assert(rc
== MEMCACHED_SUCCESS
);
1986 rc
= memcached_mget(memc
, keys
, key_length
, 3);
1987 assert(rc
== MEMCACHED_SUCCESS
);
1989 /* We need to empty the server before continueing test */
1990 while ((return_value
= memcached_fetch(memc
, return_key
, &return_key_length
,
1991 &return_value_length
, &flags
, &rc
)) != NULL
)
1993 assert(return_value
);
2002 /* We are testing with aggressive timeout to get failures */
2003 static test_return
user_supplied_bug10(memcached_st
*memc
)
2007 size_t value_length
= 512;
2010 memcached_return rc
;
2011 unsigned int set
= 1;
2012 memcached_st
*mclone
= memcached_clone(NULL
, memc
);
2015 memcached_behavior_set(mclone
, MEMCACHED_BEHAVIOR_NO_BLOCK
, set
);
2016 memcached_behavior_set(mclone
, MEMCACHED_BEHAVIOR_TCP_NODELAY
, set
);
2018 memcached_behavior_set(mclone
, MEMCACHED_BEHAVIOR_POLL_TIMEOUT
, timeout
);
2020 value
= (char*)malloc(value_length
* sizeof(char));
2022 for (x
= 0; x
< value_length
; x
++)
2023 value
[x
]= (char) (x
% 127);
2025 for (x
= 1; x
<= 100000; ++x
)
2027 rc
= memcached_set(mclone
, key
, key_len
,value
, value_length
, 0, 0);
2029 assert(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_WRITE_FAILURE
||
2030 rc
== MEMCACHED_BUFFERED
|| rc
== MEMCACHED_TIMEOUT
);
2032 if (rc
== MEMCACHED_WRITE_FAILURE
|| rc
== MEMCACHED_TIMEOUT
)
2037 memcached_free(mclone
);
2043 We are looking failures in the async protocol
2045 static test_return
user_supplied_bug11(memcached_st
*memc
)
2049 size_t value_length
= 512;
2052 memcached_return rc
;
2053 unsigned int set
= 1;
2055 memcached_st
*mclone
= memcached_clone(NULL
, memc
);
2057 memcached_behavior_set(mclone
, MEMCACHED_BEHAVIOR_NO_BLOCK
, set
);
2058 memcached_behavior_set(mclone
, MEMCACHED_BEHAVIOR_TCP_NODELAY
, set
);
2060 memcached_behavior_set(mclone
, MEMCACHED_BEHAVIOR_POLL_TIMEOUT
, timeout
);
2062 timeout
= (int32_t)memcached_behavior_get(mclone
, MEMCACHED_BEHAVIOR_POLL_TIMEOUT
);
2064 assert(timeout
== -1);
2066 value
= (char*)malloc(value_length
* sizeof(char));
2068 for (x
= 0; x
< value_length
; x
++)
2069 value
[x
]= (char) (x
% 127);
2071 for (x
= 1; x
<= 100000; ++x
)
2073 rc
= memcached_set(mclone
, key
, key_len
,value
, value_length
, 0, 0);
2077 memcached_free(mclone
);
2083 Bug found where incr was not returning MEMCACHED_NOTFOUND when object did not exist.
2085 static test_return
user_supplied_bug12(memcached_st
*memc
)
2087 memcached_return rc
;
2089 size_t value_length
;
2091 uint64_t number_value
;
2093 value
= memcached_get(memc
, "autoincrement", strlen("autoincrement"),
2094 &value_length
, &flags
, &rc
);
2095 assert(value
== NULL
);
2096 assert(rc
== MEMCACHED_NOTFOUND
);
2098 rc
= memcached_increment(memc
, "autoincrement", strlen("autoincrement"),
2101 assert(value
== NULL
);
2102 /* The binary protocol will set the key if it doesn't exist */
2103 if (memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
) == 1)
2104 assert(rc
== MEMCACHED_SUCCESS
);
2106 assert(rc
== MEMCACHED_NOTFOUND
);
2108 rc
= memcached_set(memc
, "autoincrement", strlen("autoincrement"), "1", 1, 0, 0);
2110 value
= memcached_get(memc
, "autoincrement", strlen("autoincrement"),
2111 &value_length
, &flags
, &rc
);
2113 assert(rc
== MEMCACHED_SUCCESS
);
2116 rc
= memcached_increment(memc
, "autoincrement", strlen("autoincrement"),
2118 assert(number_value
== 2);
2119 assert(rc
== MEMCACHED_SUCCESS
);
2125 Bug found where command total one more than MEMCACHED_MAX_BUFFER
2126 set key34567890 0 0 8169 \r\n is sent followed by buffer of size 8169, followed by 8169
2128 static test_return
user_supplied_bug13(memcached_st
*memc
)
2130 char key
[] = "key34567890";
2132 memcached_return rc
;
2133 size_t overflowSize
;
2135 char commandFirst
[]= "set key34567890 0 0 ";
2136 char commandLast
[] = " \r\n"; /* first line of command sent to server */
2137 size_t commandLength
;
2140 commandLength
= strlen(commandFirst
) + strlen(commandLast
) + 4; /* 4 is number of characters in size, probably 8196 */
2142 overflowSize
= MEMCACHED_MAX_BUFFER
- commandLength
;
2144 for (testSize
= overflowSize
- 1; testSize
< overflowSize
+ 1; testSize
++)
2146 overflow
= malloc(testSize
);
2147 assert(overflow
!= NULL
);
2149 memset(overflow
, 'x', testSize
);
2150 rc
= memcached_set(memc
, key
, strlen(key
),
2151 overflow
, testSize
, 0, 0);
2152 assert(rc
== MEMCACHED_SUCCESS
);
2161 Test values of many different sizes
2162 Bug found where command total one more than MEMCACHED_MAX_BUFFER
2163 set key34567890 0 0 8169 \r\n
2164 is sent followed by buffer of size 8169, followed by 8169
2166 static test_return
user_supplied_bug14(memcached_st
*memc
)
2169 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_TCP_NODELAY
, setter
);
2170 memcached_return rc
;
2173 size_t value_length
= 18000;
2175 size_t string_length
;
2178 size_t current_length
;
2180 value
= (char*)malloc(value_length
);
2183 for (x
= 0; x
< value_length
; x
++)
2184 value
[x
] = (char) (x
% 127);
2186 for (current_length
= 0; current_length
< value_length
; current_length
++)
2188 rc
= memcached_set(memc
, key
, strlen(key
),
2189 value
, current_length
,
2190 (time_t)0, (uint32_t)0);
2191 assert(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
);
2193 string
= memcached_get(memc
, key
, strlen(key
),
2194 &string_length
, &flags
, &rc
);
2196 assert(rc
== MEMCACHED_SUCCESS
);
2197 assert(string_length
== current_length
);
2198 assert(!memcmp(string
, value
, string_length
));
2209 Look for zero length value problems
2211 static test_return
user_supplied_bug15(memcached_st
*memc
)
2214 memcached_return rc
;
2220 for (x
= 0; x
< 2; x
++)
2222 rc
= memcached_set(memc
, key
, strlen(key
),
2224 (time_t)0, (uint32_t)0);
2226 assert(rc
== MEMCACHED_SUCCESS
);
2228 value
= memcached_get(memc
, key
, strlen(key
),
2229 &length
, &flags
, &rc
);
2231 assert(rc
== MEMCACHED_SUCCESS
);
2232 assert(value
== NULL
);
2233 assert(length
== 0);
2236 value
= memcached_get(memc
, key
, strlen(key
),
2237 &length
, &flags
, &rc
);
2239 assert(rc
== MEMCACHED_SUCCESS
);
2240 assert(value
== NULL
);
2241 assert(length
== 0);
2248 /* Check the return sizes on FLAGS to make sure it stores 32bit unsigned values correctly */
2249 static test_return
user_supplied_bug16(memcached_st
*memc
)
2251 memcached_return rc
;
2257 rc
= memcached_set(memc
, key
, strlen(key
),
2259 (time_t)0, UINT32_MAX
);
2261 assert(rc
== MEMCACHED_SUCCESS
);
2263 value
= memcached_get(memc
, key
, strlen(key
),
2264 &length
, &flags
, &rc
);
2266 assert(rc
== MEMCACHED_SUCCESS
);
2267 assert(value
== NULL
);
2268 assert(length
== 0);
2269 assert(flags
== UINT32_MAX
);
2274 /* Check the validity of chinese key*/
2275 static test_return
user_supplied_bug17(memcached_st
*memc
)
2277 memcached_return rc
;
2279 char *value
="我们在炎热抑郁的夏天无法停止豆瓣";
2284 rc
= memcached_set(memc
, key
, strlen(key
),
2285 value
, strlen(value
),
2288 assert(rc
== MEMCACHED_SUCCESS
);
2290 value2
= memcached_get(memc
, key
, strlen(key
),
2291 &length
, &flags
, &rc
);
2293 assert(length
==strlen(value
));
2294 assert(rc
== MEMCACHED_SUCCESS
);
2295 assert(memcmp(value
, value2
, length
)==0);
2305 test_return
user_supplied_bug19(memcached_st
*memc
)
2308 memcached_server_st
*s
;
2309 memcached_return res
;
2313 m
= memcached_create(NULL
);
2314 memcached_server_add_with_weight(m
, "localhost", 11311, 100);
2315 memcached_server_add_with_weight(m
, "localhost", 11312, 100);
2317 s
= memcached_server_by_key(m
, "a", 1, &res
);
2318 memcached_server_free(s
);
2325 /* CAS test from Andei */
2326 test_return
user_supplied_bug20(memcached_st
*memc
)
2328 memcached_return status
;
2329 memcached_result_st
*result
, result_obj
;
2331 size_t key_len
= strlen("abc");
2332 char *value
= "foobar";
2333 size_t value_len
= strlen(value
);
2335 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_SUPPORT_CAS
, 1);
2337 status
= memcached_set(memc
, key
, key_len
, value
, value_len
, (time_t)0, (uint32_t)0);
2338 assert(status
== MEMCACHED_SUCCESS
);
2340 status
= memcached_mget(memc
, &key
, &key_len
, 1);
2341 assert(status
== MEMCACHED_SUCCESS
);
2343 result
= memcached_result_create(memc
, &result_obj
);
2346 memcached_result_create(memc
, &result_obj
);
2347 result
= memcached_fetch_result(memc
, &result_obj
, &status
);
2350 assert(status
== MEMCACHED_SUCCESS
);
2352 memcached_result_free(result
);
2357 #include "ketama_test_cases.h"
2358 test_return
user_supplied_bug18(memcached_st
*trash
)
2360 memcached_return rc
;
2363 memcached_server_st
*server_pool
;
2368 memc
= memcached_create(NULL
);
2371 rc
= memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_KETAMA_WEIGHTED
, 1);
2372 assert(rc
== MEMCACHED_SUCCESS
);
2374 value
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_KETAMA_WEIGHTED
);
2377 rc
= memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_KETAMA_HASH
, MEMCACHED_HASH_MD5
);
2378 assert(rc
== MEMCACHED_SUCCESS
);
2380 value
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_KETAMA_HASH
);
2381 assert(value
== MEMCACHED_HASH_MD5
);
2383 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");
2384 memcached_server_push(memc
, server_pool
);
2386 /* verify that the server list was parsed okay. */
2387 assert(memc
->number_of_hosts
== 8);
2388 assert(strcmp(server_pool
[0].hostname
, "10.0.1.1") == 0);
2389 assert(server_pool
[0].port
== 11211);
2390 assert(server_pool
[0].weight
== 600);
2391 assert(strcmp(server_pool
[2].hostname
, "10.0.1.3") == 0);
2392 assert(server_pool
[2].port
== 11211);
2393 assert(server_pool
[2].weight
== 200);
2394 assert(strcmp(server_pool
[7].hostname
, "10.0.1.8") == 0);
2395 assert(server_pool
[7].port
== 11211);
2396 assert(server_pool
[7].weight
== 100);
2398 /* VDEAAAAA hashes to fffcd1b5, after the last continuum point, and lets
2399 * us test the boundary wraparound.
2401 assert(memcached_generate_hash(memc
, (char *)"VDEAAAAA", 8) == memc
->continuum
[0].index
);
2403 /* verify the standard ketama set. */
2404 for (x
= 0; x
< 99; x
++)
2406 uint32_t server_idx
= memcached_generate_hash(memc
, test_cases
[x
].key
, strlen(test_cases
[x
].key
));
2407 char *hostname
= memc
->hosts
[server_idx
].hostname
;
2408 assert(strcmp(hostname
, test_cases
[x
].server
) == 0);
2411 memcached_server_list_free(server_pool
);
2412 memcached_free(memc
);
2417 test_return
auto_eject_hosts(memcached_st
*trash
)
2419 memcached_return rc
;
2420 memcached_st
*memc
= memcached_create(NULL
);
2423 rc
= memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_KETAMA_WEIGHTED
, 1);
2424 assert(rc
== MEMCACHED_SUCCESS
);
2426 uint64_t value
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_KETAMA_WEIGHTED
);
2429 rc
= memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_KETAMA_HASH
, MEMCACHED_HASH_MD5
);
2430 assert(rc
== MEMCACHED_SUCCESS
);
2432 value
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_KETAMA_HASH
);
2433 assert(value
== MEMCACHED_HASH_MD5
);
2435 /* server should be removed when in delay */
2436 rc
= memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_AUTO_EJECT_HOSTS
, 1);
2437 assert(rc
== MEMCACHED_SUCCESS
);
2439 value
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_AUTO_EJECT_HOSTS
);
2442 memcached_server_st
*server_pool
;
2443 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");
2444 memcached_server_push(memc
, server_pool
);
2446 /* verify that the server list was parsed okay. */
2447 assert(memc
->number_of_hosts
== 8);
2448 assert(strcmp(server_pool
[0].hostname
, "10.0.1.1") == 0);
2449 assert(server_pool
[0].port
== 11211);
2450 assert(server_pool
[0].weight
== 600);
2451 assert(strcmp(server_pool
[2].hostname
, "10.0.1.3") == 0);
2452 assert(server_pool
[2].port
== 11211);
2453 assert(server_pool
[2].weight
== 200);
2454 assert(strcmp(server_pool
[7].hostname
, "10.0.1.8") == 0);
2455 assert(server_pool
[7].port
== 11211);
2456 assert(server_pool
[7].weight
== 100);
2458 memc
->hosts
[2].next_retry
= time(NULL
) + 15;
2459 memc
->next_distribution_rebuild
= time(NULL
) - 1;
2461 for (int x
= 0; x
< 99; x
++)
2463 uint32_t server_idx
= memcached_generate_hash(memc
, test_cases
[x
].key
, strlen(test_cases
[x
].key
));
2464 assert(server_idx
!= 2);
2467 /* and re-added when it's back. */
2468 memc
->hosts
[2].next_retry
= time(NULL
) - 1;
2469 memc
->next_distribution_rebuild
= time(NULL
) - 1;
2470 run_distribution(memc
);
2471 for (int x
= 0; x
< 99; x
++)
2473 uint32_t server_idx
= memcached_generate_hash(memc
, test_cases
[x
].key
, strlen(test_cases
[x
].key
));
2474 char *hostname
= memc
->hosts
[server_idx
].hostname
;
2475 assert(strcmp(hostname
, test_cases
[x
].server
) == 0);
2478 memcached_server_list_free(server_pool
);
2479 memcached_free(memc
);
2481 return TEST_SUCCESS
;
2484 static test_return
result_static(memcached_st
*memc
)
2486 memcached_result_st result
;
2487 memcached_result_st
*result_ptr
;
2489 result_ptr
= memcached_result_create(memc
, &result
);
2490 assert(result
.is_allocated
== false);
2492 memcached_result_free(&result
);
2497 static test_return
result_alloc(memcached_st
*memc
)
2499 memcached_result_st
*result
;
2501 result
= memcached_result_create(memc
, NULL
);
2503 memcached_result_free(result
);
2508 static test_return
string_static_null(memcached_st
*memc
)
2510 memcached_string_st string
;
2511 memcached_string_st
*string_ptr
;
2513 string_ptr
= memcached_string_create(memc
, &string
, 0);
2514 assert(string
.is_allocated
== false);
2516 memcached_string_free(&string
);
2521 static test_return
string_alloc_null(memcached_st
*memc
)
2523 memcached_string_st
*string
;
2525 string
= memcached_string_create(memc
, NULL
, 0);
2527 memcached_string_free(string
);
2532 static test_return
string_alloc_with_size(memcached_st
*memc
)
2534 memcached_string_st
*string
;
2536 string
= memcached_string_create(memc
, NULL
, 1024);
2538 memcached_string_free(string
);
2543 static test_return
string_alloc_with_size_toobig(memcached_st
*memc
)
2545 memcached_string_st
*string
;
2547 string
= memcached_string_create(memc
, NULL
, INT64_MAX
);
2548 assert(string
== NULL
);
2553 static test_return
string_alloc_append(memcached_st
*memc
)
2556 char buffer
[SMALL_STRING_LEN
];
2557 memcached_string_st
*string
;
2559 /* Ring the bell! */
2560 memset(buffer
, 6, SMALL_STRING_LEN
);
2562 string
= memcached_string_create(memc
, NULL
, 100);
2565 for (x
= 0; x
< 1024; x
++)
2567 memcached_return rc
;
2568 rc
= memcached_string_append(string
, buffer
, SMALL_STRING_LEN
);
2569 assert(rc
== MEMCACHED_SUCCESS
);
2571 memcached_string_free(string
);
2576 static test_return
string_alloc_append_toobig(memcached_st
*memc
)
2578 memcached_return rc
;
2580 char buffer
[SMALL_STRING_LEN
];
2581 memcached_string_st
*string
;
2583 /* Ring the bell! */
2584 memset(buffer
, 6, SMALL_STRING_LEN
);
2586 string
= memcached_string_create(memc
, NULL
, 100);
2589 for (x
= 0; x
< 1024; x
++)
2591 rc
= memcached_string_append(string
, buffer
, SMALL_STRING_LEN
);
2592 assert(rc
== MEMCACHED_SUCCESS
);
2594 rc
= memcached_string_append(string
, buffer
, INT64_MAX
);
2595 assert(rc
== MEMCACHED_MEMORY_ALLOCATION_FAILURE
);
2596 memcached_string_free(string
);
2601 static test_return
cleanup_pairs(memcached_st
*memc
__attribute__((unused
)))
2603 pairs_free(global_pairs
);
2608 static test_return
generate_pairs(memcached_st
*memc
__attribute__((unused
)))
2610 unsigned long long x
;
2611 global_pairs
= pairs_generate(GLOBAL_COUNT
, 400);
2612 global_count
= GLOBAL_COUNT
;
2614 for (x
= 0; x
< global_count
; x
++)
2616 global_keys
[x
]= global_pairs
[x
].key
;
2617 global_keys_length
[x
]= global_pairs
[x
].key_length
;
2623 static test_return
generate_large_pairs(memcached_st
*memc
__attribute__((unused
)))
2625 unsigned long long x
;
2626 global_pairs
= pairs_generate(GLOBAL2_COUNT
, MEMCACHED_MAX_BUFFER
+10);
2627 global_count
= GLOBAL2_COUNT
;
2629 for (x
= 0; x
< global_count
; x
++)
2631 global_keys
[x
]= global_pairs
[x
].key
;
2632 global_keys_length
[x
]= global_pairs
[x
].key_length
;
2638 static test_return
generate_data(memcached_st
*memc
)
2640 execute_set(memc
, global_pairs
, global_count
);
2645 static test_return
generate_data_with_stats(memcached_st
*memc
)
2647 memcached_stat_st
*stat_p
;
2648 memcached_return rc
;
2649 uint32_t host_index
= 0;
2650 execute_set(memc
, global_pairs
, global_count
);
2652 //TODO: hosts used size stats
2653 stat_p
= memcached_stat(memc
, NULL
, &rc
);
2656 for (host_index
= 0; host_index
< SERVERS_TO_CREATE
; host_index
++)
2658 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
);
2661 memcached_stat_free(NULL
, stat_p
);
2665 static test_return
generate_buffer_data(memcached_st
*memc
)
2670 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_BUFFER_REQUESTS
, latch
);
2671 generate_data(memc
);
2676 static test_return
get_read_count(memcached_st
*memc
)
2679 memcached_return rc
;
2680 memcached_st
*clone
;
2682 clone
= memcached_clone(NULL
, memc
);
2685 memcached_server_add_with_weight(clone
, "localhost", 6666, 0);
2689 size_t return_value_length
;
2693 for (x
= count
= 0; x
< global_count
; x
++)
2695 return_value
= memcached_get(clone
, global_keys
[x
], global_keys_length
[x
],
2696 &return_value_length
, &flags
, &rc
);
2697 if (rc
== MEMCACHED_SUCCESS
)
2704 fprintf(stderr
, "\t%u -> %u", global_count
, count
);
2707 memcached_free(clone
);
2712 static test_return
get_read(memcached_st
*memc
)
2715 memcached_return rc
;
2719 size_t return_value_length
;
2722 for (x
= 0; x
< global_count
; x
++)
2724 return_value
= memcached_get(memc
, global_keys
[x
], global_keys_length
[x
],
2725 &return_value_length
, &flags
, &rc
);
2727 assert(return_value);
2728 assert(rc == MEMCACHED_SUCCESS);
2730 if (rc
== MEMCACHED_SUCCESS
&& return_value
)
2738 static test_return
mget_read(memcached_st
*memc
)
2740 memcached_return rc
;
2742 rc
= memcached_mget(memc
, global_keys
, global_keys_length
, global_count
);
2743 assert(rc
== MEMCACHED_SUCCESS
);
2744 /* Turn this into a help function */
2746 char return_key
[MEMCACHED_MAX_KEY
];
2747 size_t return_key_length
;
2749 size_t return_value_length
;
2752 while ((return_value
= memcached_fetch(memc
, return_key
, &return_key_length
,
2753 &return_value_length
, &flags
, &rc
)))
2755 assert(return_value
);
2756 assert(rc
== MEMCACHED_SUCCESS
);
2764 static test_return
mget_read_result(memcached_st
*memc
)
2766 memcached_return rc
;
2768 rc
= memcached_mget(memc
, global_keys
, global_keys_length
, global_count
);
2769 assert(rc
== MEMCACHED_SUCCESS
);
2770 /* Turn this into a help function */
2772 memcached_result_st results_obj
;
2773 memcached_result_st
*results
;
2775 results
= memcached_result_create(memc
, &results_obj
);
2777 while ((results
= memcached_fetch_result(memc
, &results_obj
, &rc
)))
2780 assert(rc
== MEMCACHED_SUCCESS
);
2783 memcached_result_free(&results_obj
);
2789 static test_return
mget_read_function(memcached_st
*memc
)
2791 memcached_return rc
;
2792 unsigned int counter
;
2793 memcached_execute_function callbacks
[1];
2795 rc
= memcached_mget(memc
, global_keys
, global_keys_length
, global_count
);
2796 assert(rc
== MEMCACHED_SUCCESS
);
2798 callbacks
[0]= &callback_counter
;
2800 rc
= memcached_fetch_execute(memc
, callbacks
, (void *)&counter
, 1);
2805 static test_return
delete_generate(memcached_st
*memc
)
2809 for (x
= 0; x
< global_count
; x
++)
2811 (void)memcached_delete(memc
, global_keys
[x
], global_keys_length
[x
], (time_t)0);
2817 static test_return
delete_buffer_generate(memcached_st
*memc
)
2823 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_BUFFER_REQUESTS
, latch
);
2825 for (x
= 0; x
< global_count
; x
++)
2827 (void)memcached_delete(memc
, global_keys
[x
], global_keys_length
[x
], (time_t)0);
2833 static test_return
free_data(memcached_st
*memc
__attribute__((unused
)))
2835 pairs_free(global_pairs
);
2840 static test_return
add_host_test1(memcached_st
*memc
)
2843 memcached_return rc
;
2844 char servername
[]= "0.example.com";
2845 memcached_server_st
*servers
;
2847 servers
= memcached_server_list_append_with_weight(NULL
, servername
, 400, 0, &rc
);
2849 assert(1 == memcached_server_list_count(servers
));
2851 for (x
= 2; x
< 20; x
++)
2853 char buffer
[SMALL_STRING_LEN
];
2855 snprintf(buffer
, SMALL_STRING_LEN
, "%u.example.com", 400+x
);
2856 servers
= memcached_server_list_append_with_weight(servers
, buffer
, 401, 0,
2858 assert(rc
== MEMCACHED_SUCCESS
);
2859 assert(x
== memcached_server_list_count(servers
));
2862 rc
= memcached_server_push(memc
, servers
);
2863 assert(rc
== MEMCACHED_SUCCESS
);
2864 rc
= memcached_server_push(memc
, servers
);
2865 assert(rc
== MEMCACHED_SUCCESS
);
2867 memcached_server_list_free(servers
);
2872 static memcached_return
pre_nonblock(memcached_st
*memc
)
2874 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NO_BLOCK
, 0);
2876 return MEMCACHED_SUCCESS
;
2879 static memcached_return
pre_nonblock_binary(memcached_st
*memc
)
2881 memcached_return rc
= MEMCACHED_FAILURE
;
2882 memcached_st
*clone
;
2884 clone
= memcached_clone(NULL
, memc
);
2886 // The memcached_version needs to be done on a clone, because the server
2887 // will not toggle protocol on an connection.
2888 memcached_version(clone
);
2890 if (clone
->hosts
[0].major_version
>= 1 && clone
->hosts
[0].minor_version
> 2)
2892 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NO_BLOCK
, 0);
2893 rc
= memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
, 1);
2894 assert(rc
== MEMCACHED_SUCCESS
);
2895 assert(memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
) == 1);
2898 memcached_free(clone
);
2902 static memcached_return
pre_murmur(memcached_st
*memc
)
2904 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_HASH
, (uint64_t)MEMCACHED_HASH_MURMUR
);
2906 return MEMCACHED_SUCCESS
;
2909 static memcached_return
pre_jenkins(memcached_st
*memc
)
2911 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_HASH
, (uint64_t)MEMCACHED_HASH_JENKINS
);
2913 return MEMCACHED_SUCCESS
;
2917 static memcached_return
pre_md5(memcached_st
*memc
)
2919 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_HASH
, (uint64_t)MEMCACHED_HASH_MD5
);
2921 return MEMCACHED_SUCCESS
;
2924 static memcached_return
pre_crc(memcached_st
*memc
)
2926 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_HASH
, (uint64_t)MEMCACHED_HASH_CRC
);
2928 return MEMCACHED_SUCCESS
;
2931 static memcached_return
pre_hsieh(memcached_st
*memc
)
2933 #ifdef HAVE_HSIEH_HASH
2934 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_HASH
, (uint64_t)MEMCACHED_HASH_HSIEH
);
2935 return MEMCACHED_SUCCESS
;
2937 return MEMCACHED_FAILURE
;
2941 static memcached_return
pre_hash_fnv1_64(memcached_st
*memc
)
2943 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_HASH
, (uint64_t)MEMCACHED_HASH_FNV1_64
);
2945 return MEMCACHED_SUCCESS
;
2948 static memcached_return
pre_hash_fnv1a_64(memcached_st
*memc
)
2950 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_HASH
, (uint64_t)MEMCACHED_HASH_FNV1A_64
);
2952 return MEMCACHED_SUCCESS
;
2955 static memcached_return
pre_hash_fnv1_32(memcached_st
*memc
)
2957 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_HASH
, (uint64_t)MEMCACHED_HASH_FNV1_32
);
2959 return MEMCACHED_SUCCESS
;
2962 static memcached_return
pre_hash_fnv1a_32(memcached_st
*memc
)
2964 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_HASH
, (uint64_t)MEMCACHED_HASH_FNV1A_32
);
2966 return MEMCACHED_SUCCESS
;
2969 static memcached_return
pre_behavior_ketama(memcached_st
*memc
)
2971 memcached_return rc
;
2974 rc
= memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_KETAMA
, 1);
2975 assert(rc
== MEMCACHED_SUCCESS
);
2977 value
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_KETAMA
);
2980 return MEMCACHED_SUCCESS
;
2983 static memcached_return
pre_behavior_ketama_weighted(memcached_st
*memc
)
2985 memcached_return rc
;
2988 rc
= memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_KETAMA_WEIGHTED
, 1);
2989 assert(rc
== MEMCACHED_SUCCESS
);
2991 value
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_KETAMA_WEIGHTED
);
2994 rc
= memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_KETAMA_HASH
, MEMCACHED_HASH_MD5
);
2995 assert(rc
== MEMCACHED_SUCCESS
);
2997 value
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_KETAMA_HASH
);
2998 assert(value
== MEMCACHED_HASH_MD5
);
2999 return MEMCACHED_SUCCESS
;
3002 static memcached_return
pre_binary(memcached_st
*memc
)
3004 memcached_return rc
= MEMCACHED_FAILURE
;
3005 memcached_st
*clone
;
3007 clone
= memcached_clone(NULL
, memc
);
3009 // The memcached_version needs to be done on a clone, because the server
3010 // will not toggle protocol on an connection.
3011 memcached_version(clone
);
3013 if (clone
->hosts
[0].major_version
>= 1 && clone
->hosts
[0].minor_version
> 2)
3015 rc
= memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
, 1);
3016 assert(rc
== MEMCACHED_SUCCESS
);
3017 assert(memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
) == 1);
3020 memcached_free(clone
);
3024 static void my_free(memcached_st
*ptr
__attribute__((unused
)), void *mem
)
3029 static void *my_malloc(memcached_st
*ptr
__attribute__((unused
)), const size_t size
)
3031 return malloc(size
);
3034 static void *my_realloc(memcached_st
*ptr
__attribute__((unused
)), void *mem
, const size_t size
)
3036 return realloc(mem
, size
);
3039 static memcached_return
set_prefix(memcached_st
*memc
)
3041 memcached_return rc
;
3042 const char *key
= "mine";
3045 /* Make sure be default none exists */
3046 value
= memcached_callback_get(memc
, MEMCACHED_CALLBACK_PREFIX_KEY
, &rc
);
3047 assert(rc
== MEMCACHED_FAILURE
);
3049 /* Test a clean set */
3050 rc
= memcached_callback_set(memc
, MEMCACHED_CALLBACK_PREFIX_KEY
, (void *)key
);
3051 assert(rc
== MEMCACHED_SUCCESS
);
3053 value
= memcached_callback_get(memc
, MEMCACHED_CALLBACK_PREFIX_KEY
, &rc
);
3054 assert(memcmp(value
, key
, 4) == 0);
3055 assert(rc
== MEMCACHED_SUCCESS
);
3057 /* Test that we can turn it off */
3058 rc
= memcached_callback_set(memc
, MEMCACHED_CALLBACK_PREFIX_KEY
, NULL
);
3059 assert(rc
== MEMCACHED_SUCCESS
);
3061 value
= memcached_callback_get(memc
, MEMCACHED_CALLBACK_PREFIX_KEY
, &rc
);
3062 assert(rc
== MEMCACHED_FAILURE
);
3064 /* Now setup for main test */
3065 rc
= memcached_callback_set(memc
, MEMCACHED_CALLBACK_PREFIX_KEY
, (void *)key
);
3066 assert(rc
== MEMCACHED_SUCCESS
);
3068 value
= memcached_callback_get(memc
, MEMCACHED_CALLBACK_PREFIX_KEY
, &rc
);
3069 assert(rc
== MEMCACHED_SUCCESS
);
3070 assert(memcmp(value
, key
, 4) == 0);
3072 /* Set to Zero, and then Set to something too large */
3075 rc
= memcached_callback_set(memc
, MEMCACHED_CALLBACK_PREFIX_KEY
, NULL
);
3076 assert(rc
== MEMCACHED_SUCCESS
);
3078 value
= memcached_callback_get(memc
, MEMCACHED_CALLBACK_PREFIX_KEY
, &rc
);
3079 assert(rc
== MEMCACHED_FAILURE
);
3080 assert(value
== NULL
);
3082 /* Test a long key for failure */
3083 /* TODO, extend test to determine based on setting, what result should be */
3084 long_key
= "Thisismorethentheallottednumberofcharacters";
3085 rc
= memcached_callback_set(memc
, MEMCACHED_CALLBACK_PREFIX_KEY
, long_key
);
3086 //assert(rc == MEMCACHED_BAD_KEY_PROVIDED);
3087 assert(rc
== MEMCACHED_SUCCESS
);
3089 /* Now test a key with spaces (which will fail from long key, since bad key is not set) */
3090 long_key
= "This is more then the allotted number of characters";
3091 rc
= memcached_callback_set(memc
, MEMCACHED_CALLBACK_PREFIX_KEY
, long_key
);
3092 assert(rc
== MEMCACHED_BAD_KEY_PROVIDED
);
3094 /* Test for a bad prefix, but with a short key */
3095 rc
= memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_VERIFY_KEY
, 1);
3096 assert(rc
== MEMCACHED_SUCCESS
);
3098 long_key
= "dog cat";
3099 rc
= memcached_callback_set(memc
, MEMCACHED_CALLBACK_PREFIX_KEY
, long_key
);
3100 assert(rc
== MEMCACHED_BAD_KEY_PROVIDED
);
3103 return MEMCACHED_SUCCESS
;
3106 static memcached_return
set_memory_alloc(memcached_st
*memc
)
3109 memcached_malloc_function test_ptr
;
3110 memcached_return rc
;
3112 rc
= memcached_callback_set(memc
, MEMCACHED_CALLBACK_MALLOC_FUNCTION
, (void*)&my_malloc
);
3113 assert(rc
== MEMCACHED_SUCCESS
);
3114 test_ptr
= (memcached_malloc_function
)memcached_callback_get(memc
, MEMCACHED_CALLBACK_MALLOC_FUNCTION
, &rc
);
3115 assert(rc
== MEMCACHED_SUCCESS
);
3116 assert(test_ptr
== my_malloc
);
3120 memcached_realloc_function test_ptr
;
3121 memcached_return rc
;
3123 rc
= memcached_callback_set(memc
, MEMCACHED_CALLBACK_REALLOC_FUNCTION
, (void*)&my_realloc
);
3124 assert(rc
== MEMCACHED_SUCCESS
);
3125 test_ptr
= (memcached_realloc_function
)memcached_callback_get(memc
, MEMCACHED_CALLBACK_REALLOC_FUNCTION
, &rc
);
3126 assert(rc
== MEMCACHED_SUCCESS
);
3127 assert(test_ptr
== my_realloc
);
3131 memcached_free_function test_ptr
;
3132 memcached_return rc
;
3134 rc
= memcached_callback_set(memc
, MEMCACHED_CALLBACK_FREE_FUNCTION
, (void*)my_free
);
3135 assert(rc
== MEMCACHED_SUCCESS
);
3136 test_ptr
= (memcached_free_function
)memcached_callback_get(memc
, MEMCACHED_CALLBACK_FREE_FUNCTION
, &rc
);
3137 assert(rc
== MEMCACHED_SUCCESS
);
3138 assert(test_ptr
== my_free
);
3141 return MEMCACHED_SUCCESS
;
3144 static memcached_return
enable_consistent(memcached_st
*memc
)
3146 memcached_server_distribution value
= MEMCACHED_DISTRIBUTION_CONSISTENT
;
3147 memcached_hash hash
;
3148 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_DISTRIBUTION
, value
);
3149 if (pre_hsieh(memc
) != MEMCACHED_SUCCESS
)
3150 return MEMCACHED_FAILURE
;
3152 value
= (memcached_server_distribution
)memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_DISTRIBUTION
);
3153 assert(value
== MEMCACHED_DISTRIBUTION_CONSISTENT
);
3155 hash
= (memcached_hash
)memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_HASH
);
3156 assert(hash
== MEMCACHED_HASH_HSIEH
);
3159 return MEMCACHED_SUCCESS
;
3162 static memcached_return
enable_cas(memcached_st
*memc
)
3164 unsigned int set
= 1;
3166 memcached_version(memc
);
3168 if ((memc
->hosts
[0].major_version
>= 1 && (memc
->hosts
[0].minor_version
== 2 && memc
->hosts
[0].micro_version
>= 4))
3169 || memc
->hosts
[0].minor_version
> 2)
3171 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_SUPPORT_CAS
, set
);
3173 return MEMCACHED_SUCCESS
;
3176 return MEMCACHED_FAILURE
;
3179 static memcached_return
check_for_1_2_3(memcached_st
*memc
)
3181 memcached_version(memc
);
3183 if ((memc
->hosts
[0].major_version
>= 1 && (memc
->hosts
[0].minor_version
== 2 && memc
->hosts
[0].micro_version
>= 4))
3184 || memc
->hosts
[0].minor_version
> 2)
3185 return MEMCACHED_SUCCESS
;
3187 return MEMCACHED_FAILURE
;
3190 static memcached_return
pre_unix_socket(memcached_st
*memc
)
3192 memcached_return rc
;
3195 memcached_server_list_free(memc
->hosts
);
3197 memc
->number_of_hosts
= 0;
3199 if (stat("/tmp/memcached.socket", &buf
))
3200 return MEMCACHED_FAILURE
;
3202 rc
= memcached_server_add_unix_socket_with_weight(memc
, "/tmp/memcached.socket", 0);
3207 static memcached_return
pre_nodelay(memcached_st
*memc
)
3209 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NO_BLOCK
, 0);
3210 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_TCP_NODELAY
, 0);
3212 return MEMCACHED_SUCCESS
;
3215 static memcached_return
pre_settimer(memcached_st
*memc
)
3217 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_SND_TIMEOUT
, 1000);
3218 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_RCV_TIMEOUT
, 1000);
3220 return MEMCACHED_SUCCESS
;
3223 static memcached_return
poll_timeout(memcached_st
*memc
)
3229 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_POLL_TIMEOUT
, timeout
);
3231 timeout
= (int32_t)memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_POLL_TIMEOUT
);
3233 assert(timeout
== 100);
3235 return MEMCACHED_SUCCESS
;
3238 static test_return
noreply_test(memcached_st
*memc
)
3240 memcached_return ret
;
3241 ret
= memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NOREPLY
, 1);
3242 assert(ret
== MEMCACHED_SUCCESS
);
3243 ret
= memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_BUFFER_REQUESTS
, 1);
3244 assert(ret
== MEMCACHED_SUCCESS
);
3245 ret
= memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_SUPPORT_CAS
, 1);
3246 assert(ret
== MEMCACHED_SUCCESS
);
3247 assert(memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_NOREPLY
) == 1);
3248 assert(memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_BUFFER_REQUESTS
) == 1);
3249 assert(memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_SUPPORT_CAS
) == 1);
3251 for (int count
=0; count
< 5; ++count
)
3253 for (int x
=0; x
< 100; ++x
)
3256 size_t len
=sprintf(key
, "%d", x
);
3260 ret
=memcached_add(memc
, key
, len
, key
, len
, 0, 0);
3263 ret
=memcached_replace(memc
, key
, len
, key
, len
, 0, 0);
3266 ret
=memcached_set(memc
, key
, len
, key
, len
, 0, 0);
3269 ret
=memcached_append(memc
, key
, len
, key
, len
, 0, 0);
3272 ret
=memcached_prepend(memc
, key
, len
, key
, len
, 0, 0);
3275 assert(ret
== MEMCACHED_SUCCESS
|| ret
== MEMCACHED_BUFFERED
);
3279 ** NOTE: Don't ever do this in your code! this is not a supported use of the
3280 ** API and is _ONLY_ done this way to verify that the library works the
3281 ** way it is supposed to do!!!!
3284 for (int x
=0; x
< memc
->number_of_hosts
; ++x
)
3285 no_msg
+=memc
->hosts
[x
].cursor_active
;
3287 assert(no_msg
== 0);
3288 assert(memcached_flush_buffers(memc
) == MEMCACHED_SUCCESS
);
3291 ** Now validate that all items was set properly!
3293 for (int x
=0; x
< 100; ++x
)
3296 size_t len
=sprintf(key
, "%d", x
);
3299 char* value
=memcached_get(memc
, key
, strlen(key
),
3300 &length
, &flags
, &ret
);
3301 assert(ret
== MEMCACHED_SUCCESS
&& value
!= NULL
);
3304 case 0: /* FALLTHROUGH */
3305 case 1: /* FALLTHROUGH */
3307 assert(strncmp(value
, key
, len
) == 0);
3308 assert(len
== length
);
3311 assert(length
== len
* 2);
3314 assert(length
== len
* 3);
3321 /* Try setting an illegal cas value (should not return an error to
3322 * the caller (because we don't expect a return message from the server)
3324 char* keys
[]= {"0"};
3325 size_t lengths
[]= {1};
3328 memcached_result_st results_obj
;
3329 memcached_result_st
*results
;
3330 ret
=memcached_mget(memc
, keys
, lengths
, 1);
3331 assert(ret
== MEMCACHED_SUCCESS
);
3333 results
=memcached_result_create(memc
, &results_obj
);
3335 results
=memcached_fetch_result(memc
, &results_obj
, &ret
);
3337 assert(ret
== MEMCACHED_SUCCESS
);
3338 uint64_t cas
= memcached_result_cas(results
);
3339 memcached_result_free(&results_obj
);
3341 ret
= memcached_cas(memc
, keys
[0], lengths
[0], keys
[0], lengths
[0], 0, 0, cas
);
3342 assert(ret
== MEMCACHED_SUCCESS
);
3345 * The item will have a new cas value, so try to set it again with the old
3346 * value. This should fail!
3348 ret
= memcached_cas(memc
, keys
[0], lengths
[0], keys
[0], lengths
[0], 0, 0, cas
);
3349 assert(ret
== MEMCACHED_SUCCESS
);
3350 assert(memcached_flush_buffers(memc
) == MEMCACHED_SUCCESS
);
3351 char* value
=memcached_get(memc
, keys
[0], lengths
[0], &length
, &flags
, &ret
);
3352 assert(ret
== MEMCACHED_SUCCESS
&& value
!= NULL
);
3355 return TEST_SUCCESS
;
3358 static test_return
analyzer_test(memcached_st
*memc
)
3360 memcached_return rc
;
3361 memcached_stat_st
*stat
;
3362 memcached_analysis_st
*report
;
3364 stat
= memcached_stat(memc
, NULL
, &rc
);
3365 assert(rc
== MEMCACHED_SUCCESS
);
3368 report
= memcached_analyze(memc
, stat
, &rc
);
3369 assert(rc
== MEMCACHED_SUCCESS
);
3373 memcached_stat_free(NULL
, stat
);
3375 return TEST_SUCCESS
;
3378 #ifdef HAVE_LIBMEMCACHEDUTIL
3379 static void* connection_release(void *arg
) {
3381 memcached_pool_st
* pool
;
3386 assert(memcached_pool_push(resource
->pool
, resource
->mmc
) == MEMCACHED_SUCCESS
);
3389 static test_return
connection_pool_test(memcached_st
*memc
)
3391 memcached_pool_st
* pool
= memcached_pool_create(memc
, 5, 10);
3392 assert(pool
!= NULL
);
3393 memcached_st
* mmc
[10];
3394 memcached_return rc
;
3396 for (int x
= 0; x
< 10; ++x
) {
3397 mmc
[x
]= memcached_pool_pop(pool
, false, &rc
);
3398 assert(mmc
[x
] != NULL
);
3399 assert(rc
== MEMCACHED_SUCCESS
);
3402 assert(memcached_pool_pop(pool
, false, &rc
) == NULL
);
3403 assert(rc
== MEMCACHED_SUCCESS
);
3407 memcached_pool_st
* pool
;
3409 } item
= { .pool
= pool
, .mmc
= mmc
[9] };
3410 pthread_create(&tid
, NULL
, connection_release
, &item
);
3411 mmc
[9]= memcached_pool_pop(pool
, true, &rc
);
3412 assert(rc
== MEMCACHED_SUCCESS
);
3413 pthread_join(tid
, NULL
);
3414 assert(mmc
[9] == item
.mmc
);
3415 const char *key
= "key";
3416 size_t keylen
= strlen(key
);
3418 // verify that I can do ops with all connections
3419 rc
= memcached_set(mmc
[0], key
, keylen
, "0", 1, 0, 0);
3420 assert(rc
== MEMCACHED_SUCCESS
);
3422 for (int x
= 0; x
< 10; ++x
) {
3423 uint64_t number_value
;
3424 rc
= memcached_increment(mmc
[x
], key
, keylen
, 1, &number_value
);
3425 assert(rc
== MEMCACHED_SUCCESS
);
3426 assert(number_value
== (x
+1));
3430 for (int x
= 0; x
< 10; ++x
)
3431 assert(memcached_pool_push(pool
, mmc
[x
]) == MEMCACHED_SUCCESS
);
3433 assert(memcached_pool_destroy(pool
) == memc
);
3434 return TEST_SUCCESS
;
3438 static void increment_request_id(uint16_t *id
)
3441 if ((*id
& UDP_REQUEST_ID_THREAD_MASK
) != 0)
3445 static uint16_t *get_udp_request_ids(memcached_st
*memc
)
3447 uint16_t *ids
= malloc(sizeof(uint16_t) * memc
->number_of_hosts
);
3448 assert(ids
!= NULL
);
3450 for (x
= 0; x
< memc
->number_of_hosts
; x
++)
3451 ids
[x
]= get_udp_datagram_request_id((struct udp_datagram_header_st
*) memc
->hosts
[x
].write_buffer
);
3456 static test_return
post_udp_op_check(memcached_st
*memc
, uint16_t *expected_req_ids
)
3459 memcached_server_st
*cur_server
= memc
->hosts
;
3460 uint16_t *cur_req_ids
= get_udp_request_ids(memc
);
3461 for (x
= 0; x
< memc
->number_of_hosts
; x
++)
3463 assert(cur_server
[x
].cursor_active
== 0);
3464 assert(cur_req_ids
[x
] == expected_req_ids
[x
]);
3466 free(expected_req_ids
);
3468 return TEST_SUCCESS
;
3472 ** There is a little bit of a hack here, instead of removing
3473 ** the servers, I just set num host to 0 and them add then new udp servers
3475 static memcached_return
init_udp(memcached_st
*memc
)
3477 memcached_version(memc
);
3478 /* For the time being, only support udp test for >= 1.2.6 && < 1.3 */
3479 if (memc
->hosts
[0].major_version
!= 1 || memc
->hosts
[0].minor_version
!= 2
3480 || memc
->hosts
[0].micro_version
< 6)
3481 return MEMCACHED_FAILURE
;
3483 uint32_t num_hosts
= memc
->number_of_hosts
;
3485 memcached_server_st servers
[num_hosts
];
3486 memcpy(servers
, memc
->hosts
, sizeof(memcached_server_st
) * num_hosts
);
3487 for (x
= 0; x
< num_hosts
; x
++)
3488 memcached_server_free(&memc
->hosts
[x
]);
3489 memc
->number_of_hosts
= 0;
3490 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_USE_UDP
, 1);
3491 for (x
= 0; x
< num_hosts
; x
++)
3493 assert(memcached_server_add_udp(memc
, servers
[x
].hostname
, servers
[x
].port
) == MEMCACHED_SUCCESS
);
3494 assert(memc
->hosts
[x
].write_buffer_offset
== UDP_DATAGRAM_HEADER_LENGTH
);
3496 return MEMCACHED_SUCCESS
;
3499 static memcached_return
binary_init_udp(memcached_st
*memc
)
3502 return init_udp(memc
);
3505 /* Make sure that I cant add a tcp server to a udp client */
3506 static test_return
add_tcp_server_udp_client_test(memcached_st
*memc
)
3508 memcached_server_st server
;
3509 memcached_server_clone(&server
, &memc
->hosts
[0]);
3510 assert(memcached_server_remove(&(memc
->hosts
[0])) == MEMCACHED_SUCCESS
);
3511 assert(memcached_server_add(memc
, server
.hostname
, server
.port
) == MEMCACHED_INVALID_HOST_PROTOCOL
);
3512 return TEST_SUCCESS
;
3515 /* Make sure that I cant add a udp server to a tcp client */
3516 static test_return
add_udp_server_tcp_client_test(memcached_st
*memc
)
3518 memcached_server_st server
;
3519 memcached_server_clone(&server
, &memc
->hosts
[0]);
3520 assert(memcached_server_remove(&(memc
->hosts
[0])) == MEMCACHED_SUCCESS
);
3522 memcached_st tcp_client
;
3523 memcached_create(&tcp_client
);
3524 assert(memcached_server_add_udp(&tcp_client
, server
.hostname
, server
.port
) == MEMCACHED_INVALID_HOST_PROTOCOL
);
3525 return TEST_SUCCESS
;
3528 static test_return
set_udp_behavior_test(memcached_st
*memc
)
3531 memcached_quit(memc
);
3532 memc
->number_of_hosts
= 0;
3533 run_distribution(memc
);
3534 assert(memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_USE_UDP
, 1) == MEMCACHED_SUCCESS
);
3535 assert(memc
->flags
& MEM_USE_UDP
);
3536 assert(memc
->flags
& MEM_NOREPLY
);;
3538 assert(memc
->number_of_hosts
== 0);
3540 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_USE_UDP
,0);
3541 assert(!(memc
->flags
& MEM_USE_UDP
));
3542 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NOREPLY
,0);
3543 assert(!(memc
->flags
& MEM_NOREPLY
));
3544 return TEST_SUCCESS
;
3547 static test_return
udp_set_test(memcached_st
*memc
)
3550 unsigned int num_iters
= 1025; //request id rolls over at 1024
3551 for (x
= 0; x
< num_iters
;x
++)
3553 memcached_return rc
;
3555 char *value
= "when we sanitize";
3556 uint16_t *expected_ids
= get_udp_request_ids(memc
);
3557 unsigned int server_key
= memcached_generate_hash(memc
,key
,strlen(key
));
3558 size_t init_offset
= memc
->hosts
[server_key
].write_buffer_offset
;
3559 rc
= memcached_set(memc
, key
, strlen(key
),
3560 value
, strlen(value
),
3561 (time_t)0, (uint32_t)0);
3562 assert(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
);
3563 /** NB, the check below assumes that if new write_ptr is less than
3564 * the original write_ptr that we have flushed. For large payloads, this
3565 * maybe an invalid assumption, but for the small payload we have it is OK
3567 if (rc
== MEMCACHED_SUCCESS
||
3568 memc
->hosts
[server_key
].write_buffer_offset
< init_offset
)
3569 increment_request_id(&expected_ids
[server_key
]);
3571 if (rc
== MEMCACHED_SUCCESS
)
3573 assert(memc
->hosts
[server_key
].write_buffer_offset
== UDP_DATAGRAM_HEADER_LENGTH
);
3577 assert(memc
->hosts
[server_key
].write_buffer_offset
!= UDP_DATAGRAM_HEADER_LENGTH
);
3578 assert(memc
->hosts
[server_key
].write_buffer_offset
<= MAX_UDP_DATAGRAM_LENGTH
);
3580 assert(post_udp_op_check(memc
,expected_ids
) == TEST_SUCCESS
);
3582 return TEST_SUCCESS
;
3585 static test_return
udp_buffered_set_test(memcached_st
*memc
)
3587 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_BUFFER_REQUESTS
, 1);
3588 return udp_set_test(memc
);
3591 static test_return
udp_set_too_big_test(memcached_st
*memc
)
3593 memcached_return rc
;
3595 char value
[MAX_UDP_DATAGRAM_LENGTH
];
3596 uint16_t *expected_ids
= get_udp_request_ids(memc
);
3597 rc
= memcached_set(memc
, key
, strlen(key
),
3598 value
, MAX_UDP_DATAGRAM_LENGTH
,
3599 (time_t)0, (uint32_t)0);
3600 assert(rc
== MEMCACHED_WRITE_FAILURE
);
3601 return post_udp_op_check(memc
,expected_ids
);
3604 test_return
udp_delete_test(memcached_st
*memc
)
3607 unsigned int num_iters
= 1025; //request id rolls over at 1024
3608 for (x
= 0; x
< num_iters
;x
++)
3610 memcached_return rc
;
3612 uint16_t *expected_ids
=get_udp_request_ids(memc
);
3613 unsigned int server_key
= memcached_generate_hash(memc
, key
, strlen(key
));
3614 size_t init_offset
= memc
->hosts
[server_key
].write_buffer_offset
;
3615 rc
= memcached_delete(memc
, key
, strlen(key
), 0);
3616 assert(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
);
3617 if (rc
== MEMCACHED_SUCCESS
|| memc
->hosts
[server_key
].write_buffer_offset
< init_offset
)
3618 increment_request_id(&expected_ids
[server_key
]);
3619 if (rc
== MEMCACHED_SUCCESS
)
3620 assert(memc
->hosts
[server_key
].write_buffer_offset
== UDP_DATAGRAM_HEADER_LENGTH
);
3623 assert(memc
->hosts
[server_key
].write_buffer_offset
!= UDP_DATAGRAM_HEADER_LENGTH
);
3624 assert(memc
->hosts
[server_key
].write_buffer_offset
<= MAX_UDP_DATAGRAM_LENGTH
);
3626 assert(post_udp_op_check(memc
,expected_ids
) == TEST_SUCCESS
);
3628 return TEST_SUCCESS
;
3631 static test_return
udp_buffered_delete_test(memcached_st
*memc
)
3633 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_BUFFER_REQUESTS
, 1);
3634 return udp_delete_test(memc
);
3637 test_return
udp_verbosity_test(memcached_st
*memc
)
3639 memcached_return rc
;
3640 uint16_t *expected_ids
= get_udp_request_ids(memc
);
3642 for (x
= 0; x
< memc
->number_of_hosts
;x
++)
3643 increment_request_id(&expected_ids
[x
]);
3645 rc
= memcached_verbosity(memc
,3);
3646 assert(rc
== MEMCACHED_SUCCESS
);
3647 return post_udp_op_check(memc
,expected_ids
);
3650 test_return
udp_quit_test(memcached_st
*memc
)
3652 uint16_t *expected_ids
= get_udp_request_ids(memc
);
3653 memcached_quit(memc
);
3654 return post_udp_op_check(memc
, expected_ids
);
3657 test_return
udp_flush_test(memcached_st
*memc
)
3659 memcached_return rc
;
3660 uint16_t *expected_ids
= get_udp_request_ids(memc
);
3662 for (x
= 0; x
< memc
->number_of_hosts
;x
++)
3663 increment_request_id(&expected_ids
[x
]);
3665 rc
= memcached_flush(memc
,0);
3666 assert(rc
== MEMCACHED_SUCCESS
);
3667 return post_udp_op_check(memc
,expected_ids
);
3670 test_return
udp_incr_test(memcached_st
*memc
)
3672 memcached_return rc
;
3675 rc
= memcached_set(memc
, key
, strlen(key
),
3676 value
, strlen(value
),
3677 (time_t)0, (uint32_t)0);
3679 assert(rc
== MEMCACHED_SUCCESS
);
3680 uint16_t *expected_ids
= get_udp_request_ids(memc
);
3681 unsigned int server_key
= memcached_generate_hash(memc
, key
, strlen(key
));
3682 increment_request_id(&expected_ids
[server_key
]);
3684 rc
= memcached_increment(memc
, key
, strlen(key
), 1, &newvalue
);
3685 assert(rc
== MEMCACHED_SUCCESS
);
3686 return post_udp_op_check(memc
, expected_ids
);
3689 test_return
udp_decr_test(memcached_st
*memc
)
3691 memcached_return rc
;
3694 rc
= memcached_set(memc
, key
, strlen(key
),
3695 value
, strlen(value
),
3696 (time_t)0, (uint32_t)0);
3698 assert(rc
== MEMCACHED_SUCCESS
);
3699 uint16_t *expected_ids
= get_udp_request_ids(memc
);
3700 unsigned int server_key
= memcached_generate_hash(memc
, key
, strlen(key
));
3701 increment_request_id(&expected_ids
[server_key
]);
3703 rc
= memcached_decrement(memc
, key
, strlen(key
), 1, &newvalue
);
3704 assert(rc
== MEMCACHED_SUCCESS
);
3705 return post_udp_op_check(memc
, expected_ids
);
3709 test_return
udp_stat_test(memcached_st
*memc
)
3711 memcached_stat_st
* rv
= NULL
;
3712 memcached_return rc
;
3714 uint16_t *expected_ids
= get_udp_request_ids(memc
);
3715 rv
= memcached_stat(memc
, args
, &rc
);
3717 assert(rc
== MEMCACHED_NOT_SUPPORTED
);
3718 return post_udp_op_check(memc
, expected_ids
);
3721 test_return
udp_version_test(memcached_st
*memc
)
3723 memcached_return rc
;
3724 uint16_t *expected_ids
= get_udp_request_ids(memc
);
3725 rc
= memcached_version(memc
);
3726 assert(rc
== MEMCACHED_NOT_SUPPORTED
);
3727 return post_udp_op_check(memc
, expected_ids
);
3730 test_return
udp_get_test(memcached_st
*memc
)
3732 memcached_return rc
;
3735 uint16_t *expected_ids
= get_udp_request_ids(memc
);
3736 char *val
= memcached_get(memc
, key
, strlen(key
), &vlen
, (uint32_t)0, &rc
);
3737 assert(rc
== MEMCACHED_NOT_SUPPORTED
);
3738 assert(val
== NULL
);
3739 return post_udp_op_check(memc
, expected_ids
);
3742 test_return
udp_mixed_io_test(memcached_st
*memc
)
3745 test_st mixed_io_ops
[] ={
3746 {"udp_set_test", 0, udp_set_test
},
3747 {"udp_set_too_big_test", 0, udp_set_too_big_test
},
3748 {"udp_delete_test", 0, udp_delete_test
},
3749 {"udp_verbosity_test", 0, udp_verbosity_test
},
3750 {"udp_quit_test", 0, udp_quit_test
},
3751 {"udp_flush_test", 0, udp_flush_test
},
3752 {"udp_incr_test", 0, udp_incr_test
},
3753 {"udp_decr_test", 0, udp_decr_test
},
3754 {"udp_version_test", 0, udp_version_test
}
3757 for (x
= 0; x
< 500; x
++)
3759 current_op
= mixed_io_ops
[random() % 9];
3760 assert(current_op
.function(memc
) == TEST_SUCCESS
);
3762 return TEST_SUCCESS
;
3765 test_return
hsieh_avaibility_test (memcached_st
*memc
)
3767 memcached_return expected_rc
= MEMCACHED_FAILURE
;
3768 #ifdef HAVE_HSIEH_HASH
3769 expected_rc
= MEMCACHED_SUCCESS
;
3771 memcached_return rc
= memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_HASH
,
3772 (uint64_t)MEMCACHED_HASH_HSIEH
);
3773 assert(rc
== expected_rc
);
3774 return TEST_SUCCESS
;
3777 test_st udp_setup_server_tests
[] ={
3778 {"set_udp_behavior_test", 0, set_udp_behavior_test
},
3779 {"add_tcp_server_udp_client_test", 0, add_tcp_server_udp_client_test
},
3780 {"add_udp_server_tcp_client_test", 0, add_udp_server_tcp_client_test
},
3784 test_st upd_io_tests
[] ={
3785 {"udp_set_test", 0, udp_set_test
},
3786 {"udp_buffered_set_test", 0, udp_buffered_set_test
},
3787 {"udp_set_too_big_test", 0, udp_set_too_big_test
},
3788 {"udp_delete_test", 0, udp_delete_test
},
3789 {"udp_buffered_delete_test", 0, udp_buffered_delete_test
},
3790 {"udp_verbosity_test", 0, udp_verbosity_test
},
3791 {"udp_quit_test", 0, udp_quit_test
},
3792 {"udp_flush_test", 0, udp_flush_test
},
3793 {"udp_incr_test", 0, udp_incr_test
},
3794 {"udp_decr_test", 0, udp_decr_test
},
3795 {"udp_stat_test", 0, udp_stat_test
},
3796 {"udp_version_test", 0, udp_version_test
},
3797 {"udp_get_test", 0, udp_get_test
},
3798 {"udp_mixed_io_test", 0, udp_mixed_io_test
},
3802 /* Clean the server before beginning testing */
3804 {"flush", 0, flush_test
},
3805 {"init", 0, init_test
},
3806 {"allocation", 0, allocation_test
},
3807 {"server_list_null_test", 0, server_list_null_test
},
3808 {"server_unsort", 0, server_unsort_test
},
3809 {"server_sort", 0, server_sort_test
},
3810 {"server_sort2", 0, server_sort2_test
},
3811 {"clone_test", 0, clone_test
},
3812 {"error", 0, error_test
},
3813 {"set", 0, set_test
},
3814 {"set2", 0, set_test2
},
3815 {"set3", 0, set_test3
},
3816 {"add", 1, add_test
},
3817 {"replace", 1, replace_test
},
3818 {"delete", 1, delete_test
},
3819 {"get", 1, get_test
},
3820 {"get2", 0, get_test2
},
3821 {"get3", 0, get_test3
},
3822 {"get4", 0, get_test4
},
3823 {"partial mget", 0, get_test5
},
3824 {"stats_servername", 0, stats_servername_test
},
3825 {"increment", 0, increment_test
},
3826 {"increment_with_initial", 1, increment_with_initial_test
},
3827 {"decrement", 0, decrement_test
},
3828 {"decrement_with_initial", 1, decrement_with_initial_test
},
3829 {"quit", 0, quit_test
},
3830 {"mget", 1, mget_test
},
3831 {"mget_result", 1, mget_result_test
},
3832 {"mget_result_alloc", 1, mget_result_alloc_test
},
3833 {"mget_result_function", 1, mget_result_function
},
3834 {"get_stats", 0, get_stats
},
3835 {"add_host_test", 0, add_host_test
},
3836 {"add_host_test_1", 0, add_host_test1
},
3837 {"get_stats_keys", 0, get_stats_keys
},
3838 {"behavior_test", 0, get_stats_keys
},
3839 {"callback_test", 0, get_stats_keys
},
3840 {"version_string_test", 0, version_string_test
},
3841 {"bad_key", 1, bad_key_test
},
3842 {"memcached_server_cursor", 1, memcached_server_cursor_test
},
3843 {"read_through", 1, read_through
},
3844 {"delete_through", 1, delete_through
},
3845 {"noreply", 1, noreply_test
},
3846 {"analyzer", 1, analyzer_test
},
3847 #ifdef HAVE_LIBMEMCACHEDUTIL
3848 {"connectionpool", 1, connection_pool_test
},
3853 test_st async_tests
[] ={
3854 {"add", 1, add_wrapper
},
3858 test_st string_tests
[] ={
3859 {"string static with null", 0, string_static_null
},
3860 {"string alloc with null", 0, string_alloc_null
},
3861 {"string alloc with 1K", 0, string_alloc_with_size
},
3862 {"string alloc with malloc failure", 0, string_alloc_with_size_toobig
},
3863 {"string append", 0, string_alloc_append
},
3864 {"string append failure (too big)", 0, string_alloc_append_toobig
},
3868 test_st result_tests
[] ={
3869 {"result static", 0, result_static
},
3870 {"result alloc", 0, result_alloc
},
3874 test_st version_1_2_3
[] ={
3875 {"append", 0, append_test
},
3876 {"prepend", 0, prepend_test
},
3877 {"cas", 0, cas_test
},
3878 {"cas2", 0, cas2_test
},
3879 {"append_binary", 0, append_binary_test
},
3883 test_st user_tests
[] ={
3884 {"user_supplied_bug1", 0, user_supplied_bug1
},
3885 {"user_supplied_bug2", 0, user_supplied_bug2
},
3886 {"user_supplied_bug3", 0, user_supplied_bug3
},
3887 {"user_supplied_bug4", 0, user_supplied_bug4
},
3888 {"user_supplied_bug5", 1, user_supplied_bug5
},
3889 {"user_supplied_bug6", 1, user_supplied_bug6
},
3890 {"user_supplied_bug7", 1, user_supplied_bug7
},
3891 {"user_supplied_bug8", 1, user_supplied_bug8
},
3892 {"user_supplied_bug9", 1, user_supplied_bug9
},
3893 {"user_supplied_bug10", 1, user_supplied_bug10
},
3894 {"user_supplied_bug11", 1, user_supplied_bug11
},
3895 {"user_supplied_bug12", 1, user_supplied_bug12
},
3896 {"user_supplied_bug13", 1, user_supplied_bug13
},
3897 {"user_supplied_bug14", 1, user_supplied_bug14
},
3898 {"user_supplied_bug15", 1, user_supplied_bug15
},
3899 {"user_supplied_bug16", 1, user_supplied_bug16
},
3902 ** It seems to be something weird with the character sets..
3903 ** value_fetch is unable to parse the value line (iscntrl "fails"), so I
3904 ** guess I need to find out how this is supposed to work.. Perhaps I need
3905 ** to run the test in a specific locale (I tried zh_CN.UTF-8 without success,
3906 ** so just disable the code for now...).
3908 {"user_supplied_bug17", 1, user_supplied_bug17
},
3910 {"user_supplied_bug18", 1, user_supplied_bug18
},
3911 {"user_supplied_bug19", 1, user_supplied_bug19
},
3912 {"user_supplied_bug20", 1, user_supplied_bug20
},
3916 test_st generate_tests
[] ={
3917 {"generate_pairs", 1, generate_pairs
},
3918 {"generate_data", 1, generate_data
},
3919 {"get_read", 0, get_read
},
3920 {"delete_generate", 0, delete_generate
},
3921 {"generate_buffer_data", 1, generate_buffer_data
},
3922 {"delete_buffer", 0, delete_buffer_generate
},
3923 {"generate_data", 1, generate_data
},
3924 {"mget_read", 0, mget_read
},
3925 {"mget_read_result", 0, mget_read_result
},
3926 {"mget_read_function", 0, mget_read_function
},
3927 {"cleanup", 1, cleanup_pairs
},
3928 {"generate_large_pairs", 1, generate_large_pairs
},
3929 {"generate_data", 1, generate_data
},
3930 {"generate_buffer_data", 1, generate_buffer_data
},
3931 {"cleanup", 1, cleanup_pairs
},
3935 test_st consistent_tests
[] ={
3936 {"generate_pairs", 1, generate_pairs
},
3937 {"generate_data", 1, generate_data
},
3938 {"get_read", 0, get_read_count
},
3939 {"cleanup", 1, cleanup_pairs
},
3943 test_st consistent_weighted_tests
[] ={
3944 {"generate_pairs", 1, generate_pairs
},
3945 {"generate_data", 1, generate_data_with_stats
},
3946 {"get_read", 0, get_read_count
},
3947 {"cleanup", 1, cleanup_pairs
},
3951 test_st hsieh_availability
[] ={
3952 {"hsieh_avaibility_test",0,hsieh_avaibility_test
},
3956 test_st ketama_auto_eject_hosts
[] ={
3957 {"auto_eject_hosts", 1, auto_eject_hosts
},
3961 collection_st collection
[] ={
3962 {"hsieh_availability",0,0,hsieh_availability
},
3963 {"udp_setup", init_udp
, 0, udp_setup_server_tests
},
3964 {"udp_io", init_udp
, 0, upd_io_tests
},
3965 {"udp_binary_io", binary_init_udp
, 0, upd_io_tests
},
3966 {"block", 0, 0, tests
},
3967 {"binary", pre_binary
, 0, tests
},
3968 {"nonblock", pre_nonblock
, 0, tests
},
3969 {"nodelay", pre_nodelay
, 0, tests
},
3970 {"settimer", pre_settimer
, 0, tests
},
3971 {"md5", pre_md5
, 0, tests
},
3972 {"crc", pre_crc
, 0, tests
},
3973 {"hsieh", pre_hsieh
, 0, tests
},
3974 {"jenkins", pre_jenkins
, 0, tests
},
3975 {"fnv1_64", pre_hash_fnv1_64
, 0, tests
},
3976 {"fnv1a_64", pre_hash_fnv1a_64
, 0, tests
},
3977 {"fnv1_32", pre_hash_fnv1_32
, 0, tests
},
3978 {"fnv1a_32", pre_hash_fnv1a_32
, 0, tests
},
3979 {"ketama", pre_behavior_ketama
, 0, tests
},
3980 {"ketama_auto_eject_hosts", pre_behavior_ketama
, 0, ketama_auto_eject_hosts
},
3981 {"unix_socket", pre_unix_socket
, 0, tests
},
3982 {"unix_socket_nodelay", pre_nodelay
, 0, tests
},
3983 {"poll_timeout", poll_timeout
, 0, tests
},
3984 {"gets", enable_cas
, 0, tests
},
3985 {"consistent", enable_consistent
, 0, tests
},
3986 {"memory_allocators", set_memory_alloc
, 0, tests
},
3987 {"prefix", set_prefix
, 0, tests
},
3988 {"version_1_2_3", check_for_1_2_3
, 0, version_1_2_3
},
3989 {"string", 0, 0, string_tests
},
3990 {"result", 0, 0, result_tests
},
3991 {"async", pre_nonblock
, 0, async_tests
},
3992 {"async_binary", pre_nonblock_binary
, 0, async_tests
},
3993 {"user", 0, 0, user_tests
},
3994 {"generate", 0, 0, generate_tests
},
3995 {"generate_hsieh", pre_hsieh
, 0, generate_tests
},
3996 {"generate_ketama", pre_behavior_ketama
, 0, generate_tests
},
3997 {"generate_hsieh_consistent", enable_consistent
, 0, generate_tests
},
3998 {"generate_md5", pre_md5
, 0, generate_tests
},
3999 {"generate_murmur", pre_murmur
, 0, generate_tests
},
4000 {"generate_jenkins", pre_jenkins
, 0, generate_tests
},
4001 {"generate_nonblock", pre_nonblock
, 0, generate_tests
},
4002 {"consistent_not", 0, 0, consistent_tests
},
4003 {"consistent_ketama", pre_behavior_ketama
, 0, consistent_tests
},
4004 {"consistent_ketama_weighted", pre_behavior_ketama_weighted
, 0, consistent_weighted_tests
},
4008 #define SERVERS_TO_CREATE 5
4010 /* Prototypes for functions we will pass to test framework */
4011 void *world_create(void);
4012 void world_destroy(void *p
);
4014 void *world_create(void)
4016 server_startup_st
*construct
;
4018 construct
= (server_startup_st
*)malloc(sizeof(server_startup_st
));
4019 memset(construct
, 0, sizeof(server_startup_st
));
4020 construct
->count
= SERVERS_TO_CREATE
;
4022 server_startup(construct
);
4028 void world_destroy(void *p
)
4030 server_startup_st
*construct
= (server_startup_st
*)p
;
4031 memcached_server_st
*servers
= (memcached_server_st
*)construct
->servers
;
4032 memcached_server_list_free(servers
);
4034 server_shutdown(construct
);
4038 void get_world(world_st
*world
)
4040 world
->collections
= collection
;
4041 world
->create
= world_create
;
4042 world
->destroy
= world_destroy
;