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
)
203 memcached_st
*memc_clone
;
204 memc_clone
= memcached_clone(NULL
, NULL
);
206 memcached_free(memc_clone
);
209 /* Can we init from null? */
211 memcached_st
*memc_clone
;
212 memc_clone
= memcached_clone(NULL
, memc
);
215 assert(memc_clone
->call_free
== memc
->call_free
);
216 assert(memc_clone
->call_malloc
== memc
->call_malloc
);
217 assert(memc_clone
->call_realloc
== memc
->call_realloc
);
218 assert(memc_clone
->call_calloc
== memc
->call_calloc
);
219 assert(memc_clone
->connect_timeout
== memc
->connect_timeout
);
220 assert(memc_clone
->delete_trigger
== memc
->delete_trigger
);
221 assert(memc_clone
->distribution
== memc
->distribution
);
222 assert(memc_clone
->flags
== memc
->flags
);
223 assert(memc_clone
->get_key_failure
== memc
->get_key_failure
);
224 assert(memc_clone
->hash
== memc
->hash
);
225 assert(memc_clone
->hash_continuum
== memc
->hash_continuum
);
226 assert(memc_clone
->io_bytes_watermark
== memc
->io_bytes_watermark
);
227 assert(memc_clone
->io_msg_watermark
== memc
->io_msg_watermark
);
228 assert(memc_clone
->io_key_prefetch
== memc
->io_key_prefetch
);
229 assert(memc_clone
->on_cleanup
== memc
->on_cleanup
);
230 assert(memc_clone
->on_clone
== memc
->on_clone
);
231 assert(memc_clone
->poll_timeout
== memc
->poll_timeout
);
232 assert(memc_clone
->rcv_timeout
== memc
->rcv_timeout
);
233 assert(memc_clone
->recv_size
== memc
->recv_size
);
234 assert(memc_clone
->retry_timeout
== memc
->retry_timeout
);
235 assert(memc_clone
->send_size
== memc
->send_size
);
236 assert(memc_clone
->server_failure_limit
== memc
->server_failure_limit
);
237 assert(memc_clone
->snd_timeout
== memc
->snd_timeout
);
238 assert(memc_clone
->user_data
== memc
->user_data
);
240 memcached_free(memc_clone
);
243 /* Can we init from struct? */
245 memcached_st declared_clone
;
246 memcached_st
*memc_clone
;
247 memset(&declared_clone
, 0 , sizeof(memcached_st
));
248 memc_clone
= memcached_clone(&declared_clone
, NULL
);
250 memcached_free(memc_clone
);
253 /* Can we init from struct? */
255 memcached_st declared_clone
;
256 memcached_st
*memc_clone
;
257 memset(&declared_clone
, 0 , sizeof(memcached_st
));
258 memc_clone
= memcached_clone(&declared_clone
, memc
);
260 memcached_free(memc_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
;
660 memcached_st
*memc_clone
;
662 size_t max_keylen
= 0xffff;
664 memc_clone
= memcached_clone(NULL
, memc
);
667 rc
= memcached_behavior_set(memc_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(memc_clone
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
) == 0)
673 string
= memcached_get(memc_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(memc_clone
, MEMCACHED_BEHAVIOR_VERIFY_KEY
, set
);
681 assert(rc
== MEMCACHED_SUCCESS
);
682 string
= memcached_get(memc_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(memc_clone
, MEMCACHED_BEHAVIOR_VERIFY_KEY
, set
);
693 assert(rc
== MEMCACHED_SUCCESS
);
695 rc
= memcached_mget(memc_clone
, keys
, key_lengths
, 3);
696 assert(rc
== MEMCACHED_BAD_KEY_PROVIDED
);
698 rc
= memcached_mget_by_key(memc_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(memc_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(memc_clone
, longkey
, max_keylen
,
715 &string_length
, &flags
, &rc
);
716 assert(rc
== MEMCACHED_NOTFOUND
);
717 assert(string_length
== 0);
720 string
= memcached_get(memc_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(memc_clone
, MEMCACHED_BEHAVIOR_VERIFY_KEY
, set
);
733 assert(rc
== MEMCACHED_SUCCESS
);
734 string
= memcached_get(memc_clone
, key
, 0,
735 &string_length
, &flags
, &rc
);
736 assert(rc
== MEMCACHED_BAD_KEY_PROVIDED
);
737 assert(string_length
== 0);
740 memcached_free(memc_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 memc_stat
;
1039 rc
= memcached_stat_servername(&memc_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 memc_stat
;
1370 memcached_return rc
;
1372 list
= memcached_stat_get_keys(memc
, &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
*memc_stat
;
1402 memc_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
, memc_stat
+x
, &rc
);
1411 assert(rc
== MEMCACHED_SUCCESS
);
1412 for (ptr
= list
; *ptr
; ptr
++);
1417 memcached_stat_free(NULL
, memc_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
*memc_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
*memc_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 memc_clone
= memcached_clone(NULL
, mine
);
1929 memcached_quit(mine
);
1930 memcached_quit(memc_clone
);
1933 memcached_free(mine
);
1934 memcached_free(memc_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
*memc_clone
;
2714 memc_clone
= memcached_clone(NULL
, memc
);
2717 memcached_server_add_with_weight(memc_clone
, "localhost", 6666, 0);
2721 size_t return_value_length
;
2725 for (x
= count
= 0; x
< global_count
; x
++)
2727 return_value
= memcached_get(memc_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(memc_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
*memc_clone
;
2909 memc_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(memc_clone
);
2915 if (memc_clone
->hosts
[0].major_version
>= 1 && memc_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(memc_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
*memc_clone
;
3033 memc_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(memc_clone
);
3039 if (memc_clone
->hosts
[0].major_version
>= 1 && memc_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(memc_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);
3345 assert(ret
== MEMCACHED_SUCCESS
|| ret
== MEMCACHED_BUFFERED
);
3349 ** NOTE: Don't ever do this in your code! this is not a supported use of the
3350 ** API and is _ONLY_ done this way to verify that the library works the
3351 ** way it is supposed to do!!!!
3354 for (uint32_t x
=0; x
< memc
->number_of_hosts
; ++x
)
3355 no_msg
+=memc
->hosts
[x
].cursor_active
;
3357 assert(no_msg
== 0);
3358 assert(memcached_flush_buffers(memc
) == MEMCACHED_SUCCESS
);
3361 ** Now validate that all items was set properly!
3363 for (int x
=0; x
< 100; ++x
)
3366 size_t len
= sprintf(key
, "%d", x
);
3369 char* value
=memcached_get(memc
, key
, strlen(key
),
3370 &length
, &flags
, &ret
);
3371 assert(ret
== MEMCACHED_SUCCESS
&& value
!= NULL
);
3374 case 0: /* FALLTHROUGH */
3375 case 1: /* FALLTHROUGH */
3377 assert(strncmp(value
, key
, len
) == 0);
3378 assert(len
== length
);
3381 assert(length
== len
* 2);
3384 assert(length
== len
* 3);
3394 /* Try setting an illegal cas value (should not return an error to
3395 * the caller (because we don't expect a return message from the server)
3397 char* keys
[]= {"0"};
3398 size_t lengths
[]= {1};
3401 memcached_result_st results_obj
;
3402 memcached_result_st
*results
;
3403 ret
= memcached_mget(memc
, keys
, lengths
, 1);
3404 assert(ret
== MEMCACHED_SUCCESS
);
3406 results
= memcached_result_create(memc
, &results_obj
);
3408 results
= memcached_fetch_result(memc
, &results_obj
, &ret
);
3410 assert(ret
== MEMCACHED_SUCCESS
);
3411 uint64_t cas
= memcached_result_cas(results
);
3412 memcached_result_free(&results_obj
);
3414 ret
= memcached_cas(memc
, keys
[0], lengths
[0], keys
[0], lengths
[0], 0, 0, cas
);
3415 assert(ret
== MEMCACHED_SUCCESS
);
3418 * The item will have a new cas value, so try to set it again with the old
3419 * value. This should fail!
3421 ret
= memcached_cas(memc
, keys
[0], lengths
[0], keys
[0], lengths
[0], 0, 0, cas
);
3422 assert(ret
== MEMCACHED_SUCCESS
);
3423 assert(memcached_flush_buffers(memc
) == MEMCACHED_SUCCESS
);
3424 char* value
=memcached_get(memc
, keys
[0], lengths
[0], &length
, &flags
, &ret
);
3425 assert(ret
== MEMCACHED_SUCCESS
&& value
!= NULL
);
3428 return TEST_SUCCESS
;
3431 static test_return
analyzer_test(memcached_st
*memc
)
3433 memcached_return rc
;
3434 memcached_stat_st
*memc_stat
;
3435 memcached_analysis_st
*report
;
3437 memc_stat
= memcached_stat(memc
, NULL
, &rc
);
3438 assert(rc
== MEMCACHED_SUCCESS
);
3441 report
= memcached_analyze(memc
, memc_stat
, &rc
);
3442 assert(rc
== MEMCACHED_SUCCESS
);
3446 memcached_stat_free(NULL
, memc_stat
);
3448 return TEST_SUCCESS
;
3451 /* Count the objects */
3452 static memcached_return
callback_dump_counter(memcached_st
*ptr
__attribute__((unused
)),
3453 const char *key
__attribute__((unused
)),
3454 size_t key_length
__attribute__((unused
)),
3457 uint32_t *counter
= (uint32_t *)context
;
3459 *counter
= *counter
+ 1;
3461 return MEMCACHED_SUCCESS
;
3464 static test_return
dump_test(memcached_st
*memc
)
3466 memcached_return rc
;
3467 uint32_t counter
= 0;
3468 memcached_dump_func callbacks
[1];
3469 test_return main_rc
;
3471 callbacks
[0]= &callback_dump_counter
;
3473 /* No support for Binary protocol yet */
3474 if (memc
->flags
& MEM_BINARY_PROTOCOL
)
3475 return TEST_SUCCESS
;
3477 main_rc
= set_test3(memc
);
3479 assert (main_rc
== TEST_SUCCESS
);
3481 rc
= memcached_dump(memc
, callbacks
, (void *)&counter
, 1);
3482 assert(rc
== MEMCACHED_SUCCESS
);
3484 /* We may have more then 32 if our previous flush has not completed */
3485 assert(counter
>= 32);
3487 return TEST_SUCCESS
;
3490 #ifdef HAVE_LIBMEMCACHEDUTIL
3491 static void* connection_release(void *arg
) {
3493 memcached_pool_st
* pool
;
3498 assert(memcached_pool_push(resource
->pool
, resource
->mmc
) == MEMCACHED_SUCCESS
);
3502 static test_return
connection_pool_test(memcached_st
*memc
)
3504 memcached_pool_st
* pool
= memcached_pool_create(memc
, 5, 10);
3505 assert(pool
!= NULL
);
3506 memcached_st
* mmc
[10];
3507 memcached_return rc
;
3509 for (int x
= 0; x
< 10; ++x
) {
3510 mmc
[x
]= memcached_pool_pop(pool
, false, &rc
);
3511 assert(mmc
[x
] != NULL
);
3512 assert(rc
== MEMCACHED_SUCCESS
);
3515 assert(memcached_pool_pop(pool
, false, &rc
) == NULL
);
3516 assert(rc
== MEMCACHED_SUCCESS
);
3520 memcached_pool_st
* pool
;
3522 } item
= { .pool
= pool
, .mmc
= mmc
[9] };
3523 pthread_create(&tid
, NULL
, connection_release
, &item
);
3524 mmc
[9]= memcached_pool_pop(pool
, true, &rc
);
3525 assert(rc
== MEMCACHED_SUCCESS
);
3526 pthread_join(tid
, NULL
);
3527 assert(mmc
[9] == item
.mmc
);
3528 const char *key
= "key";
3529 size_t keylen
= strlen(key
);
3531 // verify that I can do ops with all connections
3532 rc
= memcached_set(mmc
[0], key
, keylen
, "0", 1, 0, 0);
3533 assert(rc
== MEMCACHED_SUCCESS
);
3535 for (unsigned int x
= 0; x
< 10; ++x
) {
3536 uint64_t number_value
;
3537 rc
= memcached_increment(mmc
[x
], key
, keylen
, 1, &number_value
);
3538 assert(rc
== MEMCACHED_SUCCESS
);
3539 assert(number_value
== (x
+1));
3543 for (int x
= 0; x
< 10; ++x
)
3544 assert(memcached_pool_push(pool
, mmc
[x
]) == MEMCACHED_SUCCESS
);
3546 assert(memcached_pool_destroy(pool
) == memc
);
3547 return TEST_SUCCESS
;
3551 static void increment_request_id(uint16_t *id
)
3554 if ((*id
& UDP_REQUEST_ID_THREAD_MASK
) != 0)
3558 static uint16_t *get_udp_request_ids(memcached_st
*memc
)
3560 uint16_t *ids
= malloc(sizeof(uint16_t) * memc
->number_of_hosts
);
3561 assert(ids
!= NULL
);
3563 for (x
= 0; x
< memc
->number_of_hosts
; x
++)
3564 ids
[x
]= get_udp_datagram_request_id((struct udp_datagram_header_st
*) memc
->hosts
[x
].write_buffer
);
3569 static test_return
post_udp_op_check(memcached_st
*memc
, uint16_t *expected_req_ids
)
3572 memcached_server_st
*cur_server
= memc
->hosts
;
3573 uint16_t *cur_req_ids
= get_udp_request_ids(memc
);
3574 for (x
= 0; x
< memc
->number_of_hosts
; x
++)
3576 assert(cur_server
[x
].cursor_active
== 0);
3577 assert(cur_req_ids
[x
] == expected_req_ids
[x
]);
3579 free(expected_req_ids
);
3581 return TEST_SUCCESS
;
3585 ** There is a little bit of a hack here, instead of removing
3586 ** the servers, I just set num host to 0 and them add then new udp servers
3588 static memcached_return
init_udp(memcached_st
*memc
)
3590 memcached_version(memc
);
3591 /* For the time being, only support udp test for >= 1.2.6 && < 1.3 */
3592 if (memc
->hosts
[0].major_version
!= 1 || memc
->hosts
[0].minor_version
!= 2
3593 || memc
->hosts
[0].micro_version
< 6)
3594 return MEMCACHED_FAILURE
;
3596 uint32_t num_hosts
= memc
->number_of_hosts
;
3598 memcached_server_st servers
[num_hosts
];
3599 memcpy(servers
, memc
->hosts
, sizeof(memcached_server_st
) * num_hosts
);
3600 for (x
= 0; x
< num_hosts
; x
++)
3601 memcached_server_free(&memc
->hosts
[x
]);
3602 memc
->number_of_hosts
= 0;
3603 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_USE_UDP
, 1);
3604 for (x
= 0; x
< num_hosts
; x
++)
3606 assert(memcached_server_add_udp(memc
, servers
[x
].hostname
, servers
[x
].port
) == MEMCACHED_SUCCESS
);
3607 assert(memc
->hosts
[x
].write_buffer_offset
== UDP_DATAGRAM_HEADER_LENGTH
);
3609 return MEMCACHED_SUCCESS
;
3612 static memcached_return
binary_init_udp(memcached_st
*memc
)
3615 return init_udp(memc
);
3618 /* Make sure that I cant add a tcp server to a udp client */
3619 static test_return
add_tcp_server_udp_client_test(memcached_st
*memc
)
3621 memcached_server_st server
;
3622 memcached_server_clone(&server
, &memc
->hosts
[0]);
3623 assert(memcached_server_remove(&(memc
->hosts
[0])) == MEMCACHED_SUCCESS
);
3624 assert(memcached_server_add(memc
, server
.hostname
, server
.port
) == MEMCACHED_INVALID_HOST_PROTOCOL
);
3625 return TEST_SUCCESS
;
3628 /* Make sure that I cant add a udp server to a tcp client */
3629 static test_return
add_udp_server_tcp_client_test(memcached_st
*memc
)
3631 memcached_server_st server
;
3632 memcached_server_clone(&server
, &memc
->hosts
[0]);
3633 assert(memcached_server_remove(&(memc
->hosts
[0])) == MEMCACHED_SUCCESS
);
3635 memcached_st tcp_client
;
3636 memcached_create(&tcp_client
);
3637 assert(memcached_server_add_udp(&tcp_client
, server
.hostname
, server
.port
) == MEMCACHED_INVALID_HOST_PROTOCOL
);
3638 return TEST_SUCCESS
;
3641 static test_return
set_udp_behavior_test(memcached_st
*memc
)
3644 memcached_quit(memc
);
3645 memc
->number_of_hosts
= 0;
3646 run_distribution(memc
);
3647 assert(memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_USE_UDP
, 1) == MEMCACHED_SUCCESS
);
3648 assert(memc
->flags
& MEM_USE_UDP
);
3649 assert(memc
->flags
& MEM_NOREPLY
);;
3651 assert(memc
->number_of_hosts
== 0);
3653 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_USE_UDP
,0);
3654 assert(!(memc
->flags
& MEM_USE_UDP
));
3655 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NOREPLY
,0);
3656 assert(!(memc
->flags
& MEM_NOREPLY
));
3657 return TEST_SUCCESS
;
3660 static test_return
udp_set_test(memcached_st
*memc
)
3663 unsigned int num_iters
= 1025; //request id rolls over at 1024
3664 for (x
= 0; x
< num_iters
;x
++)
3666 memcached_return rc
;
3668 char *value
= "when we sanitize";
3669 uint16_t *expected_ids
= get_udp_request_ids(memc
);
3670 unsigned int server_key
= memcached_generate_hash(memc
,key
,strlen(key
));
3671 size_t init_offset
= memc
->hosts
[server_key
].write_buffer_offset
;
3672 rc
= memcached_set(memc
, key
, strlen(key
),
3673 value
, strlen(value
),
3674 (time_t)0, (uint32_t)0);
3675 assert(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
);
3676 /** NB, the check below assumes that if new write_ptr is less than
3677 * the original write_ptr that we have flushed. For large payloads, this
3678 * maybe an invalid assumption, but for the small payload we have it is OK
3680 if (rc
== MEMCACHED_SUCCESS
||
3681 memc
->hosts
[server_key
].write_buffer_offset
< init_offset
)
3682 increment_request_id(&expected_ids
[server_key
]);
3684 if (rc
== MEMCACHED_SUCCESS
)
3686 assert(memc
->hosts
[server_key
].write_buffer_offset
== UDP_DATAGRAM_HEADER_LENGTH
);
3690 assert(memc
->hosts
[server_key
].write_buffer_offset
!= UDP_DATAGRAM_HEADER_LENGTH
);
3691 assert(memc
->hosts
[server_key
].write_buffer_offset
<= MAX_UDP_DATAGRAM_LENGTH
);
3693 assert(post_udp_op_check(memc
,expected_ids
) == TEST_SUCCESS
);
3695 return TEST_SUCCESS
;
3698 static test_return
udp_buffered_set_test(memcached_st
*memc
)
3700 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_BUFFER_REQUESTS
, 1);
3701 return udp_set_test(memc
);
3704 static test_return
udp_set_too_big_test(memcached_st
*memc
)
3706 memcached_return rc
;
3708 char value
[MAX_UDP_DATAGRAM_LENGTH
];
3709 uint16_t *expected_ids
= get_udp_request_ids(memc
);
3710 rc
= memcached_set(memc
, key
, strlen(key
),
3711 value
, MAX_UDP_DATAGRAM_LENGTH
,
3712 (time_t)0, (uint32_t)0);
3713 assert(rc
== MEMCACHED_WRITE_FAILURE
);
3714 return post_udp_op_check(memc
,expected_ids
);
3717 static test_return
udp_delete_test(memcached_st
*memc
)
3720 unsigned int num_iters
= 1025; //request id rolls over at 1024
3721 for (x
= 0; x
< num_iters
;x
++)
3723 memcached_return rc
;
3725 uint16_t *expected_ids
=get_udp_request_ids(memc
);
3726 unsigned int server_key
= memcached_generate_hash(memc
, key
, strlen(key
));
3727 size_t init_offset
= memc
->hosts
[server_key
].write_buffer_offset
;
3728 rc
= memcached_delete(memc
, key
, strlen(key
), 0);
3729 assert(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
);
3730 if (rc
== MEMCACHED_SUCCESS
|| memc
->hosts
[server_key
].write_buffer_offset
< init_offset
)
3731 increment_request_id(&expected_ids
[server_key
]);
3732 if (rc
== MEMCACHED_SUCCESS
)
3733 assert(memc
->hosts
[server_key
].write_buffer_offset
== UDP_DATAGRAM_HEADER_LENGTH
);
3736 assert(memc
->hosts
[server_key
].write_buffer_offset
!= UDP_DATAGRAM_HEADER_LENGTH
);
3737 assert(memc
->hosts
[server_key
].write_buffer_offset
<= MAX_UDP_DATAGRAM_LENGTH
);
3739 assert(post_udp_op_check(memc
,expected_ids
) == TEST_SUCCESS
);
3741 return TEST_SUCCESS
;
3744 static test_return
udp_buffered_delete_test(memcached_st
*memc
)
3746 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_BUFFER_REQUESTS
, 1);
3747 return udp_delete_test(memc
);
3750 static test_return
udp_verbosity_test(memcached_st
*memc
)
3752 memcached_return rc
;
3753 uint16_t *expected_ids
= get_udp_request_ids(memc
);
3755 for (x
= 0; x
< memc
->number_of_hosts
;x
++)
3756 increment_request_id(&expected_ids
[x
]);
3758 rc
= memcached_verbosity(memc
,3);
3759 assert(rc
== MEMCACHED_SUCCESS
);
3760 return post_udp_op_check(memc
,expected_ids
);
3763 static test_return
udp_quit_test(memcached_st
*memc
)
3765 uint16_t *expected_ids
= get_udp_request_ids(memc
);
3766 memcached_quit(memc
);
3767 return post_udp_op_check(memc
, expected_ids
);
3770 static test_return
udp_flush_test(memcached_st
*memc
)
3772 memcached_return rc
;
3773 uint16_t *expected_ids
= get_udp_request_ids(memc
);
3775 for (x
= 0; x
< memc
->number_of_hosts
;x
++)
3776 increment_request_id(&expected_ids
[x
]);
3778 rc
= memcached_flush(memc
,0);
3779 assert(rc
== MEMCACHED_SUCCESS
);
3780 return post_udp_op_check(memc
,expected_ids
);
3783 static test_return
udp_incr_test(memcached_st
*memc
)
3785 memcached_return rc
;
3788 rc
= memcached_set(memc
, key
, strlen(key
),
3789 value
, strlen(value
),
3790 (time_t)0, (uint32_t)0);
3792 assert(rc
== MEMCACHED_SUCCESS
);
3793 uint16_t *expected_ids
= get_udp_request_ids(memc
);
3794 unsigned int server_key
= memcached_generate_hash(memc
, key
, strlen(key
));
3795 increment_request_id(&expected_ids
[server_key
]);
3797 rc
= memcached_increment(memc
, key
, strlen(key
), 1, &newvalue
);
3798 assert(rc
== MEMCACHED_SUCCESS
);
3799 return post_udp_op_check(memc
, expected_ids
);
3802 static test_return
udp_decr_test(memcached_st
*memc
)
3804 memcached_return rc
;
3807 rc
= memcached_set(memc
, key
, strlen(key
),
3808 value
, strlen(value
),
3809 (time_t)0, (uint32_t)0);
3811 assert(rc
== MEMCACHED_SUCCESS
);
3812 uint16_t *expected_ids
= get_udp_request_ids(memc
);
3813 unsigned int server_key
= memcached_generate_hash(memc
, key
, strlen(key
));
3814 increment_request_id(&expected_ids
[server_key
]);
3816 rc
= memcached_decrement(memc
, key
, strlen(key
), 1, &newvalue
);
3817 assert(rc
== MEMCACHED_SUCCESS
);
3818 return post_udp_op_check(memc
, expected_ids
);
3822 static test_return
udp_stat_test(memcached_st
*memc
)
3824 memcached_stat_st
* rv
= NULL
;
3825 memcached_return rc
;
3827 uint16_t *expected_ids
= get_udp_request_ids(memc
);
3828 rv
= memcached_stat(memc
, args
, &rc
);
3830 assert(rc
== MEMCACHED_NOT_SUPPORTED
);
3831 return post_udp_op_check(memc
, expected_ids
);
3834 static test_return
udp_version_test(memcached_st
*memc
)
3836 memcached_return rc
;
3837 uint16_t *expected_ids
= get_udp_request_ids(memc
);
3838 rc
= memcached_version(memc
);
3839 assert(rc
== MEMCACHED_NOT_SUPPORTED
);
3840 return post_udp_op_check(memc
, expected_ids
);
3843 static test_return
udp_get_test(memcached_st
*memc
)
3845 memcached_return rc
;
3848 uint16_t *expected_ids
= get_udp_request_ids(memc
);
3849 char *val
= memcached_get(memc
, key
, strlen(key
), &vlen
, (uint32_t)0, &rc
);
3850 assert(rc
== MEMCACHED_NOT_SUPPORTED
);
3851 assert(val
== NULL
);
3852 return post_udp_op_check(memc
, expected_ids
);
3855 static test_return
udp_mixed_io_test(memcached_st
*memc
)
3858 test_st mixed_io_ops
[] ={
3859 {"udp_set_test", 0, udp_set_test
},
3860 {"udp_set_too_big_test", 0, udp_set_too_big_test
},
3861 {"udp_delete_test", 0, udp_delete_test
},
3862 {"udp_verbosity_test", 0, udp_verbosity_test
},
3863 {"udp_quit_test", 0, udp_quit_test
},
3864 {"udp_flush_test", 0, udp_flush_test
},
3865 {"udp_incr_test", 0, udp_incr_test
},
3866 {"udp_decr_test", 0, udp_decr_test
},
3867 {"udp_version_test", 0, udp_version_test
}
3870 for (x
= 0; x
< 500; x
++)
3872 current_op
= mixed_io_ops
[random() % 9];
3873 assert(current_op
.function(memc
) == TEST_SUCCESS
);
3875 return TEST_SUCCESS
;
3878 static test_return
hsieh_avaibility_test (memcached_st
*memc
)
3880 memcached_return expected_rc
= MEMCACHED_FAILURE
;
3881 #ifdef HAVE_HSIEH_HASH
3882 expected_rc
= MEMCACHED_SUCCESS
;
3884 memcached_return rc
= memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_HASH
,
3885 (uint64_t)MEMCACHED_HASH_HSIEH
);
3886 assert(rc
== expected_rc
);
3887 return TEST_SUCCESS
;
3890 static char *list
[]=
3920 static test_return
md5_run (memcached_st
*memc
__attribute__((unused
)))
3924 uint32_t values
[]= { 3195025439, 2556848621, 3724893440, 3332385401, 245758794, 2550894432,
3925 121710495, 3053817768, 1250994555, 1862072655, 2631955953, 2951528551,
3926 1451250070, 2820856945, 2060845566, 3646985608, 2138080750, 217675895,
3927 2230934345, 1234361223, 3968582726, 2455685270, 1293568479, 199067604,
3931 for (ptr
= list
, x
= 0; *ptr
; ptr
++, x
++)
3935 hash_val
= memcached_generate_hash_value(*ptr
, strlen(*ptr
), MEMCACHED_HASH_MD5
);
3936 assert(values
[x
] == hash_val
);
3939 return TEST_SUCCESS
;
3942 static test_return
crc_run (memcached_st
*memc
__attribute__((unused
)))
3946 uint32_t values
[]= { 10542, 22009, 14526, 19510, 19432, 10199, 20634, 9369, 11511, 10362,
3947 7893, 31289, 11313, 9354, 7621, 30628, 15218, 25967, 2695, 9380,
3948 17300, 28156, 9192, 20484, 16925 };
3950 for (ptr
= list
, x
= 0; *ptr
; ptr
++, x
++)
3954 hash_val
= memcached_generate_hash_value(*ptr
, strlen(*ptr
), MEMCACHED_HASH_CRC
);
3955 assert(values
[x
] == hash_val
);
3958 return TEST_SUCCESS
;
3961 static test_return
fnv1_64_run (memcached_st
*memc
__attribute__((unused
)))
3965 uint32_t values
[]= { 473199127, 4148981457, 3971873300, 3257986707, 1722477987, 2991193800,
3966 4147007314, 3633179701, 1805162104, 3503289120, 3395702895, 3325073042,
3967 2345265314, 3340346032, 2722964135, 1173398992, 2815549194, 2562818319,
3968 224996066, 2680194749, 3035305390, 246890365, 2395624193, 4145193337,
3971 for (ptr
= list
, x
= 0; *ptr
; ptr
++, x
++)
3975 hash_val
= memcached_generate_hash_value(*ptr
, strlen(*ptr
), MEMCACHED_HASH_FNV1_64
);
3976 assert(values
[x
] == hash_val
);
3979 return TEST_SUCCESS
;
3982 static test_return
fnv1a_64_run (memcached_st
*memc
__attribute__((unused
)))
3986 uint32_t values
[]= { 1488911807, 2500855813, 1510099634, 1390325195, 3647689787, 3241528582,
3987 1669328060, 2604311949, 734810122, 1516407546, 560948863, 1767346780,
3988 561034892, 4156330026, 3716417003, 3475297030, 1518272172, 227211583,
3989 3938128828, 126112909, 3043416448, 3131561933, 1328739897, 2455664041,
3992 for (ptr
= list
, x
= 0; *ptr
; ptr
++, x
++)
3996 hash_val
= memcached_generate_hash_value(*ptr
, strlen(*ptr
), MEMCACHED_HASH_FNV1A_64
);
3997 assert(values
[x
] == hash_val
);
4000 return TEST_SUCCESS
;
4003 static test_return
fnv1_32_run (memcached_st
*memc
__attribute__((unused
)))
4007 uint32_t values
[]= { 67176023, 1190179409, 2043204404, 3221866419, 2567703427, 3787535528, 4147287986,
4008 3500475733, 344481048, 3865235296, 2181839183, 119581266, 510234242, 4248244304,
4009 1362796839, 103389328, 1449620010, 182962511, 3554262370, 3206747549, 1551306158,
4010 4127558461, 1889140833, 2774173721, 1180552018 };
4013 for (ptr
= list
, x
= 0; *ptr
; ptr
++, x
++)
4017 hash_val
= memcached_generate_hash_value(*ptr
, strlen(*ptr
), MEMCACHED_HASH_FNV1_32
);
4018 assert(values
[x
] == hash_val
);
4021 return TEST_SUCCESS
;
4024 static test_return
fnv1a_32_run (memcached_st
*memc
__attribute__((unused
)))
4028 uint32_t values
[]= { 280767167, 2421315013, 3072375666, 855001899, 459261019, 3521085446, 18738364,
4029 1625305005, 2162232970, 777243802, 3323728671, 132336572, 3654473228, 260679466,
4030 1169454059, 2698319462, 1062177260, 235516991, 2218399068, 405302637, 1128467232,
4031 3579622413, 2138539289, 96429129, 2877453236 };
4033 for (ptr
= list
, x
= 0; *ptr
; ptr
++, x
++)
4037 hash_val
= memcached_generate_hash_value(*ptr
, strlen(*ptr
), MEMCACHED_HASH_FNV1A_32
);
4038 assert(values
[x
] == hash_val
);
4041 return TEST_SUCCESS
;
4044 static test_return
hsieh_run (memcached_st
*memc
__attribute__((unused
)))
4048 #ifdef HAVE_HSIEH_HASH
4049 uint32_t values
[]= { 3738850110, 3636226060, 3821074029, 3489929160, 3485772682, 80540287,
4050 1805464076, 1895033657, 409795758, 979934958, 3634096985, 1284445480,
4051 2265380744, 707972988, 353823508, 1549198350, 1327930172, 9304163,
4052 4220749037, 2493964934, 2777873870, 2057831732, 1510213931, 2027828987,
4055 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 };
4058 for (ptr
= list
, x
= 0; *ptr
; ptr
++, x
++)
4062 hash_val
= memcached_generate_hash_value(*ptr
, strlen(*ptr
), MEMCACHED_HASH_HSIEH
);
4063 assert(values
[x
] == hash_val
);
4066 return TEST_SUCCESS
;
4069 static test_return
murmur_run (memcached_st
*memc
__attribute__((unused
)))
4073 uint32_t values
[]= { 473199127, 4148981457, 3971873300, 3257986707, 1722477987, 2991193800,
4074 4147007314, 3633179701, 1805162104, 3503289120, 3395702895, 3325073042,
4075 2345265314, 3340346032, 2722964135, 1173398992, 2815549194, 2562818319,
4076 224996066, 2680194749, 3035305390, 246890365, 2395624193, 4145193337,
4079 for (ptr
= list
, x
= 0; *ptr
; ptr
++, x
++)
4083 hash_val
= memcached_generate_hash_value(*ptr
, strlen(*ptr
), MEMCACHED_HASH_FNV1_64
);
4084 assert(values
[x
] == hash_val
);
4087 return TEST_SUCCESS
;
4090 static test_return
jenkins_run (memcached_st
*memc
__attribute__((unused
)))
4094 uint32_t values
[]= { 1442444624, 4253821186, 1885058256, 2120131735, 3261968576, 3515188778,
4095 4232909173, 4288625128, 1812047395, 3689182164, 2502979932, 1214050606,
4096 2415988847, 1494268927, 1025545760, 3920481083, 4153263658, 3824871822,
4097 3072759809, 798622255, 3065432577, 1453328165, 2691550971, 3408888387,
4101 for (ptr
= list
, x
= 0; *ptr
; ptr
++, x
++)
4105 hash_val
= memcached_generate_hash_value(*ptr
, strlen(*ptr
), MEMCACHED_HASH_JENKINS
);
4106 assert(values
[x
] == hash_val
);
4109 return TEST_SUCCESS
;
4112 test_st udp_setup_server_tests
[] ={
4113 {"set_udp_behavior_test", 0, set_udp_behavior_test
},
4114 {"add_tcp_server_udp_client_test", 0, add_tcp_server_udp_client_test
},
4115 {"add_udp_server_tcp_client_test", 0, add_udp_server_tcp_client_test
},
4119 test_st upd_io_tests
[] ={
4120 {"udp_set_test", 0, udp_set_test
},
4121 {"udp_buffered_set_test", 0, udp_buffered_set_test
},
4122 {"udp_set_too_big_test", 0, udp_set_too_big_test
},
4123 {"udp_delete_test", 0, udp_delete_test
},
4124 {"udp_buffered_delete_test", 0, udp_buffered_delete_test
},
4125 {"udp_verbosity_test", 0, udp_verbosity_test
},
4126 {"udp_quit_test", 0, udp_quit_test
},
4127 {"udp_flush_test", 0, udp_flush_test
},
4128 {"udp_incr_test", 0, udp_incr_test
},
4129 {"udp_decr_test", 0, udp_decr_test
},
4130 {"udp_stat_test", 0, udp_stat_test
},
4131 {"udp_version_test", 0, udp_version_test
},
4132 {"udp_get_test", 0, udp_get_test
},
4133 {"udp_mixed_io_test", 0, udp_mixed_io_test
},
4137 /* Clean the server before beginning testing */
4139 {"flush", 0, flush_test
},
4140 {"init", 0, init_test
},
4141 {"allocation", 0, allocation_test
},
4142 {"server_list_null_test", 0, server_list_null_test
},
4143 {"server_unsort", 0, server_unsort_test
},
4144 {"server_sort", 0, server_sort_test
},
4145 {"server_sort2", 0, server_sort2_test
},
4146 {"clone_test", 0, clone_test
},
4147 {"connection_test", 0, connection_test
},
4148 {"callback_test", 0, callback_test
},
4149 {"behavior_test", 0, behavior_test
},
4150 {"userdata_test", 0, userdata_test
},
4151 {"error", 0, error_test
},
4152 {"set", 0, set_test
},
4153 {"set2", 0, set_test2
},
4154 {"set3", 0, set_test3
},
4155 {"dump", 1, dump_test
},
4156 {"add", 1, add_test
},
4157 {"replace", 1, replace_test
},
4158 {"delete", 1, delete_test
},
4159 {"get", 1, get_test
},
4160 {"get2", 0, get_test2
},
4161 {"get3", 0, get_test3
},
4162 {"get4", 0, get_test4
},
4163 {"partial mget", 0, get_test5
},
4164 {"stats_servername", 0, stats_servername_test
},
4165 {"increment", 0, increment_test
},
4166 {"increment_with_initial", 1, increment_with_initial_test
},
4167 {"decrement", 0, decrement_test
},
4168 {"decrement_with_initial", 1, decrement_with_initial_test
},
4169 {"quit", 0, quit_test
},
4170 {"mget", 1, mget_test
},
4171 {"mget_result", 1, mget_result_test
},
4172 {"mget_result_alloc", 1, mget_result_alloc_test
},
4173 {"mget_result_function", 1, mget_result_function
},
4174 {"get_stats", 0, get_stats
},
4175 {"add_host_test", 0, add_host_test
},
4176 {"add_host_test_1", 0, add_host_test1
},
4177 {"get_stats_keys", 0, get_stats_keys
},
4178 {"behavior_test", 0, get_stats_keys
},
4179 {"callback_test", 0, get_stats_keys
},
4180 {"version_string_test", 0, version_string_test
},
4181 {"bad_key", 1, bad_key_test
},
4182 {"memcached_server_cursor", 1, memcached_server_cursor_test
},
4183 {"read_through", 1, read_through
},
4184 {"delete_through", 1, delete_through
},
4185 {"noreply", 1, noreply_test
},
4186 {"analyzer", 1, analyzer_test
},
4187 #ifdef HAVE_LIBMEMCACHEDUTIL
4188 {"connectionpool", 1, connection_pool_test
},
4193 test_st async_tests
[] ={
4194 {"add", 1, add_wrapper
},
4198 test_st string_tests
[] ={
4199 {"string static with null", 0, string_static_null
},
4200 {"string alloc with null", 0, string_alloc_null
},
4201 {"string alloc with 1K", 0, string_alloc_with_size
},
4202 {"string alloc with malloc failure", 0, string_alloc_with_size_toobig
},
4203 {"string append", 0, string_alloc_append
},
4204 {"string append failure (too big)", 0, string_alloc_append_toobig
},
4208 test_st result_tests
[] ={
4209 {"result static", 0, result_static
},
4210 {"result alloc", 0, result_alloc
},
4214 test_st version_1_2_3
[] ={
4215 {"append", 0, append_test
},
4216 {"prepend", 0, prepend_test
},
4217 {"cas", 0, cas_test
},
4218 {"cas2", 0, cas2_test
},
4219 {"append_binary", 0, append_binary_test
},
4223 test_st user_tests
[] ={
4224 {"user_supplied_bug1", 0, user_supplied_bug1
},
4225 {"user_supplied_bug2", 0, user_supplied_bug2
},
4226 {"user_supplied_bug3", 0, user_supplied_bug3
},
4227 {"user_supplied_bug4", 0, user_supplied_bug4
},
4228 {"user_supplied_bug5", 1, user_supplied_bug5
},
4229 {"user_supplied_bug6", 1, user_supplied_bug6
},
4230 {"user_supplied_bug7", 1, user_supplied_bug7
},
4231 {"user_supplied_bug8", 1, user_supplied_bug8
},
4232 {"user_supplied_bug9", 1, user_supplied_bug9
},
4233 {"user_supplied_bug10", 1, user_supplied_bug10
},
4234 {"user_supplied_bug11", 1, user_supplied_bug11
},
4235 {"user_supplied_bug12", 1, user_supplied_bug12
},
4236 {"user_supplied_bug13", 1, user_supplied_bug13
},
4237 {"user_supplied_bug14", 1, user_supplied_bug14
},
4238 {"user_supplied_bug15", 1, user_supplied_bug15
},
4239 {"user_supplied_bug16", 1, user_supplied_bug16
},
4242 ** It seems to be something weird with the character sets..
4243 ** value_fetch is unable to parse the value line (iscntrl "fails"), so I
4244 ** guess I need to find out how this is supposed to work.. Perhaps I need
4245 ** to run the test in a specific locale (I tried zh_CN.UTF-8 without success,
4246 ** so just disable the code for now...).
4248 {"user_supplied_bug17", 1, user_supplied_bug17
},
4250 {"user_supplied_bug18", 1, user_supplied_bug18
},
4251 {"user_supplied_bug19", 1, user_supplied_bug19
},
4252 {"user_supplied_bug20", 1, user_supplied_bug20
},
4256 test_st generate_tests
[] ={
4257 {"generate_pairs", 1, generate_pairs
},
4258 {"generate_data", 1, generate_data
},
4259 {"get_read", 0, get_read
},
4260 {"delete_generate", 0, delete_generate
},
4261 {"generate_buffer_data", 1, generate_buffer_data
},
4262 {"delete_buffer", 0, delete_buffer_generate
},
4263 {"generate_data", 1, generate_data
},
4264 {"mget_read", 0, mget_read
},
4265 {"mget_read_result", 0, mget_read_result
},
4266 {"mget_read_function", 0, mget_read_function
},
4267 {"cleanup", 1, cleanup_pairs
},
4268 {"generate_large_pairs", 1, generate_large_pairs
},
4269 {"generate_data", 1, generate_data
},
4270 {"generate_buffer_data", 1, generate_buffer_data
},
4271 {"cleanup", 1, cleanup_pairs
},
4275 test_st consistent_tests
[] ={
4276 {"generate_pairs", 1, generate_pairs
},
4277 {"generate_data", 1, generate_data
},
4278 {"get_read", 0, get_read_count
},
4279 {"cleanup", 1, cleanup_pairs
},
4283 test_st consistent_weighted_tests
[] ={
4284 {"generate_pairs", 1, generate_pairs
},
4285 {"generate_data", 1, generate_data_with_stats
},
4286 {"get_read", 0, get_read_count
},
4287 {"cleanup", 1, cleanup_pairs
},
4291 test_st hsieh_availability
[] ={
4292 {"hsieh_avaibility_test",0,hsieh_avaibility_test
},
4296 test_st ketama_auto_eject_hosts
[] ={
4297 {"auto_eject_hosts", 1, auto_eject_hosts
},
4301 test_st hash_tests
[] ={
4302 {"md5", 0, md5_run
},
4303 {"crc", 0, crc_run
},
4304 {"fnv1_64", 0, fnv1_64_run
},
4305 {"fnv1a_64", 0, fnv1a_64_run
},
4306 {"fnv1_32", 0, fnv1_32_run
},
4307 {"fnv1a_32", 0, fnv1a_32_run
},
4308 {"hsieh", 0, hsieh_run
},
4309 {"murmur", 0, murmur_run
},
4310 {"jenkis", 0, jenkins_run
},
4314 collection_st collection
[] ={
4315 {"hsieh_availability",0,0,hsieh_availability
},
4316 {"udp_setup", init_udp
, 0, udp_setup_server_tests
},
4317 {"udp_io", init_udp
, 0, upd_io_tests
},
4318 {"udp_binary_io", binary_init_udp
, 0, upd_io_tests
},
4319 {"block", 0, 0, tests
},
4320 {"binary", pre_binary
, 0, tests
},
4321 {"nonblock", pre_nonblock
, 0, tests
},
4322 {"nodelay", pre_nodelay
, 0, tests
},
4323 {"settimer", pre_settimer
, 0, tests
},
4324 {"md5", pre_md5
, 0, tests
},
4325 {"crc", pre_crc
, 0, tests
},
4326 {"hsieh", pre_hsieh
, 0, tests
},
4327 {"jenkins", pre_jenkins
, 0, tests
},
4328 {"fnv1_64", pre_hash_fnv1_64
, 0, tests
},
4329 {"fnv1a_64", pre_hash_fnv1a_64
, 0, tests
},
4330 {"fnv1_32", pre_hash_fnv1_32
, 0, tests
},
4331 {"fnv1a_32", pre_hash_fnv1a_32
, 0, tests
},
4332 {"ketama", pre_behavior_ketama
, 0, tests
},
4333 {"ketama_auto_eject_hosts", pre_behavior_ketama
, 0, ketama_auto_eject_hosts
},
4334 {"unix_socket", pre_unix_socket
, 0, tests
},
4335 {"unix_socket_nodelay", pre_nodelay
, 0, tests
},
4336 {"poll_timeout", poll_timeout
, 0, tests
},
4337 {"gets", enable_cas
, 0, tests
},
4338 {"consistent", enable_consistent
, 0, tests
},
4339 {"deprecated_memory_allocators", deprecated_set_memory_alloc
, 0, tests
},
4340 {"memory_allocators", set_memory_alloc
, 0, tests
},
4341 {"prefix", set_prefix
, 0, tests
},
4342 {"version_1_2_3", check_for_1_2_3
, 0, version_1_2_3
},
4343 {"string", 0, 0, string_tests
},
4344 {"result", 0, 0, result_tests
},
4345 {"async", pre_nonblock
, 0, async_tests
},
4346 {"async_binary", pre_nonblock_binary
, 0, async_tests
},
4347 {"user", 0, 0, user_tests
},
4348 {"generate", 0, 0, generate_tests
},
4349 {"generate_hsieh", pre_hsieh
, 0, generate_tests
},
4350 {"generate_ketama", pre_behavior_ketama
, 0, generate_tests
},
4351 {"generate_hsieh_consistent", enable_consistent
, 0, generate_tests
},
4352 {"generate_md5", pre_md5
, 0, generate_tests
},
4353 {"generate_murmur", pre_murmur
, 0, generate_tests
},
4354 {"generate_jenkins", pre_jenkins
, 0, generate_tests
},
4355 {"generate_nonblock", pre_nonblock
, 0, generate_tests
},
4356 {"consistent_not", 0, 0, consistent_tests
},
4357 {"consistent_ketama", pre_behavior_ketama
, 0, consistent_tests
},
4358 {"consistent_ketama_weighted", pre_behavior_ketama_weighted
, 0, consistent_weighted_tests
},
4359 {"test_hashes", 0, 0, hash_tests
},
4363 #define SERVERS_TO_CREATE 5
4365 /* Prototypes for functions we will pass to test framework */
4366 void *world_create(void);
4367 void world_destroy(void *p
);
4369 void *world_create(void)
4371 server_startup_st
*construct
;
4373 construct
= (server_startup_st
*)malloc(sizeof(server_startup_st
));
4374 memset(construct
, 0, sizeof(server_startup_st
));
4375 construct
->count
= SERVERS_TO_CREATE
;
4377 server_startup(construct
);
4383 void world_destroy(void *p
)
4385 server_startup_st
*construct
= (server_startup_st
*)p
;
4386 memcached_server_st
*servers
= (memcached_server_st
*)construct
->servers
;
4387 memcached_server_list_free(servers
);
4389 server_shutdown(construct
);
4393 void get_world(world_st
*world
)
4395 world
->collections
= collection
;
4396 world
->create
= world_create
;
4397 world
->destroy
= world_destroy
;