2 Sample test application.
5 #include "libmemcached/common.h"
12 #include <sys/types.h>
17 #include "clients/generator.h"
18 #include "clients/execute.h"
21 #define INT64_MAX LONG_MAX
24 #define INT32_MAX INT_MAX
30 #ifdef HAVE_LIBMEMCACHEDUTIL
32 #include "libmemcached/memcached_util.h"
35 #define GLOBAL_COUNT 10000
36 #define GLOBAL2_COUNT 100
37 #define SERVERS_TO_CREATE 5
38 static uint32_t global_count
;
40 static pairs_st
*global_pairs
;
41 static char *global_keys
[GLOBAL_COUNT
];
42 static size_t global_keys_length
[GLOBAL_COUNT
];
44 static test_return
init_test(memcached_st
*not_used
__attribute__((unused
)))
48 (void)memcached_create(&memc
);
49 memcached_free(&memc
);
54 static test_return
server_list_null_test(memcached_st
*ptr
__attribute__((unused
)))
56 memcached_server_st
*server_list
;
59 server_list
= memcached_server_list_append_with_weight(NULL
, NULL
, 0, 0, NULL
);
60 assert(server_list
== NULL
);
62 server_list
= memcached_server_list_append_with_weight(NULL
, "localhost", 0, 0, NULL
);
63 assert(server_list
== NULL
);
65 server_list
= memcached_server_list_append_with_weight(NULL
, NULL
, 0, 0, &rc
);
66 assert(server_list
== NULL
);
71 #define TEST_PORT_COUNT 7
72 uint32_t test_ports
[TEST_PORT_COUNT
];
74 static memcached_return
server_display_function(memcached_st
*ptr
__attribute__((unused
)), memcached_server_st
*server
, void *context
)
77 uint32_t bigger
= *((uint32_t *)(context
));
78 assert(bigger
<= server
->port
);
79 *((uint32_t *)(context
))= server
->port
;
81 return MEMCACHED_SUCCESS
;
84 static test_return
server_sort_test(memcached_st
*ptr
__attribute__((unused
)))
87 uint32_t bigger
= 0; /* Prime the value for the assert in server_display_function */
89 memcached_server_function callbacks
[1];
90 memcached_st
*local_memc
;
92 local_memc
= memcached_create(NULL
);
94 memcached_behavior_set(local_memc
, MEMCACHED_BEHAVIOR_SORT_HOSTS
, 1);
96 for (x
= 0; x
< TEST_PORT_COUNT
; x
++)
98 test_ports
[x
]= (uint32_t)random() % 64000;
99 rc
= memcached_server_add_with_weight(local_memc
, "localhost", test_ports
[x
], 0);
100 assert(local_memc
->number_of_hosts
== x
+ 1);
101 assert(local_memc
->hosts
[0].count
== x
+1);
102 assert(rc
== MEMCACHED_SUCCESS
);
105 callbacks
[0]= server_display_function
;
106 memcached_server_cursor(local_memc
, callbacks
, (void *)&bigger
, 1);
109 memcached_free(local_memc
);
114 static test_return
server_sort2_test(memcached_st
*ptr
__attribute__((unused
)))
116 uint32_t bigger
= 0; /* Prime the value for the assert in server_display_function */
118 memcached_server_function callbacks
[1];
119 memcached_st
*local_memc
;
121 local_memc
= memcached_create(NULL
);
123 rc
= memcached_behavior_set(local_memc
, MEMCACHED_BEHAVIOR_SORT_HOSTS
, 1);
124 assert(rc
== MEMCACHED_SUCCESS
);
126 rc
= memcached_server_add_with_weight(local_memc
, "MEMCACHED_BEHAVIOR_SORT_HOSTS", 43043, 0);
127 assert(rc
== MEMCACHED_SUCCESS
);
128 assert(local_memc
->hosts
[0].port
== 43043);
130 rc
= memcached_server_add_with_weight(local_memc
, "MEMCACHED_BEHAVIOR_SORT_HOSTS", 43042, 0);
131 assert(rc
== MEMCACHED_SUCCESS
);
132 assert(local_memc
->hosts
[0].port
== 43042);
133 assert(local_memc
->hosts
[1].port
== 43043);
135 callbacks
[0]= server_display_function
;
136 memcached_server_cursor(local_memc
, callbacks
, (void *)&bigger
, 1);
139 memcached_free(local_memc
);
144 static memcached_return
server_display_unsort_function(memcached_st
*ptr
__attribute__((unused
)), memcached_server_st
*server
, void *context
)
147 uint32_t x
= *((uint32_t *)(context
));
149 assert(test_ports
[x
] == server
->port
);
150 *((uint32_t *)(context
))= ++x
;
152 return MEMCACHED_SUCCESS
;
155 static test_return
server_unsort_test(memcached_st
*ptr
__attribute__((unused
)))
158 uint32_t counter
= 0; /* Prime the value for the assert in server_display_function */
159 uint32_t bigger
= 0; /* Prime the value for the assert in server_display_function */
161 memcached_server_function callbacks
[1];
162 memcached_st
*local_memc
;
164 local_memc
= memcached_create(NULL
);
167 for (x
= 0; x
< TEST_PORT_COUNT
; x
++)
169 test_ports
[x
]= (uint32_t)(random() % 64000);
170 rc
= memcached_server_add_with_weight(local_memc
, "localhost", test_ports
[x
], 0);
171 assert(local_memc
->number_of_hosts
== x
+1);
172 assert(local_memc
->hosts
[0].count
== x
+1);
173 assert(rc
== MEMCACHED_SUCCESS
);
176 callbacks
[0]= server_display_unsort_function
;
177 memcached_server_cursor(local_memc
, callbacks
, (void *)&counter
, 1);
179 /* Now we sort old data! */
180 memcached_behavior_set(local_memc
, MEMCACHED_BEHAVIOR_SORT_HOSTS
, 1);
181 callbacks
[0]= server_display_function
;
182 memcached_server_cursor(local_memc
, callbacks
, (void *)&bigger
, 1);
185 memcached_free(local_memc
);
190 static test_return
allocation_test(memcached_st
*not_used
__attribute__((unused
)))
193 memc
= memcached_create(NULL
);
195 memcached_free(memc
);
200 static test_return
clone_test(memcached_st
*memc
)
204 memcached_st
*memc_clone
;
205 memc_clone
= memcached_clone(NULL
, NULL
);
207 memcached_free(memc_clone
);
210 /* Can we init from null? */
212 memcached_st
*memc_clone
;
213 memc_clone
= memcached_clone(NULL
, memc
);
216 assert(memc_clone
->call_free
== memc
->call_free
);
217 assert(memc_clone
->call_malloc
== memc
->call_malloc
);
218 assert(memc_clone
->call_realloc
== memc
->call_realloc
);
219 assert(memc_clone
->call_calloc
== memc
->call_calloc
);
220 assert(memc_clone
->connect_timeout
== memc
->connect_timeout
);
221 assert(memc_clone
->delete_trigger
== memc
->delete_trigger
);
222 assert(memc_clone
->distribution
== memc
->distribution
);
223 assert(memc_clone
->flags
== memc
->flags
);
224 assert(memc_clone
->get_key_failure
== memc
->get_key_failure
);
225 assert(memc_clone
->hash
== memc
->hash
);
226 assert(memc_clone
->hash_continuum
== memc
->hash_continuum
);
227 assert(memc_clone
->io_bytes_watermark
== memc
->io_bytes_watermark
);
228 assert(memc_clone
->io_msg_watermark
== memc
->io_msg_watermark
);
229 assert(memc_clone
->io_key_prefetch
== memc
->io_key_prefetch
);
230 assert(memc_clone
->on_cleanup
== memc
->on_cleanup
);
231 assert(memc_clone
->on_clone
== memc
->on_clone
);
232 assert(memc_clone
->poll_timeout
== memc
->poll_timeout
);
233 assert(memc_clone
->rcv_timeout
== memc
->rcv_timeout
);
234 assert(memc_clone
->recv_size
== memc
->recv_size
);
235 assert(memc_clone
->retry_timeout
== memc
->retry_timeout
);
236 assert(memc_clone
->send_size
== memc
->send_size
);
237 assert(memc_clone
->server_failure_limit
== memc
->server_failure_limit
);
238 assert(memc_clone
->snd_timeout
== memc
->snd_timeout
);
239 assert(memc_clone
->user_data
== memc
->user_data
);
241 memcached_free(memc_clone
);
244 /* Can we init from struct? */
246 memcached_st declared_clone
;
247 memcached_st
*memc_clone
;
248 memset(&declared_clone
, 0 , sizeof(memcached_st
));
249 memc_clone
= memcached_clone(&declared_clone
, NULL
);
251 memcached_free(memc_clone
);
254 /* Can we init from struct? */
256 memcached_st declared_clone
;
257 memcached_st
*memc_clone
;
258 memset(&declared_clone
, 0 , sizeof(memcached_st
));
259 memc_clone
= memcached_clone(&declared_clone
, memc
);
261 memcached_free(memc_clone
);
267 static test_return
userdata_test(memcached_st
*memc
)
270 assert(memcached_set_user_data(memc
, foo
) == NULL
);
271 assert(memcached_get_user_data(memc
) == foo
);
272 assert(memcached_set_user_data(memc
, NULL
) == foo
);
277 static test_return
connection_test(memcached_st
*memc
)
281 rc
= memcached_server_add_with_weight(memc
, "localhost", 0, 0);
282 assert(rc
== MEMCACHED_SUCCESS
);
287 static test_return
error_test(memcached_st
*memc
)
291 for (rc
= MEMCACHED_SUCCESS
; rc
< MEMCACHED_MAXIMUM_RETURN
; rc
++)
293 printf("Error %d -> %s\n", rc
, memcached_strerror(memc
, rc
));
299 static test_return
set_test(memcached_st
*memc
)
303 char *value
= "when we sanitize";
305 rc
= memcached_set(memc
, key
, strlen(key
),
306 value
, strlen(value
),
307 (time_t)0, (uint32_t)0);
308 assert(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
);
313 static test_return
append_test(memcached_st
*memc
)
321 rc
= memcached_flush(memc
, 0);
322 assert(rc
== MEMCACHED_SUCCESS
);
324 rc
= memcached_set(memc
, key
, strlen(key
),
325 value
, strlen(value
),
326 (time_t)0, (uint32_t)0);
327 assert(rc
== MEMCACHED_SUCCESS
);
329 rc
= memcached_append(memc
, key
, strlen(key
),
330 " the", strlen(" the"),
331 (time_t)0, (uint32_t)0);
332 assert(rc
== MEMCACHED_SUCCESS
);
334 rc
= memcached_append(memc
, key
, strlen(key
),
335 " people", strlen(" people"),
336 (time_t)0, (uint32_t)0);
337 assert(rc
== MEMCACHED_SUCCESS
);
339 value
= memcached_get(memc
, key
, strlen(key
),
340 &value_length
, &flags
, &rc
);
341 assert(!memcmp(value
, "we the people", strlen("we the people")));
342 assert(strlen("we the people") == value_length
);
343 assert(rc
== MEMCACHED_SUCCESS
);
349 static test_return
append_binary_test(memcached_st
*memc
)
352 char *key
= "numbers";
353 unsigned int *store_ptr
;
354 unsigned int store_list
[] = { 23, 56, 499, 98, 32847, 0 };
360 rc
= memcached_flush(memc
, 0);
361 assert(rc
== MEMCACHED_SUCCESS
);
363 rc
= memcached_set(memc
,
366 (time_t)0, (uint32_t)0);
367 assert(rc
== MEMCACHED_SUCCESS
);
369 for (x
= 0; store_list
[x
] ; x
++)
371 rc
= memcached_append(memc
,
373 (char *)&store_list
[x
], sizeof(unsigned int),
374 (time_t)0, (uint32_t)0);
375 assert(rc
== MEMCACHED_SUCCESS
);
378 value
= memcached_get(memc
, key
, strlen(key
),
379 &value_length
, &flags
, &rc
);
380 assert((value_length
== (sizeof(unsigned int) * x
)));
381 assert(rc
== MEMCACHED_SUCCESS
);
383 store_ptr
= (unsigned int *)value
;
385 while ((size_t)store_ptr
< (size_t)(value
+ value_length
))
387 assert(*store_ptr
== store_list
[x
++]);
395 static test_return
cas2_test(memcached_st
*memc
)
398 char *keys
[]= {"fudge", "son", "food"};
399 size_t key_length
[]= {5, 3, 4};
400 char *value
= "we the people";
401 size_t value_length
= strlen("we the people");
403 memcached_result_st results_obj
;
404 memcached_result_st
*results
;
407 rc
= memcached_flush(memc
, 0);
408 assert(rc
== MEMCACHED_SUCCESS
);
410 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_SUPPORT_CAS
, set
);
412 for (x
= 0; x
< 3; x
++)
414 rc
= memcached_set(memc
, keys
[x
], key_length
[x
],
415 keys
[x
], key_length
[x
],
416 (time_t)50, (uint32_t)9);
417 assert(rc
== MEMCACHED_SUCCESS
);
420 rc
= memcached_mget(memc
, keys
, key_length
, 3);
422 results
= memcached_result_create(memc
, &results_obj
);
424 results
= memcached_fetch_result(memc
, &results_obj
, &rc
);
426 assert(results
->cas
);
427 assert(rc
== MEMCACHED_SUCCESS
);
428 assert(memcached_result_cas(results
));
430 assert(!memcmp(value
, "we the people", strlen("we the people")));
431 assert(strlen("we the people") == value_length
);
432 assert(rc
== MEMCACHED_SUCCESS
);
434 memcached_result_free(&results_obj
);
439 static test_return
cas_test(memcached_st
*memc
)
442 const char *key
= "fun";
443 size_t key_length
= strlen(key
);
444 const char *value
= "we the people";
445 char* keys
[2] = { (char*)key
, NULL
};
446 size_t keylengths
[2] = { strlen(key
), 0 };
447 size_t value_length
= strlen(value
);
448 const char *value2
= "change the value";
449 size_t value2_length
= strlen(value2
);
451 memcached_result_st results_obj
;
452 memcached_result_st
*results
;
455 rc
= memcached_flush(memc
, 0);
456 assert(rc
== MEMCACHED_SUCCESS
);
458 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_SUPPORT_CAS
, set
);
460 rc
= memcached_set(memc
, key
, strlen(key
),
461 value
, strlen(value
),
462 (time_t)0, (uint32_t)0);
463 assert(rc
== MEMCACHED_SUCCESS
);
465 rc
= memcached_mget(memc
, keys
, keylengths
, 1);
467 results
= memcached_result_create(memc
, &results_obj
);
469 results
= memcached_fetch_result(memc
, &results_obj
, &rc
);
471 assert(rc
== MEMCACHED_SUCCESS
);
472 assert(memcached_result_cas(results
));
473 assert(!memcmp(value
, memcached_result_value(results
), value_length
));
474 assert(strlen(memcached_result_value(results
)) == value_length
);
475 assert(rc
== MEMCACHED_SUCCESS
);
476 uint64_t cas
= memcached_result_cas(results
);
479 results
= memcached_fetch_result(memc
, &results_obj
, &rc
);
480 assert(rc
== MEMCACHED_END
);
481 assert(results
== NULL
);
484 rc
= memcached_cas(memc
, key
, key_length
, value2
, value2_length
, 0, 0, cas
);
485 assert(rc
== MEMCACHED_SUCCESS
);
488 * The item will have a new cas value, so try to set it again with the old
489 * value. This should fail!
491 rc
= memcached_cas(memc
, key
, key_length
, value2
, value2_length
, 0, 0, cas
);
492 assert(rc
== MEMCACHED_DATA_EXISTS
);
494 memcached_result_free(&results_obj
);
499 static test_return
prepend_test(memcached_st
*memc
)
503 char *value
= "people";
507 rc
= memcached_flush(memc
, 0);
508 assert(rc
== MEMCACHED_SUCCESS
);
510 rc
= memcached_set(memc
, key
, strlen(key
),
511 value
, strlen(value
),
512 (time_t)0, (uint32_t)0);
513 assert(rc
== MEMCACHED_SUCCESS
);
515 rc
= memcached_prepend(memc
, key
, strlen(key
),
516 "the ", strlen("the "),
517 (time_t)0, (uint32_t)0);
518 assert(rc
== MEMCACHED_SUCCESS
);
520 rc
= memcached_prepend(memc
, key
, strlen(key
),
521 "we ", strlen("we "),
522 (time_t)0, (uint32_t)0);
523 assert(rc
== MEMCACHED_SUCCESS
);
525 value
= memcached_get(memc
, key
, strlen(key
),
526 &value_length
, &flags
, &rc
);
527 assert(!memcmp(value
, "we the people", strlen("we the people")));
528 assert(strlen("we the people") == value_length
);
529 assert(rc
== MEMCACHED_SUCCESS
);
536 Set the value, then quit to make sure it is flushed.
537 Come back in and test that add fails.
539 static test_return
add_test(memcached_st
*memc
)
543 char *value
= "when we sanitize";
544 unsigned long long setting_value
;
546 setting_value
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_NO_BLOCK
);
548 rc
= memcached_set(memc
, key
, strlen(key
),
549 value
, strlen(value
),
550 (time_t)0, (uint32_t)0);
551 assert(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
);
552 memcached_quit(memc
);
553 rc
= memcached_add(memc
, key
, strlen(key
),
554 value
, strlen(value
),
555 (time_t)0, (uint32_t)0);
557 /* Too many broken OS'es have broken loopback in async, so we can't be sure of the result */
559 assert(rc
== MEMCACHED_NOTSTORED
|| rc
== MEMCACHED_STORED
);
561 assert(rc
== MEMCACHED_NOTSTORED
|| rc
== MEMCACHED_DATA_EXISTS
);
567 ** There was a problem of leaking filedescriptors in the initial release
568 ** of MacOSX 10.5. This test case triggers the problem. On some Solaris
569 ** systems it seems that the kernel is slow on reclaiming the resources
570 ** because the connects starts to time out (the test doesn't do much
571 ** anyway, so just loop 10 iterations)
573 static test_return
add_wrapper(memcached_st
*memc
)
576 unsigned int max
= 10000;
581 for (x
= 0; x
< max
; x
++)
587 static test_return
replace_test(memcached_st
*memc
)
591 char *value
= "when we sanitize";
592 char *original
= "first we insert some data";
594 rc
= memcached_set(memc
, key
, strlen(key
),
595 original
, strlen(original
),
596 (time_t)0, (uint32_t)0);
597 assert(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
);
599 rc
= memcached_replace(memc
, key
, strlen(key
),
600 value
, strlen(value
),
601 (time_t)0, (uint32_t)0);
602 assert(rc
== MEMCACHED_SUCCESS
);
607 static test_return
delete_test(memcached_st
*memc
)
611 char *value
= "when we sanitize";
613 rc
= memcached_set(memc
, key
, strlen(key
),
614 value
, strlen(value
),
615 (time_t)0, (uint32_t)0);
616 assert(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
);
618 rc
= memcached_delete(memc
, key
, strlen(key
), (time_t)0);
619 assert(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
);
624 static test_return
flush_test(memcached_st
*memc
)
628 rc
= memcached_flush(memc
, 0);
629 assert(rc
== MEMCACHED_SUCCESS
);
634 static memcached_return
server_function(memcached_st
*ptr
__attribute__((unused
)),
635 memcached_server_st
*server
__attribute__((unused
)),
636 void *context
__attribute__((unused
)))
640 return MEMCACHED_SUCCESS
;
643 static test_return
memcached_server_cursor_test(memcached_st
*memc
)
645 char *context
= "foo bad";
646 memcached_server_function callbacks
[1];
648 callbacks
[0]= server_function
;
649 memcached_server_cursor(memc
, callbacks
, context
, 1);
654 static test_return
bad_key_test(memcached_st
*memc
)
657 char *key
= "foo bad";
659 size_t string_length
;
661 memcached_st
*memc_clone
;
663 size_t max_keylen
= 0xffff;
665 memc_clone
= memcached_clone(NULL
, memc
);
668 rc
= memcached_behavior_set(memc_clone
, MEMCACHED_BEHAVIOR_VERIFY_KEY
, set
);
669 assert(rc
== MEMCACHED_SUCCESS
);
671 /* All keys are valid in the binary protocol (except for length) */
672 if (memcached_behavior_get(memc_clone
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
) == 0)
674 string
= memcached_get(memc_clone
, key
, strlen(key
),
675 &string_length
, &flags
, &rc
);
676 assert(rc
== MEMCACHED_BAD_KEY_PROVIDED
);
677 assert(string_length
== 0);
681 rc
= memcached_behavior_set(memc_clone
, MEMCACHED_BEHAVIOR_VERIFY_KEY
, set
);
682 assert(rc
== MEMCACHED_SUCCESS
);
683 string
= memcached_get(memc_clone
, key
, strlen(key
),
684 &string_length
, &flags
, &rc
);
685 assert(rc
== MEMCACHED_NOTFOUND
);
686 assert(string_length
== 0);
689 /* Test multi key for bad keys */
690 char *keys
[] = { "GoodKey", "Bad Key", "NotMine" };
691 size_t key_lengths
[] = { 7, 7, 7 };
693 rc
= memcached_behavior_set(memc_clone
, MEMCACHED_BEHAVIOR_VERIFY_KEY
, set
);
694 assert(rc
== MEMCACHED_SUCCESS
);
696 rc
= memcached_mget(memc_clone
, keys
, key_lengths
, 3);
697 assert(rc
== MEMCACHED_BAD_KEY_PROVIDED
);
699 rc
= memcached_mget_by_key(memc_clone
, "foo daddy", 9, keys
, key_lengths
, 1);
700 assert(rc
== MEMCACHED_BAD_KEY_PROVIDED
);
704 /* The following test should be moved to the end of this function when the
705 memcached server is updated to allow max size length of the keys in the
708 rc
= memcached_callback_set(memc_clone
, MEMCACHED_CALLBACK_PREFIX_KEY
, NULL
);
709 assert(rc
== MEMCACHED_SUCCESS
);
711 char *longkey
= malloc(max_keylen
+ 1);
714 memset(longkey
, 'a', max_keylen
+ 1);
715 string
= memcached_get(memc_clone
, longkey
, max_keylen
,
716 &string_length
, &flags
, &rc
);
717 assert(rc
== MEMCACHED_NOTFOUND
);
718 assert(string_length
== 0);
721 string
= memcached_get(memc_clone
, longkey
, max_keylen
+ 1,
722 &string_length
, &flags
, &rc
);
723 assert(rc
== MEMCACHED_BAD_KEY_PROVIDED
);
724 assert(string_length
== 0);
731 /* Make sure zero length keys are marked as bad */
733 rc
= memcached_behavior_set(memc_clone
, MEMCACHED_BEHAVIOR_VERIFY_KEY
, set
);
734 assert(rc
== MEMCACHED_SUCCESS
);
735 string
= memcached_get(memc_clone
, key
, 0,
736 &string_length
, &flags
, &rc
);
737 assert(rc
== MEMCACHED_BAD_KEY_PROVIDED
);
738 assert(string_length
== 0);
741 memcached_free(memc_clone
);
746 #define READ_THROUGH_VALUE "set for me"
747 static memcached_return
read_through_trigger(memcached_st
*memc
__attribute__((unused
)),
748 char *key
__attribute__((unused
)),
749 size_t key_length
__attribute__((unused
)),
750 memcached_result_st
*result
)
753 return memcached_result_set_value(result
, READ_THROUGH_VALUE
, strlen(READ_THROUGH_VALUE
));
756 static test_return
read_through(memcached_st
*memc
)
761 size_t string_length
;
763 memcached_trigger_key cb
= (memcached_trigger_key
)read_through_trigger
;
765 string
= memcached_get(memc
, key
, strlen(key
),
766 &string_length
, &flags
, &rc
);
768 assert(rc
== MEMCACHED_NOTFOUND
);
769 assert(string_length
== 0);
772 rc
= memcached_callback_set(memc
, MEMCACHED_CALLBACK_GET_FAILURE
,
774 assert(rc
== MEMCACHED_SUCCESS
);
776 string
= memcached_get(memc
, key
, strlen(key
),
777 &string_length
, &flags
, &rc
);
779 assert(rc
== MEMCACHED_SUCCESS
);
780 assert(string_length
== strlen(READ_THROUGH_VALUE
));
781 assert(!strcmp(READ_THROUGH_VALUE
, string
));
784 string
= memcached_get(memc
, key
, strlen(key
),
785 &string_length
, &flags
, &rc
);
787 assert(rc
== MEMCACHED_SUCCESS
);
788 assert(string_length
== strlen(READ_THROUGH_VALUE
));
789 assert(!strcmp(READ_THROUGH_VALUE
, string
));
795 static memcached_return
delete_trigger(memcached_st
*ptr
__attribute__((unused
)),
797 size_t key_length
__attribute__((unused
)))
801 return MEMCACHED_SUCCESS
;
804 static test_return
delete_through(memcached_st
*memc
)
806 memcached_trigger_delete_key callback
;
809 callback
= (memcached_trigger_delete_key
)delete_trigger
;
811 rc
= memcached_callback_set(memc
, MEMCACHED_CALLBACK_DELETE_TRIGGER
, *(void**)&callback
);
812 assert(rc
== MEMCACHED_SUCCESS
);
817 static test_return
get_test(memcached_st
*memc
)
822 size_t string_length
;
825 rc
= memcached_delete(memc
, key
, strlen(key
), (time_t)0);
826 assert(rc
== MEMCACHED_BUFFERED
|| rc
== MEMCACHED_NOTFOUND
);
828 string
= memcached_get(memc
, key
, strlen(key
),
829 &string_length
, &flags
, &rc
);
831 assert(rc
== MEMCACHED_NOTFOUND
);
832 assert(string_length
== 0);
838 static test_return
get_test2(memcached_st
*memc
)
842 char *value
= "when we sanitize";
844 size_t string_length
;
847 rc
= memcached_set(memc
, key
, strlen(key
),
848 value
, strlen(value
),
849 (time_t)0, (uint32_t)0);
850 assert(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
);
852 string
= memcached_get(memc
, key
, strlen(key
),
853 &string_length
, &flags
, &rc
);
856 assert(rc
== MEMCACHED_SUCCESS
);
857 assert(string_length
== strlen(value
));
858 assert(!memcmp(string
, value
, string_length
));
865 static test_return
set_test2(memcached_st
*memc
)
869 char *value
= "train in the brain";
870 size_t value_length
= strlen(value
);
873 for (x
= 0; x
< 10; x
++)
875 rc
= memcached_set(memc
, key
, strlen(key
),
877 (time_t)0, (uint32_t)0);
878 assert(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
);
884 static test_return
set_test3(memcached_st
*memc
)
888 size_t value_length
= 8191;
891 value
= (char*)malloc(value_length
);
894 for (x
= 0; x
< value_length
; x
++)
895 value
[x
] = (char) (x
% 127);
897 /* The dump test relies on there being at least 32 items in memcached */
898 for (x
= 0; x
< 32; x
++)
902 sprintf(key
, "foo%u", x
);
904 rc
= memcached_set(memc
, key
, strlen(key
),
906 (time_t)0, (uint32_t)0);
907 assert(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
);
915 static test_return
get_test3(memcached_st
*memc
)
920 size_t value_length
= 8191;
922 size_t string_length
;
926 value
= (char*)malloc(value_length
);
929 for (x
= 0; x
< value_length
; x
++)
930 value
[x
] = (char) (x
% 127);
932 rc
= memcached_set(memc
, key
, strlen(key
),
934 (time_t)0, (uint32_t)0);
935 assert(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
);
937 string
= memcached_get(memc
, key
, strlen(key
),
938 &string_length
, &flags
, &rc
);
940 assert(rc
== MEMCACHED_SUCCESS
);
942 assert(string_length
== value_length
);
943 assert(!memcmp(string
, value
, string_length
));
951 static test_return
get_test4(memcached_st
*memc
)
956 size_t value_length
= 8191;
958 size_t string_length
;
962 value
= (char*)malloc(value_length
);
965 for (x
= 0; x
< value_length
; x
++)
966 value
[x
] = (char) (x
% 127);
968 rc
= memcached_set(memc
, key
, strlen(key
),
970 (time_t)0, (uint32_t)0);
971 assert(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
);
973 for (x
= 0; x
< 10; x
++)
975 string
= memcached_get(memc
, key
, strlen(key
),
976 &string_length
, &flags
, &rc
);
978 assert(rc
== MEMCACHED_SUCCESS
);
980 assert(string_length
== value_length
);
981 assert(!memcmp(string
, value
, string_length
));
991 * This test verifies that memcached_read_one_response doesn't try to
992 * dereference a NIL-pointer if you issue a multi-get and don't read out all
993 * responses before you execute a storage command.
995 static test_return
get_test5(memcached_st
*memc
)
998 ** Request the same key twice, to ensure that we hash to the same server
999 ** (so that we have multiple response values queued up) ;-)
1001 char *keys
[]= { "key", "key" };
1002 size_t lengths
[]= { 3, 3 };
1006 memcached_return rc
= memcached_set(memc
, keys
[0], lengths
[0],
1007 keys
[0], lengths
[0], 0, 0);
1008 assert(rc
== MEMCACHED_SUCCESS
);
1009 rc
= memcached_mget(memc
, keys
, lengths
, 2);
1011 memcached_result_st results_obj
;
1012 memcached_result_st
*results
;
1013 results
=memcached_result_create(memc
, &results_obj
);
1015 results
=memcached_fetch_result(memc
, &results_obj
, &rc
);
1017 memcached_result_free(&results_obj
);
1019 /* Don't read out the second result, but issue a set instead.. */
1020 rc
= memcached_set(memc
, keys
[0], lengths
[0], keys
[0], lengths
[0], 0, 0);
1021 assert(rc
== MEMCACHED_SUCCESS
);
1023 char *val
= memcached_get_by_key(memc
, keys
[0], lengths
[0], "yek", 3,
1024 &rlen
, &flags
, &rc
);
1025 assert(val
== NULL
);
1026 assert(rc
== MEMCACHED_NOTFOUND
);
1027 val
= memcached_get(memc
, keys
[0], lengths
[0], &rlen
, &flags
, &rc
);
1028 assert(val
!= NULL
);
1029 assert(rc
== MEMCACHED_SUCCESS
);
1032 return TEST_SUCCESS
;
1035 /* Do not copy the style of this code, I just access hosts to testthis function */
1036 static test_return
stats_servername_test(memcached_st
*memc
)
1038 memcached_return rc
;
1039 memcached_stat_st memc_stat
;
1040 rc
= memcached_stat_servername(&memc_stat
, NULL
,
1041 memc
->hosts
[0].hostname
,
1042 memc
->hosts
[0].port
);
1047 static test_return
increment_test(memcached_st
*memc
)
1049 uint64_t new_number
;
1050 memcached_return rc
;
1051 char *key
= "number";
1054 rc
= memcached_set(memc
, key
, strlen(key
),
1055 value
, strlen(value
),
1056 (time_t)0, (uint32_t)0);
1057 assert(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
);
1059 rc
= memcached_increment(memc
, key
, strlen(key
),
1061 assert(rc
== MEMCACHED_SUCCESS
);
1062 assert(new_number
== 1);
1064 rc
= memcached_increment(memc
, key
, strlen(key
),
1066 assert(rc
== MEMCACHED_SUCCESS
);
1067 assert(new_number
== 2);
1072 static test_return
increment_with_initial_test(memcached_st
*memc
)
1074 if (memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
) != 0)
1076 uint64_t new_number
;
1077 memcached_return rc
;
1078 char *key
= "number";
1079 uint64_t initial
= 0;
1081 rc
= memcached_increment_with_initial(memc
, key
, strlen(key
),
1082 1, initial
, 0, &new_number
);
1083 assert(rc
== MEMCACHED_SUCCESS
);
1084 assert(new_number
== initial
);
1086 rc
= memcached_increment_with_initial(memc
, key
, strlen(key
),
1087 1, initial
, 0, &new_number
);
1088 assert(rc
== MEMCACHED_SUCCESS
);
1089 assert(new_number
== (initial
+ 1));
1094 static test_return
decrement_test(memcached_st
*memc
)
1096 uint64_t new_number
;
1097 memcached_return rc
;
1098 char *key
= "number";
1101 rc
= memcached_set(memc
, key
, strlen(key
),
1102 value
, strlen(value
),
1103 (time_t)0, (uint32_t)0);
1104 assert(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
);
1106 rc
= memcached_decrement(memc
, key
, strlen(key
),
1108 assert(rc
== MEMCACHED_SUCCESS
);
1109 assert(new_number
== 2);
1111 rc
= memcached_decrement(memc
, key
, strlen(key
),
1113 assert(rc
== MEMCACHED_SUCCESS
);
1114 assert(new_number
== 1);
1119 static test_return
decrement_with_initial_test(memcached_st
*memc
)
1121 if (memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
) != 0)
1123 uint64_t new_number
;
1124 memcached_return rc
;
1125 char *key
= "number";
1126 uint64_t initial
= 3;
1128 rc
= memcached_decrement_with_initial(memc
, key
, strlen(key
),
1129 1, initial
, 0, &new_number
);
1130 assert(rc
== MEMCACHED_SUCCESS
);
1131 assert(new_number
== initial
);
1133 rc
= memcached_decrement_with_initial(memc
, key
, strlen(key
),
1134 1, initial
, 0, &new_number
);
1135 assert(rc
== MEMCACHED_SUCCESS
);
1136 assert(new_number
== (initial
- 1));
1141 static test_return
quit_test(memcached_st
*memc
)
1143 memcached_return rc
;
1145 char *value
= "sanford and sun";
1147 rc
= memcached_set(memc
, key
, strlen(key
),
1148 value
, strlen(value
),
1149 (time_t)10, (uint32_t)3);
1150 assert(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
);
1151 memcached_quit(memc
);
1153 rc
= memcached_set(memc
, key
, strlen(key
),
1154 value
, strlen(value
),
1155 (time_t)50, (uint32_t)9);
1156 assert(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
);
1161 static test_return
mget_result_test(memcached_st
*memc
)
1163 memcached_return rc
;
1164 char *keys
[]= {"fudge", "son", "food"};
1165 size_t key_length
[]= {5, 3, 4};
1168 memcached_result_st results_obj
;
1169 memcached_result_st
*results
;
1171 results
= memcached_result_create(memc
, &results_obj
);
1173 assert(&results_obj
== results
);
1175 /* We need to empty the server before continueing test */
1176 rc
= memcached_flush(memc
, 0);
1177 assert(rc
== MEMCACHED_SUCCESS
);
1179 rc
= memcached_mget(memc
, keys
, key_length
, 3);
1180 assert(rc
== MEMCACHED_SUCCESS
);
1182 while ((results
= memcached_fetch_result(memc
, &results_obj
, &rc
)) != NULL
)
1187 while ((results
= memcached_fetch_result(memc
, &results_obj
, &rc
)) != NULL
)
1189 assert(rc
== MEMCACHED_END
);
1191 for (x
= 0; x
< 3; x
++)
1193 rc
= memcached_set(memc
, keys
[x
], key_length
[x
],
1194 keys
[x
], key_length
[x
],
1195 (time_t)50, (uint32_t)9);
1196 assert(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
);
1199 rc
= memcached_mget(memc
, keys
, key_length
, 3);
1200 assert(rc
== MEMCACHED_SUCCESS
);
1202 while ((results
= memcached_fetch_result(memc
, &results_obj
, &rc
)))
1205 assert(&results_obj
== results
);
1206 assert(rc
== MEMCACHED_SUCCESS
);
1207 assert(memcached_result_key_length(results
) == memcached_result_length(results
));
1208 assert(!memcmp(memcached_result_key_value(results
),
1209 memcached_result_value(results
),
1210 memcached_result_length(results
)));
1213 memcached_result_free(&results_obj
);
1218 static test_return
mget_result_alloc_test(memcached_st
*memc
)
1220 memcached_return rc
;
1221 char *keys
[]= {"fudge", "son", "food"};
1222 size_t key_length
[]= {5, 3, 4};
1225 memcached_result_st
*results
;
1227 /* We need to empty the server before continueing test */
1228 rc
= memcached_flush(memc
, 0);
1229 assert(rc
== MEMCACHED_SUCCESS
);
1231 rc
= memcached_mget(memc
, keys
, key_length
, 3);
1232 assert(rc
== MEMCACHED_SUCCESS
);
1234 while ((results
= memcached_fetch_result(memc
, NULL
, &rc
)) != NULL
)
1239 assert(rc
== MEMCACHED_END
);
1241 for (x
= 0; x
< 3; x
++)
1243 rc
= memcached_set(memc
, keys
[x
], key_length
[x
],
1244 keys
[x
], key_length
[x
],
1245 (time_t)50, (uint32_t)9);
1246 assert(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
);
1249 rc
= memcached_mget(memc
, keys
, key_length
, 3);
1250 assert(rc
== MEMCACHED_SUCCESS
);
1253 while ((results
= memcached_fetch_result(memc
, NULL
, &rc
)))
1256 assert(rc
== MEMCACHED_SUCCESS
);
1257 assert(memcached_result_key_length(results
) == memcached_result_length(results
));
1258 assert(!memcmp(memcached_result_key_value(results
),
1259 memcached_result_value(results
),
1260 memcached_result_length(results
)));
1261 memcached_result_free(results
);
1268 /* Count the results */
1269 static memcached_return
callback_counter(memcached_st
*ptr
__attribute__((unused
)),
1270 memcached_result_st
*result
__attribute__((unused
)),
1273 unsigned int *counter
= (unsigned int *)context
;
1275 *counter
= *counter
+ 1;
1277 return MEMCACHED_SUCCESS
;
1280 static test_return
mget_result_function(memcached_st
*memc
)
1282 memcached_return rc
;
1283 char *keys
[]= {"fudge", "son", "food"};
1284 size_t key_length
[]= {5, 3, 4};
1286 unsigned int counter
;
1287 memcached_execute_function callbacks
[1];
1289 /* We need to empty the server before continueing test */
1290 rc
= memcached_flush(memc
, 0);
1291 for (x
= 0; x
< 3; x
++)
1293 rc
= memcached_set(memc
, keys
[x
], key_length
[x
],
1294 keys
[x
], key_length
[x
],
1295 (time_t)50, (uint32_t)9);
1296 assert(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
);
1299 rc
= memcached_mget(memc
, keys
, key_length
, 3);
1300 assert(rc
== MEMCACHED_SUCCESS
);
1302 callbacks
[0]= &callback_counter
;
1304 rc
= memcached_fetch_execute(memc
, callbacks
, (void *)&counter
, 1);
1306 assert(counter
== 3);
1311 static test_return
mget_test(memcached_st
*memc
)
1313 memcached_return rc
;
1314 char *keys
[]= {"fudge", "son", "food"};
1315 size_t key_length
[]= {5, 3, 4};
1319 char return_key
[MEMCACHED_MAX_KEY
];
1320 size_t return_key_length
;
1322 size_t return_value_length
;
1324 /* We need to empty the server before continueing test */
1325 rc
= memcached_flush(memc
, 0);
1326 assert(rc
== MEMCACHED_SUCCESS
);
1328 rc
= memcached_mget(memc
, keys
, key_length
, 3);
1329 assert(rc
== MEMCACHED_SUCCESS
);
1331 while ((return_value
= memcached_fetch(memc
, return_key
, &return_key_length
,
1332 &return_value_length
, &flags
, &rc
)) != NULL
)
1334 assert(return_value
);
1336 assert(!return_value
);
1337 assert(return_value_length
== 0);
1338 assert(rc
== MEMCACHED_END
);
1340 for (x
= 0; x
< 3; x
++)
1342 rc
= memcached_set(memc
, keys
[x
], key_length
[x
],
1343 keys
[x
], key_length
[x
],
1344 (time_t)50, (uint32_t)9);
1345 assert(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
);
1348 rc
= memcached_mget(memc
, keys
, key_length
, 3);
1349 assert(rc
== MEMCACHED_SUCCESS
);
1352 while ((return_value
= memcached_fetch(memc
, return_key
, &return_key_length
,
1353 &return_value_length
, &flags
, &rc
)))
1355 assert(return_value
);
1356 assert(rc
== MEMCACHED_SUCCESS
);
1357 assert(return_key_length
== return_value_length
);
1358 assert(!memcmp(return_value
, return_key
, return_value_length
));
1366 static test_return
get_stats_keys(memcached_st
*memc
)
1370 memcached_stat_st memc_stat
;
1371 memcached_return rc
;
1373 list
= memcached_stat_get_keys(memc
, &memc_stat
, &rc
);
1374 assert(rc
== MEMCACHED_SUCCESS
);
1375 for (ptr
= list
; *ptr
; ptr
++)
1384 static test_return
version_string_test(memcached_st
*memc
__attribute__((unused
)))
1386 const char *version_string
;
1388 version_string
= memcached_lib_version();
1390 assert(!strcmp(version_string
, LIBMEMCACHED_VERSION_STRING
));
1395 static test_return
get_stats(memcached_st
*memc
)
1400 memcached_return rc
;
1401 memcached_stat_st
*memc_stat
;
1403 memc_stat
= memcached_stat(memc
, NULL
, &rc
);
1404 assert(rc
== MEMCACHED_SUCCESS
);
1406 assert(rc
== MEMCACHED_SUCCESS
);
1409 for (x
= 0; x
< memcached_server_count(memc
); x
++)
1411 list
= memcached_stat_get_keys(memc
, memc_stat
+x
, &rc
);
1412 assert(rc
== MEMCACHED_SUCCESS
);
1413 for (ptr
= list
; *ptr
; ptr
++);
1418 memcached_stat_free(NULL
, memc_stat
);
1423 static test_return
add_host_test(memcached_st
*memc
)
1426 memcached_server_st
*servers
;
1427 memcached_return rc
;
1428 char servername
[]= "0.example.com";
1430 servers
= memcached_server_list_append_with_weight(NULL
, servername
, 400, 0, &rc
);
1432 assert(1 == memcached_server_list_count(servers
));
1434 for (x
= 2; x
< 20; x
++)
1436 char buffer
[SMALL_STRING_LEN
];
1438 snprintf(buffer
, SMALL_STRING_LEN
, "%u.example.com", 400+x
);
1439 servers
= memcached_server_list_append_with_weight(servers
, buffer
, 401, 0,
1441 assert(rc
== MEMCACHED_SUCCESS
);
1442 assert(x
== memcached_server_list_count(servers
));
1445 rc
= memcached_server_push(memc
, servers
);
1446 assert(rc
== MEMCACHED_SUCCESS
);
1447 rc
= memcached_server_push(memc
, servers
);
1448 assert(rc
== MEMCACHED_SUCCESS
);
1450 memcached_server_list_free(servers
);
1455 static memcached_return
clone_test_callback(memcached_st
*parent
__attribute__((unused
)), memcached_st
*memc_clone
__attribute__((unused
)))
1457 return MEMCACHED_SUCCESS
;
1460 static memcached_return
cleanup_test_callback(memcached_st
*ptr
__attribute__((unused
)))
1462 return MEMCACHED_SUCCESS
;
1465 static test_return
callback_test(memcached_st
*memc
)
1467 /* Test User Data */
1471 memcached_return rc
;
1473 rc
= memcached_callback_set(memc
, MEMCACHED_CALLBACK_USER_DATA
, &x
);
1474 assert(rc
== MEMCACHED_SUCCESS
);
1475 test_ptr
= (int *)memcached_callback_get(memc
, MEMCACHED_CALLBACK_USER_DATA
, &rc
);
1476 assert(*test_ptr
== x
);
1479 /* Test Clone Callback */
1481 memcached_clone_func clone_cb
= (memcached_clone_func
)clone_test_callback
;
1482 void *clone_cb_ptr
= *(void **)&clone_cb
;
1483 void *temp_function
= NULL
;
1484 memcached_return rc
;
1486 rc
= memcached_callback_set(memc
, MEMCACHED_CALLBACK_CLONE_FUNCTION
,
1488 assert(rc
== MEMCACHED_SUCCESS
);
1489 temp_function
= memcached_callback_get(memc
, MEMCACHED_CALLBACK_CLONE_FUNCTION
, &rc
);
1490 assert(temp_function
== clone_cb_ptr
);
1493 /* Test Cleanup Callback */
1495 memcached_cleanup_func cleanup_cb
=
1496 (memcached_cleanup_func
)cleanup_test_callback
;
1497 void *cleanup_cb_ptr
= *(void **)&cleanup_cb
;
1498 void *temp_function
= NULL
;
1499 memcached_return rc
;
1501 rc
= memcached_callback_set(memc
, MEMCACHED_CALLBACK_CLONE_FUNCTION
,
1503 assert(rc
== MEMCACHED_SUCCESS
);
1504 temp_function
= memcached_callback_get(memc
, MEMCACHED_CALLBACK_CLONE_FUNCTION
, &rc
);
1505 assert(temp_function
== cleanup_cb_ptr
);
1511 /* We don't test the behavior itself, we test the switches */
1512 static test_return
behavior_test(memcached_st
*memc
)
1517 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NO_BLOCK
, set
);
1518 value
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_NO_BLOCK
);
1521 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_TCP_NODELAY
, set
);
1522 value
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_TCP_NODELAY
);
1525 set
= MEMCACHED_HASH_MD5
;
1526 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_HASH
, set
);
1527 value
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_HASH
);
1528 assert(value
== MEMCACHED_HASH_MD5
);
1532 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NO_BLOCK
, set
);
1533 value
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_NO_BLOCK
);
1536 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_TCP_NODELAY
, set
);
1537 value
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_TCP_NODELAY
);
1540 set
= MEMCACHED_HASH_DEFAULT
;
1541 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_HASH
, set
);
1542 value
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_HASH
);
1543 assert(value
== MEMCACHED_HASH_DEFAULT
);
1545 set
= MEMCACHED_HASH_CRC
;
1546 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_HASH
, set
);
1547 value
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_HASH
);
1548 assert(value
== MEMCACHED_HASH_CRC
);
1550 value
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_SOCKET_SEND_SIZE
);
1553 value
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_SOCKET_RECV_SIZE
);
1556 value
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_NUMBER_OF_REPLICAS
);
1557 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NUMBER_OF_REPLICAS
, value
+ 1);
1558 assert((value
+ 1) == memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_NUMBER_OF_REPLICAS
));
1562 /* Test case provided by Cal Haldenbrand */
1563 static test_return
user_supplied_bug1(memcached_st
*memc
)
1565 unsigned int setter
= 1;
1568 unsigned long long total
= 0;
1571 char randomstuff
[6 * 1024];
1572 memcached_return rc
;
1574 memset(randomstuff
, 0, 6 * 1024);
1576 /* We just keep looking at the same values over and over */
1579 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NO_BLOCK
, setter
);
1580 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_TCP_NODELAY
, setter
);
1584 for (x
= 0 ; total
< 20 * 1024576 ; x
++ )
1588 size
= (uint32_t)(rand() % ( 5 * 1024 ) ) + 400;
1589 memset(randomstuff
, 0, 6 * 1024);
1590 assert(size
< 6 * 1024); /* Being safe here */
1592 for (j
= 0 ; j
< size
;j
++)
1593 randomstuff
[j
] = (signed char) ((rand() % 26) + 97);
1596 sprintf(key
, "%d", x
);
1597 rc
= memcached_set(memc
, key
, strlen(key
),
1598 randomstuff
, strlen(randomstuff
), 10, 0);
1599 assert(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
);
1600 /* If we fail, lets try again */
1601 if (rc
!= MEMCACHED_SUCCESS
&& rc
!= MEMCACHED_BUFFERED
)
1602 rc
= memcached_set(memc
, key
, strlen(key
),
1603 randomstuff
, strlen(randomstuff
), 10, 0);
1604 assert(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
);
1610 /* Test case provided by Cal Haldenbrand */
1611 static test_return
user_supplied_bug2(memcached_st
*memc
)
1614 unsigned int setter
;
1616 unsigned long long total
;
1619 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NO_BLOCK
, setter
);
1620 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_TCP_NODELAY
, setter
);
1622 setter
= 20 * 1024576;
1623 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_SOCKET_SEND_SIZE
, setter
);
1624 setter
= 20 * 1024576;
1625 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_SOCKET_RECV_SIZE
, setter
);
1626 getter
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_SOCKET_SEND_SIZE
);
1627 getter
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_SOCKET_RECV_SIZE
);
1629 for (x
= 0, errors
= 0, total
= 0 ; total
< 20 * 1024576 ; x
++)
1632 for (x
= 0, errors
= 0, total
= 0 ; total
< 24576 ; x
++)
1634 memcached_return rc
= MEMCACHED_SUCCESS
;
1635 char buffer
[SMALL_STRING_LEN
];
1640 memset(buffer
, 0, SMALL_STRING_LEN
);
1642 snprintf(buffer
, SMALL_STRING_LEN
, "%u", x
);
1643 getval
= memcached_get(memc
, buffer
, strlen(buffer
),
1644 &val_len
, &flags
, &rc
);
1645 if (rc
!= MEMCACHED_SUCCESS
)
1647 if (rc
== MEMCACHED_NOTFOUND
)
1664 /* Do a large mget() over all the keys we think exist */
1665 #define KEY_COUNT 3000 // * 1024576
1666 static test_return
user_supplied_bug3(memcached_st
*memc
)
1668 memcached_return rc
;
1669 unsigned int setter
;
1672 size_t key_lengths
[KEY_COUNT
];
1675 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NO_BLOCK
, setter
);
1676 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_TCP_NODELAY
, setter
);
1678 setter
= 20 * 1024576;
1679 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_SOCKET_SEND_SIZE
, setter
);
1680 setter
= 20 * 1024576;
1681 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_SOCKET_RECV_SIZE
, setter
);
1682 getter
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_SOCKET_SEND_SIZE
);
1683 getter
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_SOCKET_RECV_SIZE
);
1686 keys
= (char **)malloc(sizeof(char *) * KEY_COUNT
);
1688 memset(keys
, 0, (sizeof(char *) * KEY_COUNT
));
1689 for (x
= 0; x
< KEY_COUNT
; x
++)
1693 snprintf(buffer
, 30, "%u", x
);
1694 keys
[x
]= strdup(buffer
);
1695 key_lengths
[x
]= strlen(keys
[x
]);
1698 rc
= memcached_mget(memc
, keys
, key_lengths
, KEY_COUNT
);
1699 assert(rc
== MEMCACHED_SUCCESS
);
1701 /* Turn this into a help function */
1703 char return_key
[MEMCACHED_MAX_KEY
];
1704 size_t return_key_length
;
1706 size_t return_value_length
;
1709 while ((return_value
= memcached_fetch(memc
, return_key
, &return_key_length
,
1710 &return_value_length
, &flags
, &rc
)))
1712 assert(return_value
);
1713 assert(rc
== MEMCACHED_SUCCESS
);
1718 for (x
= 0; x
< KEY_COUNT
; x
++)
1725 /* Make sure we behave properly if server list has no values */
1726 static test_return
user_supplied_bug4(memcached_st
*memc
)
1728 memcached_return rc
;
1729 char *keys
[]= {"fudge", "son", "food"};
1730 size_t key_length
[]= {5, 3, 4};
1733 char return_key
[MEMCACHED_MAX_KEY
];
1734 size_t return_key_length
;
1736 size_t return_value_length
;
1738 /* Here we free everything before running a bunch of mget tests */
1740 memcached_server_list_free(memc
->hosts
);
1742 memc
->number_of_hosts
= 0;
1746 /* We need to empty the server before continueing test */
1747 rc
= memcached_flush(memc
, 0);
1748 assert(rc
== MEMCACHED_NO_SERVERS
);
1750 rc
= memcached_mget(memc
, keys
, key_length
, 3);
1751 assert(rc
== MEMCACHED_NO_SERVERS
);
1753 while ((return_value
= memcached_fetch(memc
, return_key
, &return_key_length
,
1754 &return_value_length
, &flags
, &rc
)) != NULL
)
1756 assert(return_value
);
1758 assert(!return_value
);
1759 assert(return_value_length
== 0);
1760 assert(rc
== MEMCACHED_NO_SERVERS
);
1762 for (x
= 0; x
< 3; x
++)
1764 rc
= memcached_set(memc
, keys
[x
], key_length
[x
],
1765 keys
[x
], key_length
[x
],
1766 (time_t)50, (uint32_t)9);
1767 assert(rc
== MEMCACHED_NO_SERVERS
);
1770 rc
= memcached_mget(memc
, keys
, key_length
, 3);
1771 assert(rc
== MEMCACHED_NO_SERVERS
);
1774 while ((return_value
= memcached_fetch(memc
, return_key
, &return_key_length
,
1775 &return_value_length
, &flags
, &rc
)))
1777 assert(return_value
);
1778 assert(rc
== MEMCACHED_SUCCESS
);
1779 assert(return_key_length
== return_value_length
);
1780 assert(!memcmp(return_value
, return_key
, return_value_length
));
1788 #define VALUE_SIZE_BUG5 1048064
1789 static test_return
user_supplied_bug5(memcached_st
*memc
)
1791 memcached_return rc
;
1792 char *keys
[]= {"036790384900", "036790384902", "036790384904", "036790384906"};
1793 size_t key_length
[]= {strlen("036790384900"), strlen("036790384902"), strlen("036790384904"), strlen("036790384906")};
1794 char return_key
[MEMCACHED_MAX_KEY
];
1795 size_t return_key_length
;
1797 size_t value_length
;
1801 char insert_data
[VALUE_SIZE_BUG5
];
1803 for (x
= 0; x
< VALUE_SIZE_BUG5
; x
++)
1804 insert_data
[x
]= (signed char)rand();
1806 memcached_flush(memc
, 0);
1807 value
= memcached_get(memc
, keys
[0], key_length
[0],
1808 &value_length
, &flags
, &rc
);
1809 assert(value
== NULL
);
1810 rc
= memcached_mget(memc
, keys
, key_length
, 4);
1813 while ((value
= memcached_fetch(memc
, return_key
, &return_key_length
,
1814 &value_length
, &flags
, &rc
)))
1818 for (x
= 0; x
< 4; x
++)
1820 rc
= memcached_set(memc
, keys
[x
], key_length
[x
],
1821 insert_data
, VALUE_SIZE_BUG5
,
1822 (time_t)0, (uint32_t)0);
1823 assert(rc
== MEMCACHED_SUCCESS
);
1826 for (x
= 0; x
< 10; x
++)
1828 value
= memcached_get(memc
, keys
[0], key_length
[0],
1829 &value_length
, &flags
, &rc
);
1833 rc
= memcached_mget(memc
, keys
, key_length
, 4);
1835 while ((value
= memcached_fetch(memc
, return_key
, &return_key_length
,
1836 &value_length
, &flags
, &rc
)))
1847 static test_return
user_supplied_bug6(memcached_st
*memc
)
1849 memcached_return rc
;
1850 char *keys
[]= {"036790384900", "036790384902", "036790384904", "036790384906"};
1851 size_t key_length
[]= {strlen("036790384900"), strlen("036790384902"), strlen("036790384904"), strlen("036790384906")};
1852 char return_key
[MEMCACHED_MAX_KEY
];
1853 size_t return_key_length
;
1855 size_t value_length
;
1859 char insert_data
[VALUE_SIZE_BUG5
];
1861 for (x
= 0; x
< VALUE_SIZE_BUG5
; x
++)
1862 insert_data
[x
]= (signed char)rand();
1864 memcached_flush(memc
, 0);
1865 value
= memcached_get(memc
, keys
[0], key_length
[0],
1866 &value_length
, &flags
, &rc
);
1867 assert(value
== NULL
);
1868 assert(rc
== MEMCACHED_NOTFOUND
);
1869 rc
= memcached_mget(memc
, keys
, key_length
, 4);
1870 assert(rc
== MEMCACHED_SUCCESS
);
1873 while ((value
= memcached_fetch(memc
, return_key
, &return_key_length
,
1874 &value_length
, &flags
, &rc
)))
1877 assert(rc
== MEMCACHED_END
);
1879 for (x
= 0; x
< 4; x
++)
1881 rc
= memcached_set(memc
, keys
[x
], key_length
[x
],
1882 insert_data
, VALUE_SIZE_BUG5
,
1883 (time_t)0, (uint32_t)0);
1884 assert(rc
== MEMCACHED_SUCCESS
);
1887 for (x
= 0; x
< 2; x
++)
1889 value
= memcached_get(memc
, keys
[0], key_length
[0],
1890 &value_length
, &flags
, &rc
);
1894 rc
= memcached_mget(memc
, keys
, key_length
, 4);
1895 assert(rc
== MEMCACHED_SUCCESS
);
1897 /* We test for purge of partial complete fetches */
1898 for (count
= 3; count
; count
--)
1900 value
= memcached_fetch(memc
, return_key
, &return_key_length
,
1901 &value_length
, &flags
, &rc
);
1902 assert(rc
== MEMCACHED_SUCCESS
);
1903 assert(!(memcmp(value
, insert_data
, value_length
)));
1904 assert(value_length
);
1912 static test_return
user_supplied_bug8(memcached_st
*memc
__attribute__((unused
)))
1914 memcached_return rc
;
1916 memcached_st
*memc_clone
;
1918 memcached_server_st
*servers
;
1919 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";
1921 servers
= memcached_servers_parse(server_list
);
1924 mine
= memcached_create(NULL
);
1925 rc
= memcached_server_push(mine
, servers
);
1926 assert(rc
== MEMCACHED_SUCCESS
);
1927 memcached_server_list_free(servers
);
1930 memc_clone
= memcached_clone(NULL
, mine
);
1932 memcached_quit(mine
);
1933 memcached_quit(memc_clone
);
1936 memcached_free(mine
);
1937 memcached_free(memc_clone
);
1942 /* Test flag store/retrieve */
1943 static test_return
user_supplied_bug7(memcached_st
*memc
)
1945 memcached_return rc
;
1946 char *keys
= "036790384900";
1947 size_t key_length
= strlen("036790384900");
1948 char return_key
[MEMCACHED_MAX_KEY
];
1949 size_t return_key_length
;
1951 size_t value_length
;
1954 char insert_data
[VALUE_SIZE_BUG5
];
1956 for (x
= 0; x
< VALUE_SIZE_BUG5
; x
++)
1957 insert_data
[x
]= (signed char)rand();
1959 memcached_flush(memc
, 0);
1962 rc
= memcached_set(memc
, keys
, key_length
,
1963 insert_data
, VALUE_SIZE_BUG5
,
1965 assert(rc
== MEMCACHED_SUCCESS
);
1968 value
= memcached_get(memc
, keys
, key_length
,
1969 &value_length
, &flags
, &rc
);
1970 assert(flags
== 245);
1974 rc
= memcached_mget(memc
, &keys
, &key_length
, 1);
1977 value
= memcached_fetch(memc
, return_key
, &return_key_length
,
1978 &value_length
, &flags
, &rc
);
1979 assert(flags
== 245);
1987 static test_return
user_supplied_bug9(memcached_st
*memc
)
1989 memcached_return rc
;
1990 char *keys
[]= {"UDATA:edevil@sapo.pt", "fudge&*@#", "for^#@&$not"};
1991 size_t key_length
[3];
1996 char return_key
[MEMCACHED_MAX_KEY
];
1997 size_t return_key_length
;
1999 size_t return_value_length
;
2002 key_length
[0]= strlen("UDATA:edevil@sapo.pt");
2003 key_length
[1]= strlen("fudge&*@#");
2004 key_length
[2]= strlen("for^#@&$not");
2007 for (x
= 0; x
< 3; x
++)
2009 rc
= memcached_set(memc
, keys
[x
], key_length
[x
],
2010 keys
[x
], key_length
[x
],
2011 (time_t)50, (uint32_t)9);
2012 assert(rc
== MEMCACHED_SUCCESS
);
2015 rc
= memcached_mget(memc
, keys
, key_length
, 3);
2016 assert(rc
== MEMCACHED_SUCCESS
);
2018 /* We need to empty the server before continueing test */
2019 while ((return_value
= memcached_fetch(memc
, return_key
, &return_key_length
,
2020 &return_value_length
, &flags
, &rc
)) != NULL
)
2022 assert(return_value
);
2031 /* We are testing with aggressive timeout to get failures */
2032 static test_return
user_supplied_bug10(memcached_st
*memc
)
2036 size_t value_length
= 512;
2039 memcached_return rc
;
2040 unsigned int set
= 1;
2041 memcached_st
*mclone
= memcached_clone(NULL
, memc
);
2044 memcached_behavior_set(mclone
, MEMCACHED_BEHAVIOR_NO_BLOCK
, set
);
2045 memcached_behavior_set(mclone
, MEMCACHED_BEHAVIOR_TCP_NODELAY
, set
);
2047 memcached_behavior_set(mclone
, MEMCACHED_BEHAVIOR_POLL_TIMEOUT
,
2050 value
= (char*)malloc(value_length
* sizeof(char));
2052 for (x
= 0; x
< value_length
; x
++)
2053 value
[x
]= (char) (x
% 127);
2055 for (x
= 1; x
<= 100000; ++x
)
2057 rc
= memcached_set(mclone
, key
, key_len
,value
, value_length
, 0, 0);
2059 assert(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_WRITE_FAILURE
||
2060 rc
== MEMCACHED_BUFFERED
|| rc
== MEMCACHED_TIMEOUT
);
2062 if (rc
== MEMCACHED_WRITE_FAILURE
|| rc
== MEMCACHED_TIMEOUT
)
2067 memcached_free(mclone
);
2073 We are looking failures in the async protocol
2075 static test_return
user_supplied_bug11(memcached_st
*memc
)
2079 size_t value_length
= 512;
2082 memcached_return rc
;
2083 unsigned int set
= 1;
2085 memcached_st
*mclone
= memcached_clone(NULL
, memc
);
2087 memcached_behavior_set(mclone
, MEMCACHED_BEHAVIOR_NO_BLOCK
, set
);
2088 memcached_behavior_set(mclone
, MEMCACHED_BEHAVIOR_TCP_NODELAY
, set
);
2090 memcached_behavior_set(mclone
, MEMCACHED_BEHAVIOR_POLL_TIMEOUT
,
2093 timeout
= (int32_t)memcached_behavior_get(mclone
, MEMCACHED_BEHAVIOR_POLL_TIMEOUT
);
2095 assert(timeout
== -1);
2097 value
= (char*)malloc(value_length
* sizeof(char));
2099 for (x
= 0; x
< value_length
; x
++)
2100 value
[x
]= (char) (x
% 127);
2102 for (x
= 1; x
<= 100000; ++x
)
2104 rc
= memcached_set(mclone
, key
, key_len
,value
, value_length
, 0, 0);
2108 memcached_free(mclone
);
2114 Bug found where incr was not returning MEMCACHED_NOTFOUND when object did not exist.
2116 static test_return
user_supplied_bug12(memcached_st
*memc
)
2118 memcached_return rc
;
2120 size_t value_length
;
2122 uint64_t number_value
;
2124 value
= memcached_get(memc
, "autoincrement", strlen("autoincrement"),
2125 &value_length
, &flags
, &rc
);
2126 assert(value
== NULL
);
2127 assert(rc
== MEMCACHED_NOTFOUND
);
2129 rc
= memcached_increment(memc
, "autoincrement", strlen("autoincrement"),
2132 assert(value
== NULL
);
2133 /* The binary protocol will set the key if it doesn't exist */
2134 if (memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
) == 1)
2135 assert(rc
== MEMCACHED_SUCCESS
);
2137 assert(rc
== MEMCACHED_NOTFOUND
);
2139 rc
= memcached_set(memc
, "autoincrement", strlen("autoincrement"), "1", 1, 0, 0);
2141 value
= memcached_get(memc
, "autoincrement", strlen("autoincrement"),
2142 &value_length
, &flags
, &rc
);
2144 assert(rc
== MEMCACHED_SUCCESS
);
2147 rc
= memcached_increment(memc
, "autoincrement", strlen("autoincrement"),
2149 assert(number_value
== 2);
2150 assert(rc
== MEMCACHED_SUCCESS
);
2156 Bug found where command total one more than MEMCACHED_MAX_BUFFER
2157 set key34567890 0 0 8169 \r\n is sent followed by buffer of size 8169, followed by 8169
2159 static test_return
user_supplied_bug13(memcached_st
*memc
)
2161 char key
[] = "key34567890";
2163 memcached_return rc
;
2164 size_t overflowSize
;
2166 char commandFirst
[]= "set key34567890 0 0 ";
2167 char commandLast
[] = " \r\n"; /* first line of command sent to server */
2168 size_t commandLength
;
2171 commandLength
= strlen(commandFirst
) + strlen(commandLast
) + 4; /* 4 is number of characters in size, probably 8196 */
2173 overflowSize
= MEMCACHED_MAX_BUFFER
- commandLength
;
2175 for (testSize
= overflowSize
- 1; testSize
< overflowSize
+ 1; testSize
++)
2177 overflow
= malloc(testSize
);
2178 assert(overflow
!= NULL
);
2180 memset(overflow
, 'x', testSize
);
2181 rc
= memcached_set(memc
, key
, strlen(key
),
2182 overflow
, testSize
, 0, 0);
2183 assert(rc
== MEMCACHED_SUCCESS
);
2192 Test values of many different sizes
2193 Bug found where command total one more than MEMCACHED_MAX_BUFFER
2194 set key34567890 0 0 8169 \r\n
2195 is sent followed by buffer of size 8169, followed by 8169
2197 static test_return
user_supplied_bug14(memcached_st
*memc
)
2200 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_TCP_NODELAY
, setter
);
2201 memcached_return rc
;
2204 size_t value_length
= 18000;
2206 size_t string_length
;
2209 size_t current_length
;
2211 value
= (char*)malloc(value_length
);
2214 for (x
= 0; x
< value_length
; x
++)
2215 value
[x
] = (char) (x
% 127);
2217 for (current_length
= 0; current_length
< value_length
; current_length
++)
2219 rc
= memcached_set(memc
, key
, strlen(key
),
2220 value
, current_length
,
2221 (time_t)0, (uint32_t)0);
2222 assert(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
);
2224 string
= memcached_get(memc
, key
, strlen(key
),
2225 &string_length
, &flags
, &rc
);
2227 assert(rc
== MEMCACHED_SUCCESS
);
2228 assert(string_length
== current_length
);
2229 assert(!memcmp(string
, value
, string_length
));
2240 Look for zero length value problems
2242 static test_return
user_supplied_bug15(memcached_st
*memc
)
2245 memcached_return rc
;
2251 for (x
= 0; x
< 2; x
++)
2253 rc
= memcached_set(memc
, key
, strlen(key
),
2255 (time_t)0, (uint32_t)0);
2257 assert(rc
== MEMCACHED_SUCCESS
);
2259 value
= memcached_get(memc
, key
, strlen(key
),
2260 &length
, &flags
, &rc
);
2262 assert(rc
== MEMCACHED_SUCCESS
);
2263 assert(value
== NULL
);
2264 assert(length
== 0);
2267 value
= memcached_get(memc
, key
, strlen(key
),
2268 &length
, &flags
, &rc
);
2270 assert(rc
== MEMCACHED_SUCCESS
);
2271 assert(value
== NULL
);
2272 assert(length
== 0);
2279 /* Check the return sizes on FLAGS to make sure it stores 32bit unsigned values correctly */
2280 static test_return
user_supplied_bug16(memcached_st
*memc
)
2282 memcached_return rc
;
2288 rc
= memcached_set(memc
, key
, strlen(key
),
2290 (time_t)0, UINT32_MAX
);
2292 assert(rc
== MEMCACHED_SUCCESS
);
2294 value
= memcached_get(memc
, key
, strlen(key
),
2295 &length
, &flags
, &rc
);
2297 assert(rc
== MEMCACHED_SUCCESS
);
2298 assert(value
== NULL
);
2299 assert(length
== 0);
2300 assert(flags
== UINT32_MAX
);
2305 /* Check the validity of chinese key*/
2306 static test_return
user_supplied_bug17(memcached_st
*memc
)
2308 memcached_return rc
;
2310 char *value
="我们在炎热抑郁的夏天无法停止豆瓣";
2315 rc
= memcached_set(memc
, key
, strlen(key
),
2316 value
, strlen(value
),
2319 assert(rc
== MEMCACHED_SUCCESS
);
2321 value2
= memcached_get(memc
, key
, strlen(key
),
2322 &length
, &flags
, &rc
);
2324 assert(length
==strlen(value
));
2325 assert(rc
== MEMCACHED_SUCCESS
);
2326 assert(memcmp(value
, value2
, length
)==0);
2336 static test_return
user_supplied_bug19(memcached_st
*memc
)
2339 memcached_server_st
*s
;
2340 memcached_return res
;
2344 m
= memcached_create(NULL
);
2345 memcached_server_add_with_weight(m
, "localhost", 11311, 100);
2346 memcached_server_add_with_weight(m
, "localhost", 11312, 100);
2348 s
= memcached_server_by_key(m
, "a", 1, &res
);
2349 memcached_server_free(s
);
2356 /* CAS test from Andei */
2357 static test_return
user_supplied_bug20(memcached_st
*memc
)
2359 memcached_return status
;
2360 memcached_result_st
*result
, result_obj
;
2362 size_t key_len
= strlen("abc");
2363 char *value
= "foobar";
2364 size_t value_len
= strlen(value
);
2366 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_SUPPORT_CAS
, 1);
2368 status
= memcached_set(memc
, key
, key_len
, value
, value_len
, (time_t)0, (uint32_t)0);
2369 assert(status
== MEMCACHED_SUCCESS
);
2371 status
= memcached_mget(memc
, &key
, &key_len
, 1);
2372 assert(status
== MEMCACHED_SUCCESS
);
2374 result
= memcached_result_create(memc
, &result_obj
);
2377 memcached_result_create(memc
, &result_obj
);
2378 result
= memcached_fetch_result(memc
, &result_obj
, &status
);
2381 assert(status
== MEMCACHED_SUCCESS
);
2383 memcached_result_free(result
);
2388 #include "ketama_test_cases.h"
2389 static test_return
user_supplied_bug18(memcached_st
*trash
)
2391 memcached_return rc
;
2394 memcached_server_st
*server_pool
;
2399 memc
= memcached_create(NULL
);
2402 rc
= memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_KETAMA_WEIGHTED
, 1);
2403 assert(rc
== MEMCACHED_SUCCESS
);
2405 value
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_KETAMA_WEIGHTED
);
2408 rc
= memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_KETAMA_HASH
, MEMCACHED_HASH_MD5
);
2409 assert(rc
== MEMCACHED_SUCCESS
);
2411 value
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_KETAMA_HASH
);
2412 assert(value
== MEMCACHED_HASH_MD5
);
2414 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");
2415 memcached_server_push(memc
, server_pool
);
2417 /* verify that the server list was parsed okay. */
2418 assert(memc
->number_of_hosts
== 8);
2419 assert(strcmp(server_pool
[0].hostname
, "10.0.1.1") == 0);
2420 assert(server_pool
[0].port
== 11211);
2421 assert(server_pool
[0].weight
== 600);
2422 assert(strcmp(server_pool
[2].hostname
, "10.0.1.3") == 0);
2423 assert(server_pool
[2].port
== 11211);
2424 assert(server_pool
[2].weight
== 200);
2425 assert(strcmp(server_pool
[7].hostname
, "10.0.1.8") == 0);
2426 assert(server_pool
[7].port
== 11211);
2427 assert(server_pool
[7].weight
== 100);
2429 /* VDEAAAAA hashes to fffcd1b5, after the last continuum point, and lets
2430 * us test the boundary wraparound.
2432 assert(memcached_generate_hash(memc
, (char *)"VDEAAAAA", 8) == memc
->continuum
[0].index
);
2434 /* verify the standard ketama set. */
2435 for (x
= 0; x
< 99; x
++)
2437 uint32_t server_idx
= memcached_generate_hash(memc
, test_cases
[x
].key
, strlen(test_cases
[x
].key
));
2438 char *hostname
= memc
->hosts
[server_idx
].hostname
;
2439 assert(strcmp(hostname
, test_cases
[x
].server
) == 0);
2442 memcached_server_list_free(server_pool
);
2443 memcached_free(memc
);
2448 static test_return
auto_eject_hosts(memcached_st
*trash
)
2452 memcached_return rc
;
2453 memcached_st
*memc
= memcached_create(NULL
);
2456 rc
= memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_KETAMA_WEIGHTED
, 1);
2457 assert(rc
== MEMCACHED_SUCCESS
);
2459 uint64_t value
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_KETAMA_WEIGHTED
);
2462 rc
= memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_KETAMA_HASH
, MEMCACHED_HASH_MD5
);
2463 assert(rc
== MEMCACHED_SUCCESS
);
2465 value
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_KETAMA_HASH
);
2466 assert(value
== MEMCACHED_HASH_MD5
);
2468 /* server should be removed when in delay */
2469 rc
= memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_AUTO_EJECT_HOSTS
, 1);
2470 assert(rc
== MEMCACHED_SUCCESS
);
2472 value
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_AUTO_EJECT_HOSTS
);
2475 memcached_server_st
*server_pool
;
2476 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");
2477 memcached_server_push(memc
, server_pool
);
2479 /* verify that the server list was parsed okay. */
2480 assert(memc
->number_of_hosts
== 8);
2481 assert(strcmp(server_pool
[0].hostname
, "10.0.1.1") == 0);
2482 assert(server_pool
[0].port
== 11211);
2483 assert(server_pool
[0].weight
== 600);
2484 assert(strcmp(server_pool
[2].hostname
, "10.0.1.3") == 0);
2485 assert(server_pool
[2].port
== 11211);
2486 assert(server_pool
[2].weight
== 200);
2487 assert(strcmp(server_pool
[7].hostname
, "10.0.1.8") == 0);
2488 assert(server_pool
[7].port
== 11211);
2489 assert(server_pool
[7].weight
== 100);
2491 memc
->hosts
[2].next_retry
= time(NULL
) + 15;
2492 memc
->next_distribution_rebuild
= time(NULL
) - 1;
2494 for (int x
= 0; x
< 99; x
++)
2496 uint32_t server_idx
= memcached_generate_hash(memc
, test_cases
[x
].key
, strlen(test_cases
[x
].key
));
2497 assert(server_idx
!= 2);
2500 /* and re-added when it's back. */
2501 memc
->hosts
[2].next_retry
= time(NULL
) - 1;
2502 memc
->next_distribution_rebuild
= time(NULL
) - 1;
2503 run_distribution(memc
);
2504 for (int x
= 0; x
< 99; x
++)
2506 uint32_t server_idx
= memcached_generate_hash(memc
, test_cases
[x
].key
, strlen(test_cases
[x
].key
));
2507 char *hostname
= memc
->hosts
[server_idx
].hostname
;
2508 assert(strcmp(hostname
, test_cases
[x
].server
) == 0);
2511 memcached_server_list_free(server_pool
);
2512 memcached_free(memc
);
2514 return TEST_SUCCESS
;
2517 static test_return
result_static(memcached_st
*memc
)
2519 memcached_result_st result
;
2520 memcached_result_st
*result_ptr
;
2522 result_ptr
= memcached_result_create(memc
, &result
);
2523 assert(result
.is_allocated
== false);
2525 memcached_result_free(&result
);
2530 static test_return
result_alloc(memcached_st
*memc
)
2532 memcached_result_st
*result
;
2534 result
= memcached_result_create(memc
, NULL
);
2536 memcached_result_free(result
);
2541 static test_return
string_static_null(memcached_st
*memc
)
2543 memcached_string_st string
;
2544 memcached_string_st
*string_ptr
;
2546 string_ptr
= memcached_string_create(memc
, &string
, 0);
2547 assert(string
.is_allocated
== false);
2549 memcached_string_free(&string
);
2554 static test_return
string_alloc_null(memcached_st
*memc
)
2556 memcached_string_st
*string
;
2558 string
= memcached_string_create(memc
, NULL
, 0);
2560 memcached_string_free(string
);
2565 static test_return
string_alloc_with_size(memcached_st
*memc
)
2567 memcached_string_st
*string
;
2569 string
= memcached_string_create(memc
, NULL
, 1024);
2571 memcached_string_free(string
);
2576 static test_return
string_alloc_with_size_toobig(memcached_st
*memc
)
2578 memcached_string_st
*string
;
2580 string
= memcached_string_create(memc
, NULL
, SIZE_MAX
);
2581 assert(string
== NULL
);
2586 static test_return
string_alloc_append(memcached_st
*memc
)
2589 char buffer
[SMALL_STRING_LEN
];
2590 memcached_string_st
*string
;
2592 /* Ring the bell! */
2593 memset(buffer
, 6, SMALL_STRING_LEN
);
2595 string
= memcached_string_create(memc
, NULL
, 100);
2598 for (x
= 0; x
< 1024; x
++)
2600 memcached_return rc
;
2601 rc
= memcached_string_append(string
, buffer
, SMALL_STRING_LEN
);
2602 assert(rc
== MEMCACHED_SUCCESS
);
2604 memcached_string_free(string
);
2609 static test_return
string_alloc_append_toobig(memcached_st
*memc
)
2611 memcached_return rc
;
2613 char buffer
[SMALL_STRING_LEN
];
2614 memcached_string_st
*string
;
2616 /* Ring the bell! */
2617 memset(buffer
, 6, SMALL_STRING_LEN
);
2619 string
= memcached_string_create(memc
, NULL
, 100);
2622 for (x
= 0; x
< 1024; x
++)
2624 rc
= memcached_string_append(string
, buffer
, SMALL_STRING_LEN
);
2625 assert(rc
== MEMCACHED_SUCCESS
);
2627 rc
= memcached_string_append(string
, buffer
, SIZE_MAX
);
2628 assert(rc
== MEMCACHED_MEMORY_ALLOCATION_FAILURE
);
2629 memcached_string_free(string
);
2634 static test_return
cleanup_pairs(memcached_st
*memc
__attribute__((unused
)))
2636 pairs_free(global_pairs
);
2641 static test_return
generate_pairs(memcached_st
*memc
__attribute__((unused
)))
2643 unsigned long long x
;
2644 global_pairs
= pairs_generate(GLOBAL_COUNT
, 400);
2645 global_count
= GLOBAL_COUNT
;
2647 for (x
= 0; x
< global_count
; x
++)
2649 global_keys
[x
]= global_pairs
[x
].key
;
2650 global_keys_length
[x
]= global_pairs
[x
].key_length
;
2656 static test_return
generate_large_pairs(memcached_st
*memc
__attribute__((unused
)))
2658 unsigned long long x
;
2659 global_pairs
= pairs_generate(GLOBAL2_COUNT
, MEMCACHED_MAX_BUFFER
+10);
2660 global_count
= GLOBAL2_COUNT
;
2662 for (x
= 0; x
< global_count
; x
++)
2664 global_keys
[x
]= global_pairs
[x
].key
;
2665 global_keys_length
[x
]= global_pairs
[x
].key_length
;
2671 static test_return
generate_data(memcached_st
*memc
)
2673 execute_set(memc
, global_pairs
, global_count
);
2678 static test_return
generate_data_with_stats(memcached_st
*memc
)
2680 memcached_stat_st
*stat_p
;
2681 memcached_return rc
;
2682 uint32_t host_index
= 0;
2683 execute_set(memc
, global_pairs
, global_count
);
2685 //TODO: hosts used size stats
2686 stat_p
= memcached_stat(memc
, NULL
, &rc
);
2689 for (host_index
= 0; host_index
< SERVERS_TO_CREATE
; host_index
++)
2691 /* This test was changes so that "make test" would work properlly */
2693 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
);
2695 assert((unsigned long long)(stat_p
+ host_index
)->bytes
);
2698 memcached_stat_free(NULL
, stat_p
);
2702 static test_return
generate_buffer_data(memcached_st
*memc
)
2707 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_BUFFER_REQUESTS
, latch
);
2708 generate_data(memc
);
2713 static test_return
get_read_count(memcached_st
*memc
)
2716 memcached_return rc
;
2717 memcached_st
*memc_clone
;
2719 memc_clone
= memcached_clone(NULL
, memc
);
2722 memcached_server_add_with_weight(memc_clone
, "localhost", 6666, 0);
2726 size_t return_value_length
;
2730 for (x
= count
= 0; x
< global_count
; x
++)
2732 return_value
= memcached_get(memc_clone
, global_keys
[x
], global_keys_length
[x
],
2733 &return_value_length
, &flags
, &rc
);
2734 if (rc
== MEMCACHED_SUCCESS
)
2741 fprintf(stderr
, "\t%u -> %u", global_count
, count
);
2744 memcached_free(memc_clone
);
2749 static test_return
get_read(memcached_st
*memc
)
2752 memcached_return rc
;
2756 size_t return_value_length
;
2759 for (x
= 0; x
< global_count
; x
++)
2761 return_value
= memcached_get(memc
, global_keys
[x
], global_keys_length
[x
],
2762 &return_value_length
, &flags
, &rc
);
2764 assert(return_value);
2765 assert(rc == MEMCACHED_SUCCESS);
2767 if (rc
== MEMCACHED_SUCCESS
&& return_value
)
2775 static test_return
mget_read(memcached_st
*memc
)
2777 memcached_return rc
;
2779 rc
= memcached_mget(memc
, global_keys
, global_keys_length
, global_count
);
2780 assert(rc
== MEMCACHED_SUCCESS
);
2781 /* Turn this into a help function */
2783 char return_key
[MEMCACHED_MAX_KEY
];
2784 size_t return_key_length
;
2786 size_t return_value_length
;
2789 while ((return_value
= memcached_fetch(memc
, return_key
, &return_key_length
,
2790 &return_value_length
, &flags
, &rc
)))
2792 assert(return_value
);
2793 assert(rc
== MEMCACHED_SUCCESS
);
2801 static test_return
mget_read_result(memcached_st
*memc
)
2803 memcached_return rc
;
2805 rc
= memcached_mget(memc
, global_keys
, global_keys_length
, global_count
);
2806 assert(rc
== MEMCACHED_SUCCESS
);
2807 /* Turn this into a help function */
2809 memcached_result_st results_obj
;
2810 memcached_result_st
*results
;
2812 results
= memcached_result_create(memc
, &results_obj
);
2814 while ((results
= memcached_fetch_result(memc
, &results_obj
, &rc
)))
2817 assert(rc
== MEMCACHED_SUCCESS
);
2820 memcached_result_free(&results_obj
);
2826 static test_return
mget_read_function(memcached_st
*memc
)
2828 memcached_return rc
;
2829 unsigned int counter
;
2830 memcached_execute_function callbacks
[1];
2832 rc
= memcached_mget(memc
, global_keys
, global_keys_length
, global_count
);
2833 assert(rc
== MEMCACHED_SUCCESS
);
2835 callbacks
[0]= &callback_counter
;
2837 rc
= memcached_fetch_execute(memc
, callbacks
, (void *)&counter
, 1);
2842 static test_return
delete_generate(memcached_st
*memc
)
2846 for (x
= 0; x
< global_count
; x
++)
2848 (void)memcached_delete(memc
, global_keys
[x
], global_keys_length
[x
], (time_t)0);
2854 static test_return
delete_buffer_generate(memcached_st
*memc
)
2860 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_BUFFER_REQUESTS
, latch
);
2862 for (x
= 0; x
< global_count
; x
++)
2864 (void)memcached_delete(memc
, global_keys
[x
], global_keys_length
[x
], (time_t)0);
2870 static test_return
add_host_test1(memcached_st
*memc
)
2873 memcached_return rc
;
2874 char servername
[]= "0.example.com";
2875 memcached_server_st
*servers
;
2877 servers
= memcached_server_list_append_with_weight(NULL
, servername
, 400, 0, &rc
);
2879 assert(1 == memcached_server_list_count(servers
));
2881 for (x
= 2; x
< 20; x
++)
2883 char buffer
[SMALL_STRING_LEN
];
2885 snprintf(buffer
, SMALL_STRING_LEN
, "%u.example.com", 400+x
);
2886 servers
= memcached_server_list_append_with_weight(servers
, buffer
, 401, 0,
2888 assert(rc
== MEMCACHED_SUCCESS
);
2889 assert(x
== memcached_server_list_count(servers
));
2892 rc
= memcached_server_push(memc
, servers
);
2893 assert(rc
== MEMCACHED_SUCCESS
);
2894 rc
= memcached_server_push(memc
, servers
);
2895 assert(rc
== MEMCACHED_SUCCESS
);
2897 memcached_server_list_free(servers
);
2902 static memcached_return
pre_nonblock(memcached_st
*memc
)
2904 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NO_BLOCK
, 0);
2906 return MEMCACHED_SUCCESS
;
2909 static memcached_return
pre_nonblock_binary(memcached_st
*memc
)
2911 memcached_return rc
= MEMCACHED_FAILURE
;
2912 memcached_st
*memc_clone
;
2914 memc_clone
= memcached_clone(NULL
, memc
);
2916 // The memcached_version needs to be done on a clone, because the server
2917 // will not toggle protocol on an connection.
2918 memcached_version(memc_clone
);
2920 if (memc_clone
->hosts
[0].major_version
>= 1 && memc_clone
->hosts
[0].minor_version
> 2)
2922 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NO_BLOCK
, 0);
2923 rc
= memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
, 1);
2924 assert(rc
== MEMCACHED_SUCCESS
);
2925 assert(memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
) == 1);
2928 memcached_free(memc_clone
);
2932 static memcached_return
pre_murmur(memcached_st
*memc
)
2934 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_HASH
, (uint64_t)MEMCACHED_HASH_MURMUR
);
2936 return MEMCACHED_SUCCESS
;
2939 static memcached_return
pre_jenkins(memcached_st
*memc
)
2941 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_HASH
, (uint64_t)MEMCACHED_HASH_JENKINS
);
2943 return MEMCACHED_SUCCESS
;
2947 static memcached_return
pre_md5(memcached_st
*memc
)
2949 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_HASH
, (uint64_t)MEMCACHED_HASH_MD5
);
2951 return MEMCACHED_SUCCESS
;
2954 static memcached_return
pre_crc(memcached_st
*memc
)
2956 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_HASH
, (uint64_t)MEMCACHED_HASH_CRC
);
2958 return MEMCACHED_SUCCESS
;
2961 static memcached_return
pre_hsieh(memcached_st
*memc
)
2963 #ifdef HAVE_HSIEH_HASH
2964 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_HASH
, (uint64_t)MEMCACHED_HASH_HSIEH
);
2965 return MEMCACHED_SUCCESS
;
2968 return MEMCACHED_FAILURE
;
2972 static memcached_return
pre_hash_fnv1_64(memcached_st
*memc
)
2974 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_HASH
, (uint64_t)MEMCACHED_HASH_FNV1_64
);
2976 return MEMCACHED_SUCCESS
;
2979 static memcached_return
pre_hash_fnv1a_64(memcached_st
*memc
)
2981 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_HASH
, (uint64_t)MEMCACHED_HASH_FNV1A_64
);
2983 return MEMCACHED_SUCCESS
;
2986 static memcached_return
pre_hash_fnv1_32(memcached_st
*memc
)
2988 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_HASH
, (uint64_t)MEMCACHED_HASH_FNV1_32
);
2990 return MEMCACHED_SUCCESS
;
2993 static memcached_return
pre_hash_fnv1a_32(memcached_st
*memc
)
2995 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_HASH
, (uint64_t)MEMCACHED_HASH_FNV1A_32
);
2997 return MEMCACHED_SUCCESS
;
3000 static memcached_return
pre_behavior_ketama(memcached_st
*memc
)
3002 memcached_return rc
;
3005 rc
= memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_KETAMA
, 1);
3006 assert(rc
== MEMCACHED_SUCCESS
);
3008 value
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_KETAMA
);
3011 return MEMCACHED_SUCCESS
;
3014 static memcached_return
pre_behavior_ketama_weighted(memcached_st
*memc
)
3016 memcached_return rc
;
3019 rc
= memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_KETAMA_WEIGHTED
, 1);
3020 assert(rc
== MEMCACHED_SUCCESS
);
3022 value
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_KETAMA_WEIGHTED
);
3025 rc
= memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_KETAMA_HASH
, MEMCACHED_HASH_MD5
);
3026 assert(rc
== MEMCACHED_SUCCESS
);
3028 value
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_KETAMA_HASH
);
3029 assert(value
== MEMCACHED_HASH_MD5
);
3030 return MEMCACHED_SUCCESS
;
3033 static memcached_return
pre_binary(memcached_st
*memc
)
3035 memcached_return rc
= MEMCACHED_FAILURE
;
3036 memcached_st
*memc_clone
;
3038 memc_clone
= memcached_clone(NULL
, memc
);
3040 // The memcached_version needs to be done on a clone, because the server
3041 // will not toggle protocol on an connection.
3042 memcached_version(memc_clone
);
3044 if (memc_clone
->hosts
[0].major_version
>= 1 && memc_clone
->hosts
[0].minor_version
> 2)
3046 rc
= memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
, 1);
3047 assert(rc
== MEMCACHED_SUCCESS
);
3048 assert(memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
) == 1);
3051 memcached_free(memc_clone
);
3055 static memcached_return
pre_replication(memcached_st
*memc
)
3057 memcached_return rc
= MEMCACHED_FAILURE
;
3058 if (pre_binary(memc
) == MEMCACHED_SUCCESS
)
3061 * Make sure that we store the item on all servers
3062 * (master + replicas == number of servers)
3064 rc
= memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NUMBER_OF_REPLICAS
,
3065 memc
->number_of_hosts
- 1);
3066 assert(rc
== MEMCACHED_SUCCESS
);
3067 assert(memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_NUMBER_OF_REPLICAS
) == memc
->number_of_hosts
- 1);
3073 static memcached_return
pre_replication_noblock(memcached_st
*memc
)
3075 memcached_return rc
= MEMCACHED_FAILURE
;
3076 if (pre_replication(memc
) == MEMCACHED_SUCCESS
&&
3077 pre_nonblock(memc
) == MEMCACHED_SUCCESS
)
3078 rc
= MEMCACHED_SUCCESS
;
3083 static void my_free(memcached_st
*ptr
__attribute__((unused
)), void *mem
)
3088 static void *my_malloc(memcached_st
*ptr
__attribute__((unused
)), const size_t size
)
3090 void *ret
= malloc(size
);
3092 memset(ret
, 0xff, size
);
3097 static void *my_realloc(memcached_st
*ptr
__attribute__((unused
)), void *mem
, const size_t size
)
3099 return realloc(mem
, size
);
3102 static void *my_calloc(memcached_st
*ptr
__attribute__((unused
)), size_t nelem
, const size_t size
)
3104 return calloc(nelem
, size
);
3107 static memcached_return
set_prefix(memcached_st
*memc
)
3109 memcached_return rc
;
3110 const char *key
= "mine";
3113 /* Make sure be default none exists */
3114 value
= memcached_callback_get(memc
, MEMCACHED_CALLBACK_PREFIX_KEY
, &rc
);
3115 assert(rc
== MEMCACHED_FAILURE
);
3117 /* Test a clean set */
3118 rc
= memcached_callback_set(memc
, MEMCACHED_CALLBACK_PREFIX_KEY
, (void *)key
);
3119 assert(rc
== MEMCACHED_SUCCESS
);
3121 value
= memcached_callback_get(memc
, MEMCACHED_CALLBACK_PREFIX_KEY
, &rc
);
3122 assert(memcmp(value
, key
, 4) == 0);
3123 assert(rc
== MEMCACHED_SUCCESS
);
3125 /* Test that we can turn it off */
3126 rc
= memcached_callback_set(memc
, MEMCACHED_CALLBACK_PREFIX_KEY
, NULL
);
3127 assert(rc
== MEMCACHED_SUCCESS
);
3129 value
= memcached_callback_get(memc
, MEMCACHED_CALLBACK_PREFIX_KEY
, &rc
);
3130 assert(rc
== MEMCACHED_FAILURE
);
3132 /* Now setup for main test */
3133 rc
= memcached_callback_set(memc
, MEMCACHED_CALLBACK_PREFIX_KEY
, (void *)key
);
3134 assert(rc
== MEMCACHED_SUCCESS
);
3136 value
= memcached_callback_get(memc
, MEMCACHED_CALLBACK_PREFIX_KEY
, &rc
);
3137 assert(rc
== MEMCACHED_SUCCESS
);
3138 assert(memcmp(value
, key
, 4) == 0);
3140 /* Set to Zero, and then Set to something too large */
3143 rc
= memcached_callback_set(memc
, MEMCACHED_CALLBACK_PREFIX_KEY
, NULL
);
3144 assert(rc
== MEMCACHED_SUCCESS
);
3146 value
= memcached_callback_get(memc
, MEMCACHED_CALLBACK_PREFIX_KEY
, &rc
);
3147 assert(rc
== MEMCACHED_FAILURE
);
3148 assert(value
== NULL
);
3150 /* Test a long key for failure */
3151 /* TODO, extend test to determine based on setting, what result should be */
3152 long_key
= "Thisismorethentheallottednumberofcharacters";
3153 rc
= memcached_callback_set(memc
, MEMCACHED_CALLBACK_PREFIX_KEY
, long_key
);
3154 //assert(rc == MEMCACHED_BAD_KEY_PROVIDED);
3155 assert(rc
== MEMCACHED_SUCCESS
);
3157 /* Now test a key with spaces (which will fail from long key, since bad key is not set) */
3158 long_key
= "This is more then the allotted number of characters";
3159 rc
= memcached_callback_set(memc
, MEMCACHED_CALLBACK_PREFIX_KEY
, long_key
);
3160 assert(rc
== MEMCACHED_BAD_KEY_PROVIDED
);
3162 /* Test for a bad prefix, but with a short key */
3163 rc
= memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_VERIFY_KEY
, 1);
3164 assert(rc
== MEMCACHED_SUCCESS
);
3166 long_key
= "dog cat";
3167 rc
= memcached_callback_set(memc
, MEMCACHED_CALLBACK_PREFIX_KEY
, long_key
);
3168 assert(rc
== MEMCACHED_BAD_KEY_PROVIDED
);
3171 return MEMCACHED_SUCCESS
;
3174 #ifdef MEMCACHED_ENABLE_DEPRECATED
3175 static memcached_return
deprecated_set_memory_alloc(memcached_st
*memc
)
3177 void *test_ptr
= NULL
;
3180 memcached_malloc_function malloc_cb
=
3181 (memcached_malloc_function
)my_malloc
;
3182 cb_ptr
= *(void **)&malloc_cb
;
3183 memcached_return rc
;
3185 rc
= memcached_callback_set(memc
, MEMCACHED_CALLBACK_MALLOC_FUNCTION
, cb_ptr
);
3186 assert(rc
== MEMCACHED_SUCCESS
);
3187 test_ptr
= memcached_callback_get(memc
, MEMCACHED_CALLBACK_MALLOC_FUNCTION
, &rc
);
3188 assert(rc
== MEMCACHED_SUCCESS
);
3189 assert(test_ptr
== cb_ptr
);
3193 memcached_realloc_function realloc_cb
=
3194 (memcached_realloc_function
)my_realloc
;
3195 cb_ptr
= *(void **)&realloc_cb
;
3196 memcached_return rc
;
3198 rc
= memcached_callback_set(memc
, MEMCACHED_CALLBACK_REALLOC_FUNCTION
, cb_ptr
);
3199 assert(rc
== MEMCACHED_SUCCESS
);
3200 test_ptr
= memcached_callback_get(memc
, MEMCACHED_CALLBACK_REALLOC_FUNCTION
, &rc
);
3201 assert(rc
== MEMCACHED_SUCCESS
);
3202 assert(test_ptr
== cb_ptr
);
3206 memcached_free_function free_cb
=
3207 (memcached_free_function
)my_free
;
3208 cb_ptr
= *(void **)&free_cb
;
3209 memcached_return rc
;
3211 rc
= memcached_callback_set(memc
, MEMCACHED_CALLBACK_FREE_FUNCTION
, cb_ptr
);
3212 assert(rc
== MEMCACHED_SUCCESS
);
3213 test_ptr
= memcached_callback_get(memc
, MEMCACHED_CALLBACK_FREE_FUNCTION
, &rc
);
3214 assert(rc
== MEMCACHED_SUCCESS
);
3215 assert(test_ptr
== cb_ptr
);
3217 return MEMCACHED_SUCCESS
;
3221 static memcached_return
set_memory_alloc(memcached_st
*memc
)
3223 memcached_return rc
;
3224 rc
= memcached_set_memory_allocators(memc
, NULL
, my_free
,
3225 my_realloc
, my_calloc
);
3226 assert(rc
== MEMCACHED_FAILURE
);
3228 rc
= memcached_set_memory_allocators(memc
, my_malloc
, my_free
,
3229 my_realloc
, my_calloc
);
3231 memcached_malloc_function mem_malloc
;
3232 memcached_free_function mem_free
;
3233 memcached_realloc_function mem_realloc
;
3234 memcached_calloc_function mem_calloc
;
3235 memcached_get_memory_allocators(memc
, &mem_malloc
, &mem_free
,
3236 &mem_realloc
, &mem_calloc
);
3238 assert(mem_malloc
== my_malloc
);
3239 assert(mem_realloc
== my_realloc
);
3240 assert(mem_calloc
== my_calloc
);
3241 assert(mem_free
== my_free
);
3243 return MEMCACHED_SUCCESS
;
3246 static memcached_return
enable_consistent(memcached_st
*memc
)
3248 memcached_server_distribution value
= MEMCACHED_DISTRIBUTION_CONSISTENT
;
3249 memcached_hash hash
;
3250 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_DISTRIBUTION
, value
);
3251 if (pre_hsieh(memc
) != MEMCACHED_SUCCESS
)
3252 return MEMCACHED_FAILURE
;
3254 value
= (memcached_server_distribution
)memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_DISTRIBUTION
);
3255 assert(value
== MEMCACHED_DISTRIBUTION_CONSISTENT
);
3257 hash
= (memcached_hash
)memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_HASH
);
3258 assert(hash
== MEMCACHED_HASH_HSIEH
);
3261 return MEMCACHED_SUCCESS
;
3264 static memcached_return
enable_cas(memcached_st
*memc
)
3266 unsigned int set
= 1;
3268 memcached_version(memc
);
3270 if ((memc
->hosts
[0].major_version
>= 1 && (memc
->hosts
[0].minor_version
== 2 && memc
->hosts
[0].micro_version
>= 4))
3271 || memc
->hosts
[0].minor_version
> 2)
3273 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_SUPPORT_CAS
, set
);
3275 return MEMCACHED_SUCCESS
;
3278 return MEMCACHED_FAILURE
;
3281 static memcached_return
check_for_1_2_3(memcached_st
*memc
)
3283 memcached_version(memc
);
3285 if ((memc
->hosts
[0].major_version
>= 1 && (memc
->hosts
[0].minor_version
== 2 && memc
->hosts
[0].micro_version
>= 4))
3286 || memc
->hosts
[0].minor_version
> 2)
3287 return MEMCACHED_SUCCESS
;
3289 return MEMCACHED_FAILURE
;
3292 static memcached_return
pre_unix_socket(memcached_st
*memc
)
3294 memcached_return rc
;
3297 memcached_server_list_free(memc
->hosts
);
3299 memc
->number_of_hosts
= 0;
3301 if (stat("/tmp/memcached.socket", &buf
))
3302 return MEMCACHED_FAILURE
;
3304 rc
= memcached_server_add_unix_socket_with_weight(memc
, "/tmp/memcached.socket", 0);
3309 static memcached_return
pre_nodelay(memcached_st
*memc
)
3311 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NO_BLOCK
, 0);
3312 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_TCP_NODELAY
, 0);
3314 return MEMCACHED_SUCCESS
;
3317 static memcached_return
pre_settimer(memcached_st
*memc
)
3319 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_SND_TIMEOUT
, 1000);
3320 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_RCV_TIMEOUT
, 1000);
3322 return MEMCACHED_SUCCESS
;
3325 static memcached_return
poll_timeout(memcached_st
*memc
)
3331 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_POLL_TIMEOUT
, timeout
);
3333 timeout
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_POLL_TIMEOUT
);
3335 assert(timeout
== 100);
3337 return MEMCACHED_SUCCESS
;
3340 static test_return
noreply_test(memcached_st
*memc
)
3342 memcached_return ret
;
3343 ret
= memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NOREPLY
, 1);
3344 assert(ret
== MEMCACHED_SUCCESS
);
3345 ret
= memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_BUFFER_REQUESTS
, 1);
3346 assert(ret
== MEMCACHED_SUCCESS
);
3347 ret
= memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_SUPPORT_CAS
, 1);
3348 assert(ret
== MEMCACHED_SUCCESS
);
3349 assert(memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_NOREPLY
) == 1);
3350 assert(memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_BUFFER_REQUESTS
) == 1);
3351 assert(memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_SUPPORT_CAS
) == 1);
3353 for (int count
=0; count
< 5; ++count
)
3355 for (int x
=0; x
< 100; ++x
)
3358 size_t len
= (size_t)sprintf(key
, "%d", x
);
3362 ret
=memcached_add(memc
, key
, len
, key
, len
, 0, 0);
3365 ret
=memcached_replace(memc
, key
, len
, key
, len
, 0, 0);
3368 ret
=memcached_set(memc
, key
, len
, key
, len
, 0, 0);
3371 ret
=memcached_append(memc
, key
, len
, key
, len
, 0, 0);
3374 ret
=memcached_prepend(memc
, key
, len
, key
, len
, 0, 0);
3380 assert(ret
== MEMCACHED_SUCCESS
|| ret
== MEMCACHED_BUFFERED
);
3384 ** NOTE: Don't ever do this in your code! this is not a supported use of the
3385 ** API and is _ONLY_ done this way to verify that the library works the
3386 ** way it is supposed to do!!!!
3389 for (uint32_t x
=0; x
< memc
->number_of_hosts
; ++x
)
3390 no_msg
+=(int)(memc
->hosts
[x
].cursor_active
);
3392 assert(no_msg
== 0);
3393 assert(memcached_flush_buffers(memc
) == MEMCACHED_SUCCESS
);
3396 ** Now validate that all items was set properly!
3398 for (int x
=0; x
< 100; ++x
)
3401 size_t len
= (size_t)sprintf(key
, "%d", x
);
3404 char* value
=memcached_get(memc
, key
, strlen(key
),
3405 &length
, &flags
, &ret
);
3406 assert(ret
== MEMCACHED_SUCCESS
&& value
!= NULL
);
3409 case 0: /* FALLTHROUGH */
3410 case 1: /* FALLTHROUGH */
3412 assert(strncmp(value
, key
, len
) == 0);
3413 assert(len
== length
);
3416 assert(length
== len
* 2);
3419 assert(length
== len
* 3);
3429 /* Try setting an illegal cas value (should not return an error to
3430 * the caller (because we don't expect a return message from the server)
3432 char* keys
[]= {"0"};
3433 size_t lengths
[]= {1};
3436 memcached_result_st results_obj
;
3437 memcached_result_st
*results
;
3438 ret
= memcached_mget(memc
, keys
, lengths
, 1);
3439 assert(ret
== MEMCACHED_SUCCESS
);
3441 results
= memcached_result_create(memc
, &results_obj
);
3443 results
= memcached_fetch_result(memc
, &results_obj
, &ret
);
3445 assert(ret
== MEMCACHED_SUCCESS
);
3446 uint64_t cas
= memcached_result_cas(results
);
3447 memcached_result_free(&results_obj
);
3449 ret
= memcached_cas(memc
, keys
[0], lengths
[0], keys
[0], lengths
[0], 0, 0, cas
);
3450 assert(ret
== MEMCACHED_SUCCESS
);
3453 * The item will have a new cas value, so try to set it again with the old
3454 * value. This should fail!
3456 ret
= memcached_cas(memc
, keys
[0], lengths
[0], keys
[0], lengths
[0], 0, 0, cas
);
3457 assert(ret
== MEMCACHED_SUCCESS
);
3458 assert(memcached_flush_buffers(memc
) == MEMCACHED_SUCCESS
);
3459 char* value
=memcached_get(memc
, keys
[0], lengths
[0], &length
, &flags
, &ret
);
3460 assert(ret
== MEMCACHED_SUCCESS
&& value
!= NULL
);
3463 return TEST_SUCCESS
;
3466 static test_return
analyzer_test(memcached_st
*memc
)
3468 memcached_return rc
;
3469 memcached_stat_st
*memc_stat
;
3470 memcached_analysis_st
*report
;
3472 memc_stat
= memcached_stat(memc
, NULL
, &rc
);
3473 assert(rc
== MEMCACHED_SUCCESS
);
3476 report
= memcached_analyze(memc
, memc_stat
, &rc
);
3477 assert(rc
== MEMCACHED_SUCCESS
);
3481 memcached_stat_free(NULL
, memc_stat
);
3483 return TEST_SUCCESS
;
3486 /* Count the objects */
3487 static memcached_return
callback_dump_counter(memcached_st
*ptr
__attribute__((unused
)),
3488 const char *key
__attribute__((unused
)),
3489 size_t key_length
__attribute__((unused
)),
3492 uint32_t *counter
= (uint32_t *)context
;
3494 *counter
= *counter
+ 1;
3496 return MEMCACHED_SUCCESS
;
3499 static test_return
dump_test(memcached_st
*memc
)
3501 memcached_return rc
;
3502 uint32_t counter
= 0;
3503 memcached_dump_func callbacks
[1];
3504 test_return main_rc
;
3506 callbacks
[0]= &callback_dump_counter
;
3508 /* No support for Binary protocol yet */
3509 if (memc
->flags
& MEM_BINARY_PROTOCOL
)
3510 return TEST_SUCCESS
;
3512 main_rc
= set_test3(memc
);
3514 assert (main_rc
== TEST_SUCCESS
);
3516 rc
= memcached_dump(memc
, callbacks
, (void *)&counter
, 1);
3517 assert(rc
== MEMCACHED_SUCCESS
);
3519 /* We may have more then 32 if our previous flush has not completed */
3520 assert(counter
>= 32);
3522 return TEST_SUCCESS
;
3525 #ifdef HAVE_LIBMEMCACHEDUTIL
3526 static void* connection_release(void *arg
) {
3528 memcached_pool_st
* pool
;
3533 assert(memcached_pool_push(resource
->pool
, resource
->mmc
) == MEMCACHED_SUCCESS
);
3537 static test_return
connection_pool_test(memcached_st
*memc
)
3539 memcached_pool_st
* pool
= memcached_pool_create(memc
, 5, 10);
3540 assert(pool
!= NULL
);
3541 memcached_st
* mmc
[10];
3542 memcached_return rc
;
3544 for (int x
= 0; x
< 10; ++x
) {
3545 mmc
[x
]= memcached_pool_pop(pool
, false, &rc
);
3546 assert(mmc
[x
] != NULL
);
3547 assert(rc
== MEMCACHED_SUCCESS
);
3550 assert(memcached_pool_pop(pool
, false, &rc
) == NULL
);
3551 assert(rc
== MEMCACHED_SUCCESS
);
3555 memcached_pool_st
* pool
;
3557 } item
= { .pool
= pool
, .mmc
= mmc
[9] };
3558 pthread_create(&tid
, NULL
, connection_release
, &item
);
3559 mmc
[9]= memcached_pool_pop(pool
, true, &rc
);
3560 assert(rc
== MEMCACHED_SUCCESS
);
3561 pthread_join(tid
, NULL
);
3562 assert(mmc
[9] == item
.mmc
);
3563 const char *key
= "key";
3564 size_t keylen
= strlen(key
);
3566 // verify that I can do ops with all connections
3567 rc
= memcached_set(mmc
[0], key
, keylen
, "0", 1, 0, 0);
3568 assert(rc
== MEMCACHED_SUCCESS
);
3570 for (unsigned int x
= 0; x
< 10; ++x
) {
3571 uint64_t number_value
;
3572 rc
= memcached_increment(mmc
[x
], key
, keylen
, 1, &number_value
);
3573 assert(rc
== MEMCACHED_SUCCESS
);
3574 assert(number_value
== (x
+1));
3578 for (int x
= 0; x
< 10; ++x
)
3579 assert(memcached_pool_push(pool
, mmc
[x
]) == MEMCACHED_SUCCESS
);
3581 assert(memcached_pool_destroy(pool
) == memc
);
3582 return TEST_SUCCESS
;
3586 static test_return
replication_set_test(memcached_st
*memc
)
3588 memcached_return rc
;
3589 memcached_st
*memc_clone
= memcached_clone(NULL
, memc
);
3590 memcached_behavior_set(memc_clone
, MEMCACHED_BEHAVIOR_NUMBER_OF_REPLICAS
, 0);
3592 rc
= memcached_set(memc
, "bubba", 5, "0", 1, 0, 0);
3593 assert(rc
== MEMCACHED_SUCCESS
);
3596 ** We are using the quiet commands to store the replicas, so we need
3597 ** to ensure that all of them are processed before we can continue.
3598 ** In the test we go directly from storing the object to trying to
3599 ** receive the object from all of the different servers, so we
3600 ** could end up in a race condition (the memcached server hasn't yet
3601 ** processed the quiet command from the replication set when it process
3602 ** the request from the other client (created by the clone)). As a
3603 ** workaround for that we call memcached_quit to send the quit command
3604 ** to the server and wait for the response ;-) If you use the test code
3605 ** as an example for your own code, please note that you shouldn't need
3608 memcached_quit(memc
);
3611 ** "bubba" should now be stored on all of our servers. We don't have an
3612 ** easy to use API to address each individual server, so I'll just iterate
3613 ** through a bunch of "master keys" and I should most likely hit all of the
3616 for (int x
= 'a'; x
<= 'z'; ++x
)
3618 char key
[2]= { [0]= (char)x
};
3621 char *val
= memcached_get_by_key(memc_clone
, key
, 1, "bubba", 5,
3623 assert(rc
== MEMCACHED_SUCCESS
);
3624 assert(val
!= NULL
);
3628 memcached_free(memc_clone
);
3630 return TEST_SUCCESS
;
3633 static test_return
replication_get_test(memcached_st
*memc
)
3635 memcached_return rc
;
3638 * Don't do the following in your code. I am abusing the internal details
3639 * within the library, and this is not a supported interface.
3640 * This is to verify correct behavior in the library
3642 for (uint32_t host
= 0; host
< memc
->number_of_hosts
; ++host
)
3644 memcached_st
*memc_clone
= memcached_clone(NULL
, memc
);
3645 memc_clone
->hosts
[host
].port
= 0;
3647 for (int x
= 'a'; x
<= 'z'; ++x
)
3649 char key
[2]= { [0]= (char)x
};
3652 char *val
= memcached_get_by_key(memc_clone
, key
, 1, "bubba", 5,
3654 assert(rc
== MEMCACHED_SUCCESS
);
3655 assert(val
!= NULL
);
3659 memcached_free(memc_clone
);
3662 return TEST_SUCCESS
;
3665 static test_return
replication_mget_test(memcached_st
*memc
)
3667 memcached_return rc
;
3668 memcached_st
*memc_clone
= memcached_clone(NULL
, memc
);
3669 memcached_behavior_set(memc_clone
, MEMCACHED_BEHAVIOR_NUMBER_OF_REPLICAS
, 0);
3671 char *keys
[]= { "bubba", "key1", "key2", "key3" };
3672 size_t len
[]= { 5, 4, 4, 4 };
3674 for (int x
=0; x
< 4; ++x
)
3676 rc
= memcached_set(memc
, keys
[x
], len
[x
], "0", 1, 0, 0);
3677 assert(rc
== MEMCACHED_SUCCESS
);
3681 ** We are using the quiet commands to store the replicas, so we need
3682 ** to ensure that all of them are processed before we can continue.
3683 ** In the test we go directly from storing the object to trying to
3684 ** receive the object from all of the different servers, so we
3685 ** could end up in a race condition (the memcached server hasn't yet
3686 ** processed the quiet command from the replication set when it process
3687 ** the request from the other client (created by the clone)). As a
3688 ** workaround for that we call memcached_quit to send the quit command
3689 ** to the server and wait for the response ;-) If you use the test code
3690 ** as an example for your own code, please note that you shouldn't need
3693 memcached_quit(memc
);
3696 * Don't do the following in your code. I am abusing the internal details
3697 * within the library, and this is not a supported interface.
3698 * This is to verify correct behavior in the library
3700 memcached_result_st result_obj
;
3701 for (uint32_t host
= 0; host
< memc_clone
->number_of_hosts
; host
++)
3703 memcached_st
*new_clone
= memcached_clone(NULL
, memc
);
3704 new_clone
->hosts
[host
].port
= 0;
3706 for (int x
= 'a'; x
<= 'z'; ++x
)
3708 char key
[2]= { [0]= (char)x
};
3710 rc
= memcached_mget_by_key(new_clone
, key
, 1, keys
, len
, 4);
3711 assert(rc
== MEMCACHED_SUCCESS
);
3713 memcached_result_st
*results
= memcached_result_create(new_clone
, &result_obj
);
3717 while ((results
= memcached_fetch_result(new_clone
, &result_obj
, &rc
)) != NULL
)
3722 memcached_result_free(&result_obj
);
3725 memcached_free(new_clone
);
3728 return TEST_SUCCESS
;
3731 static test_return
replication_delete_test(memcached_st
*memc
)
3733 memcached_return rc
;
3734 memcached_st
*memc_clone
= memcached_clone(NULL
, memc
);
3735 /* Delete the items from all of the servers except 1 */
3736 uint64_t repl
= memcached_behavior_get(memc
,
3737 MEMCACHED_BEHAVIOR_NUMBER_OF_REPLICAS
);
3738 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NUMBER_OF_REPLICAS
, --repl
);
3740 char *keys
[]= { "bubba", "key1", "key2", "key3" };
3741 size_t len
[]= { 5, 4, 4, 4 };
3743 for (int x
=0; x
< 4; ++x
)
3745 rc
= memcached_delete_by_key(memc
, keys
[0], len
[0], keys
[x
], len
[x
], 0);
3746 assert(rc
== MEMCACHED_SUCCESS
);
3750 * Don't do the following in your code. I am abusing the internal details
3751 * within the library, and this is not a supported interface.
3752 * This is to verify correct behavior in the library
3754 uint32_t hash
= memcached_generate_hash(memc
, keys
[0], len
[0]);
3755 for (uint32_t x
= 0; x
< (repl
+ 1); ++x
)
3757 memc_clone
->hosts
[hash
].port
= 0;
3758 if (++hash
== memc_clone
->number_of_hosts
)
3762 memcached_result_st result_obj
;
3763 for (uint32_t host
= 0; host
< memc_clone
->number_of_hosts
; ++host
)
3765 for (int x
= 'a'; x
<= 'z'; ++x
)
3767 char key
[2]= { [0]= (char)x
};
3769 rc
= memcached_mget_by_key(memc_clone
, key
, 1, keys
, len
, 4);
3770 assert(rc
== MEMCACHED_SUCCESS
);
3772 memcached_result_st
*results
= memcached_result_create(memc_clone
, &result_obj
);
3776 while ((results
= memcached_fetch_result(memc_clone
, &result_obj
, &rc
)) != NULL
)
3781 memcached_result_free(&result_obj
);
3784 memcached_free(memc_clone
);
3786 return TEST_SUCCESS
;
3789 static void increment_request_id(uint16_t *id
)
3792 if ((*id
& UDP_REQUEST_ID_THREAD_MASK
) != 0)
3796 static uint16_t *get_udp_request_ids(memcached_st
*memc
)
3798 uint16_t *ids
= malloc(sizeof(uint16_t) * memc
->number_of_hosts
);
3799 assert(ids
!= NULL
);
3802 for (x
= 0; x
< memc
->number_of_hosts
; x
++)
3803 ids
[x
]= get_udp_datagram_request_id((struct udp_datagram_header_st
*) memc
->hosts
[x
].write_buffer
);
3808 static test_return
post_udp_op_check(memcached_st
*memc
, uint16_t *expected_req_ids
)
3811 memcached_server_st
*cur_server
= memc
->hosts
;
3812 uint16_t *cur_req_ids
= get_udp_request_ids(memc
);
3814 for (x
= 0; x
< memc
->number_of_hosts
; x
++)
3816 assert(cur_server
[x
].cursor_active
== 0);
3817 assert(cur_req_ids
[x
] == expected_req_ids
[x
]);
3819 free(expected_req_ids
);
3822 return TEST_SUCCESS
;
3826 ** There is a little bit of a hack here, instead of removing
3827 ** the servers, I just set num host to 0 and them add then new udp servers
3829 static memcached_return
init_udp(memcached_st
*memc
)
3831 memcached_version(memc
);
3832 /* For the time being, only support udp test for >= 1.2.6 && < 1.3 */
3833 if (memc
->hosts
[0].major_version
!= 1 || memc
->hosts
[0].minor_version
!= 2
3834 || memc
->hosts
[0].micro_version
< 6)
3835 return MEMCACHED_FAILURE
;
3837 uint32_t num_hosts
= memc
->number_of_hosts
;
3839 memcached_server_st servers
[num_hosts
];
3840 memcpy(servers
, memc
->hosts
, sizeof(memcached_server_st
) * num_hosts
);
3841 for (x
= 0; x
< num_hosts
; x
++)
3842 memcached_server_free(&memc
->hosts
[x
]);
3844 memc
->number_of_hosts
= 0;
3845 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_USE_UDP
, 1);
3846 for (x
= 0; x
< num_hosts
; x
++)
3848 assert(memcached_server_add_udp(memc
, servers
[x
].hostname
, servers
[x
].port
) == MEMCACHED_SUCCESS
);
3849 assert(memc
->hosts
[x
].write_buffer_offset
== UDP_DATAGRAM_HEADER_LENGTH
);
3852 return MEMCACHED_SUCCESS
;
3855 static memcached_return
binary_init_udp(memcached_st
*memc
)
3858 return init_udp(memc
);
3861 /* Make sure that I cant add a tcp server to a udp client */
3862 static test_return
add_tcp_server_udp_client_test(memcached_st
*memc
)
3864 memcached_server_st server
;
3865 memcached_server_clone(&server
, &memc
->hosts
[0]);
3866 assert(memcached_server_remove(&(memc
->hosts
[0])) == MEMCACHED_SUCCESS
);
3867 assert(memcached_server_add(memc
, server
.hostname
, server
.port
) == MEMCACHED_INVALID_HOST_PROTOCOL
);
3868 return TEST_SUCCESS
;
3871 /* Make sure that I cant add a udp server to a tcp client */
3872 static test_return
add_udp_server_tcp_client_test(memcached_st
*memc
)
3874 memcached_server_st server
;
3875 memcached_server_clone(&server
, &memc
->hosts
[0]);
3876 assert(memcached_server_remove(&(memc
->hosts
[0])) == MEMCACHED_SUCCESS
);
3878 memcached_st tcp_client
;
3879 memcached_create(&tcp_client
);
3880 assert(memcached_server_add_udp(&tcp_client
, server
.hostname
, server
.port
) == MEMCACHED_INVALID_HOST_PROTOCOL
);
3881 return TEST_SUCCESS
;
3884 static test_return
set_udp_behavior_test(memcached_st
*memc
)
3887 memcached_quit(memc
);
3888 memc
->number_of_hosts
= 0;
3889 run_distribution(memc
);
3890 assert(memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_USE_UDP
, 1) == MEMCACHED_SUCCESS
);
3891 assert(memc
->flags
& MEM_USE_UDP
);
3892 assert(memc
->flags
& MEM_NOREPLY
);;
3894 assert(memc
->number_of_hosts
== 0);
3896 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_USE_UDP
,0);
3897 assert(!(memc
->flags
& MEM_USE_UDP
));
3898 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NOREPLY
,0);
3899 assert(!(memc
->flags
& MEM_NOREPLY
));
3900 return TEST_SUCCESS
;
3903 static test_return
udp_set_test(memcached_st
*memc
)
3906 unsigned int num_iters
= 1025; //request id rolls over at 1024
3907 for (x
= 0; x
< num_iters
;x
++)
3909 memcached_return rc
;
3911 char *value
= "when we sanitize";
3912 uint16_t *expected_ids
= get_udp_request_ids(memc
);
3913 unsigned int server_key
= memcached_generate_hash(memc
,key
,strlen(key
));
3914 size_t init_offset
= memc
->hosts
[server_key
].write_buffer_offset
;
3915 rc
= memcached_set(memc
, key
, strlen(key
),
3916 value
, strlen(value
),
3917 (time_t)0, (uint32_t)0);
3918 assert(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
);
3919 /** NB, the check below assumes that if new write_ptr is less than
3920 * the original write_ptr that we have flushed. For large payloads, this
3921 * maybe an invalid assumption, but for the small payload we have it is OK
3923 if (rc
== MEMCACHED_SUCCESS
||
3924 memc
->hosts
[server_key
].write_buffer_offset
< init_offset
)
3925 increment_request_id(&expected_ids
[server_key
]);
3927 if (rc
== MEMCACHED_SUCCESS
)
3929 assert(memc
->hosts
[server_key
].write_buffer_offset
== UDP_DATAGRAM_HEADER_LENGTH
);
3933 assert(memc
->hosts
[server_key
].write_buffer_offset
!= UDP_DATAGRAM_HEADER_LENGTH
);
3934 assert(memc
->hosts
[server_key
].write_buffer_offset
<= MAX_UDP_DATAGRAM_LENGTH
);
3936 assert(post_udp_op_check(memc
,expected_ids
) == TEST_SUCCESS
);
3938 return TEST_SUCCESS
;
3941 static test_return
udp_buffered_set_test(memcached_st
*memc
)
3943 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_BUFFER_REQUESTS
, 1);
3944 return udp_set_test(memc
);
3947 static test_return
udp_set_too_big_test(memcached_st
*memc
)
3949 memcached_return rc
;
3951 char value
[MAX_UDP_DATAGRAM_LENGTH
];
3952 uint16_t *expected_ids
= get_udp_request_ids(memc
);
3953 rc
= memcached_set(memc
, key
, strlen(key
),
3954 value
, MAX_UDP_DATAGRAM_LENGTH
,
3955 (time_t)0, (uint32_t)0);
3956 assert(rc
== MEMCACHED_WRITE_FAILURE
);
3957 return post_udp_op_check(memc
,expected_ids
);
3960 static test_return
udp_delete_test(memcached_st
*memc
)
3963 unsigned int num_iters
= 1025; //request id rolls over at 1024
3964 for (x
= 0; x
< num_iters
;x
++)
3966 memcached_return rc
;
3968 uint16_t *expected_ids
=get_udp_request_ids(memc
);
3969 unsigned int server_key
= memcached_generate_hash(memc
, key
, strlen(key
));
3970 size_t init_offset
= memc
->hosts
[server_key
].write_buffer_offset
;
3971 rc
= memcached_delete(memc
, key
, strlen(key
), 0);
3972 assert(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
);
3973 if (rc
== MEMCACHED_SUCCESS
|| memc
->hosts
[server_key
].write_buffer_offset
< init_offset
)
3974 increment_request_id(&expected_ids
[server_key
]);
3975 if (rc
== MEMCACHED_SUCCESS
)
3976 assert(memc
->hosts
[server_key
].write_buffer_offset
== UDP_DATAGRAM_HEADER_LENGTH
);
3979 assert(memc
->hosts
[server_key
].write_buffer_offset
!= UDP_DATAGRAM_HEADER_LENGTH
);
3980 assert(memc
->hosts
[server_key
].write_buffer_offset
<= MAX_UDP_DATAGRAM_LENGTH
);
3982 assert(post_udp_op_check(memc
,expected_ids
) == TEST_SUCCESS
);
3984 return TEST_SUCCESS
;
3987 static test_return
udp_buffered_delete_test(memcached_st
*memc
)
3989 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_BUFFER_REQUESTS
, 1);
3990 return udp_delete_test(memc
);
3993 static test_return
udp_verbosity_test(memcached_st
*memc
)
3995 memcached_return rc
;
3996 uint16_t *expected_ids
= get_udp_request_ids(memc
);
3998 for (x
= 0; x
< memc
->number_of_hosts
;x
++)
3999 increment_request_id(&expected_ids
[x
]);
4001 rc
= memcached_verbosity(memc
,3);
4002 assert(rc
== MEMCACHED_SUCCESS
);
4003 return post_udp_op_check(memc
,expected_ids
);
4006 static test_return
udp_quit_test(memcached_st
*memc
)
4008 uint16_t *expected_ids
= get_udp_request_ids(memc
);
4009 memcached_quit(memc
);
4010 return post_udp_op_check(memc
, expected_ids
);
4013 static test_return
udp_flush_test(memcached_st
*memc
)
4015 memcached_return rc
;
4016 uint16_t *expected_ids
= get_udp_request_ids(memc
);
4018 for (x
= 0; x
< memc
->number_of_hosts
;x
++)
4019 increment_request_id(&expected_ids
[x
]);
4021 rc
= memcached_flush(memc
,0);
4022 assert(rc
== MEMCACHED_SUCCESS
);
4023 return post_udp_op_check(memc
,expected_ids
);
4026 static test_return
udp_incr_test(memcached_st
*memc
)
4028 memcached_return rc
;
4031 rc
= memcached_set(memc
, key
, strlen(key
),
4032 value
, strlen(value
),
4033 (time_t)0, (uint32_t)0);
4035 assert(rc
== MEMCACHED_SUCCESS
);
4036 uint16_t *expected_ids
= get_udp_request_ids(memc
);
4037 unsigned int server_key
= memcached_generate_hash(memc
, key
, strlen(key
));
4038 increment_request_id(&expected_ids
[server_key
]);
4040 rc
= memcached_increment(memc
, key
, strlen(key
), 1, &newvalue
);
4041 assert(rc
== MEMCACHED_SUCCESS
);
4042 return post_udp_op_check(memc
, expected_ids
);
4045 static test_return
udp_decr_test(memcached_st
*memc
)
4047 memcached_return rc
;
4050 rc
= memcached_set(memc
, key
, strlen(key
),
4051 value
, strlen(value
),
4052 (time_t)0, (uint32_t)0);
4054 assert(rc
== MEMCACHED_SUCCESS
);
4055 uint16_t *expected_ids
= get_udp_request_ids(memc
);
4056 unsigned int server_key
= memcached_generate_hash(memc
, key
, strlen(key
));
4057 increment_request_id(&expected_ids
[server_key
]);
4059 rc
= memcached_decrement(memc
, key
, strlen(key
), 1, &newvalue
);
4060 assert(rc
== MEMCACHED_SUCCESS
);
4061 return post_udp_op_check(memc
, expected_ids
);
4065 static test_return
udp_stat_test(memcached_st
*memc
)
4067 memcached_stat_st
* rv
= NULL
;
4068 memcached_return rc
;
4070 uint16_t *expected_ids
= get_udp_request_ids(memc
);
4071 rv
= memcached_stat(memc
, args
, &rc
);
4073 assert(rc
== MEMCACHED_NOT_SUPPORTED
);
4074 return post_udp_op_check(memc
, expected_ids
);
4077 static test_return
udp_version_test(memcached_st
*memc
)
4079 memcached_return rc
;
4080 uint16_t *expected_ids
= get_udp_request_ids(memc
);
4081 rc
= memcached_version(memc
);
4082 assert(rc
== MEMCACHED_NOT_SUPPORTED
);
4083 return post_udp_op_check(memc
, expected_ids
);
4086 static test_return
udp_get_test(memcached_st
*memc
)
4088 memcached_return rc
;
4091 uint16_t *expected_ids
= get_udp_request_ids(memc
);
4092 char *val
= memcached_get(memc
, key
, strlen(key
), &vlen
, (uint32_t)0, &rc
);
4093 assert(rc
== MEMCACHED_NOT_SUPPORTED
);
4094 assert(val
== NULL
);
4095 return post_udp_op_check(memc
, expected_ids
);
4098 static test_return
udp_mixed_io_test(memcached_st
*memc
)
4101 test_st mixed_io_ops
[] ={
4102 {"udp_set_test", 0, udp_set_test
},
4103 {"udp_set_too_big_test", 0, udp_set_too_big_test
},
4104 {"udp_delete_test", 0, udp_delete_test
},
4105 {"udp_verbosity_test", 0, udp_verbosity_test
},
4106 {"udp_quit_test", 0, udp_quit_test
},
4107 {"udp_flush_test", 0, udp_flush_test
},
4108 {"udp_incr_test", 0, udp_incr_test
},
4109 {"udp_decr_test", 0, udp_decr_test
},
4110 {"udp_version_test", 0, udp_version_test
}
4113 for (x
= 0; x
< 500; x
++)
4115 current_op
= mixed_io_ops
[random() % 9];
4116 assert(current_op
.function(memc
) == TEST_SUCCESS
);
4118 return TEST_SUCCESS
;
4121 static test_return
hsieh_avaibility_test (memcached_st
*memc
)
4123 memcached_return expected_rc
= MEMCACHED_FAILURE
;
4124 #ifdef HAVE_HSIEH_HASH
4125 expected_rc
= MEMCACHED_SUCCESS
;
4127 memcached_return rc
= memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_HASH
,
4128 (uint64_t)MEMCACHED_HASH_HSIEH
);
4129 assert(rc
== expected_rc
);
4130 return TEST_SUCCESS
;
4133 static char *list
[]=
4163 static test_return
md5_run (memcached_st
*memc
__attribute__((unused
)))
4167 uint32_t values
[]= { 3195025439U, 2556848621U, 3724893440U, 3332385401U,
4168 245758794U, 2550894432U, 121710495U, 3053817768U,
4169 1250994555U, 1862072655U, 2631955953U, 2951528551U,
4170 1451250070U, 2820856945U, 2060845566U, 3646985608U,
4171 2138080750U, 217675895U, 2230934345U, 1234361223U,
4172 3968582726U, 2455685270U, 1293568479U, 199067604U,
4176 for (ptr
= list
, x
= 0; *ptr
; ptr
++, x
++)
4180 hash_val
= memcached_generate_hash_value(*ptr
, strlen(*ptr
), MEMCACHED_HASH_MD5
);
4181 assert(values
[x
] == hash_val
);
4184 return TEST_SUCCESS
;
4187 static test_return
crc_run (memcached_st
*memc
__attribute__((unused
)))
4191 uint32_t values
[]= { 10542U, 22009U, 14526U, 19510U, 19432U, 10199U, 20634U,
4192 9369U, 11511U, 10362U, 7893U, 31289U, 11313U, 9354U,
4193 7621U, 30628U, 15218U, 25967U, 2695U, 9380U,
4194 17300U, 28156U, 9192U, 20484U, 16925U };
4196 for (ptr
= list
, x
= 0; *ptr
; ptr
++, x
++)
4200 hash_val
= memcached_generate_hash_value(*ptr
, strlen(*ptr
), MEMCACHED_HASH_CRC
);
4201 assert(values
[x
] == hash_val
);
4204 return TEST_SUCCESS
;
4207 static test_return
fnv1_64_run (memcached_st
*memc
__attribute__((unused
)))
4211 uint32_t values
[]= { 473199127U, 4148981457U, 3971873300U, 3257986707U,
4212 1722477987U, 2991193800U, 4147007314U, 3633179701U,
4213 1805162104U, 3503289120U, 3395702895U, 3325073042U,
4214 2345265314U, 3340346032U, 2722964135U, 1173398992U,
4215 2815549194U, 2562818319U, 224996066U, 2680194749U,
4216 3035305390U, 246890365U, 2395624193U, 4145193337U,
4219 for (ptr
= list
, x
= 0; *ptr
; ptr
++, x
++)
4223 hash_val
= memcached_generate_hash_value(*ptr
, strlen(*ptr
), MEMCACHED_HASH_FNV1_64
);
4224 assert(values
[x
] == hash_val
);
4227 return TEST_SUCCESS
;
4230 static test_return
fnv1a_64_run (memcached_st
*memc
__attribute__((unused
)))
4234 uint32_t values
[]= { 1488911807U, 2500855813U, 1510099634U, 1390325195U,
4235 3647689787U, 3241528582U, 1669328060U, 2604311949U,
4236 734810122U, 1516407546U, 560948863U, 1767346780U,
4237 561034892U, 4156330026U, 3716417003U, 3475297030U,
4238 1518272172U, 227211583U, 3938128828U, 126112909U,
4239 3043416448U, 3131561933U, 1328739897U, 2455664041U,
4242 for (ptr
= list
, x
= 0; *ptr
; ptr
++, x
++)
4246 hash_val
= memcached_generate_hash_value(*ptr
, strlen(*ptr
), MEMCACHED_HASH_FNV1A_64
);
4247 assert(values
[x
] == hash_val
);
4250 return TEST_SUCCESS
;
4253 static test_return
fnv1_32_run (memcached_st
*memc
__attribute__((unused
)))
4257 uint32_t values
[]= { 67176023U, 1190179409U, 2043204404U, 3221866419U,
4258 2567703427U, 3787535528U, 4147287986U, 3500475733U,
4259 344481048U, 3865235296U, 2181839183U, 119581266U,
4260 510234242U, 4248244304U, 1362796839U, 103389328U,
4261 1449620010U, 182962511U, 3554262370U, 3206747549U,
4262 1551306158U, 4127558461U, 1889140833U, 2774173721U,
4266 for (ptr
= list
, x
= 0; *ptr
; ptr
++, x
++)
4270 hash_val
= memcached_generate_hash_value(*ptr
, strlen(*ptr
), MEMCACHED_HASH_FNV1_32
);
4271 assert(values
[x
] == hash_val
);
4274 return TEST_SUCCESS
;
4277 static test_return
fnv1a_32_run (memcached_st
*memc
__attribute__((unused
)))
4281 uint32_t values
[]= { 280767167U, 2421315013U, 3072375666U, 855001899U,
4282 459261019U, 3521085446U, 18738364U, 1625305005U,
4283 2162232970U, 777243802U, 3323728671U, 132336572U,
4284 3654473228U, 260679466U, 1169454059U, 2698319462U,
4285 1062177260U, 235516991U, 2218399068U, 405302637U,
4286 1128467232U, 3579622413U, 2138539289U, 96429129U,
4289 for (ptr
= list
, x
= 0; *ptr
; ptr
++, x
++)
4293 hash_val
= memcached_generate_hash_value(*ptr
, strlen(*ptr
), MEMCACHED_HASH_FNV1A_32
);
4294 assert(values
[x
] == hash_val
);
4297 return TEST_SUCCESS
;
4300 static test_return
hsieh_run (memcached_st
*memc
__attribute__((unused
)))
4304 #ifdef HAVE_HSIEH_HASH
4305 uint32_t values
[]= { 3738850110, 3636226060, 3821074029, 3489929160, 3485772682, 80540287,
4306 1805464076, 1895033657, 409795758, 979934958, 3634096985, 1284445480,
4307 2265380744, 707972988, 353823508, 1549198350, 1327930172, 9304163,
4308 4220749037, 2493964934, 2777873870, 2057831732, 1510213931, 2027828987,
4311 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 };
4314 for (ptr
= list
, x
= 0; *ptr
; ptr
++, x
++)
4318 hash_val
= memcached_generate_hash_value(*ptr
, strlen(*ptr
), MEMCACHED_HASH_HSIEH
);
4319 assert(values
[x
] == hash_val
);
4322 return TEST_SUCCESS
;
4325 static test_return
murmur_run (memcached_st
*memc
__attribute__((unused
)))
4329 uint32_t values
[]= { 473199127U, 4148981457U, 3971873300U, 3257986707U,
4330 1722477987U, 2991193800U, 4147007314U, 3633179701U,
4331 1805162104U, 3503289120U, 3395702895U, 3325073042U,
4332 2345265314U, 3340346032U, 2722964135U, 1173398992U,
4333 2815549194U, 2562818319U, 224996066U, 2680194749U,
4334 3035305390U, 246890365U, 2395624193U, 4145193337U,
4337 for (ptr
= list
, x
= 0; *ptr
; ptr
++, x
++)
4341 hash_val
= memcached_generate_hash_value(*ptr
, strlen(*ptr
), MEMCACHED_HASH_FNV1_64
);
4342 assert(values
[x
] == hash_val
);
4345 return TEST_SUCCESS
;
4348 static test_return
jenkins_run (memcached_st
*memc
__attribute__((unused
)))
4352 uint32_t values
[]= { 1442444624U, 4253821186U, 1885058256U, 2120131735U,
4353 3261968576U, 3515188778U, 4232909173U, 4288625128U,
4354 1812047395U, 3689182164U, 2502979932U, 1214050606U,
4355 2415988847U, 1494268927U, 1025545760U, 3920481083U,
4356 4153263658U, 3824871822U, 3072759809U, 798622255U,
4357 3065432577U, 1453328165U, 2691550971U, 3408888387U,
4361 for (ptr
= list
, x
= 0; *ptr
; ptr
++, x
++)
4365 hash_val
= memcached_generate_hash_value(*ptr
, strlen(*ptr
), MEMCACHED_HASH_JENKINS
);
4366 assert(values
[x
] == hash_val
);
4369 return TEST_SUCCESS
;
4372 test_st udp_setup_server_tests
[] ={
4373 {"set_udp_behavior_test", 0, set_udp_behavior_test
},
4374 {"add_tcp_server_udp_client_test", 0, add_tcp_server_udp_client_test
},
4375 {"add_udp_server_tcp_client_test", 0, add_udp_server_tcp_client_test
},
4379 test_st upd_io_tests
[] ={
4380 {"udp_set_test", 0, udp_set_test
},
4381 {"udp_buffered_set_test", 0, udp_buffered_set_test
},
4382 {"udp_set_too_big_test", 0, udp_set_too_big_test
},
4383 {"udp_delete_test", 0, udp_delete_test
},
4384 {"udp_buffered_delete_test", 0, udp_buffered_delete_test
},
4385 {"udp_verbosity_test", 0, udp_verbosity_test
},
4386 {"udp_quit_test", 0, udp_quit_test
},
4387 {"udp_flush_test", 0, udp_flush_test
},
4388 {"udp_incr_test", 0, udp_incr_test
},
4389 {"udp_decr_test", 0, udp_decr_test
},
4390 {"udp_stat_test", 0, udp_stat_test
},
4391 {"udp_version_test", 0, udp_version_test
},
4392 {"udp_get_test", 0, udp_get_test
},
4393 {"udp_mixed_io_test", 0, udp_mixed_io_test
},
4397 /* Clean the server before beginning testing */
4399 {"flush", 0, flush_test
},
4400 {"init", 0, init_test
},
4401 {"allocation", 0, allocation_test
},
4402 {"server_list_null_test", 0, server_list_null_test
},
4403 {"server_unsort", 0, server_unsort_test
},
4404 {"server_sort", 0, server_sort_test
},
4405 {"server_sort2", 0, server_sort2_test
},
4406 {"clone_test", 0, clone_test
},
4407 {"connection_test", 0, connection_test
},
4408 {"callback_test", 0, callback_test
},
4409 {"behavior_test", 0, behavior_test
},
4410 {"userdata_test", 0, userdata_test
},
4411 {"error", 0, error_test
},
4412 {"set", 0, set_test
},
4413 {"set2", 0, set_test2
},
4414 {"set3", 0, set_test3
},
4415 {"dump", 1, dump_test
},
4416 {"add", 1, add_test
},
4417 {"replace", 1, replace_test
},
4418 {"delete", 1, delete_test
},
4419 {"get", 1, get_test
},
4420 {"get2", 0, get_test2
},
4421 {"get3", 0, get_test3
},
4422 {"get4", 0, get_test4
},
4423 {"partial mget", 0, get_test5
},
4424 {"stats_servername", 0, stats_servername_test
},
4425 {"increment", 0, increment_test
},
4426 {"increment_with_initial", 1, increment_with_initial_test
},
4427 {"decrement", 0, decrement_test
},
4428 {"decrement_with_initial", 1, decrement_with_initial_test
},
4429 {"quit", 0, quit_test
},
4430 {"mget", 1, mget_test
},
4431 {"mget_result", 1, mget_result_test
},
4432 {"mget_result_alloc", 1, mget_result_alloc_test
},
4433 {"mget_result_function", 1, mget_result_function
},
4434 {"get_stats", 0, get_stats
},
4435 {"add_host_test", 0, add_host_test
},
4436 {"add_host_test_1", 0, add_host_test1
},
4437 {"get_stats_keys", 0, get_stats_keys
},
4438 {"behavior_test", 0, get_stats_keys
},
4439 {"callback_test", 0, get_stats_keys
},
4440 {"version_string_test", 0, version_string_test
},
4441 {"bad_key", 1, bad_key_test
},
4442 {"memcached_server_cursor", 1, memcached_server_cursor_test
},
4443 {"read_through", 1, read_through
},
4444 {"delete_through", 1, delete_through
},
4445 {"noreply", 1, noreply_test
},
4446 {"analyzer", 1, analyzer_test
},
4447 #ifdef HAVE_LIBMEMCACHEDUTIL
4448 {"connectionpool", 1, connection_pool_test
},
4453 test_st async_tests
[] ={
4454 {"add", 1, add_wrapper
},
4458 test_st string_tests
[] ={
4459 {"string static with null", 0, string_static_null
},
4460 {"string alloc with null", 0, string_alloc_null
},
4461 {"string alloc with 1K", 0, string_alloc_with_size
},
4462 {"string alloc with malloc failure", 0, string_alloc_with_size_toobig
},
4463 {"string append", 0, string_alloc_append
},
4464 {"string append failure (too big)", 0, string_alloc_append_toobig
},
4468 test_st result_tests
[] ={
4469 {"result static", 0, result_static
},
4470 {"result alloc", 0, result_alloc
},
4474 test_st version_1_2_3
[] ={
4475 {"append", 0, append_test
},
4476 {"prepend", 0, prepend_test
},
4477 {"cas", 0, cas_test
},
4478 {"cas2", 0, cas2_test
},
4479 {"append_binary", 0, append_binary_test
},
4483 test_st user_tests
[] ={
4484 {"user_supplied_bug1", 0, user_supplied_bug1
},
4485 {"user_supplied_bug2", 0, user_supplied_bug2
},
4486 {"user_supplied_bug3", 0, user_supplied_bug3
},
4487 {"user_supplied_bug4", 0, user_supplied_bug4
},
4488 {"user_supplied_bug5", 1, user_supplied_bug5
},
4489 {"user_supplied_bug6", 1, user_supplied_bug6
},
4490 {"user_supplied_bug7", 1, user_supplied_bug7
},
4491 {"user_supplied_bug8", 1, user_supplied_bug8
},
4492 {"user_supplied_bug9", 1, user_supplied_bug9
},
4493 {"user_supplied_bug10", 1, user_supplied_bug10
},
4494 {"user_supplied_bug11", 1, user_supplied_bug11
},
4495 {"user_supplied_bug12", 1, user_supplied_bug12
},
4496 {"user_supplied_bug13", 1, user_supplied_bug13
},
4497 {"user_supplied_bug14", 1, user_supplied_bug14
},
4498 {"user_supplied_bug15", 1, user_supplied_bug15
},
4499 {"user_supplied_bug16", 1, user_supplied_bug16
},
4502 ** It seems to be something weird with the character sets..
4503 ** value_fetch is unable to parse the value line (iscntrl "fails"), so I
4504 ** guess I need to find out how this is supposed to work.. Perhaps I need
4505 ** to run the test in a specific locale (I tried zh_CN.UTF-8 without success,
4506 ** so just disable the code for now...).
4508 {"user_supplied_bug17", 1, user_supplied_bug17
},
4510 {"user_supplied_bug18", 1, user_supplied_bug18
},
4511 {"user_supplied_bug19", 1, user_supplied_bug19
},
4512 {"user_supplied_bug20", 1, user_supplied_bug20
},
4516 test_st replication_tests
[]= {
4517 {"set", 1, replication_set_test
},
4518 {"get", 0, replication_get_test
},
4519 {"mget", 0, replication_mget_test
},
4520 {"delete", 0, replication_delete_test
},
4524 test_st generate_tests
[] ={
4525 {"generate_pairs", 1, generate_pairs
},
4526 {"generate_data", 1, generate_data
},
4527 {"get_read", 0, get_read
},
4528 {"delete_generate", 0, delete_generate
},
4529 {"generate_buffer_data", 1, generate_buffer_data
},
4530 {"delete_buffer", 0, delete_buffer_generate
},
4531 {"generate_data", 1, generate_data
},
4532 {"mget_read", 0, mget_read
},
4533 {"mget_read_result", 0, mget_read_result
},
4534 {"mget_read_function", 0, mget_read_function
},
4535 {"cleanup", 1, cleanup_pairs
},
4536 {"generate_large_pairs", 1, generate_large_pairs
},
4537 {"generate_data", 1, generate_data
},
4538 {"generate_buffer_data", 1, generate_buffer_data
},
4539 {"cleanup", 1, cleanup_pairs
},
4543 test_st consistent_tests
[] ={
4544 {"generate_pairs", 1, generate_pairs
},
4545 {"generate_data", 1, generate_data
},
4546 {"get_read", 0, get_read_count
},
4547 {"cleanup", 1, cleanup_pairs
},
4551 test_st consistent_weighted_tests
[] ={
4552 {"generate_pairs", 1, generate_pairs
},
4553 {"generate_data", 1, generate_data_with_stats
},
4554 {"get_read", 0, get_read_count
},
4555 {"cleanup", 1, cleanup_pairs
},
4559 test_st hsieh_availability
[] ={
4560 {"hsieh_avaibility_test",0,hsieh_avaibility_test
},
4564 test_st ketama_auto_eject_hosts
[] ={
4565 {"auto_eject_hosts", 1, auto_eject_hosts
},
4569 test_st hash_tests
[] ={
4570 {"md5", 0, md5_run
},
4571 {"crc", 0, crc_run
},
4572 {"fnv1_64", 0, fnv1_64_run
},
4573 {"fnv1a_64", 0, fnv1a_64_run
},
4574 {"fnv1_32", 0, fnv1_32_run
},
4575 {"fnv1a_32", 0, fnv1a_32_run
},
4576 {"hsieh", 0, hsieh_run
},
4577 {"murmur", 0, murmur_run
},
4578 {"jenkis", 0, jenkins_run
},
4582 collection_st collection
[] ={
4583 {"hsieh_availability",0,0,hsieh_availability
},
4584 {"udp_setup", init_udp
, 0, udp_setup_server_tests
},
4585 {"udp_io", init_udp
, 0, upd_io_tests
},
4586 {"udp_binary_io", binary_init_udp
, 0, upd_io_tests
},
4587 {"block", 0, 0, tests
},
4588 {"binary", pre_binary
, 0, tests
},
4589 {"nonblock", pre_nonblock
, 0, tests
},
4590 {"nodelay", pre_nodelay
, 0, tests
},
4591 {"settimer", pre_settimer
, 0, tests
},
4592 {"md5", pre_md5
, 0, tests
},
4593 {"crc", pre_crc
, 0, tests
},
4594 {"hsieh", pre_hsieh
, 0, tests
},
4595 {"jenkins", pre_jenkins
, 0, tests
},
4596 {"fnv1_64", pre_hash_fnv1_64
, 0, tests
},
4597 {"fnv1a_64", pre_hash_fnv1a_64
, 0, tests
},
4598 {"fnv1_32", pre_hash_fnv1_32
, 0, tests
},
4599 {"fnv1a_32", pre_hash_fnv1a_32
, 0, tests
},
4600 {"ketama", pre_behavior_ketama
, 0, tests
},
4601 {"ketama_auto_eject_hosts", pre_behavior_ketama
, 0, ketama_auto_eject_hosts
},
4602 {"unix_socket", pre_unix_socket
, 0, tests
},
4603 {"unix_socket_nodelay", pre_nodelay
, 0, tests
},
4604 {"poll_timeout", poll_timeout
, 0, tests
},
4605 {"gets", enable_cas
, 0, tests
},
4606 {"consistent", enable_consistent
, 0, tests
},
4607 #ifdef MEMCACHED_ENABLE_DEPRECATED
4608 {"deprecated_memory_allocators", deprecated_set_memory_alloc
, 0, tests
},
4610 {"memory_allocators", set_memory_alloc
, 0, tests
},
4611 {"prefix", set_prefix
, 0, tests
},
4612 {"version_1_2_3", check_for_1_2_3
, 0, version_1_2_3
},
4613 {"string", 0, 0, string_tests
},
4614 {"result", 0, 0, result_tests
},
4615 {"async", pre_nonblock
, 0, async_tests
},
4616 {"async_binary", pre_nonblock_binary
, 0, async_tests
},
4617 {"user", 0, 0, user_tests
},
4618 {"generate", 0, 0, generate_tests
},
4619 {"generate_hsieh", pre_hsieh
, 0, generate_tests
},
4620 {"generate_ketama", pre_behavior_ketama
, 0, generate_tests
},
4621 {"generate_hsieh_consistent", enable_consistent
, 0, generate_tests
},
4622 {"generate_md5", pre_md5
, 0, generate_tests
},
4623 {"generate_murmur", pre_murmur
, 0, generate_tests
},
4624 {"generate_jenkins", pre_jenkins
, 0, generate_tests
},
4625 {"generate_nonblock", pre_nonblock
, 0, generate_tests
},
4626 {"consistent_not", 0, 0, consistent_tests
},
4627 {"consistent_ketama", pre_behavior_ketama
, 0, consistent_tests
},
4628 {"consistent_ketama_weighted", pre_behavior_ketama_weighted
, 0, consistent_weighted_tests
},
4629 {"test_hashes", 0, 0, hash_tests
},
4630 {"replication", pre_replication
, 0, replication_tests
},
4631 {"replication_noblock", pre_replication_noblock
, 0, replication_tests
},
4635 #define SERVERS_TO_CREATE 5
4637 /* Prototypes for functions we will pass to test framework */
4638 void *world_create(void);
4639 void world_destroy(void *p
);
4641 void *world_create(void)
4643 server_startup_st
*construct
;
4645 construct
= (server_startup_st
*)malloc(sizeof(server_startup_st
));
4646 memset(construct
, 0, sizeof(server_startup_st
));
4647 construct
->count
= SERVERS_TO_CREATE
;
4649 server_startup(construct
);
4655 void world_destroy(void *p
)
4657 server_startup_st
*construct
= (server_startup_st
*)p
;
4658 memcached_server_st
*servers
= (memcached_server_st
*)construct
->servers
;
4659 memcached_server_list_free(servers
);
4661 server_shutdown(construct
);
4665 void get_world(world_st
*world
)
4667 world
->collections
= collection
;
4668 world
->create
= world_create
;
4669 world
->destroy
= world_destroy
;