2 Sample test application.
14 #include "../clients/generator.h"
15 #include "../clients/execute.h"
18 #define INT64_MAX LONG_MAX
21 #define INT32_MAX INT_MAX
27 #define GLOBAL_COUNT 10000
28 #define GLOBAL2_COUNT 100
29 #define SERVERS_TO_CREATE 5
30 static uint32_t global_count
;
32 static pairs_st
*global_pairs
;
33 static char *global_keys
[GLOBAL_COUNT
];
34 static size_t global_keys_length
[GLOBAL_COUNT
];
36 static test_return
init_test(memcached_st
*not_used
__attribute__((unused
)))
40 (void)memcached_create(&memc
);
41 memcached_free(&memc
);
46 static test_return
server_list_null_test(memcached_st
*ptr
__attribute__((unused
)))
48 memcached_server_st
*server_list
;
51 server_list
= memcached_server_list_append_with_weight(NULL
, NULL
, 0, 0, NULL
);
52 assert(server_list
== NULL
);
54 server_list
= memcached_server_list_append_with_weight(NULL
, "localhost", 0, 0, NULL
);
55 assert(server_list
== NULL
);
57 server_list
= memcached_server_list_append_with_weight(NULL
, NULL
, 0, 0, &rc
);
58 assert(server_list
== NULL
);
63 #define TEST_PORT_COUNT 7
64 uint32_t test_ports
[TEST_PORT_COUNT
];
66 static memcached_return
server_display_function(memcached_st
*ptr
__attribute__((unused
)), memcached_server_st
*server
, void *context
)
69 uint32_t bigger
= *((uint32_t *)(context
));
70 assert(bigger
<= server
->port
);
71 *((uint32_t *)(context
))= server
->port
;
73 return MEMCACHED_SUCCESS
;
76 static test_return
server_sort_test(memcached_st
*ptr
__attribute__((unused
)))
79 uint32_t bigger
= 0; /* Prime the value for the assert in server_display_function */
81 memcached_server_function callbacks
[1];
82 memcached_st
*local_memc
;
84 local_memc
= memcached_create(NULL
);
86 memcached_behavior_set(local_memc
, MEMCACHED_BEHAVIOR_SORT_HOSTS
, 1);
88 for (x
= 0; x
< TEST_PORT_COUNT
; x
++)
90 test_ports
[x
]= random() % 64000;
91 rc
= memcached_server_add_with_weight(local_memc
, "localhost", test_ports
[x
], 0);
92 assert(local_memc
->number_of_hosts
== x
+ 1);
93 assert(local_memc
->hosts
[0].count
== x
+1);
94 assert(rc
== MEMCACHED_SUCCESS
);
97 callbacks
[0]= server_display_function
;
98 memcached_server_cursor(local_memc
, callbacks
, (void *)&bigger
, 1);
101 memcached_free(local_memc
);
106 static test_return
server_sort2_test(memcached_st
*ptr
__attribute__((unused
)))
108 uint32_t bigger
= 0; /* Prime the value for the assert in server_display_function */
110 memcached_server_function callbacks
[1];
111 memcached_st
*local_memc
;
113 local_memc
= memcached_create(NULL
);
115 rc
= memcached_behavior_set(local_memc
, MEMCACHED_BEHAVIOR_SORT_HOSTS
, 1);
116 assert(rc
== MEMCACHED_SUCCESS
);
118 rc
= memcached_server_add_with_weight(local_memc
, "MEMCACHED_BEHAVIOR_SORT_HOSTS", 43043, 0);
119 assert(rc
== MEMCACHED_SUCCESS
);
120 assert(local_memc
->hosts
[0].port
== 43043);
122 rc
= memcached_server_add_with_weight(local_memc
, "MEMCACHED_BEHAVIOR_SORT_HOSTS", 43042, 0);
123 assert(rc
== MEMCACHED_SUCCESS
);
124 assert(local_memc
->hosts
[0].port
== 43042);
125 assert(local_memc
->hosts
[1].port
== 43043);
127 callbacks
[0]= server_display_function
;
128 memcached_server_cursor(local_memc
, callbacks
, (void *)&bigger
, 1);
131 memcached_free(local_memc
);
136 static memcached_return
server_display_unsort_function(memcached_st
*ptr
__attribute__((unused
)), memcached_server_st
*server
, void *context
)
139 uint32_t x
= *((uint32_t *)(context
));
141 assert(test_ports
[x
] == server
->port
);
142 *((uint32_t *)(context
))= ++x
;
144 return MEMCACHED_SUCCESS
;
147 static test_return
server_unsort_test(memcached_st
*ptr
__attribute__((unused
)))
150 uint32_t counter
= 0; /* Prime the value for the assert in server_display_function */
151 uint32_t bigger
= 0; /* Prime the value for the assert in server_display_function */
153 memcached_server_function callbacks
[1];
154 memcached_st
*local_memc
;
156 local_memc
= memcached_create(NULL
);
159 for (x
= 0; x
< TEST_PORT_COUNT
; x
++)
161 test_ports
[x
]= random() % 64000;
162 rc
= memcached_server_add_with_weight(local_memc
, "localhost", test_ports
[x
], 0);
163 assert(local_memc
->number_of_hosts
== x
+1);
164 assert(local_memc
->hosts
[0].count
== x
+1);
165 assert(rc
== MEMCACHED_SUCCESS
);
168 callbacks
[0]= server_display_unsort_function
;
169 memcached_server_cursor(local_memc
, callbacks
, (void *)&counter
, 1);
171 /* Now we sort old data! */
172 memcached_behavior_set(local_memc
, MEMCACHED_BEHAVIOR_SORT_HOSTS
, 1);
173 callbacks
[0]= server_display_function
;
174 memcached_server_cursor(local_memc
, callbacks
, (void *)&bigger
, 1);
177 memcached_free(local_memc
);
182 static test_return
allocation_test(memcached_st
*not_used
__attribute__((unused
)))
185 memc
= memcached_create(NULL
);
187 memcached_free(memc
);
192 static test_return
clone_test(memcached_st
*memc
)
197 clone
= memcached_clone(NULL
, NULL
);
199 memcached_free(clone
);
202 /* Can we init from null? */
205 clone
= memcached_clone(NULL
, memc
);
208 assert(clone
->call_free
== memc
->call_free
);
209 assert(clone
->call_malloc
== memc
->call_malloc
);
210 assert(clone
->call_realloc
== memc
->call_realloc
);
211 assert(clone
->connect_timeout
== memc
->connect_timeout
);
212 assert(clone
->delete_trigger
== memc
->delete_trigger
);
213 assert(clone
->distribution
== memc
->distribution
);
214 assert(clone
->flags
== memc
->flags
);
215 assert(clone
->get_key_failure
== memc
->get_key_failure
);
216 assert(clone
->hash
== memc
->hash
);
217 assert(clone
->hash_continuum
== memc
->hash_continuum
);
218 assert(clone
->io_bytes_watermark
== memc
->io_bytes_watermark
);
219 assert(clone
->io_msg_watermark
== memc
->io_msg_watermark
);
220 assert(clone
->on_cleanup
== memc
->on_cleanup
);
221 assert(clone
->on_clone
== memc
->on_clone
);
222 assert(clone
->poll_timeout
== memc
->poll_timeout
);
223 assert(clone
->rcv_timeout
== memc
->rcv_timeout
);
224 assert(clone
->recv_size
== memc
->recv_size
);
225 assert(clone
->retry_timeout
== memc
->retry_timeout
);
226 assert(clone
->send_size
== memc
->send_size
);
227 assert(clone
->server_failure_limit
== memc
->server_failure_limit
);
228 assert(clone
->snd_timeout
== memc
->snd_timeout
);
229 assert(clone
->user_data
== memc
->user_data
);
231 memcached_free(clone
);
234 /* Can we init from struct? */
236 memcached_st declared_clone
;
238 memset(&declared_clone
, 0 , sizeof(memcached_st
));
239 clone
= memcached_clone(&declared_clone
, NULL
);
241 memcached_free(clone
);
244 /* Can we init from struct? */
246 memcached_st declared_clone
;
248 memset(&declared_clone
, 0 , sizeof(memcached_st
));
249 clone
= memcached_clone(&declared_clone
, memc
);
251 memcached_free(clone
);
257 static test_return
connection_test(memcached_st
*memc
)
261 rc
= memcached_server_add_with_weight(memc
, "localhost", 0, 0);
262 assert(rc
== MEMCACHED_SUCCESS
);
267 static test_return
error_test(memcached_st
*memc
)
271 for (rc
= MEMCACHED_SUCCESS
; rc
< MEMCACHED_MAXIMUM_RETURN
; rc
++)
273 printf("Error %d -> %s\n", rc
, memcached_strerror(memc
, rc
));
279 static test_return
set_test(memcached_st
*memc
)
283 char *value
= "when we sanitize";
285 rc
= memcached_set(memc
, key
, strlen(key
),
286 value
, strlen(value
),
287 (time_t)0, (uint32_t)0);
288 assert(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
);
293 static test_return
append_test(memcached_st
*memc
)
301 rc
= memcached_flush(memc
, 0);
302 assert(rc
== MEMCACHED_SUCCESS
);
304 rc
= memcached_set(memc
, key
, strlen(key
),
305 value
, strlen(value
),
306 (time_t)0, (uint32_t)0);
307 assert(rc
== MEMCACHED_SUCCESS
);
309 rc
= memcached_append(memc
, key
, strlen(key
),
310 " the", strlen(" the"),
311 (time_t)0, (uint32_t)0);
312 assert(rc
== MEMCACHED_SUCCESS
);
314 rc
= memcached_append(memc
, key
, strlen(key
),
315 " people", strlen(" people"),
316 (time_t)0, (uint32_t)0);
317 assert(rc
== MEMCACHED_SUCCESS
);
319 value
= memcached_get(memc
, key
, strlen(key
),
320 &value_length
, &flags
, &rc
);
321 assert(!memcmp(value
, "we the people", strlen("we the people")));
322 assert(strlen("we the people") == value_length
);
323 assert(rc
== MEMCACHED_SUCCESS
);
329 static test_return
append_binary_test(memcached_st
*memc
)
332 char *key
= "numbers";
333 unsigned int *store_ptr
;
334 unsigned int store_list
[] = { 23, 56, 499, 98, 32847, 0 };
340 rc
= memcached_flush(memc
, 0);
341 assert(rc
== MEMCACHED_SUCCESS
);
343 rc
= memcached_set(memc
,
346 (time_t)0, (uint32_t)0);
347 assert(rc
== MEMCACHED_SUCCESS
);
349 for (x
= 0; store_list
[x
] ; x
++)
351 rc
= memcached_append(memc
,
353 (char *)&store_list
[x
], sizeof(unsigned int),
354 (time_t)0, (uint32_t)0);
355 assert(rc
== MEMCACHED_SUCCESS
);
358 value
= memcached_get(memc
, key
, strlen(key
),
359 &value_length
, &flags
, &rc
);
360 assert((value_length
== (sizeof(unsigned int) * x
)));
361 assert(rc
== MEMCACHED_SUCCESS
);
363 store_ptr
= (unsigned int *)value
;
365 while ((size_t)store_ptr
< (size_t)(value
+ value_length
))
367 assert(*store_ptr
== store_list
[x
++]);
375 static test_return
cas2_test(memcached_st
*memc
)
378 char *keys
[]= {"fudge", "son", "food"};
379 size_t key_length
[]= {5, 3, 4};
380 char *value
= "we the people";
381 size_t value_length
= strlen("we the people");
383 memcached_result_st results_obj
;
384 memcached_result_st
*results
;
387 rc
= memcached_flush(memc
, 0);
388 assert(rc
== MEMCACHED_SUCCESS
);
390 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_SUPPORT_CAS
, set
);
392 for (x
= 0; x
< 3; x
++)
394 rc
= memcached_set(memc
, keys
[x
], key_length
[x
],
395 keys
[x
], key_length
[x
],
396 (time_t)50, (uint32_t)9);
397 assert(rc
== MEMCACHED_SUCCESS
);
400 rc
= memcached_mget(memc
, keys
, key_length
, 3);
402 results
= memcached_result_create(memc
, &results_obj
);
404 results
= memcached_fetch_result(memc
, &results_obj
, &rc
);
406 assert(results
->cas
);
407 assert(rc
== MEMCACHED_SUCCESS
);
408 WATCHPOINT_ASSERT(memcached_result_cas(results
));
410 assert(!memcmp(value
, "we the people", strlen("we the people")));
411 assert(strlen("we the people") == value_length
);
412 assert(rc
== MEMCACHED_SUCCESS
);
414 memcached_result_free(&results_obj
);
419 static test_return
cas_test(memcached_st
*memc
)
422 const char *key
= "fun";
423 size_t key_length
= strlen(key
);
424 const char *value
= "we the people";
425 char* keys
[2] = { (char*)key
, NULL
};
426 size_t keylengths
[2] = { strlen(key
), 0 };
427 size_t value_length
= strlen(value
);
428 const char *value2
= "change the value";
429 size_t value2_length
= strlen(value2
);
431 memcached_result_st results_obj
;
432 memcached_result_st
*results
;
435 rc
= memcached_flush(memc
, 0);
436 assert(rc
== MEMCACHED_SUCCESS
);
438 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_SUPPORT_CAS
, set
);
440 rc
= memcached_set(memc
, key
, strlen(key
),
441 value
, strlen(value
),
442 (time_t)0, (uint32_t)0);
443 assert(rc
== MEMCACHED_SUCCESS
);
445 rc
= memcached_mget(memc
, keys
, keylengths
, 1);
447 results
= memcached_result_create(memc
, &results_obj
);
449 results
= memcached_fetch_result(memc
, &results_obj
, &rc
);
451 assert(rc
== MEMCACHED_SUCCESS
);
452 WATCHPOINT_ASSERT(memcached_result_cas(results
));
453 assert(!memcmp(value
, memcached_result_value(results
), value_length
));
454 assert(strlen(memcached_result_value(results
)) == value_length
);
455 assert(rc
== MEMCACHED_SUCCESS
);
456 uint64_t cas
= memcached_result_cas(results
);
459 results
= memcached_fetch_result(memc
, &results_obj
, &rc
);
460 assert(rc
== MEMCACHED_END
);
461 assert(results
== NULL
);
464 rc
= memcached_cas(memc
, key
, key_length
, value2
, value2_length
, 0, 0, cas
);
465 assert(rc
== MEMCACHED_SUCCESS
);
468 * The item will have a new cas value, so try to set it again with the old
469 * value. This should fail!
471 rc
= memcached_cas(memc
, key
, key_length
, value2
, value2_length
, 0, 0, cas
);
472 assert(rc
== MEMCACHED_DATA_EXISTS
);
474 memcached_result_free(&results_obj
);
479 static test_return
prepend_test(memcached_st
*memc
)
483 char *value
= "people";
487 rc
= memcached_flush(memc
, 0);
488 assert(rc
== MEMCACHED_SUCCESS
);
490 rc
= memcached_set(memc
, key
, strlen(key
),
491 value
, strlen(value
),
492 (time_t)0, (uint32_t)0);
493 assert(rc
== MEMCACHED_SUCCESS
);
495 rc
= memcached_prepend(memc
, key
, strlen(key
),
496 "the ", strlen("the "),
497 (time_t)0, (uint32_t)0);
498 assert(rc
== MEMCACHED_SUCCESS
);
500 rc
= memcached_prepend(memc
, key
, strlen(key
),
501 "we ", strlen("we "),
502 (time_t)0, (uint32_t)0);
503 assert(rc
== MEMCACHED_SUCCESS
);
505 value
= memcached_get(memc
, key
, strlen(key
),
506 &value_length
, &flags
, &rc
);
507 assert(!memcmp(value
, "we the people", strlen("we the people")));
508 assert(strlen("we the people") == value_length
);
509 assert(rc
== MEMCACHED_SUCCESS
);
516 Set the value, then quit to make sure it is flushed.
517 Come back in and test that add fails.
519 static test_return
add_test(memcached_st
*memc
)
523 char *value
= "when we sanitize";
524 unsigned long long setting_value
;
526 setting_value
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_NO_BLOCK
);
528 rc
= memcached_set(memc
, key
, strlen(key
),
529 value
, strlen(value
),
530 (time_t)0, (uint32_t)0);
531 assert(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
);
532 memcached_quit(memc
);
533 rc
= memcached_add(memc
, key
, strlen(key
),
534 value
, strlen(value
),
535 (time_t)0, (uint32_t)0);
537 /* Too many broken OS'es have broken loopback in async, so we can't be sure of the result */
539 assert(rc
== MEMCACHED_NOTSTORED
|| rc
== MEMCACHED_STORED
);
541 assert(rc
== MEMCACHED_NOTSTORED
|| rc
== MEMCACHED_DATA_EXISTS
);
547 ** There was a problem of leaking filedescriptors in the initial release
548 ** of MacOSX 10.5. This test case triggers the problem. On some Solaris
549 ** systems it seems that the kernel is slow on reclaiming the resources
550 ** because the connects starts to time out (the test doesn't do much
551 ** anyway, so just loop 10 iterations)
553 static test_return
add_wrapper(memcached_st
*memc
)
556 unsigned int max
= 10000;
561 for (x
= 0; x
< max
; x
++)
567 static test_return
replace_test(memcached_st
*memc
)
571 char *value
= "when we sanitize";
572 char *original
= "first we insert some data";
574 rc
= memcached_set(memc
, key
, strlen(key
),
575 original
, strlen(original
),
576 (time_t)0, (uint32_t)0);
577 assert(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
);
579 rc
= memcached_replace(memc
, key
, strlen(key
),
580 value
, strlen(value
),
581 (time_t)0, (uint32_t)0);
582 assert(rc
== MEMCACHED_SUCCESS
);
587 static test_return
delete_test(memcached_st
*memc
)
591 char *value
= "when we sanitize";
593 rc
= memcached_set(memc
, key
, strlen(key
),
594 value
, strlen(value
),
595 (time_t)0, (uint32_t)0);
596 assert(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
);
598 rc
= memcached_delete(memc
, key
, strlen(key
), (time_t)0);
599 assert(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
);
604 static test_return
flush_test(memcached_st
*memc
)
608 rc
= memcached_flush(memc
, 0);
609 assert(rc
== MEMCACHED_SUCCESS
);
614 static memcached_return
server_function(memcached_st
*ptr
__attribute__((unused
)),
615 memcached_server_st
*server
__attribute__((unused
)),
616 void *context
__attribute__((unused
)))
620 return MEMCACHED_SUCCESS
;
623 static test_return
memcached_server_cursor_test(memcached_st
*memc
)
625 char *context
= "foo bad";
626 memcached_server_function callbacks
[1];
628 callbacks
[0]= server_function
;
629 memcached_server_cursor(memc
, callbacks
, context
, 1);
634 static test_return
bad_key_test(memcached_st
*memc
)
637 char *key
= "foo bad";
639 size_t string_length
;
643 size_t max_keylen
= 0xffff;
645 clone
= memcached_clone(NULL
, memc
);
648 rc
= memcached_behavior_set(clone
, MEMCACHED_BEHAVIOR_VERIFY_KEY
, set
);
649 assert(rc
== MEMCACHED_SUCCESS
);
651 /* All keys are valid in the binary protocol (except for length) */
652 if (memcached_behavior_get(clone
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
) == 0)
654 string
= memcached_get(clone
, key
, strlen(key
),
655 &string_length
, &flags
, &rc
);
656 assert(rc
== MEMCACHED_BAD_KEY_PROVIDED
);
657 assert(string_length
== 0);
661 rc
= memcached_behavior_set(clone
, MEMCACHED_BEHAVIOR_VERIFY_KEY
, set
);
662 assert(rc
== MEMCACHED_SUCCESS
);
663 string
= memcached_get(clone
, key
, strlen(key
),
664 &string_length
, &flags
, &rc
);
665 assert(rc
== MEMCACHED_NOTFOUND
);
666 assert(string_length
== 0);
669 /* Test multi key for bad keys */
670 char *keys
[] = { "GoodKey", "Bad Key", "NotMine" };
671 size_t key_lengths
[] = { 7, 7, 7 };
673 rc
= memcached_behavior_set(clone
, MEMCACHED_BEHAVIOR_VERIFY_KEY
, set
);
674 assert(rc
== MEMCACHED_SUCCESS
);
676 rc
= memcached_mget(clone
, keys
, key_lengths
, 3);
677 assert(rc
== MEMCACHED_BAD_KEY_PROVIDED
);
679 rc
= memcached_mget_by_key(clone
, "foo daddy", 9, keys
, key_lengths
, 1);
680 assert(rc
== MEMCACHED_BAD_KEY_PROVIDED
);
684 /* The following test should be moved to the end of this function when the
685 memcached server is updated to allow max size length of the keys in the
688 rc
= memcached_callback_set(clone
, MEMCACHED_CALLBACK_PREFIX_KEY
, NULL
);
689 assert(rc
== MEMCACHED_SUCCESS
);
691 char *longkey
= malloc(max_keylen
+ 1);
694 memset(longkey
, 'a', max_keylen
+ 1);
695 string
= memcached_get(clone
, longkey
, max_keylen
,
696 &string_length
, &flags
, &rc
);
697 assert(rc
== MEMCACHED_NOTFOUND
);
698 assert(string_length
== 0);
701 string
= memcached_get(clone
, longkey
, max_keylen
+ 1,
702 &string_length
, &flags
, &rc
);
703 assert(rc
== MEMCACHED_BAD_KEY_PROVIDED
);
704 assert(string_length
== 0);
711 /* Make sure zero length keys are marked as bad */
713 rc
= memcached_behavior_set(clone
, MEMCACHED_BEHAVIOR_VERIFY_KEY
, set
);
714 assert(rc
== MEMCACHED_SUCCESS
);
715 string
= memcached_get(clone
, key
, 0,
716 &string_length
, &flags
, &rc
);
717 assert(rc
== MEMCACHED_BAD_KEY_PROVIDED
);
718 assert(string_length
== 0);
721 memcached_free(clone
);
726 #define READ_THROUGH_VALUE "set for me"
727 static memcached_return
read_through_trigger(memcached_st
*memc
__attribute__((unused
)),
728 char *key
__attribute__((unused
)),
729 size_t key_length
__attribute__((unused
)),
730 memcached_result_st
*result
)
733 return memcached_result_set_value(result
, READ_THROUGH_VALUE
, strlen(READ_THROUGH_VALUE
));
736 static test_return
read_through(memcached_st
*memc
)
741 size_t string_length
;
744 string
= memcached_get(memc
, key
, strlen(key
),
745 &string_length
, &flags
, &rc
);
747 assert(rc
== MEMCACHED_NOTFOUND
);
748 assert(string_length
== 0);
751 rc
= memcached_callback_set(memc
, MEMCACHED_CALLBACK_GET_FAILURE
, (void *)read_through_trigger
);
752 assert(rc
== MEMCACHED_SUCCESS
);
754 string
= memcached_get(memc
, key
, strlen(key
),
755 &string_length
, &flags
, &rc
);
757 assert(rc
== MEMCACHED_SUCCESS
);
758 assert(string_length
== strlen(READ_THROUGH_VALUE
));
759 assert(!strcmp(READ_THROUGH_VALUE
, string
));
762 string
= memcached_get(memc
, key
, strlen(key
),
763 &string_length
, &flags
, &rc
);
765 assert(rc
== MEMCACHED_SUCCESS
);
766 assert(string_length
== strlen(READ_THROUGH_VALUE
));
767 assert(!strcmp(READ_THROUGH_VALUE
, string
));
773 static memcached_return
delete_trigger(memcached_st
*ptr
__attribute__((unused
)),
775 size_t key_length
__attribute__((unused
)))
779 return MEMCACHED_SUCCESS
;
782 static test_return
delete_through(memcached_st
*memc
)
784 memcached_trigger_delete_key callback
;
787 callback
= delete_trigger
;
789 rc
= memcached_callback_set(memc
, MEMCACHED_CALLBACK_DELETE_TRIGGER
, (void*)callback
);
790 assert(rc
== MEMCACHED_SUCCESS
);
795 static test_return
get_test(memcached_st
*memc
)
800 size_t string_length
;
803 rc
= memcached_delete(memc
, key
, strlen(key
), (time_t)0);
804 assert(rc
== MEMCACHED_BUFFERED
|| rc
== MEMCACHED_NOTFOUND
);
806 string
= memcached_get(memc
, key
, strlen(key
),
807 &string_length
, &flags
, &rc
);
809 assert(rc
== MEMCACHED_NOTFOUND
);
810 assert(string_length
== 0);
816 static test_return
get_test2(memcached_st
*memc
)
820 char *value
= "when we sanitize";
822 size_t string_length
;
825 rc
= memcached_set(memc
, key
, strlen(key
),
826 value
, strlen(value
),
827 (time_t)0, (uint32_t)0);
828 assert(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
);
830 string
= memcached_get(memc
, key
, strlen(key
),
831 &string_length
, &flags
, &rc
);
834 assert(rc
== MEMCACHED_SUCCESS
);
835 assert(string_length
== strlen(value
));
836 assert(!memcmp(string
, value
, string_length
));
843 static test_return
set_test2(memcached_st
*memc
)
847 char *value
= "train in the brain";
848 size_t value_length
= strlen(value
);
851 for (x
= 0; x
< 10; x
++)
853 rc
= memcached_set(memc
, key
, strlen(key
),
855 (time_t)0, (uint32_t)0);
856 assert(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
);
862 static test_return
set_test3(memcached_st
*memc
)
867 size_t value_length
= 8191;
870 value
= (char*)malloc(value_length
);
873 for (x
= 0; x
< value_length
; x
++)
874 value
[x
] = (char) (x
% 127);
876 for (x
= 0; x
< 1; x
++)
878 rc
= memcached_set(memc
, key
, strlen(key
),
880 (time_t)0, (uint32_t)0);
881 assert(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
);
889 static test_return
get_test3(memcached_st
*memc
)
894 size_t value_length
= 8191;
896 size_t string_length
;
900 value
= (char*)malloc(value_length
);
903 for (x
= 0; x
< value_length
; x
++)
904 value
[x
] = (char) (x
% 127);
906 rc
= memcached_set(memc
, key
, strlen(key
),
908 (time_t)0, (uint32_t)0);
909 assert(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
);
911 string
= memcached_get(memc
, key
, strlen(key
),
912 &string_length
, &flags
, &rc
);
914 assert(rc
== MEMCACHED_SUCCESS
);
916 assert(string_length
== value_length
);
917 assert(!memcmp(string
, value
, string_length
));
925 static test_return
get_test4(memcached_st
*memc
)
930 size_t value_length
= 8191;
932 size_t string_length
;
936 value
= (char*)malloc(value_length
);
939 for (x
= 0; x
< value_length
; x
++)
940 value
[x
] = (char) (x
% 127);
942 rc
= memcached_set(memc
, key
, strlen(key
),
944 (time_t)0, (uint32_t)0);
945 assert(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
);
947 for (x
= 0; x
< 10; x
++)
949 string
= memcached_get(memc
, key
, strlen(key
),
950 &string_length
, &flags
, &rc
);
952 assert(rc
== MEMCACHED_SUCCESS
);
954 assert(string_length
== value_length
);
955 assert(!memcmp(string
, value
, string_length
));
965 * This test verifies that memcached_read_one_response doesn't try to
966 * dereference a NIL-pointer if you issue a multi-get and don't read out all
967 * responses before you execute a storage command.
969 static test_return
get_test5(memcached_st
*memc
)
972 ** Request the same key twice, to ensure that we hash to the same server
973 ** (so that we have multiple response values queued up) ;-)
975 char *keys
[]= { "key", "key" };
976 size_t lengths
[]= { 3, 3 };
980 memcached_return rc
= memcached_set(memc
, keys
[0], lengths
[0],
981 keys
[0], lengths
[0], 0, 0);
982 assert(rc
== MEMCACHED_SUCCESS
);
983 rc
= memcached_mget(memc
, keys
, lengths
, 2);
985 memcached_result_st results_obj
;
986 memcached_result_st
*results
;
987 results
=memcached_result_create(memc
, &results_obj
);
989 results
=memcached_fetch_result(memc
, &results_obj
, &rc
);
991 memcached_result_free(&results_obj
);
993 /* Don't read out the second result, but issue a set instead.. */
994 rc
= memcached_set(memc
, keys
[0], lengths
[0], keys
[0], lengths
[0], 0, 0);
995 assert(rc
== MEMCACHED_SUCCESS
);
997 char *val
= memcached_get_by_key(memc
, keys
[0], lengths
[0], "yek", 3,
1000 assert(rc
== MEMCACHED_NOTFOUND
);
1001 val
= memcached_get(memc
, keys
[0], lengths
[0], &rlen
, &flags
, &rc
);
1002 assert(val
!= NULL
);
1003 assert(rc
== MEMCACHED_SUCCESS
);
1006 return TEST_SUCCESS
;
1009 /* Do not copy the style of this code, I just access hosts to testthis function */
1010 static test_return
stats_servername_test(memcached_st
*memc
)
1012 memcached_return rc
;
1013 memcached_stat_st stat
;
1014 rc
= memcached_stat_servername(&stat
, NULL
,
1015 memc
->hosts
[0].hostname
,
1016 memc
->hosts
[0].port
);
1021 static test_return
increment_test(memcached_st
*memc
)
1023 uint64_t new_number
;
1024 memcached_return rc
;
1025 char *key
= "number";
1028 rc
= memcached_set(memc
, key
, strlen(key
),
1029 value
, strlen(value
),
1030 (time_t)0, (uint32_t)0);
1031 assert(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
);
1033 rc
= memcached_increment(memc
, key
, strlen(key
),
1035 assert(rc
== MEMCACHED_SUCCESS
);
1036 assert(new_number
== 1);
1038 rc
= memcached_increment(memc
, key
, strlen(key
),
1040 assert(rc
== MEMCACHED_SUCCESS
);
1041 assert(new_number
== 2);
1046 static test_return
increment_with_initial_test(memcached_st
*memc
)
1048 if (memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
) != 0)
1050 uint64_t new_number
;
1051 memcached_return rc
;
1052 char *key
= "number";
1053 uint64_t initial
= 0;
1055 rc
= memcached_increment_with_initial(memc
, key
, strlen(key
),
1056 1, initial
, 0, &new_number
);
1057 assert(rc
== MEMCACHED_SUCCESS
);
1058 assert(new_number
== initial
);
1060 rc
= memcached_increment_with_initial(memc
, key
, strlen(key
),
1061 1, initial
, 0, &new_number
);
1062 assert(rc
== MEMCACHED_SUCCESS
);
1063 assert(new_number
== (initial
+ 1));
1068 static test_return
decrement_test(memcached_st
*memc
)
1070 uint64_t new_number
;
1071 memcached_return rc
;
1072 char *key
= "number";
1075 rc
= memcached_set(memc
, key
, strlen(key
),
1076 value
, strlen(value
),
1077 (time_t)0, (uint32_t)0);
1078 assert(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
);
1080 rc
= memcached_decrement(memc
, key
, strlen(key
),
1082 assert(rc
== MEMCACHED_SUCCESS
);
1083 assert(new_number
== 2);
1085 rc
= memcached_decrement(memc
, key
, strlen(key
),
1087 assert(rc
== MEMCACHED_SUCCESS
);
1088 assert(new_number
== 1);
1093 static test_return
decrement_with_initial_test(memcached_st
*memc
)
1095 if (memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
) != 0)
1097 uint64_t new_number
;
1098 memcached_return rc
;
1099 char *key
= "number";
1100 uint64_t initial
= 3;
1102 rc
= memcached_decrement_with_initial(memc
, key
, strlen(key
),
1103 1, initial
, 0, &new_number
);
1104 assert(rc
== MEMCACHED_SUCCESS
);
1105 assert(new_number
== initial
);
1107 rc
= memcached_decrement_with_initial(memc
, key
, strlen(key
),
1108 1, initial
, 0, &new_number
);
1109 assert(rc
== MEMCACHED_SUCCESS
);
1110 assert(new_number
== (initial
- 1));
1115 static test_return
quit_test(memcached_st
*memc
)
1117 memcached_return rc
;
1119 char *value
= "sanford and sun";
1121 rc
= memcached_set(memc
, key
, strlen(key
),
1122 value
, strlen(value
),
1123 (time_t)10, (uint32_t)3);
1124 assert(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
);
1125 memcached_quit(memc
);
1127 rc
= memcached_set(memc
, key
, strlen(key
),
1128 value
, strlen(value
),
1129 (time_t)50, (uint32_t)9);
1130 assert(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
);
1135 static test_return
mget_result_test(memcached_st
*memc
)
1137 memcached_return rc
;
1138 char *keys
[]= {"fudge", "son", "food"};
1139 size_t key_length
[]= {5, 3, 4};
1142 memcached_result_st results_obj
;
1143 memcached_result_st
*results
;
1145 results
= memcached_result_create(memc
, &results_obj
);
1147 assert(&results_obj
== results
);
1149 /* We need to empty the server before continueing test */
1150 rc
= memcached_flush(memc
, 0);
1151 assert(rc
== MEMCACHED_SUCCESS
);
1153 rc
= memcached_mget(memc
, keys
, key_length
, 3);
1154 assert(rc
== MEMCACHED_SUCCESS
);
1156 while ((results
= memcached_fetch_result(memc
, &results_obj
, &rc
)) != NULL
)
1161 while ((results
= memcached_fetch_result(memc
, &results_obj
, &rc
)) != NULL
)
1163 assert(rc
== MEMCACHED_END
);
1165 for (x
= 0; x
< 3; x
++)
1167 rc
= memcached_set(memc
, keys
[x
], key_length
[x
],
1168 keys
[x
], key_length
[x
],
1169 (time_t)50, (uint32_t)9);
1170 assert(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
);
1173 rc
= memcached_mget(memc
, keys
, key_length
, 3);
1174 assert(rc
== MEMCACHED_SUCCESS
);
1176 while ((results
= memcached_fetch_result(memc
, &results_obj
, &rc
)))
1179 assert(&results_obj
== results
);
1180 assert(rc
== MEMCACHED_SUCCESS
);
1181 assert(memcached_result_key_length(results
) == memcached_result_length(results
));
1182 assert(!memcmp(memcached_result_key_value(results
),
1183 memcached_result_value(results
),
1184 memcached_result_length(results
)));
1187 memcached_result_free(&results_obj
);
1192 static test_return
mget_result_alloc_test(memcached_st
*memc
)
1194 memcached_return rc
;
1195 char *keys
[]= {"fudge", "son", "food"};
1196 size_t key_length
[]= {5, 3, 4};
1199 memcached_result_st
*results
;
1201 /* We need to empty the server before continueing test */
1202 rc
= memcached_flush(memc
, 0);
1203 assert(rc
== MEMCACHED_SUCCESS
);
1205 rc
= memcached_mget(memc
, keys
, key_length
, 3);
1206 assert(rc
== MEMCACHED_SUCCESS
);
1208 while ((results
= memcached_fetch_result(memc
, NULL
, &rc
)) != NULL
)
1213 assert(rc
== MEMCACHED_END
);
1215 for (x
= 0; x
< 3; x
++)
1217 rc
= memcached_set(memc
, keys
[x
], key_length
[x
],
1218 keys
[x
], key_length
[x
],
1219 (time_t)50, (uint32_t)9);
1220 assert(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
);
1223 rc
= memcached_mget(memc
, keys
, key_length
, 3);
1224 assert(rc
== MEMCACHED_SUCCESS
);
1227 while ((results
= memcached_fetch_result(memc
, NULL
, &rc
)))
1230 assert(rc
== MEMCACHED_SUCCESS
);
1231 assert(memcached_result_key_length(results
) == memcached_result_length(results
));
1232 assert(!memcmp(memcached_result_key_value(results
),
1233 memcached_result_value(results
),
1234 memcached_result_length(results
)));
1235 memcached_result_free(results
);
1242 /* Count the results */
1243 static memcached_return
callback_counter(memcached_st
*ptr
__attribute__((unused
)),
1244 memcached_result_st
*result
__attribute__((unused
)),
1247 unsigned int *counter
= (unsigned int *)context
;
1249 *counter
= *counter
+ 1;
1251 return MEMCACHED_SUCCESS
;
1254 static test_return
mget_result_function(memcached_st
*memc
)
1256 memcached_return rc
;
1257 char *keys
[]= {"fudge", "son", "food"};
1258 size_t key_length
[]= {5, 3, 4};
1260 unsigned int counter
;
1261 memcached_execute_function callbacks
[1];
1263 /* We need to empty the server before continueing test */
1264 rc
= memcached_flush(memc
, 0);
1265 for (x
= 0; x
< 3; x
++)
1267 rc
= memcached_set(memc
, keys
[x
], key_length
[x
],
1268 keys
[x
], key_length
[x
],
1269 (time_t)50, (uint32_t)9);
1270 assert(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
);
1273 rc
= memcached_mget(memc
, keys
, key_length
, 3);
1274 assert(rc
== MEMCACHED_SUCCESS
);
1276 callbacks
[0]= &callback_counter
;
1278 rc
= memcached_fetch_execute(memc
, callbacks
, (void *)&counter
, 1);
1280 assert(counter
== 3);
1285 static test_return
mget_test(memcached_st
*memc
)
1287 memcached_return rc
;
1288 char *keys
[]= {"fudge", "son", "food"};
1289 size_t key_length
[]= {5, 3, 4};
1293 char return_key
[MEMCACHED_MAX_KEY
];
1294 size_t return_key_length
;
1296 size_t return_value_length
;
1298 /* We need to empty the server before continueing test */
1299 rc
= memcached_flush(memc
, 0);
1300 assert(rc
== MEMCACHED_SUCCESS
);
1302 rc
= memcached_mget(memc
, keys
, key_length
, 3);
1303 assert(rc
== MEMCACHED_SUCCESS
);
1305 while ((return_value
= memcached_fetch(memc
, return_key
, &return_key_length
,
1306 &return_value_length
, &flags
, &rc
)) != NULL
)
1308 assert(return_value
);
1310 assert(!return_value
);
1311 assert(return_value_length
== 0);
1312 assert(rc
== MEMCACHED_END
);
1314 for (x
= 0; x
< 3; x
++)
1316 rc
= memcached_set(memc
, keys
[x
], key_length
[x
],
1317 keys
[x
], key_length
[x
],
1318 (time_t)50, (uint32_t)9);
1319 assert(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
);
1322 rc
= memcached_mget(memc
, keys
, key_length
, 3);
1323 assert(rc
== MEMCACHED_SUCCESS
);
1326 while ((return_value
= memcached_fetch(memc
, return_key
, &return_key_length
,
1327 &return_value_length
, &flags
, &rc
)))
1329 assert(return_value
);
1330 assert(rc
== MEMCACHED_SUCCESS
);
1331 assert(return_key_length
== return_value_length
);
1332 assert(!memcmp(return_value
, return_key
, return_value_length
));
1340 static test_return
get_stats_keys(memcached_st
*memc
)
1344 memcached_stat_st stat
;
1345 memcached_return rc
;
1347 list
= memcached_stat_get_keys(memc
, &stat
, &rc
);
1348 assert(rc
== MEMCACHED_SUCCESS
);
1349 for (ptr
= list
; *ptr
; ptr
++)
1358 static test_return
version_string_test(memcached_st
*memc
__attribute__((unused
)))
1360 const char *version_string
;
1362 version_string
= memcached_lib_version();
1364 assert(!strcmp(version_string
, LIBMEMCACHED_VERSION_STRING
));
1369 static test_return
get_stats(memcached_st
*memc
)
1374 memcached_return rc
;
1375 memcached_stat_st
*stat
;
1377 stat
= memcached_stat(memc
, NULL
, &rc
);
1378 assert(rc
== MEMCACHED_SUCCESS
);
1380 assert(rc
== MEMCACHED_SUCCESS
);
1383 for (x
= 0; x
< memcached_server_count(memc
); x
++)
1385 list
= memcached_stat_get_keys(memc
, stat
+x
, &rc
);
1386 assert(rc
== MEMCACHED_SUCCESS
);
1387 for (ptr
= list
; *ptr
; ptr
++);
1392 memcached_stat_free(NULL
, stat
);
1397 static test_return
add_host_test(memcached_st
*memc
)
1400 memcached_server_st
*servers
;
1401 memcached_return rc
;
1402 char servername
[]= "0.example.com";
1404 servers
= memcached_server_list_append_with_weight(NULL
, servername
, 400, 0, &rc
);
1406 assert(1 == memcached_server_list_count(servers
));
1408 for (x
= 2; x
< 20; x
++)
1410 char buffer
[SMALL_STRING_LEN
];
1412 snprintf(buffer
, SMALL_STRING_LEN
, "%u.example.com", 400+x
);
1413 servers
= memcached_server_list_append_with_weight(servers
, buffer
, 401, 0,
1415 assert(rc
== MEMCACHED_SUCCESS
);
1416 assert(x
== memcached_server_list_count(servers
));
1419 rc
= memcached_server_push(memc
, servers
);
1420 assert(rc
== MEMCACHED_SUCCESS
);
1421 rc
= memcached_server_push(memc
, servers
);
1422 assert(rc
== MEMCACHED_SUCCESS
);
1424 memcached_server_list_free(servers
);
1429 static memcached_return
clone_test_callback(memcached_st
*parent
__attribute__((unused
)), memcached_st
*clone
__attribute__((unused
)))
1431 return MEMCACHED_SUCCESS
;
1434 static memcached_return
cleanup_test_callback(memcached_st
*ptr
__attribute__((unused
)))
1436 return MEMCACHED_SUCCESS
;
1439 static test_return
callback_test(memcached_st
*memc
)
1441 /* Test User Data */
1445 memcached_return rc
;
1447 rc
= memcached_callback_set(memc
, MEMCACHED_CALLBACK_USER_DATA
, &x
);
1448 assert(rc
== MEMCACHED_SUCCESS
);
1449 test_ptr
= (int *)memcached_callback_get(memc
, MEMCACHED_CALLBACK_USER_DATA
, &rc
);
1450 assert(*test_ptr
== x
);
1453 /* Test Clone Callback */
1455 memcached_clone_func temp_function
;
1456 memcached_return rc
;
1458 rc
= memcached_callback_set(memc
, MEMCACHED_CALLBACK_CLONE_FUNCTION
, (void*)clone_test_callback
);
1459 assert(rc
== MEMCACHED_SUCCESS
);
1460 temp_function
= (memcached_clone_func
)memcached_callback_get(memc
, MEMCACHED_CALLBACK_CLONE_FUNCTION
, &rc
);
1461 assert(temp_function
== clone_test_callback
);
1464 /* Test Cleanup Callback */
1466 memcached_cleanup_func temp_function
;
1467 memcached_return rc
;
1469 rc
= memcached_callback_set(memc
, MEMCACHED_CALLBACK_CLONE_FUNCTION
, (void*)cleanup_test_callback
);
1470 assert(rc
== MEMCACHED_SUCCESS
);
1471 temp_function
= (memcached_cleanup_func
)memcached_callback_get(memc
, MEMCACHED_CALLBACK_CLONE_FUNCTION
, &rc
);
1472 assert(temp_function
== cleanup_test_callback
);
1478 /* We don't test the behavior itself, we test the switches */
1479 static test_return
behavior_test(memcached_st
*memc
)
1484 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NO_BLOCK
, set
);
1485 value
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_NO_BLOCK
);
1488 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_TCP_NODELAY
, set
);
1489 value
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_TCP_NODELAY
);
1492 set
= MEMCACHED_HASH_MD5
;
1493 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_HASH
, set
);
1494 value
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_HASH
);
1495 assert(value
== MEMCACHED_HASH_MD5
);
1499 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NO_BLOCK
, set
);
1500 value
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_NO_BLOCK
);
1503 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_TCP_NODELAY
, set
);
1504 value
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_TCP_NODELAY
);
1507 set
= MEMCACHED_HASH_DEFAULT
;
1508 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_HASH
, set
);
1509 value
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_HASH
);
1510 assert(value
== MEMCACHED_HASH_DEFAULT
);
1512 set
= MEMCACHED_HASH_CRC
;
1513 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_HASH
, set
);
1514 value
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_HASH
);
1515 assert(value
== MEMCACHED_HASH_CRC
);
1517 value
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_SOCKET_SEND_SIZE
);
1520 value
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_SOCKET_RECV_SIZE
);
1526 /* Test case provided by Cal Haldenbrand */
1527 static test_return
user_supplied_bug1(memcached_st
*memc
)
1529 unsigned int setter
= 1;
1532 unsigned long long total
= 0;
1535 char randomstuff
[6 * 1024];
1536 memcached_return rc
;
1538 memset(randomstuff
, 0, 6 * 1024);
1540 /* We just keep looking at the same values over and over */
1543 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NO_BLOCK
, setter
);
1544 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_TCP_NODELAY
, setter
);
1548 for (x
= 0 ; total
< 20 * 1024576 ; x
++ )
1552 size
= (rand() % ( 5 * 1024 ) ) + 400;
1553 memset(randomstuff
, 0, 6 * 1024);
1554 assert(size
< 6 * 1024); /* Being safe here */
1556 for (j
= 0 ; j
< size
;j
++)
1557 randomstuff
[j
] = (char) (rand() % 26) + 97;
1560 sprintf(key
, "%d", x
);
1561 rc
= memcached_set(memc
, key
, strlen(key
),
1562 randomstuff
, strlen(randomstuff
), 10, 0);
1563 assert(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
);
1564 /* If we fail, lets try again */
1565 if (rc
!= MEMCACHED_SUCCESS
&& rc
!= MEMCACHED_BUFFERED
)
1566 rc
= memcached_set(memc
, key
, strlen(key
),
1567 randomstuff
, strlen(randomstuff
), 10, 0);
1568 assert(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
);
1574 /* Test case provided by Cal Haldenbrand */
1575 static test_return
user_supplied_bug2(memcached_st
*memc
)
1578 unsigned int setter
;
1580 unsigned long long total
;
1583 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NO_BLOCK
, setter
);
1584 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_TCP_NODELAY
, setter
);
1586 setter
= 20 * 1024576;
1587 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_SOCKET_SEND_SIZE
, setter
);
1588 setter
= 20 * 1024576;
1589 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_SOCKET_RECV_SIZE
, setter
);
1590 getter
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_SOCKET_SEND_SIZE
);
1591 getter
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_SOCKET_RECV_SIZE
);
1593 for (x
= 0, errors
= 0, total
= 0 ; total
< 20 * 1024576 ; x
++)
1596 for (x
= 0, errors
= 0, total
= 0 ; total
< 24576 ; x
++)
1598 memcached_return rc
= MEMCACHED_SUCCESS
;
1599 char buffer
[SMALL_STRING_LEN
];
1604 memset(buffer
, 0, SMALL_STRING_LEN
);
1606 snprintf(buffer
, SMALL_STRING_LEN
, "%u", x
);
1607 getval
= memcached_get(memc
, buffer
, strlen(buffer
),
1608 &val_len
, &flags
, &rc
);
1609 if (rc
!= MEMCACHED_SUCCESS
)
1611 if (rc
== MEMCACHED_NOTFOUND
)
1615 WATCHPOINT_ERROR(rc
);
1629 /* Do a large mget() over all the keys we think exist */
1630 #define KEY_COUNT 3000 // * 1024576
1631 static test_return
user_supplied_bug3(memcached_st
*memc
)
1633 memcached_return rc
;
1634 unsigned int setter
;
1637 size_t key_lengths
[KEY_COUNT
];
1640 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NO_BLOCK
, setter
);
1641 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_TCP_NODELAY
, setter
);
1643 setter
= 20 * 1024576;
1644 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_SOCKET_SEND_SIZE
, setter
);
1645 setter
= 20 * 1024576;
1646 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_SOCKET_RECV_SIZE
, setter
);
1647 getter
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_SOCKET_SEND_SIZE
);
1648 getter
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_SOCKET_RECV_SIZE
);
1651 keys
= (char **)malloc(sizeof(char *) * KEY_COUNT
);
1653 memset(keys
, 0, (sizeof(char *) * KEY_COUNT
));
1654 for (x
= 0; x
< KEY_COUNT
; x
++)
1658 snprintf(buffer
, 30, "%u", x
);
1659 keys
[x
]= strdup(buffer
);
1660 key_lengths
[x
]= strlen(keys
[x
]);
1663 rc
= memcached_mget(memc
, keys
, key_lengths
, KEY_COUNT
);
1664 assert(rc
== MEMCACHED_SUCCESS
);
1666 /* Turn this into a help function */
1668 char return_key
[MEMCACHED_MAX_KEY
];
1669 size_t return_key_length
;
1671 size_t return_value_length
;
1674 while ((return_value
= memcached_fetch(memc
, return_key
, &return_key_length
,
1675 &return_value_length
, &flags
, &rc
)))
1677 assert(return_value
);
1678 assert(rc
== MEMCACHED_SUCCESS
);
1683 for (x
= 0; x
< KEY_COUNT
; x
++)
1690 /* Make sure we behave properly if server list has no values */
1691 static test_return
user_supplied_bug4(memcached_st
*memc
)
1693 memcached_return rc
;
1694 char *keys
[]= {"fudge", "son", "food"};
1695 size_t key_length
[]= {5, 3, 4};
1698 char return_key
[MEMCACHED_MAX_KEY
];
1699 size_t return_key_length
;
1701 size_t return_value_length
;
1703 /* Here we free everything before running a bunch of mget tests */
1705 memcached_server_list_free(memc
->hosts
);
1707 memc
->number_of_hosts
= 0;
1711 /* We need to empty the server before continueing test */
1712 rc
= memcached_flush(memc
, 0);
1713 assert(rc
== MEMCACHED_NO_SERVERS
);
1715 rc
= memcached_mget(memc
, keys
, key_length
, 3);
1716 assert(rc
== MEMCACHED_NO_SERVERS
);
1718 while ((return_value
= memcached_fetch(memc
, return_key
, &return_key_length
,
1719 &return_value_length
, &flags
, &rc
)) != NULL
)
1721 assert(return_value
);
1723 assert(!return_value
);
1724 assert(return_value_length
== 0);
1725 assert(rc
== MEMCACHED_NO_SERVERS
);
1727 for (x
= 0; x
< 3; x
++)
1729 rc
= memcached_set(memc
, keys
[x
], key_length
[x
],
1730 keys
[x
], key_length
[x
],
1731 (time_t)50, (uint32_t)9);
1732 assert(rc
== MEMCACHED_NO_SERVERS
);
1735 rc
= memcached_mget(memc
, keys
, key_length
, 3);
1736 assert(rc
== MEMCACHED_NO_SERVERS
);
1739 while ((return_value
= memcached_fetch(memc
, return_key
, &return_key_length
,
1740 &return_value_length
, &flags
, &rc
)))
1742 assert(return_value
);
1743 assert(rc
== MEMCACHED_SUCCESS
);
1744 assert(return_key_length
== return_value_length
);
1745 assert(!memcmp(return_value
, return_key
, return_value_length
));
1753 #define VALUE_SIZE_BUG5 1048064
1754 static test_return
user_supplied_bug5(memcached_st
*memc
)
1756 memcached_return rc
;
1757 char *keys
[]= {"036790384900", "036790384902", "036790384904", "036790384906"};
1758 size_t key_length
[]= {strlen("036790384900"), strlen("036790384902"), strlen("036790384904"), strlen("036790384906")};
1759 char return_key
[MEMCACHED_MAX_KEY
];
1760 size_t return_key_length
;
1762 size_t value_length
;
1766 char insert_data
[VALUE_SIZE_BUG5
];
1768 for (x
= 0; x
< VALUE_SIZE_BUG5
; x
++)
1769 insert_data
[x
]= rand();
1771 memcached_flush(memc
, 0);
1772 value
= memcached_get(memc
, keys
[0], key_length
[0],
1773 &value_length
, &flags
, &rc
);
1774 assert(value
== NULL
);
1775 rc
= memcached_mget(memc
, keys
, key_length
, 4);
1778 while ((value
= memcached_fetch(memc
, return_key
, &return_key_length
,
1779 &value_length
, &flags
, &rc
)))
1783 for (x
= 0; x
< 4; x
++)
1785 rc
= memcached_set(memc
, keys
[x
], key_length
[x
],
1786 insert_data
, VALUE_SIZE_BUG5
,
1787 (time_t)0, (uint32_t)0);
1788 assert(rc
== MEMCACHED_SUCCESS
);
1791 for (x
= 0; x
< 10; x
++)
1793 value
= memcached_get(memc
, keys
[0], key_length
[0],
1794 &value_length
, &flags
, &rc
);
1798 rc
= memcached_mget(memc
, keys
, key_length
, 4);
1800 while ((value
= memcached_fetch(memc
, return_key
, &return_key_length
,
1801 &value_length
, &flags
, &rc
)))
1812 static test_return
user_supplied_bug6(memcached_st
*memc
)
1814 memcached_return rc
;
1815 char *keys
[]= {"036790384900", "036790384902", "036790384904", "036790384906"};
1816 size_t key_length
[]= {strlen("036790384900"), strlen("036790384902"), strlen("036790384904"), strlen("036790384906")};
1817 char return_key
[MEMCACHED_MAX_KEY
];
1818 size_t return_key_length
;
1820 size_t value_length
;
1824 char insert_data
[VALUE_SIZE_BUG5
];
1826 for (x
= 0; x
< VALUE_SIZE_BUG5
; x
++)
1827 insert_data
[x
]= rand();
1829 memcached_flush(memc
, 0);
1830 value
= memcached_get(memc
, keys
[0], key_length
[0],
1831 &value_length
, &flags
, &rc
);
1832 assert(value
== NULL
);
1833 assert(rc
== MEMCACHED_NOTFOUND
);
1834 rc
= memcached_mget(memc
, keys
, key_length
, 4);
1835 assert(rc
== MEMCACHED_SUCCESS
);
1838 while ((value
= memcached_fetch(memc
, return_key
, &return_key_length
,
1839 &value_length
, &flags
, &rc
)))
1842 assert(rc
== MEMCACHED_END
);
1844 for (x
= 0; x
< 4; x
++)
1846 rc
= memcached_set(memc
, keys
[x
], key_length
[x
],
1847 insert_data
, VALUE_SIZE_BUG5
,
1848 (time_t)0, (uint32_t)0);
1849 assert(rc
== MEMCACHED_SUCCESS
);
1852 for (x
= 0; x
< 2; x
++)
1854 value
= memcached_get(memc
, keys
[0], key_length
[0],
1855 &value_length
, &flags
, &rc
);
1859 rc
= memcached_mget(memc
, keys
, key_length
, 4);
1860 assert(rc
== MEMCACHED_SUCCESS
);
1862 /* We test for purge of partial complete fetches */
1863 for (count
= 3; count
; count
--)
1865 value
= memcached_fetch(memc
, return_key
, &return_key_length
,
1866 &value_length
, &flags
, &rc
);
1867 assert(rc
== MEMCACHED_SUCCESS
);
1868 assert(!(memcmp(value
, insert_data
, value_length
)));
1869 assert(value_length
);
1877 static test_return
user_supplied_bug8(memcached_st
*memc
__attribute__((unused
)))
1879 memcached_return rc
;
1881 memcached_st
*clone
;
1883 memcached_server_st
*servers
;
1884 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";
1886 servers
= memcached_servers_parse(server_list
);
1889 mine
= memcached_create(NULL
);
1890 rc
= memcached_server_push(mine
, servers
);
1891 assert(rc
== MEMCACHED_SUCCESS
);
1892 memcached_server_list_free(servers
);
1895 clone
= memcached_clone(NULL
, mine
);
1897 memcached_quit(mine
);
1898 memcached_quit(clone
);
1901 memcached_free(mine
);
1902 memcached_free(clone
);
1907 /* Test flag store/retrieve */
1908 static test_return
user_supplied_bug7(memcached_st
*memc
)
1910 memcached_return rc
;
1911 char *keys
= "036790384900";
1912 size_t key_length
= strlen("036790384900");
1913 char return_key
[MEMCACHED_MAX_KEY
];
1914 size_t return_key_length
;
1916 size_t value_length
;
1919 char insert_data
[VALUE_SIZE_BUG5
];
1921 for (x
= 0; x
< VALUE_SIZE_BUG5
; x
++)
1922 insert_data
[x
]= rand();
1924 memcached_flush(memc
, 0);
1927 rc
= memcached_set(memc
, keys
, key_length
,
1928 insert_data
, VALUE_SIZE_BUG5
,
1930 assert(rc
== MEMCACHED_SUCCESS
);
1933 value
= memcached_get(memc
, keys
, key_length
,
1934 &value_length
, &flags
, &rc
);
1935 assert(flags
== 245);
1939 rc
= memcached_mget(memc
, &keys
, &key_length
, 1);
1942 value
= memcached_fetch(memc
, return_key
, &return_key_length
,
1943 &value_length
, &flags
, &rc
);
1944 assert(flags
== 245);
1952 static test_return
user_supplied_bug9(memcached_st
*memc
)
1954 memcached_return rc
;
1955 char *keys
[]= {"UDATA:edevil@sapo.pt", "fudge&*@#", "for^#@&$not"};
1956 size_t key_length
[3];
1961 char return_key
[MEMCACHED_MAX_KEY
];
1962 size_t return_key_length
;
1964 size_t return_value_length
;
1967 key_length
[0]= strlen("UDATA:edevil@sapo.pt");
1968 key_length
[1]= strlen("fudge&*@#");
1969 key_length
[2]= strlen("for^#@&$not");
1972 for (x
= 0; x
< 3; x
++)
1974 rc
= memcached_set(memc
, keys
[x
], key_length
[x
],
1975 keys
[x
], key_length
[x
],
1976 (time_t)50, (uint32_t)9);
1977 assert(rc
== MEMCACHED_SUCCESS
);
1980 rc
= memcached_mget(memc
, keys
, key_length
, 3);
1981 assert(rc
== MEMCACHED_SUCCESS
);
1983 /* We need to empty the server before continueing test */
1984 while ((return_value
= memcached_fetch(memc
, return_key
, &return_key_length
,
1985 &return_value_length
, &flags
, &rc
)) != NULL
)
1987 assert(return_value
);
1996 /* We are testing with aggressive timeout to get failures */
1997 static test_return
user_supplied_bug10(memcached_st
*memc
)
2001 size_t value_length
= 512;
2004 memcached_return rc
;
2005 unsigned int set
= 1;
2006 memcached_st
*mclone
= memcached_clone(NULL
, memc
);
2009 memcached_behavior_set(mclone
, MEMCACHED_BEHAVIOR_NO_BLOCK
, set
);
2010 memcached_behavior_set(mclone
, MEMCACHED_BEHAVIOR_TCP_NODELAY
, set
);
2012 memcached_behavior_set(mclone
, MEMCACHED_BEHAVIOR_POLL_TIMEOUT
, timeout
);
2014 value
= (char*)malloc(value_length
* sizeof(char));
2016 for (x
= 0; x
< value_length
; x
++)
2017 value
[x
]= (char) (x
% 127);
2019 for (x
= 1; x
<= 100000; ++x
)
2021 rc
= memcached_set(mclone
, key
, key_len
,value
, value_length
, 0, 0);
2023 assert(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_WRITE_FAILURE
|| rc
== MEMCACHED_BUFFERED
);
2025 if (rc
== MEMCACHED_WRITE_FAILURE
)
2030 memcached_free(mclone
);
2036 We are looking failures in the async protocol
2038 static test_return
user_supplied_bug11(memcached_st
*memc
)
2042 size_t value_length
= 512;
2045 memcached_return rc
;
2046 unsigned int set
= 1;
2048 memcached_st
*mclone
= memcached_clone(NULL
, memc
);
2050 memcached_behavior_set(mclone
, MEMCACHED_BEHAVIOR_NO_BLOCK
, set
);
2051 memcached_behavior_set(mclone
, MEMCACHED_BEHAVIOR_TCP_NODELAY
, set
);
2053 memcached_behavior_set(mclone
, MEMCACHED_BEHAVIOR_POLL_TIMEOUT
, timeout
);
2055 timeout
= (int32_t)memcached_behavior_get(mclone
, MEMCACHED_BEHAVIOR_POLL_TIMEOUT
);
2057 assert(timeout
== -1);
2059 value
= (char*)malloc(value_length
* sizeof(char));
2061 for (x
= 0; x
< value_length
; x
++)
2062 value
[x
]= (char) (x
% 127);
2064 for (x
= 1; x
<= 100000; ++x
)
2066 rc
= memcached_set(mclone
, key
, key_len
,value
, value_length
, 0, 0);
2070 memcached_free(mclone
);
2076 Bug found where incr was not returning MEMCACHED_NOTFOUND when object did not exist.
2078 static test_return
user_supplied_bug12(memcached_st
*memc
)
2080 memcached_return rc
;
2082 size_t value_length
;
2084 uint64_t number_value
;
2086 value
= memcached_get(memc
, "autoincrement", strlen("autoincrement"),
2087 &value_length
, &flags
, &rc
);
2088 assert(value
== NULL
);
2089 assert(rc
== MEMCACHED_NOTFOUND
);
2091 rc
= memcached_increment(memc
, "autoincrement", strlen("autoincrement"),
2094 assert(value
== NULL
);
2095 /* The binary protocol will set the key if it doesn't exist */
2096 if (memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
) == 1)
2097 assert(rc
== MEMCACHED_SUCCESS
);
2099 assert(rc
== MEMCACHED_NOTFOUND
);
2101 rc
= memcached_set(memc
, "autoincrement", strlen("autoincrement"), "1", 1, 0, 0);
2103 value
= memcached_get(memc
, "autoincrement", strlen("autoincrement"),
2104 &value_length
, &flags
, &rc
);
2106 assert(rc
== MEMCACHED_SUCCESS
);
2109 rc
= memcached_increment(memc
, "autoincrement", strlen("autoincrement"),
2111 assert(number_value
== 2);
2112 assert(rc
== MEMCACHED_SUCCESS
);
2118 Bug found where command total one more than MEMCACHED_MAX_BUFFER
2119 set key34567890 0 0 8169 \r\n is sent followed by buffer of size 8169, followed by 8169
2121 static test_return
user_supplied_bug13(memcached_st
*memc
)
2123 char key
[] = "key34567890";
2125 memcached_return rc
;
2126 size_t overflowSize
;
2128 char commandFirst
[]= "set key34567890 0 0 ";
2129 char commandLast
[] = " \r\n"; /* first line of command sent to server */
2130 size_t commandLength
;
2133 commandLength
= strlen(commandFirst
) + strlen(commandLast
) + 4; /* 4 is number of characters in size, probably 8196 */
2135 overflowSize
= MEMCACHED_MAX_BUFFER
- commandLength
;
2137 for (testSize
= overflowSize
- 1; testSize
< overflowSize
+ 1; testSize
++)
2139 overflow
= malloc(testSize
);
2140 assert(overflow
!= NULL
);
2142 memset(overflow
, 'x', testSize
);
2143 rc
= memcached_set(memc
, key
, strlen(key
),
2144 overflow
, testSize
, 0, 0);
2145 assert(rc
== MEMCACHED_SUCCESS
);
2154 Test values of many different sizes
2155 Bug found where command total one more than MEMCACHED_MAX_BUFFER
2156 set key34567890 0 0 8169 \r\n
2157 is sent followed by buffer of size 8169, followed by 8169
2159 static test_return
user_supplied_bug14(memcached_st
*memc
)
2162 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_TCP_NODELAY
, setter
);
2163 memcached_return rc
;
2166 size_t value_length
= 18000;
2168 size_t string_length
;
2171 size_t current_length
;
2173 value
= (char*)malloc(value_length
);
2176 for (x
= 0; x
< value_length
; x
++)
2177 value
[x
] = (char) (x
% 127);
2179 for (current_length
= 0; current_length
< value_length
; current_length
++)
2181 rc
= memcached_set(memc
, key
, strlen(key
),
2182 value
, current_length
,
2183 (time_t)0, (uint32_t)0);
2184 assert(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
);
2186 string
= memcached_get(memc
, key
, strlen(key
),
2187 &string_length
, &flags
, &rc
);
2189 assert(rc
== MEMCACHED_SUCCESS
);
2190 assert(string_length
== current_length
);
2191 assert(!memcmp(string
, value
, string_length
));
2202 Look for zero length value problems
2204 static test_return
user_supplied_bug15(memcached_st
*memc
)
2207 memcached_return rc
;
2213 for (x
= 0; x
< 2; x
++)
2215 rc
= memcached_set(memc
, key
, strlen(key
),
2217 (time_t)0, (uint32_t)0);
2219 assert(rc
== MEMCACHED_SUCCESS
);
2221 value
= memcached_get(memc
, key
, strlen(key
),
2222 &length
, &flags
, &rc
);
2224 assert(rc
== MEMCACHED_SUCCESS
);
2225 assert(value
== NULL
);
2226 assert(length
== 0);
2229 value
= memcached_get(memc
, key
, strlen(key
),
2230 &length
, &flags
, &rc
);
2232 assert(rc
== MEMCACHED_SUCCESS
);
2233 assert(value
== NULL
);
2234 assert(length
== 0);
2241 /* Check the return sizes on FLAGS to make sure it stores 32bit unsigned values correctly */
2242 static test_return
user_supplied_bug16(memcached_st
*memc
)
2244 memcached_return rc
;
2250 rc
= memcached_set(memc
, key
, strlen(key
),
2252 (time_t)0, UINT32_MAX
);
2254 assert(rc
== MEMCACHED_SUCCESS
);
2256 value
= memcached_get(memc
, key
, strlen(key
),
2257 &length
, &flags
, &rc
);
2259 assert(rc
== MEMCACHED_SUCCESS
);
2260 assert(value
== NULL
);
2261 assert(length
== 0);
2262 assert(flags
== UINT32_MAX
);
2267 /* Check the validity of chinese key*/
2268 static test_return
user_supplied_bug17(memcached_st
*memc
)
2270 memcached_return rc
;
2272 char *value
="我们在炎热抑郁的夏天无法停止豆瓣";
2277 rc
= memcached_set(memc
, key
, strlen(key
),
2278 value
, strlen(value
),
2281 assert(rc
== MEMCACHED_SUCCESS
);
2283 value2
= memcached_get(memc
, key
, strlen(key
),
2284 &length
, &flags
, &rc
);
2286 assert(length
==strlen(value
));
2287 assert(rc
== MEMCACHED_SUCCESS
);
2288 assert(memcmp(value
, value2
, length
)==0);
2298 test_return
user_supplied_bug19(memcached_st
*memc
)
2301 memcached_server_st
*s
;
2302 memcached_return res
;
2306 m
= memcached_create(NULL
);
2307 memcached_server_add_with_weight(m
, "localhost", 11311, 100);
2308 memcached_server_add_with_weight(m
, "localhost", 11312, 100);
2310 s
= memcached_server_by_key(m
, "a", 1, &res
);
2311 memcached_server_free(s
);
2318 /* CAS test from Andei */
2319 test_return
user_supplied_bug20(memcached_st
*memc
)
2321 memcached_return status
;
2322 memcached_result_st
*result
, result_obj
;
2324 size_t key_len
= strlen("abc");
2325 char *value
= "foobar";
2326 size_t value_len
= strlen(value
);
2328 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_SUPPORT_CAS
, 1);
2330 status
= memcached_set(memc
, key
, key_len
, value
, value_len
, (time_t)0, (uint32_t)0);
2331 assert(status
== MEMCACHED_SUCCESS
);
2333 status
= memcached_mget(memc
, &key
, &key_len
, 1);
2334 assert(status
== MEMCACHED_SUCCESS
);
2336 result
= memcached_result_create(memc
, &result_obj
);
2339 memcached_result_create(memc
, &result_obj
);
2340 result
= memcached_fetch_result(memc
, &result_obj
, &status
);
2343 assert(status
== MEMCACHED_SUCCESS
);
2345 memcached_result_free(result
);
2350 #include "ketama_test_cases.h"
2351 test_return
user_supplied_bug18(memcached_st
*trash
)
2353 memcached_return rc
;
2356 memcached_server_st
*server_pool
;
2361 memc
= memcached_create(NULL
);
2364 rc
= memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_KETAMA_WEIGHTED
, 1);
2365 assert(rc
== MEMCACHED_SUCCESS
);
2367 value
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_KETAMA_WEIGHTED
);
2370 rc
= memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_KETAMA_HASH
, MEMCACHED_HASH_MD5
);
2371 assert(rc
== MEMCACHED_SUCCESS
);
2373 value
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_KETAMA_HASH
);
2374 assert(value
== MEMCACHED_HASH_MD5
);
2376 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");
2377 memcached_server_push(memc
, server_pool
);
2379 /* verify that the server list was parsed okay. */
2380 assert(memc
->number_of_hosts
== 8);
2381 assert(strcmp(server_pool
[0].hostname
, "10.0.1.1") == 0);
2382 assert(server_pool
[0].port
== 11211);
2383 assert(server_pool
[0].weight
== 600);
2384 assert(strcmp(server_pool
[2].hostname
, "10.0.1.3") == 0);
2385 assert(server_pool
[2].port
== 11211);
2386 assert(server_pool
[2].weight
== 200);
2387 assert(strcmp(server_pool
[7].hostname
, "10.0.1.8") == 0);
2388 assert(server_pool
[7].port
== 11211);
2389 assert(server_pool
[7].weight
== 100);
2391 /* VDEAAAAA hashes to fffcd1b5, after the last continuum point, and lets
2392 * us test the boundary wraparound.
2394 assert(memcached_generate_hash(memc
, (char *)"VDEAAAAA", 8) == memc
->continuum
[0].index
);
2396 /* verify the standard ketama set. */
2397 for (x
= 0; x
< 99; x
++)
2399 uint32_t server_idx
= memcached_generate_hash(memc
, test_cases
[x
].key
, strlen(test_cases
[x
].key
));
2400 char *hostname
= memc
->hosts
[server_idx
].hostname
;
2401 assert(strcmp(hostname
, test_cases
[x
].server
) == 0);
2404 memcached_server_list_free(server_pool
);
2405 memcached_free(memc
);
2410 test_return
auto_eject_hosts(memcached_st
*trash
)
2412 memcached_return rc
;
2413 memcached_st
*memc
= memcached_create(NULL
);
2416 rc
= memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_KETAMA_WEIGHTED
, 1);
2417 assert(rc
== MEMCACHED_SUCCESS
);
2419 uint64_t value
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_KETAMA_WEIGHTED
);
2422 rc
= memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_KETAMA_HASH
, MEMCACHED_HASH_MD5
);
2423 assert(rc
== MEMCACHED_SUCCESS
);
2425 value
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_KETAMA_HASH
);
2426 assert(value
== MEMCACHED_HASH_MD5
);
2428 /* server should be removed when in delay */
2429 rc
= memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_AUTO_EJECT_HOSTS
, 1);
2430 assert(rc
== MEMCACHED_SUCCESS
);
2432 value
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_AUTO_EJECT_HOSTS
);
2435 memcached_server_st
*server_pool
;
2436 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");
2437 memcached_server_push(memc
, server_pool
);
2439 /* verify that the server list was parsed okay. */
2440 assert(memc
->number_of_hosts
== 8);
2441 assert(strcmp(server_pool
[0].hostname
, "10.0.1.1") == 0);
2442 assert(server_pool
[0].port
== 11211);
2443 assert(server_pool
[0].weight
== 600);
2444 assert(strcmp(server_pool
[2].hostname
, "10.0.1.3") == 0);
2445 assert(server_pool
[2].port
== 11211);
2446 assert(server_pool
[2].weight
== 200);
2447 assert(strcmp(server_pool
[7].hostname
, "10.0.1.8") == 0);
2448 assert(server_pool
[7].port
== 11211);
2449 assert(server_pool
[7].weight
== 100);
2451 memc
->hosts
[2].next_retry
= time(NULL
) + 15;
2452 memc
->next_distribution_rebuild
= time(NULL
) - 1;
2454 for (int x
= 0; x
< 99; x
++)
2456 uint32_t server_idx
= memcached_generate_hash(memc
, test_cases
[x
].key
, strlen(test_cases
[x
].key
));
2457 assert(server_idx
!= 2);
2460 /* and re-added when it's back. */
2461 memc
->hosts
[2].next_retry
= time(NULL
) - 1;
2462 memc
->next_distribution_rebuild
= time(NULL
) - 1;
2463 run_distribution(memc
);
2464 for (int x
= 0; x
< 99; x
++)
2466 uint32_t server_idx
= memcached_generate_hash(memc
, test_cases
[x
].key
, strlen(test_cases
[x
].key
));
2467 char *hostname
= memc
->hosts
[server_idx
].hostname
;
2468 assert(strcmp(hostname
, test_cases
[x
].server
) == 0);
2471 memcached_server_list_free(server_pool
);
2472 memcached_free(memc
);
2474 return TEST_SUCCESS
;
2477 static test_return
result_static(memcached_st
*memc
)
2479 memcached_result_st result
;
2480 memcached_result_st
*result_ptr
;
2482 result_ptr
= memcached_result_create(memc
, &result
);
2483 assert(result
.is_allocated
== false);
2485 memcached_result_free(&result
);
2490 static test_return
result_alloc(memcached_st
*memc
)
2492 memcached_result_st
*result
;
2494 result
= memcached_result_create(memc
, NULL
);
2496 memcached_result_free(result
);
2501 static test_return
string_static_null(memcached_st
*memc
)
2503 memcached_string_st string
;
2504 memcached_string_st
*string_ptr
;
2506 string_ptr
= memcached_string_create(memc
, &string
, 0);
2507 assert(string
.is_allocated
== false);
2509 memcached_string_free(&string
);
2514 static test_return
string_alloc_null(memcached_st
*memc
)
2516 memcached_string_st
*string
;
2518 string
= memcached_string_create(memc
, NULL
, 0);
2520 memcached_string_free(string
);
2525 static test_return
string_alloc_with_size(memcached_st
*memc
)
2527 memcached_string_st
*string
;
2529 string
= memcached_string_create(memc
, NULL
, 1024);
2531 memcached_string_free(string
);
2536 static test_return
string_alloc_with_size_toobig(memcached_st
*memc
)
2538 memcached_string_st
*string
;
2540 string
= memcached_string_create(memc
, NULL
, INT64_MAX
);
2541 assert(string
== NULL
);
2546 static test_return
string_alloc_append(memcached_st
*memc
)
2549 char buffer
[SMALL_STRING_LEN
];
2550 memcached_string_st
*string
;
2552 /* Ring the bell! */
2553 memset(buffer
, 6, SMALL_STRING_LEN
);
2555 string
= memcached_string_create(memc
, NULL
, 100);
2558 for (x
= 0; x
< 1024; x
++)
2560 memcached_return rc
;
2561 rc
= memcached_string_append(string
, buffer
, SMALL_STRING_LEN
);
2562 assert(rc
== MEMCACHED_SUCCESS
);
2564 memcached_string_free(string
);
2569 static test_return
string_alloc_append_toobig(memcached_st
*memc
)
2571 memcached_return rc
;
2573 char buffer
[SMALL_STRING_LEN
];
2574 memcached_string_st
*string
;
2576 /* Ring the bell! */
2577 memset(buffer
, 6, SMALL_STRING_LEN
);
2579 string
= memcached_string_create(memc
, NULL
, 100);
2582 for (x
= 0; x
< 1024; x
++)
2584 rc
= memcached_string_append(string
, buffer
, SMALL_STRING_LEN
);
2585 assert(rc
== MEMCACHED_SUCCESS
);
2587 rc
= memcached_string_append(string
, buffer
, INT64_MAX
);
2588 assert(rc
== MEMCACHED_MEMORY_ALLOCATION_FAILURE
);
2589 memcached_string_free(string
);
2594 static test_return
cleanup_pairs(memcached_st
*memc
__attribute__((unused
)))
2596 pairs_free(global_pairs
);
2601 static test_return
generate_pairs(memcached_st
*memc
__attribute__((unused
)))
2603 unsigned long long x
;
2604 global_pairs
= pairs_generate(GLOBAL_COUNT
, 400);
2605 global_count
= GLOBAL_COUNT
;
2607 for (x
= 0; x
< global_count
; x
++)
2609 global_keys
[x
]= global_pairs
[x
].key
;
2610 global_keys_length
[x
]= global_pairs
[x
].key_length
;
2616 static test_return
generate_large_pairs(memcached_st
*memc
__attribute__((unused
)))
2618 unsigned long long x
;
2619 global_pairs
= pairs_generate(GLOBAL2_COUNT
, MEMCACHED_MAX_BUFFER
+10);
2620 global_count
= GLOBAL2_COUNT
;
2622 for (x
= 0; x
< global_count
; x
++)
2624 global_keys
[x
]= global_pairs
[x
].key
;
2625 global_keys_length
[x
]= global_pairs
[x
].key_length
;
2631 static test_return
generate_data(memcached_st
*memc
)
2633 execute_set(memc
, global_pairs
, global_count
);
2638 static test_return
generate_data_with_stats(memcached_st
*memc
)
2640 memcached_stat_st
*stat_p
;
2641 memcached_return rc
;
2642 uint32_t host_index
= 0;
2643 execute_set(memc
, global_pairs
, global_count
);
2645 //TODO: hosts used size stats
2646 stat_p
= memcached_stat(memc
, NULL
, &rc
);
2649 for (host_index
= 0; host_index
< SERVERS_TO_CREATE
; host_index
++)
2651 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
);
2654 memcached_stat_free(NULL
, stat_p
);
2658 static test_return
generate_buffer_data(memcached_st
*memc
)
2663 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_BUFFER_REQUESTS
, latch
);
2664 generate_data(memc
);
2669 static test_return
get_read_count(memcached_st
*memc
)
2672 memcached_return rc
;
2673 memcached_st
*clone
;
2675 clone
= memcached_clone(NULL
, memc
);
2678 memcached_server_add_with_weight(clone
, "localhost", 6666, 0);
2682 size_t return_value_length
;
2686 for (x
= count
= 0; x
< global_count
; x
++)
2688 return_value
= memcached_get(clone
, global_keys
[x
], global_keys_length
[x
],
2689 &return_value_length
, &flags
, &rc
);
2690 if (rc
== MEMCACHED_SUCCESS
)
2697 fprintf(stderr
, "\t%u -> %u", global_count
, count
);
2700 memcached_free(clone
);
2705 static test_return
get_read(memcached_st
*memc
)
2708 memcached_return rc
;
2712 size_t return_value_length
;
2715 for (x
= 0; x
< global_count
; x
++)
2717 return_value
= memcached_get(memc
, global_keys
[x
], global_keys_length
[x
],
2718 &return_value_length
, &flags
, &rc
);
2720 assert(return_value);
2721 assert(rc == MEMCACHED_SUCCESS);
2723 if (rc
== MEMCACHED_SUCCESS
&& return_value
)
2731 static test_return
mget_read(memcached_st
*memc
)
2733 memcached_return rc
;
2735 rc
= memcached_mget(memc
, global_keys
, global_keys_length
, global_count
);
2736 assert(rc
== MEMCACHED_SUCCESS
);
2737 /* Turn this into a help function */
2739 char return_key
[MEMCACHED_MAX_KEY
];
2740 size_t return_key_length
;
2742 size_t return_value_length
;
2745 while ((return_value
= memcached_fetch(memc
, return_key
, &return_key_length
,
2746 &return_value_length
, &flags
, &rc
)))
2748 assert(return_value
);
2749 assert(rc
== MEMCACHED_SUCCESS
);
2757 static test_return
mget_read_result(memcached_st
*memc
)
2759 memcached_return rc
;
2761 rc
= memcached_mget(memc
, global_keys
, global_keys_length
, global_count
);
2762 assert(rc
== MEMCACHED_SUCCESS
);
2763 /* Turn this into a help function */
2765 memcached_result_st results_obj
;
2766 memcached_result_st
*results
;
2768 results
= memcached_result_create(memc
, &results_obj
);
2770 while ((results
= memcached_fetch_result(memc
, &results_obj
, &rc
)))
2773 assert(rc
== MEMCACHED_SUCCESS
);
2776 memcached_result_free(&results_obj
);
2782 static test_return
mget_read_function(memcached_st
*memc
)
2784 memcached_return rc
;
2785 unsigned int counter
;
2786 memcached_execute_function callbacks
[1];
2788 rc
= memcached_mget(memc
, global_keys
, global_keys_length
, global_count
);
2789 assert(rc
== MEMCACHED_SUCCESS
);
2791 callbacks
[0]= &callback_counter
;
2793 rc
= memcached_fetch_execute(memc
, callbacks
, (void *)&counter
, 1);
2798 static test_return
delete_generate(memcached_st
*memc
)
2802 for (x
= 0; x
< global_count
; x
++)
2804 (void)memcached_delete(memc
, global_keys
[x
], global_keys_length
[x
], (time_t)0);
2810 static test_return
delete_buffer_generate(memcached_st
*memc
)
2816 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_BUFFER_REQUESTS
, latch
);
2818 for (x
= 0; x
< global_count
; x
++)
2820 (void)memcached_delete(memc
, global_keys
[x
], global_keys_length
[x
], (time_t)0);
2826 static test_return
free_data(memcached_st
*memc
__attribute__((unused
)))
2828 pairs_free(global_pairs
);
2833 static test_return
add_host_test1(memcached_st
*memc
)
2836 memcached_return rc
;
2837 char servername
[]= "0.example.com";
2838 memcached_server_st
*servers
;
2840 servers
= memcached_server_list_append_with_weight(NULL
, servername
, 400, 0, &rc
);
2842 assert(1 == memcached_server_list_count(servers
));
2844 for (x
= 2; x
< 20; x
++)
2846 char buffer
[SMALL_STRING_LEN
];
2848 snprintf(buffer
, SMALL_STRING_LEN
, "%u.example.com", 400+x
);
2849 servers
= memcached_server_list_append_with_weight(servers
, buffer
, 401, 0,
2851 assert(rc
== MEMCACHED_SUCCESS
);
2852 assert(x
== memcached_server_list_count(servers
));
2855 rc
= memcached_server_push(memc
, servers
);
2856 assert(rc
== MEMCACHED_SUCCESS
);
2857 rc
= memcached_server_push(memc
, servers
);
2858 assert(rc
== MEMCACHED_SUCCESS
);
2860 memcached_server_list_free(servers
);
2865 static memcached_return
pre_nonblock(memcached_st
*memc
)
2867 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NO_BLOCK
, 0);
2869 return MEMCACHED_SUCCESS
;
2872 static memcached_return
pre_nonblock_binary(memcached_st
*memc
)
2874 memcached_return rc
= MEMCACHED_FAILURE
;
2875 memcached_st
*clone
;
2877 clone
= memcached_clone(NULL
, memc
);
2879 // The memcached_version needs to be done on a clone, because the server
2880 // will not toggle protocol on an connection.
2881 memcached_version(clone
);
2883 if (clone
->hosts
[0].major_version
>= 1 && clone
->hosts
[0].minor_version
> 2)
2885 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NO_BLOCK
, 0);
2886 rc
= memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
, 1);
2887 assert(rc
== MEMCACHED_SUCCESS
);
2888 assert(memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
) == 1);
2891 memcached_free(clone
);
2895 static memcached_return
pre_murmur(memcached_st
*memc
)
2897 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_HASH
, (uint64_t)MEMCACHED_HASH_MURMUR
);
2899 return MEMCACHED_SUCCESS
;
2902 static memcached_return
pre_jenkins(memcached_st
*memc
)
2904 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_HASH
, (uint64_t)MEMCACHED_HASH_JENKINS
);
2906 return MEMCACHED_SUCCESS
;
2910 static memcached_return
pre_md5(memcached_st
*memc
)
2912 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_HASH
, (uint64_t)MEMCACHED_HASH_MD5
);
2914 return MEMCACHED_SUCCESS
;
2917 static memcached_return
pre_crc(memcached_st
*memc
)
2919 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_HASH
, (uint64_t)MEMCACHED_HASH_CRC
);
2921 return MEMCACHED_SUCCESS
;
2924 static memcached_return
pre_hsieh(memcached_st
*memc
)
2926 #ifdef HAVE_HSIEH_HASH
2927 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_HASH
, (uint64_t)MEMCACHED_HASH_HSIEH
);
2928 return MEMCACHED_SUCCESS
;
2930 return MEMCACHED_FAILURE
;
2934 static memcached_return
pre_hash_fnv1_64(memcached_st
*memc
)
2936 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_HASH
, (uint64_t)MEMCACHED_HASH_FNV1_64
);
2938 return MEMCACHED_SUCCESS
;
2941 static memcached_return
pre_hash_fnv1a_64(memcached_st
*memc
)
2943 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_HASH
, (uint64_t)MEMCACHED_HASH_FNV1A_64
);
2945 return MEMCACHED_SUCCESS
;
2948 static memcached_return
pre_hash_fnv1_32(memcached_st
*memc
)
2950 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_HASH
, (uint64_t)MEMCACHED_HASH_FNV1_32
);
2952 return MEMCACHED_SUCCESS
;
2955 static memcached_return
pre_hash_fnv1a_32(memcached_st
*memc
)
2957 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_HASH
, (uint64_t)MEMCACHED_HASH_FNV1A_32
);
2959 return MEMCACHED_SUCCESS
;
2962 static memcached_return
pre_behavior_ketama(memcached_st
*memc
)
2964 memcached_return rc
;
2967 rc
= memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_KETAMA
, 1);
2968 assert(rc
== MEMCACHED_SUCCESS
);
2970 value
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_KETAMA
);
2973 return MEMCACHED_SUCCESS
;
2976 static memcached_return
pre_behavior_ketama_weighted(memcached_st
*memc
)
2978 memcached_return rc
;
2981 rc
= memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_KETAMA_WEIGHTED
, 1);
2982 assert(rc
== MEMCACHED_SUCCESS
);
2984 value
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_KETAMA_WEIGHTED
);
2987 rc
= memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_KETAMA_HASH
, MEMCACHED_HASH_MD5
);
2988 assert(rc
== MEMCACHED_SUCCESS
);
2990 value
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_KETAMA_HASH
);
2991 assert(value
== MEMCACHED_HASH_MD5
);
2992 return MEMCACHED_SUCCESS
;
2995 static memcached_return
pre_binary(memcached_st
*memc
)
2997 memcached_return rc
= MEMCACHED_FAILURE
;
2998 memcached_st
*clone
;
3000 clone
= memcached_clone(NULL
, memc
);
3002 // The memcached_version needs to be done on a clone, because the server
3003 // will not toggle protocol on an connection.
3004 memcached_version(clone
);
3006 if (clone
->hosts
[0].major_version
>= 1 && clone
->hosts
[0].minor_version
> 2)
3008 rc
= memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
, 1);
3009 assert(rc
== MEMCACHED_SUCCESS
);
3010 assert(memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
) == 1);
3013 memcached_free(clone
);
3017 static void my_free(memcached_st
*ptr
__attribute__((unused
)), void *mem
)
3022 static void *my_malloc(memcached_st
*ptr
__attribute__((unused
)), const size_t size
)
3024 return malloc(size
);
3027 static void *my_realloc(memcached_st
*ptr
__attribute__((unused
)), void *mem
, const size_t size
)
3029 return realloc(mem
, size
);
3032 static memcached_return
set_prefix(memcached_st
*memc
)
3034 memcached_return rc
;
3035 const char *key
= "mine";
3038 /* Make sure be default none exists */
3039 value
= memcached_callback_get(memc
, MEMCACHED_CALLBACK_PREFIX_KEY
, &rc
);
3040 assert(rc
== MEMCACHED_FAILURE
);
3042 /* Test a clean set */
3043 rc
= memcached_callback_set(memc
, MEMCACHED_CALLBACK_PREFIX_KEY
, (void *)key
);
3044 assert(rc
== MEMCACHED_SUCCESS
);
3046 value
= memcached_callback_get(memc
, MEMCACHED_CALLBACK_PREFIX_KEY
, &rc
);
3047 assert(memcmp(value
, key
, 4) == 0);
3048 assert(rc
== MEMCACHED_SUCCESS
);
3050 /* Test that we can turn it off */
3051 rc
= memcached_callback_set(memc
, MEMCACHED_CALLBACK_PREFIX_KEY
, NULL
);
3052 assert(rc
== MEMCACHED_SUCCESS
);
3054 value
= memcached_callback_get(memc
, MEMCACHED_CALLBACK_PREFIX_KEY
, &rc
);
3055 assert(rc
== MEMCACHED_FAILURE
);
3057 /* Now setup for main test */
3058 rc
= memcached_callback_set(memc
, MEMCACHED_CALLBACK_PREFIX_KEY
, (void *)key
);
3059 assert(rc
== MEMCACHED_SUCCESS
);
3061 value
= memcached_callback_get(memc
, MEMCACHED_CALLBACK_PREFIX_KEY
, &rc
);
3062 assert(rc
== MEMCACHED_SUCCESS
);
3063 assert(memcmp(value
, key
, 4) == 0);
3065 /* Set to Zero, and then Set to something too large */
3068 rc
= memcached_callback_set(memc
, MEMCACHED_CALLBACK_PREFIX_KEY
, NULL
);
3069 assert(rc
== MEMCACHED_SUCCESS
);
3071 value
= memcached_callback_get(memc
, MEMCACHED_CALLBACK_PREFIX_KEY
, &rc
);
3072 assert(rc
== MEMCACHED_FAILURE
);
3073 assert(value
== NULL
);
3075 /* Test a long key for failure */
3076 /* TODO, extend test to determine based on setting, what result should be */
3077 long_key
= "Thisismorethentheallottednumberofcharacters";
3078 rc
= memcached_callback_set(memc
, MEMCACHED_CALLBACK_PREFIX_KEY
, long_key
);
3079 //assert(rc == MEMCACHED_BAD_KEY_PROVIDED);
3080 assert(rc
== MEMCACHED_SUCCESS
);
3082 /* Now test a key with spaces (which will fail from long key, since bad key is not set) */
3083 long_key
= "This is more then the allotted number of characters";
3084 rc
= memcached_callback_set(memc
, MEMCACHED_CALLBACK_PREFIX_KEY
, long_key
);
3085 assert(rc
== MEMCACHED_BAD_KEY_PROVIDED
);
3087 /* Test for a bad prefix, but with a short key */
3088 rc
= memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_VERIFY_KEY
, 1);
3089 assert(rc
== MEMCACHED_SUCCESS
);
3091 long_key
= "dog cat";
3092 rc
= memcached_callback_set(memc
, MEMCACHED_CALLBACK_PREFIX_KEY
, long_key
);
3093 assert(rc
== MEMCACHED_BAD_KEY_PROVIDED
);
3096 return MEMCACHED_SUCCESS
;
3099 static memcached_return
set_memory_alloc(memcached_st
*memc
)
3102 memcached_malloc_function test_ptr
;
3103 memcached_return rc
;
3105 rc
= memcached_callback_set(memc
, MEMCACHED_CALLBACK_MALLOC_FUNCTION
, (void*)&my_malloc
);
3106 assert(rc
== MEMCACHED_SUCCESS
);
3107 test_ptr
= (memcached_malloc_function
)memcached_callback_get(memc
, MEMCACHED_CALLBACK_MALLOC_FUNCTION
, &rc
);
3108 assert(rc
== MEMCACHED_SUCCESS
);
3109 assert(test_ptr
== my_malloc
);
3113 memcached_realloc_function test_ptr
;
3114 memcached_return rc
;
3116 rc
= memcached_callback_set(memc
, MEMCACHED_CALLBACK_REALLOC_FUNCTION
, (void*)&my_realloc
);
3117 assert(rc
== MEMCACHED_SUCCESS
);
3118 test_ptr
= (memcached_realloc_function
)memcached_callback_get(memc
, MEMCACHED_CALLBACK_REALLOC_FUNCTION
, &rc
);
3119 assert(rc
== MEMCACHED_SUCCESS
);
3120 assert(test_ptr
== my_realloc
);
3124 memcached_free_function test_ptr
;
3125 memcached_return rc
;
3127 rc
= memcached_callback_set(memc
, MEMCACHED_CALLBACK_FREE_FUNCTION
, (void*)my_free
);
3128 assert(rc
== MEMCACHED_SUCCESS
);
3129 test_ptr
= (memcached_free_function
)memcached_callback_get(memc
, MEMCACHED_CALLBACK_FREE_FUNCTION
, &rc
);
3130 assert(rc
== MEMCACHED_SUCCESS
);
3131 assert(test_ptr
== my_free
);
3134 return MEMCACHED_SUCCESS
;
3137 static memcached_return
enable_consistent(memcached_st
*memc
)
3139 memcached_server_distribution value
= MEMCACHED_DISTRIBUTION_CONSISTENT
;
3140 memcached_hash hash
;
3141 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_DISTRIBUTION
, value
);
3142 if (pre_hsieh(memc
) != MEMCACHED_SUCCESS
)
3143 return MEMCACHED_FAILURE
;
3145 value
= (memcached_server_distribution
)memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_DISTRIBUTION
);
3146 assert(value
== MEMCACHED_DISTRIBUTION_CONSISTENT
);
3148 hash
= (memcached_hash
)memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_HASH
);
3149 assert(hash
== MEMCACHED_HASH_HSIEH
);
3152 return MEMCACHED_SUCCESS
;
3155 static memcached_return
enable_cas(memcached_st
*memc
)
3157 unsigned int set
= 1;
3159 memcached_version(memc
);
3161 if ((memc
->hosts
[0].major_version
>= 1 && (memc
->hosts
[0].minor_version
== 2 && memc
->hosts
[0].micro_version
>= 4))
3162 || memc
->hosts
[0].minor_version
> 2)
3164 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_SUPPORT_CAS
, set
);
3166 return MEMCACHED_SUCCESS
;
3169 return MEMCACHED_FAILURE
;
3172 static memcached_return
check_for_1_2_3(memcached_st
*memc
)
3174 memcached_version(memc
);
3176 if ((memc
->hosts
[0].major_version
>= 1 && (memc
->hosts
[0].minor_version
== 2 && memc
->hosts
[0].micro_version
>= 4))
3177 || memc
->hosts
[0].minor_version
> 2)
3178 return MEMCACHED_SUCCESS
;
3180 return MEMCACHED_FAILURE
;
3183 static memcached_return
pre_unix_socket(memcached_st
*memc
)
3185 memcached_return rc
;
3188 memcached_server_list_free(memc
->hosts
);
3190 memc
->number_of_hosts
= 0;
3192 if (stat("/tmp/memcached.socket", &buf
))
3193 return MEMCACHED_FAILURE
;
3195 rc
= memcached_server_add_unix_socket_with_weight(memc
, "/tmp/memcached.socket", 0);
3200 static memcached_return
pre_nodelay(memcached_st
*memc
)
3202 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NO_BLOCK
, 0);
3203 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_TCP_NODELAY
, 0);
3205 return MEMCACHED_SUCCESS
;
3208 static memcached_return
pre_settimer(memcached_st
*memc
)
3210 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_SND_TIMEOUT
, 1000);
3211 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_RCV_TIMEOUT
, 1000);
3213 return MEMCACHED_SUCCESS
;
3216 static memcached_return
poll_timeout(memcached_st
*memc
)
3222 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_POLL_TIMEOUT
, timeout
);
3224 timeout
= (int32_t)memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_POLL_TIMEOUT
);
3226 assert(timeout
== 100);
3228 return MEMCACHED_SUCCESS
;
3231 static test_return
noreply_test(memcached_st
*memc
)
3233 memcached_return ret
;
3234 ret
= memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NOREPLY
, 1);
3235 assert(ret
== MEMCACHED_SUCCESS
);
3236 ret
= memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_BUFFER_REQUESTS
, 1);
3237 assert(ret
== MEMCACHED_SUCCESS
);
3238 ret
= memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_SUPPORT_CAS
, 1);
3239 assert(ret
== MEMCACHED_SUCCESS
);
3240 assert(memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_NOREPLY
) == 1);
3241 assert(memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_BUFFER_REQUESTS
) == 1);
3242 assert(memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_SUPPORT_CAS
) == 1);
3244 for (int count
=0; count
< 5; ++count
)
3246 for (int x
=0; x
< 100; ++x
)
3249 size_t len
=sprintf(key
, "%d", x
);
3253 ret
=memcached_add(memc
, key
, len
, key
, len
, 0, 0);
3256 ret
=memcached_replace(memc
, key
, len
, key
, len
, 0, 0);
3259 ret
=memcached_set(memc
, key
, len
, key
, len
, 0, 0);
3262 ret
=memcached_append(memc
, key
, len
, key
, len
, 0, 0);
3265 ret
=memcached_prepend(memc
, key
, len
, key
, len
, 0, 0);
3268 assert(ret
== MEMCACHED_SUCCESS
|| ret
== MEMCACHED_BUFFERED
);
3272 ** NOTE: Don't ever do this in your code! this is not a supported use of the
3273 ** API and is _ONLY_ done this way to verify that the library works the
3274 ** way it is supposed to do!!!!
3277 for (int x
=0; x
< memc
->number_of_hosts
; ++x
)
3278 no_msg
+=memc
->hosts
[x
].cursor_active
;
3280 assert(no_msg
== 0);
3281 assert(memcached_flush_buffers(memc
) == MEMCACHED_SUCCESS
);
3284 ** Now validate that all items was set properly!
3286 for (int x
=0; x
< 100; ++x
)
3289 size_t len
=sprintf(key
, "%d", x
);
3292 char* value
=memcached_get(memc
, key
, strlen(key
),
3293 &length
, &flags
, &ret
);
3294 assert(ret
== MEMCACHED_SUCCESS
&& value
!= NULL
);
3297 case 0: /* FALLTHROUGH */
3298 case 1: /* FALLTHROUGH */
3300 assert(strncmp(value
, key
, len
) == 0);
3301 assert(len
== length
);
3304 assert(length
== len
* 2);
3307 assert(length
== len
* 3);
3314 /* Try setting an illegal cas value (should not return an error to
3315 * the caller (because we don't expect a return message from the server)
3317 char* keys
[]= {"0"};
3318 size_t lengths
[]= {1};
3321 memcached_result_st results_obj
;
3322 memcached_result_st
*results
;
3323 ret
=memcached_mget(memc
, keys
, lengths
, 1);
3324 assert(ret
== MEMCACHED_SUCCESS
);
3326 results
=memcached_result_create(memc
, &results_obj
);
3328 results
=memcached_fetch_result(memc
, &results_obj
, &ret
);
3330 assert(ret
== MEMCACHED_SUCCESS
);
3331 uint64_t cas
= memcached_result_cas(results
);
3332 memcached_result_free(&results_obj
);
3334 ret
= memcached_cas(memc
, keys
[0], lengths
[0], keys
[0], lengths
[0], 0, 0, cas
);
3335 assert(ret
== MEMCACHED_SUCCESS
);
3338 * The item will have a new cas value, so try to set it again with the old
3339 * value. This should fail!
3341 ret
= memcached_cas(memc
, keys
[0], lengths
[0], keys
[0], lengths
[0], 0, 0, cas
);
3342 assert(ret
== MEMCACHED_SUCCESS
);
3343 assert(memcached_flush_buffers(memc
) == MEMCACHED_SUCCESS
);
3344 char* value
=memcached_get(memc
, keys
[0], lengths
[0], &length
, &flags
, &ret
);
3345 assert(ret
== MEMCACHED_SUCCESS
&& value
!= NULL
);
3348 return TEST_SUCCESS
;
3351 static test_return
analyzer_test(memcached_st
*memc
)
3353 memcached_return rc
;
3354 memcached_stat_st
*stat
;
3355 memcached_analysis_st
*report
;
3357 stat
= memcached_stat(memc
, NULL
, &rc
);
3358 assert(rc
== MEMCACHED_SUCCESS
);
3361 report
= memcached_analyze(memc
, stat
, &rc
);
3362 assert(rc
== MEMCACHED_SUCCESS
);
3366 memcached_stat_free(NULL
, stat
);
3368 return TEST_SUCCESS
;
3371 static void increment_request_id(uint16_t *id
)
3374 if ((*id
& UDP_REQUEST_ID_THREAD_MASK
) != 0)
3378 static uint16_t *get_udp_request_ids(memcached_st
*memc
)
3380 uint16_t *ids
= malloc(sizeof(uint16_t) * memc
->number_of_hosts
);
3381 assert(ids
!= NULL
);
3383 for (x
= 0; x
< memc
->number_of_hosts
; x
++)
3384 ids
[x
]= get_udp_datagram_request_id((struct udp_datagram_header_st
*) memc
->hosts
[x
].write_buffer
);
3389 static test_return
post_udp_op_check(memcached_st
*memc
, uint16_t *expected_req_ids
)
3392 memcached_server_st
*cur_server
= memc
->hosts
;
3393 uint16_t *cur_req_ids
= get_udp_request_ids(memc
);
3394 for (x
= 0; x
< memc
->number_of_hosts
; x
++)
3396 assert(cur_server
[x
].cursor_active
== 0);
3397 assert(cur_req_ids
[x
] == expected_req_ids
[x
]);
3399 free(expected_req_ids
);
3401 return TEST_SUCCESS
;
3405 ** There is a little bit of a hack here, instead of removing
3406 ** the servers, I just set num host to 0 and them add then new udp servers
3408 static memcached_return
init_udp(memcached_st
*memc
)
3410 memcached_version(memc
);
3411 /* For the time being, only support udp test for >= 1.2.6 && < 1.3 */
3412 if (memc
->hosts
[0].major_version
!= 1 || memc
->hosts
[0].minor_version
!= 2
3413 || memc
->hosts
[0].micro_version
< 6)
3414 return MEMCACHED_FAILURE
;
3416 uint32_t num_hosts
= memc
->number_of_hosts
;
3418 memcached_server_st servers
[num_hosts
];
3419 memcpy(servers
, memc
->hosts
, sizeof(memcached_server_st
) * num_hosts
);
3420 for (x
= 0; x
< num_hosts
; x
++)
3421 memcached_server_free(&memc
->hosts
[x
]);
3422 memc
->number_of_hosts
= 0;
3423 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_USE_UDP
, 1);
3424 for (x
= 0; x
< num_hosts
; x
++)
3426 assert(memcached_server_add_udp(memc
, servers
[x
].hostname
, servers
[x
].port
) == MEMCACHED_SUCCESS
);
3427 assert(memc
->hosts
[x
].write_buffer_offset
== UDP_DATAGRAM_HEADER_LENGTH
);
3429 return MEMCACHED_SUCCESS
;
3432 static memcached_return
binary_init_udp(memcached_st
*memc
)
3435 return init_udp(memc
);
3438 /* Make sure that I cant add a tcp server to a udp client */
3439 static test_return
add_tcp_server_udp_client_test(memcached_st
*memc
)
3441 memcached_server_st server
;
3442 memcached_server_clone(&server
, &memc
->hosts
[0]);
3443 assert(memcached_server_remove(&(memc
->hosts
[0])) == MEMCACHED_SUCCESS
);
3444 assert(memcached_server_add(memc
, server
.hostname
, server
.port
) == MEMCACHED_INVALID_HOST_PROTOCOL
);
3445 return TEST_SUCCESS
;
3448 /* Make sure that I cant add a udp server to a tcp client */
3449 static test_return
add_udp_server_tcp_client_test(memcached_st
*memc
)
3451 memcached_server_st server
;
3452 memcached_server_clone(&server
, &memc
->hosts
[0]);
3453 assert(memcached_server_remove(&(memc
->hosts
[0])) == MEMCACHED_SUCCESS
);
3455 memcached_st tcp_client
;
3456 memcached_create(&tcp_client
);
3457 assert(memcached_server_add_udp(&tcp_client
, server
.hostname
, server
.port
) == MEMCACHED_INVALID_HOST_PROTOCOL
);
3458 return TEST_SUCCESS
;
3461 static test_return
set_udp_behavior_test(memcached_st
*memc
)
3464 memcached_quit(memc
);
3465 memc
->number_of_hosts
= 0;
3466 run_distribution(memc
);
3467 assert(memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_USE_UDP
, 1) == MEMCACHED_SUCCESS
);
3468 assert(memc
->flags
& MEM_USE_UDP
);
3469 assert(memc
->flags
& MEM_NOREPLY
);;
3471 assert(memc
->number_of_hosts
== 0);
3473 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_USE_UDP
,0);
3474 assert(!(memc
->flags
& MEM_USE_UDP
));
3475 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NOREPLY
,0);
3476 assert(!(memc
->flags
& MEM_NOREPLY
));
3477 return TEST_SUCCESS
;
3480 static test_return
udp_set_test(memcached_st
*memc
)
3483 unsigned int num_iters
= 1025; //request id rolls over at 1024
3484 for (x
= 0; x
< num_iters
;x
++)
3486 memcached_return rc
;
3488 char *value
= "when we sanitize";
3489 uint16_t *expected_ids
= get_udp_request_ids(memc
);
3490 unsigned int server_key
= memcached_generate_hash(memc
,key
,strlen(key
));
3491 size_t init_offset
= memc
->hosts
[server_key
].write_buffer_offset
;
3492 rc
= memcached_set(memc
, key
, strlen(key
),
3493 value
, strlen(value
),
3494 (time_t)0, (uint32_t)0);
3495 assert(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
);
3496 /** NB, the check below assumes that if new write_ptr is less than
3497 * the original write_ptr that we have flushed. For large payloads, this
3498 * maybe an invalid assumption, but for the small payload we have it is OK
3500 if (rc
== MEMCACHED_SUCCESS
||
3501 memc
->hosts
[server_key
].write_buffer_offset
< init_offset
)
3502 increment_request_id(&expected_ids
[server_key
]);
3504 if (rc
== MEMCACHED_SUCCESS
)
3506 assert(memc
->hosts
[server_key
].write_buffer_offset
== UDP_DATAGRAM_HEADER_LENGTH
);
3510 assert(memc
->hosts
[server_key
].write_buffer_offset
!= UDP_DATAGRAM_HEADER_LENGTH
);
3511 assert(memc
->hosts
[server_key
].write_buffer_offset
<= MAX_UDP_DATAGRAM_LENGTH
);
3513 assert(post_udp_op_check(memc
,expected_ids
) == TEST_SUCCESS
);
3515 return TEST_SUCCESS
;
3518 static test_return
udp_buffered_set_test(memcached_st
*memc
)
3520 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_BUFFER_REQUESTS
, 1);
3521 return udp_set_test(memc
);
3524 static test_return
udp_set_too_big_test(memcached_st
*memc
)
3526 memcached_return rc
;
3528 char value
[MAX_UDP_DATAGRAM_LENGTH
];
3529 uint16_t *expected_ids
= get_udp_request_ids(memc
);
3530 rc
= memcached_set(memc
, key
, strlen(key
),
3531 value
, MAX_UDP_DATAGRAM_LENGTH
,
3532 (time_t)0, (uint32_t)0);
3533 assert(rc
== MEMCACHED_WRITE_FAILURE
);
3534 return post_udp_op_check(memc
,expected_ids
);
3537 test_return
udp_delete_test(memcached_st
*memc
)
3540 unsigned int num_iters
= 1025; //request id rolls over at 1024
3541 for (x
= 0; x
< num_iters
;x
++)
3543 memcached_return rc
;
3545 uint16_t *expected_ids
=get_udp_request_ids(memc
);
3546 unsigned int server_key
= memcached_generate_hash(memc
, key
, strlen(key
));
3547 size_t init_offset
= memc
->hosts
[server_key
].write_buffer_offset
;
3548 rc
= memcached_delete(memc
, key
, strlen(key
), 0);
3549 assert(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
);
3550 if (rc
== MEMCACHED_SUCCESS
|| memc
->hosts
[server_key
].write_buffer_offset
< init_offset
)
3551 increment_request_id(&expected_ids
[server_key
]);
3552 if (rc
== MEMCACHED_SUCCESS
)
3553 assert(memc
->hosts
[server_key
].write_buffer_offset
== UDP_DATAGRAM_HEADER_LENGTH
);
3556 assert(memc
->hosts
[server_key
].write_buffer_offset
!= UDP_DATAGRAM_HEADER_LENGTH
);
3557 assert(memc
->hosts
[server_key
].write_buffer_offset
<= MAX_UDP_DATAGRAM_LENGTH
);
3559 assert(post_udp_op_check(memc
,expected_ids
) == TEST_SUCCESS
);
3561 return TEST_SUCCESS
;
3564 static test_return
udp_buffered_delete_test(memcached_st
*memc
)
3566 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_BUFFER_REQUESTS
, 1);
3567 return udp_delete_test(memc
);
3570 test_return
udp_verbosity_test(memcached_st
*memc
)
3572 memcached_return rc
;
3573 uint16_t *expected_ids
= get_udp_request_ids(memc
);
3575 for (x
= 0; x
< memc
->number_of_hosts
;x
++)
3576 increment_request_id(&expected_ids
[x
]);
3578 rc
= memcached_verbosity(memc
,3);
3579 assert(rc
== MEMCACHED_SUCCESS
);
3580 return post_udp_op_check(memc
,expected_ids
);
3583 test_return
udp_quit_test(memcached_st
*memc
)
3585 uint16_t *expected_ids
= get_udp_request_ids(memc
);
3586 memcached_quit(memc
);
3587 return post_udp_op_check(memc
, expected_ids
);
3590 test_return
udp_flush_test(memcached_st
*memc
)
3592 memcached_return rc
;
3593 uint16_t *expected_ids
= get_udp_request_ids(memc
);
3595 for (x
= 0; x
< memc
->number_of_hosts
;x
++)
3596 increment_request_id(&expected_ids
[x
]);
3598 rc
= memcached_flush(memc
,0);
3599 assert(rc
== MEMCACHED_SUCCESS
);
3600 return post_udp_op_check(memc
,expected_ids
);
3603 test_return
udp_incr_test(memcached_st
*memc
)
3605 memcached_return rc
;
3608 rc
= memcached_set(memc
, key
, strlen(key
),
3609 value
, strlen(value
),
3610 (time_t)0, (uint32_t)0);
3612 assert(rc
== MEMCACHED_SUCCESS
);
3613 uint16_t *expected_ids
= get_udp_request_ids(memc
);
3614 unsigned int server_key
= memcached_generate_hash(memc
, key
, strlen(key
));
3615 increment_request_id(&expected_ids
[server_key
]);
3617 rc
= memcached_increment(memc
, key
, strlen(key
), 1, &newvalue
);
3618 assert(rc
== MEMCACHED_SUCCESS
);
3619 return post_udp_op_check(memc
, expected_ids
);
3622 test_return
udp_decr_test(memcached_st
*memc
)
3624 memcached_return rc
;
3627 rc
= memcached_set(memc
, key
, strlen(key
),
3628 value
, strlen(value
),
3629 (time_t)0, (uint32_t)0);
3631 assert(rc
== MEMCACHED_SUCCESS
);
3632 uint16_t *expected_ids
= get_udp_request_ids(memc
);
3633 unsigned int server_key
= memcached_generate_hash(memc
, key
, strlen(key
));
3634 increment_request_id(&expected_ids
[server_key
]);
3636 rc
= memcached_decrement(memc
, key
, strlen(key
), 1, &newvalue
);
3637 assert(rc
== MEMCACHED_SUCCESS
);
3638 return post_udp_op_check(memc
, expected_ids
);
3642 test_return
udp_stat_test(memcached_st
*memc
)
3644 memcached_stat_st
* rv
= NULL
;
3645 memcached_return rc
;
3647 uint16_t *expected_ids
= get_udp_request_ids(memc
);
3648 rv
= memcached_stat(memc
, args
, &rc
);
3650 assert(rc
== MEMCACHED_NOT_SUPPORTED
);
3651 return post_udp_op_check(memc
, expected_ids
);
3654 test_return
udp_version_test(memcached_st
*memc
)
3656 memcached_return rc
;
3657 uint16_t *expected_ids
= get_udp_request_ids(memc
);
3658 rc
= memcached_version(memc
);
3659 assert(rc
== MEMCACHED_NOT_SUPPORTED
);
3660 return post_udp_op_check(memc
, expected_ids
);
3663 test_return
udp_get_test(memcached_st
*memc
)
3665 memcached_return rc
;
3668 uint16_t *expected_ids
= get_udp_request_ids(memc
);
3669 char *val
= memcached_get(memc
, key
, strlen(key
), &vlen
, (uint32_t)0, &rc
);
3670 assert(rc
== MEMCACHED_NOT_SUPPORTED
);
3671 assert(val
== NULL
);
3672 return post_udp_op_check(memc
, expected_ids
);
3675 test_return
udp_mixed_io_test(memcached_st
*memc
)
3678 test_st mixed_io_ops
[] ={
3679 {"udp_set_test", 0, udp_set_test
},
3680 {"udp_set_too_big_test", 0, udp_set_too_big_test
},
3681 {"udp_delete_test", 0, udp_delete_test
},
3682 {"udp_verbosity_test", 0, udp_verbosity_test
},
3683 {"udp_quit_test", 0, udp_quit_test
},
3684 {"udp_flush_test", 0, udp_flush_test
},
3685 {"udp_incr_test", 0, udp_incr_test
},
3686 {"udp_decr_test", 0, udp_decr_test
},
3687 {"udp_version_test", 0, udp_version_test
}
3690 for (x
= 0; x
< 500; x
++)
3692 current_op
= mixed_io_ops
[random() % 9];
3693 assert(current_op
.function(memc
) == TEST_SUCCESS
);
3695 return TEST_SUCCESS
;
3698 test_return
hsieh_avaibility_test (memcached_st
*memc
)
3700 memcached_return expected_rc
= MEMCACHED_FAILURE
;
3701 #ifdef HAVE_HSIEH_HASH
3702 expected_rc
= MEMCACHED_SUCCESS
;
3704 memcached_return rc
= memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_HASH
,
3705 (uint64_t)MEMCACHED_HASH_HSIEH
);
3706 assert(rc
== expected_rc
);
3707 return TEST_SUCCESS
;
3710 test_st udp_setup_server_tests
[] ={
3711 {"set_udp_behavior_test", 0, set_udp_behavior_test
},
3712 {"add_tcp_server_udp_client_test", 0, add_tcp_server_udp_client_test
},
3713 {"add_udp_server_tcp_client_test", 0, add_udp_server_tcp_client_test
},
3717 test_st upd_io_tests
[] ={
3718 {"udp_set_test", 0, udp_set_test
},
3719 {"udp_buffered_set_test", 0, udp_buffered_set_test
},
3720 {"udp_set_too_big_test", 0, udp_set_too_big_test
},
3721 {"udp_delete_test", 0, udp_delete_test
},
3722 {"udp_buffered_delete_test", 0, udp_buffered_delete_test
},
3723 {"udp_verbosity_test", 0, udp_verbosity_test
},
3724 {"udp_quit_test", 0, udp_quit_test
},
3725 {"udp_flush_test", 0, udp_flush_test
},
3726 {"udp_incr_test", 0, udp_incr_test
},
3727 {"udp_decr_test", 0, udp_decr_test
},
3728 {"udp_stat_test", 0, udp_stat_test
},
3729 {"udp_version_test", 0, udp_version_test
},
3730 {"udp_get_test", 0, udp_get_test
},
3731 {"udp_mixed_io_test", 0, udp_mixed_io_test
},
3735 /* Clean the server before beginning testing */
3737 {"flush", 0, flush_test
},
3738 {"init", 0, init_test
},
3739 {"allocation", 0, allocation_test
},
3740 {"server_list_null_test", 0, server_list_null_test
},
3741 {"server_unsort", 0, server_unsort_test
},
3742 {"server_sort", 0, server_sort_test
},
3743 {"server_sort2", 0, server_sort2_test
},
3744 {"clone_test", 0, clone_test
},
3745 {"error", 0, error_test
},
3746 {"set", 0, set_test
},
3747 {"set2", 0, set_test2
},
3748 {"set3", 0, set_test3
},
3749 {"add", 1, add_test
},
3750 {"replace", 1, replace_test
},
3751 {"delete", 1, delete_test
},
3752 {"get", 1, get_test
},
3753 {"get2", 0, get_test2
},
3754 {"get3", 0, get_test3
},
3755 {"get4", 0, get_test4
},
3756 {"partial mget", 0, get_test5
},
3757 {"stats_servername", 0, stats_servername_test
},
3758 {"increment", 0, increment_test
},
3759 {"increment_with_initial", 1, increment_with_initial_test
},
3760 {"decrement", 0, decrement_test
},
3761 {"decrement_with_initial", 1, decrement_with_initial_test
},
3762 {"quit", 0, quit_test
},
3763 {"mget", 1, mget_test
},
3764 {"mget_result", 1, mget_result_test
},
3765 {"mget_result_alloc", 1, mget_result_alloc_test
},
3766 {"mget_result_function", 1, mget_result_function
},
3767 {"get_stats", 0, get_stats
},
3768 {"add_host_test", 0, add_host_test
},
3769 {"add_host_test_1", 0, add_host_test1
},
3770 {"get_stats_keys", 0, get_stats_keys
},
3771 {"behavior_test", 0, get_stats_keys
},
3772 {"callback_test", 0, get_stats_keys
},
3773 {"version_string_test", 0, version_string_test
},
3774 {"bad_key", 1, bad_key_test
},
3775 {"memcached_server_cursor", 1, memcached_server_cursor_test
},
3776 {"read_through", 1, read_through
},
3777 {"delete_through", 1, delete_through
},
3778 {"noreply", 1, noreply_test
},
3779 {"analyzer", 1, analyzer_test
},
3783 test_st async_tests
[] ={
3784 {"add", 1, add_wrapper
},
3788 test_st string_tests
[] ={
3789 {"string static with null", 0, string_static_null
},
3790 {"string alloc with null", 0, string_alloc_null
},
3791 {"string alloc with 1K", 0, string_alloc_with_size
},
3792 {"string alloc with malloc failure", 0, string_alloc_with_size_toobig
},
3793 {"string append", 0, string_alloc_append
},
3794 {"string append failure (too big)", 0, string_alloc_append_toobig
},
3798 test_st result_tests
[] ={
3799 {"result static", 0, result_static
},
3800 {"result alloc", 0, result_alloc
},
3804 test_st version_1_2_3
[] ={
3805 {"append", 0, append_test
},
3806 {"prepend", 0, prepend_test
},
3807 {"cas", 0, cas_test
},
3808 {"cas2", 0, cas2_test
},
3809 {"append_binary", 0, append_binary_test
},
3813 test_st user_tests
[] ={
3814 {"user_supplied_bug1", 0, user_supplied_bug1
},
3815 {"user_supplied_bug2", 0, user_supplied_bug2
},
3816 {"user_supplied_bug3", 0, user_supplied_bug3
},
3817 {"user_supplied_bug4", 0, user_supplied_bug4
},
3818 {"user_supplied_bug5", 1, user_supplied_bug5
},
3819 {"user_supplied_bug6", 1, user_supplied_bug6
},
3820 {"user_supplied_bug7", 1, user_supplied_bug7
},
3821 {"user_supplied_bug8", 1, user_supplied_bug8
},
3822 {"user_supplied_bug9", 1, user_supplied_bug9
},
3823 {"user_supplied_bug10", 1, user_supplied_bug10
},
3824 {"user_supplied_bug11", 1, user_supplied_bug11
},
3825 {"user_supplied_bug12", 1, user_supplied_bug12
},
3826 {"user_supplied_bug13", 1, user_supplied_bug13
},
3827 {"user_supplied_bug14", 1, user_supplied_bug14
},
3828 {"user_supplied_bug15", 1, user_supplied_bug15
},
3829 {"user_supplied_bug16", 1, user_supplied_bug16
},
3832 ** It seems to be something weird with the character sets..
3833 ** value_fetch is unable to parse the value line (iscntrl "fails"), so I
3834 ** guess I need to find out how this is supposed to work.. Perhaps I need
3835 ** to run the test in a specific locale (I tried zh_CN.UTF-8 without success,
3836 ** so just disable the code for now...).
3838 {"user_supplied_bug17", 1, user_supplied_bug17
},
3840 {"user_supplied_bug18", 1, user_supplied_bug18
},
3841 {"user_supplied_bug19", 1, user_supplied_bug19
},
3842 {"user_supplied_bug20", 1, user_supplied_bug20
},
3846 test_st generate_tests
[] ={
3847 {"generate_pairs", 1, generate_pairs
},
3848 {"generate_data", 1, generate_data
},
3849 {"get_read", 0, get_read
},
3850 {"delete_generate", 0, delete_generate
},
3851 {"generate_buffer_data", 1, generate_buffer_data
},
3852 {"delete_buffer", 0, delete_buffer_generate
},
3853 {"generate_data", 1, generate_data
},
3854 {"mget_read", 0, mget_read
},
3855 {"mget_read_result", 0, mget_read_result
},
3856 {"mget_read_function", 0, mget_read_function
},
3857 {"cleanup", 1, cleanup_pairs
},
3858 {"generate_large_pairs", 1, generate_large_pairs
},
3859 {"generate_data", 1, generate_data
},
3860 {"generate_buffer_data", 1, generate_buffer_data
},
3861 {"cleanup", 1, cleanup_pairs
},
3865 test_st consistent_tests
[] ={
3866 {"generate_pairs", 1, generate_pairs
},
3867 {"generate_data", 1, generate_data
},
3868 {"get_read", 0, get_read_count
},
3869 {"cleanup", 1, cleanup_pairs
},
3873 test_st consistent_weighted_tests
[] ={
3874 {"generate_pairs", 1, generate_pairs
},
3875 {"generate_data", 1, generate_data_with_stats
},
3876 {"get_read", 0, get_read_count
},
3877 {"cleanup", 1, cleanup_pairs
},
3881 test_st hsieh_availability
[] ={
3882 {"hsieh_avaibility_test",0,hsieh_avaibility_test
},
3886 test_st ketama_auto_eject_hosts
[] ={
3887 {"auto_eject_hosts", 1, auto_eject_hosts
},
3891 collection_st collection
[] ={
3892 {"hsieh_availability",0,0,hsieh_availability
},
3893 {"udp_setup", init_udp
, 0, udp_setup_server_tests
},
3894 {"udp_io", init_udp
, 0, upd_io_tests
},
3895 {"udp_binary_io", binary_init_udp
, 0, upd_io_tests
},
3896 {"block", 0, 0, tests
},
3897 {"binary", pre_binary
, 0, tests
},
3898 {"nonblock", pre_nonblock
, 0, tests
},
3899 {"nodelay", pre_nodelay
, 0, tests
},
3900 {"settimer", pre_settimer
, 0, tests
},
3901 {"md5", pre_md5
, 0, tests
},
3902 {"crc", pre_crc
, 0, tests
},
3903 {"hsieh", pre_hsieh
, 0, tests
},
3904 {"jenkins", pre_jenkins
, 0, tests
},
3905 {"fnv1_64", pre_hash_fnv1_64
, 0, tests
},
3906 {"fnv1a_64", pre_hash_fnv1a_64
, 0, tests
},
3907 {"fnv1_32", pre_hash_fnv1_32
, 0, tests
},
3908 {"fnv1a_32", pre_hash_fnv1a_32
, 0, tests
},
3909 {"ketama", pre_behavior_ketama
, 0, tests
},
3910 {"ketama_auto_eject_hosts", pre_behavior_ketama
, 0, ketama_auto_eject_hosts
},
3911 {"unix_socket", pre_unix_socket
, 0, tests
},
3912 {"unix_socket_nodelay", pre_nodelay
, 0, tests
},
3913 {"poll_timeout", poll_timeout
, 0, tests
},
3914 {"gets", enable_cas
, 0, tests
},
3915 {"consistent", enable_consistent
, 0, tests
},
3916 {"memory_allocators", set_memory_alloc
, 0, tests
},
3917 {"prefix", set_prefix
, 0, tests
},
3918 {"version_1_2_3", check_for_1_2_3
, 0, version_1_2_3
},
3919 {"string", 0, 0, string_tests
},
3920 {"result", 0, 0, result_tests
},
3921 {"async", pre_nonblock
, 0, async_tests
},
3922 {"async_binary", pre_nonblock_binary
, 0, async_tests
},
3923 {"user", 0, 0, user_tests
},
3924 {"generate", 0, 0, generate_tests
},
3925 {"generate_hsieh", pre_hsieh
, 0, generate_tests
},
3926 {"generate_ketama", pre_behavior_ketama
, 0, generate_tests
},
3927 {"generate_hsieh_consistent", enable_consistent
, 0, generate_tests
},
3928 {"generate_md5", pre_md5
, 0, generate_tests
},
3929 {"generate_murmur", pre_murmur
, 0, generate_tests
},
3930 {"generate_jenkins", pre_jenkins
, 0, generate_tests
},
3931 {"generate_nonblock", pre_nonblock
, 0, generate_tests
},
3932 {"consistent_not", 0, 0, consistent_tests
},
3933 {"consistent_ketama", pre_behavior_ketama
, 0, consistent_tests
},
3934 {"consistent_ketama_weighted", pre_behavior_ketama_weighted
, 0, consistent_weighted_tests
},
3938 #define SERVERS_TO_CREATE 5
3940 /* Prototypes for functions we will pass to test framework */
3941 void *world_create(void);
3942 void world_destroy(void *p
);
3944 void *world_create(void)
3946 server_startup_st
*construct
;
3948 construct
= (server_startup_st
*)malloc(sizeof(server_startup_st
));
3949 memset(construct
, 0, sizeof(server_startup_st
));
3950 construct
->count
= SERVERS_TO_CREATE
;
3952 server_startup(construct
);
3958 void world_destroy(void *p
)
3960 server_startup_st
*construct
= (server_startup_st
*)p
;
3961 memcached_server_st
*servers
= (memcached_server_st
*)construct
->servers
;
3962 memcached_server_list_free(servers
);
3964 server_shutdown(construct
);
3968 void get_world(world_st
*world
)
3970 world
->collections
= collection
;
3971 world
->create
= world_create
;
3972 world
->destroy
= world_destroy
;