2 Sample test application.
4 #include "libmemcached/common.h"
11 #include <sys/types.h>
16 #include "clients/generator.h"
17 #include "clients/execute.h"
20 #define INT64_MAX LONG_MAX
23 #define INT32_MAX INT_MAX
29 #ifdef HAVE_LIBMEMCACHEDUTIL
31 #include "libmemcached/memcached_util.h"
34 #define GLOBAL_COUNT 10000
35 #define GLOBAL2_COUNT 100
36 #define SERVERS_TO_CREATE 5
37 static uint32_t global_count
;
39 static pairs_st
*global_pairs
;
40 static char *global_keys
[GLOBAL_COUNT
];
41 static size_t global_keys_length
[GLOBAL_COUNT
];
43 static test_return
init_test(memcached_st
*not_used
__attribute__((unused
)))
47 (void)memcached_create(&memc
);
48 memcached_free(&memc
);
53 static test_return
server_list_null_test(memcached_st
*ptr
__attribute__((unused
)))
55 memcached_server_st
*server_list
;
58 server_list
= memcached_server_list_append_with_weight(NULL
, NULL
, 0, 0, NULL
);
59 assert(server_list
== NULL
);
61 server_list
= memcached_server_list_append_with_weight(NULL
, "localhost", 0, 0, NULL
);
62 assert(server_list
== NULL
);
64 server_list
= memcached_server_list_append_with_weight(NULL
, NULL
, 0, 0, &rc
);
65 assert(server_list
== NULL
);
70 #define TEST_PORT_COUNT 7
71 uint32_t test_ports
[TEST_PORT_COUNT
];
73 static memcached_return
server_display_function(memcached_st
*ptr
__attribute__((unused
)), memcached_server_st
*server
, void *context
)
76 uint32_t bigger
= *((uint32_t *)(context
));
77 assert(bigger
<= server
->port
);
78 *((uint32_t *)(context
))= server
->port
;
80 return MEMCACHED_SUCCESS
;
83 static test_return
server_sort_test(memcached_st
*ptr
__attribute__((unused
)))
86 uint32_t bigger
= 0; /* Prime the value for the assert in server_display_function */
88 memcached_server_function callbacks
[1];
89 memcached_st
*local_memc
;
91 local_memc
= memcached_create(NULL
);
93 memcached_behavior_set(local_memc
, MEMCACHED_BEHAVIOR_SORT_HOSTS
, 1);
95 for (x
= 0; x
< TEST_PORT_COUNT
; x
++)
97 test_ports
[x
]= random() % 64000;
98 rc
= memcached_server_add_with_weight(local_memc
, "localhost", test_ports
[x
], 0);
99 assert(local_memc
->number_of_hosts
== x
+ 1);
100 assert(local_memc
->hosts
[0].count
== x
+1);
101 assert(rc
== MEMCACHED_SUCCESS
);
104 callbacks
[0]= server_display_function
;
105 memcached_server_cursor(local_memc
, callbacks
, (void *)&bigger
, 1);
108 memcached_free(local_memc
);
113 static test_return
server_sort2_test(memcached_st
*ptr
__attribute__((unused
)))
115 uint32_t bigger
= 0; /* Prime the value for the assert in server_display_function */
117 memcached_server_function callbacks
[1];
118 memcached_st
*local_memc
;
120 local_memc
= memcached_create(NULL
);
122 rc
= memcached_behavior_set(local_memc
, MEMCACHED_BEHAVIOR_SORT_HOSTS
, 1);
123 assert(rc
== MEMCACHED_SUCCESS
);
125 rc
= memcached_server_add_with_weight(local_memc
, "MEMCACHED_BEHAVIOR_SORT_HOSTS", 43043, 0);
126 assert(rc
== MEMCACHED_SUCCESS
);
127 assert(local_memc
->hosts
[0].port
== 43043);
129 rc
= memcached_server_add_with_weight(local_memc
, "MEMCACHED_BEHAVIOR_SORT_HOSTS", 43042, 0);
130 assert(rc
== MEMCACHED_SUCCESS
);
131 assert(local_memc
->hosts
[0].port
== 43042);
132 assert(local_memc
->hosts
[1].port
== 43043);
134 callbacks
[0]= server_display_function
;
135 memcached_server_cursor(local_memc
, callbacks
, (void *)&bigger
, 1);
138 memcached_free(local_memc
);
143 static memcached_return
server_display_unsort_function(memcached_st
*ptr
__attribute__((unused
)), memcached_server_st
*server
, void *context
)
146 uint32_t x
= *((uint32_t *)(context
));
148 assert(test_ports
[x
] == server
->port
);
149 *((uint32_t *)(context
))= ++x
;
151 return MEMCACHED_SUCCESS
;
154 static test_return
server_unsort_test(memcached_st
*ptr
__attribute__((unused
)))
157 uint32_t counter
= 0; /* Prime the value for the assert in server_display_function */
158 uint32_t bigger
= 0; /* Prime the value for the assert in server_display_function */
160 memcached_server_function callbacks
[1];
161 memcached_st
*local_memc
;
163 local_memc
= memcached_create(NULL
);
166 for (x
= 0; x
< TEST_PORT_COUNT
; x
++)
168 test_ports
[x
]= random() % 64000;
169 rc
= memcached_server_add_with_weight(local_memc
, "localhost", test_ports
[x
], 0);
170 assert(local_memc
->number_of_hosts
== x
+1);
171 assert(local_memc
->hosts
[0].count
== x
+1);
172 assert(rc
== MEMCACHED_SUCCESS
);
175 callbacks
[0]= server_display_unsort_function
;
176 memcached_server_cursor(local_memc
, callbacks
, (void *)&counter
, 1);
178 /* Now we sort old data! */
179 memcached_behavior_set(local_memc
, MEMCACHED_BEHAVIOR_SORT_HOSTS
, 1);
180 callbacks
[0]= server_display_function
;
181 memcached_server_cursor(local_memc
, callbacks
, (void *)&bigger
, 1);
184 memcached_free(local_memc
);
189 static test_return
allocation_test(memcached_st
*not_used
__attribute__((unused
)))
192 memc
= memcached_create(NULL
);
194 memcached_free(memc
);
199 static test_return
clone_test(memcached_st
*memc
)
204 clone
= memcached_clone(NULL
, NULL
);
206 memcached_free(clone
);
209 /* Can we init from null? */
212 clone
= memcached_clone(NULL
, memc
);
215 assert(clone
->call_free
== memc
->call_free
);
216 assert(clone
->call_malloc
== memc
->call_malloc
);
217 assert(clone
->call_realloc
== memc
->call_realloc
);
218 assert(clone
->call_calloc
== memc
->call_calloc
);
219 assert(clone
->connect_timeout
== memc
->connect_timeout
);
220 assert(clone
->delete_trigger
== memc
->delete_trigger
);
221 assert(clone
->distribution
== memc
->distribution
);
222 assert(clone
->flags
== memc
->flags
);
223 assert(clone
->get_key_failure
== memc
->get_key_failure
);
224 assert(clone
->hash
== memc
->hash
);
225 assert(clone
->hash_continuum
== memc
->hash_continuum
);
226 assert(clone
->io_bytes_watermark
== memc
->io_bytes_watermark
);
227 assert(clone
->io_msg_watermark
== memc
->io_msg_watermark
);
228 assert(clone
->io_key_prefetch
== memc
->io_key_prefetch
);
229 assert(clone
->on_cleanup
== memc
->on_cleanup
);
230 assert(clone
->on_clone
== memc
->on_clone
);
231 assert(clone
->poll_timeout
== memc
->poll_timeout
);
232 assert(clone
->rcv_timeout
== memc
->rcv_timeout
);
233 assert(clone
->recv_size
== memc
->recv_size
);
234 assert(clone
->retry_timeout
== memc
->retry_timeout
);
235 assert(clone
->send_size
== memc
->send_size
);
236 assert(clone
->server_failure_limit
== memc
->server_failure_limit
);
237 assert(clone
->snd_timeout
== memc
->snd_timeout
);
238 assert(clone
->user_data
== memc
->user_data
);
240 memcached_free(clone
);
243 /* Can we init from struct? */
245 memcached_st declared_clone
;
247 memset(&declared_clone
, 0 , sizeof(memcached_st
));
248 clone
= memcached_clone(&declared_clone
, NULL
);
250 memcached_free(clone
);
253 /* Can we init from struct? */
255 memcached_st declared_clone
;
257 memset(&declared_clone
, 0 , sizeof(memcached_st
));
258 clone
= memcached_clone(&declared_clone
, memc
);
260 memcached_free(clone
);
266 static test_return
userdata_test(memcached_st
*memc
)
269 assert(memcached_set_user_data(memc
, foo
) == NULL
);
270 assert(memcached_get_user_data(memc
) == foo
);
271 assert(memcached_set_user_data(memc
, NULL
) == foo
);
276 static test_return
connection_test(memcached_st
*memc
)
280 rc
= memcached_server_add_with_weight(memc
, "localhost", 0, 0);
281 assert(rc
== MEMCACHED_SUCCESS
);
286 static test_return
error_test(memcached_st
*memc
)
290 for (rc
= MEMCACHED_SUCCESS
; rc
< MEMCACHED_MAXIMUM_RETURN
; rc
++)
292 printf("Error %d -> %s\n", rc
, memcached_strerror(memc
, rc
));
298 static test_return
set_test(memcached_st
*memc
)
302 char *value
= "when we sanitize";
304 rc
= memcached_set(memc
, key
, strlen(key
),
305 value
, strlen(value
),
306 (time_t)0, (uint32_t)0);
307 assert(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
);
312 static test_return
append_test(memcached_st
*memc
)
320 rc
= memcached_flush(memc
, 0);
321 assert(rc
== MEMCACHED_SUCCESS
);
323 rc
= memcached_set(memc
, key
, strlen(key
),
324 value
, strlen(value
),
325 (time_t)0, (uint32_t)0);
326 assert(rc
== MEMCACHED_SUCCESS
);
328 rc
= memcached_append(memc
, key
, strlen(key
),
329 " the", strlen(" the"),
330 (time_t)0, (uint32_t)0);
331 assert(rc
== MEMCACHED_SUCCESS
);
333 rc
= memcached_append(memc
, key
, strlen(key
),
334 " people", strlen(" people"),
335 (time_t)0, (uint32_t)0);
336 assert(rc
== MEMCACHED_SUCCESS
);
338 value
= memcached_get(memc
, key
, strlen(key
),
339 &value_length
, &flags
, &rc
);
340 assert(!memcmp(value
, "we the people", strlen("we the people")));
341 assert(strlen("we the people") == value_length
);
342 assert(rc
== MEMCACHED_SUCCESS
);
348 static test_return
append_binary_test(memcached_st
*memc
)
351 char *key
= "numbers";
352 unsigned int *store_ptr
;
353 unsigned int store_list
[] = { 23, 56, 499, 98, 32847, 0 };
359 rc
= memcached_flush(memc
, 0);
360 assert(rc
== MEMCACHED_SUCCESS
);
362 rc
= memcached_set(memc
,
365 (time_t)0, (uint32_t)0);
366 assert(rc
== MEMCACHED_SUCCESS
);
368 for (x
= 0; store_list
[x
] ; x
++)
370 rc
= memcached_append(memc
,
372 (char *)&store_list
[x
], sizeof(unsigned int),
373 (time_t)0, (uint32_t)0);
374 assert(rc
== MEMCACHED_SUCCESS
);
377 value
= memcached_get(memc
, key
, strlen(key
),
378 &value_length
, &flags
, &rc
);
379 assert((value_length
== (sizeof(unsigned int) * x
)));
380 assert(rc
== MEMCACHED_SUCCESS
);
382 store_ptr
= (unsigned int *)value
;
384 while ((size_t)store_ptr
< (size_t)(value
+ value_length
))
386 assert(*store_ptr
== store_list
[x
++]);
394 static test_return
cas2_test(memcached_st
*memc
)
397 char *keys
[]= {"fudge", "son", "food"};
398 size_t key_length
[]= {5, 3, 4};
399 char *value
= "we the people";
400 size_t value_length
= strlen("we the people");
402 memcached_result_st results_obj
;
403 memcached_result_st
*results
;
406 rc
= memcached_flush(memc
, 0);
407 assert(rc
== MEMCACHED_SUCCESS
);
409 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_SUPPORT_CAS
, set
);
411 for (x
= 0; x
< 3; x
++)
413 rc
= memcached_set(memc
, keys
[x
], key_length
[x
],
414 keys
[x
], key_length
[x
],
415 (time_t)50, (uint32_t)9);
416 assert(rc
== MEMCACHED_SUCCESS
);
419 rc
= memcached_mget(memc
, keys
, key_length
, 3);
421 results
= memcached_result_create(memc
, &results_obj
);
423 results
= memcached_fetch_result(memc
, &results_obj
, &rc
);
425 assert(results
->cas
);
426 assert(rc
== MEMCACHED_SUCCESS
);
427 WATCHPOINT_ASSERT(memcached_result_cas(results
));
429 assert(!memcmp(value
, "we the people", strlen("we the people")));
430 assert(strlen("we the people") == value_length
);
431 assert(rc
== MEMCACHED_SUCCESS
);
433 memcached_result_free(&results_obj
);
438 static test_return
cas_test(memcached_st
*memc
)
441 const char *key
= "fun";
442 size_t key_length
= strlen(key
);
443 const char *value
= "we the people";
444 char* keys
[2] = { (char*)key
, NULL
};
445 size_t keylengths
[2] = { strlen(key
), 0 };
446 size_t value_length
= strlen(value
);
447 const char *value2
= "change the value";
448 size_t value2_length
= strlen(value2
);
450 memcached_result_st results_obj
;
451 memcached_result_st
*results
;
454 rc
= memcached_flush(memc
, 0);
455 assert(rc
== MEMCACHED_SUCCESS
);
457 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_SUPPORT_CAS
, set
);
459 rc
= memcached_set(memc
, key
, strlen(key
),
460 value
, strlen(value
),
461 (time_t)0, (uint32_t)0);
462 assert(rc
== MEMCACHED_SUCCESS
);
464 rc
= memcached_mget(memc
, keys
, keylengths
, 1);
466 results
= memcached_result_create(memc
, &results_obj
);
468 results
= memcached_fetch_result(memc
, &results_obj
, &rc
);
470 assert(rc
== MEMCACHED_SUCCESS
);
471 WATCHPOINT_ASSERT(memcached_result_cas(results
));
472 assert(!memcmp(value
, memcached_result_value(results
), value_length
));
473 assert(strlen(memcached_result_value(results
)) == value_length
);
474 assert(rc
== MEMCACHED_SUCCESS
);
475 uint64_t cas
= memcached_result_cas(results
);
478 results
= memcached_fetch_result(memc
, &results_obj
, &rc
);
479 assert(rc
== MEMCACHED_END
);
480 assert(results
== NULL
);
483 rc
= memcached_cas(memc
, key
, key_length
, value2
, value2_length
, 0, 0, cas
);
484 assert(rc
== MEMCACHED_SUCCESS
);
487 * The item will have a new cas value, so try to set it again with the old
488 * value. This should fail!
490 rc
= memcached_cas(memc
, key
, key_length
, value2
, value2_length
, 0, 0, cas
);
491 assert(rc
== MEMCACHED_DATA_EXISTS
);
493 memcached_result_free(&results_obj
);
498 static test_return
prepend_test(memcached_st
*memc
)
502 char *value
= "people";
506 rc
= memcached_flush(memc
, 0);
507 assert(rc
== MEMCACHED_SUCCESS
);
509 rc
= memcached_set(memc
, key
, strlen(key
),
510 value
, strlen(value
),
511 (time_t)0, (uint32_t)0);
512 assert(rc
== MEMCACHED_SUCCESS
);
514 rc
= memcached_prepend(memc
, key
, strlen(key
),
515 "the ", strlen("the "),
516 (time_t)0, (uint32_t)0);
517 assert(rc
== MEMCACHED_SUCCESS
);
519 rc
= memcached_prepend(memc
, key
, strlen(key
),
520 "we ", strlen("we "),
521 (time_t)0, (uint32_t)0);
522 assert(rc
== MEMCACHED_SUCCESS
);
524 value
= memcached_get(memc
, key
, strlen(key
),
525 &value_length
, &flags
, &rc
);
526 assert(!memcmp(value
, "we the people", strlen("we the people")));
527 assert(strlen("we the people") == value_length
);
528 assert(rc
== MEMCACHED_SUCCESS
);
535 Set the value, then quit to make sure it is flushed.
536 Come back in and test that add fails.
538 static test_return
add_test(memcached_st
*memc
)
542 char *value
= "when we sanitize";
543 unsigned long long setting_value
;
545 setting_value
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_NO_BLOCK
);
547 rc
= memcached_set(memc
, key
, strlen(key
),
548 value
, strlen(value
),
549 (time_t)0, (uint32_t)0);
550 assert(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
);
551 memcached_quit(memc
);
552 rc
= memcached_add(memc
, key
, strlen(key
),
553 value
, strlen(value
),
554 (time_t)0, (uint32_t)0);
556 /* Too many broken OS'es have broken loopback in async, so we can't be sure of the result */
558 assert(rc
== MEMCACHED_NOTSTORED
|| rc
== MEMCACHED_STORED
);
560 assert(rc
== MEMCACHED_NOTSTORED
|| rc
== MEMCACHED_DATA_EXISTS
);
566 ** There was a problem of leaking filedescriptors in the initial release
567 ** of MacOSX 10.5. This test case triggers the problem. On some Solaris
568 ** systems it seems that the kernel is slow on reclaiming the resources
569 ** because the connects starts to time out (the test doesn't do much
570 ** anyway, so just loop 10 iterations)
572 static test_return
add_wrapper(memcached_st
*memc
)
575 unsigned int max
= 10000;
580 for (x
= 0; x
< max
; x
++)
586 static test_return
replace_test(memcached_st
*memc
)
590 char *value
= "when we sanitize";
591 char *original
= "first we insert some data";
593 rc
= memcached_set(memc
, key
, strlen(key
),
594 original
, strlen(original
),
595 (time_t)0, (uint32_t)0);
596 assert(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
);
598 rc
= memcached_replace(memc
, key
, strlen(key
),
599 value
, strlen(value
),
600 (time_t)0, (uint32_t)0);
601 assert(rc
== MEMCACHED_SUCCESS
);
606 static test_return
delete_test(memcached_st
*memc
)
610 char *value
= "when we sanitize";
612 rc
= memcached_set(memc
, key
, strlen(key
),
613 value
, strlen(value
),
614 (time_t)0, (uint32_t)0);
615 assert(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
);
617 rc
= memcached_delete(memc
, key
, strlen(key
), (time_t)0);
618 assert(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
);
623 static test_return
flush_test(memcached_st
*memc
)
627 rc
= memcached_flush(memc
, 0);
628 assert(rc
== MEMCACHED_SUCCESS
);
633 static memcached_return
server_function(memcached_st
*ptr
__attribute__((unused
)),
634 memcached_server_st
*server
__attribute__((unused
)),
635 void *context
__attribute__((unused
)))
639 return MEMCACHED_SUCCESS
;
642 static test_return
memcached_server_cursor_test(memcached_st
*memc
)
644 char *context
= "foo bad";
645 memcached_server_function callbacks
[1];
647 callbacks
[0]= server_function
;
648 memcached_server_cursor(memc
, callbacks
, context
, 1);
653 static test_return
bad_key_test(memcached_st
*memc
)
656 char *key
= "foo bad";
658 size_t string_length
;
662 size_t max_keylen
= 0xffff;
664 clone
= memcached_clone(NULL
, memc
);
667 rc
= memcached_behavior_set(clone
, MEMCACHED_BEHAVIOR_VERIFY_KEY
, set
);
668 assert(rc
== MEMCACHED_SUCCESS
);
670 /* All keys are valid in the binary protocol (except for length) */
671 if (memcached_behavior_get(clone
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
) == 0)
673 string
= memcached_get(clone
, key
, strlen(key
),
674 &string_length
, &flags
, &rc
);
675 assert(rc
== MEMCACHED_BAD_KEY_PROVIDED
);
676 assert(string_length
== 0);
680 rc
= memcached_behavior_set(clone
, MEMCACHED_BEHAVIOR_VERIFY_KEY
, set
);
681 assert(rc
== MEMCACHED_SUCCESS
);
682 string
= memcached_get(clone
, key
, strlen(key
),
683 &string_length
, &flags
, &rc
);
684 assert(rc
== MEMCACHED_NOTFOUND
);
685 assert(string_length
== 0);
688 /* Test multi key for bad keys */
689 char *keys
[] = { "GoodKey", "Bad Key", "NotMine" };
690 size_t key_lengths
[] = { 7, 7, 7 };
692 rc
= memcached_behavior_set(clone
, MEMCACHED_BEHAVIOR_VERIFY_KEY
, set
);
693 assert(rc
== MEMCACHED_SUCCESS
);
695 rc
= memcached_mget(clone
, keys
, key_lengths
, 3);
696 assert(rc
== MEMCACHED_BAD_KEY_PROVIDED
);
698 rc
= memcached_mget_by_key(clone
, "foo daddy", 9, keys
, key_lengths
, 1);
699 assert(rc
== MEMCACHED_BAD_KEY_PROVIDED
);
703 /* The following test should be moved to the end of this function when the
704 memcached server is updated to allow max size length of the keys in the
707 rc
= memcached_callback_set(clone
, MEMCACHED_CALLBACK_PREFIX_KEY
, NULL
);
708 assert(rc
== MEMCACHED_SUCCESS
);
710 char *longkey
= malloc(max_keylen
+ 1);
713 memset(longkey
, 'a', max_keylen
+ 1);
714 string
= memcached_get(clone
, longkey
, max_keylen
,
715 &string_length
, &flags
, &rc
);
716 assert(rc
== MEMCACHED_NOTFOUND
);
717 assert(string_length
== 0);
720 string
= memcached_get(clone
, longkey
, max_keylen
+ 1,
721 &string_length
, &flags
, &rc
);
722 assert(rc
== MEMCACHED_BAD_KEY_PROVIDED
);
723 assert(string_length
== 0);
730 /* Make sure zero length keys are marked as bad */
732 rc
= memcached_behavior_set(clone
, MEMCACHED_BEHAVIOR_VERIFY_KEY
, set
);
733 assert(rc
== MEMCACHED_SUCCESS
);
734 string
= memcached_get(clone
, key
, 0,
735 &string_length
, &flags
, &rc
);
736 assert(rc
== MEMCACHED_BAD_KEY_PROVIDED
);
737 assert(string_length
== 0);
740 memcached_free(clone
);
745 #define READ_THROUGH_VALUE "set for me"
746 static memcached_return
read_through_trigger(memcached_st
*memc
__attribute__((unused
)),
747 char *key
__attribute__((unused
)),
748 size_t key_length
__attribute__((unused
)),
749 memcached_result_st
*result
)
752 return memcached_result_set_value(result
, READ_THROUGH_VALUE
, strlen(READ_THROUGH_VALUE
));
755 static test_return
read_through(memcached_st
*memc
)
760 size_t string_length
;
762 memcached_trigger_key cb
= (memcached_trigger_key
)read_through_trigger
;
764 string
= memcached_get(memc
, key
, strlen(key
),
765 &string_length
, &flags
, &rc
);
767 assert(rc
== MEMCACHED_NOTFOUND
);
768 assert(string_length
== 0);
771 rc
= memcached_callback_set(memc
, MEMCACHED_CALLBACK_GET_FAILURE
,
773 assert(rc
== MEMCACHED_SUCCESS
);
775 string
= memcached_get(memc
, key
, strlen(key
),
776 &string_length
, &flags
, &rc
);
778 assert(rc
== MEMCACHED_SUCCESS
);
779 assert(string_length
== strlen(READ_THROUGH_VALUE
));
780 assert(!strcmp(READ_THROUGH_VALUE
, string
));
783 string
= memcached_get(memc
, key
, strlen(key
),
784 &string_length
, &flags
, &rc
);
786 assert(rc
== MEMCACHED_SUCCESS
);
787 assert(string_length
== strlen(READ_THROUGH_VALUE
));
788 assert(!strcmp(READ_THROUGH_VALUE
, string
));
794 static memcached_return
delete_trigger(memcached_st
*ptr
__attribute__((unused
)),
796 size_t key_length
__attribute__((unused
)))
800 return MEMCACHED_SUCCESS
;
803 static test_return
delete_through(memcached_st
*memc
)
805 memcached_trigger_delete_key callback
;
808 callback
= (memcached_trigger_delete_key
)delete_trigger
;
810 rc
= memcached_callback_set(memc
, MEMCACHED_CALLBACK_DELETE_TRIGGER
, *(void**)&callback
);
811 assert(rc
== MEMCACHED_SUCCESS
);
816 static test_return
get_test(memcached_st
*memc
)
821 size_t string_length
;
824 rc
= memcached_delete(memc
, key
, strlen(key
), (time_t)0);
825 assert(rc
== MEMCACHED_BUFFERED
|| rc
== MEMCACHED_NOTFOUND
);
827 string
= memcached_get(memc
, key
, strlen(key
),
828 &string_length
, &flags
, &rc
);
830 assert(rc
== MEMCACHED_NOTFOUND
);
831 assert(string_length
== 0);
837 static test_return
get_test2(memcached_st
*memc
)
841 char *value
= "when we sanitize";
843 size_t string_length
;
846 rc
= memcached_set(memc
, key
, strlen(key
),
847 value
, strlen(value
),
848 (time_t)0, (uint32_t)0);
849 assert(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
);
851 string
= memcached_get(memc
, key
, strlen(key
),
852 &string_length
, &flags
, &rc
);
855 assert(rc
== MEMCACHED_SUCCESS
);
856 assert(string_length
== strlen(value
));
857 assert(!memcmp(string
, value
, string_length
));
864 static test_return
set_test2(memcached_st
*memc
)
868 char *value
= "train in the brain";
869 size_t value_length
= strlen(value
);
872 for (x
= 0; x
< 10; x
++)
874 rc
= memcached_set(memc
, key
, strlen(key
),
876 (time_t)0, (uint32_t)0);
877 assert(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
);
883 static test_return
set_test3(memcached_st
*memc
)
887 size_t value_length
= 8191;
890 value
= (char*)malloc(value_length
);
893 for (x
= 0; x
< value_length
; x
++)
894 value
[x
] = (char) (x
% 127);
896 /* The dump test relies on there being at least 32 items in memcached */
897 for (x
= 0; x
< 32; x
++)
901 sprintf(key
, "foo%u", x
);
903 rc
= memcached_set(memc
, key
, strlen(key
),
905 (time_t)0, (uint32_t)0);
906 assert(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
);
914 static test_return
get_test3(memcached_st
*memc
)
919 size_t value_length
= 8191;
921 size_t string_length
;
925 value
= (char*)malloc(value_length
);
928 for (x
= 0; x
< value_length
; x
++)
929 value
[x
] = (char) (x
% 127);
931 rc
= memcached_set(memc
, key
, strlen(key
),
933 (time_t)0, (uint32_t)0);
934 assert(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
);
936 string
= memcached_get(memc
, key
, strlen(key
),
937 &string_length
, &flags
, &rc
);
939 assert(rc
== MEMCACHED_SUCCESS
);
941 assert(string_length
== value_length
);
942 assert(!memcmp(string
, value
, string_length
));
950 static test_return
get_test4(memcached_st
*memc
)
955 size_t value_length
= 8191;
957 size_t string_length
;
961 value
= (char*)malloc(value_length
);
964 for (x
= 0; x
< value_length
; x
++)
965 value
[x
] = (char) (x
% 127);
967 rc
= memcached_set(memc
, key
, strlen(key
),
969 (time_t)0, (uint32_t)0);
970 assert(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
);
972 for (x
= 0; x
< 10; x
++)
974 string
= memcached_get(memc
, key
, strlen(key
),
975 &string_length
, &flags
, &rc
);
977 assert(rc
== MEMCACHED_SUCCESS
);
979 assert(string_length
== value_length
);
980 assert(!memcmp(string
, value
, string_length
));
990 * This test verifies that memcached_read_one_response doesn't try to
991 * dereference a NIL-pointer if you issue a multi-get and don't read out all
992 * responses before you execute a storage command.
994 static test_return
get_test5(memcached_st
*memc
)
997 ** Request the same key twice, to ensure that we hash to the same server
998 ** (so that we have multiple response values queued up) ;-)
1000 char *keys
[]= { "key", "key" };
1001 size_t lengths
[]= { 3, 3 };
1005 memcached_return rc
= memcached_set(memc
, keys
[0], lengths
[0],
1006 keys
[0], lengths
[0], 0, 0);
1007 assert(rc
== MEMCACHED_SUCCESS
);
1008 rc
= memcached_mget(memc
, keys
, lengths
, 2);
1010 memcached_result_st results_obj
;
1011 memcached_result_st
*results
;
1012 results
=memcached_result_create(memc
, &results_obj
);
1014 results
=memcached_fetch_result(memc
, &results_obj
, &rc
);
1016 memcached_result_free(&results_obj
);
1018 /* Don't read out the second result, but issue a set instead.. */
1019 rc
= memcached_set(memc
, keys
[0], lengths
[0], keys
[0], lengths
[0], 0, 0);
1020 assert(rc
== MEMCACHED_SUCCESS
);
1022 char *val
= memcached_get_by_key(memc
, keys
[0], lengths
[0], "yek", 3,
1023 &rlen
, &flags
, &rc
);
1024 assert(val
== NULL
);
1025 assert(rc
== MEMCACHED_NOTFOUND
);
1026 val
= memcached_get(memc
, keys
[0], lengths
[0], &rlen
, &flags
, &rc
);
1027 assert(val
!= NULL
);
1028 assert(rc
== MEMCACHED_SUCCESS
);
1031 return TEST_SUCCESS
;
1034 /* Do not copy the style of this code, I just access hosts to testthis function */
1035 static test_return
stats_servername_test(memcached_st
*memc
)
1037 memcached_return rc
;
1038 memcached_stat_st stat
;
1039 rc
= memcached_stat_servername(&stat
, NULL
,
1040 memc
->hosts
[0].hostname
,
1041 memc
->hosts
[0].port
);
1046 static test_return
increment_test(memcached_st
*memc
)
1048 uint64_t new_number
;
1049 memcached_return rc
;
1050 char *key
= "number";
1053 rc
= memcached_set(memc
, key
, strlen(key
),
1054 value
, strlen(value
),
1055 (time_t)0, (uint32_t)0);
1056 assert(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
);
1058 rc
= memcached_increment(memc
, key
, strlen(key
),
1060 assert(rc
== MEMCACHED_SUCCESS
);
1061 assert(new_number
== 1);
1063 rc
= memcached_increment(memc
, key
, strlen(key
),
1065 assert(rc
== MEMCACHED_SUCCESS
);
1066 assert(new_number
== 2);
1071 static test_return
increment_with_initial_test(memcached_st
*memc
)
1073 if (memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
) != 0)
1075 uint64_t new_number
;
1076 memcached_return rc
;
1077 char *key
= "number";
1078 uint64_t initial
= 0;
1080 rc
= memcached_increment_with_initial(memc
, key
, strlen(key
),
1081 1, initial
, 0, &new_number
);
1082 assert(rc
== MEMCACHED_SUCCESS
);
1083 assert(new_number
== initial
);
1085 rc
= memcached_increment_with_initial(memc
, key
, strlen(key
),
1086 1, initial
, 0, &new_number
);
1087 assert(rc
== MEMCACHED_SUCCESS
);
1088 assert(new_number
== (initial
+ 1));
1093 static test_return
decrement_test(memcached_st
*memc
)
1095 uint64_t new_number
;
1096 memcached_return rc
;
1097 char *key
= "number";
1100 rc
= memcached_set(memc
, key
, strlen(key
),
1101 value
, strlen(value
),
1102 (time_t)0, (uint32_t)0);
1103 assert(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
);
1105 rc
= memcached_decrement(memc
, key
, strlen(key
),
1107 assert(rc
== MEMCACHED_SUCCESS
);
1108 assert(new_number
== 2);
1110 rc
= memcached_decrement(memc
, key
, strlen(key
),
1112 assert(rc
== MEMCACHED_SUCCESS
);
1113 assert(new_number
== 1);
1118 static test_return
decrement_with_initial_test(memcached_st
*memc
)
1120 if (memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
) != 0)
1122 uint64_t new_number
;
1123 memcached_return rc
;
1124 char *key
= "number";
1125 uint64_t initial
= 3;
1127 rc
= memcached_decrement_with_initial(memc
, key
, strlen(key
),
1128 1, initial
, 0, &new_number
);
1129 assert(rc
== MEMCACHED_SUCCESS
);
1130 assert(new_number
== initial
);
1132 rc
= memcached_decrement_with_initial(memc
, key
, strlen(key
),
1133 1, initial
, 0, &new_number
);
1134 assert(rc
== MEMCACHED_SUCCESS
);
1135 assert(new_number
== (initial
- 1));
1140 static test_return
quit_test(memcached_st
*memc
)
1142 memcached_return rc
;
1144 char *value
= "sanford and sun";
1146 rc
= memcached_set(memc
, key
, strlen(key
),
1147 value
, strlen(value
),
1148 (time_t)10, (uint32_t)3);
1149 assert(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
);
1150 memcached_quit(memc
);
1152 rc
= memcached_set(memc
, key
, strlen(key
),
1153 value
, strlen(value
),
1154 (time_t)50, (uint32_t)9);
1155 assert(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
);
1160 static test_return
mget_result_test(memcached_st
*memc
)
1162 memcached_return rc
;
1163 char *keys
[]= {"fudge", "son", "food"};
1164 size_t key_length
[]= {5, 3, 4};
1167 memcached_result_st results_obj
;
1168 memcached_result_st
*results
;
1170 results
= memcached_result_create(memc
, &results_obj
);
1172 assert(&results_obj
== results
);
1174 /* We need to empty the server before continueing test */
1175 rc
= memcached_flush(memc
, 0);
1176 assert(rc
== MEMCACHED_SUCCESS
);
1178 rc
= memcached_mget(memc
, keys
, key_length
, 3);
1179 assert(rc
== MEMCACHED_SUCCESS
);
1181 while ((results
= memcached_fetch_result(memc
, &results_obj
, &rc
)) != NULL
)
1186 while ((results
= memcached_fetch_result(memc
, &results_obj
, &rc
)) != NULL
)
1188 assert(rc
== MEMCACHED_END
);
1190 for (x
= 0; x
< 3; x
++)
1192 rc
= memcached_set(memc
, keys
[x
], key_length
[x
],
1193 keys
[x
], key_length
[x
],
1194 (time_t)50, (uint32_t)9);
1195 assert(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
);
1198 rc
= memcached_mget(memc
, keys
, key_length
, 3);
1199 assert(rc
== MEMCACHED_SUCCESS
);
1201 while ((results
= memcached_fetch_result(memc
, &results_obj
, &rc
)))
1204 assert(&results_obj
== results
);
1205 assert(rc
== MEMCACHED_SUCCESS
);
1206 assert(memcached_result_key_length(results
) == memcached_result_length(results
));
1207 assert(!memcmp(memcached_result_key_value(results
),
1208 memcached_result_value(results
),
1209 memcached_result_length(results
)));
1212 memcached_result_free(&results_obj
);
1217 static test_return
mget_result_alloc_test(memcached_st
*memc
)
1219 memcached_return rc
;
1220 char *keys
[]= {"fudge", "son", "food"};
1221 size_t key_length
[]= {5, 3, 4};
1224 memcached_result_st
*results
;
1226 /* We need to empty the server before continueing test */
1227 rc
= memcached_flush(memc
, 0);
1228 assert(rc
== MEMCACHED_SUCCESS
);
1230 rc
= memcached_mget(memc
, keys
, key_length
, 3);
1231 assert(rc
== MEMCACHED_SUCCESS
);
1233 while ((results
= memcached_fetch_result(memc
, NULL
, &rc
)) != NULL
)
1238 assert(rc
== MEMCACHED_END
);
1240 for (x
= 0; x
< 3; x
++)
1242 rc
= memcached_set(memc
, keys
[x
], key_length
[x
],
1243 keys
[x
], key_length
[x
],
1244 (time_t)50, (uint32_t)9);
1245 assert(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
);
1248 rc
= memcached_mget(memc
, keys
, key_length
, 3);
1249 assert(rc
== MEMCACHED_SUCCESS
);
1252 while ((results
= memcached_fetch_result(memc
, NULL
, &rc
)))
1255 assert(rc
== MEMCACHED_SUCCESS
);
1256 assert(memcached_result_key_length(results
) == memcached_result_length(results
));
1257 assert(!memcmp(memcached_result_key_value(results
),
1258 memcached_result_value(results
),
1259 memcached_result_length(results
)));
1260 memcached_result_free(results
);
1267 /* Count the results */
1268 static memcached_return
callback_counter(memcached_st
*ptr
__attribute__((unused
)),
1269 memcached_result_st
*result
__attribute__((unused
)),
1272 unsigned int *counter
= (unsigned int *)context
;
1274 *counter
= *counter
+ 1;
1276 return MEMCACHED_SUCCESS
;
1279 static test_return
mget_result_function(memcached_st
*memc
)
1281 memcached_return rc
;
1282 char *keys
[]= {"fudge", "son", "food"};
1283 size_t key_length
[]= {5, 3, 4};
1285 unsigned int counter
;
1286 memcached_execute_function callbacks
[1];
1288 /* We need to empty the server before continueing test */
1289 rc
= memcached_flush(memc
, 0);
1290 for (x
= 0; x
< 3; x
++)
1292 rc
= memcached_set(memc
, keys
[x
], key_length
[x
],
1293 keys
[x
], key_length
[x
],
1294 (time_t)50, (uint32_t)9);
1295 assert(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
);
1298 rc
= memcached_mget(memc
, keys
, key_length
, 3);
1299 assert(rc
== MEMCACHED_SUCCESS
);
1301 callbacks
[0]= &callback_counter
;
1303 rc
= memcached_fetch_execute(memc
, callbacks
, (void *)&counter
, 1);
1305 assert(counter
== 3);
1310 static test_return
mget_test(memcached_st
*memc
)
1312 memcached_return rc
;
1313 char *keys
[]= {"fudge", "son", "food"};
1314 size_t key_length
[]= {5, 3, 4};
1318 char return_key
[MEMCACHED_MAX_KEY
];
1319 size_t return_key_length
;
1321 size_t return_value_length
;
1323 /* We need to empty the server before continueing test */
1324 rc
= memcached_flush(memc
, 0);
1325 assert(rc
== MEMCACHED_SUCCESS
);
1327 rc
= memcached_mget(memc
, keys
, key_length
, 3);
1328 assert(rc
== MEMCACHED_SUCCESS
);
1330 while ((return_value
= memcached_fetch(memc
, return_key
, &return_key_length
,
1331 &return_value_length
, &flags
, &rc
)) != NULL
)
1333 assert(return_value
);
1335 assert(!return_value
);
1336 assert(return_value_length
== 0);
1337 assert(rc
== MEMCACHED_END
);
1339 for (x
= 0; x
< 3; x
++)
1341 rc
= memcached_set(memc
, keys
[x
], key_length
[x
],
1342 keys
[x
], key_length
[x
],
1343 (time_t)50, (uint32_t)9);
1344 assert(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
);
1347 rc
= memcached_mget(memc
, keys
, key_length
, 3);
1348 assert(rc
== MEMCACHED_SUCCESS
);
1351 while ((return_value
= memcached_fetch(memc
, return_key
, &return_key_length
,
1352 &return_value_length
, &flags
, &rc
)))
1354 assert(return_value
);
1355 assert(rc
== MEMCACHED_SUCCESS
);
1356 assert(return_key_length
== return_value_length
);
1357 assert(!memcmp(return_value
, return_key
, return_value_length
));
1365 static test_return
get_stats_keys(memcached_st
*memc
)
1369 memcached_stat_st stat
;
1370 memcached_return rc
;
1372 list
= memcached_stat_get_keys(memc
, &stat
, &rc
);
1373 assert(rc
== MEMCACHED_SUCCESS
);
1374 for (ptr
= list
; *ptr
; ptr
++)
1383 static test_return
version_string_test(memcached_st
*memc
__attribute__((unused
)))
1385 const char *version_string
;
1387 version_string
= memcached_lib_version();
1389 assert(!strcmp(version_string
, LIBMEMCACHED_VERSION_STRING
));
1394 static test_return
get_stats(memcached_st
*memc
)
1399 memcached_return rc
;
1400 memcached_stat_st
*stat
;
1402 stat
= memcached_stat(memc
, NULL
, &rc
);
1403 assert(rc
== MEMCACHED_SUCCESS
);
1405 assert(rc
== MEMCACHED_SUCCESS
);
1408 for (x
= 0; x
< memcached_server_count(memc
); x
++)
1410 list
= memcached_stat_get_keys(memc
, stat
+x
, &rc
);
1411 assert(rc
== MEMCACHED_SUCCESS
);
1412 for (ptr
= list
; *ptr
; ptr
++);
1417 memcached_stat_free(NULL
, stat
);
1422 static test_return
add_host_test(memcached_st
*memc
)
1425 memcached_server_st
*servers
;
1426 memcached_return rc
;
1427 char servername
[]= "0.example.com";
1429 servers
= memcached_server_list_append_with_weight(NULL
, servername
, 400, 0, &rc
);
1431 assert(1 == memcached_server_list_count(servers
));
1433 for (x
= 2; x
< 20; x
++)
1435 char buffer
[SMALL_STRING_LEN
];
1437 snprintf(buffer
, SMALL_STRING_LEN
, "%u.example.com", 400+x
);
1438 servers
= memcached_server_list_append_with_weight(servers
, buffer
, 401, 0,
1440 assert(rc
== MEMCACHED_SUCCESS
);
1441 assert(x
== memcached_server_list_count(servers
));
1444 rc
= memcached_server_push(memc
, servers
);
1445 assert(rc
== MEMCACHED_SUCCESS
);
1446 rc
= memcached_server_push(memc
, servers
);
1447 assert(rc
== MEMCACHED_SUCCESS
);
1449 memcached_server_list_free(servers
);
1454 static memcached_return
clone_test_callback(memcached_st
*parent
__attribute__((unused
)), memcached_st
*clone
__attribute__((unused
)))
1456 return MEMCACHED_SUCCESS
;
1459 static memcached_return
cleanup_test_callback(memcached_st
*ptr
__attribute__((unused
)))
1461 return MEMCACHED_SUCCESS
;
1464 static test_return
callback_test(memcached_st
*memc
)
1466 /* Test User Data */
1470 memcached_return rc
;
1472 rc
= memcached_callback_set(memc
, MEMCACHED_CALLBACK_USER_DATA
, &x
);
1473 assert(rc
== MEMCACHED_SUCCESS
);
1474 test_ptr
= (int *)memcached_callback_get(memc
, MEMCACHED_CALLBACK_USER_DATA
, &rc
);
1475 assert(*test_ptr
== x
);
1478 /* Test Clone Callback */
1480 memcached_clone_func clone_cb
= (memcached_clone_func
)clone_test_callback
;
1481 void *clone_cb_ptr
= *(void **)&clone_cb
;
1482 void *temp_function
= NULL
;
1483 memcached_return rc
;
1485 rc
= memcached_callback_set(memc
, MEMCACHED_CALLBACK_CLONE_FUNCTION
,
1487 assert(rc
== MEMCACHED_SUCCESS
);
1488 temp_function
= memcached_callback_get(memc
, MEMCACHED_CALLBACK_CLONE_FUNCTION
, &rc
);
1489 assert(temp_function
== clone_cb_ptr
);
1492 /* Test Cleanup Callback */
1494 memcached_cleanup_func cleanup_cb
=
1495 (memcached_cleanup_func
)cleanup_test_callback
;
1496 void *cleanup_cb_ptr
= *(void **)&cleanup_cb
;
1497 void *temp_function
= NULL
;
1498 memcached_return rc
;
1500 rc
= memcached_callback_set(memc
, MEMCACHED_CALLBACK_CLONE_FUNCTION
,
1502 assert(rc
== MEMCACHED_SUCCESS
);
1503 temp_function
= memcached_callback_get(memc
, MEMCACHED_CALLBACK_CLONE_FUNCTION
, &rc
);
1504 assert(temp_function
== cleanup_cb_ptr
);
1510 /* We don't test the behavior itself, we test the switches */
1511 static test_return
behavior_test(memcached_st
*memc
)
1516 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NO_BLOCK
, set
);
1517 value
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_NO_BLOCK
);
1520 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_TCP_NODELAY
, set
);
1521 value
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_TCP_NODELAY
);
1524 set
= MEMCACHED_HASH_MD5
;
1525 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_HASH
, set
);
1526 value
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_HASH
);
1527 assert(value
== MEMCACHED_HASH_MD5
);
1531 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NO_BLOCK
, set
);
1532 value
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_NO_BLOCK
);
1535 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_TCP_NODELAY
, set
);
1536 value
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_TCP_NODELAY
);
1539 set
= MEMCACHED_HASH_DEFAULT
;
1540 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_HASH
, set
);
1541 value
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_HASH
);
1542 assert(value
== MEMCACHED_HASH_DEFAULT
);
1544 set
= MEMCACHED_HASH_CRC
;
1545 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_HASH
, set
);
1546 value
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_HASH
);
1547 assert(value
== MEMCACHED_HASH_CRC
);
1549 value
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_SOCKET_SEND_SIZE
);
1552 value
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_SOCKET_RECV_SIZE
);
1558 /* Test case provided by Cal Haldenbrand */
1559 static test_return
user_supplied_bug1(memcached_st
*memc
)
1561 unsigned int setter
= 1;
1564 unsigned long long total
= 0;
1567 char randomstuff
[6 * 1024];
1568 memcached_return rc
;
1570 memset(randomstuff
, 0, 6 * 1024);
1572 /* We just keep looking at the same values over and over */
1575 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NO_BLOCK
, setter
);
1576 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_TCP_NODELAY
, setter
);
1580 for (x
= 0 ; total
< 20 * 1024576 ; x
++ )
1584 size
= (rand() % ( 5 * 1024 ) ) + 400;
1585 memset(randomstuff
, 0, 6 * 1024);
1586 assert(size
< 6 * 1024); /* Being safe here */
1588 for (j
= 0 ; j
< size
;j
++)
1589 randomstuff
[j
] = (char) (rand() % 26) + 97;
1592 sprintf(key
, "%d", x
);
1593 rc
= memcached_set(memc
, key
, strlen(key
),
1594 randomstuff
, strlen(randomstuff
), 10, 0);
1595 assert(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
);
1596 /* If we fail, lets try again */
1597 if (rc
!= MEMCACHED_SUCCESS
&& rc
!= MEMCACHED_BUFFERED
)
1598 rc
= memcached_set(memc
, key
, strlen(key
),
1599 randomstuff
, strlen(randomstuff
), 10, 0);
1600 assert(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
);
1606 /* Test case provided by Cal Haldenbrand */
1607 static test_return
user_supplied_bug2(memcached_st
*memc
)
1610 unsigned int setter
;
1612 unsigned long long total
;
1615 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NO_BLOCK
, setter
);
1616 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_TCP_NODELAY
, setter
);
1618 setter
= 20 * 1024576;
1619 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_SOCKET_SEND_SIZE
, setter
);
1620 setter
= 20 * 1024576;
1621 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_SOCKET_RECV_SIZE
, setter
);
1622 getter
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_SOCKET_SEND_SIZE
);
1623 getter
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_SOCKET_RECV_SIZE
);
1625 for (x
= 0, errors
= 0, total
= 0 ; total
< 20 * 1024576 ; x
++)
1628 for (x
= 0, errors
= 0, total
= 0 ; total
< 24576 ; x
++)
1630 memcached_return rc
= MEMCACHED_SUCCESS
;
1631 char buffer
[SMALL_STRING_LEN
];
1636 memset(buffer
, 0, SMALL_STRING_LEN
);
1638 snprintf(buffer
, SMALL_STRING_LEN
, "%u", x
);
1639 getval
= memcached_get(memc
, buffer
, strlen(buffer
),
1640 &val_len
, &flags
, &rc
);
1641 if (rc
!= MEMCACHED_SUCCESS
)
1643 if (rc
== MEMCACHED_NOTFOUND
)
1647 WATCHPOINT_ERROR(rc
);
1661 /* Do a large mget() over all the keys we think exist */
1662 #define KEY_COUNT 3000 // * 1024576
1663 static test_return
user_supplied_bug3(memcached_st
*memc
)
1665 memcached_return rc
;
1666 unsigned int setter
;
1669 size_t key_lengths
[KEY_COUNT
];
1672 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NO_BLOCK
, setter
);
1673 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_TCP_NODELAY
, setter
);
1675 setter
= 20 * 1024576;
1676 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_SOCKET_SEND_SIZE
, setter
);
1677 setter
= 20 * 1024576;
1678 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_SOCKET_RECV_SIZE
, setter
);
1679 getter
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_SOCKET_SEND_SIZE
);
1680 getter
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_SOCKET_RECV_SIZE
);
1683 keys
= (char **)malloc(sizeof(char *) * KEY_COUNT
);
1685 memset(keys
, 0, (sizeof(char *) * KEY_COUNT
));
1686 for (x
= 0; x
< KEY_COUNT
; x
++)
1690 snprintf(buffer
, 30, "%u", x
);
1691 keys
[x
]= strdup(buffer
);
1692 key_lengths
[x
]= strlen(keys
[x
]);
1695 rc
= memcached_mget(memc
, keys
, key_lengths
, KEY_COUNT
);
1696 assert(rc
== MEMCACHED_SUCCESS
);
1698 /* Turn this into a help function */
1700 char return_key
[MEMCACHED_MAX_KEY
];
1701 size_t return_key_length
;
1703 size_t return_value_length
;
1706 while ((return_value
= memcached_fetch(memc
, return_key
, &return_key_length
,
1707 &return_value_length
, &flags
, &rc
)))
1709 assert(return_value
);
1710 assert(rc
== MEMCACHED_SUCCESS
);
1715 for (x
= 0; x
< KEY_COUNT
; x
++)
1722 /* Make sure we behave properly if server list has no values */
1723 static test_return
user_supplied_bug4(memcached_st
*memc
)
1725 memcached_return rc
;
1726 char *keys
[]= {"fudge", "son", "food"};
1727 size_t key_length
[]= {5, 3, 4};
1730 char return_key
[MEMCACHED_MAX_KEY
];
1731 size_t return_key_length
;
1733 size_t return_value_length
;
1735 /* Here we free everything before running a bunch of mget tests */
1737 memcached_server_list_free(memc
->hosts
);
1739 memc
->number_of_hosts
= 0;
1743 /* We need to empty the server before continueing test */
1744 rc
= memcached_flush(memc
, 0);
1745 assert(rc
== MEMCACHED_NO_SERVERS
);
1747 rc
= memcached_mget(memc
, keys
, key_length
, 3);
1748 assert(rc
== MEMCACHED_NO_SERVERS
);
1750 while ((return_value
= memcached_fetch(memc
, return_key
, &return_key_length
,
1751 &return_value_length
, &flags
, &rc
)) != NULL
)
1753 assert(return_value
);
1755 assert(!return_value
);
1756 assert(return_value_length
== 0);
1757 assert(rc
== MEMCACHED_NO_SERVERS
);
1759 for (x
= 0; x
< 3; x
++)
1761 rc
= memcached_set(memc
, keys
[x
], key_length
[x
],
1762 keys
[x
], key_length
[x
],
1763 (time_t)50, (uint32_t)9);
1764 assert(rc
== MEMCACHED_NO_SERVERS
);
1767 rc
= memcached_mget(memc
, keys
, key_length
, 3);
1768 assert(rc
== MEMCACHED_NO_SERVERS
);
1771 while ((return_value
= memcached_fetch(memc
, return_key
, &return_key_length
,
1772 &return_value_length
, &flags
, &rc
)))
1774 assert(return_value
);
1775 assert(rc
== MEMCACHED_SUCCESS
);
1776 assert(return_key_length
== return_value_length
);
1777 assert(!memcmp(return_value
, return_key
, return_value_length
));
1785 #define VALUE_SIZE_BUG5 1048064
1786 static test_return
user_supplied_bug5(memcached_st
*memc
)
1788 memcached_return rc
;
1789 char *keys
[]= {"036790384900", "036790384902", "036790384904", "036790384906"};
1790 size_t key_length
[]= {strlen("036790384900"), strlen("036790384902"), strlen("036790384904"), strlen("036790384906")};
1791 char return_key
[MEMCACHED_MAX_KEY
];
1792 size_t return_key_length
;
1794 size_t value_length
;
1798 char insert_data
[VALUE_SIZE_BUG5
];
1800 for (x
= 0; x
< VALUE_SIZE_BUG5
; x
++)
1801 insert_data
[x
]= rand();
1803 memcached_flush(memc
, 0);
1804 value
= memcached_get(memc
, keys
[0], key_length
[0],
1805 &value_length
, &flags
, &rc
);
1806 assert(value
== NULL
);
1807 rc
= memcached_mget(memc
, keys
, key_length
, 4);
1810 while ((value
= memcached_fetch(memc
, return_key
, &return_key_length
,
1811 &value_length
, &flags
, &rc
)))
1815 for (x
= 0; x
< 4; x
++)
1817 rc
= memcached_set(memc
, keys
[x
], key_length
[x
],
1818 insert_data
, VALUE_SIZE_BUG5
,
1819 (time_t)0, (uint32_t)0);
1820 assert(rc
== MEMCACHED_SUCCESS
);
1823 for (x
= 0; x
< 10; x
++)
1825 value
= memcached_get(memc
, keys
[0], key_length
[0],
1826 &value_length
, &flags
, &rc
);
1830 rc
= memcached_mget(memc
, keys
, key_length
, 4);
1832 while ((value
= memcached_fetch(memc
, return_key
, &return_key_length
,
1833 &value_length
, &flags
, &rc
)))
1844 static test_return
user_supplied_bug6(memcached_st
*memc
)
1846 memcached_return rc
;
1847 char *keys
[]= {"036790384900", "036790384902", "036790384904", "036790384906"};
1848 size_t key_length
[]= {strlen("036790384900"), strlen("036790384902"), strlen("036790384904"), strlen("036790384906")};
1849 char return_key
[MEMCACHED_MAX_KEY
];
1850 size_t return_key_length
;
1852 size_t value_length
;
1856 char insert_data
[VALUE_SIZE_BUG5
];
1858 for (x
= 0; x
< VALUE_SIZE_BUG5
; x
++)
1859 insert_data
[x
]= rand();
1861 memcached_flush(memc
, 0);
1862 value
= memcached_get(memc
, keys
[0], key_length
[0],
1863 &value_length
, &flags
, &rc
);
1864 assert(value
== NULL
);
1865 assert(rc
== MEMCACHED_NOTFOUND
);
1866 rc
= memcached_mget(memc
, keys
, key_length
, 4);
1867 assert(rc
== MEMCACHED_SUCCESS
);
1870 while ((value
= memcached_fetch(memc
, return_key
, &return_key_length
,
1871 &value_length
, &flags
, &rc
)))
1874 assert(rc
== MEMCACHED_END
);
1876 for (x
= 0; x
< 4; x
++)
1878 rc
= memcached_set(memc
, keys
[x
], key_length
[x
],
1879 insert_data
, VALUE_SIZE_BUG5
,
1880 (time_t)0, (uint32_t)0);
1881 assert(rc
== MEMCACHED_SUCCESS
);
1884 for (x
= 0; x
< 2; x
++)
1886 value
= memcached_get(memc
, keys
[0], key_length
[0],
1887 &value_length
, &flags
, &rc
);
1891 rc
= memcached_mget(memc
, keys
, key_length
, 4);
1892 assert(rc
== MEMCACHED_SUCCESS
);
1894 /* We test for purge of partial complete fetches */
1895 for (count
= 3; count
; count
--)
1897 value
= memcached_fetch(memc
, return_key
, &return_key_length
,
1898 &value_length
, &flags
, &rc
);
1899 assert(rc
== MEMCACHED_SUCCESS
);
1900 assert(!(memcmp(value
, insert_data
, value_length
)));
1901 assert(value_length
);
1909 static test_return
user_supplied_bug8(memcached_st
*memc
__attribute__((unused
)))
1911 memcached_return rc
;
1913 memcached_st
*clone
;
1915 memcached_server_st
*servers
;
1916 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";
1918 servers
= memcached_servers_parse(server_list
);
1921 mine
= memcached_create(NULL
);
1922 rc
= memcached_server_push(mine
, servers
);
1923 assert(rc
== MEMCACHED_SUCCESS
);
1924 memcached_server_list_free(servers
);
1927 clone
= memcached_clone(NULL
, mine
);
1929 memcached_quit(mine
);
1930 memcached_quit(clone
);
1933 memcached_free(mine
);
1934 memcached_free(clone
);
1939 /* Test flag store/retrieve */
1940 static test_return
user_supplied_bug7(memcached_st
*memc
)
1942 memcached_return rc
;
1943 char *keys
= "036790384900";
1944 size_t key_length
= strlen("036790384900");
1945 char return_key
[MEMCACHED_MAX_KEY
];
1946 size_t return_key_length
;
1948 size_t value_length
;
1951 char insert_data
[VALUE_SIZE_BUG5
];
1953 for (x
= 0; x
< VALUE_SIZE_BUG5
; x
++)
1954 insert_data
[x
]= rand();
1956 memcached_flush(memc
, 0);
1959 rc
= memcached_set(memc
, keys
, key_length
,
1960 insert_data
, VALUE_SIZE_BUG5
,
1962 assert(rc
== MEMCACHED_SUCCESS
);
1965 value
= memcached_get(memc
, keys
, key_length
,
1966 &value_length
, &flags
, &rc
);
1967 assert(flags
== 245);
1971 rc
= memcached_mget(memc
, &keys
, &key_length
, 1);
1974 value
= memcached_fetch(memc
, return_key
, &return_key_length
,
1975 &value_length
, &flags
, &rc
);
1976 assert(flags
== 245);
1984 static test_return
user_supplied_bug9(memcached_st
*memc
)
1986 memcached_return rc
;
1987 char *keys
[]= {"UDATA:edevil@sapo.pt", "fudge&*@#", "for^#@&$not"};
1988 size_t key_length
[3];
1993 char return_key
[MEMCACHED_MAX_KEY
];
1994 size_t return_key_length
;
1996 size_t return_value_length
;
1999 key_length
[0]= strlen("UDATA:edevil@sapo.pt");
2000 key_length
[1]= strlen("fudge&*@#");
2001 key_length
[2]= strlen("for^#@&$not");
2004 for (x
= 0; x
< 3; x
++)
2006 rc
= memcached_set(memc
, keys
[x
], key_length
[x
],
2007 keys
[x
], key_length
[x
],
2008 (time_t)50, (uint32_t)9);
2009 assert(rc
== MEMCACHED_SUCCESS
);
2012 rc
= memcached_mget(memc
, keys
, key_length
, 3);
2013 assert(rc
== MEMCACHED_SUCCESS
);
2015 /* We need to empty the server before continueing test */
2016 while ((return_value
= memcached_fetch(memc
, return_key
, &return_key_length
,
2017 &return_value_length
, &flags
, &rc
)) != NULL
)
2019 assert(return_value
);
2028 /* We are testing with aggressive timeout to get failures */
2029 static test_return
user_supplied_bug10(memcached_st
*memc
)
2033 size_t value_length
= 512;
2036 memcached_return rc
;
2037 unsigned int set
= 1;
2038 memcached_st
*mclone
= memcached_clone(NULL
, memc
);
2041 memcached_behavior_set(mclone
, MEMCACHED_BEHAVIOR_NO_BLOCK
, set
);
2042 memcached_behavior_set(mclone
, MEMCACHED_BEHAVIOR_TCP_NODELAY
, set
);
2044 memcached_behavior_set(mclone
, MEMCACHED_BEHAVIOR_POLL_TIMEOUT
, timeout
);
2046 value
= (char*)malloc(value_length
* sizeof(char));
2048 for (x
= 0; x
< value_length
; x
++)
2049 value
[x
]= (char) (x
% 127);
2051 for (x
= 1; x
<= 100000; ++x
)
2053 rc
= memcached_set(mclone
, key
, key_len
,value
, value_length
, 0, 0);
2055 assert(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_WRITE_FAILURE
||
2056 rc
== MEMCACHED_BUFFERED
|| rc
== MEMCACHED_TIMEOUT
);
2058 if (rc
== MEMCACHED_WRITE_FAILURE
|| rc
== MEMCACHED_TIMEOUT
)
2063 memcached_free(mclone
);
2069 We are looking failures in the async protocol
2071 static test_return
user_supplied_bug11(memcached_st
*memc
)
2075 size_t value_length
= 512;
2078 memcached_return rc
;
2079 unsigned int set
= 1;
2081 memcached_st
*mclone
= memcached_clone(NULL
, memc
);
2083 memcached_behavior_set(mclone
, MEMCACHED_BEHAVIOR_NO_BLOCK
, set
);
2084 memcached_behavior_set(mclone
, MEMCACHED_BEHAVIOR_TCP_NODELAY
, set
);
2086 memcached_behavior_set(mclone
, MEMCACHED_BEHAVIOR_POLL_TIMEOUT
, timeout
);
2088 timeout
= (int32_t)memcached_behavior_get(mclone
, MEMCACHED_BEHAVIOR_POLL_TIMEOUT
);
2090 assert(timeout
== -1);
2092 value
= (char*)malloc(value_length
* sizeof(char));
2094 for (x
= 0; x
< value_length
; x
++)
2095 value
[x
]= (char) (x
% 127);
2097 for (x
= 1; x
<= 100000; ++x
)
2099 rc
= memcached_set(mclone
, key
, key_len
,value
, value_length
, 0, 0);
2103 memcached_free(mclone
);
2109 Bug found where incr was not returning MEMCACHED_NOTFOUND when object did not exist.
2111 static test_return
user_supplied_bug12(memcached_st
*memc
)
2113 memcached_return rc
;
2115 size_t value_length
;
2117 uint64_t number_value
;
2119 value
= memcached_get(memc
, "autoincrement", strlen("autoincrement"),
2120 &value_length
, &flags
, &rc
);
2121 assert(value
== NULL
);
2122 assert(rc
== MEMCACHED_NOTFOUND
);
2124 rc
= memcached_increment(memc
, "autoincrement", strlen("autoincrement"),
2127 assert(value
== NULL
);
2128 /* The binary protocol will set the key if it doesn't exist */
2129 if (memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
) == 1)
2130 assert(rc
== MEMCACHED_SUCCESS
);
2132 assert(rc
== MEMCACHED_NOTFOUND
);
2134 rc
= memcached_set(memc
, "autoincrement", strlen("autoincrement"), "1", 1, 0, 0);
2136 value
= memcached_get(memc
, "autoincrement", strlen("autoincrement"),
2137 &value_length
, &flags
, &rc
);
2139 assert(rc
== MEMCACHED_SUCCESS
);
2142 rc
= memcached_increment(memc
, "autoincrement", strlen("autoincrement"),
2144 assert(number_value
== 2);
2145 assert(rc
== MEMCACHED_SUCCESS
);
2151 Bug found where command total one more than MEMCACHED_MAX_BUFFER
2152 set key34567890 0 0 8169 \r\n is sent followed by buffer of size 8169, followed by 8169
2154 static test_return
user_supplied_bug13(memcached_st
*memc
)
2156 char key
[] = "key34567890";
2158 memcached_return rc
;
2159 size_t overflowSize
;
2161 char commandFirst
[]= "set key34567890 0 0 ";
2162 char commandLast
[] = " \r\n"; /* first line of command sent to server */
2163 size_t commandLength
;
2166 commandLength
= strlen(commandFirst
) + strlen(commandLast
) + 4; /* 4 is number of characters in size, probably 8196 */
2168 overflowSize
= MEMCACHED_MAX_BUFFER
- commandLength
;
2170 for (testSize
= overflowSize
- 1; testSize
< overflowSize
+ 1; testSize
++)
2172 overflow
= malloc(testSize
);
2173 assert(overflow
!= NULL
);
2175 memset(overflow
, 'x', testSize
);
2176 rc
= memcached_set(memc
, key
, strlen(key
),
2177 overflow
, testSize
, 0, 0);
2178 assert(rc
== MEMCACHED_SUCCESS
);
2187 Test values of many different sizes
2188 Bug found where command total one more than MEMCACHED_MAX_BUFFER
2189 set key34567890 0 0 8169 \r\n
2190 is sent followed by buffer of size 8169, followed by 8169
2192 static test_return
user_supplied_bug14(memcached_st
*memc
)
2195 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_TCP_NODELAY
, setter
);
2196 memcached_return rc
;
2199 size_t value_length
= 18000;
2201 size_t string_length
;
2204 size_t current_length
;
2206 value
= (char*)malloc(value_length
);
2209 for (x
= 0; x
< value_length
; x
++)
2210 value
[x
] = (char) (x
% 127);
2212 for (current_length
= 0; current_length
< value_length
; current_length
++)
2214 rc
= memcached_set(memc
, key
, strlen(key
),
2215 value
, current_length
,
2216 (time_t)0, (uint32_t)0);
2217 assert(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
);
2219 string
= memcached_get(memc
, key
, strlen(key
),
2220 &string_length
, &flags
, &rc
);
2222 assert(rc
== MEMCACHED_SUCCESS
);
2223 assert(string_length
== current_length
);
2224 assert(!memcmp(string
, value
, string_length
));
2235 Look for zero length value problems
2237 static test_return
user_supplied_bug15(memcached_st
*memc
)
2240 memcached_return rc
;
2246 for (x
= 0; x
< 2; x
++)
2248 rc
= memcached_set(memc
, key
, strlen(key
),
2250 (time_t)0, (uint32_t)0);
2252 assert(rc
== MEMCACHED_SUCCESS
);
2254 value
= memcached_get(memc
, key
, strlen(key
),
2255 &length
, &flags
, &rc
);
2257 assert(rc
== MEMCACHED_SUCCESS
);
2258 assert(value
== NULL
);
2259 assert(length
== 0);
2262 value
= memcached_get(memc
, key
, strlen(key
),
2263 &length
, &flags
, &rc
);
2265 assert(rc
== MEMCACHED_SUCCESS
);
2266 assert(value
== NULL
);
2267 assert(length
== 0);
2274 /* Check the return sizes on FLAGS to make sure it stores 32bit unsigned values correctly */
2275 static test_return
user_supplied_bug16(memcached_st
*memc
)
2277 memcached_return rc
;
2283 rc
= memcached_set(memc
, key
, strlen(key
),
2285 (time_t)0, UINT32_MAX
);
2287 assert(rc
== MEMCACHED_SUCCESS
);
2289 value
= memcached_get(memc
, key
, strlen(key
),
2290 &length
, &flags
, &rc
);
2292 assert(rc
== MEMCACHED_SUCCESS
);
2293 assert(value
== NULL
);
2294 assert(length
== 0);
2295 assert(flags
== UINT32_MAX
);
2300 /* Check the validity of chinese key*/
2301 static test_return
user_supplied_bug17(memcached_st
*memc
)
2303 memcached_return rc
;
2305 char *value
="我们在炎热抑郁的夏天无法停止豆瓣";
2310 rc
= memcached_set(memc
, key
, strlen(key
),
2311 value
, strlen(value
),
2314 assert(rc
== MEMCACHED_SUCCESS
);
2316 value2
= memcached_get(memc
, key
, strlen(key
),
2317 &length
, &flags
, &rc
);
2319 assert(length
==strlen(value
));
2320 assert(rc
== MEMCACHED_SUCCESS
);
2321 assert(memcmp(value
, value2
, length
)==0);
2331 static test_return
user_supplied_bug19(memcached_st
*memc
)
2334 memcached_server_st
*s
;
2335 memcached_return res
;
2339 m
= memcached_create(NULL
);
2340 memcached_server_add_with_weight(m
, "localhost", 11311, 100);
2341 memcached_server_add_with_weight(m
, "localhost", 11312, 100);
2343 s
= memcached_server_by_key(m
, "a", 1, &res
);
2344 memcached_server_free(s
);
2351 /* CAS test from Andei */
2352 static test_return
user_supplied_bug20(memcached_st
*memc
)
2354 memcached_return status
;
2355 memcached_result_st
*result
, result_obj
;
2357 size_t key_len
= strlen("abc");
2358 char *value
= "foobar";
2359 size_t value_len
= strlen(value
);
2361 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_SUPPORT_CAS
, 1);
2363 status
= memcached_set(memc
, key
, key_len
, value
, value_len
, (time_t)0, (uint32_t)0);
2364 assert(status
== MEMCACHED_SUCCESS
);
2366 status
= memcached_mget(memc
, &key
, &key_len
, 1);
2367 assert(status
== MEMCACHED_SUCCESS
);
2369 result
= memcached_result_create(memc
, &result_obj
);
2372 memcached_result_create(memc
, &result_obj
);
2373 result
= memcached_fetch_result(memc
, &result_obj
, &status
);
2376 assert(status
== MEMCACHED_SUCCESS
);
2378 memcached_result_free(result
);
2383 #include "ketama_test_cases.h"
2384 static test_return
user_supplied_bug18(memcached_st
*trash
)
2386 memcached_return rc
;
2389 memcached_server_st
*server_pool
;
2394 memc
= memcached_create(NULL
);
2397 rc
= memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_KETAMA_WEIGHTED
, 1);
2398 assert(rc
== MEMCACHED_SUCCESS
);
2400 value
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_KETAMA_WEIGHTED
);
2403 rc
= memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_KETAMA_HASH
, MEMCACHED_HASH_MD5
);
2404 assert(rc
== MEMCACHED_SUCCESS
);
2406 value
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_KETAMA_HASH
);
2407 assert(value
== MEMCACHED_HASH_MD5
);
2409 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");
2410 memcached_server_push(memc
, server_pool
);
2412 /* verify that the server list was parsed okay. */
2413 assert(memc
->number_of_hosts
== 8);
2414 assert(strcmp(server_pool
[0].hostname
, "10.0.1.1") == 0);
2415 assert(server_pool
[0].port
== 11211);
2416 assert(server_pool
[0].weight
== 600);
2417 assert(strcmp(server_pool
[2].hostname
, "10.0.1.3") == 0);
2418 assert(server_pool
[2].port
== 11211);
2419 assert(server_pool
[2].weight
== 200);
2420 assert(strcmp(server_pool
[7].hostname
, "10.0.1.8") == 0);
2421 assert(server_pool
[7].port
== 11211);
2422 assert(server_pool
[7].weight
== 100);
2424 /* VDEAAAAA hashes to fffcd1b5, after the last continuum point, and lets
2425 * us test the boundary wraparound.
2427 assert(memcached_generate_hash(memc
, (char *)"VDEAAAAA", 8) == memc
->continuum
[0].index
);
2429 /* verify the standard ketama set. */
2430 for (x
= 0; x
< 99; x
++)
2432 uint32_t server_idx
= memcached_generate_hash(memc
, test_cases
[x
].key
, strlen(test_cases
[x
].key
));
2433 char *hostname
= memc
->hosts
[server_idx
].hostname
;
2434 assert(strcmp(hostname
, test_cases
[x
].server
) == 0);
2437 memcached_server_list_free(server_pool
);
2438 memcached_free(memc
);
2443 static test_return
auto_eject_hosts(memcached_st
*trash
)
2447 memcached_return rc
;
2448 memcached_st
*memc
= memcached_create(NULL
);
2451 rc
= memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_KETAMA_WEIGHTED
, 1);
2452 assert(rc
== MEMCACHED_SUCCESS
);
2454 uint64_t value
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_KETAMA_WEIGHTED
);
2457 rc
= memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_KETAMA_HASH
, MEMCACHED_HASH_MD5
);
2458 assert(rc
== MEMCACHED_SUCCESS
);
2460 value
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_KETAMA_HASH
);
2461 assert(value
== MEMCACHED_HASH_MD5
);
2463 /* server should be removed when in delay */
2464 rc
= memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_AUTO_EJECT_HOSTS
, 1);
2465 assert(rc
== MEMCACHED_SUCCESS
);
2467 value
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_AUTO_EJECT_HOSTS
);
2470 memcached_server_st
*server_pool
;
2471 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");
2472 memcached_server_push(memc
, server_pool
);
2474 /* verify that the server list was parsed okay. */
2475 assert(memc
->number_of_hosts
== 8);
2476 assert(strcmp(server_pool
[0].hostname
, "10.0.1.1") == 0);
2477 assert(server_pool
[0].port
== 11211);
2478 assert(server_pool
[0].weight
== 600);
2479 assert(strcmp(server_pool
[2].hostname
, "10.0.1.3") == 0);
2480 assert(server_pool
[2].port
== 11211);
2481 assert(server_pool
[2].weight
== 200);
2482 assert(strcmp(server_pool
[7].hostname
, "10.0.1.8") == 0);
2483 assert(server_pool
[7].port
== 11211);
2484 assert(server_pool
[7].weight
== 100);
2486 memc
->hosts
[2].next_retry
= time(NULL
) + 15;
2487 memc
->next_distribution_rebuild
= time(NULL
) - 1;
2489 for (int x
= 0; x
< 99; x
++)
2491 uint32_t server_idx
= memcached_generate_hash(memc
, test_cases
[x
].key
, strlen(test_cases
[x
].key
));
2492 assert(server_idx
!= 2);
2495 /* and re-added when it's back. */
2496 memc
->hosts
[2].next_retry
= time(NULL
) - 1;
2497 memc
->next_distribution_rebuild
= time(NULL
) - 1;
2498 run_distribution(memc
);
2499 for (int x
= 0; x
< 99; x
++)
2501 uint32_t server_idx
= memcached_generate_hash(memc
, test_cases
[x
].key
, strlen(test_cases
[x
].key
));
2502 char *hostname
= memc
->hosts
[server_idx
].hostname
;
2503 assert(strcmp(hostname
, test_cases
[x
].server
) == 0);
2506 memcached_server_list_free(server_pool
);
2507 memcached_free(memc
);
2509 return TEST_SUCCESS
;
2512 static test_return
result_static(memcached_st
*memc
)
2514 memcached_result_st result
;
2515 memcached_result_st
*result_ptr
;
2517 result_ptr
= memcached_result_create(memc
, &result
);
2518 assert(result
.is_allocated
== false);
2520 memcached_result_free(&result
);
2525 static test_return
result_alloc(memcached_st
*memc
)
2527 memcached_result_st
*result
;
2529 result
= memcached_result_create(memc
, NULL
);
2531 memcached_result_free(result
);
2536 static test_return
string_static_null(memcached_st
*memc
)
2538 memcached_string_st string
;
2539 memcached_string_st
*string_ptr
;
2541 string_ptr
= memcached_string_create(memc
, &string
, 0);
2542 assert(string
.is_allocated
== false);
2544 memcached_string_free(&string
);
2549 static test_return
string_alloc_null(memcached_st
*memc
)
2551 memcached_string_st
*string
;
2553 string
= memcached_string_create(memc
, NULL
, 0);
2555 memcached_string_free(string
);
2560 static test_return
string_alloc_with_size(memcached_st
*memc
)
2562 memcached_string_st
*string
;
2564 string
= memcached_string_create(memc
, NULL
, 1024);
2566 memcached_string_free(string
);
2571 static test_return
string_alloc_with_size_toobig(memcached_st
*memc
)
2573 memcached_string_st
*string
;
2575 string
= memcached_string_create(memc
, NULL
, SIZE_MAX
);
2576 assert(string
== NULL
);
2581 static test_return
string_alloc_append(memcached_st
*memc
)
2584 char buffer
[SMALL_STRING_LEN
];
2585 memcached_string_st
*string
;
2587 /* Ring the bell! */
2588 memset(buffer
, 6, SMALL_STRING_LEN
);
2590 string
= memcached_string_create(memc
, NULL
, 100);
2593 for (x
= 0; x
< 1024; x
++)
2595 memcached_return rc
;
2596 rc
= memcached_string_append(string
, buffer
, SMALL_STRING_LEN
);
2597 assert(rc
== MEMCACHED_SUCCESS
);
2599 memcached_string_free(string
);
2604 static test_return
string_alloc_append_toobig(memcached_st
*memc
)
2606 memcached_return rc
;
2608 char buffer
[SMALL_STRING_LEN
];
2609 memcached_string_st
*string
;
2611 /* Ring the bell! */
2612 memset(buffer
, 6, SMALL_STRING_LEN
);
2614 string
= memcached_string_create(memc
, NULL
, 100);
2617 for (x
= 0; x
< 1024; x
++)
2619 rc
= memcached_string_append(string
, buffer
, SMALL_STRING_LEN
);
2620 assert(rc
== MEMCACHED_SUCCESS
);
2622 rc
= memcached_string_append(string
, buffer
, SIZE_MAX
);
2623 assert(rc
== MEMCACHED_MEMORY_ALLOCATION_FAILURE
);
2624 memcached_string_free(string
);
2629 static test_return
cleanup_pairs(memcached_st
*memc
__attribute__((unused
)))
2631 pairs_free(global_pairs
);
2636 static test_return
generate_pairs(memcached_st
*memc
__attribute__((unused
)))
2638 unsigned long long x
;
2639 global_pairs
= pairs_generate(GLOBAL_COUNT
, 400);
2640 global_count
= GLOBAL_COUNT
;
2642 for (x
= 0; x
< global_count
; x
++)
2644 global_keys
[x
]= global_pairs
[x
].key
;
2645 global_keys_length
[x
]= global_pairs
[x
].key_length
;
2651 static test_return
generate_large_pairs(memcached_st
*memc
__attribute__((unused
)))
2653 unsigned long long x
;
2654 global_pairs
= pairs_generate(GLOBAL2_COUNT
, MEMCACHED_MAX_BUFFER
+10);
2655 global_count
= GLOBAL2_COUNT
;
2657 for (x
= 0; x
< global_count
; x
++)
2659 global_keys
[x
]= global_pairs
[x
].key
;
2660 global_keys_length
[x
]= global_pairs
[x
].key_length
;
2666 static test_return
generate_data(memcached_st
*memc
)
2668 execute_set(memc
, global_pairs
, global_count
);
2673 static test_return
generate_data_with_stats(memcached_st
*memc
)
2675 memcached_stat_st
*stat_p
;
2676 memcached_return rc
;
2677 uint32_t host_index
= 0;
2678 execute_set(memc
, global_pairs
, global_count
);
2680 //TODO: hosts used size stats
2681 stat_p
= memcached_stat(memc
, NULL
, &rc
);
2684 for (host_index
= 0; host_index
< SERVERS_TO_CREATE
; host_index
++)
2686 /* This test was changes so that "make test" would work properlly */
2688 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
);
2690 assert((unsigned long long)(stat_p
+ host_index
)->bytes
);
2693 memcached_stat_free(NULL
, stat_p
);
2697 static test_return
generate_buffer_data(memcached_st
*memc
)
2702 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_BUFFER_REQUESTS
, latch
);
2703 generate_data(memc
);
2708 static test_return
get_read_count(memcached_st
*memc
)
2711 memcached_return rc
;
2712 memcached_st
*clone
;
2714 clone
= memcached_clone(NULL
, memc
);
2717 memcached_server_add_with_weight(clone
, "localhost", 6666, 0);
2721 size_t return_value_length
;
2725 for (x
= count
= 0; x
< global_count
; x
++)
2727 return_value
= memcached_get(clone
, global_keys
[x
], global_keys_length
[x
],
2728 &return_value_length
, &flags
, &rc
);
2729 if (rc
== MEMCACHED_SUCCESS
)
2736 fprintf(stderr
, "\t%u -> %u", global_count
, count
);
2739 memcached_free(clone
);
2744 static test_return
get_read(memcached_st
*memc
)
2747 memcached_return rc
;
2751 size_t return_value_length
;
2754 for (x
= 0; x
< global_count
; x
++)
2756 return_value
= memcached_get(memc
, global_keys
[x
], global_keys_length
[x
],
2757 &return_value_length
, &flags
, &rc
);
2759 assert(return_value);
2760 assert(rc == MEMCACHED_SUCCESS);
2762 if (rc
== MEMCACHED_SUCCESS
&& return_value
)
2770 static test_return
mget_read(memcached_st
*memc
)
2772 memcached_return rc
;
2774 rc
= memcached_mget(memc
, global_keys
, global_keys_length
, global_count
);
2775 assert(rc
== MEMCACHED_SUCCESS
);
2776 /* Turn this into a help function */
2778 char return_key
[MEMCACHED_MAX_KEY
];
2779 size_t return_key_length
;
2781 size_t return_value_length
;
2784 while ((return_value
= memcached_fetch(memc
, return_key
, &return_key_length
,
2785 &return_value_length
, &flags
, &rc
)))
2787 assert(return_value
);
2788 assert(rc
== MEMCACHED_SUCCESS
);
2796 static test_return
mget_read_result(memcached_st
*memc
)
2798 memcached_return rc
;
2800 rc
= memcached_mget(memc
, global_keys
, global_keys_length
, global_count
);
2801 assert(rc
== MEMCACHED_SUCCESS
);
2802 /* Turn this into a help function */
2804 memcached_result_st results_obj
;
2805 memcached_result_st
*results
;
2807 results
= memcached_result_create(memc
, &results_obj
);
2809 while ((results
= memcached_fetch_result(memc
, &results_obj
, &rc
)))
2812 assert(rc
== MEMCACHED_SUCCESS
);
2815 memcached_result_free(&results_obj
);
2821 static test_return
mget_read_function(memcached_st
*memc
)
2823 memcached_return rc
;
2824 unsigned int counter
;
2825 memcached_execute_function callbacks
[1];
2827 rc
= memcached_mget(memc
, global_keys
, global_keys_length
, global_count
);
2828 assert(rc
== MEMCACHED_SUCCESS
);
2830 callbacks
[0]= &callback_counter
;
2832 rc
= memcached_fetch_execute(memc
, callbacks
, (void *)&counter
, 1);
2837 static test_return
delete_generate(memcached_st
*memc
)
2841 for (x
= 0; x
< global_count
; x
++)
2843 (void)memcached_delete(memc
, global_keys
[x
], global_keys_length
[x
], (time_t)0);
2849 static test_return
delete_buffer_generate(memcached_st
*memc
)
2855 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_BUFFER_REQUESTS
, latch
);
2857 for (x
= 0; x
< global_count
; x
++)
2859 (void)memcached_delete(memc
, global_keys
[x
], global_keys_length
[x
], (time_t)0);
2865 static test_return
add_host_test1(memcached_st
*memc
)
2868 memcached_return rc
;
2869 char servername
[]= "0.example.com";
2870 memcached_server_st
*servers
;
2872 servers
= memcached_server_list_append_with_weight(NULL
, servername
, 400, 0, &rc
);
2874 assert(1 == memcached_server_list_count(servers
));
2876 for (x
= 2; x
< 20; x
++)
2878 char buffer
[SMALL_STRING_LEN
];
2880 snprintf(buffer
, SMALL_STRING_LEN
, "%u.example.com", 400+x
);
2881 servers
= memcached_server_list_append_with_weight(servers
, buffer
, 401, 0,
2883 assert(rc
== MEMCACHED_SUCCESS
);
2884 assert(x
== memcached_server_list_count(servers
));
2887 rc
= memcached_server_push(memc
, servers
);
2888 assert(rc
== MEMCACHED_SUCCESS
);
2889 rc
= memcached_server_push(memc
, servers
);
2890 assert(rc
== MEMCACHED_SUCCESS
);
2892 memcached_server_list_free(servers
);
2897 static memcached_return
pre_nonblock(memcached_st
*memc
)
2899 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NO_BLOCK
, 0);
2901 return MEMCACHED_SUCCESS
;
2904 static memcached_return
pre_nonblock_binary(memcached_st
*memc
)
2906 memcached_return rc
= MEMCACHED_FAILURE
;
2907 memcached_st
*clone
;
2909 clone
= memcached_clone(NULL
, memc
);
2911 // The memcached_version needs to be done on a clone, because the server
2912 // will not toggle protocol on an connection.
2913 memcached_version(clone
);
2915 if (clone
->hosts
[0].major_version
>= 1 && clone
->hosts
[0].minor_version
> 2)
2917 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NO_BLOCK
, 0);
2918 rc
= memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
, 1);
2919 assert(rc
== MEMCACHED_SUCCESS
);
2920 assert(memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
) == 1);
2923 memcached_free(clone
);
2927 static memcached_return
pre_murmur(memcached_st
*memc
)
2929 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_HASH
, (uint64_t)MEMCACHED_HASH_MURMUR
);
2931 return MEMCACHED_SUCCESS
;
2934 static memcached_return
pre_jenkins(memcached_st
*memc
)
2936 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_HASH
, (uint64_t)MEMCACHED_HASH_JENKINS
);
2938 return MEMCACHED_SUCCESS
;
2942 static memcached_return
pre_md5(memcached_st
*memc
)
2944 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_HASH
, (uint64_t)MEMCACHED_HASH_MD5
);
2946 return MEMCACHED_SUCCESS
;
2949 static memcached_return
pre_crc(memcached_st
*memc
)
2951 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_HASH
, (uint64_t)MEMCACHED_HASH_CRC
);
2953 return MEMCACHED_SUCCESS
;
2956 static memcached_return
pre_hsieh(memcached_st
*memc
)
2958 #ifdef HAVE_HSIEH_HASH
2959 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_HASH
, (uint64_t)MEMCACHED_HASH_HSIEH
);
2960 return MEMCACHED_SUCCESS
;
2963 return MEMCACHED_FAILURE
;
2967 static memcached_return
pre_hash_fnv1_64(memcached_st
*memc
)
2969 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_HASH
, (uint64_t)MEMCACHED_HASH_FNV1_64
);
2971 return MEMCACHED_SUCCESS
;
2974 static memcached_return
pre_hash_fnv1a_64(memcached_st
*memc
)
2976 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_HASH
, (uint64_t)MEMCACHED_HASH_FNV1A_64
);
2978 return MEMCACHED_SUCCESS
;
2981 static memcached_return
pre_hash_fnv1_32(memcached_st
*memc
)
2983 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_HASH
, (uint64_t)MEMCACHED_HASH_FNV1_32
);
2985 return MEMCACHED_SUCCESS
;
2988 static memcached_return
pre_hash_fnv1a_32(memcached_st
*memc
)
2990 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_HASH
, (uint64_t)MEMCACHED_HASH_FNV1A_32
);
2992 return MEMCACHED_SUCCESS
;
2995 static memcached_return
pre_behavior_ketama(memcached_st
*memc
)
2997 memcached_return rc
;
3000 rc
= memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_KETAMA
, 1);
3001 assert(rc
== MEMCACHED_SUCCESS
);
3003 value
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_KETAMA
);
3006 return MEMCACHED_SUCCESS
;
3009 static memcached_return
pre_behavior_ketama_weighted(memcached_st
*memc
)
3011 memcached_return rc
;
3014 rc
= memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_KETAMA_WEIGHTED
, 1);
3015 assert(rc
== MEMCACHED_SUCCESS
);
3017 value
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_KETAMA_WEIGHTED
);
3020 rc
= memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_KETAMA_HASH
, MEMCACHED_HASH_MD5
);
3021 assert(rc
== MEMCACHED_SUCCESS
);
3023 value
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_KETAMA_HASH
);
3024 assert(value
== MEMCACHED_HASH_MD5
);
3025 return MEMCACHED_SUCCESS
;
3028 static memcached_return
pre_binary(memcached_st
*memc
)
3030 memcached_return rc
= MEMCACHED_FAILURE
;
3031 memcached_st
*clone
;
3033 clone
= memcached_clone(NULL
, memc
);
3035 // The memcached_version needs to be done on a clone, because the server
3036 // will not toggle protocol on an connection.
3037 memcached_version(clone
);
3039 if (clone
->hosts
[0].major_version
>= 1 && clone
->hosts
[0].minor_version
> 2)
3041 rc
= memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
, 1);
3042 assert(rc
== MEMCACHED_SUCCESS
);
3043 assert(memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
) == 1);
3046 memcached_free(clone
);
3050 static void my_free(memcached_st
*ptr
__attribute__((unused
)), void *mem
)
3055 static void *my_malloc(memcached_st
*ptr
__attribute__((unused
)), const size_t size
)
3057 void *ret
= malloc(size
);
3059 memset(ret
, 0xff, size
);
3064 static void *my_realloc(memcached_st
*ptr
__attribute__((unused
)), void *mem
, const size_t size
)
3066 return realloc(mem
, size
);
3069 static void *my_calloc(memcached_st
*ptr
__attribute__((unused
)), size_t nelem
, const size_t size
)
3071 return calloc(nelem
, size
);
3074 static memcached_return
set_prefix(memcached_st
*memc
)
3076 memcached_return rc
;
3077 const char *key
= "mine";
3080 /* Make sure be default none exists */
3081 value
= memcached_callback_get(memc
, MEMCACHED_CALLBACK_PREFIX_KEY
, &rc
);
3082 assert(rc
== MEMCACHED_FAILURE
);
3084 /* Test a clean set */
3085 rc
= memcached_callback_set(memc
, MEMCACHED_CALLBACK_PREFIX_KEY
, (void *)key
);
3086 assert(rc
== MEMCACHED_SUCCESS
);
3088 value
= memcached_callback_get(memc
, MEMCACHED_CALLBACK_PREFIX_KEY
, &rc
);
3089 assert(memcmp(value
, key
, 4) == 0);
3090 assert(rc
== MEMCACHED_SUCCESS
);
3092 /* Test that we can turn it off */
3093 rc
= memcached_callback_set(memc
, MEMCACHED_CALLBACK_PREFIX_KEY
, NULL
);
3094 assert(rc
== MEMCACHED_SUCCESS
);
3096 value
= memcached_callback_get(memc
, MEMCACHED_CALLBACK_PREFIX_KEY
, &rc
);
3097 assert(rc
== MEMCACHED_FAILURE
);
3099 /* Now setup for main test */
3100 rc
= memcached_callback_set(memc
, MEMCACHED_CALLBACK_PREFIX_KEY
, (void *)key
);
3101 assert(rc
== MEMCACHED_SUCCESS
);
3103 value
= memcached_callback_get(memc
, MEMCACHED_CALLBACK_PREFIX_KEY
, &rc
);
3104 assert(rc
== MEMCACHED_SUCCESS
);
3105 assert(memcmp(value
, key
, 4) == 0);
3107 /* Set to Zero, and then Set to something too large */
3110 rc
= memcached_callback_set(memc
, MEMCACHED_CALLBACK_PREFIX_KEY
, NULL
);
3111 assert(rc
== MEMCACHED_SUCCESS
);
3113 value
= memcached_callback_get(memc
, MEMCACHED_CALLBACK_PREFIX_KEY
, &rc
);
3114 assert(rc
== MEMCACHED_FAILURE
);
3115 assert(value
== NULL
);
3117 /* Test a long key for failure */
3118 /* TODO, extend test to determine based on setting, what result should be */
3119 long_key
= "Thisismorethentheallottednumberofcharacters";
3120 rc
= memcached_callback_set(memc
, MEMCACHED_CALLBACK_PREFIX_KEY
, long_key
);
3121 //assert(rc == MEMCACHED_BAD_KEY_PROVIDED);
3122 assert(rc
== MEMCACHED_SUCCESS
);
3124 /* Now test a key with spaces (which will fail from long key, since bad key is not set) */
3125 long_key
= "This is more then the allotted number of characters";
3126 rc
= memcached_callback_set(memc
, MEMCACHED_CALLBACK_PREFIX_KEY
, long_key
);
3127 assert(rc
== MEMCACHED_BAD_KEY_PROVIDED
);
3129 /* Test for a bad prefix, but with a short key */
3130 rc
= memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_VERIFY_KEY
, 1);
3131 assert(rc
== MEMCACHED_SUCCESS
);
3133 long_key
= "dog cat";
3134 rc
= memcached_callback_set(memc
, MEMCACHED_CALLBACK_PREFIX_KEY
, long_key
);
3135 assert(rc
== MEMCACHED_BAD_KEY_PROVIDED
);
3138 return MEMCACHED_SUCCESS
;
3141 static memcached_return
deprecated_set_memory_alloc(memcached_st
*memc
)
3143 void *test_ptr
= NULL
;
3146 memcached_malloc_function malloc_cb
=
3147 (memcached_malloc_function
)my_malloc
;
3148 cb_ptr
= *(void **)&malloc_cb
;
3149 memcached_return rc
;
3151 rc
= memcached_callback_set(memc
, MEMCACHED_CALLBACK_MALLOC_FUNCTION
, cb_ptr
);
3152 assert(rc
== MEMCACHED_SUCCESS
);
3153 test_ptr
= memcached_callback_get(memc
, MEMCACHED_CALLBACK_MALLOC_FUNCTION
, &rc
);
3154 assert(rc
== MEMCACHED_SUCCESS
);
3155 assert(test_ptr
== cb_ptr
);
3159 memcached_realloc_function realloc_cb
=
3160 (memcached_realloc_function
)my_realloc
;
3161 cb_ptr
= *(void **)&realloc_cb
;
3162 memcached_return rc
;
3164 rc
= memcached_callback_set(memc
, MEMCACHED_CALLBACK_REALLOC_FUNCTION
, cb_ptr
);
3165 assert(rc
== MEMCACHED_SUCCESS
);
3166 test_ptr
= memcached_callback_get(memc
, MEMCACHED_CALLBACK_REALLOC_FUNCTION
, &rc
);
3167 assert(rc
== MEMCACHED_SUCCESS
);
3168 assert(test_ptr
== cb_ptr
);
3172 memcached_free_function free_cb
=
3173 (memcached_free_function
)my_free
;
3174 cb_ptr
= *(void **)&free_cb
;
3175 memcached_return rc
;
3177 rc
= memcached_callback_set(memc
, MEMCACHED_CALLBACK_FREE_FUNCTION
, cb_ptr
);
3178 assert(rc
== MEMCACHED_SUCCESS
);
3179 test_ptr
= memcached_callback_get(memc
, MEMCACHED_CALLBACK_FREE_FUNCTION
, &rc
);
3180 assert(rc
== MEMCACHED_SUCCESS
);
3181 assert(test_ptr
== cb_ptr
);
3183 return MEMCACHED_SUCCESS
;
3186 static memcached_return
set_memory_alloc(memcached_st
*memc
)
3188 memcached_return rc
;
3189 rc
= memcached_set_memory_allocators(memc
, NULL
, my_free
,
3190 my_realloc
, my_calloc
);
3191 assert(rc
== MEMCACHED_FAILURE
);
3193 rc
= memcached_set_memory_allocators(memc
, my_malloc
, my_free
,
3194 my_realloc
, my_calloc
);
3196 memcached_malloc_function mem_malloc
;
3197 memcached_free_function mem_free
;
3198 memcached_realloc_function mem_realloc
;
3199 memcached_calloc_function mem_calloc
;
3200 memcached_get_memory_allocators(memc
, &mem_malloc
, &mem_free
,
3201 &mem_realloc
, &mem_calloc
);
3203 assert(mem_malloc
== my_malloc
);
3204 assert(mem_realloc
== my_realloc
);
3205 assert(mem_calloc
== my_calloc
);
3206 assert(mem_free
== my_free
);
3208 return MEMCACHED_SUCCESS
;
3211 static memcached_return
enable_consistent(memcached_st
*memc
)
3213 memcached_server_distribution value
= MEMCACHED_DISTRIBUTION_CONSISTENT
;
3214 memcached_hash hash
;
3215 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_DISTRIBUTION
, value
);
3216 if (pre_hsieh(memc
) != MEMCACHED_SUCCESS
)
3217 return MEMCACHED_FAILURE
;
3219 value
= (memcached_server_distribution
)memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_DISTRIBUTION
);
3220 assert(value
== MEMCACHED_DISTRIBUTION_CONSISTENT
);
3222 hash
= (memcached_hash
)memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_HASH
);
3223 assert(hash
== MEMCACHED_HASH_HSIEH
);
3226 return MEMCACHED_SUCCESS
;
3229 static memcached_return
enable_cas(memcached_st
*memc
)
3231 unsigned int set
= 1;
3233 memcached_version(memc
);
3235 if ((memc
->hosts
[0].major_version
>= 1 && (memc
->hosts
[0].minor_version
== 2 && memc
->hosts
[0].micro_version
>= 4))
3236 || memc
->hosts
[0].minor_version
> 2)
3238 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_SUPPORT_CAS
, set
);
3240 return MEMCACHED_SUCCESS
;
3243 return MEMCACHED_FAILURE
;
3246 static memcached_return
check_for_1_2_3(memcached_st
*memc
)
3248 memcached_version(memc
);
3250 if ((memc
->hosts
[0].major_version
>= 1 && (memc
->hosts
[0].minor_version
== 2 && memc
->hosts
[0].micro_version
>= 4))
3251 || memc
->hosts
[0].minor_version
> 2)
3252 return MEMCACHED_SUCCESS
;
3254 return MEMCACHED_FAILURE
;
3257 static memcached_return
pre_unix_socket(memcached_st
*memc
)
3259 memcached_return rc
;
3262 memcached_server_list_free(memc
->hosts
);
3264 memc
->number_of_hosts
= 0;
3266 if (stat("/tmp/memcached.socket", &buf
))
3267 return MEMCACHED_FAILURE
;
3269 rc
= memcached_server_add_unix_socket_with_weight(memc
, "/tmp/memcached.socket", 0);
3274 static memcached_return
pre_nodelay(memcached_st
*memc
)
3276 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NO_BLOCK
, 0);
3277 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_TCP_NODELAY
, 0);
3279 return MEMCACHED_SUCCESS
;
3282 static memcached_return
pre_settimer(memcached_st
*memc
)
3284 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_SND_TIMEOUT
, 1000);
3285 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_RCV_TIMEOUT
, 1000);
3287 return MEMCACHED_SUCCESS
;
3290 static memcached_return
poll_timeout(memcached_st
*memc
)
3296 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_POLL_TIMEOUT
, timeout
);
3298 timeout
= (int32_t)memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_POLL_TIMEOUT
);
3300 assert(timeout
== 100);
3302 return MEMCACHED_SUCCESS
;
3305 static test_return
noreply_test(memcached_st
*memc
)
3307 memcached_return ret
;
3308 ret
= memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NOREPLY
, 1);
3309 assert(ret
== MEMCACHED_SUCCESS
);
3310 ret
= memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_BUFFER_REQUESTS
, 1);
3311 assert(ret
== MEMCACHED_SUCCESS
);
3312 ret
= memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_SUPPORT_CAS
, 1);
3313 assert(ret
== MEMCACHED_SUCCESS
);
3314 assert(memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_NOREPLY
) == 1);
3315 assert(memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_BUFFER_REQUESTS
) == 1);
3316 assert(memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_SUPPORT_CAS
) == 1);
3318 for (int count
=0; count
< 5; ++count
)
3320 for (int x
=0; x
< 100; ++x
)
3323 size_t len
= sprintf(key
, "%d", x
);
3327 ret
=memcached_add(memc
, key
, len
, key
, len
, 0, 0);
3330 ret
=memcached_replace(memc
, key
, len
, key
, len
, 0, 0);
3333 ret
=memcached_set(memc
, key
, len
, key
, len
, 0, 0);
3336 ret
=memcached_append(memc
, key
, len
, key
, len
, 0, 0);
3339 ret
=memcached_prepend(memc
, key
, len
, key
, len
, 0, 0);
3342 assert(ret
== MEMCACHED_SUCCESS
|| ret
== MEMCACHED_BUFFERED
);
3346 ** NOTE: Don't ever do this in your code! this is not a supported use of the
3347 ** API and is _ONLY_ done this way to verify that the library works the
3348 ** way it is supposed to do!!!!
3351 for (uint32_t x
=0; x
< memc
->number_of_hosts
; ++x
)
3352 no_msg
+=memc
->hosts
[x
].cursor_active
;
3354 assert(no_msg
== 0);
3355 assert(memcached_flush_buffers(memc
) == MEMCACHED_SUCCESS
);
3358 ** Now validate that all items was set properly!
3360 for (int x
=0; x
< 100; ++x
)
3363 size_t len
= sprintf(key
, "%d", x
);
3366 char* value
=memcached_get(memc
, key
, strlen(key
),
3367 &length
, &flags
, &ret
);
3368 assert(ret
== MEMCACHED_SUCCESS
&& value
!= NULL
);
3371 case 0: /* FALLTHROUGH */
3372 case 1: /* FALLTHROUGH */
3374 assert(strncmp(value
, key
, len
) == 0);
3375 assert(len
== length
);
3378 assert(length
== len
* 2);
3381 assert(length
== len
* 3);
3388 /* Try setting an illegal cas value (should not return an error to
3389 * the caller (because we don't expect a return message from the server)
3391 char* keys
[]= {"0"};
3392 size_t lengths
[]= {1};
3395 memcached_result_st results_obj
;
3396 memcached_result_st
*results
;
3397 ret
= memcached_mget(memc
, keys
, lengths
, 1);
3398 assert(ret
== MEMCACHED_SUCCESS
);
3400 results
= memcached_result_create(memc
, &results_obj
);
3402 results
= memcached_fetch_result(memc
, &results_obj
, &ret
);
3404 assert(ret
== MEMCACHED_SUCCESS
);
3405 uint64_t cas
= memcached_result_cas(results
);
3406 memcached_result_free(&results_obj
);
3408 ret
= memcached_cas(memc
, keys
[0], lengths
[0], keys
[0], lengths
[0], 0, 0, cas
);
3409 assert(ret
== MEMCACHED_SUCCESS
);
3412 * The item will have a new cas value, so try to set it again with the old
3413 * value. This should fail!
3415 ret
= memcached_cas(memc
, keys
[0], lengths
[0], keys
[0], lengths
[0], 0, 0, cas
);
3416 assert(ret
== MEMCACHED_SUCCESS
);
3417 assert(memcached_flush_buffers(memc
) == MEMCACHED_SUCCESS
);
3418 char* value
=memcached_get(memc
, keys
[0], lengths
[0], &length
, &flags
, &ret
);
3419 assert(ret
== MEMCACHED_SUCCESS
&& value
!= NULL
);
3422 return TEST_SUCCESS
;
3425 static test_return
analyzer_test(memcached_st
*memc
)
3427 memcached_return rc
;
3428 memcached_stat_st
*stat
;
3429 memcached_analysis_st
*report
;
3431 stat
= memcached_stat(memc
, NULL
, &rc
);
3432 assert(rc
== MEMCACHED_SUCCESS
);
3435 report
= memcached_analyze(memc
, stat
, &rc
);
3436 assert(rc
== MEMCACHED_SUCCESS
);
3440 memcached_stat_free(NULL
, stat
);
3442 return TEST_SUCCESS
;
3445 /* Count the objects */
3446 static memcached_return
callback_dump_counter(memcached_st
*ptr
__attribute__((unused
)),
3447 const char *key
__attribute__((unused
)),
3448 size_t key_length
__attribute__((unused
)),
3451 uint32_t *counter
= (uint32_t *)context
;
3453 *counter
= *counter
+ 1;
3455 return MEMCACHED_SUCCESS
;
3458 static test_return
dump_test(memcached_st
*memc
)
3460 memcached_return rc
;
3461 uint32_t counter
= 0;
3462 memcached_dump_func callbacks
[1];
3463 test_return main_rc
;
3465 callbacks
[0]= &callback_dump_counter
;
3467 /* No support for Binary protocol yet */
3468 if (memc
->flags
& MEM_BINARY_PROTOCOL
)
3469 return TEST_SUCCESS
;
3471 main_rc
= set_test3(memc
);
3473 assert (main_rc
== TEST_SUCCESS
);
3475 rc
= memcached_dump(memc
, callbacks
, (void *)&counter
, 1);
3476 assert(rc
== MEMCACHED_SUCCESS
);
3478 /* We may have more then 32 if our previous flush has not completed */
3479 assert(counter
>= 32);
3481 return TEST_SUCCESS
;
3484 #ifdef HAVE_LIBMEMCACHEDUTIL
3485 static void* connection_release(void *arg
) {
3487 memcached_pool_st
* pool
;
3492 assert(memcached_pool_push(resource
->pool
, resource
->mmc
) == MEMCACHED_SUCCESS
);
3496 static test_return
connection_pool_test(memcached_st
*memc
)
3498 memcached_pool_st
* pool
= memcached_pool_create(memc
, 5, 10);
3499 assert(pool
!= NULL
);
3500 memcached_st
* mmc
[10];
3501 memcached_return rc
;
3503 for (int x
= 0; x
< 10; ++x
) {
3504 mmc
[x
]= memcached_pool_pop(pool
, false, &rc
);
3505 assert(mmc
[x
] != NULL
);
3506 assert(rc
== MEMCACHED_SUCCESS
);
3509 assert(memcached_pool_pop(pool
, false, &rc
) == NULL
);
3510 assert(rc
== MEMCACHED_SUCCESS
);
3514 memcached_pool_st
* pool
;
3516 } item
= { .pool
= pool
, .mmc
= mmc
[9] };
3517 pthread_create(&tid
, NULL
, connection_release
, &item
);
3518 mmc
[9]= memcached_pool_pop(pool
, true, &rc
);
3519 assert(rc
== MEMCACHED_SUCCESS
);
3520 pthread_join(tid
, NULL
);
3521 assert(mmc
[9] == item
.mmc
);
3522 const char *key
= "key";
3523 size_t keylen
= strlen(key
);
3525 // verify that I can do ops with all connections
3526 rc
= memcached_set(mmc
[0], key
, keylen
, "0", 1, 0, 0);
3527 assert(rc
== MEMCACHED_SUCCESS
);
3529 for (unsigned int x
= 0; x
< 10; ++x
) {
3530 uint64_t number_value
;
3531 rc
= memcached_increment(mmc
[x
], key
, keylen
, 1, &number_value
);
3532 assert(rc
== MEMCACHED_SUCCESS
);
3533 assert(number_value
== (x
+1));
3537 for (int x
= 0; x
< 10; ++x
)
3538 assert(memcached_pool_push(pool
, mmc
[x
]) == MEMCACHED_SUCCESS
);
3540 assert(memcached_pool_destroy(pool
) == memc
);
3541 return TEST_SUCCESS
;
3545 static void increment_request_id(uint16_t *id
)
3548 if ((*id
& UDP_REQUEST_ID_THREAD_MASK
) != 0)
3552 static uint16_t *get_udp_request_ids(memcached_st
*memc
)
3554 uint16_t *ids
= malloc(sizeof(uint16_t) * memc
->number_of_hosts
);
3555 assert(ids
!= NULL
);
3557 for (x
= 0; x
< memc
->number_of_hosts
; x
++)
3558 ids
[x
]= get_udp_datagram_request_id((struct udp_datagram_header_st
*) memc
->hosts
[x
].write_buffer
);
3563 static test_return
post_udp_op_check(memcached_st
*memc
, uint16_t *expected_req_ids
)
3566 memcached_server_st
*cur_server
= memc
->hosts
;
3567 uint16_t *cur_req_ids
= get_udp_request_ids(memc
);
3568 for (x
= 0; x
< memc
->number_of_hosts
; x
++)
3570 assert(cur_server
[x
].cursor_active
== 0);
3571 assert(cur_req_ids
[x
] == expected_req_ids
[x
]);
3573 free(expected_req_ids
);
3575 return TEST_SUCCESS
;
3579 ** There is a little bit of a hack here, instead of removing
3580 ** the servers, I just set num host to 0 and them add then new udp servers
3582 static memcached_return
init_udp(memcached_st
*memc
)
3584 memcached_version(memc
);
3585 /* For the time being, only support udp test for >= 1.2.6 && < 1.3 */
3586 if (memc
->hosts
[0].major_version
!= 1 || memc
->hosts
[0].minor_version
!= 2
3587 || memc
->hosts
[0].micro_version
< 6)
3588 return MEMCACHED_FAILURE
;
3590 uint32_t num_hosts
= memc
->number_of_hosts
;
3592 memcached_server_st servers
[num_hosts
];
3593 memcpy(servers
, memc
->hosts
, sizeof(memcached_server_st
) * num_hosts
);
3594 for (x
= 0; x
< num_hosts
; x
++)
3595 memcached_server_free(&memc
->hosts
[x
]);
3596 memc
->number_of_hosts
= 0;
3597 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_USE_UDP
, 1);
3598 for (x
= 0; x
< num_hosts
; x
++)
3600 assert(memcached_server_add_udp(memc
, servers
[x
].hostname
, servers
[x
].port
) == MEMCACHED_SUCCESS
);
3601 assert(memc
->hosts
[x
].write_buffer_offset
== UDP_DATAGRAM_HEADER_LENGTH
);
3603 return MEMCACHED_SUCCESS
;
3606 static memcached_return
binary_init_udp(memcached_st
*memc
)
3609 return init_udp(memc
);
3612 /* Make sure that I cant add a tcp server to a udp client */
3613 static test_return
add_tcp_server_udp_client_test(memcached_st
*memc
)
3615 memcached_server_st server
;
3616 memcached_server_clone(&server
, &memc
->hosts
[0]);
3617 assert(memcached_server_remove(&(memc
->hosts
[0])) == MEMCACHED_SUCCESS
);
3618 assert(memcached_server_add(memc
, server
.hostname
, server
.port
) == MEMCACHED_INVALID_HOST_PROTOCOL
);
3619 return TEST_SUCCESS
;
3622 /* Make sure that I cant add a udp server to a tcp client */
3623 static test_return
add_udp_server_tcp_client_test(memcached_st
*memc
)
3625 memcached_server_st server
;
3626 memcached_server_clone(&server
, &memc
->hosts
[0]);
3627 assert(memcached_server_remove(&(memc
->hosts
[0])) == MEMCACHED_SUCCESS
);
3629 memcached_st tcp_client
;
3630 memcached_create(&tcp_client
);
3631 assert(memcached_server_add_udp(&tcp_client
, server
.hostname
, server
.port
) == MEMCACHED_INVALID_HOST_PROTOCOL
);
3632 return TEST_SUCCESS
;
3635 static test_return
set_udp_behavior_test(memcached_st
*memc
)
3638 memcached_quit(memc
);
3639 memc
->number_of_hosts
= 0;
3640 run_distribution(memc
);
3641 assert(memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_USE_UDP
, 1) == MEMCACHED_SUCCESS
);
3642 assert(memc
->flags
& MEM_USE_UDP
);
3643 assert(memc
->flags
& MEM_NOREPLY
);;
3645 assert(memc
->number_of_hosts
== 0);
3647 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_USE_UDP
,0);
3648 assert(!(memc
->flags
& MEM_USE_UDP
));
3649 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NOREPLY
,0);
3650 assert(!(memc
->flags
& MEM_NOREPLY
));
3651 return TEST_SUCCESS
;
3654 static test_return
udp_set_test(memcached_st
*memc
)
3657 unsigned int num_iters
= 1025; //request id rolls over at 1024
3658 for (x
= 0; x
< num_iters
;x
++)
3660 memcached_return rc
;
3662 char *value
= "when we sanitize";
3663 uint16_t *expected_ids
= get_udp_request_ids(memc
);
3664 unsigned int server_key
= memcached_generate_hash(memc
,key
,strlen(key
));
3665 size_t init_offset
= memc
->hosts
[server_key
].write_buffer_offset
;
3666 rc
= memcached_set(memc
, key
, strlen(key
),
3667 value
, strlen(value
),
3668 (time_t)0, (uint32_t)0);
3669 assert(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
);
3670 /** NB, the check below assumes that if new write_ptr is less than
3671 * the original write_ptr that we have flushed. For large payloads, this
3672 * maybe an invalid assumption, but for the small payload we have it is OK
3674 if (rc
== MEMCACHED_SUCCESS
||
3675 memc
->hosts
[server_key
].write_buffer_offset
< init_offset
)
3676 increment_request_id(&expected_ids
[server_key
]);
3678 if (rc
== MEMCACHED_SUCCESS
)
3680 assert(memc
->hosts
[server_key
].write_buffer_offset
== UDP_DATAGRAM_HEADER_LENGTH
);
3684 assert(memc
->hosts
[server_key
].write_buffer_offset
!= UDP_DATAGRAM_HEADER_LENGTH
);
3685 assert(memc
->hosts
[server_key
].write_buffer_offset
<= MAX_UDP_DATAGRAM_LENGTH
);
3687 assert(post_udp_op_check(memc
,expected_ids
) == TEST_SUCCESS
);
3689 return TEST_SUCCESS
;
3692 static test_return
udp_buffered_set_test(memcached_st
*memc
)
3694 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_BUFFER_REQUESTS
, 1);
3695 return udp_set_test(memc
);
3698 static test_return
udp_set_too_big_test(memcached_st
*memc
)
3700 memcached_return rc
;
3702 char value
[MAX_UDP_DATAGRAM_LENGTH
];
3703 uint16_t *expected_ids
= get_udp_request_ids(memc
);
3704 rc
= memcached_set(memc
, key
, strlen(key
),
3705 value
, MAX_UDP_DATAGRAM_LENGTH
,
3706 (time_t)0, (uint32_t)0);
3707 assert(rc
== MEMCACHED_WRITE_FAILURE
);
3708 return post_udp_op_check(memc
,expected_ids
);
3711 static test_return
udp_delete_test(memcached_st
*memc
)
3714 unsigned int num_iters
= 1025; //request id rolls over at 1024
3715 for (x
= 0; x
< num_iters
;x
++)
3717 memcached_return rc
;
3719 uint16_t *expected_ids
=get_udp_request_ids(memc
);
3720 unsigned int server_key
= memcached_generate_hash(memc
, key
, strlen(key
));
3721 size_t init_offset
= memc
->hosts
[server_key
].write_buffer_offset
;
3722 rc
= memcached_delete(memc
, key
, strlen(key
), 0);
3723 assert(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
);
3724 if (rc
== MEMCACHED_SUCCESS
|| memc
->hosts
[server_key
].write_buffer_offset
< init_offset
)
3725 increment_request_id(&expected_ids
[server_key
]);
3726 if (rc
== MEMCACHED_SUCCESS
)
3727 assert(memc
->hosts
[server_key
].write_buffer_offset
== UDP_DATAGRAM_HEADER_LENGTH
);
3730 assert(memc
->hosts
[server_key
].write_buffer_offset
!= UDP_DATAGRAM_HEADER_LENGTH
);
3731 assert(memc
->hosts
[server_key
].write_buffer_offset
<= MAX_UDP_DATAGRAM_LENGTH
);
3733 assert(post_udp_op_check(memc
,expected_ids
) == TEST_SUCCESS
);
3735 return TEST_SUCCESS
;
3738 static test_return
udp_buffered_delete_test(memcached_st
*memc
)
3740 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_BUFFER_REQUESTS
, 1);
3741 return udp_delete_test(memc
);
3744 static test_return
udp_verbosity_test(memcached_st
*memc
)
3746 memcached_return rc
;
3747 uint16_t *expected_ids
= get_udp_request_ids(memc
);
3749 for (x
= 0; x
< memc
->number_of_hosts
;x
++)
3750 increment_request_id(&expected_ids
[x
]);
3752 rc
= memcached_verbosity(memc
,3);
3753 assert(rc
== MEMCACHED_SUCCESS
);
3754 return post_udp_op_check(memc
,expected_ids
);
3757 static test_return
udp_quit_test(memcached_st
*memc
)
3759 uint16_t *expected_ids
= get_udp_request_ids(memc
);
3760 memcached_quit(memc
);
3761 return post_udp_op_check(memc
, expected_ids
);
3764 static test_return
udp_flush_test(memcached_st
*memc
)
3766 memcached_return rc
;
3767 uint16_t *expected_ids
= get_udp_request_ids(memc
);
3769 for (x
= 0; x
< memc
->number_of_hosts
;x
++)
3770 increment_request_id(&expected_ids
[x
]);
3772 rc
= memcached_flush(memc
,0);
3773 assert(rc
== MEMCACHED_SUCCESS
);
3774 return post_udp_op_check(memc
,expected_ids
);
3777 static test_return
udp_incr_test(memcached_st
*memc
)
3779 memcached_return rc
;
3782 rc
= memcached_set(memc
, key
, strlen(key
),
3783 value
, strlen(value
),
3784 (time_t)0, (uint32_t)0);
3786 assert(rc
== MEMCACHED_SUCCESS
);
3787 uint16_t *expected_ids
= get_udp_request_ids(memc
);
3788 unsigned int server_key
= memcached_generate_hash(memc
, key
, strlen(key
));
3789 increment_request_id(&expected_ids
[server_key
]);
3791 rc
= memcached_increment(memc
, key
, strlen(key
), 1, &newvalue
);
3792 assert(rc
== MEMCACHED_SUCCESS
);
3793 return post_udp_op_check(memc
, expected_ids
);
3796 static test_return
udp_decr_test(memcached_st
*memc
)
3798 memcached_return rc
;
3801 rc
= memcached_set(memc
, key
, strlen(key
),
3802 value
, strlen(value
),
3803 (time_t)0, (uint32_t)0);
3805 assert(rc
== MEMCACHED_SUCCESS
);
3806 uint16_t *expected_ids
= get_udp_request_ids(memc
);
3807 unsigned int server_key
= memcached_generate_hash(memc
, key
, strlen(key
));
3808 increment_request_id(&expected_ids
[server_key
]);
3810 rc
= memcached_decrement(memc
, key
, strlen(key
), 1, &newvalue
);
3811 assert(rc
== MEMCACHED_SUCCESS
);
3812 return post_udp_op_check(memc
, expected_ids
);
3816 static test_return
udp_stat_test(memcached_st
*memc
)
3818 memcached_stat_st
* rv
= NULL
;
3819 memcached_return rc
;
3821 uint16_t *expected_ids
= get_udp_request_ids(memc
);
3822 rv
= memcached_stat(memc
, args
, &rc
);
3824 assert(rc
== MEMCACHED_NOT_SUPPORTED
);
3825 return post_udp_op_check(memc
, expected_ids
);
3828 static test_return
udp_version_test(memcached_st
*memc
)
3830 memcached_return rc
;
3831 uint16_t *expected_ids
= get_udp_request_ids(memc
);
3832 rc
= memcached_version(memc
);
3833 assert(rc
== MEMCACHED_NOT_SUPPORTED
);
3834 return post_udp_op_check(memc
, expected_ids
);
3837 static test_return
udp_get_test(memcached_st
*memc
)
3839 memcached_return rc
;
3842 uint16_t *expected_ids
= get_udp_request_ids(memc
);
3843 char *val
= memcached_get(memc
, key
, strlen(key
), &vlen
, (uint32_t)0, &rc
);
3844 assert(rc
== MEMCACHED_NOT_SUPPORTED
);
3845 assert(val
== NULL
);
3846 return post_udp_op_check(memc
, expected_ids
);
3849 static test_return
udp_mixed_io_test(memcached_st
*memc
)
3852 test_st mixed_io_ops
[] ={
3853 {"udp_set_test", 0, udp_set_test
},
3854 {"udp_set_too_big_test", 0, udp_set_too_big_test
},
3855 {"udp_delete_test", 0, udp_delete_test
},
3856 {"udp_verbosity_test", 0, udp_verbosity_test
},
3857 {"udp_quit_test", 0, udp_quit_test
},
3858 {"udp_flush_test", 0, udp_flush_test
},
3859 {"udp_incr_test", 0, udp_incr_test
},
3860 {"udp_decr_test", 0, udp_decr_test
},
3861 {"udp_version_test", 0, udp_version_test
}
3864 for (x
= 0; x
< 500; x
++)
3866 current_op
= mixed_io_ops
[random() % 9];
3867 assert(current_op
.function(memc
) == TEST_SUCCESS
);
3869 return TEST_SUCCESS
;
3872 static test_return
hsieh_avaibility_test (memcached_st
*memc
)
3874 memcached_return expected_rc
= MEMCACHED_FAILURE
;
3875 #ifdef HAVE_HSIEH_HASH
3876 expected_rc
= MEMCACHED_SUCCESS
;
3878 memcached_return rc
= memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_HASH
,
3879 (uint64_t)MEMCACHED_HASH_HSIEH
);
3880 assert(rc
== expected_rc
);
3881 return TEST_SUCCESS
;
3884 static char *list
[]=
3914 static test_return
md5_run (memcached_st
*memc
__attribute__((unused
)))
3918 uint32_t values
[]= { 3195025439, 2556848621, 3724893440, 3332385401, 245758794, 2550894432,
3919 121710495, 3053817768, 1250994555, 1862072655, 2631955953, 2951528551,
3920 1451250070, 2820856945, 2060845566, 3646985608, 2138080750, 217675895,
3921 2230934345, 1234361223, 3968582726, 2455685270, 1293568479, 199067604,
3925 for (ptr
= list
, x
= 0; *ptr
; ptr
++, x
++)
3929 hash_val
= memcached_generate_hash_value(*ptr
, strlen(*ptr
), MEMCACHED_HASH_MD5
);
3930 assert(values
[x
] == hash_val
);
3933 return TEST_SUCCESS
;
3936 static test_return
crc_run (memcached_st
*memc
__attribute__((unused
)))
3940 uint32_t values
[]= { 10542, 22009, 14526, 19510, 19432, 10199, 20634, 9369, 11511, 10362,
3941 7893, 31289, 11313, 9354, 7621, 30628, 15218, 25967, 2695, 9380,
3942 17300, 28156, 9192, 20484, 16925 };
3944 for (ptr
= list
, x
= 0; *ptr
; ptr
++, x
++)
3948 hash_val
= memcached_generate_hash_value(*ptr
, strlen(*ptr
), MEMCACHED_HASH_CRC
);
3949 assert(values
[x
] == hash_val
);
3952 return TEST_SUCCESS
;
3955 static test_return
fnv1_64_run (memcached_st
*memc
__attribute__((unused
)))
3959 uint32_t values
[]= { 473199127, 4148981457, 3971873300, 3257986707, 1722477987, 2991193800,
3960 4147007314, 3633179701, 1805162104, 3503289120, 3395702895, 3325073042,
3961 2345265314, 3340346032, 2722964135, 1173398992, 2815549194, 2562818319,
3962 224996066, 2680194749, 3035305390, 246890365, 2395624193, 4145193337,
3965 for (ptr
= list
, x
= 0; *ptr
; ptr
++, x
++)
3969 hash_val
= memcached_generate_hash_value(*ptr
, strlen(*ptr
), MEMCACHED_HASH_FNV1_64
);
3970 assert(values
[x
] == hash_val
);
3973 return TEST_SUCCESS
;
3976 static test_return
fnv1a_64_run (memcached_st
*memc
__attribute__((unused
)))
3980 uint32_t values
[]= { 1488911807, 2500855813, 1510099634, 1390325195, 3647689787, 3241528582,
3981 1669328060, 2604311949, 734810122, 1516407546, 560948863, 1767346780,
3982 561034892, 4156330026, 3716417003, 3475297030, 1518272172, 227211583,
3983 3938128828, 126112909, 3043416448, 3131561933, 1328739897, 2455664041,
3986 for (ptr
= list
, x
= 0; *ptr
; ptr
++, x
++)
3990 hash_val
= memcached_generate_hash_value(*ptr
, strlen(*ptr
), MEMCACHED_HASH_FNV1A_64
);
3991 assert(values
[x
] == hash_val
);
3994 return TEST_SUCCESS
;
3997 static test_return
fnv1_32_run (memcached_st
*memc
__attribute__((unused
)))
4001 uint32_t values
[]= { 67176023, 1190179409, 2043204404, 3221866419, 2567703427, 3787535528, 4147287986,
4002 3500475733, 344481048, 3865235296, 2181839183, 119581266, 510234242, 4248244304,
4003 1362796839, 103389328, 1449620010, 182962511, 3554262370, 3206747549, 1551306158,
4004 4127558461, 1889140833, 2774173721, 1180552018 };
4007 for (ptr
= list
, x
= 0; *ptr
; ptr
++, x
++)
4011 hash_val
= memcached_generate_hash_value(*ptr
, strlen(*ptr
), MEMCACHED_HASH_FNV1_32
);
4012 assert(values
[x
] == hash_val
);
4015 return TEST_SUCCESS
;
4018 static test_return
fnv1a_32_run (memcached_st
*memc
__attribute__((unused
)))
4022 uint32_t values
[]= { 280767167, 2421315013, 3072375666, 855001899, 459261019, 3521085446, 18738364,
4023 1625305005, 2162232970, 777243802, 3323728671, 132336572, 3654473228, 260679466,
4024 1169454059, 2698319462, 1062177260, 235516991, 2218399068, 405302637, 1128467232,
4025 3579622413, 2138539289, 96429129, 2877453236 };
4027 for (ptr
= list
, x
= 0; *ptr
; ptr
++, x
++)
4031 hash_val
= memcached_generate_hash_value(*ptr
, strlen(*ptr
), MEMCACHED_HASH_FNV1A_32
);
4032 assert(values
[x
] == hash_val
);
4035 return TEST_SUCCESS
;
4038 static test_return
hsieh_run (memcached_st
*memc
__attribute__((unused
)))
4042 #ifdef HAVE_HSIEH_HASH
4043 uint32_t values
[]= { 3738850110, 3636226060, 3821074029, 3489929160, 3485772682, 80540287,
4044 1805464076, 1895033657, 409795758, 979934958, 3634096985, 1284445480,
4045 2265380744, 707972988, 353823508, 1549198350, 1327930172, 9304163,
4046 4220749037, 2493964934, 2777873870, 2057831732, 1510213931, 2027828987,
4049 uint32_t values
[]= { 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1 };
4052 for (ptr
= list
, x
= 0; *ptr
; ptr
++, x
++)
4056 hash_val
= memcached_generate_hash_value(*ptr
, strlen(*ptr
), MEMCACHED_HASH_HSIEH
);
4057 assert(values
[x
] == hash_val
);
4060 return TEST_SUCCESS
;
4063 static test_return
murmur_run (memcached_st
*memc
__attribute__((unused
)))
4067 uint32_t values
[]= { 473199127, 4148981457, 3971873300, 3257986707, 1722477987, 2991193800,
4068 4147007314, 3633179701, 1805162104, 3503289120, 3395702895, 3325073042,
4069 2345265314, 3340346032, 2722964135, 1173398992, 2815549194, 2562818319,
4070 224996066, 2680194749, 3035305390, 246890365, 2395624193, 4145193337,
4073 for (ptr
= list
, x
= 0; *ptr
; ptr
++, x
++)
4077 hash_val
= memcached_generate_hash_value(*ptr
, strlen(*ptr
), MEMCACHED_HASH_FNV1_64
);
4078 assert(values
[x
] == hash_val
);
4081 return TEST_SUCCESS
;
4084 static test_return
jenkins_run (memcached_st
*memc
__attribute__((unused
)))
4088 uint32_t values
[]= { 1442444624, 4253821186, 1885058256, 2120131735, 3261968576, 3515188778,
4089 4232909173, 4288625128, 1812047395, 3689182164, 2502979932, 1214050606,
4090 2415988847, 1494268927, 1025545760, 3920481083, 4153263658, 3824871822,
4091 3072759809, 798622255, 3065432577, 1453328165, 2691550971, 3408888387,
4095 for (ptr
= list
, x
= 0; *ptr
; ptr
++, x
++)
4099 hash_val
= memcached_generate_hash_value(*ptr
, strlen(*ptr
), MEMCACHED_HASH_JENKINS
);
4100 assert(values
[x
] == hash_val
);
4103 return TEST_SUCCESS
;
4106 test_st udp_setup_server_tests
[] ={
4107 {"set_udp_behavior_test", 0, set_udp_behavior_test
},
4108 {"add_tcp_server_udp_client_test", 0, add_tcp_server_udp_client_test
},
4109 {"add_udp_server_tcp_client_test", 0, add_udp_server_tcp_client_test
},
4113 test_st upd_io_tests
[] ={
4114 {"udp_set_test", 0, udp_set_test
},
4115 {"udp_buffered_set_test", 0, udp_buffered_set_test
},
4116 {"udp_set_too_big_test", 0, udp_set_too_big_test
},
4117 {"udp_delete_test", 0, udp_delete_test
},
4118 {"udp_buffered_delete_test", 0, udp_buffered_delete_test
},
4119 {"udp_verbosity_test", 0, udp_verbosity_test
},
4120 {"udp_quit_test", 0, udp_quit_test
},
4121 {"udp_flush_test", 0, udp_flush_test
},
4122 {"udp_incr_test", 0, udp_incr_test
},
4123 {"udp_decr_test", 0, udp_decr_test
},
4124 {"udp_stat_test", 0, udp_stat_test
},
4125 {"udp_version_test", 0, udp_version_test
},
4126 {"udp_get_test", 0, udp_get_test
},
4127 {"udp_mixed_io_test", 0, udp_mixed_io_test
},
4131 /* Clean the server before beginning testing */
4133 {"flush", 0, flush_test
},
4134 {"init", 0, init_test
},
4135 {"allocation", 0, allocation_test
},
4136 {"server_list_null_test", 0, server_list_null_test
},
4137 {"server_unsort", 0, server_unsort_test
},
4138 {"server_sort", 0, server_sort_test
},
4139 {"server_sort2", 0, server_sort2_test
},
4140 {"clone_test", 0, clone_test
},
4141 {"connection_test", 0, connection_test
},
4142 {"callback_test", 0, callback_test
},
4143 {"behavior_test", 0, behavior_test
},
4144 {"userdata_test", 0, userdata_test
},
4145 {"error", 0, error_test
},
4146 {"set", 0, set_test
},
4147 {"set2", 0, set_test2
},
4148 {"set3", 0, set_test3
},
4149 {"dump", 1, dump_test
},
4150 {"add", 1, add_test
},
4151 {"replace", 1, replace_test
},
4152 {"delete", 1, delete_test
},
4153 {"get", 1, get_test
},
4154 {"get2", 0, get_test2
},
4155 {"get3", 0, get_test3
},
4156 {"get4", 0, get_test4
},
4157 {"partial mget", 0, get_test5
},
4158 {"stats_servername", 0, stats_servername_test
},
4159 {"increment", 0, increment_test
},
4160 {"increment_with_initial", 1, increment_with_initial_test
},
4161 {"decrement", 0, decrement_test
},
4162 {"decrement_with_initial", 1, decrement_with_initial_test
},
4163 {"quit", 0, quit_test
},
4164 {"mget", 1, mget_test
},
4165 {"mget_result", 1, mget_result_test
},
4166 {"mget_result_alloc", 1, mget_result_alloc_test
},
4167 {"mget_result_function", 1, mget_result_function
},
4168 {"get_stats", 0, get_stats
},
4169 {"add_host_test", 0, add_host_test
},
4170 {"add_host_test_1", 0, add_host_test1
},
4171 {"get_stats_keys", 0, get_stats_keys
},
4172 {"behavior_test", 0, get_stats_keys
},
4173 {"callback_test", 0, get_stats_keys
},
4174 {"version_string_test", 0, version_string_test
},
4175 {"bad_key", 1, bad_key_test
},
4176 {"memcached_server_cursor", 1, memcached_server_cursor_test
},
4177 {"read_through", 1, read_through
},
4178 {"delete_through", 1, delete_through
},
4179 {"noreply", 1, noreply_test
},
4180 {"analyzer", 1, analyzer_test
},
4181 #ifdef HAVE_LIBMEMCACHEDUTIL
4182 {"connectionpool", 1, connection_pool_test
},
4187 test_st async_tests
[] ={
4188 {"add", 1, add_wrapper
},
4192 test_st string_tests
[] ={
4193 {"string static with null", 0, string_static_null
},
4194 {"string alloc with null", 0, string_alloc_null
},
4195 {"string alloc with 1K", 0, string_alloc_with_size
},
4196 {"string alloc with malloc failure", 0, string_alloc_with_size_toobig
},
4197 {"string append", 0, string_alloc_append
},
4198 {"string append failure (too big)", 0, string_alloc_append_toobig
},
4202 test_st result_tests
[] ={
4203 {"result static", 0, result_static
},
4204 {"result alloc", 0, result_alloc
},
4208 test_st version_1_2_3
[] ={
4209 {"append", 0, append_test
},
4210 {"prepend", 0, prepend_test
},
4211 {"cas", 0, cas_test
},
4212 {"cas2", 0, cas2_test
},
4213 {"append_binary", 0, append_binary_test
},
4217 test_st user_tests
[] ={
4218 {"user_supplied_bug1", 0, user_supplied_bug1
},
4219 {"user_supplied_bug2", 0, user_supplied_bug2
},
4220 {"user_supplied_bug3", 0, user_supplied_bug3
},
4221 {"user_supplied_bug4", 0, user_supplied_bug4
},
4222 {"user_supplied_bug5", 1, user_supplied_bug5
},
4223 {"user_supplied_bug6", 1, user_supplied_bug6
},
4224 {"user_supplied_bug7", 1, user_supplied_bug7
},
4225 {"user_supplied_bug8", 1, user_supplied_bug8
},
4226 {"user_supplied_bug9", 1, user_supplied_bug9
},
4227 {"user_supplied_bug10", 1, user_supplied_bug10
},
4228 {"user_supplied_bug11", 1, user_supplied_bug11
},
4229 {"user_supplied_bug12", 1, user_supplied_bug12
},
4230 {"user_supplied_bug13", 1, user_supplied_bug13
},
4231 {"user_supplied_bug14", 1, user_supplied_bug14
},
4232 {"user_supplied_bug15", 1, user_supplied_bug15
},
4233 {"user_supplied_bug16", 1, user_supplied_bug16
},
4236 ** It seems to be something weird with the character sets..
4237 ** value_fetch is unable to parse the value line (iscntrl "fails"), so I
4238 ** guess I need to find out how this is supposed to work.. Perhaps I need
4239 ** to run the test in a specific locale (I tried zh_CN.UTF-8 without success,
4240 ** so just disable the code for now...).
4242 {"user_supplied_bug17", 1, user_supplied_bug17
},
4244 {"user_supplied_bug18", 1, user_supplied_bug18
},
4245 {"user_supplied_bug19", 1, user_supplied_bug19
},
4246 {"user_supplied_bug20", 1, user_supplied_bug20
},
4250 test_st generate_tests
[] ={
4251 {"generate_pairs", 1, generate_pairs
},
4252 {"generate_data", 1, generate_data
},
4253 {"get_read", 0, get_read
},
4254 {"delete_generate", 0, delete_generate
},
4255 {"generate_buffer_data", 1, generate_buffer_data
},
4256 {"delete_buffer", 0, delete_buffer_generate
},
4257 {"generate_data", 1, generate_data
},
4258 {"mget_read", 0, mget_read
},
4259 {"mget_read_result", 0, mget_read_result
},
4260 {"mget_read_function", 0, mget_read_function
},
4261 {"cleanup", 1, cleanup_pairs
},
4262 {"generate_large_pairs", 1, generate_large_pairs
},
4263 {"generate_data", 1, generate_data
},
4264 {"generate_buffer_data", 1, generate_buffer_data
},
4265 {"cleanup", 1, cleanup_pairs
},
4269 test_st consistent_tests
[] ={
4270 {"generate_pairs", 1, generate_pairs
},
4271 {"generate_data", 1, generate_data
},
4272 {"get_read", 0, get_read_count
},
4273 {"cleanup", 1, cleanup_pairs
},
4277 test_st consistent_weighted_tests
[] ={
4278 {"generate_pairs", 1, generate_pairs
},
4279 {"generate_data", 1, generate_data_with_stats
},
4280 {"get_read", 0, get_read_count
},
4281 {"cleanup", 1, cleanup_pairs
},
4285 test_st hsieh_availability
[] ={
4286 {"hsieh_avaibility_test",0,hsieh_avaibility_test
},
4290 test_st ketama_auto_eject_hosts
[] ={
4291 {"auto_eject_hosts", 1, auto_eject_hosts
},
4295 test_st hash_tests
[] ={
4296 {"md5", 0, md5_run
},
4297 {"crc", 0, crc_run
},
4298 {"fnv1_64", 0, fnv1_64_run
},
4299 {"fnv1a_64", 0, fnv1a_64_run
},
4300 {"fnv1_32", 0, fnv1_32_run
},
4301 {"fnv1a_32", 0, fnv1a_32_run
},
4302 {"hsieh", 0, hsieh_run
},
4303 {"murmur", 0, murmur_run
},
4304 {"jenkis", 0, jenkins_run
},
4308 collection_st collection
[] ={
4309 {"hsieh_availability",0,0,hsieh_availability
},
4310 {"udp_setup", init_udp
, 0, udp_setup_server_tests
},
4311 {"udp_io", init_udp
, 0, upd_io_tests
},
4312 {"udp_binary_io", binary_init_udp
, 0, upd_io_tests
},
4313 {"block", 0, 0, tests
},
4314 {"binary", pre_binary
, 0, tests
},
4315 {"nonblock", pre_nonblock
, 0, tests
},
4316 {"nodelay", pre_nodelay
, 0, tests
},
4317 {"settimer", pre_settimer
, 0, tests
},
4318 {"md5", pre_md5
, 0, tests
},
4319 {"crc", pre_crc
, 0, tests
},
4320 {"hsieh", pre_hsieh
, 0, tests
},
4321 {"jenkins", pre_jenkins
, 0, tests
},
4322 {"fnv1_64", pre_hash_fnv1_64
, 0, tests
},
4323 {"fnv1a_64", pre_hash_fnv1a_64
, 0, tests
},
4324 {"fnv1_32", pre_hash_fnv1_32
, 0, tests
},
4325 {"fnv1a_32", pre_hash_fnv1a_32
, 0, tests
},
4326 {"ketama", pre_behavior_ketama
, 0, tests
},
4327 {"ketama_auto_eject_hosts", pre_behavior_ketama
, 0, ketama_auto_eject_hosts
},
4328 {"unix_socket", pre_unix_socket
, 0, tests
},
4329 {"unix_socket_nodelay", pre_nodelay
, 0, tests
},
4330 {"poll_timeout", poll_timeout
, 0, tests
},
4331 {"gets", enable_cas
, 0, tests
},
4332 {"consistent", enable_consistent
, 0, tests
},
4333 {"deprecated_memory_allocators", deprecated_set_memory_alloc
, 0, tests
},
4334 {"memory_allocators", set_memory_alloc
, 0, tests
},
4335 {"prefix", set_prefix
, 0, tests
},
4336 {"version_1_2_3", check_for_1_2_3
, 0, version_1_2_3
},
4337 {"string", 0, 0, string_tests
},
4338 {"result", 0, 0, result_tests
},
4339 {"async", pre_nonblock
, 0, async_tests
},
4340 {"async_binary", pre_nonblock_binary
, 0, async_tests
},
4341 {"user", 0, 0, user_tests
},
4342 {"generate", 0, 0, generate_tests
},
4343 {"generate_hsieh", pre_hsieh
, 0, generate_tests
},
4344 {"generate_ketama", pre_behavior_ketama
, 0, generate_tests
},
4345 {"generate_hsieh_consistent", enable_consistent
, 0, generate_tests
},
4346 {"generate_md5", pre_md5
, 0, generate_tests
},
4347 {"generate_murmur", pre_murmur
, 0, generate_tests
},
4348 {"generate_jenkins", pre_jenkins
, 0, generate_tests
},
4349 {"generate_nonblock", pre_nonblock
, 0, generate_tests
},
4350 {"consistent_not", 0, 0, consistent_tests
},
4351 {"consistent_ketama", pre_behavior_ketama
, 0, consistent_tests
},
4352 {"consistent_ketama_weighted", pre_behavior_ketama_weighted
, 0, consistent_weighted_tests
},
4353 {"test_hashes", 0, 0, hash_tests
},
4357 #define SERVERS_TO_CREATE 5
4359 /* Prototypes for functions we will pass to test framework */
4360 void *world_create(void);
4361 void world_destroy(void *p
);
4363 void *world_create(void)
4365 server_startup_st
*construct
;
4367 construct
= (server_startup_st
*)malloc(sizeof(server_startup_st
));
4368 memset(construct
, 0, sizeof(server_startup_st
));
4369 construct
->count
= SERVERS_TO_CREATE
;
4371 server_startup(construct
);
4377 void world_destroy(void *p
)
4379 server_startup_st
*construct
= (server_startup_st
*)p
;
4380 memcached_server_st
*servers
= (memcached_server_st
*)construct
->servers
;
4381 memcached_server_list_free(servers
);
4383 server_shutdown(construct
);
4387 void get_world(world_st
*world
)
4389 world
->collections
= collection
;
4390 world
->create
= world_create
;
4391 world
->destroy
= world_destroy
;