2 Sample test application.
4 #include "libmemcached/common.h"
11 #include <sys/types.h>
16 #include "clients/generator.h"
17 #include "clients/execute.h"
20 #define INT64_MAX LONG_MAX
23 #define INT32_MAX INT_MAX
29 #ifdef HAVE_LIBMEMCACHEDUTIL
31 #include "libmemcached/memcached_util.h"
34 #define GLOBAL_COUNT 10000
35 #define GLOBAL2_COUNT 100
36 #define SERVERS_TO_CREATE 5
37 static uint32_t global_count
;
39 static pairs_st
*global_pairs
;
40 static char *global_keys
[GLOBAL_COUNT
];
41 static size_t global_keys_length
[GLOBAL_COUNT
];
43 static test_return
init_test(memcached_st
*not_used
__attribute__((unused
)))
47 (void)memcached_create(&memc
);
48 memcached_free(&memc
);
53 static test_return
server_list_null_test(memcached_st
*ptr
__attribute__((unused
)))
55 memcached_server_st
*server_list
;
58 server_list
= memcached_server_list_append_with_weight(NULL
, NULL
, 0, 0, NULL
);
59 assert(server_list
== NULL
);
61 server_list
= memcached_server_list_append_with_weight(NULL
, "localhost", 0, 0, NULL
);
62 assert(server_list
== NULL
);
64 server_list
= memcached_server_list_append_with_weight(NULL
, NULL
, 0, 0, &rc
);
65 assert(server_list
== NULL
);
70 #define TEST_PORT_COUNT 7
71 uint32_t test_ports
[TEST_PORT_COUNT
];
73 static memcached_return
server_display_function(memcached_st
*ptr
__attribute__((unused
)), memcached_server_st
*server
, void *context
)
76 uint32_t bigger
= *((uint32_t *)(context
));
77 assert(bigger
<= server
->port
);
78 *((uint32_t *)(context
))= server
->port
;
80 return MEMCACHED_SUCCESS
;
83 static test_return
server_sort_test(memcached_st
*ptr
__attribute__((unused
)))
86 uint32_t bigger
= 0; /* Prime the value for the assert in server_display_function */
88 memcached_server_function callbacks
[1];
89 memcached_st
*local_memc
;
91 local_memc
= memcached_create(NULL
);
93 memcached_behavior_set(local_memc
, MEMCACHED_BEHAVIOR_SORT_HOSTS
, 1);
95 for (x
= 0; x
< TEST_PORT_COUNT
; x
++)
97 test_ports
[x
]= random() % 64000;
98 rc
= memcached_server_add_with_weight(local_memc
, "localhost", test_ports
[x
], 0);
99 assert(local_memc
->number_of_hosts
== x
+ 1);
100 assert(local_memc
->hosts
[0].count
== x
+1);
101 assert(rc
== MEMCACHED_SUCCESS
);
104 callbacks
[0]= server_display_function
;
105 memcached_server_cursor(local_memc
, callbacks
, (void *)&bigger
, 1);
108 memcached_free(local_memc
);
113 static test_return
server_sort2_test(memcached_st
*ptr
__attribute__((unused
)))
115 uint32_t bigger
= 0; /* Prime the value for the assert in server_display_function */
117 memcached_server_function callbacks
[1];
118 memcached_st
*local_memc
;
120 local_memc
= memcached_create(NULL
);
122 rc
= memcached_behavior_set(local_memc
, MEMCACHED_BEHAVIOR_SORT_HOSTS
, 1);
123 assert(rc
== MEMCACHED_SUCCESS
);
125 rc
= memcached_server_add_with_weight(local_memc
, "MEMCACHED_BEHAVIOR_SORT_HOSTS", 43043, 0);
126 assert(rc
== MEMCACHED_SUCCESS
);
127 assert(local_memc
->hosts
[0].port
== 43043);
129 rc
= memcached_server_add_with_weight(local_memc
, "MEMCACHED_BEHAVIOR_SORT_HOSTS", 43042, 0);
130 assert(rc
== MEMCACHED_SUCCESS
);
131 assert(local_memc
->hosts
[0].port
== 43042);
132 assert(local_memc
->hosts
[1].port
== 43043);
134 callbacks
[0]= server_display_function
;
135 memcached_server_cursor(local_memc
, callbacks
, (void *)&bigger
, 1);
138 memcached_free(local_memc
);
143 static memcached_return
server_display_unsort_function(memcached_st
*ptr
__attribute__((unused
)), memcached_server_st
*server
, void *context
)
146 uint32_t x
= *((uint32_t *)(context
));
148 assert(test_ports
[x
] == server
->port
);
149 *((uint32_t *)(context
))= ++x
;
151 return MEMCACHED_SUCCESS
;
154 static test_return
server_unsort_test(memcached_st
*ptr
__attribute__((unused
)))
157 uint32_t counter
= 0; /* Prime the value for the assert in server_display_function */
158 uint32_t bigger
= 0; /* Prime the value for the assert in server_display_function */
160 memcached_server_function callbacks
[1];
161 memcached_st
*local_memc
;
163 local_memc
= memcached_create(NULL
);
166 for (x
= 0; x
< TEST_PORT_COUNT
; x
++)
168 test_ports
[x
]= random() % 64000;
169 rc
= memcached_server_add_with_weight(local_memc
, "localhost", test_ports
[x
], 0);
170 assert(local_memc
->number_of_hosts
== x
+1);
171 assert(local_memc
->hosts
[0].count
== x
+1);
172 assert(rc
== MEMCACHED_SUCCESS
);
175 callbacks
[0]= server_display_unsort_function
;
176 memcached_server_cursor(local_memc
, callbacks
, (void *)&counter
, 1);
178 /* Now we sort old data! */
179 memcached_behavior_set(local_memc
, MEMCACHED_BEHAVIOR_SORT_HOSTS
, 1);
180 callbacks
[0]= server_display_function
;
181 memcached_server_cursor(local_memc
, callbacks
, (void *)&bigger
, 1);
184 memcached_free(local_memc
);
189 static test_return
allocation_test(memcached_st
*not_used
__attribute__((unused
)))
192 memc
= memcached_create(NULL
);
194 memcached_free(memc
);
199 static test_return
clone_test(memcached_st
*memc
)
204 clone
= memcached_clone(NULL
, NULL
);
206 memcached_free(clone
);
209 /* Can we init from null? */
212 clone
= memcached_clone(NULL
, memc
);
215 assert(clone
->call_free
== memc
->call_free
);
216 assert(clone
->call_malloc
== memc
->call_malloc
);
217 assert(clone
->call_realloc
== memc
->call_realloc
);
218 assert(clone
->connect_timeout
== memc
->connect_timeout
);
219 assert(clone
->delete_trigger
== memc
->delete_trigger
);
220 assert(clone
->distribution
== memc
->distribution
);
221 assert(clone
->flags
== memc
->flags
);
222 assert(clone
->get_key_failure
== memc
->get_key_failure
);
223 assert(clone
->hash
== memc
->hash
);
224 assert(clone
->hash_continuum
== memc
->hash_continuum
);
225 assert(clone
->io_bytes_watermark
== memc
->io_bytes_watermark
);
226 assert(clone
->io_msg_watermark
== memc
->io_msg_watermark
);
227 assert(clone
->io_key_prefetch
== memc
->io_key_prefetch
);
228 assert(clone
->on_cleanup
== memc
->on_cleanup
);
229 assert(clone
->on_clone
== memc
->on_clone
);
230 assert(clone
->poll_timeout
== memc
->poll_timeout
);
231 assert(clone
->rcv_timeout
== memc
->rcv_timeout
);
232 assert(clone
->recv_size
== memc
->recv_size
);
233 assert(clone
->retry_timeout
== memc
->retry_timeout
);
234 assert(clone
->send_size
== memc
->send_size
);
235 assert(clone
->server_failure_limit
== memc
->server_failure_limit
);
236 assert(clone
->snd_timeout
== memc
->snd_timeout
);
237 assert(clone
->user_data
== memc
->user_data
);
239 memcached_free(clone
);
242 /* Can we init from struct? */
244 memcached_st declared_clone
;
246 memset(&declared_clone
, 0 , sizeof(memcached_st
));
247 clone
= memcached_clone(&declared_clone
, NULL
);
249 memcached_free(clone
);
252 /* Can we init from struct? */
254 memcached_st declared_clone
;
256 memset(&declared_clone
, 0 , sizeof(memcached_st
));
257 clone
= memcached_clone(&declared_clone
, memc
);
259 memcached_free(clone
);
265 static test_return
connection_test(memcached_st
*memc
)
269 rc
= memcached_server_add_with_weight(memc
, "localhost", 0, 0);
270 assert(rc
== MEMCACHED_SUCCESS
);
275 static test_return
error_test(memcached_st
*memc
)
279 for (rc
= MEMCACHED_SUCCESS
; rc
< MEMCACHED_MAXIMUM_RETURN
; rc
++)
281 printf("Error %d -> %s\n", rc
, memcached_strerror(memc
, rc
));
287 static test_return
set_test(memcached_st
*memc
)
291 char *value
= "when we sanitize";
293 rc
= memcached_set(memc
, key
, strlen(key
),
294 value
, strlen(value
),
295 (time_t)0, (uint32_t)0);
296 assert(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
);
301 static test_return
append_test(memcached_st
*memc
)
309 rc
= memcached_flush(memc
, 0);
310 assert(rc
== MEMCACHED_SUCCESS
);
312 rc
= memcached_set(memc
, key
, strlen(key
),
313 value
, strlen(value
),
314 (time_t)0, (uint32_t)0);
315 assert(rc
== MEMCACHED_SUCCESS
);
317 rc
= memcached_append(memc
, key
, strlen(key
),
318 " the", strlen(" the"),
319 (time_t)0, (uint32_t)0);
320 assert(rc
== MEMCACHED_SUCCESS
);
322 rc
= memcached_append(memc
, key
, strlen(key
),
323 " people", strlen(" people"),
324 (time_t)0, (uint32_t)0);
325 assert(rc
== MEMCACHED_SUCCESS
);
327 value
= memcached_get(memc
, key
, strlen(key
),
328 &value_length
, &flags
, &rc
);
329 assert(!memcmp(value
, "we the people", strlen("we the people")));
330 assert(strlen("we the people") == value_length
);
331 assert(rc
== MEMCACHED_SUCCESS
);
337 static test_return
append_binary_test(memcached_st
*memc
)
340 char *key
= "numbers";
341 unsigned int *store_ptr
;
342 unsigned int store_list
[] = { 23, 56, 499, 98, 32847, 0 };
348 rc
= memcached_flush(memc
, 0);
349 assert(rc
== MEMCACHED_SUCCESS
);
351 rc
= memcached_set(memc
,
354 (time_t)0, (uint32_t)0);
355 assert(rc
== MEMCACHED_SUCCESS
);
357 for (x
= 0; store_list
[x
] ; x
++)
359 rc
= memcached_append(memc
,
361 (char *)&store_list
[x
], sizeof(unsigned int),
362 (time_t)0, (uint32_t)0);
363 assert(rc
== MEMCACHED_SUCCESS
);
366 value
= memcached_get(memc
, key
, strlen(key
),
367 &value_length
, &flags
, &rc
);
368 assert((value_length
== (sizeof(unsigned int) * x
)));
369 assert(rc
== MEMCACHED_SUCCESS
);
371 store_ptr
= (unsigned int *)value
;
373 while ((size_t)store_ptr
< (size_t)(value
+ value_length
))
375 assert(*store_ptr
== store_list
[x
++]);
383 static test_return
cas2_test(memcached_st
*memc
)
386 char *keys
[]= {"fudge", "son", "food"};
387 size_t key_length
[]= {5, 3, 4};
388 char *value
= "we the people";
389 size_t value_length
= strlen("we the people");
391 memcached_result_st results_obj
;
392 memcached_result_st
*results
;
395 rc
= memcached_flush(memc
, 0);
396 assert(rc
== MEMCACHED_SUCCESS
);
398 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_SUPPORT_CAS
, set
);
400 for (x
= 0; x
< 3; x
++)
402 rc
= memcached_set(memc
, keys
[x
], key_length
[x
],
403 keys
[x
], key_length
[x
],
404 (time_t)50, (uint32_t)9);
405 assert(rc
== MEMCACHED_SUCCESS
);
408 rc
= memcached_mget(memc
, keys
, key_length
, 3);
410 results
= memcached_result_create(memc
, &results_obj
);
412 results
= memcached_fetch_result(memc
, &results_obj
, &rc
);
414 assert(results
->cas
);
415 assert(rc
== MEMCACHED_SUCCESS
);
416 WATCHPOINT_ASSERT(memcached_result_cas(results
));
418 assert(!memcmp(value
, "we the people", strlen("we the people")));
419 assert(strlen("we the people") == value_length
);
420 assert(rc
== MEMCACHED_SUCCESS
);
422 memcached_result_free(&results_obj
);
427 static test_return
cas_test(memcached_st
*memc
)
430 const char *key
= "fun";
431 size_t key_length
= strlen(key
);
432 const char *value
= "we the people";
433 char* keys
[2] = { (char*)key
, NULL
};
434 size_t keylengths
[2] = { strlen(key
), 0 };
435 size_t value_length
= strlen(value
);
436 const char *value2
= "change the value";
437 size_t value2_length
= strlen(value2
);
439 memcached_result_st results_obj
;
440 memcached_result_st
*results
;
443 rc
= memcached_flush(memc
, 0);
444 assert(rc
== MEMCACHED_SUCCESS
);
446 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_SUPPORT_CAS
, set
);
448 rc
= memcached_set(memc
, key
, strlen(key
),
449 value
, strlen(value
),
450 (time_t)0, (uint32_t)0);
451 assert(rc
== MEMCACHED_SUCCESS
);
453 rc
= memcached_mget(memc
, keys
, keylengths
, 1);
455 results
= memcached_result_create(memc
, &results_obj
);
457 results
= memcached_fetch_result(memc
, &results_obj
, &rc
);
459 assert(rc
== MEMCACHED_SUCCESS
);
460 WATCHPOINT_ASSERT(memcached_result_cas(results
));
461 assert(!memcmp(value
, memcached_result_value(results
), value_length
));
462 assert(strlen(memcached_result_value(results
)) == value_length
);
463 assert(rc
== MEMCACHED_SUCCESS
);
464 uint64_t cas
= memcached_result_cas(results
);
467 results
= memcached_fetch_result(memc
, &results_obj
, &rc
);
468 assert(rc
== MEMCACHED_END
);
469 assert(results
== NULL
);
472 rc
= memcached_cas(memc
, key
, key_length
, value2
, value2_length
, 0, 0, cas
);
473 assert(rc
== MEMCACHED_SUCCESS
);
476 * The item will have a new cas value, so try to set it again with the old
477 * value. This should fail!
479 rc
= memcached_cas(memc
, key
, key_length
, value2
, value2_length
, 0, 0, cas
);
480 assert(rc
== MEMCACHED_DATA_EXISTS
);
482 memcached_result_free(&results_obj
);
487 static test_return
prepend_test(memcached_st
*memc
)
491 char *value
= "people";
495 rc
= memcached_flush(memc
, 0);
496 assert(rc
== MEMCACHED_SUCCESS
);
498 rc
= memcached_set(memc
, key
, strlen(key
),
499 value
, strlen(value
),
500 (time_t)0, (uint32_t)0);
501 assert(rc
== MEMCACHED_SUCCESS
);
503 rc
= memcached_prepend(memc
, key
, strlen(key
),
504 "the ", strlen("the "),
505 (time_t)0, (uint32_t)0);
506 assert(rc
== MEMCACHED_SUCCESS
);
508 rc
= memcached_prepend(memc
, key
, strlen(key
),
509 "we ", strlen("we "),
510 (time_t)0, (uint32_t)0);
511 assert(rc
== MEMCACHED_SUCCESS
);
513 value
= memcached_get(memc
, key
, strlen(key
),
514 &value_length
, &flags
, &rc
);
515 assert(!memcmp(value
, "we the people", strlen("we the people")));
516 assert(strlen("we the people") == value_length
);
517 assert(rc
== MEMCACHED_SUCCESS
);
524 Set the value, then quit to make sure it is flushed.
525 Come back in and test that add fails.
527 static test_return
add_test(memcached_st
*memc
)
531 char *value
= "when we sanitize";
532 unsigned long long setting_value
;
534 setting_value
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_NO_BLOCK
);
536 rc
= memcached_set(memc
, key
, strlen(key
),
537 value
, strlen(value
),
538 (time_t)0, (uint32_t)0);
539 assert(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
);
540 memcached_quit(memc
);
541 rc
= memcached_add(memc
, key
, strlen(key
),
542 value
, strlen(value
),
543 (time_t)0, (uint32_t)0);
545 /* Too many broken OS'es have broken loopback in async, so we can't be sure of the result */
547 assert(rc
== MEMCACHED_NOTSTORED
|| rc
== MEMCACHED_STORED
);
549 assert(rc
== MEMCACHED_NOTSTORED
|| rc
== MEMCACHED_DATA_EXISTS
);
555 ** There was a problem of leaking filedescriptors in the initial release
556 ** of MacOSX 10.5. This test case triggers the problem. On some Solaris
557 ** systems it seems that the kernel is slow on reclaiming the resources
558 ** because the connects starts to time out (the test doesn't do much
559 ** anyway, so just loop 10 iterations)
561 static test_return
add_wrapper(memcached_st
*memc
)
564 unsigned int max
= 10000;
569 for (x
= 0; x
< max
; x
++)
575 static test_return
replace_test(memcached_st
*memc
)
579 char *value
= "when we sanitize";
580 char *original
= "first we insert some data";
582 rc
= memcached_set(memc
, key
, strlen(key
),
583 original
, strlen(original
),
584 (time_t)0, (uint32_t)0);
585 assert(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
);
587 rc
= memcached_replace(memc
, key
, strlen(key
),
588 value
, strlen(value
),
589 (time_t)0, (uint32_t)0);
590 assert(rc
== MEMCACHED_SUCCESS
);
595 static test_return
delete_test(memcached_st
*memc
)
599 char *value
= "when we sanitize";
601 rc
= memcached_set(memc
, key
, strlen(key
),
602 value
, strlen(value
),
603 (time_t)0, (uint32_t)0);
604 assert(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
);
606 rc
= memcached_delete(memc
, key
, strlen(key
), (time_t)0);
607 assert(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
);
612 static test_return
flush_test(memcached_st
*memc
)
616 rc
= memcached_flush(memc
, 0);
617 assert(rc
== MEMCACHED_SUCCESS
);
622 static memcached_return
server_function(memcached_st
*ptr
__attribute__((unused
)),
623 memcached_server_st
*server
__attribute__((unused
)),
624 void *context
__attribute__((unused
)))
628 return MEMCACHED_SUCCESS
;
631 static test_return
memcached_server_cursor_test(memcached_st
*memc
)
633 char *context
= "foo bad";
634 memcached_server_function callbacks
[1];
636 callbacks
[0]= server_function
;
637 memcached_server_cursor(memc
, callbacks
, context
, 1);
642 static test_return
bad_key_test(memcached_st
*memc
)
645 char *key
= "foo bad";
647 size_t string_length
;
651 size_t max_keylen
= 0xffff;
653 clone
= memcached_clone(NULL
, memc
);
656 rc
= memcached_behavior_set(clone
, MEMCACHED_BEHAVIOR_VERIFY_KEY
, set
);
657 assert(rc
== MEMCACHED_SUCCESS
);
659 /* All keys are valid in the binary protocol (except for length) */
660 if (memcached_behavior_get(clone
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
) == 0)
662 string
= memcached_get(clone
, key
, strlen(key
),
663 &string_length
, &flags
, &rc
);
664 assert(rc
== MEMCACHED_BAD_KEY_PROVIDED
);
665 assert(string_length
== 0);
669 rc
= memcached_behavior_set(clone
, MEMCACHED_BEHAVIOR_VERIFY_KEY
, set
);
670 assert(rc
== MEMCACHED_SUCCESS
);
671 string
= memcached_get(clone
, key
, strlen(key
),
672 &string_length
, &flags
, &rc
);
673 assert(rc
== MEMCACHED_NOTFOUND
);
674 assert(string_length
== 0);
677 /* Test multi key for bad keys */
678 char *keys
[] = { "GoodKey", "Bad Key", "NotMine" };
679 size_t key_lengths
[] = { 7, 7, 7 };
681 rc
= memcached_behavior_set(clone
, MEMCACHED_BEHAVIOR_VERIFY_KEY
, set
);
682 assert(rc
== MEMCACHED_SUCCESS
);
684 rc
= memcached_mget(clone
, keys
, key_lengths
, 3);
685 assert(rc
== MEMCACHED_BAD_KEY_PROVIDED
);
687 rc
= memcached_mget_by_key(clone
, "foo daddy", 9, keys
, key_lengths
, 1);
688 assert(rc
== MEMCACHED_BAD_KEY_PROVIDED
);
692 /* The following test should be moved to the end of this function when the
693 memcached server is updated to allow max size length of the keys in the
696 rc
= memcached_callback_set(clone
, MEMCACHED_CALLBACK_PREFIX_KEY
, NULL
);
697 assert(rc
== MEMCACHED_SUCCESS
);
699 char *longkey
= malloc(max_keylen
+ 1);
702 memset(longkey
, 'a', max_keylen
+ 1);
703 string
= memcached_get(clone
, longkey
, max_keylen
,
704 &string_length
, &flags
, &rc
);
705 assert(rc
== MEMCACHED_NOTFOUND
);
706 assert(string_length
== 0);
709 string
= memcached_get(clone
, longkey
, max_keylen
+ 1,
710 &string_length
, &flags
, &rc
);
711 assert(rc
== MEMCACHED_BAD_KEY_PROVIDED
);
712 assert(string_length
== 0);
719 /* Make sure zero length keys are marked as bad */
721 rc
= memcached_behavior_set(clone
, MEMCACHED_BEHAVIOR_VERIFY_KEY
, set
);
722 assert(rc
== MEMCACHED_SUCCESS
);
723 string
= memcached_get(clone
, key
, 0,
724 &string_length
, &flags
, &rc
);
725 assert(rc
== MEMCACHED_BAD_KEY_PROVIDED
);
726 assert(string_length
== 0);
729 memcached_free(clone
);
734 #define READ_THROUGH_VALUE "set for me"
735 static memcached_return
read_through_trigger(memcached_st
*memc
__attribute__((unused
)),
736 char *key
__attribute__((unused
)),
737 size_t key_length
__attribute__((unused
)),
738 memcached_result_st
*result
)
741 return memcached_result_set_value(result
, READ_THROUGH_VALUE
, strlen(READ_THROUGH_VALUE
));
744 static test_return
read_through(memcached_st
*memc
)
749 size_t string_length
;
751 memcached_trigger_key cb
= (memcached_trigger_key
)read_through_trigger
;
753 string
= memcached_get(memc
, key
, strlen(key
),
754 &string_length
, &flags
, &rc
);
756 assert(rc
== MEMCACHED_NOTFOUND
);
757 assert(string_length
== 0);
760 rc
= memcached_callback_set(memc
, MEMCACHED_CALLBACK_GET_FAILURE
,
762 assert(rc
== MEMCACHED_SUCCESS
);
764 string
= memcached_get(memc
, key
, strlen(key
),
765 &string_length
, &flags
, &rc
);
767 assert(rc
== MEMCACHED_SUCCESS
);
768 assert(string_length
== strlen(READ_THROUGH_VALUE
));
769 assert(!strcmp(READ_THROUGH_VALUE
, string
));
772 string
= memcached_get(memc
, key
, strlen(key
),
773 &string_length
, &flags
, &rc
);
775 assert(rc
== MEMCACHED_SUCCESS
);
776 assert(string_length
== strlen(READ_THROUGH_VALUE
));
777 assert(!strcmp(READ_THROUGH_VALUE
, string
));
783 static memcached_return
delete_trigger(memcached_st
*ptr
__attribute__((unused
)),
785 size_t key_length
__attribute__((unused
)))
789 return MEMCACHED_SUCCESS
;
792 static test_return
delete_through(memcached_st
*memc
)
794 memcached_trigger_delete_key callback
;
797 callback
= (memcached_trigger_delete_key
)delete_trigger
;
799 rc
= memcached_callback_set(memc
, MEMCACHED_CALLBACK_DELETE_TRIGGER
, *(void**)&callback
);
800 assert(rc
== MEMCACHED_SUCCESS
);
805 static test_return
get_test(memcached_st
*memc
)
810 size_t string_length
;
813 rc
= memcached_delete(memc
, key
, strlen(key
), (time_t)0);
814 assert(rc
== MEMCACHED_BUFFERED
|| rc
== MEMCACHED_NOTFOUND
);
816 string
= memcached_get(memc
, key
, strlen(key
),
817 &string_length
, &flags
, &rc
);
819 assert(rc
== MEMCACHED_NOTFOUND
);
820 assert(string_length
== 0);
826 static test_return
get_test2(memcached_st
*memc
)
830 char *value
= "when we sanitize";
832 size_t string_length
;
835 rc
= memcached_set(memc
, key
, strlen(key
),
836 value
, strlen(value
),
837 (time_t)0, (uint32_t)0);
838 assert(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
);
840 string
= memcached_get(memc
, key
, strlen(key
),
841 &string_length
, &flags
, &rc
);
844 assert(rc
== MEMCACHED_SUCCESS
);
845 assert(string_length
== strlen(value
));
846 assert(!memcmp(string
, value
, string_length
));
853 static test_return
set_test2(memcached_st
*memc
)
857 char *value
= "train in the brain";
858 size_t value_length
= strlen(value
);
861 for (x
= 0; x
< 10; x
++)
863 rc
= memcached_set(memc
, key
, strlen(key
),
865 (time_t)0, (uint32_t)0);
866 assert(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
);
872 static test_return
set_test3(memcached_st
*memc
)
877 size_t value_length
= 8191;
880 value
= (char*)malloc(value_length
);
883 for (x
= 0; x
< value_length
; x
++)
884 value
[x
] = (char) (x
% 127);
886 for (x
= 0; x
< 1; x
++)
888 rc
= memcached_set(memc
, key
, strlen(key
),
890 (time_t)0, (uint32_t)0);
891 assert(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
);
899 static test_return
get_test3(memcached_st
*memc
)
904 size_t value_length
= 8191;
906 size_t string_length
;
910 value
= (char*)malloc(value_length
);
913 for (x
= 0; x
< value_length
; x
++)
914 value
[x
] = (char) (x
% 127);
916 rc
= memcached_set(memc
, key
, strlen(key
),
918 (time_t)0, (uint32_t)0);
919 assert(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
);
921 string
= memcached_get(memc
, key
, strlen(key
),
922 &string_length
, &flags
, &rc
);
924 assert(rc
== MEMCACHED_SUCCESS
);
926 assert(string_length
== value_length
);
927 assert(!memcmp(string
, value
, string_length
));
935 static test_return
get_test4(memcached_st
*memc
)
940 size_t value_length
= 8191;
942 size_t string_length
;
946 value
= (char*)malloc(value_length
);
949 for (x
= 0; x
< value_length
; x
++)
950 value
[x
] = (char) (x
% 127);
952 rc
= memcached_set(memc
, key
, strlen(key
),
954 (time_t)0, (uint32_t)0);
955 assert(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
);
957 for (x
= 0; x
< 10; x
++)
959 string
= memcached_get(memc
, key
, strlen(key
),
960 &string_length
, &flags
, &rc
);
962 assert(rc
== MEMCACHED_SUCCESS
);
964 assert(string_length
== value_length
);
965 assert(!memcmp(string
, value
, string_length
));
975 * This test verifies that memcached_read_one_response doesn't try to
976 * dereference a NIL-pointer if you issue a multi-get and don't read out all
977 * responses before you execute a storage command.
979 static test_return
get_test5(memcached_st
*memc
)
982 ** Request the same key twice, to ensure that we hash to the same server
983 ** (so that we have multiple response values queued up) ;-)
985 char *keys
[]= { "key", "key" };
986 size_t lengths
[]= { 3, 3 };
990 memcached_return rc
= memcached_set(memc
, keys
[0], lengths
[0],
991 keys
[0], lengths
[0], 0, 0);
992 assert(rc
== MEMCACHED_SUCCESS
);
993 rc
= memcached_mget(memc
, keys
, lengths
, 2);
995 memcached_result_st results_obj
;
996 memcached_result_st
*results
;
997 results
=memcached_result_create(memc
, &results_obj
);
999 results
=memcached_fetch_result(memc
, &results_obj
, &rc
);
1001 memcached_result_free(&results_obj
);
1003 /* Don't read out the second result, but issue a set instead.. */
1004 rc
= memcached_set(memc
, keys
[0], lengths
[0], keys
[0], lengths
[0], 0, 0);
1005 assert(rc
== MEMCACHED_SUCCESS
);
1007 char *val
= memcached_get_by_key(memc
, keys
[0], lengths
[0], "yek", 3,
1008 &rlen
, &flags
, &rc
);
1009 assert(val
== NULL
);
1010 assert(rc
== MEMCACHED_NOTFOUND
);
1011 val
= memcached_get(memc
, keys
[0], lengths
[0], &rlen
, &flags
, &rc
);
1012 assert(val
!= NULL
);
1013 assert(rc
== MEMCACHED_SUCCESS
);
1016 return TEST_SUCCESS
;
1019 /* Do not copy the style of this code, I just access hosts to testthis function */
1020 static test_return
stats_servername_test(memcached_st
*memc
)
1022 memcached_return rc
;
1023 memcached_stat_st stat
;
1024 rc
= memcached_stat_servername(&stat
, NULL
,
1025 memc
->hosts
[0].hostname
,
1026 memc
->hosts
[0].port
);
1031 static test_return
increment_test(memcached_st
*memc
)
1033 uint64_t new_number
;
1034 memcached_return rc
;
1035 char *key
= "number";
1038 rc
= memcached_set(memc
, key
, strlen(key
),
1039 value
, strlen(value
),
1040 (time_t)0, (uint32_t)0);
1041 assert(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
);
1043 rc
= memcached_increment(memc
, key
, strlen(key
),
1045 assert(rc
== MEMCACHED_SUCCESS
);
1046 assert(new_number
== 1);
1048 rc
= memcached_increment(memc
, key
, strlen(key
),
1050 assert(rc
== MEMCACHED_SUCCESS
);
1051 assert(new_number
== 2);
1056 static test_return
increment_with_initial_test(memcached_st
*memc
)
1058 if (memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
) != 0)
1060 uint64_t new_number
;
1061 memcached_return rc
;
1062 char *key
= "number";
1063 uint64_t initial
= 0;
1065 rc
= memcached_increment_with_initial(memc
, key
, strlen(key
),
1066 1, initial
, 0, &new_number
);
1067 assert(rc
== MEMCACHED_SUCCESS
);
1068 assert(new_number
== initial
);
1070 rc
= memcached_increment_with_initial(memc
, key
, strlen(key
),
1071 1, initial
, 0, &new_number
);
1072 assert(rc
== MEMCACHED_SUCCESS
);
1073 assert(new_number
== (initial
+ 1));
1078 static test_return
decrement_test(memcached_st
*memc
)
1080 uint64_t new_number
;
1081 memcached_return rc
;
1082 char *key
= "number";
1085 rc
= memcached_set(memc
, key
, strlen(key
),
1086 value
, strlen(value
),
1087 (time_t)0, (uint32_t)0);
1088 assert(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
);
1090 rc
= memcached_decrement(memc
, key
, strlen(key
),
1092 assert(rc
== MEMCACHED_SUCCESS
);
1093 assert(new_number
== 2);
1095 rc
= memcached_decrement(memc
, key
, strlen(key
),
1097 assert(rc
== MEMCACHED_SUCCESS
);
1098 assert(new_number
== 1);
1103 static test_return
decrement_with_initial_test(memcached_st
*memc
)
1105 if (memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
) != 0)
1107 uint64_t new_number
;
1108 memcached_return rc
;
1109 char *key
= "number";
1110 uint64_t initial
= 3;
1112 rc
= memcached_decrement_with_initial(memc
, key
, strlen(key
),
1113 1, initial
, 0, &new_number
);
1114 assert(rc
== MEMCACHED_SUCCESS
);
1115 assert(new_number
== initial
);
1117 rc
= memcached_decrement_with_initial(memc
, key
, strlen(key
),
1118 1, initial
, 0, &new_number
);
1119 assert(rc
== MEMCACHED_SUCCESS
);
1120 assert(new_number
== (initial
- 1));
1125 static test_return
quit_test(memcached_st
*memc
)
1127 memcached_return rc
;
1129 char *value
= "sanford and sun";
1131 rc
= memcached_set(memc
, key
, strlen(key
),
1132 value
, strlen(value
),
1133 (time_t)10, (uint32_t)3);
1134 assert(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
);
1135 memcached_quit(memc
);
1137 rc
= memcached_set(memc
, key
, strlen(key
),
1138 value
, strlen(value
),
1139 (time_t)50, (uint32_t)9);
1140 assert(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
);
1145 static test_return
mget_result_test(memcached_st
*memc
)
1147 memcached_return rc
;
1148 char *keys
[]= {"fudge", "son", "food"};
1149 size_t key_length
[]= {5, 3, 4};
1152 memcached_result_st results_obj
;
1153 memcached_result_st
*results
;
1155 results
= memcached_result_create(memc
, &results_obj
);
1157 assert(&results_obj
== results
);
1159 /* We need to empty the server before continueing test */
1160 rc
= memcached_flush(memc
, 0);
1161 assert(rc
== MEMCACHED_SUCCESS
);
1163 rc
= memcached_mget(memc
, keys
, key_length
, 3);
1164 assert(rc
== MEMCACHED_SUCCESS
);
1166 while ((results
= memcached_fetch_result(memc
, &results_obj
, &rc
)) != NULL
)
1171 while ((results
= memcached_fetch_result(memc
, &results_obj
, &rc
)) != NULL
)
1173 assert(rc
== MEMCACHED_END
);
1175 for (x
= 0; x
< 3; x
++)
1177 rc
= memcached_set(memc
, keys
[x
], key_length
[x
],
1178 keys
[x
], key_length
[x
],
1179 (time_t)50, (uint32_t)9);
1180 assert(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
);
1183 rc
= memcached_mget(memc
, keys
, key_length
, 3);
1184 assert(rc
== MEMCACHED_SUCCESS
);
1186 while ((results
= memcached_fetch_result(memc
, &results_obj
, &rc
)))
1189 assert(&results_obj
== results
);
1190 assert(rc
== MEMCACHED_SUCCESS
);
1191 assert(memcached_result_key_length(results
) == memcached_result_length(results
));
1192 assert(!memcmp(memcached_result_key_value(results
),
1193 memcached_result_value(results
),
1194 memcached_result_length(results
)));
1197 memcached_result_free(&results_obj
);
1202 static test_return
mget_result_alloc_test(memcached_st
*memc
)
1204 memcached_return rc
;
1205 char *keys
[]= {"fudge", "son", "food"};
1206 size_t key_length
[]= {5, 3, 4};
1209 memcached_result_st
*results
;
1211 /* We need to empty the server before continueing test */
1212 rc
= memcached_flush(memc
, 0);
1213 assert(rc
== MEMCACHED_SUCCESS
);
1215 rc
= memcached_mget(memc
, keys
, key_length
, 3);
1216 assert(rc
== MEMCACHED_SUCCESS
);
1218 while ((results
= memcached_fetch_result(memc
, NULL
, &rc
)) != NULL
)
1223 assert(rc
== MEMCACHED_END
);
1225 for (x
= 0; x
< 3; x
++)
1227 rc
= memcached_set(memc
, keys
[x
], key_length
[x
],
1228 keys
[x
], key_length
[x
],
1229 (time_t)50, (uint32_t)9);
1230 assert(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
);
1233 rc
= memcached_mget(memc
, keys
, key_length
, 3);
1234 assert(rc
== MEMCACHED_SUCCESS
);
1237 while ((results
= memcached_fetch_result(memc
, NULL
, &rc
)))
1240 assert(rc
== MEMCACHED_SUCCESS
);
1241 assert(memcached_result_key_length(results
) == memcached_result_length(results
));
1242 assert(!memcmp(memcached_result_key_value(results
),
1243 memcached_result_value(results
),
1244 memcached_result_length(results
)));
1245 memcached_result_free(results
);
1252 /* Count the results */
1253 static memcached_return
callback_counter(memcached_st
*ptr
__attribute__((unused
)),
1254 memcached_result_st
*result
__attribute__((unused
)),
1257 unsigned int *counter
= (unsigned int *)context
;
1259 *counter
= *counter
+ 1;
1261 return MEMCACHED_SUCCESS
;
1264 static test_return
mget_result_function(memcached_st
*memc
)
1266 memcached_return rc
;
1267 char *keys
[]= {"fudge", "son", "food"};
1268 size_t key_length
[]= {5, 3, 4};
1270 unsigned int counter
;
1271 memcached_execute_function callbacks
[1];
1273 /* We need to empty the server before continueing test */
1274 rc
= memcached_flush(memc
, 0);
1275 for (x
= 0; x
< 3; x
++)
1277 rc
= memcached_set(memc
, keys
[x
], key_length
[x
],
1278 keys
[x
], key_length
[x
],
1279 (time_t)50, (uint32_t)9);
1280 assert(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
);
1283 rc
= memcached_mget(memc
, keys
, key_length
, 3);
1284 assert(rc
== MEMCACHED_SUCCESS
);
1286 callbacks
[0]= &callback_counter
;
1288 rc
= memcached_fetch_execute(memc
, callbacks
, (void *)&counter
, 1);
1290 assert(counter
== 3);
1295 static test_return
mget_test(memcached_st
*memc
)
1297 memcached_return rc
;
1298 char *keys
[]= {"fudge", "son", "food"};
1299 size_t key_length
[]= {5, 3, 4};
1303 char return_key
[MEMCACHED_MAX_KEY
];
1304 size_t return_key_length
;
1306 size_t return_value_length
;
1308 /* We need to empty the server before continueing test */
1309 rc
= memcached_flush(memc
, 0);
1310 assert(rc
== MEMCACHED_SUCCESS
);
1312 rc
= memcached_mget(memc
, keys
, key_length
, 3);
1313 assert(rc
== MEMCACHED_SUCCESS
);
1315 while ((return_value
= memcached_fetch(memc
, return_key
, &return_key_length
,
1316 &return_value_length
, &flags
, &rc
)) != NULL
)
1318 assert(return_value
);
1320 assert(!return_value
);
1321 assert(return_value_length
== 0);
1322 assert(rc
== MEMCACHED_END
);
1324 for (x
= 0; x
< 3; x
++)
1326 rc
= memcached_set(memc
, keys
[x
], key_length
[x
],
1327 keys
[x
], key_length
[x
],
1328 (time_t)50, (uint32_t)9);
1329 assert(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
);
1332 rc
= memcached_mget(memc
, keys
, key_length
, 3);
1333 assert(rc
== MEMCACHED_SUCCESS
);
1336 while ((return_value
= memcached_fetch(memc
, return_key
, &return_key_length
,
1337 &return_value_length
, &flags
, &rc
)))
1339 assert(return_value
);
1340 assert(rc
== MEMCACHED_SUCCESS
);
1341 assert(return_key_length
== return_value_length
);
1342 assert(!memcmp(return_value
, return_key
, return_value_length
));
1350 static test_return
get_stats_keys(memcached_st
*memc
)
1354 memcached_stat_st stat
;
1355 memcached_return rc
;
1357 list
= memcached_stat_get_keys(memc
, &stat
, &rc
);
1358 assert(rc
== MEMCACHED_SUCCESS
);
1359 for (ptr
= list
; *ptr
; ptr
++)
1368 static test_return
version_string_test(memcached_st
*memc
__attribute__((unused
)))
1370 const char *version_string
;
1372 version_string
= memcached_lib_version();
1374 assert(!strcmp(version_string
, LIBMEMCACHED_VERSION_STRING
));
1379 static test_return
get_stats(memcached_st
*memc
)
1384 memcached_return rc
;
1385 memcached_stat_st
*stat
;
1387 stat
= memcached_stat(memc
, NULL
, &rc
);
1388 assert(rc
== MEMCACHED_SUCCESS
);
1390 assert(rc
== MEMCACHED_SUCCESS
);
1393 for (x
= 0; x
< memcached_server_count(memc
); x
++)
1395 list
= memcached_stat_get_keys(memc
, stat
+x
, &rc
);
1396 assert(rc
== MEMCACHED_SUCCESS
);
1397 for (ptr
= list
; *ptr
; ptr
++);
1402 memcached_stat_free(NULL
, stat
);
1407 static test_return
add_host_test(memcached_st
*memc
)
1410 memcached_server_st
*servers
;
1411 memcached_return rc
;
1412 char servername
[]= "0.example.com";
1414 servers
= memcached_server_list_append_with_weight(NULL
, servername
, 400, 0, &rc
);
1416 assert(1 == memcached_server_list_count(servers
));
1418 for (x
= 2; x
< 20; x
++)
1420 char buffer
[SMALL_STRING_LEN
];
1422 snprintf(buffer
, SMALL_STRING_LEN
, "%u.example.com", 400+x
);
1423 servers
= memcached_server_list_append_with_weight(servers
, buffer
, 401, 0,
1425 assert(rc
== MEMCACHED_SUCCESS
);
1426 assert(x
== memcached_server_list_count(servers
));
1429 rc
= memcached_server_push(memc
, servers
);
1430 assert(rc
== MEMCACHED_SUCCESS
);
1431 rc
= memcached_server_push(memc
, servers
);
1432 assert(rc
== MEMCACHED_SUCCESS
);
1434 memcached_server_list_free(servers
);
1439 static memcached_return
clone_test_callback(memcached_st
*parent
__attribute__((unused
)), memcached_st
*clone
__attribute__((unused
)))
1441 return MEMCACHED_SUCCESS
;
1444 static memcached_return
cleanup_test_callback(memcached_st
*ptr
__attribute__((unused
)))
1446 return MEMCACHED_SUCCESS
;
1449 static test_return
callback_test(memcached_st
*memc
)
1451 /* Test User Data */
1455 memcached_return rc
;
1457 rc
= memcached_callback_set(memc
, MEMCACHED_CALLBACK_USER_DATA
, &x
);
1458 assert(rc
== MEMCACHED_SUCCESS
);
1459 test_ptr
= (int *)memcached_callback_get(memc
, MEMCACHED_CALLBACK_USER_DATA
, &rc
);
1460 assert(*test_ptr
== x
);
1463 /* Test Clone Callback */
1465 memcached_clone_func clone_cb
= (memcached_clone_func
)clone_test_callback
;
1466 void *clone_cb_ptr
= *(void **)&clone_cb
;
1467 void *temp_function
= NULL
;
1468 memcached_return rc
;
1470 rc
= memcached_callback_set(memc
, MEMCACHED_CALLBACK_CLONE_FUNCTION
,
1472 assert(rc
== MEMCACHED_SUCCESS
);
1473 temp_function
= memcached_callback_get(memc
, MEMCACHED_CALLBACK_CLONE_FUNCTION
, &rc
);
1474 assert(temp_function
== clone_cb_ptr
);
1477 /* Test Cleanup Callback */
1479 memcached_cleanup_func cleanup_cb
=
1480 (memcached_cleanup_func
)cleanup_test_callback
;
1481 void *cleanup_cb_ptr
= *(void **)&cleanup_cb
;
1482 void *temp_function
= NULL
;
1483 memcached_return rc
;
1485 rc
= memcached_callback_set(memc
, MEMCACHED_CALLBACK_CLONE_FUNCTION
,
1487 assert(rc
== MEMCACHED_SUCCESS
);
1488 temp_function
= memcached_callback_get(memc
, MEMCACHED_CALLBACK_CLONE_FUNCTION
, &rc
);
1489 assert(temp_function
== cleanup_cb_ptr
);
1495 /* We don't test the behavior itself, we test the switches */
1496 static test_return
behavior_test(memcached_st
*memc
)
1501 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NO_BLOCK
, set
);
1502 value
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_NO_BLOCK
);
1505 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_TCP_NODELAY
, set
);
1506 value
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_TCP_NODELAY
);
1509 set
= MEMCACHED_HASH_MD5
;
1510 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_HASH
, set
);
1511 value
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_HASH
);
1512 assert(value
== MEMCACHED_HASH_MD5
);
1516 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NO_BLOCK
, set
);
1517 value
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_NO_BLOCK
);
1520 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_TCP_NODELAY
, set
);
1521 value
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_TCP_NODELAY
);
1524 set
= MEMCACHED_HASH_DEFAULT
;
1525 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_HASH
, set
);
1526 value
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_HASH
);
1527 assert(value
== MEMCACHED_HASH_DEFAULT
);
1529 set
= MEMCACHED_HASH_CRC
;
1530 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_HASH
, set
);
1531 value
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_HASH
);
1532 assert(value
== MEMCACHED_HASH_CRC
);
1534 value
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_SOCKET_SEND_SIZE
);
1537 value
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_SOCKET_RECV_SIZE
);
1543 /* Test case provided by Cal Haldenbrand */
1544 static test_return
user_supplied_bug1(memcached_st
*memc
)
1546 unsigned int setter
= 1;
1549 unsigned long long total
= 0;
1552 char randomstuff
[6 * 1024];
1553 memcached_return rc
;
1555 memset(randomstuff
, 0, 6 * 1024);
1557 /* We just keep looking at the same values over and over */
1560 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NO_BLOCK
, setter
);
1561 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_TCP_NODELAY
, setter
);
1565 for (x
= 0 ; total
< 20 * 1024576 ; x
++ )
1569 size
= (rand() % ( 5 * 1024 ) ) + 400;
1570 memset(randomstuff
, 0, 6 * 1024);
1571 assert(size
< 6 * 1024); /* Being safe here */
1573 for (j
= 0 ; j
< size
;j
++)
1574 randomstuff
[j
] = (char) (rand() % 26) + 97;
1577 sprintf(key
, "%d", x
);
1578 rc
= memcached_set(memc
, key
, strlen(key
),
1579 randomstuff
, strlen(randomstuff
), 10, 0);
1580 assert(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
);
1581 /* If we fail, lets try again */
1582 if (rc
!= MEMCACHED_SUCCESS
&& rc
!= MEMCACHED_BUFFERED
)
1583 rc
= memcached_set(memc
, key
, strlen(key
),
1584 randomstuff
, strlen(randomstuff
), 10, 0);
1585 assert(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
);
1591 /* Test case provided by Cal Haldenbrand */
1592 static test_return
user_supplied_bug2(memcached_st
*memc
)
1595 unsigned int setter
;
1597 unsigned long long total
;
1600 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NO_BLOCK
, setter
);
1601 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_TCP_NODELAY
, setter
);
1603 setter
= 20 * 1024576;
1604 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_SOCKET_SEND_SIZE
, setter
);
1605 setter
= 20 * 1024576;
1606 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_SOCKET_RECV_SIZE
, setter
);
1607 getter
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_SOCKET_SEND_SIZE
);
1608 getter
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_SOCKET_RECV_SIZE
);
1610 for (x
= 0, errors
= 0, total
= 0 ; total
< 20 * 1024576 ; x
++)
1613 for (x
= 0, errors
= 0, total
= 0 ; total
< 24576 ; x
++)
1615 memcached_return rc
= MEMCACHED_SUCCESS
;
1616 char buffer
[SMALL_STRING_LEN
];
1621 memset(buffer
, 0, SMALL_STRING_LEN
);
1623 snprintf(buffer
, SMALL_STRING_LEN
, "%u", x
);
1624 getval
= memcached_get(memc
, buffer
, strlen(buffer
),
1625 &val_len
, &flags
, &rc
);
1626 if (rc
!= MEMCACHED_SUCCESS
)
1628 if (rc
== MEMCACHED_NOTFOUND
)
1632 WATCHPOINT_ERROR(rc
);
1646 /* Do a large mget() over all the keys we think exist */
1647 #define KEY_COUNT 3000 // * 1024576
1648 static test_return
user_supplied_bug3(memcached_st
*memc
)
1650 memcached_return rc
;
1651 unsigned int setter
;
1654 size_t key_lengths
[KEY_COUNT
];
1657 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NO_BLOCK
, setter
);
1658 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_TCP_NODELAY
, setter
);
1660 setter
= 20 * 1024576;
1661 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_SOCKET_SEND_SIZE
, setter
);
1662 setter
= 20 * 1024576;
1663 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_SOCKET_RECV_SIZE
, setter
);
1664 getter
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_SOCKET_SEND_SIZE
);
1665 getter
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_SOCKET_RECV_SIZE
);
1668 keys
= (char **)malloc(sizeof(char *) * KEY_COUNT
);
1670 memset(keys
, 0, (sizeof(char *) * KEY_COUNT
));
1671 for (x
= 0; x
< KEY_COUNT
; x
++)
1675 snprintf(buffer
, 30, "%u", x
);
1676 keys
[x
]= strdup(buffer
);
1677 key_lengths
[x
]= strlen(keys
[x
]);
1680 rc
= memcached_mget(memc
, keys
, key_lengths
, KEY_COUNT
);
1681 assert(rc
== MEMCACHED_SUCCESS
);
1683 /* Turn this into a help function */
1685 char return_key
[MEMCACHED_MAX_KEY
];
1686 size_t return_key_length
;
1688 size_t return_value_length
;
1691 while ((return_value
= memcached_fetch(memc
, return_key
, &return_key_length
,
1692 &return_value_length
, &flags
, &rc
)))
1694 assert(return_value
);
1695 assert(rc
== MEMCACHED_SUCCESS
);
1700 for (x
= 0; x
< KEY_COUNT
; x
++)
1707 /* Make sure we behave properly if server list has no values */
1708 static test_return
user_supplied_bug4(memcached_st
*memc
)
1710 memcached_return rc
;
1711 char *keys
[]= {"fudge", "son", "food"};
1712 size_t key_length
[]= {5, 3, 4};
1715 char return_key
[MEMCACHED_MAX_KEY
];
1716 size_t return_key_length
;
1718 size_t return_value_length
;
1720 /* Here we free everything before running a bunch of mget tests */
1722 memcached_server_list_free(memc
->hosts
);
1724 memc
->number_of_hosts
= 0;
1728 /* We need to empty the server before continueing test */
1729 rc
= memcached_flush(memc
, 0);
1730 assert(rc
== MEMCACHED_NO_SERVERS
);
1732 rc
= memcached_mget(memc
, keys
, key_length
, 3);
1733 assert(rc
== MEMCACHED_NO_SERVERS
);
1735 while ((return_value
= memcached_fetch(memc
, return_key
, &return_key_length
,
1736 &return_value_length
, &flags
, &rc
)) != NULL
)
1738 assert(return_value
);
1740 assert(!return_value
);
1741 assert(return_value_length
== 0);
1742 assert(rc
== MEMCACHED_NO_SERVERS
);
1744 for (x
= 0; x
< 3; x
++)
1746 rc
= memcached_set(memc
, keys
[x
], key_length
[x
],
1747 keys
[x
], key_length
[x
],
1748 (time_t)50, (uint32_t)9);
1749 assert(rc
== MEMCACHED_NO_SERVERS
);
1752 rc
= memcached_mget(memc
, keys
, key_length
, 3);
1753 assert(rc
== MEMCACHED_NO_SERVERS
);
1756 while ((return_value
= memcached_fetch(memc
, return_key
, &return_key_length
,
1757 &return_value_length
, &flags
, &rc
)))
1759 assert(return_value
);
1760 assert(rc
== MEMCACHED_SUCCESS
);
1761 assert(return_key_length
== return_value_length
);
1762 assert(!memcmp(return_value
, return_key
, return_value_length
));
1770 #define VALUE_SIZE_BUG5 1048064
1771 static test_return
user_supplied_bug5(memcached_st
*memc
)
1773 memcached_return rc
;
1774 char *keys
[]= {"036790384900", "036790384902", "036790384904", "036790384906"};
1775 size_t key_length
[]= {strlen("036790384900"), strlen("036790384902"), strlen("036790384904"), strlen("036790384906")};
1776 char return_key
[MEMCACHED_MAX_KEY
];
1777 size_t return_key_length
;
1779 size_t value_length
;
1783 char insert_data
[VALUE_SIZE_BUG5
];
1785 for (x
= 0; x
< VALUE_SIZE_BUG5
; x
++)
1786 insert_data
[x
]= rand();
1788 memcached_flush(memc
, 0);
1789 value
= memcached_get(memc
, keys
[0], key_length
[0],
1790 &value_length
, &flags
, &rc
);
1791 assert(value
== NULL
);
1792 rc
= memcached_mget(memc
, keys
, key_length
, 4);
1795 while ((value
= memcached_fetch(memc
, return_key
, &return_key_length
,
1796 &value_length
, &flags
, &rc
)))
1800 for (x
= 0; x
< 4; x
++)
1802 rc
= memcached_set(memc
, keys
[x
], key_length
[x
],
1803 insert_data
, VALUE_SIZE_BUG5
,
1804 (time_t)0, (uint32_t)0);
1805 assert(rc
== MEMCACHED_SUCCESS
);
1808 for (x
= 0; x
< 10; x
++)
1810 value
= memcached_get(memc
, keys
[0], key_length
[0],
1811 &value_length
, &flags
, &rc
);
1815 rc
= memcached_mget(memc
, keys
, key_length
, 4);
1817 while ((value
= memcached_fetch(memc
, return_key
, &return_key_length
,
1818 &value_length
, &flags
, &rc
)))
1829 static test_return
user_supplied_bug6(memcached_st
*memc
)
1831 memcached_return rc
;
1832 char *keys
[]= {"036790384900", "036790384902", "036790384904", "036790384906"};
1833 size_t key_length
[]= {strlen("036790384900"), strlen("036790384902"), strlen("036790384904"), strlen("036790384906")};
1834 char return_key
[MEMCACHED_MAX_KEY
];
1835 size_t return_key_length
;
1837 size_t value_length
;
1841 char insert_data
[VALUE_SIZE_BUG5
];
1843 for (x
= 0; x
< VALUE_SIZE_BUG5
; x
++)
1844 insert_data
[x
]= rand();
1846 memcached_flush(memc
, 0);
1847 value
= memcached_get(memc
, keys
[0], key_length
[0],
1848 &value_length
, &flags
, &rc
);
1849 assert(value
== NULL
);
1850 assert(rc
== MEMCACHED_NOTFOUND
);
1851 rc
= memcached_mget(memc
, keys
, key_length
, 4);
1852 assert(rc
== MEMCACHED_SUCCESS
);
1855 while ((value
= memcached_fetch(memc
, return_key
, &return_key_length
,
1856 &value_length
, &flags
, &rc
)))
1859 assert(rc
== MEMCACHED_END
);
1861 for (x
= 0; x
< 4; x
++)
1863 rc
= memcached_set(memc
, keys
[x
], key_length
[x
],
1864 insert_data
, VALUE_SIZE_BUG5
,
1865 (time_t)0, (uint32_t)0);
1866 assert(rc
== MEMCACHED_SUCCESS
);
1869 for (x
= 0; x
< 2; x
++)
1871 value
= memcached_get(memc
, keys
[0], key_length
[0],
1872 &value_length
, &flags
, &rc
);
1876 rc
= memcached_mget(memc
, keys
, key_length
, 4);
1877 assert(rc
== MEMCACHED_SUCCESS
);
1879 /* We test for purge of partial complete fetches */
1880 for (count
= 3; count
; count
--)
1882 value
= memcached_fetch(memc
, return_key
, &return_key_length
,
1883 &value_length
, &flags
, &rc
);
1884 assert(rc
== MEMCACHED_SUCCESS
);
1885 assert(!(memcmp(value
, insert_data
, value_length
)));
1886 assert(value_length
);
1894 static test_return
user_supplied_bug8(memcached_st
*memc
__attribute__((unused
)))
1896 memcached_return rc
;
1898 memcached_st
*clone
;
1900 memcached_server_st
*servers
;
1901 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";
1903 servers
= memcached_servers_parse(server_list
);
1906 mine
= memcached_create(NULL
);
1907 rc
= memcached_server_push(mine
, servers
);
1908 assert(rc
== MEMCACHED_SUCCESS
);
1909 memcached_server_list_free(servers
);
1912 clone
= memcached_clone(NULL
, mine
);
1914 memcached_quit(mine
);
1915 memcached_quit(clone
);
1918 memcached_free(mine
);
1919 memcached_free(clone
);
1924 /* Test flag store/retrieve */
1925 static test_return
user_supplied_bug7(memcached_st
*memc
)
1927 memcached_return rc
;
1928 char *keys
= "036790384900";
1929 size_t key_length
= strlen("036790384900");
1930 char return_key
[MEMCACHED_MAX_KEY
];
1931 size_t return_key_length
;
1933 size_t value_length
;
1936 char insert_data
[VALUE_SIZE_BUG5
];
1938 for (x
= 0; x
< VALUE_SIZE_BUG5
; x
++)
1939 insert_data
[x
]= rand();
1941 memcached_flush(memc
, 0);
1944 rc
= memcached_set(memc
, keys
, key_length
,
1945 insert_data
, VALUE_SIZE_BUG5
,
1947 assert(rc
== MEMCACHED_SUCCESS
);
1950 value
= memcached_get(memc
, keys
, key_length
,
1951 &value_length
, &flags
, &rc
);
1952 assert(flags
== 245);
1956 rc
= memcached_mget(memc
, &keys
, &key_length
, 1);
1959 value
= memcached_fetch(memc
, return_key
, &return_key_length
,
1960 &value_length
, &flags
, &rc
);
1961 assert(flags
== 245);
1969 static test_return
user_supplied_bug9(memcached_st
*memc
)
1971 memcached_return rc
;
1972 char *keys
[]= {"UDATA:edevil@sapo.pt", "fudge&*@#", "for^#@&$not"};
1973 size_t key_length
[3];
1978 char return_key
[MEMCACHED_MAX_KEY
];
1979 size_t return_key_length
;
1981 size_t return_value_length
;
1984 key_length
[0]= strlen("UDATA:edevil@sapo.pt");
1985 key_length
[1]= strlen("fudge&*@#");
1986 key_length
[2]= strlen("for^#@&$not");
1989 for (x
= 0; x
< 3; x
++)
1991 rc
= memcached_set(memc
, keys
[x
], key_length
[x
],
1992 keys
[x
], key_length
[x
],
1993 (time_t)50, (uint32_t)9);
1994 assert(rc
== MEMCACHED_SUCCESS
);
1997 rc
= memcached_mget(memc
, keys
, key_length
, 3);
1998 assert(rc
== MEMCACHED_SUCCESS
);
2000 /* We need to empty the server before continueing test */
2001 while ((return_value
= memcached_fetch(memc
, return_key
, &return_key_length
,
2002 &return_value_length
, &flags
, &rc
)) != NULL
)
2004 assert(return_value
);
2013 /* We are testing with aggressive timeout to get failures */
2014 static test_return
user_supplied_bug10(memcached_st
*memc
)
2018 size_t value_length
= 512;
2021 memcached_return rc
;
2022 unsigned int set
= 1;
2023 memcached_st
*mclone
= memcached_clone(NULL
, memc
);
2026 memcached_behavior_set(mclone
, MEMCACHED_BEHAVIOR_NO_BLOCK
, set
);
2027 memcached_behavior_set(mclone
, MEMCACHED_BEHAVIOR_TCP_NODELAY
, set
);
2029 memcached_behavior_set(mclone
, MEMCACHED_BEHAVIOR_POLL_TIMEOUT
, timeout
);
2031 value
= (char*)malloc(value_length
* sizeof(char));
2033 for (x
= 0; x
< value_length
; x
++)
2034 value
[x
]= (char) (x
% 127);
2036 for (x
= 1; x
<= 100000; ++x
)
2038 rc
= memcached_set(mclone
, key
, key_len
,value
, value_length
, 0, 0);
2040 assert(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_WRITE_FAILURE
||
2041 rc
== MEMCACHED_BUFFERED
|| rc
== MEMCACHED_TIMEOUT
);
2043 if (rc
== MEMCACHED_WRITE_FAILURE
|| rc
== MEMCACHED_TIMEOUT
)
2048 memcached_free(mclone
);
2054 We are looking failures in the async protocol
2056 static test_return
user_supplied_bug11(memcached_st
*memc
)
2060 size_t value_length
= 512;
2063 memcached_return rc
;
2064 unsigned int set
= 1;
2066 memcached_st
*mclone
= memcached_clone(NULL
, memc
);
2068 memcached_behavior_set(mclone
, MEMCACHED_BEHAVIOR_NO_BLOCK
, set
);
2069 memcached_behavior_set(mclone
, MEMCACHED_BEHAVIOR_TCP_NODELAY
, set
);
2071 memcached_behavior_set(mclone
, MEMCACHED_BEHAVIOR_POLL_TIMEOUT
, timeout
);
2073 timeout
= (int32_t)memcached_behavior_get(mclone
, MEMCACHED_BEHAVIOR_POLL_TIMEOUT
);
2075 assert(timeout
== -1);
2077 value
= (char*)malloc(value_length
* sizeof(char));
2079 for (x
= 0; x
< value_length
; x
++)
2080 value
[x
]= (char) (x
% 127);
2082 for (x
= 1; x
<= 100000; ++x
)
2084 rc
= memcached_set(mclone
, key
, key_len
,value
, value_length
, 0, 0);
2088 memcached_free(mclone
);
2094 Bug found where incr was not returning MEMCACHED_NOTFOUND when object did not exist.
2096 static test_return
user_supplied_bug12(memcached_st
*memc
)
2098 memcached_return rc
;
2100 size_t value_length
;
2102 uint64_t number_value
;
2104 value
= memcached_get(memc
, "autoincrement", strlen("autoincrement"),
2105 &value_length
, &flags
, &rc
);
2106 assert(value
== NULL
);
2107 assert(rc
== MEMCACHED_NOTFOUND
);
2109 rc
= memcached_increment(memc
, "autoincrement", strlen("autoincrement"),
2112 assert(value
== NULL
);
2113 /* The binary protocol will set the key if it doesn't exist */
2114 if (memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
) == 1)
2115 assert(rc
== MEMCACHED_SUCCESS
);
2117 assert(rc
== MEMCACHED_NOTFOUND
);
2119 rc
= memcached_set(memc
, "autoincrement", strlen("autoincrement"), "1", 1, 0, 0);
2121 value
= memcached_get(memc
, "autoincrement", strlen("autoincrement"),
2122 &value_length
, &flags
, &rc
);
2124 assert(rc
== MEMCACHED_SUCCESS
);
2127 rc
= memcached_increment(memc
, "autoincrement", strlen("autoincrement"),
2129 assert(number_value
== 2);
2130 assert(rc
== MEMCACHED_SUCCESS
);
2136 Bug found where command total one more than MEMCACHED_MAX_BUFFER
2137 set key34567890 0 0 8169 \r\n is sent followed by buffer of size 8169, followed by 8169
2139 static test_return
user_supplied_bug13(memcached_st
*memc
)
2141 char key
[] = "key34567890";
2143 memcached_return rc
;
2144 size_t overflowSize
;
2146 char commandFirst
[]= "set key34567890 0 0 ";
2147 char commandLast
[] = " \r\n"; /* first line of command sent to server */
2148 size_t commandLength
;
2151 commandLength
= strlen(commandFirst
) + strlen(commandLast
) + 4; /* 4 is number of characters in size, probably 8196 */
2153 overflowSize
= MEMCACHED_MAX_BUFFER
- commandLength
;
2155 for (testSize
= overflowSize
- 1; testSize
< overflowSize
+ 1; testSize
++)
2157 overflow
= malloc(testSize
);
2158 assert(overflow
!= NULL
);
2160 memset(overflow
, 'x', testSize
);
2161 rc
= memcached_set(memc
, key
, strlen(key
),
2162 overflow
, testSize
, 0, 0);
2163 assert(rc
== MEMCACHED_SUCCESS
);
2172 Test values of many different sizes
2173 Bug found where command total one more than MEMCACHED_MAX_BUFFER
2174 set key34567890 0 0 8169 \r\n
2175 is sent followed by buffer of size 8169, followed by 8169
2177 static test_return
user_supplied_bug14(memcached_st
*memc
)
2180 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_TCP_NODELAY
, setter
);
2181 memcached_return rc
;
2184 size_t value_length
= 18000;
2186 size_t string_length
;
2189 size_t current_length
;
2191 value
= (char*)malloc(value_length
);
2194 for (x
= 0; x
< value_length
; x
++)
2195 value
[x
] = (char) (x
% 127);
2197 for (current_length
= 0; current_length
< value_length
; current_length
++)
2199 rc
= memcached_set(memc
, key
, strlen(key
),
2200 value
, current_length
,
2201 (time_t)0, (uint32_t)0);
2202 assert(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
);
2204 string
= memcached_get(memc
, key
, strlen(key
),
2205 &string_length
, &flags
, &rc
);
2207 assert(rc
== MEMCACHED_SUCCESS
);
2208 assert(string_length
== current_length
);
2209 assert(!memcmp(string
, value
, string_length
));
2220 Look for zero length value problems
2222 static test_return
user_supplied_bug15(memcached_st
*memc
)
2225 memcached_return rc
;
2231 for (x
= 0; x
< 2; x
++)
2233 rc
= memcached_set(memc
, key
, strlen(key
),
2235 (time_t)0, (uint32_t)0);
2237 assert(rc
== MEMCACHED_SUCCESS
);
2239 value
= memcached_get(memc
, key
, strlen(key
),
2240 &length
, &flags
, &rc
);
2242 assert(rc
== MEMCACHED_SUCCESS
);
2243 assert(value
== NULL
);
2244 assert(length
== 0);
2247 value
= memcached_get(memc
, key
, strlen(key
),
2248 &length
, &flags
, &rc
);
2250 assert(rc
== MEMCACHED_SUCCESS
);
2251 assert(value
== NULL
);
2252 assert(length
== 0);
2259 /* Check the return sizes on FLAGS to make sure it stores 32bit unsigned values correctly */
2260 static test_return
user_supplied_bug16(memcached_st
*memc
)
2262 memcached_return rc
;
2268 rc
= memcached_set(memc
, key
, strlen(key
),
2270 (time_t)0, UINT32_MAX
);
2272 assert(rc
== MEMCACHED_SUCCESS
);
2274 value
= memcached_get(memc
, key
, strlen(key
),
2275 &length
, &flags
, &rc
);
2277 assert(rc
== MEMCACHED_SUCCESS
);
2278 assert(value
== NULL
);
2279 assert(length
== 0);
2280 assert(flags
== UINT32_MAX
);
2285 /* Check the validity of chinese key*/
2286 static test_return
user_supplied_bug17(memcached_st
*memc
)
2288 memcached_return rc
;
2290 char *value
="我们在炎热抑郁的夏天无法停止豆瓣";
2295 rc
= memcached_set(memc
, key
, strlen(key
),
2296 value
, strlen(value
),
2299 assert(rc
== MEMCACHED_SUCCESS
);
2301 value2
= memcached_get(memc
, key
, strlen(key
),
2302 &length
, &flags
, &rc
);
2304 assert(length
==strlen(value
));
2305 assert(rc
== MEMCACHED_SUCCESS
);
2306 assert(memcmp(value
, value2
, length
)==0);
2316 static test_return
user_supplied_bug19(memcached_st
*memc
)
2319 memcached_server_st
*s
;
2320 memcached_return res
;
2324 m
= memcached_create(NULL
);
2325 memcached_server_add_with_weight(m
, "localhost", 11311, 100);
2326 memcached_server_add_with_weight(m
, "localhost", 11312, 100);
2328 s
= memcached_server_by_key(m
, "a", 1, &res
);
2329 memcached_server_free(s
);
2336 /* CAS test from Andei */
2337 static test_return
user_supplied_bug20(memcached_st
*memc
)
2339 memcached_return status
;
2340 memcached_result_st
*result
, result_obj
;
2342 size_t key_len
= strlen("abc");
2343 char *value
= "foobar";
2344 size_t value_len
= strlen(value
);
2346 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_SUPPORT_CAS
, 1);
2348 status
= memcached_set(memc
, key
, key_len
, value
, value_len
, (time_t)0, (uint32_t)0);
2349 assert(status
== MEMCACHED_SUCCESS
);
2351 status
= memcached_mget(memc
, &key
, &key_len
, 1);
2352 assert(status
== MEMCACHED_SUCCESS
);
2354 result
= memcached_result_create(memc
, &result_obj
);
2357 memcached_result_create(memc
, &result_obj
);
2358 result
= memcached_fetch_result(memc
, &result_obj
, &status
);
2361 assert(status
== MEMCACHED_SUCCESS
);
2363 memcached_result_free(result
);
2368 #include "ketama_test_cases.h"
2369 static test_return
user_supplied_bug18(memcached_st
*trash
)
2371 memcached_return rc
;
2374 memcached_server_st
*server_pool
;
2379 memc
= memcached_create(NULL
);
2382 rc
= memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_KETAMA_WEIGHTED
, 1);
2383 assert(rc
== MEMCACHED_SUCCESS
);
2385 value
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_KETAMA_WEIGHTED
);
2388 rc
= memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_KETAMA_HASH
, MEMCACHED_HASH_MD5
);
2389 assert(rc
== MEMCACHED_SUCCESS
);
2391 value
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_KETAMA_HASH
);
2392 assert(value
== MEMCACHED_HASH_MD5
);
2394 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");
2395 memcached_server_push(memc
, server_pool
);
2397 /* verify that the server list was parsed okay. */
2398 assert(memc
->number_of_hosts
== 8);
2399 assert(strcmp(server_pool
[0].hostname
, "10.0.1.1") == 0);
2400 assert(server_pool
[0].port
== 11211);
2401 assert(server_pool
[0].weight
== 600);
2402 assert(strcmp(server_pool
[2].hostname
, "10.0.1.3") == 0);
2403 assert(server_pool
[2].port
== 11211);
2404 assert(server_pool
[2].weight
== 200);
2405 assert(strcmp(server_pool
[7].hostname
, "10.0.1.8") == 0);
2406 assert(server_pool
[7].port
== 11211);
2407 assert(server_pool
[7].weight
== 100);
2409 /* VDEAAAAA hashes to fffcd1b5, after the last continuum point, and lets
2410 * us test the boundary wraparound.
2412 assert(memcached_generate_hash(memc
, (char *)"VDEAAAAA", 8) == memc
->continuum
[0].index
);
2414 /* verify the standard ketama set. */
2415 for (x
= 0; x
< 99; x
++)
2417 uint32_t server_idx
= memcached_generate_hash(memc
, test_cases
[x
].key
, strlen(test_cases
[x
].key
));
2418 char *hostname
= memc
->hosts
[server_idx
].hostname
;
2419 assert(strcmp(hostname
, test_cases
[x
].server
) == 0);
2422 memcached_server_list_free(server_pool
);
2423 memcached_free(memc
);
2428 static test_return
auto_eject_hosts(memcached_st
*trash
)
2432 memcached_return rc
;
2433 memcached_st
*memc
= memcached_create(NULL
);
2436 rc
= memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_KETAMA_WEIGHTED
, 1);
2437 assert(rc
== MEMCACHED_SUCCESS
);
2439 uint64_t value
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_KETAMA_WEIGHTED
);
2442 rc
= memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_KETAMA_HASH
, MEMCACHED_HASH_MD5
);
2443 assert(rc
== MEMCACHED_SUCCESS
);
2445 value
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_KETAMA_HASH
);
2446 assert(value
== MEMCACHED_HASH_MD5
);
2448 /* server should be removed when in delay */
2449 rc
= memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_AUTO_EJECT_HOSTS
, 1);
2450 assert(rc
== MEMCACHED_SUCCESS
);
2452 value
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_AUTO_EJECT_HOSTS
);
2455 memcached_server_st
*server_pool
;
2456 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");
2457 memcached_server_push(memc
, server_pool
);
2459 /* verify that the server list was parsed okay. */
2460 assert(memc
->number_of_hosts
== 8);
2461 assert(strcmp(server_pool
[0].hostname
, "10.0.1.1") == 0);
2462 assert(server_pool
[0].port
== 11211);
2463 assert(server_pool
[0].weight
== 600);
2464 assert(strcmp(server_pool
[2].hostname
, "10.0.1.3") == 0);
2465 assert(server_pool
[2].port
== 11211);
2466 assert(server_pool
[2].weight
== 200);
2467 assert(strcmp(server_pool
[7].hostname
, "10.0.1.8") == 0);
2468 assert(server_pool
[7].port
== 11211);
2469 assert(server_pool
[7].weight
== 100);
2471 memc
->hosts
[2].next_retry
= time(NULL
) + 15;
2472 memc
->next_distribution_rebuild
= time(NULL
) - 1;
2474 for (int x
= 0; x
< 99; x
++)
2476 uint32_t server_idx
= memcached_generate_hash(memc
, test_cases
[x
].key
, strlen(test_cases
[x
].key
));
2477 assert(server_idx
!= 2);
2480 /* and re-added when it's back. */
2481 memc
->hosts
[2].next_retry
= time(NULL
) - 1;
2482 memc
->next_distribution_rebuild
= time(NULL
) - 1;
2483 run_distribution(memc
);
2484 for (int x
= 0; x
< 99; x
++)
2486 uint32_t server_idx
= memcached_generate_hash(memc
, test_cases
[x
].key
, strlen(test_cases
[x
].key
));
2487 char *hostname
= memc
->hosts
[server_idx
].hostname
;
2488 assert(strcmp(hostname
, test_cases
[x
].server
) == 0);
2491 memcached_server_list_free(server_pool
);
2492 memcached_free(memc
);
2494 return TEST_SUCCESS
;
2497 static test_return
result_static(memcached_st
*memc
)
2499 memcached_result_st result
;
2500 memcached_result_st
*result_ptr
;
2502 result_ptr
= memcached_result_create(memc
, &result
);
2503 assert(result
.is_allocated
== false);
2505 memcached_result_free(&result
);
2510 static test_return
result_alloc(memcached_st
*memc
)
2512 memcached_result_st
*result
;
2514 result
= memcached_result_create(memc
, NULL
);
2516 memcached_result_free(result
);
2521 static test_return
string_static_null(memcached_st
*memc
)
2523 memcached_string_st string
;
2524 memcached_string_st
*string_ptr
;
2526 string_ptr
= memcached_string_create(memc
, &string
, 0);
2527 assert(string
.is_allocated
== false);
2529 memcached_string_free(&string
);
2534 static test_return
string_alloc_null(memcached_st
*memc
)
2536 memcached_string_st
*string
;
2538 string
= memcached_string_create(memc
, NULL
, 0);
2540 memcached_string_free(string
);
2545 static test_return
string_alloc_with_size(memcached_st
*memc
)
2547 memcached_string_st
*string
;
2549 string
= memcached_string_create(memc
, NULL
, 1024);
2551 memcached_string_free(string
);
2556 static test_return
string_alloc_with_size_toobig(memcached_st
*memc
)
2558 memcached_string_st
*string
;
2560 string
= memcached_string_create(memc
, NULL
, INT64_MAX
);
2561 assert(string
== NULL
);
2566 static test_return
string_alloc_append(memcached_st
*memc
)
2569 char buffer
[SMALL_STRING_LEN
];
2570 memcached_string_st
*string
;
2572 /* Ring the bell! */
2573 memset(buffer
, 6, SMALL_STRING_LEN
);
2575 string
= memcached_string_create(memc
, NULL
, 100);
2578 for (x
= 0; x
< 1024; x
++)
2580 memcached_return rc
;
2581 rc
= memcached_string_append(string
, buffer
, SMALL_STRING_LEN
);
2582 assert(rc
== MEMCACHED_SUCCESS
);
2584 memcached_string_free(string
);
2589 static test_return
string_alloc_append_toobig(memcached_st
*memc
)
2591 memcached_return rc
;
2593 char buffer
[SMALL_STRING_LEN
];
2594 memcached_string_st
*string
;
2596 /* Ring the bell! */
2597 memset(buffer
, 6, SMALL_STRING_LEN
);
2599 string
= memcached_string_create(memc
, NULL
, 100);
2602 for (x
= 0; x
< 1024; x
++)
2604 rc
= memcached_string_append(string
, buffer
, SMALL_STRING_LEN
);
2605 assert(rc
== MEMCACHED_SUCCESS
);
2607 rc
= memcached_string_append(string
, buffer
, INT64_MAX
);
2608 assert(rc
== MEMCACHED_MEMORY_ALLOCATION_FAILURE
);
2609 memcached_string_free(string
);
2614 static test_return
cleanup_pairs(memcached_st
*memc
__attribute__((unused
)))
2616 pairs_free(global_pairs
);
2621 static test_return
generate_pairs(memcached_st
*memc
__attribute__((unused
)))
2623 unsigned long long x
;
2624 global_pairs
= pairs_generate(GLOBAL_COUNT
, 400);
2625 global_count
= GLOBAL_COUNT
;
2627 for (x
= 0; x
< global_count
; x
++)
2629 global_keys
[x
]= global_pairs
[x
].key
;
2630 global_keys_length
[x
]= global_pairs
[x
].key_length
;
2636 static test_return
generate_large_pairs(memcached_st
*memc
__attribute__((unused
)))
2638 unsigned long long x
;
2639 global_pairs
= pairs_generate(GLOBAL2_COUNT
, MEMCACHED_MAX_BUFFER
+10);
2640 global_count
= GLOBAL2_COUNT
;
2642 for (x
= 0; x
< global_count
; x
++)
2644 global_keys
[x
]= global_pairs
[x
].key
;
2645 global_keys_length
[x
]= global_pairs
[x
].key_length
;
2651 static test_return
generate_data(memcached_st
*memc
)
2653 execute_set(memc
, global_pairs
, global_count
);
2658 static test_return
generate_data_with_stats(memcached_st
*memc
)
2660 memcached_stat_st
*stat_p
;
2661 memcached_return rc
;
2662 uint32_t host_index
= 0;
2663 execute_set(memc
, global_pairs
, global_count
);
2665 //TODO: hosts used size stats
2666 stat_p
= memcached_stat(memc
, NULL
, &rc
);
2669 for (host_index
= 0; host_index
< SERVERS_TO_CREATE
; host_index
++)
2671 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
);
2674 memcached_stat_free(NULL
, stat_p
);
2678 static test_return
generate_buffer_data(memcached_st
*memc
)
2683 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_BUFFER_REQUESTS
, latch
);
2684 generate_data(memc
);
2689 static test_return
get_read_count(memcached_st
*memc
)
2692 memcached_return rc
;
2693 memcached_st
*clone
;
2695 clone
= memcached_clone(NULL
, memc
);
2698 memcached_server_add_with_weight(clone
, "localhost", 6666, 0);
2702 size_t return_value_length
;
2706 for (x
= count
= 0; x
< global_count
; x
++)
2708 return_value
= memcached_get(clone
, global_keys
[x
], global_keys_length
[x
],
2709 &return_value_length
, &flags
, &rc
);
2710 if (rc
== MEMCACHED_SUCCESS
)
2717 fprintf(stderr
, "\t%u -> %u", global_count
, count
);
2720 memcached_free(clone
);
2725 static test_return
get_read(memcached_st
*memc
)
2728 memcached_return rc
;
2732 size_t return_value_length
;
2735 for (x
= 0; x
< global_count
; x
++)
2737 return_value
= memcached_get(memc
, global_keys
[x
], global_keys_length
[x
],
2738 &return_value_length
, &flags
, &rc
);
2740 assert(return_value);
2741 assert(rc == MEMCACHED_SUCCESS);
2743 if (rc
== MEMCACHED_SUCCESS
&& return_value
)
2751 static test_return
mget_read(memcached_st
*memc
)
2753 memcached_return rc
;
2755 rc
= memcached_mget(memc
, global_keys
, global_keys_length
, global_count
);
2756 assert(rc
== MEMCACHED_SUCCESS
);
2757 /* Turn this into a help function */
2759 char return_key
[MEMCACHED_MAX_KEY
];
2760 size_t return_key_length
;
2762 size_t return_value_length
;
2765 while ((return_value
= memcached_fetch(memc
, return_key
, &return_key_length
,
2766 &return_value_length
, &flags
, &rc
)))
2768 assert(return_value
);
2769 assert(rc
== MEMCACHED_SUCCESS
);
2777 static test_return
mget_read_result(memcached_st
*memc
)
2779 memcached_return rc
;
2781 rc
= memcached_mget(memc
, global_keys
, global_keys_length
, global_count
);
2782 assert(rc
== MEMCACHED_SUCCESS
);
2783 /* Turn this into a help function */
2785 memcached_result_st results_obj
;
2786 memcached_result_st
*results
;
2788 results
= memcached_result_create(memc
, &results_obj
);
2790 while ((results
= memcached_fetch_result(memc
, &results_obj
, &rc
)))
2793 assert(rc
== MEMCACHED_SUCCESS
);
2796 memcached_result_free(&results_obj
);
2802 static test_return
mget_read_function(memcached_st
*memc
)
2804 memcached_return rc
;
2805 unsigned int counter
;
2806 memcached_execute_function callbacks
[1];
2808 rc
= memcached_mget(memc
, global_keys
, global_keys_length
, global_count
);
2809 assert(rc
== MEMCACHED_SUCCESS
);
2811 callbacks
[0]= &callback_counter
;
2813 rc
= memcached_fetch_execute(memc
, callbacks
, (void *)&counter
, 1);
2818 static test_return
delete_generate(memcached_st
*memc
)
2822 for (x
= 0; x
< global_count
; x
++)
2824 (void)memcached_delete(memc
, global_keys
[x
], global_keys_length
[x
], (time_t)0);
2830 static test_return
delete_buffer_generate(memcached_st
*memc
)
2836 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_BUFFER_REQUESTS
, latch
);
2838 for (x
= 0; x
< global_count
; x
++)
2840 (void)memcached_delete(memc
, global_keys
[x
], global_keys_length
[x
], (time_t)0);
2846 static test_return
add_host_test1(memcached_st
*memc
)
2849 memcached_return rc
;
2850 char servername
[]= "0.example.com";
2851 memcached_server_st
*servers
;
2853 servers
= memcached_server_list_append_with_weight(NULL
, servername
, 400, 0, &rc
);
2855 assert(1 == memcached_server_list_count(servers
));
2857 for (x
= 2; x
< 20; x
++)
2859 char buffer
[SMALL_STRING_LEN
];
2861 snprintf(buffer
, SMALL_STRING_LEN
, "%u.example.com", 400+x
);
2862 servers
= memcached_server_list_append_with_weight(servers
, buffer
, 401, 0,
2864 assert(rc
== MEMCACHED_SUCCESS
);
2865 assert(x
== memcached_server_list_count(servers
));
2868 rc
= memcached_server_push(memc
, servers
);
2869 assert(rc
== MEMCACHED_SUCCESS
);
2870 rc
= memcached_server_push(memc
, servers
);
2871 assert(rc
== MEMCACHED_SUCCESS
);
2873 memcached_server_list_free(servers
);
2878 static memcached_return
pre_nonblock(memcached_st
*memc
)
2880 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NO_BLOCK
, 0);
2882 return MEMCACHED_SUCCESS
;
2885 static memcached_return
pre_nonblock_binary(memcached_st
*memc
)
2887 memcached_return rc
= MEMCACHED_FAILURE
;
2888 memcached_st
*clone
;
2890 clone
= memcached_clone(NULL
, memc
);
2892 // The memcached_version needs to be done on a clone, because the server
2893 // will not toggle protocol on an connection.
2894 memcached_version(clone
);
2896 if (clone
->hosts
[0].major_version
>= 1 && clone
->hosts
[0].minor_version
> 2)
2898 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NO_BLOCK
, 0);
2899 rc
= memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
, 1);
2900 assert(rc
== MEMCACHED_SUCCESS
);
2901 assert(memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
) == 1);
2904 memcached_free(clone
);
2908 static memcached_return
pre_murmur(memcached_st
*memc
)
2910 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_HASH
, (uint64_t)MEMCACHED_HASH_MURMUR
);
2912 return MEMCACHED_SUCCESS
;
2915 static memcached_return
pre_jenkins(memcached_st
*memc
)
2917 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_HASH
, (uint64_t)MEMCACHED_HASH_JENKINS
);
2919 return MEMCACHED_SUCCESS
;
2923 static memcached_return
pre_md5(memcached_st
*memc
)
2925 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_HASH
, (uint64_t)MEMCACHED_HASH_MD5
);
2927 return MEMCACHED_SUCCESS
;
2930 static memcached_return
pre_crc(memcached_st
*memc
)
2932 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_HASH
, (uint64_t)MEMCACHED_HASH_CRC
);
2934 return MEMCACHED_SUCCESS
;
2937 static memcached_return
pre_hsieh(memcached_st
*memc
)
2939 #ifdef HAVE_HSIEH_HASH
2940 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_HASH
, (uint64_t)MEMCACHED_HASH_HSIEH
);
2941 return MEMCACHED_SUCCESS
;
2944 return MEMCACHED_FAILURE
;
2948 static memcached_return
pre_hash_fnv1_64(memcached_st
*memc
)
2950 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_HASH
, (uint64_t)MEMCACHED_HASH_FNV1_64
);
2952 return MEMCACHED_SUCCESS
;
2955 static memcached_return
pre_hash_fnv1a_64(memcached_st
*memc
)
2957 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_HASH
, (uint64_t)MEMCACHED_HASH_FNV1A_64
);
2959 return MEMCACHED_SUCCESS
;
2962 static memcached_return
pre_hash_fnv1_32(memcached_st
*memc
)
2964 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_HASH
, (uint64_t)MEMCACHED_HASH_FNV1_32
);
2966 return MEMCACHED_SUCCESS
;
2969 static memcached_return
pre_hash_fnv1a_32(memcached_st
*memc
)
2971 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_HASH
, (uint64_t)MEMCACHED_HASH_FNV1A_32
);
2973 return MEMCACHED_SUCCESS
;
2976 static memcached_return
pre_behavior_ketama(memcached_st
*memc
)
2978 memcached_return rc
;
2981 rc
= memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_KETAMA
, 1);
2982 assert(rc
== MEMCACHED_SUCCESS
);
2984 value
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_KETAMA
);
2987 return MEMCACHED_SUCCESS
;
2990 static memcached_return
pre_behavior_ketama_weighted(memcached_st
*memc
)
2992 memcached_return rc
;
2995 rc
= memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_KETAMA_WEIGHTED
, 1);
2996 assert(rc
== MEMCACHED_SUCCESS
);
2998 value
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_KETAMA_WEIGHTED
);
3001 rc
= memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_KETAMA_HASH
, MEMCACHED_HASH_MD5
);
3002 assert(rc
== MEMCACHED_SUCCESS
);
3004 value
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_KETAMA_HASH
);
3005 assert(value
== MEMCACHED_HASH_MD5
);
3006 return MEMCACHED_SUCCESS
;
3009 static memcached_return
pre_binary(memcached_st
*memc
)
3011 memcached_return rc
= MEMCACHED_FAILURE
;
3012 memcached_st
*clone
;
3014 clone
= memcached_clone(NULL
, memc
);
3016 // The memcached_version needs to be done on a clone, because the server
3017 // will not toggle protocol on an connection.
3018 memcached_version(clone
);
3020 if (clone
->hosts
[0].major_version
>= 1 && clone
->hosts
[0].minor_version
> 2)
3022 rc
= memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
, 1);
3023 assert(rc
== MEMCACHED_SUCCESS
);
3024 assert(memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
) == 1);
3027 memcached_free(clone
);
3031 static void my_free(memcached_st
*ptr
__attribute__((unused
)), void *mem
)
3036 static void *my_malloc(memcached_st
*ptr
__attribute__((unused
)), const size_t size
)
3038 return malloc(size
);
3041 static void *my_realloc(memcached_st
*ptr
__attribute__((unused
)), void *mem
, const size_t size
)
3043 return realloc(mem
, size
);
3046 static memcached_return
set_prefix(memcached_st
*memc
)
3048 memcached_return rc
;
3049 const char *key
= "mine";
3052 /* Make sure be default none exists */
3053 value
= memcached_callback_get(memc
, MEMCACHED_CALLBACK_PREFIX_KEY
, &rc
);
3054 assert(rc
== MEMCACHED_FAILURE
);
3056 /* Test a clean set */
3057 rc
= memcached_callback_set(memc
, MEMCACHED_CALLBACK_PREFIX_KEY
, (void *)key
);
3058 assert(rc
== MEMCACHED_SUCCESS
);
3060 value
= memcached_callback_get(memc
, MEMCACHED_CALLBACK_PREFIX_KEY
, &rc
);
3061 assert(memcmp(value
, key
, 4) == 0);
3062 assert(rc
== MEMCACHED_SUCCESS
);
3064 /* Test that we can turn it off */
3065 rc
= memcached_callback_set(memc
, MEMCACHED_CALLBACK_PREFIX_KEY
, NULL
);
3066 assert(rc
== MEMCACHED_SUCCESS
);
3068 value
= memcached_callback_get(memc
, MEMCACHED_CALLBACK_PREFIX_KEY
, &rc
);
3069 assert(rc
== MEMCACHED_FAILURE
);
3071 /* Now setup for main test */
3072 rc
= memcached_callback_set(memc
, MEMCACHED_CALLBACK_PREFIX_KEY
, (void *)key
);
3073 assert(rc
== MEMCACHED_SUCCESS
);
3075 value
= memcached_callback_get(memc
, MEMCACHED_CALLBACK_PREFIX_KEY
, &rc
);
3076 assert(rc
== MEMCACHED_SUCCESS
);
3077 assert(memcmp(value
, key
, 4) == 0);
3079 /* Set to Zero, and then Set to something too large */
3082 rc
= memcached_callback_set(memc
, MEMCACHED_CALLBACK_PREFIX_KEY
, NULL
);
3083 assert(rc
== MEMCACHED_SUCCESS
);
3085 value
= memcached_callback_get(memc
, MEMCACHED_CALLBACK_PREFIX_KEY
, &rc
);
3086 assert(rc
== MEMCACHED_FAILURE
);
3087 assert(value
== NULL
);
3089 /* Test a long key for failure */
3090 /* TODO, extend test to determine based on setting, what result should be */
3091 long_key
= "Thisismorethentheallottednumberofcharacters";
3092 rc
= memcached_callback_set(memc
, MEMCACHED_CALLBACK_PREFIX_KEY
, long_key
);
3093 //assert(rc == MEMCACHED_BAD_KEY_PROVIDED);
3094 assert(rc
== MEMCACHED_SUCCESS
);
3096 /* Now test a key with spaces (which will fail from long key, since bad key is not set) */
3097 long_key
= "This is more then the allotted number of characters";
3098 rc
= memcached_callback_set(memc
, MEMCACHED_CALLBACK_PREFIX_KEY
, long_key
);
3099 assert(rc
== MEMCACHED_BAD_KEY_PROVIDED
);
3101 /* Test for a bad prefix, but with a short key */
3102 rc
= memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_VERIFY_KEY
, 1);
3103 assert(rc
== MEMCACHED_SUCCESS
);
3105 long_key
= "dog cat";
3106 rc
= memcached_callback_set(memc
, MEMCACHED_CALLBACK_PREFIX_KEY
, long_key
);
3107 assert(rc
== MEMCACHED_BAD_KEY_PROVIDED
);
3110 return MEMCACHED_SUCCESS
;
3113 static memcached_return
set_memory_alloc(memcached_st
*memc
)
3115 void *test_ptr
= NULL
;
3118 memcached_malloc_function malloc_cb
=
3119 (memcached_malloc_function
)my_malloc
;
3120 cb_ptr
= *(void **)&malloc_cb
;
3121 memcached_return rc
;
3123 rc
= memcached_callback_set(memc
, MEMCACHED_CALLBACK_MALLOC_FUNCTION
, cb_ptr
);
3124 assert(rc
== MEMCACHED_SUCCESS
);
3125 test_ptr
= memcached_callback_get(memc
, MEMCACHED_CALLBACK_MALLOC_FUNCTION
, &rc
);
3126 assert(rc
== MEMCACHED_SUCCESS
);
3127 assert(test_ptr
== cb_ptr
);
3131 memcached_realloc_function realloc_cb
=
3132 (memcached_realloc_function
)my_realloc
;
3133 cb_ptr
= *(void **)&realloc_cb
;
3134 memcached_return rc
;
3136 rc
= memcached_callback_set(memc
, MEMCACHED_CALLBACK_REALLOC_FUNCTION
, cb_ptr
);
3137 assert(rc
== MEMCACHED_SUCCESS
);
3138 test_ptr
= memcached_callback_get(memc
, MEMCACHED_CALLBACK_REALLOC_FUNCTION
, &rc
);
3139 assert(rc
== MEMCACHED_SUCCESS
);
3140 assert(test_ptr
== cb_ptr
);
3144 memcached_free_function free_cb
=
3145 (memcached_free_function
)my_free
;
3146 cb_ptr
= *(void **)&free_cb
;
3147 memcached_return rc
;
3149 rc
= memcached_callback_set(memc
, MEMCACHED_CALLBACK_FREE_FUNCTION
, cb_ptr
);
3150 assert(rc
== MEMCACHED_SUCCESS
);
3151 test_ptr
= memcached_callback_get(memc
, MEMCACHED_CALLBACK_FREE_FUNCTION
, &rc
);
3152 assert(rc
== MEMCACHED_SUCCESS
);
3153 assert(test_ptr
== cb_ptr
);
3156 return MEMCACHED_SUCCESS
;
3159 static memcached_return
enable_consistent(memcached_st
*memc
)
3161 memcached_server_distribution value
= MEMCACHED_DISTRIBUTION_CONSISTENT
;
3162 memcached_hash hash
;
3163 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_DISTRIBUTION
, value
);
3164 if (pre_hsieh(memc
) != MEMCACHED_SUCCESS
)
3165 return MEMCACHED_FAILURE
;
3167 value
= (memcached_server_distribution
)memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_DISTRIBUTION
);
3168 assert(value
== MEMCACHED_DISTRIBUTION_CONSISTENT
);
3170 hash
= (memcached_hash
)memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_HASH
);
3171 assert(hash
== MEMCACHED_HASH_HSIEH
);
3174 return MEMCACHED_SUCCESS
;
3177 static memcached_return
enable_cas(memcached_st
*memc
)
3179 unsigned int set
= 1;
3181 memcached_version(memc
);
3183 if ((memc
->hosts
[0].major_version
>= 1 && (memc
->hosts
[0].minor_version
== 2 && memc
->hosts
[0].micro_version
>= 4))
3184 || memc
->hosts
[0].minor_version
> 2)
3186 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_SUPPORT_CAS
, set
);
3188 return MEMCACHED_SUCCESS
;
3191 return MEMCACHED_FAILURE
;
3194 static memcached_return
check_for_1_2_3(memcached_st
*memc
)
3196 memcached_version(memc
);
3198 if ((memc
->hosts
[0].major_version
>= 1 && (memc
->hosts
[0].minor_version
== 2 && memc
->hosts
[0].micro_version
>= 4))
3199 || memc
->hosts
[0].minor_version
> 2)
3200 return MEMCACHED_SUCCESS
;
3202 return MEMCACHED_FAILURE
;
3205 static memcached_return
pre_unix_socket(memcached_st
*memc
)
3207 memcached_return rc
;
3210 memcached_server_list_free(memc
->hosts
);
3212 memc
->number_of_hosts
= 0;
3214 if (stat("/tmp/memcached.socket", &buf
))
3215 return MEMCACHED_FAILURE
;
3217 rc
= memcached_server_add_unix_socket_with_weight(memc
, "/tmp/memcached.socket", 0);
3222 static memcached_return
pre_nodelay(memcached_st
*memc
)
3224 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NO_BLOCK
, 0);
3225 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_TCP_NODELAY
, 0);
3227 return MEMCACHED_SUCCESS
;
3230 static memcached_return
pre_settimer(memcached_st
*memc
)
3232 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_SND_TIMEOUT
, 1000);
3233 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_RCV_TIMEOUT
, 1000);
3235 return MEMCACHED_SUCCESS
;
3238 static memcached_return
poll_timeout(memcached_st
*memc
)
3244 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_POLL_TIMEOUT
, timeout
);
3246 timeout
= (int32_t)memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_POLL_TIMEOUT
);
3248 assert(timeout
== 100);
3250 return MEMCACHED_SUCCESS
;
3253 static test_return
noreply_test(memcached_st
*memc
)
3255 memcached_return ret
;
3256 ret
= memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NOREPLY
, 1);
3257 assert(ret
== MEMCACHED_SUCCESS
);
3258 ret
= memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_BUFFER_REQUESTS
, 1);
3259 assert(ret
== MEMCACHED_SUCCESS
);
3260 ret
= memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_SUPPORT_CAS
, 1);
3261 assert(ret
== MEMCACHED_SUCCESS
);
3262 assert(memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_NOREPLY
) == 1);
3263 assert(memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_BUFFER_REQUESTS
) == 1);
3264 assert(memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_SUPPORT_CAS
) == 1);
3266 for (int count
=0; count
< 5; ++count
)
3268 for (int x
=0; x
< 100; ++x
)
3271 size_t len
=sprintf(key
, "%d", x
);
3275 ret
=memcached_add(memc
, key
, len
, key
, len
, 0, 0);
3278 ret
=memcached_replace(memc
, key
, len
, key
, len
, 0, 0);
3281 ret
=memcached_set(memc
, key
, len
, key
, len
, 0, 0);
3284 ret
=memcached_append(memc
, key
, len
, key
, len
, 0, 0);
3287 ret
=memcached_prepend(memc
, key
, len
, key
, len
, 0, 0);
3290 assert(ret
== MEMCACHED_SUCCESS
|| ret
== MEMCACHED_BUFFERED
);
3294 ** NOTE: Don't ever do this in your code! this is not a supported use of the
3295 ** API and is _ONLY_ done this way to verify that the library works the
3296 ** way it is supposed to do!!!!
3299 for (uint32_t x
=0; x
< memc
->number_of_hosts
; ++x
)
3300 no_msg
+=memc
->hosts
[x
].cursor_active
;
3302 assert(no_msg
== 0);
3303 assert(memcached_flush_buffers(memc
) == MEMCACHED_SUCCESS
);
3306 ** Now validate that all items was set properly!
3308 for (int x
=0; x
< 100; ++x
)
3311 size_t len
=sprintf(key
, "%d", x
);
3314 char* value
=memcached_get(memc
, key
, strlen(key
),
3315 &length
, &flags
, &ret
);
3316 assert(ret
== MEMCACHED_SUCCESS
&& value
!= NULL
);
3319 case 0: /* FALLTHROUGH */
3320 case 1: /* FALLTHROUGH */
3322 assert(strncmp(value
, key
, len
) == 0);
3323 assert(len
== length
);
3326 assert(length
== len
* 2);
3329 assert(length
== len
* 3);
3336 /* Try setting an illegal cas value (should not return an error to
3337 * the caller (because we don't expect a return message from the server)
3339 char* keys
[]= {"0"};
3340 size_t lengths
[]= {1};
3343 memcached_result_st results_obj
;
3344 memcached_result_st
*results
;
3345 ret
=memcached_mget(memc
, keys
, lengths
, 1);
3346 assert(ret
== MEMCACHED_SUCCESS
);
3348 results
=memcached_result_create(memc
, &results_obj
);
3350 results
=memcached_fetch_result(memc
, &results_obj
, &ret
);
3352 assert(ret
== MEMCACHED_SUCCESS
);
3353 uint64_t cas
= memcached_result_cas(results
);
3354 memcached_result_free(&results_obj
);
3356 ret
= memcached_cas(memc
, keys
[0], lengths
[0], keys
[0], lengths
[0], 0, 0, cas
);
3357 assert(ret
== MEMCACHED_SUCCESS
);
3360 * The item will have a new cas value, so try to set it again with the old
3361 * value. This should fail!
3363 ret
= memcached_cas(memc
, keys
[0], lengths
[0], keys
[0], lengths
[0], 0, 0, cas
);
3364 assert(ret
== MEMCACHED_SUCCESS
);
3365 assert(memcached_flush_buffers(memc
) == MEMCACHED_SUCCESS
);
3366 char* value
=memcached_get(memc
, keys
[0], lengths
[0], &length
, &flags
, &ret
);
3367 assert(ret
== MEMCACHED_SUCCESS
&& value
!= NULL
);
3370 return TEST_SUCCESS
;
3373 static test_return
analyzer_test(memcached_st
*memc
)
3375 memcached_return rc
;
3376 memcached_stat_st
*stat
;
3377 memcached_analysis_st
*report
;
3379 stat
= memcached_stat(memc
, NULL
, &rc
);
3380 assert(rc
== MEMCACHED_SUCCESS
);
3383 report
= memcached_analyze(memc
, stat
, &rc
);
3384 assert(rc
== MEMCACHED_SUCCESS
);
3388 memcached_stat_free(NULL
, stat
);
3390 return TEST_SUCCESS
;
3393 #ifdef HAVE_LIBMEMCACHEDUTIL
3394 static void* connection_release(void *arg
) {
3396 memcached_pool_st
* pool
;
3401 assert(memcached_pool_push(resource
->pool
, resource
->mmc
) == MEMCACHED_SUCCESS
);
3405 static test_return
connection_pool_test(memcached_st
*memc
)
3407 memcached_pool_st
* pool
= memcached_pool_create(memc
, 5, 10);
3408 assert(pool
!= NULL
);
3409 memcached_st
* mmc
[10];
3410 memcached_return rc
;
3412 for (int x
= 0; x
< 10; ++x
) {
3413 mmc
[x
]= memcached_pool_pop(pool
, false, &rc
);
3414 assert(mmc
[x
] != NULL
);
3415 assert(rc
== MEMCACHED_SUCCESS
);
3418 assert(memcached_pool_pop(pool
, false, &rc
) == NULL
);
3419 assert(rc
== MEMCACHED_SUCCESS
);
3423 memcached_pool_st
* pool
;
3425 } item
= { .pool
= pool
, .mmc
= mmc
[9] };
3426 pthread_create(&tid
, NULL
, connection_release
, &item
);
3427 mmc
[9]= memcached_pool_pop(pool
, true, &rc
);
3428 assert(rc
== MEMCACHED_SUCCESS
);
3429 pthread_join(tid
, NULL
);
3430 assert(mmc
[9] == item
.mmc
);
3431 const char *key
= "key";
3432 size_t keylen
= strlen(key
);
3434 // verify that I can do ops with all connections
3435 rc
= memcached_set(mmc
[0], key
, keylen
, "0", 1, 0, 0);
3436 assert(rc
== MEMCACHED_SUCCESS
);
3438 for (unsigned int x
= 0; x
< 10; ++x
) {
3439 uint64_t number_value
;
3440 rc
= memcached_increment(mmc
[x
], key
, keylen
, 1, &number_value
);
3441 assert(rc
== MEMCACHED_SUCCESS
);
3442 assert(number_value
== (x
+1));
3446 for (int x
= 0; x
< 10; ++x
)
3447 assert(memcached_pool_push(pool
, mmc
[x
]) == MEMCACHED_SUCCESS
);
3449 assert(memcached_pool_destroy(pool
) == memc
);
3450 return TEST_SUCCESS
;
3454 static void increment_request_id(uint16_t *id
)
3457 if ((*id
& UDP_REQUEST_ID_THREAD_MASK
) != 0)
3461 static uint16_t *get_udp_request_ids(memcached_st
*memc
)
3463 uint16_t *ids
= malloc(sizeof(uint16_t) * memc
->number_of_hosts
);
3464 assert(ids
!= NULL
);
3466 for (x
= 0; x
< memc
->number_of_hosts
; x
++)
3467 ids
[x
]= get_udp_datagram_request_id((struct udp_datagram_header_st
*) memc
->hosts
[x
].write_buffer
);
3472 static test_return
post_udp_op_check(memcached_st
*memc
, uint16_t *expected_req_ids
)
3475 memcached_server_st
*cur_server
= memc
->hosts
;
3476 uint16_t *cur_req_ids
= get_udp_request_ids(memc
);
3477 for (x
= 0; x
< memc
->number_of_hosts
; x
++)
3479 assert(cur_server
[x
].cursor_active
== 0);
3480 assert(cur_req_ids
[x
] == expected_req_ids
[x
]);
3482 free(expected_req_ids
);
3484 return TEST_SUCCESS
;
3488 ** There is a little bit of a hack here, instead of removing
3489 ** the servers, I just set num host to 0 and them add then new udp servers
3491 static memcached_return
init_udp(memcached_st
*memc
)
3493 memcached_version(memc
);
3494 /* For the time being, only support udp test for >= 1.2.6 && < 1.3 */
3495 if (memc
->hosts
[0].major_version
!= 1 || memc
->hosts
[0].minor_version
!= 2
3496 || memc
->hosts
[0].micro_version
< 6)
3497 return MEMCACHED_FAILURE
;
3499 uint32_t num_hosts
= memc
->number_of_hosts
;
3501 memcached_server_st servers
[num_hosts
];
3502 memcpy(servers
, memc
->hosts
, sizeof(memcached_server_st
) * num_hosts
);
3503 for (x
= 0; x
< num_hosts
; x
++)
3504 memcached_server_free(&memc
->hosts
[x
]);
3505 memc
->number_of_hosts
= 0;
3506 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_USE_UDP
, 1);
3507 for (x
= 0; x
< num_hosts
; x
++)
3509 assert(memcached_server_add_udp(memc
, servers
[x
].hostname
, servers
[x
].port
) == MEMCACHED_SUCCESS
);
3510 assert(memc
->hosts
[x
].write_buffer_offset
== UDP_DATAGRAM_HEADER_LENGTH
);
3512 return MEMCACHED_SUCCESS
;
3515 static memcached_return
binary_init_udp(memcached_st
*memc
)
3518 return init_udp(memc
);
3521 /* Make sure that I cant add a tcp server to a udp client */
3522 static test_return
add_tcp_server_udp_client_test(memcached_st
*memc
)
3524 memcached_server_st server
;
3525 memcached_server_clone(&server
, &memc
->hosts
[0]);
3526 assert(memcached_server_remove(&(memc
->hosts
[0])) == MEMCACHED_SUCCESS
);
3527 assert(memcached_server_add(memc
, server
.hostname
, server
.port
) == MEMCACHED_INVALID_HOST_PROTOCOL
);
3528 return TEST_SUCCESS
;
3531 /* Make sure that I cant add a udp server to a tcp client */
3532 static test_return
add_udp_server_tcp_client_test(memcached_st
*memc
)
3534 memcached_server_st server
;
3535 memcached_server_clone(&server
, &memc
->hosts
[0]);
3536 assert(memcached_server_remove(&(memc
->hosts
[0])) == MEMCACHED_SUCCESS
);
3538 memcached_st tcp_client
;
3539 memcached_create(&tcp_client
);
3540 assert(memcached_server_add_udp(&tcp_client
, server
.hostname
, server
.port
) == MEMCACHED_INVALID_HOST_PROTOCOL
);
3541 return TEST_SUCCESS
;
3544 static test_return
set_udp_behavior_test(memcached_st
*memc
)
3547 memcached_quit(memc
);
3548 memc
->number_of_hosts
= 0;
3549 run_distribution(memc
);
3550 assert(memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_USE_UDP
, 1) == MEMCACHED_SUCCESS
);
3551 assert(memc
->flags
& MEM_USE_UDP
);
3552 assert(memc
->flags
& MEM_NOREPLY
);;
3554 assert(memc
->number_of_hosts
== 0);
3556 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_USE_UDP
,0);
3557 assert(!(memc
->flags
& MEM_USE_UDP
));
3558 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NOREPLY
,0);
3559 assert(!(memc
->flags
& MEM_NOREPLY
));
3560 return TEST_SUCCESS
;
3563 static test_return
udp_set_test(memcached_st
*memc
)
3566 unsigned int num_iters
= 1025; //request id rolls over at 1024
3567 for (x
= 0; x
< num_iters
;x
++)
3569 memcached_return rc
;
3571 char *value
= "when we sanitize";
3572 uint16_t *expected_ids
= get_udp_request_ids(memc
);
3573 unsigned int server_key
= memcached_generate_hash(memc
,key
,strlen(key
));
3574 size_t init_offset
= memc
->hosts
[server_key
].write_buffer_offset
;
3575 rc
= memcached_set(memc
, key
, strlen(key
),
3576 value
, strlen(value
),
3577 (time_t)0, (uint32_t)0);
3578 assert(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
);
3579 /** NB, the check below assumes that if new write_ptr is less than
3580 * the original write_ptr that we have flushed. For large payloads, this
3581 * maybe an invalid assumption, but for the small payload we have it is OK
3583 if (rc
== MEMCACHED_SUCCESS
||
3584 memc
->hosts
[server_key
].write_buffer_offset
< init_offset
)
3585 increment_request_id(&expected_ids
[server_key
]);
3587 if (rc
== MEMCACHED_SUCCESS
)
3589 assert(memc
->hosts
[server_key
].write_buffer_offset
== UDP_DATAGRAM_HEADER_LENGTH
);
3593 assert(memc
->hosts
[server_key
].write_buffer_offset
!= UDP_DATAGRAM_HEADER_LENGTH
);
3594 assert(memc
->hosts
[server_key
].write_buffer_offset
<= MAX_UDP_DATAGRAM_LENGTH
);
3596 assert(post_udp_op_check(memc
,expected_ids
) == TEST_SUCCESS
);
3598 return TEST_SUCCESS
;
3601 static test_return
udp_buffered_set_test(memcached_st
*memc
)
3603 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_BUFFER_REQUESTS
, 1);
3604 return udp_set_test(memc
);
3607 static test_return
udp_set_too_big_test(memcached_st
*memc
)
3609 memcached_return rc
;
3611 char value
[MAX_UDP_DATAGRAM_LENGTH
];
3612 uint16_t *expected_ids
= get_udp_request_ids(memc
);
3613 rc
= memcached_set(memc
, key
, strlen(key
),
3614 value
, MAX_UDP_DATAGRAM_LENGTH
,
3615 (time_t)0, (uint32_t)0);
3616 assert(rc
== MEMCACHED_WRITE_FAILURE
);
3617 return post_udp_op_check(memc
,expected_ids
);
3620 static test_return
udp_delete_test(memcached_st
*memc
)
3623 unsigned int num_iters
= 1025; //request id rolls over at 1024
3624 for (x
= 0; x
< num_iters
;x
++)
3626 memcached_return rc
;
3628 uint16_t *expected_ids
=get_udp_request_ids(memc
);
3629 unsigned int server_key
= memcached_generate_hash(memc
, key
, strlen(key
));
3630 size_t init_offset
= memc
->hosts
[server_key
].write_buffer_offset
;
3631 rc
= memcached_delete(memc
, key
, strlen(key
), 0);
3632 assert(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
);
3633 if (rc
== MEMCACHED_SUCCESS
|| memc
->hosts
[server_key
].write_buffer_offset
< init_offset
)
3634 increment_request_id(&expected_ids
[server_key
]);
3635 if (rc
== MEMCACHED_SUCCESS
)
3636 assert(memc
->hosts
[server_key
].write_buffer_offset
== UDP_DATAGRAM_HEADER_LENGTH
);
3639 assert(memc
->hosts
[server_key
].write_buffer_offset
!= UDP_DATAGRAM_HEADER_LENGTH
);
3640 assert(memc
->hosts
[server_key
].write_buffer_offset
<= MAX_UDP_DATAGRAM_LENGTH
);
3642 assert(post_udp_op_check(memc
,expected_ids
) == TEST_SUCCESS
);
3644 return TEST_SUCCESS
;
3647 static test_return
udp_buffered_delete_test(memcached_st
*memc
)
3649 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_BUFFER_REQUESTS
, 1);
3650 return udp_delete_test(memc
);
3653 static test_return
udp_verbosity_test(memcached_st
*memc
)
3655 memcached_return rc
;
3656 uint16_t *expected_ids
= get_udp_request_ids(memc
);
3658 for (x
= 0; x
< memc
->number_of_hosts
;x
++)
3659 increment_request_id(&expected_ids
[x
]);
3661 rc
= memcached_verbosity(memc
,3);
3662 assert(rc
== MEMCACHED_SUCCESS
);
3663 return post_udp_op_check(memc
,expected_ids
);
3666 static test_return
udp_quit_test(memcached_st
*memc
)
3668 uint16_t *expected_ids
= get_udp_request_ids(memc
);
3669 memcached_quit(memc
);
3670 return post_udp_op_check(memc
, expected_ids
);
3673 static test_return
udp_flush_test(memcached_st
*memc
)
3675 memcached_return rc
;
3676 uint16_t *expected_ids
= get_udp_request_ids(memc
);
3678 for (x
= 0; x
< memc
->number_of_hosts
;x
++)
3679 increment_request_id(&expected_ids
[x
]);
3681 rc
= memcached_flush(memc
,0);
3682 assert(rc
== MEMCACHED_SUCCESS
);
3683 return post_udp_op_check(memc
,expected_ids
);
3686 static test_return
udp_incr_test(memcached_st
*memc
)
3688 memcached_return rc
;
3691 rc
= memcached_set(memc
, key
, strlen(key
),
3692 value
, strlen(value
),
3693 (time_t)0, (uint32_t)0);
3695 assert(rc
== MEMCACHED_SUCCESS
);
3696 uint16_t *expected_ids
= get_udp_request_ids(memc
);
3697 unsigned int server_key
= memcached_generate_hash(memc
, key
, strlen(key
));
3698 increment_request_id(&expected_ids
[server_key
]);
3700 rc
= memcached_increment(memc
, key
, strlen(key
), 1, &newvalue
);
3701 assert(rc
== MEMCACHED_SUCCESS
);
3702 return post_udp_op_check(memc
, expected_ids
);
3705 static test_return
udp_decr_test(memcached_st
*memc
)
3707 memcached_return rc
;
3710 rc
= memcached_set(memc
, key
, strlen(key
),
3711 value
, strlen(value
),
3712 (time_t)0, (uint32_t)0);
3714 assert(rc
== MEMCACHED_SUCCESS
);
3715 uint16_t *expected_ids
= get_udp_request_ids(memc
);
3716 unsigned int server_key
= memcached_generate_hash(memc
, key
, strlen(key
));
3717 increment_request_id(&expected_ids
[server_key
]);
3719 rc
= memcached_decrement(memc
, key
, strlen(key
), 1, &newvalue
);
3720 assert(rc
== MEMCACHED_SUCCESS
);
3721 return post_udp_op_check(memc
, expected_ids
);
3725 static test_return
udp_stat_test(memcached_st
*memc
)
3727 memcached_stat_st
* rv
= NULL
;
3728 memcached_return rc
;
3730 uint16_t *expected_ids
= get_udp_request_ids(memc
);
3731 rv
= memcached_stat(memc
, args
, &rc
);
3733 assert(rc
== MEMCACHED_NOT_SUPPORTED
);
3734 return post_udp_op_check(memc
, expected_ids
);
3737 static test_return
udp_version_test(memcached_st
*memc
)
3739 memcached_return rc
;
3740 uint16_t *expected_ids
= get_udp_request_ids(memc
);
3741 rc
= memcached_version(memc
);
3742 assert(rc
== MEMCACHED_NOT_SUPPORTED
);
3743 return post_udp_op_check(memc
, expected_ids
);
3746 static test_return
udp_get_test(memcached_st
*memc
)
3748 memcached_return rc
;
3751 uint16_t *expected_ids
= get_udp_request_ids(memc
);
3752 char *val
= memcached_get(memc
, key
, strlen(key
), &vlen
, (uint32_t)0, &rc
);
3753 assert(rc
== MEMCACHED_NOT_SUPPORTED
);
3754 assert(val
== NULL
);
3755 return post_udp_op_check(memc
, expected_ids
);
3758 static test_return
udp_mixed_io_test(memcached_st
*memc
)
3761 test_st mixed_io_ops
[] ={
3762 {"udp_set_test", 0, udp_set_test
},
3763 {"udp_set_too_big_test", 0, udp_set_too_big_test
},
3764 {"udp_delete_test", 0, udp_delete_test
},
3765 {"udp_verbosity_test", 0, udp_verbosity_test
},
3766 {"udp_quit_test", 0, udp_quit_test
},
3767 {"udp_flush_test", 0, udp_flush_test
},
3768 {"udp_incr_test", 0, udp_incr_test
},
3769 {"udp_decr_test", 0, udp_decr_test
},
3770 {"udp_version_test", 0, udp_version_test
}
3773 for (x
= 0; x
< 500; x
++)
3775 current_op
= mixed_io_ops
[random() % 9];
3776 assert(current_op
.function(memc
) == TEST_SUCCESS
);
3778 return TEST_SUCCESS
;
3781 static test_return
hsieh_avaibility_test (memcached_st
*memc
)
3783 memcached_return expected_rc
= MEMCACHED_FAILURE
;
3784 #ifdef HAVE_HSIEH_HASH
3785 expected_rc
= MEMCACHED_SUCCESS
;
3787 memcached_return rc
= memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_HASH
,
3788 (uint64_t)MEMCACHED_HASH_HSIEH
);
3789 assert(rc
== expected_rc
);
3790 return TEST_SUCCESS
;
3793 test_st udp_setup_server_tests
[] ={
3794 {"set_udp_behavior_test", 0, set_udp_behavior_test
},
3795 {"add_tcp_server_udp_client_test", 0, add_tcp_server_udp_client_test
},
3796 {"add_udp_server_tcp_client_test", 0, add_udp_server_tcp_client_test
},
3800 test_st upd_io_tests
[] ={
3801 {"udp_set_test", 0, udp_set_test
},
3802 {"udp_buffered_set_test", 0, udp_buffered_set_test
},
3803 {"udp_set_too_big_test", 0, udp_set_too_big_test
},
3804 {"udp_delete_test", 0, udp_delete_test
},
3805 {"udp_buffered_delete_test", 0, udp_buffered_delete_test
},
3806 {"udp_verbosity_test", 0, udp_verbosity_test
},
3807 {"udp_quit_test", 0, udp_quit_test
},
3808 {"udp_flush_test", 0, udp_flush_test
},
3809 {"udp_incr_test", 0, udp_incr_test
},
3810 {"udp_decr_test", 0, udp_decr_test
},
3811 {"udp_stat_test", 0, udp_stat_test
},
3812 {"udp_version_test", 0, udp_version_test
},
3813 {"udp_get_test", 0, udp_get_test
},
3814 {"udp_mixed_io_test", 0, udp_mixed_io_test
},
3818 /* Clean the server before beginning testing */
3820 {"flush", 0, flush_test
},
3821 {"init", 0, init_test
},
3822 {"allocation", 0, allocation_test
},
3823 {"server_list_null_test", 0, server_list_null_test
},
3824 {"server_unsort", 0, server_unsort_test
},
3825 {"server_sort", 0, server_sort_test
},
3826 {"server_sort2", 0, server_sort2_test
},
3827 {"clone_test", 0, clone_test
},
3828 {"connection_test", 0, connection_test
},
3829 {"callback_test", 0, callback_test
},
3830 {"behavior_test", 0, behavior_test
},
3831 {"error", 0, error_test
},
3832 {"set", 0, set_test
},
3833 {"set2", 0, set_test2
},
3834 {"set3", 0, set_test3
},
3835 {"add", 1, add_test
},
3836 {"replace", 1, replace_test
},
3837 {"delete", 1, delete_test
},
3838 {"get", 1, get_test
},
3839 {"get2", 0, get_test2
},
3840 {"get3", 0, get_test3
},
3841 {"get4", 0, get_test4
},
3842 {"partial mget", 0, get_test5
},
3843 {"stats_servername", 0, stats_servername_test
},
3844 {"increment", 0, increment_test
},
3845 {"increment_with_initial", 1, increment_with_initial_test
},
3846 {"decrement", 0, decrement_test
},
3847 {"decrement_with_initial", 1, decrement_with_initial_test
},
3848 {"quit", 0, quit_test
},
3849 {"mget", 1, mget_test
},
3850 {"mget_result", 1, mget_result_test
},
3851 {"mget_result_alloc", 1, mget_result_alloc_test
},
3852 {"mget_result_function", 1, mget_result_function
},
3853 {"get_stats", 0, get_stats
},
3854 {"add_host_test", 0, add_host_test
},
3855 {"add_host_test_1", 0, add_host_test1
},
3856 {"get_stats_keys", 0, get_stats_keys
},
3857 {"behavior_test", 0, get_stats_keys
},
3858 {"callback_test", 0, get_stats_keys
},
3859 {"version_string_test", 0, version_string_test
},
3860 {"bad_key", 1, bad_key_test
},
3861 {"memcached_server_cursor", 1, memcached_server_cursor_test
},
3862 {"read_through", 1, read_through
},
3863 {"delete_through", 1, delete_through
},
3864 {"noreply", 1, noreply_test
},
3865 {"analyzer", 1, analyzer_test
},
3866 #ifdef HAVE_LIBMEMCACHEDUTIL
3867 {"connectionpool", 1, connection_pool_test
},
3872 test_st async_tests
[] ={
3873 {"add", 1, add_wrapper
},
3877 test_st string_tests
[] ={
3878 {"string static with null", 0, string_static_null
},
3879 {"string alloc with null", 0, string_alloc_null
},
3880 {"string alloc with 1K", 0, string_alloc_with_size
},
3881 {"string alloc with malloc failure", 0, string_alloc_with_size_toobig
},
3882 {"string append", 0, string_alloc_append
},
3883 {"string append failure (too big)", 0, string_alloc_append_toobig
},
3887 test_st result_tests
[] ={
3888 {"result static", 0, result_static
},
3889 {"result alloc", 0, result_alloc
},
3893 test_st version_1_2_3
[] ={
3894 {"append", 0, append_test
},
3895 {"prepend", 0, prepend_test
},
3896 {"cas", 0, cas_test
},
3897 {"cas2", 0, cas2_test
},
3898 {"append_binary", 0, append_binary_test
},
3902 test_st user_tests
[] ={
3903 {"user_supplied_bug1", 0, user_supplied_bug1
},
3904 {"user_supplied_bug2", 0, user_supplied_bug2
},
3905 {"user_supplied_bug3", 0, user_supplied_bug3
},
3906 {"user_supplied_bug4", 0, user_supplied_bug4
},
3907 {"user_supplied_bug5", 1, user_supplied_bug5
},
3908 {"user_supplied_bug6", 1, user_supplied_bug6
},
3909 {"user_supplied_bug7", 1, user_supplied_bug7
},
3910 {"user_supplied_bug8", 1, user_supplied_bug8
},
3911 {"user_supplied_bug9", 1, user_supplied_bug9
},
3912 {"user_supplied_bug10", 1, user_supplied_bug10
},
3913 {"user_supplied_bug11", 1, user_supplied_bug11
},
3914 {"user_supplied_bug12", 1, user_supplied_bug12
},
3915 {"user_supplied_bug13", 1, user_supplied_bug13
},
3916 {"user_supplied_bug14", 1, user_supplied_bug14
},
3917 {"user_supplied_bug15", 1, user_supplied_bug15
},
3918 {"user_supplied_bug16", 1, user_supplied_bug16
},
3921 ** It seems to be something weird with the character sets..
3922 ** value_fetch is unable to parse the value line (iscntrl "fails"), so I
3923 ** guess I need to find out how this is supposed to work.. Perhaps I need
3924 ** to run the test in a specific locale (I tried zh_CN.UTF-8 without success,
3925 ** so just disable the code for now...).
3927 {"user_supplied_bug17", 1, user_supplied_bug17
},
3929 {"user_supplied_bug18", 1, user_supplied_bug18
},
3930 {"user_supplied_bug19", 1, user_supplied_bug19
},
3931 {"user_supplied_bug20", 1, user_supplied_bug20
},
3935 test_st generate_tests
[] ={
3936 {"generate_pairs", 1, generate_pairs
},
3937 {"generate_data", 1, generate_data
},
3938 {"get_read", 0, get_read
},
3939 {"delete_generate", 0, delete_generate
},
3940 {"generate_buffer_data", 1, generate_buffer_data
},
3941 {"delete_buffer", 0, delete_buffer_generate
},
3942 {"generate_data", 1, generate_data
},
3943 {"mget_read", 0, mget_read
},
3944 {"mget_read_result", 0, mget_read_result
},
3945 {"mget_read_function", 0, mget_read_function
},
3946 {"cleanup", 1, cleanup_pairs
},
3947 {"generate_large_pairs", 1, generate_large_pairs
},
3948 {"generate_data", 1, generate_data
},
3949 {"generate_buffer_data", 1, generate_buffer_data
},
3950 {"cleanup", 1, cleanup_pairs
},
3954 test_st consistent_tests
[] ={
3955 {"generate_pairs", 1, generate_pairs
},
3956 {"generate_data", 1, generate_data
},
3957 {"get_read", 0, get_read_count
},
3958 {"cleanup", 1, cleanup_pairs
},
3962 test_st consistent_weighted_tests
[] ={
3963 {"generate_pairs", 1, generate_pairs
},
3964 {"generate_data", 1, generate_data_with_stats
},
3965 {"get_read", 0, get_read_count
},
3966 {"cleanup", 1, cleanup_pairs
},
3970 test_st hsieh_availability
[] ={
3971 {"hsieh_avaibility_test",0,hsieh_avaibility_test
},
3975 test_st ketama_auto_eject_hosts
[] ={
3976 {"auto_eject_hosts", 1, auto_eject_hosts
},
3980 collection_st collection
[] ={
3981 {"hsieh_availability",0,0,hsieh_availability
},
3982 {"udp_setup", init_udp
, 0, udp_setup_server_tests
},
3983 {"udp_io", init_udp
, 0, upd_io_tests
},
3984 {"udp_binary_io", binary_init_udp
, 0, upd_io_tests
},
3985 {"block", 0, 0, tests
},
3986 {"binary", pre_binary
, 0, tests
},
3987 {"nonblock", pre_nonblock
, 0, tests
},
3988 {"nodelay", pre_nodelay
, 0, tests
},
3989 {"settimer", pre_settimer
, 0, tests
},
3990 {"md5", pre_md5
, 0, tests
},
3991 {"crc", pre_crc
, 0, tests
},
3992 {"hsieh", pre_hsieh
, 0, tests
},
3993 {"jenkins", pre_jenkins
, 0, tests
},
3994 {"fnv1_64", pre_hash_fnv1_64
, 0, tests
},
3995 {"fnv1a_64", pre_hash_fnv1a_64
, 0, tests
},
3996 {"fnv1_32", pre_hash_fnv1_32
, 0, tests
},
3997 {"fnv1a_32", pre_hash_fnv1a_32
, 0, tests
},
3998 {"ketama", pre_behavior_ketama
, 0, tests
},
3999 {"ketama_auto_eject_hosts", pre_behavior_ketama
, 0, ketama_auto_eject_hosts
},
4000 {"unix_socket", pre_unix_socket
, 0, tests
},
4001 {"unix_socket_nodelay", pre_nodelay
, 0, tests
},
4002 {"poll_timeout", poll_timeout
, 0, tests
},
4003 {"gets", enable_cas
, 0, tests
},
4004 {"consistent", enable_consistent
, 0, tests
},
4005 {"memory_allocators", set_memory_alloc
, 0, tests
},
4006 {"prefix", set_prefix
, 0, tests
},
4007 {"version_1_2_3", check_for_1_2_3
, 0, version_1_2_3
},
4008 {"string", 0, 0, string_tests
},
4009 {"result", 0, 0, result_tests
},
4010 {"async", pre_nonblock
, 0, async_tests
},
4011 {"async_binary", pre_nonblock_binary
, 0, async_tests
},
4012 {"user", 0, 0, user_tests
},
4013 {"generate", 0, 0, generate_tests
},
4014 {"generate_hsieh", pre_hsieh
, 0, generate_tests
},
4015 {"generate_ketama", pre_behavior_ketama
, 0, generate_tests
},
4016 {"generate_hsieh_consistent", enable_consistent
, 0, generate_tests
},
4017 {"generate_md5", pre_md5
, 0, generate_tests
},
4018 {"generate_murmur", pre_murmur
, 0, generate_tests
},
4019 {"generate_jenkins", pre_jenkins
, 0, generate_tests
},
4020 {"generate_nonblock", pre_nonblock
, 0, generate_tests
},
4021 {"consistent_not", 0, 0, consistent_tests
},
4022 {"consistent_ketama", pre_behavior_ketama
, 0, consistent_tests
},
4023 {"consistent_ketama_weighted", pre_behavior_ketama_weighted
, 0, consistent_weighted_tests
},
4027 #define SERVERS_TO_CREATE 5
4029 /* Prototypes for functions we will pass to test framework */
4030 void *world_create(void);
4031 void world_destroy(void *p
);
4033 void *world_create(void)
4035 server_startup_st
*construct
;
4037 construct
= (server_startup_st
*)malloc(sizeof(server_startup_st
));
4038 memset(construct
, 0, sizeof(server_startup_st
));
4039 construct
->count
= SERVERS_TO_CREATE
;
4041 server_startup(construct
);
4047 void world_destroy(void *p
)
4049 server_startup_st
*construct
= (server_startup_st
*)p
;
4050 memcached_server_st
*servers
= (memcached_server_st
*)construct
->servers
;
4051 memcached_server_list_free(servers
);
4053 server_shutdown(construct
);
4057 void get_world(world_st
*world
)
4059 world
->collections
= collection
;
4060 world
->create
= world_create
;
4061 world
->destroy
= world_destroy
;