2 Sample test application.
14 #include "../clients/generator.h"
15 #include "../clients/execute.h"
18 #define INT64_MAX LONG_MAX
21 #define INT32_MAX INT_MAX
27 #define GLOBAL_COUNT 10000
28 #define GLOBAL2_COUNT 100
29 #define SERVERS_TO_CREATE 5
30 static uint32_t global_count
;
32 static pairs_st
*global_pairs
;
33 static char *global_keys
[GLOBAL_COUNT
];
34 static size_t global_keys_length
[GLOBAL_COUNT
];
36 static test_return
init_test(memcached_st
*not_used
__attribute__((unused
)))
40 (void)memcached_create(&memc
);
41 memcached_free(&memc
);
46 static test_return
server_list_null_test(memcached_st
*ptr
__attribute__((unused
)))
48 memcached_server_st
*server_list
;
51 server_list
= memcached_server_list_append_with_weight(NULL
, NULL
, 0, 0, NULL
);
52 assert(server_list
== NULL
);
54 server_list
= memcached_server_list_append_with_weight(NULL
, "localhost", 0, 0, NULL
);
55 assert(server_list
== NULL
);
57 server_list
= memcached_server_list_append_with_weight(NULL
, NULL
, 0, 0, &rc
);
58 assert(server_list
== NULL
);
63 #define TEST_PORT_COUNT 7
64 uint32_t test_ports
[TEST_PORT_COUNT
];
66 static memcached_return
server_display_function(memcached_st
*ptr
__attribute__((unused
)), memcached_server_st
*server
, void *context
)
69 uint32_t bigger
= *((uint32_t *)(context
));
70 assert(bigger
<= server
->port
);
71 *((uint32_t *)(context
))= server
->port
;
73 return MEMCACHED_SUCCESS
;
76 static test_return
server_sort_test(memcached_st
*ptr
__attribute__((unused
)))
79 uint32_t bigger
= 0; /* Prime the value for the assert in server_display_function */
81 memcached_server_function callbacks
[1];
82 memcached_st
*local_memc
;
84 local_memc
= memcached_create(NULL
);
86 memcached_behavior_set(local_memc
, MEMCACHED_BEHAVIOR_SORT_HOSTS
, 1);
88 for (x
= 0; x
< TEST_PORT_COUNT
; x
++)
90 test_ports
[x
]= random() % 64000;
91 rc
= memcached_server_add_with_weight(local_memc
, "localhost", test_ports
[x
], 0);
92 assert(local_memc
->number_of_hosts
== x
+ 1);
93 assert(local_memc
->hosts
[0].count
== x
+1);
94 assert(rc
== MEMCACHED_SUCCESS
);
97 callbacks
[0]= server_display_function
;
98 memcached_server_cursor(local_memc
, callbacks
, (void *)&bigger
, 1);
101 memcached_free(local_memc
);
106 static test_return
server_sort2_test(memcached_st
*ptr
__attribute__((unused
)))
108 uint32_t bigger
= 0; /* Prime the value for the assert in server_display_function */
110 memcached_server_function callbacks
[1];
111 memcached_st
*local_memc
;
113 local_memc
= memcached_create(NULL
);
115 rc
= memcached_behavior_set(local_memc
, MEMCACHED_BEHAVIOR_SORT_HOSTS
, 1);
116 assert(rc
== MEMCACHED_SUCCESS
);
118 rc
= memcached_server_add_with_weight(local_memc
, "MEMCACHED_BEHAVIOR_SORT_HOSTS", 43043, 0);
119 assert(rc
== MEMCACHED_SUCCESS
);
120 assert(local_memc
->hosts
[0].port
== 43043);
122 rc
= memcached_server_add_with_weight(local_memc
, "MEMCACHED_BEHAVIOR_SORT_HOSTS", 43042, 0);
123 assert(rc
== MEMCACHED_SUCCESS
);
124 assert(local_memc
->hosts
[0].port
== 43042);
125 assert(local_memc
->hosts
[1].port
== 43043);
127 callbacks
[0]= server_display_function
;
128 memcached_server_cursor(local_memc
, callbacks
, (void *)&bigger
, 1);
131 memcached_free(local_memc
);
136 static memcached_return
server_display_unsort_function(memcached_st
*ptr
__attribute__((unused
)), memcached_server_st
*server
, void *context
)
139 uint32_t x
= *((uint32_t *)(context
));
141 assert(test_ports
[x
] == server
->port
);
142 *((uint32_t *)(context
))= ++x
;
144 return MEMCACHED_SUCCESS
;
147 static test_return
server_unsort_test(memcached_st
*ptr
__attribute__((unused
)))
150 uint32_t counter
= 0; /* Prime the value for the assert in server_display_function */
151 uint32_t bigger
= 0; /* Prime the value for the assert in server_display_function */
153 memcached_server_function callbacks
[1];
154 memcached_st
*local_memc
;
156 local_memc
= memcached_create(NULL
);
159 for (x
= 0; x
< TEST_PORT_COUNT
; x
++)
161 test_ports
[x
]= random() % 64000;
162 rc
= memcached_server_add_with_weight(local_memc
, "localhost", test_ports
[x
], 0);
163 assert(local_memc
->number_of_hosts
== x
+1);
164 assert(local_memc
->hosts
[0].count
== x
+1);
165 assert(rc
== MEMCACHED_SUCCESS
);
168 callbacks
[0]= server_display_unsort_function
;
169 memcached_server_cursor(local_memc
, callbacks
, (void *)&counter
, 1);
171 /* Now we sort old data! */
172 memcached_behavior_set(local_memc
, MEMCACHED_BEHAVIOR_SORT_HOSTS
, 1);
173 callbacks
[0]= server_display_function
;
174 memcached_server_cursor(local_memc
, callbacks
, (void *)&bigger
, 1);
177 memcached_free(local_memc
);
182 static test_return
allocation_test(memcached_st
*not_used
__attribute__((unused
)))
185 memc
= memcached_create(NULL
);
187 memcached_free(memc
);
192 static test_return
clone_test(memcached_st
*memc
)
197 clone
= memcached_clone(NULL
, NULL
);
199 memcached_free(clone
);
202 /* Can we init from null? */
205 clone
= memcached_clone(NULL
, memc
);
208 assert(clone
->call_free
== memc
->call_free
);
209 assert(clone
->call_malloc
== memc
->call_malloc
);
210 assert(clone
->call_realloc
== memc
->call_realloc
);
211 assert(clone
->connect_timeout
== memc
->connect_timeout
);
212 assert(clone
->delete_trigger
== memc
->delete_trigger
);
213 assert(clone
->distribution
== memc
->distribution
);
214 assert(clone
->flags
== memc
->flags
);
215 assert(clone
->get_key_failure
== memc
->get_key_failure
);
216 assert(clone
->hash
== memc
->hash
);
217 assert(clone
->hash_continuum
== memc
->hash_continuum
);
218 assert(clone
->io_bytes_watermark
== memc
->io_bytes_watermark
);
219 assert(clone
->io_msg_watermark
== memc
->io_msg_watermark
);
220 assert(clone
->io_key_prefetch
== memc
->io_key_prefetch
);
221 assert(clone
->on_cleanup
== memc
->on_cleanup
);
222 assert(clone
->on_clone
== memc
->on_clone
);
223 assert(clone
->poll_timeout
== memc
->poll_timeout
);
224 assert(clone
->rcv_timeout
== memc
->rcv_timeout
);
225 assert(clone
->recv_size
== memc
->recv_size
);
226 assert(clone
->retry_timeout
== memc
->retry_timeout
);
227 assert(clone
->send_size
== memc
->send_size
);
228 assert(clone
->server_failure_limit
== memc
->server_failure_limit
);
229 assert(clone
->snd_timeout
== memc
->snd_timeout
);
230 assert(clone
->user_data
== memc
->user_data
);
232 memcached_free(clone
);
235 /* Can we init from struct? */
237 memcached_st declared_clone
;
239 memset(&declared_clone
, 0 , sizeof(memcached_st
));
240 clone
= memcached_clone(&declared_clone
, NULL
);
242 memcached_free(clone
);
245 /* Can we init from struct? */
247 memcached_st declared_clone
;
249 memset(&declared_clone
, 0 , sizeof(memcached_st
));
250 clone
= memcached_clone(&declared_clone
, memc
);
252 memcached_free(clone
);
258 static test_return
connection_test(memcached_st
*memc
)
262 rc
= memcached_server_add_with_weight(memc
, "localhost", 0, 0);
263 assert(rc
== MEMCACHED_SUCCESS
);
268 static test_return
error_test(memcached_st
*memc
)
272 for (rc
= MEMCACHED_SUCCESS
; rc
< MEMCACHED_MAXIMUM_RETURN
; rc
++)
274 printf("Error %d -> %s\n", rc
, memcached_strerror(memc
, rc
));
280 static test_return
set_test(memcached_st
*memc
)
284 char *value
= "when we sanitize";
286 rc
= memcached_set(memc
, key
, strlen(key
),
287 value
, strlen(value
),
288 (time_t)0, (uint32_t)0);
289 assert(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
);
294 static test_return
append_test(memcached_st
*memc
)
302 rc
= memcached_flush(memc
, 0);
303 assert(rc
== MEMCACHED_SUCCESS
);
305 rc
= memcached_set(memc
, key
, strlen(key
),
306 value
, strlen(value
),
307 (time_t)0, (uint32_t)0);
308 assert(rc
== MEMCACHED_SUCCESS
);
310 rc
= memcached_append(memc
, key
, strlen(key
),
311 " the", strlen(" the"),
312 (time_t)0, (uint32_t)0);
313 assert(rc
== MEMCACHED_SUCCESS
);
315 rc
= memcached_append(memc
, key
, strlen(key
),
316 " people", strlen(" people"),
317 (time_t)0, (uint32_t)0);
318 assert(rc
== MEMCACHED_SUCCESS
);
320 value
= memcached_get(memc
, key
, strlen(key
),
321 &value_length
, &flags
, &rc
);
322 assert(!memcmp(value
, "we the people", strlen("we the people")));
323 assert(strlen("we the people") == value_length
);
324 assert(rc
== MEMCACHED_SUCCESS
);
330 static test_return
append_binary_test(memcached_st
*memc
)
333 char *key
= "numbers";
334 unsigned int *store_ptr
;
335 unsigned int store_list
[] = { 23, 56, 499, 98, 32847, 0 };
341 rc
= memcached_flush(memc
, 0);
342 assert(rc
== MEMCACHED_SUCCESS
);
344 rc
= memcached_set(memc
,
347 (time_t)0, (uint32_t)0);
348 assert(rc
== MEMCACHED_SUCCESS
);
350 for (x
= 0; store_list
[x
] ; x
++)
352 rc
= memcached_append(memc
,
354 (char *)&store_list
[x
], sizeof(unsigned int),
355 (time_t)0, (uint32_t)0);
356 assert(rc
== MEMCACHED_SUCCESS
);
359 value
= memcached_get(memc
, key
, strlen(key
),
360 &value_length
, &flags
, &rc
);
361 assert((value_length
== (sizeof(unsigned int) * x
)));
362 assert(rc
== MEMCACHED_SUCCESS
);
364 store_ptr
= (unsigned int *)value
;
366 while ((size_t)store_ptr
< (size_t)(value
+ value_length
))
368 assert(*store_ptr
== store_list
[x
++]);
376 static test_return
cas2_test(memcached_st
*memc
)
379 char *keys
[]= {"fudge", "son", "food"};
380 size_t key_length
[]= {5, 3, 4};
381 char *value
= "we the people";
382 size_t value_length
= strlen("we the people");
384 memcached_result_st results_obj
;
385 memcached_result_st
*results
;
388 rc
= memcached_flush(memc
, 0);
389 assert(rc
== MEMCACHED_SUCCESS
);
391 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_SUPPORT_CAS
, set
);
393 for (x
= 0; x
< 3; x
++)
395 rc
= memcached_set(memc
, keys
[x
], key_length
[x
],
396 keys
[x
], key_length
[x
],
397 (time_t)50, (uint32_t)9);
398 assert(rc
== MEMCACHED_SUCCESS
);
401 rc
= memcached_mget(memc
, keys
, key_length
, 3);
403 results
= memcached_result_create(memc
, &results_obj
);
405 results
= memcached_fetch_result(memc
, &results_obj
, &rc
);
407 assert(results
->cas
);
408 assert(rc
== MEMCACHED_SUCCESS
);
409 WATCHPOINT_ASSERT(memcached_result_cas(results
));
411 assert(!memcmp(value
, "we the people", strlen("we the people")));
412 assert(strlen("we the people") == value_length
);
413 assert(rc
== MEMCACHED_SUCCESS
);
415 memcached_result_free(&results_obj
);
420 static test_return
cas_test(memcached_st
*memc
)
423 const char *key
= "fun";
424 size_t key_length
= strlen(key
);
425 const char *value
= "we the people";
426 char* keys
[2] = { (char*)key
, NULL
};
427 size_t keylengths
[2] = { strlen(key
), 0 };
428 size_t value_length
= strlen(value
);
429 const char *value2
= "change the value";
430 size_t value2_length
= strlen(value2
);
432 memcached_result_st results_obj
;
433 memcached_result_st
*results
;
436 rc
= memcached_flush(memc
, 0);
437 assert(rc
== MEMCACHED_SUCCESS
);
439 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_SUPPORT_CAS
, set
);
441 rc
= memcached_set(memc
, key
, strlen(key
),
442 value
, strlen(value
),
443 (time_t)0, (uint32_t)0);
444 assert(rc
== MEMCACHED_SUCCESS
);
446 rc
= memcached_mget(memc
, keys
, keylengths
, 1);
448 results
= memcached_result_create(memc
, &results_obj
);
450 results
= memcached_fetch_result(memc
, &results_obj
, &rc
);
452 assert(rc
== MEMCACHED_SUCCESS
);
453 WATCHPOINT_ASSERT(memcached_result_cas(results
));
454 assert(!memcmp(value
, memcached_result_value(results
), value_length
));
455 assert(strlen(memcached_result_value(results
)) == value_length
);
456 assert(rc
== MEMCACHED_SUCCESS
);
457 uint64_t cas
= memcached_result_cas(results
);
460 results
= memcached_fetch_result(memc
, &results_obj
, &rc
);
461 assert(rc
== MEMCACHED_END
);
462 assert(results
== NULL
);
465 rc
= memcached_cas(memc
, key
, key_length
, value2
, value2_length
, 0, 0, cas
);
466 assert(rc
== MEMCACHED_SUCCESS
);
469 * The item will have a new cas value, so try to set it again with the old
470 * value. This should fail!
472 rc
= memcached_cas(memc
, key
, key_length
, value2
, value2_length
, 0, 0, cas
);
473 assert(rc
== MEMCACHED_DATA_EXISTS
);
475 memcached_result_free(&results_obj
);
480 static test_return
prepend_test(memcached_st
*memc
)
484 char *value
= "people";
488 rc
= memcached_flush(memc
, 0);
489 assert(rc
== MEMCACHED_SUCCESS
);
491 rc
= memcached_set(memc
, key
, strlen(key
),
492 value
, strlen(value
),
493 (time_t)0, (uint32_t)0);
494 assert(rc
== MEMCACHED_SUCCESS
);
496 rc
= memcached_prepend(memc
, key
, strlen(key
),
497 "the ", strlen("the "),
498 (time_t)0, (uint32_t)0);
499 assert(rc
== MEMCACHED_SUCCESS
);
501 rc
= memcached_prepend(memc
, key
, strlen(key
),
502 "we ", strlen("we "),
503 (time_t)0, (uint32_t)0);
504 assert(rc
== MEMCACHED_SUCCESS
);
506 value
= memcached_get(memc
, key
, strlen(key
),
507 &value_length
, &flags
, &rc
);
508 assert(!memcmp(value
, "we the people", strlen("we the people")));
509 assert(strlen("we the people") == value_length
);
510 assert(rc
== MEMCACHED_SUCCESS
);
517 Set the value, then quit to make sure it is flushed.
518 Come back in and test that add fails.
520 static test_return
add_test(memcached_st
*memc
)
524 char *value
= "when we sanitize";
525 unsigned long long setting_value
;
527 setting_value
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_NO_BLOCK
);
529 rc
= memcached_set(memc
, key
, strlen(key
),
530 value
, strlen(value
),
531 (time_t)0, (uint32_t)0);
532 assert(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
);
533 memcached_quit(memc
);
534 rc
= memcached_add(memc
, key
, strlen(key
),
535 value
, strlen(value
),
536 (time_t)0, (uint32_t)0);
538 /* Too many broken OS'es have broken loopback in async, so we can't be sure of the result */
540 assert(rc
== MEMCACHED_NOTSTORED
|| rc
== MEMCACHED_STORED
);
542 assert(rc
== MEMCACHED_NOTSTORED
|| rc
== MEMCACHED_DATA_EXISTS
);
548 ** There was a problem of leaking filedescriptors in the initial release
549 ** of MacOSX 10.5. This test case triggers the problem. On some Solaris
550 ** systems it seems that the kernel is slow on reclaiming the resources
551 ** because the connects starts to time out (the test doesn't do much
552 ** anyway, so just loop 10 iterations)
554 static test_return
add_wrapper(memcached_st
*memc
)
557 unsigned int max
= 10000;
562 for (x
= 0; x
< max
; x
++)
568 static test_return
replace_test(memcached_st
*memc
)
572 char *value
= "when we sanitize";
573 char *original
= "first we insert some data";
575 rc
= memcached_set(memc
, key
, strlen(key
),
576 original
, strlen(original
),
577 (time_t)0, (uint32_t)0);
578 assert(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
);
580 rc
= memcached_replace(memc
, key
, strlen(key
),
581 value
, strlen(value
),
582 (time_t)0, (uint32_t)0);
583 assert(rc
== MEMCACHED_SUCCESS
);
588 static test_return
delete_test(memcached_st
*memc
)
592 char *value
= "when we sanitize";
594 rc
= memcached_set(memc
, key
, strlen(key
),
595 value
, strlen(value
),
596 (time_t)0, (uint32_t)0);
597 assert(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
);
599 rc
= memcached_delete(memc
, key
, strlen(key
), (time_t)0);
600 assert(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
);
605 static test_return
flush_test(memcached_st
*memc
)
609 rc
= memcached_flush(memc
, 0);
610 assert(rc
== MEMCACHED_SUCCESS
);
615 static memcached_return
server_function(memcached_st
*ptr
__attribute__((unused
)),
616 memcached_server_st
*server
__attribute__((unused
)),
617 void *context
__attribute__((unused
)))
621 return MEMCACHED_SUCCESS
;
624 static test_return
memcached_server_cursor_test(memcached_st
*memc
)
626 char *context
= "foo bad";
627 memcached_server_function callbacks
[1];
629 callbacks
[0]= server_function
;
630 memcached_server_cursor(memc
, callbacks
, context
, 1);
635 static test_return
bad_key_test(memcached_st
*memc
)
638 char *key
= "foo bad";
640 size_t string_length
;
644 size_t max_keylen
= 0xffff;
646 clone
= memcached_clone(NULL
, memc
);
649 rc
= memcached_behavior_set(clone
, MEMCACHED_BEHAVIOR_VERIFY_KEY
, set
);
650 assert(rc
== MEMCACHED_SUCCESS
);
652 /* All keys are valid in the binary protocol (except for length) */
653 if (memcached_behavior_get(clone
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
) == 0)
655 string
= memcached_get(clone
, key
, strlen(key
),
656 &string_length
, &flags
, &rc
);
657 assert(rc
== MEMCACHED_BAD_KEY_PROVIDED
);
658 assert(string_length
== 0);
662 rc
= memcached_behavior_set(clone
, MEMCACHED_BEHAVIOR_VERIFY_KEY
, set
);
663 assert(rc
== MEMCACHED_SUCCESS
);
664 string
= memcached_get(clone
, key
, strlen(key
),
665 &string_length
, &flags
, &rc
);
666 assert(rc
== MEMCACHED_NOTFOUND
);
667 assert(string_length
== 0);
670 /* Test multi key for bad keys */
671 char *keys
[] = { "GoodKey", "Bad Key", "NotMine" };
672 size_t key_lengths
[] = { 7, 7, 7 };
674 rc
= memcached_behavior_set(clone
, MEMCACHED_BEHAVIOR_VERIFY_KEY
, set
);
675 assert(rc
== MEMCACHED_SUCCESS
);
677 rc
= memcached_mget(clone
, keys
, key_lengths
, 3);
678 assert(rc
== MEMCACHED_BAD_KEY_PROVIDED
);
680 rc
= memcached_mget_by_key(clone
, "foo daddy", 9, keys
, key_lengths
, 1);
681 assert(rc
== MEMCACHED_BAD_KEY_PROVIDED
);
685 /* The following test should be moved to the end of this function when the
686 memcached server is updated to allow max size length of the keys in the
689 rc
= memcached_callback_set(clone
, MEMCACHED_CALLBACK_PREFIX_KEY
, NULL
);
690 assert(rc
== MEMCACHED_SUCCESS
);
692 char *longkey
= malloc(max_keylen
+ 1);
695 memset(longkey
, 'a', max_keylen
+ 1);
696 string
= memcached_get(clone
, longkey
, max_keylen
,
697 &string_length
, &flags
, &rc
);
698 assert(rc
== MEMCACHED_NOTFOUND
);
699 assert(string_length
== 0);
702 string
= memcached_get(clone
, longkey
, max_keylen
+ 1,
703 &string_length
, &flags
, &rc
);
704 assert(rc
== MEMCACHED_BAD_KEY_PROVIDED
);
705 assert(string_length
== 0);
712 /* Make sure zero length keys are marked as bad */
714 rc
= memcached_behavior_set(clone
, MEMCACHED_BEHAVIOR_VERIFY_KEY
, set
);
715 assert(rc
== MEMCACHED_SUCCESS
);
716 string
= memcached_get(clone
, key
, 0,
717 &string_length
, &flags
, &rc
);
718 assert(rc
== MEMCACHED_BAD_KEY_PROVIDED
);
719 assert(string_length
== 0);
722 memcached_free(clone
);
727 #define READ_THROUGH_VALUE "set for me"
728 static memcached_return
read_through_trigger(memcached_st
*memc
__attribute__((unused
)),
729 char *key
__attribute__((unused
)),
730 size_t key_length
__attribute__((unused
)),
731 memcached_result_st
*result
)
734 return memcached_result_set_value(result
, READ_THROUGH_VALUE
, strlen(READ_THROUGH_VALUE
));
737 static test_return
read_through(memcached_st
*memc
)
742 size_t string_length
;
745 string
= memcached_get(memc
, key
, strlen(key
),
746 &string_length
, &flags
, &rc
);
748 assert(rc
== MEMCACHED_NOTFOUND
);
749 assert(string_length
== 0);
752 rc
= memcached_callback_set(memc
, MEMCACHED_CALLBACK_GET_FAILURE
, (void *)read_through_trigger
);
753 assert(rc
== MEMCACHED_SUCCESS
);
755 string
= memcached_get(memc
, key
, strlen(key
),
756 &string_length
, &flags
, &rc
);
758 assert(rc
== MEMCACHED_SUCCESS
);
759 assert(string_length
== strlen(READ_THROUGH_VALUE
));
760 assert(!strcmp(READ_THROUGH_VALUE
, string
));
763 string
= memcached_get(memc
, key
, strlen(key
),
764 &string_length
, &flags
, &rc
);
766 assert(rc
== MEMCACHED_SUCCESS
);
767 assert(string_length
== strlen(READ_THROUGH_VALUE
));
768 assert(!strcmp(READ_THROUGH_VALUE
, string
));
774 static memcached_return
delete_trigger(memcached_st
*ptr
__attribute__((unused
)),
776 size_t key_length
__attribute__((unused
)))
780 return MEMCACHED_SUCCESS
;
783 static test_return
delete_through(memcached_st
*memc
)
785 memcached_trigger_delete_key callback
;
788 callback
= delete_trigger
;
790 rc
= memcached_callback_set(memc
, MEMCACHED_CALLBACK_DELETE_TRIGGER
, (void*)callback
);
791 assert(rc
== MEMCACHED_SUCCESS
);
796 static test_return
get_test(memcached_st
*memc
)
801 size_t string_length
;
804 rc
= memcached_delete(memc
, key
, strlen(key
), (time_t)0);
805 assert(rc
== MEMCACHED_BUFFERED
|| rc
== MEMCACHED_NOTFOUND
);
807 string
= memcached_get(memc
, key
, strlen(key
),
808 &string_length
, &flags
, &rc
);
810 assert(rc
== MEMCACHED_NOTFOUND
);
811 assert(string_length
== 0);
817 static test_return
get_test2(memcached_st
*memc
)
821 char *value
= "when we sanitize";
823 size_t string_length
;
826 rc
= memcached_set(memc
, key
, strlen(key
),
827 value
, strlen(value
),
828 (time_t)0, (uint32_t)0);
829 assert(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
);
831 string
= memcached_get(memc
, key
, strlen(key
),
832 &string_length
, &flags
, &rc
);
835 assert(rc
== MEMCACHED_SUCCESS
);
836 assert(string_length
== strlen(value
));
837 assert(!memcmp(string
, value
, string_length
));
844 static test_return
set_test2(memcached_st
*memc
)
848 char *value
= "train in the brain";
849 size_t value_length
= strlen(value
);
852 for (x
= 0; x
< 10; x
++)
854 rc
= memcached_set(memc
, key
, strlen(key
),
856 (time_t)0, (uint32_t)0);
857 assert(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
);
863 static test_return
set_test3(memcached_st
*memc
)
868 size_t value_length
= 8191;
871 value
= (char*)malloc(value_length
);
874 for (x
= 0; x
< value_length
; x
++)
875 value
[x
] = (char) (x
% 127);
877 for (x
= 0; x
< 1; x
++)
879 rc
= memcached_set(memc
, key
, strlen(key
),
881 (time_t)0, (uint32_t)0);
882 assert(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
);
890 static test_return
get_test3(memcached_st
*memc
)
895 size_t value_length
= 8191;
897 size_t string_length
;
901 value
= (char*)malloc(value_length
);
904 for (x
= 0; x
< value_length
; x
++)
905 value
[x
] = (char) (x
% 127);
907 rc
= memcached_set(memc
, key
, strlen(key
),
909 (time_t)0, (uint32_t)0);
910 assert(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
);
912 string
= memcached_get(memc
, key
, strlen(key
),
913 &string_length
, &flags
, &rc
);
915 assert(rc
== MEMCACHED_SUCCESS
);
917 assert(string_length
== value_length
);
918 assert(!memcmp(string
, value
, string_length
));
926 static test_return
get_test4(memcached_st
*memc
)
931 size_t value_length
= 8191;
933 size_t string_length
;
937 value
= (char*)malloc(value_length
);
940 for (x
= 0; x
< value_length
; x
++)
941 value
[x
] = (char) (x
% 127);
943 rc
= memcached_set(memc
, key
, strlen(key
),
945 (time_t)0, (uint32_t)0);
946 assert(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
);
948 for (x
= 0; x
< 10; x
++)
950 string
= memcached_get(memc
, key
, strlen(key
),
951 &string_length
, &flags
, &rc
);
953 assert(rc
== MEMCACHED_SUCCESS
);
955 assert(string_length
== value_length
);
956 assert(!memcmp(string
, value
, string_length
));
966 * This test verifies that memcached_read_one_response doesn't try to
967 * dereference a NIL-pointer if you issue a multi-get and don't read out all
968 * responses before you execute a storage command.
970 static test_return
get_test5(memcached_st
*memc
)
973 ** Request the same key twice, to ensure that we hash to the same server
974 ** (so that we have multiple response values queued up) ;-)
976 char *keys
[]= { "key", "key" };
977 size_t lengths
[]= { 3, 3 };
981 memcached_return rc
= memcached_set(memc
, keys
[0], lengths
[0],
982 keys
[0], lengths
[0], 0, 0);
983 assert(rc
== MEMCACHED_SUCCESS
);
984 rc
= memcached_mget(memc
, keys
, lengths
, 2);
986 memcached_result_st results_obj
;
987 memcached_result_st
*results
;
988 results
=memcached_result_create(memc
, &results_obj
);
990 results
=memcached_fetch_result(memc
, &results_obj
, &rc
);
992 memcached_result_free(&results_obj
);
994 /* Don't read out the second result, but issue a set instead.. */
995 rc
= memcached_set(memc
, keys
[0], lengths
[0], keys
[0], lengths
[0], 0, 0);
996 assert(rc
== MEMCACHED_SUCCESS
);
998 char *val
= memcached_get_by_key(memc
, keys
[0], lengths
[0], "yek", 3,
1000 assert(val
== NULL
);
1001 assert(rc
== MEMCACHED_NOTFOUND
);
1002 val
= memcached_get(memc
, keys
[0], lengths
[0], &rlen
, &flags
, &rc
);
1003 assert(val
!= NULL
);
1004 assert(rc
== MEMCACHED_SUCCESS
);
1007 return TEST_SUCCESS
;
1010 /* Do not copy the style of this code, I just access hosts to testthis function */
1011 static test_return
stats_servername_test(memcached_st
*memc
)
1013 memcached_return rc
;
1014 memcached_stat_st stat
;
1015 rc
= memcached_stat_servername(&stat
, NULL
,
1016 memc
->hosts
[0].hostname
,
1017 memc
->hosts
[0].port
);
1022 static test_return
increment_test(memcached_st
*memc
)
1024 uint64_t new_number
;
1025 memcached_return rc
;
1026 char *key
= "number";
1029 rc
= memcached_set(memc
, key
, strlen(key
),
1030 value
, strlen(value
),
1031 (time_t)0, (uint32_t)0);
1032 assert(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
);
1034 rc
= memcached_increment(memc
, key
, strlen(key
),
1036 assert(rc
== MEMCACHED_SUCCESS
);
1037 assert(new_number
== 1);
1039 rc
= memcached_increment(memc
, key
, strlen(key
),
1041 assert(rc
== MEMCACHED_SUCCESS
);
1042 assert(new_number
== 2);
1047 static test_return
increment_with_initial_test(memcached_st
*memc
)
1049 if (memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
) != 0)
1051 uint64_t new_number
;
1052 memcached_return rc
;
1053 char *key
= "number";
1054 uint64_t initial
= 0;
1056 rc
= memcached_increment_with_initial(memc
, key
, strlen(key
),
1057 1, initial
, 0, &new_number
);
1058 assert(rc
== MEMCACHED_SUCCESS
);
1059 assert(new_number
== initial
);
1061 rc
= memcached_increment_with_initial(memc
, key
, strlen(key
),
1062 1, initial
, 0, &new_number
);
1063 assert(rc
== MEMCACHED_SUCCESS
);
1064 assert(new_number
== (initial
+ 1));
1069 static test_return
decrement_test(memcached_st
*memc
)
1071 uint64_t new_number
;
1072 memcached_return rc
;
1073 char *key
= "number";
1076 rc
= memcached_set(memc
, key
, strlen(key
),
1077 value
, strlen(value
),
1078 (time_t)0, (uint32_t)0);
1079 assert(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
);
1081 rc
= memcached_decrement(memc
, key
, strlen(key
),
1083 assert(rc
== MEMCACHED_SUCCESS
);
1084 assert(new_number
== 2);
1086 rc
= memcached_decrement(memc
, key
, strlen(key
),
1088 assert(rc
== MEMCACHED_SUCCESS
);
1089 assert(new_number
== 1);
1094 static test_return
decrement_with_initial_test(memcached_st
*memc
)
1096 if (memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
) != 0)
1098 uint64_t new_number
;
1099 memcached_return rc
;
1100 char *key
= "number";
1101 uint64_t initial
= 3;
1103 rc
= memcached_decrement_with_initial(memc
, key
, strlen(key
),
1104 1, initial
, 0, &new_number
);
1105 assert(rc
== MEMCACHED_SUCCESS
);
1106 assert(new_number
== initial
);
1108 rc
= memcached_decrement_with_initial(memc
, key
, strlen(key
),
1109 1, initial
, 0, &new_number
);
1110 assert(rc
== MEMCACHED_SUCCESS
);
1111 assert(new_number
== (initial
- 1));
1116 static test_return
quit_test(memcached_st
*memc
)
1118 memcached_return rc
;
1120 char *value
= "sanford and sun";
1122 rc
= memcached_set(memc
, key
, strlen(key
),
1123 value
, strlen(value
),
1124 (time_t)10, (uint32_t)3);
1125 assert(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
);
1126 memcached_quit(memc
);
1128 rc
= memcached_set(memc
, key
, strlen(key
),
1129 value
, strlen(value
),
1130 (time_t)50, (uint32_t)9);
1131 assert(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
);
1136 static test_return
mget_result_test(memcached_st
*memc
)
1138 memcached_return rc
;
1139 char *keys
[]= {"fudge", "son", "food"};
1140 size_t key_length
[]= {5, 3, 4};
1143 memcached_result_st results_obj
;
1144 memcached_result_st
*results
;
1146 results
= memcached_result_create(memc
, &results_obj
);
1148 assert(&results_obj
== results
);
1150 /* We need to empty the server before continueing test */
1151 rc
= memcached_flush(memc
, 0);
1152 assert(rc
== MEMCACHED_SUCCESS
);
1154 rc
= memcached_mget(memc
, keys
, key_length
, 3);
1155 assert(rc
== MEMCACHED_SUCCESS
);
1157 while ((results
= memcached_fetch_result(memc
, &results_obj
, &rc
)) != NULL
)
1162 while ((results
= memcached_fetch_result(memc
, &results_obj
, &rc
)) != NULL
)
1164 assert(rc
== MEMCACHED_END
);
1166 for (x
= 0; x
< 3; x
++)
1168 rc
= memcached_set(memc
, keys
[x
], key_length
[x
],
1169 keys
[x
], key_length
[x
],
1170 (time_t)50, (uint32_t)9);
1171 assert(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
);
1174 rc
= memcached_mget(memc
, keys
, key_length
, 3);
1175 assert(rc
== MEMCACHED_SUCCESS
);
1177 while ((results
= memcached_fetch_result(memc
, &results_obj
, &rc
)))
1180 assert(&results_obj
== results
);
1181 assert(rc
== MEMCACHED_SUCCESS
);
1182 assert(memcached_result_key_length(results
) == memcached_result_length(results
));
1183 assert(!memcmp(memcached_result_key_value(results
),
1184 memcached_result_value(results
),
1185 memcached_result_length(results
)));
1188 memcached_result_free(&results_obj
);
1193 static test_return
mget_result_alloc_test(memcached_st
*memc
)
1195 memcached_return rc
;
1196 char *keys
[]= {"fudge", "son", "food"};
1197 size_t key_length
[]= {5, 3, 4};
1200 memcached_result_st
*results
;
1202 /* We need to empty the server before continueing test */
1203 rc
= memcached_flush(memc
, 0);
1204 assert(rc
== MEMCACHED_SUCCESS
);
1206 rc
= memcached_mget(memc
, keys
, key_length
, 3);
1207 assert(rc
== MEMCACHED_SUCCESS
);
1209 while ((results
= memcached_fetch_result(memc
, NULL
, &rc
)) != NULL
)
1214 assert(rc
== MEMCACHED_END
);
1216 for (x
= 0; x
< 3; x
++)
1218 rc
= memcached_set(memc
, keys
[x
], key_length
[x
],
1219 keys
[x
], key_length
[x
],
1220 (time_t)50, (uint32_t)9);
1221 assert(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
);
1224 rc
= memcached_mget(memc
, keys
, key_length
, 3);
1225 assert(rc
== MEMCACHED_SUCCESS
);
1228 while ((results
= memcached_fetch_result(memc
, NULL
, &rc
)))
1231 assert(rc
== MEMCACHED_SUCCESS
);
1232 assert(memcached_result_key_length(results
) == memcached_result_length(results
));
1233 assert(!memcmp(memcached_result_key_value(results
),
1234 memcached_result_value(results
),
1235 memcached_result_length(results
)));
1236 memcached_result_free(results
);
1243 /* Count the results */
1244 static memcached_return
callback_counter(memcached_st
*ptr
__attribute__((unused
)),
1245 memcached_result_st
*result
__attribute__((unused
)),
1248 unsigned int *counter
= (unsigned int *)context
;
1250 *counter
= *counter
+ 1;
1252 return MEMCACHED_SUCCESS
;
1255 static test_return
mget_result_function(memcached_st
*memc
)
1257 memcached_return rc
;
1258 char *keys
[]= {"fudge", "son", "food"};
1259 size_t key_length
[]= {5, 3, 4};
1261 unsigned int counter
;
1262 memcached_execute_function callbacks
[1];
1264 /* We need to empty the server before continueing test */
1265 rc
= memcached_flush(memc
, 0);
1266 for (x
= 0; x
< 3; x
++)
1268 rc
= memcached_set(memc
, keys
[x
], key_length
[x
],
1269 keys
[x
], key_length
[x
],
1270 (time_t)50, (uint32_t)9);
1271 assert(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
);
1274 rc
= memcached_mget(memc
, keys
, key_length
, 3);
1275 assert(rc
== MEMCACHED_SUCCESS
);
1277 callbacks
[0]= &callback_counter
;
1279 rc
= memcached_fetch_execute(memc
, callbacks
, (void *)&counter
, 1);
1281 assert(counter
== 3);
1286 static test_return
mget_test(memcached_st
*memc
)
1288 memcached_return rc
;
1289 char *keys
[]= {"fudge", "son", "food"};
1290 size_t key_length
[]= {5, 3, 4};
1294 char return_key
[MEMCACHED_MAX_KEY
];
1295 size_t return_key_length
;
1297 size_t return_value_length
;
1299 /* We need to empty the server before continueing test */
1300 rc
= memcached_flush(memc
, 0);
1301 assert(rc
== MEMCACHED_SUCCESS
);
1303 rc
= memcached_mget(memc
, keys
, key_length
, 3);
1304 assert(rc
== MEMCACHED_SUCCESS
);
1306 while ((return_value
= memcached_fetch(memc
, return_key
, &return_key_length
,
1307 &return_value_length
, &flags
, &rc
)) != NULL
)
1309 assert(return_value
);
1311 assert(!return_value
);
1312 assert(return_value_length
== 0);
1313 assert(rc
== MEMCACHED_END
);
1315 for (x
= 0; x
< 3; x
++)
1317 rc
= memcached_set(memc
, keys
[x
], key_length
[x
],
1318 keys
[x
], key_length
[x
],
1319 (time_t)50, (uint32_t)9);
1320 assert(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
);
1323 rc
= memcached_mget(memc
, keys
, key_length
, 3);
1324 assert(rc
== MEMCACHED_SUCCESS
);
1327 while ((return_value
= memcached_fetch(memc
, return_key
, &return_key_length
,
1328 &return_value_length
, &flags
, &rc
)))
1330 assert(return_value
);
1331 assert(rc
== MEMCACHED_SUCCESS
);
1332 assert(return_key_length
== return_value_length
);
1333 assert(!memcmp(return_value
, return_key
, return_value_length
));
1341 static test_return
get_stats_keys(memcached_st
*memc
)
1345 memcached_stat_st stat
;
1346 memcached_return rc
;
1348 list
= memcached_stat_get_keys(memc
, &stat
, &rc
);
1349 assert(rc
== MEMCACHED_SUCCESS
);
1350 for (ptr
= list
; *ptr
; ptr
++)
1359 static test_return
version_string_test(memcached_st
*memc
__attribute__((unused
)))
1361 const char *version_string
;
1363 version_string
= memcached_lib_version();
1365 assert(!strcmp(version_string
, LIBMEMCACHED_VERSION_STRING
));
1370 static test_return
get_stats(memcached_st
*memc
)
1375 memcached_return rc
;
1376 memcached_stat_st
*stat
;
1378 stat
= memcached_stat(memc
, NULL
, &rc
);
1379 assert(rc
== MEMCACHED_SUCCESS
);
1381 assert(rc
== MEMCACHED_SUCCESS
);
1384 for (x
= 0; x
< memcached_server_count(memc
); x
++)
1386 list
= memcached_stat_get_keys(memc
, stat
+x
, &rc
);
1387 assert(rc
== MEMCACHED_SUCCESS
);
1388 for (ptr
= list
; *ptr
; ptr
++);
1393 memcached_stat_free(NULL
, stat
);
1398 static test_return
add_host_test(memcached_st
*memc
)
1401 memcached_server_st
*servers
;
1402 memcached_return rc
;
1403 char servername
[]= "0.example.com";
1405 servers
= memcached_server_list_append_with_weight(NULL
, servername
, 400, 0, &rc
);
1407 assert(1 == memcached_server_list_count(servers
));
1409 for (x
= 2; x
< 20; x
++)
1411 char buffer
[SMALL_STRING_LEN
];
1413 snprintf(buffer
, SMALL_STRING_LEN
, "%u.example.com", 400+x
);
1414 servers
= memcached_server_list_append_with_weight(servers
, buffer
, 401, 0,
1416 assert(rc
== MEMCACHED_SUCCESS
);
1417 assert(x
== memcached_server_list_count(servers
));
1420 rc
= memcached_server_push(memc
, servers
);
1421 assert(rc
== MEMCACHED_SUCCESS
);
1422 rc
= memcached_server_push(memc
, servers
);
1423 assert(rc
== MEMCACHED_SUCCESS
);
1425 memcached_server_list_free(servers
);
1430 static memcached_return
clone_test_callback(memcached_st
*parent
__attribute__((unused
)), memcached_st
*clone
__attribute__((unused
)))
1432 return MEMCACHED_SUCCESS
;
1435 static memcached_return
cleanup_test_callback(memcached_st
*ptr
__attribute__((unused
)))
1437 return MEMCACHED_SUCCESS
;
1440 static test_return
callback_test(memcached_st
*memc
)
1442 /* Test User Data */
1446 memcached_return rc
;
1448 rc
= memcached_callback_set(memc
, MEMCACHED_CALLBACK_USER_DATA
, &x
);
1449 assert(rc
== MEMCACHED_SUCCESS
);
1450 test_ptr
= (int *)memcached_callback_get(memc
, MEMCACHED_CALLBACK_USER_DATA
, &rc
);
1451 assert(*test_ptr
== x
);
1454 /* Test Clone Callback */
1456 memcached_clone_func temp_function
;
1457 memcached_return rc
;
1459 rc
= memcached_callback_set(memc
, MEMCACHED_CALLBACK_CLONE_FUNCTION
, (void*)clone_test_callback
);
1460 assert(rc
== MEMCACHED_SUCCESS
);
1461 temp_function
= (memcached_clone_func
)memcached_callback_get(memc
, MEMCACHED_CALLBACK_CLONE_FUNCTION
, &rc
);
1462 assert(temp_function
== clone_test_callback
);
1465 /* Test Cleanup Callback */
1467 memcached_cleanup_func temp_function
;
1468 memcached_return rc
;
1470 rc
= memcached_callback_set(memc
, MEMCACHED_CALLBACK_CLONE_FUNCTION
, (void*)cleanup_test_callback
);
1471 assert(rc
== MEMCACHED_SUCCESS
);
1472 temp_function
= (memcached_cleanup_func
)memcached_callback_get(memc
, MEMCACHED_CALLBACK_CLONE_FUNCTION
, &rc
);
1473 assert(temp_function
== cleanup_test_callback
);
1479 /* We don't test the behavior itself, we test the switches */
1480 static test_return
behavior_test(memcached_st
*memc
)
1485 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NO_BLOCK
, set
);
1486 value
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_NO_BLOCK
);
1489 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_TCP_NODELAY
, set
);
1490 value
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_TCP_NODELAY
);
1493 set
= MEMCACHED_HASH_MD5
;
1494 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_HASH
, set
);
1495 value
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_HASH
);
1496 assert(value
== MEMCACHED_HASH_MD5
);
1500 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NO_BLOCK
, set
);
1501 value
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_NO_BLOCK
);
1504 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_TCP_NODELAY
, set
);
1505 value
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_TCP_NODELAY
);
1508 set
= MEMCACHED_HASH_DEFAULT
;
1509 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_HASH
, set
);
1510 value
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_HASH
);
1511 assert(value
== MEMCACHED_HASH_DEFAULT
);
1513 set
= MEMCACHED_HASH_CRC
;
1514 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_HASH
, set
);
1515 value
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_HASH
);
1516 assert(value
== MEMCACHED_HASH_CRC
);
1518 value
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_SOCKET_SEND_SIZE
);
1521 value
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_SOCKET_RECV_SIZE
);
1527 /* Test case provided by Cal Haldenbrand */
1528 static test_return
user_supplied_bug1(memcached_st
*memc
)
1530 unsigned int setter
= 1;
1533 unsigned long long total
= 0;
1536 char randomstuff
[6 * 1024];
1537 memcached_return rc
;
1539 memset(randomstuff
, 0, 6 * 1024);
1541 /* We just keep looking at the same values over and over */
1544 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NO_BLOCK
, setter
);
1545 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_TCP_NODELAY
, setter
);
1549 for (x
= 0 ; total
< 20 * 1024576 ; x
++ )
1553 size
= (rand() % ( 5 * 1024 ) ) + 400;
1554 memset(randomstuff
, 0, 6 * 1024);
1555 assert(size
< 6 * 1024); /* Being safe here */
1557 for (j
= 0 ; j
< size
;j
++)
1558 randomstuff
[j
] = (char) (rand() % 26) + 97;
1561 sprintf(key
, "%d", x
);
1562 rc
= memcached_set(memc
, key
, strlen(key
),
1563 randomstuff
, strlen(randomstuff
), 10, 0);
1564 assert(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
);
1565 /* If we fail, lets try again */
1566 if (rc
!= MEMCACHED_SUCCESS
&& rc
!= MEMCACHED_BUFFERED
)
1567 rc
= memcached_set(memc
, key
, strlen(key
),
1568 randomstuff
, strlen(randomstuff
), 10, 0);
1569 assert(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
);
1575 /* Test case provided by Cal Haldenbrand */
1576 static test_return
user_supplied_bug2(memcached_st
*memc
)
1579 unsigned int setter
;
1581 unsigned long long total
;
1584 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NO_BLOCK
, setter
);
1585 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_TCP_NODELAY
, setter
);
1587 setter
= 20 * 1024576;
1588 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_SOCKET_SEND_SIZE
, setter
);
1589 setter
= 20 * 1024576;
1590 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_SOCKET_RECV_SIZE
, setter
);
1591 getter
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_SOCKET_SEND_SIZE
);
1592 getter
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_SOCKET_RECV_SIZE
);
1594 for (x
= 0, errors
= 0, total
= 0 ; total
< 20 * 1024576 ; x
++)
1597 for (x
= 0, errors
= 0, total
= 0 ; total
< 24576 ; x
++)
1599 memcached_return rc
= MEMCACHED_SUCCESS
;
1600 char buffer
[SMALL_STRING_LEN
];
1605 memset(buffer
, 0, SMALL_STRING_LEN
);
1607 snprintf(buffer
, SMALL_STRING_LEN
, "%u", x
);
1608 getval
= memcached_get(memc
, buffer
, strlen(buffer
),
1609 &val_len
, &flags
, &rc
);
1610 if (rc
!= MEMCACHED_SUCCESS
)
1612 if (rc
== MEMCACHED_NOTFOUND
)
1616 WATCHPOINT_ERROR(rc
);
1630 /* Do a large mget() over all the keys we think exist */
1631 #define KEY_COUNT 3000 // * 1024576
1632 static test_return
user_supplied_bug3(memcached_st
*memc
)
1634 memcached_return rc
;
1635 unsigned int setter
;
1638 size_t key_lengths
[KEY_COUNT
];
1641 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NO_BLOCK
, setter
);
1642 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_TCP_NODELAY
, setter
);
1644 setter
= 20 * 1024576;
1645 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_SOCKET_SEND_SIZE
, setter
);
1646 setter
= 20 * 1024576;
1647 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_SOCKET_RECV_SIZE
, setter
);
1648 getter
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_SOCKET_SEND_SIZE
);
1649 getter
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_SOCKET_RECV_SIZE
);
1652 keys
= (char **)malloc(sizeof(char *) * KEY_COUNT
);
1654 memset(keys
, 0, (sizeof(char *) * KEY_COUNT
));
1655 for (x
= 0; x
< KEY_COUNT
; x
++)
1659 snprintf(buffer
, 30, "%u", x
);
1660 keys
[x
]= strdup(buffer
);
1661 key_lengths
[x
]= strlen(keys
[x
]);
1664 rc
= memcached_mget(memc
, keys
, key_lengths
, KEY_COUNT
);
1665 assert(rc
== MEMCACHED_SUCCESS
);
1667 /* Turn this into a help function */
1669 char return_key
[MEMCACHED_MAX_KEY
];
1670 size_t return_key_length
;
1672 size_t return_value_length
;
1675 while ((return_value
= memcached_fetch(memc
, return_key
, &return_key_length
,
1676 &return_value_length
, &flags
, &rc
)))
1678 assert(return_value
);
1679 assert(rc
== MEMCACHED_SUCCESS
);
1684 for (x
= 0; x
< KEY_COUNT
; x
++)
1691 /* Make sure we behave properly if server list has no values */
1692 static test_return
user_supplied_bug4(memcached_st
*memc
)
1694 memcached_return rc
;
1695 char *keys
[]= {"fudge", "son", "food"};
1696 size_t key_length
[]= {5, 3, 4};
1699 char return_key
[MEMCACHED_MAX_KEY
];
1700 size_t return_key_length
;
1702 size_t return_value_length
;
1704 /* Here we free everything before running a bunch of mget tests */
1706 memcached_server_list_free(memc
->hosts
);
1708 memc
->number_of_hosts
= 0;
1712 /* We need to empty the server before continueing test */
1713 rc
= memcached_flush(memc
, 0);
1714 assert(rc
== MEMCACHED_NO_SERVERS
);
1716 rc
= memcached_mget(memc
, keys
, key_length
, 3);
1717 assert(rc
== MEMCACHED_NO_SERVERS
);
1719 while ((return_value
= memcached_fetch(memc
, return_key
, &return_key_length
,
1720 &return_value_length
, &flags
, &rc
)) != NULL
)
1722 assert(return_value
);
1724 assert(!return_value
);
1725 assert(return_value_length
== 0);
1726 assert(rc
== MEMCACHED_NO_SERVERS
);
1728 for (x
= 0; x
< 3; x
++)
1730 rc
= memcached_set(memc
, keys
[x
], key_length
[x
],
1731 keys
[x
], key_length
[x
],
1732 (time_t)50, (uint32_t)9);
1733 assert(rc
== MEMCACHED_NO_SERVERS
);
1736 rc
= memcached_mget(memc
, keys
, key_length
, 3);
1737 assert(rc
== MEMCACHED_NO_SERVERS
);
1740 while ((return_value
= memcached_fetch(memc
, return_key
, &return_key_length
,
1741 &return_value_length
, &flags
, &rc
)))
1743 assert(return_value
);
1744 assert(rc
== MEMCACHED_SUCCESS
);
1745 assert(return_key_length
== return_value_length
);
1746 assert(!memcmp(return_value
, return_key
, return_value_length
));
1754 #define VALUE_SIZE_BUG5 1048064
1755 static test_return
user_supplied_bug5(memcached_st
*memc
)
1757 memcached_return rc
;
1758 char *keys
[]= {"036790384900", "036790384902", "036790384904", "036790384906"};
1759 size_t key_length
[]= {strlen("036790384900"), strlen("036790384902"), strlen("036790384904"), strlen("036790384906")};
1760 char return_key
[MEMCACHED_MAX_KEY
];
1761 size_t return_key_length
;
1763 size_t value_length
;
1767 char insert_data
[VALUE_SIZE_BUG5
];
1769 for (x
= 0; x
< VALUE_SIZE_BUG5
; x
++)
1770 insert_data
[x
]= rand();
1772 memcached_flush(memc
, 0);
1773 value
= memcached_get(memc
, keys
[0], key_length
[0],
1774 &value_length
, &flags
, &rc
);
1775 assert(value
== NULL
);
1776 rc
= memcached_mget(memc
, keys
, key_length
, 4);
1779 while ((value
= memcached_fetch(memc
, return_key
, &return_key_length
,
1780 &value_length
, &flags
, &rc
)))
1784 for (x
= 0; x
< 4; x
++)
1786 rc
= memcached_set(memc
, keys
[x
], key_length
[x
],
1787 insert_data
, VALUE_SIZE_BUG5
,
1788 (time_t)0, (uint32_t)0);
1789 assert(rc
== MEMCACHED_SUCCESS
);
1792 for (x
= 0; x
< 10; x
++)
1794 value
= memcached_get(memc
, keys
[0], key_length
[0],
1795 &value_length
, &flags
, &rc
);
1799 rc
= memcached_mget(memc
, keys
, key_length
, 4);
1801 while ((value
= memcached_fetch(memc
, return_key
, &return_key_length
,
1802 &value_length
, &flags
, &rc
)))
1813 static test_return
user_supplied_bug6(memcached_st
*memc
)
1815 memcached_return rc
;
1816 char *keys
[]= {"036790384900", "036790384902", "036790384904", "036790384906"};
1817 size_t key_length
[]= {strlen("036790384900"), strlen("036790384902"), strlen("036790384904"), strlen("036790384906")};
1818 char return_key
[MEMCACHED_MAX_KEY
];
1819 size_t return_key_length
;
1821 size_t value_length
;
1825 char insert_data
[VALUE_SIZE_BUG5
];
1827 for (x
= 0; x
< VALUE_SIZE_BUG5
; x
++)
1828 insert_data
[x
]= rand();
1830 memcached_flush(memc
, 0);
1831 value
= memcached_get(memc
, keys
[0], key_length
[0],
1832 &value_length
, &flags
, &rc
);
1833 assert(value
== NULL
);
1834 assert(rc
== MEMCACHED_NOTFOUND
);
1835 rc
= memcached_mget(memc
, keys
, key_length
, 4);
1836 assert(rc
== MEMCACHED_SUCCESS
);
1839 while ((value
= memcached_fetch(memc
, return_key
, &return_key_length
,
1840 &value_length
, &flags
, &rc
)))
1843 assert(rc
== MEMCACHED_END
);
1845 for (x
= 0; x
< 4; x
++)
1847 rc
= memcached_set(memc
, keys
[x
], key_length
[x
],
1848 insert_data
, VALUE_SIZE_BUG5
,
1849 (time_t)0, (uint32_t)0);
1850 assert(rc
== MEMCACHED_SUCCESS
);
1853 for (x
= 0; x
< 2; x
++)
1855 value
= memcached_get(memc
, keys
[0], key_length
[0],
1856 &value_length
, &flags
, &rc
);
1860 rc
= memcached_mget(memc
, keys
, key_length
, 4);
1861 assert(rc
== MEMCACHED_SUCCESS
);
1863 /* We test for purge of partial complete fetches */
1864 for (count
= 3; count
; count
--)
1866 value
= memcached_fetch(memc
, return_key
, &return_key_length
,
1867 &value_length
, &flags
, &rc
);
1868 assert(rc
== MEMCACHED_SUCCESS
);
1869 assert(!(memcmp(value
, insert_data
, value_length
)));
1870 assert(value_length
);
1878 static test_return
user_supplied_bug8(memcached_st
*memc
__attribute__((unused
)))
1880 memcached_return rc
;
1882 memcached_st
*clone
;
1884 memcached_server_st
*servers
;
1885 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";
1887 servers
= memcached_servers_parse(server_list
);
1890 mine
= memcached_create(NULL
);
1891 rc
= memcached_server_push(mine
, servers
);
1892 assert(rc
== MEMCACHED_SUCCESS
);
1893 memcached_server_list_free(servers
);
1896 clone
= memcached_clone(NULL
, mine
);
1898 memcached_quit(mine
);
1899 memcached_quit(clone
);
1902 memcached_free(mine
);
1903 memcached_free(clone
);
1908 /* Test flag store/retrieve */
1909 static test_return
user_supplied_bug7(memcached_st
*memc
)
1911 memcached_return rc
;
1912 char *keys
= "036790384900";
1913 size_t key_length
= strlen("036790384900");
1914 char return_key
[MEMCACHED_MAX_KEY
];
1915 size_t return_key_length
;
1917 size_t value_length
;
1920 char insert_data
[VALUE_SIZE_BUG5
];
1922 for (x
= 0; x
< VALUE_SIZE_BUG5
; x
++)
1923 insert_data
[x
]= rand();
1925 memcached_flush(memc
, 0);
1928 rc
= memcached_set(memc
, keys
, key_length
,
1929 insert_data
, VALUE_SIZE_BUG5
,
1931 assert(rc
== MEMCACHED_SUCCESS
);
1934 value
= memcached_get(memc
, keys
, key_length
,
1935 &value_length
, &flags
, &rc
);
1936 assert(flags
== 245);
1940 rc
= memcached_mget(memc
, &keys
, &key_length
, 1);
1943 value
= memcached_fetch(memc
, return_key
, &return_key_length
,
1944 &value_length
, &flags
, &rc
);
1945 assert(flags
== 245);
1953 static test_return
user_supplied_bug9(memcached_st
*memc
)
1955 memcached_return rc
;
1956 char *keys
[]= {"UDATA:edevil@sapo.pt", "fudge&*@#", "for^#@&$not"};
1957 size_t key_length
[3];
1962 char return_key
[MEMCACHED_MAX_KEY
];
1963 size_t return_key_length
;
1965 size_t return_value_length
;
1968 key_length
[0]= strlen("UDATA:edevil@sapo.pt");
1969 key_length
[1]= strlen("fudge&*@#");
1970 key_length
[2]= strlen("for^#@&$not");
1973 for (x
= 0; x
< 3; x
++)
1975 rc
= memcached_set(memc
, keys
[x
], key_length
[x
],
1976 keys
[x
], key_length
[x
],
1977 (time_t)50, (uint32_t)9);
1978 assert(rc
== MEMCACHED_SUCCESS
);
1981 rc
= memcached_mget(memc
, keys
, key_length
, 3);
1982 assert(rc
== MEMCACHED_SUCCESS
);
1984 /* We need to empty the server before continueing test */
1985 while ((return_value
= memcached_fetch(memc
, return_key
, &return_key_length
,
1986 &return_value_length
, &flags
, &rc
)) != NULL
)
1988 assert(return_value
);
1997 /* We are testing with aggressive timeout to get failures */
1998 static test_return
user_supplied_bug10(memcached_st
*memc
)
2002 size_t value_length
= 512;
2005 memcached_return rc
;
2006 unsigned int set
= 1;
2007 memcached_st
*mclone
= memcached_clone(NULL
, memc
);
2010 memcached_behavior_set(mclone
, MEMCACHED_BEHAVIOR_NO_BLOCK
, set
);
2011 memcached_behavior_set(mclone
, MEMCACHED_BEHAVIOR_TCP_NODELAY
, set
);
2013 memcached_behavior_set(mclone
, MEMCACHED_BEHAVIOR_POLL_TIMEOUT
, timeout
);
2015 value
= (char*)malloc(value_length
* sizeof(char));
2017 for (x
= 0; x
< value_length
; x
++)
2018 value
[x
]= (char) (x
% 127);
2020 for (x
= 1; x
<= 100000; ++x
)
2022 rc
= memcached_set(mclone
, key
, key_len
,value
, value_length
, 0, 0);
2024 assert(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_WRITE_FAILURE
||
2025 rc
== MEMCACHED_BUFFERED
|| rc
== MEMCACHED_TIMEOUT
);
2027 if (rc
== MEMCACHED_WRITE_FAILURE
|| rc
== MEMCACHED_TIMEOUT
)
2032 memcached_free(mclone
);
2038 We are looking failures in the async protocol
2040 static test_return
user_supplied_bug11(memcached_st
*memc
)
2044 size_t value_length
= 512;
2047 memcached_return rc
;
2048 unsigned int set
= 1;
2050 memcached_st
*mclone
= memcached_clone(NULL
, memc
);
2052 memcached_behavior_set(mclone
, MEMCACHED_BEHAVIOR_NO_BLOCK
, set
);
2053 memcached_behavior_set(mclone
, MEMCACHED_BEHAVIOR_TCP_NODELAY
, set
);
2055 memcached_behavior_set(mclone
, MEMCACHED_BEHAVIOR_POLL_TIMEOUT
, timeout
);
2057 timeout
= (int32_t)memcached_behavior_get(mclone
, MEMCACHED_BEHAVIOR_POLL_TIMEOUT
);
2059 assert(timeout
== -1);
2061 value
= (char*)malloc(value_length
* sizeof(char));
2063 for (x
= 0; x
< value_length
; x
++)
2064 value
[x
]= (char) (x
% 127);
2066 for (x
= 1; x
<= 100000; ++x
)
2068 rc
= memcached_set(mclone
, key
, key_len
,value
, value_length
, 0, 0);
2072 memcached_free(mclone
);
2078 Bug found where incr was not returning MEMCACHED_NOTFOUND when object did not exist.
2080 static test_return
user_supplied_bug12(memcached_st
*memc
)
2082 memcached_return rc
;
2084 size_t value_length
;
2086 uint64_t number_value
;
2088 value
= memcached_get(memc
, "autoincrement", strlen("autoincrement"),
2089 &value_length
, &flags
, &rc
);
2090 assert(value
== NULL
);
2091 assert(rc
== MEMCACHED_NOTFOUND
);
2093 rc
= memcached_increment(memc
, "autoincrement", strlen("autoincrement"),
2096 assert(value
== NULL
);
2097 /* The binary protocol will set the key if it doesn't exist */
2098 if (memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
) == 1)
2099 assert(rc
== MEMCACHED_SUCCESS
);
2101 assert(rc
== MEMCACHED_NOTFOUND
);
2103 rc
= memcached_set(memc
, "autoincrement", strlen("autoincrement"), "1", 1, 0, 0);
2105 value
= memcached_get(memc
, "autoincrement", strlen("autoincrement"),
2106 &value_length
, &flags
, &rc
);
2108 assert(rc
== MEMCACHED_SUCCESS
);
2111 rc
= memcached_increment(memc
, "autoincrement", strlen("autoincrement"),
2113 assert(number_value
== 2);
2114 assert(rc
== MEMCACHED_SUCCESS
);
2120 Bug found where command total one more than MEMCACHED_MAX_BUFFER
2121 set key34567890 0 0 8169 \r\n is sent followed by buffer of size 8169, followed by 8169
2123 static test_return
user_supplied_bug13(memcached_st
*memc
)
2125 char key
[] = "key34567890";
2127 memcached_return rc
;
2128 size_t overflowSize
;
2130 char commandFirst
[]= "set key34567890 0 0 ";
2131 char commandLast
[] = " \r\n"; /* first line of command sent to server */
2132 size_t commandLength
;
2135 commandLength
= strlen(commandFirst
) + strlen(commandLast
) + 4; /* 4 is number of characters in size, probably 8196 */
2137 overflowSize
= MEMCACHED_MAX_BUFFER
- commandLength
;
2139 for (testSize
= overflowSize
- 1; testSize
< overflowSize
+ 1; testSize
++)
2141 overflow
= malloc(testSize
);
2142 assert(overflow
!= NULL
);
2144 memset(overflow
, 'x', testSize
);
2145 rc
= memcached_set(memc
, key
, strlen(key
),
2146 overflow
, testSize
, 0, 0);
2147 assert(rc
== MEMCACHED_SUCCESS
);
2156 Test values of many different sizes
2157 Bug found where command total one more than MEMCACHED_MAX_BUFFER
2158 set key34567890 0 0 8169 \r\n
2159 is sent followed by buffer of size 8169, followed by 8169
2161 static test_return
user_supplied_bug14(memcached_st
*memc
)
2164 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_TCP_NODELAY
, setter
);
2165 memcached_return rc
;
2168 size_t value_length
= 18000;
2170 size_t string_length
;
2173 size_t current_length
;
2175 value
= (char*)malloc(value_length
);
2178 for (x
= 0; x
< value_length
; x
++)
2179 value
[x
] = (char) (x
% 127);
2181 for (current_length
= 0; current_length
< value_length
; current_length
++)
2183 rc
= memcached_set(memc
, key
, strlen(key
),
2184 value
, current_length
,
2185 (time_t)0, (uint32_t)0);
2186 assert(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
);
2188 string
= memcached_get(memc
, key
, strlen(key
),
2189 &string_length
, &flags
, &rc
);
2191 assert(rc
== MEMCACHED_SUCCESS
);
2192 assert(string_length
== current_length
);
2193 assert(!memcmp(string
, value
, string_length
));
2204 Look for zero length value problems
2206 static test_return
user_supplied_bug15(memcached_st
*memc
)
2209 memcached_return rc
;
2215 for (x
= 0; x
< 2; x
++)
2217 rc
= memcached_set(memc
, key
, strlen(key
),
2219 (time_t)0, (uint32_t)0);
2221 assert(rc
== MEMCACHED_SUCCESS
);
2223 value
= memcached_get(memc
, key
, strlen(key
),
2224 &length
, &flags
, &rc
);
2226 assert(rc
== MEMCACHED_SUCCESS
);
2227 assert(value
== NULL
);
2228 assert(length
== 0);
2231 value
= memcached_get(memc
, key
, strlen(key
),
2232 &length
, &flags
, &rc
);
2234 assert(rc
== MEMCACHED_SUCCESS
);
2235 assert(value
== NULL
);
2236 assert(length
== 0);
2243 /* Check the return sizes on FLAGS to make sure it stores 32bit unsigned values correctly */
2244 static test_return
user_supplied_bug16(memcached_st
*memc
)
2246 memcached_return rc
;
2252 rc
= memcached_set(memc
, key
, strlen(key
),
2254 (time_t)0, UINT32_MAX
);
2256 assert(rc
== MEMCACHED_SUCCESS
);
2258 value
= memcached_get(memc
, key
, strlen(key
),
2259 &length
, &flags
, &rc
);
2261 assert(rc
== MEMCACHED_SUCCESS
);
2262 assert(value
== NULL
);
2263 assert(length
== 0);
2264 assert(flags
== UINT32_MAX
);
2269 /* Check the validity of chinese key*/
2270 static test_return
user_supplied_bug17(memcached_st
*memc
)
2272 memcached_return rc
;
2274 char *value
="我们在炎热抑郁的夏天无法停止豆瓣";
2279 rc
= memcached_set(memc
, key
, strlen(key
),
2280 value
, strlen(value
),
2283 assert(rc
== MEMCACHED_SUCCESS
);
2285 value2
= memcached_get(memc
, key
, strlen(key
),
2286 &length
, &flags
, &rc
);
2288 assert(length
==strlen(value
));
2289 assert(rc
== MEMCACHED_SUCCESS
);
2290 assert(memcmp(value
, value2
, length
)==0);
2300 test_return
user_supplied_bug19(memcached_st
*memc
)
2303 memcached_server_st
*s
;
2304 memcached_return res
;
2308 m
= memcached_create(NULL
);
2309 memcached_server_add_with_weight(m
, "localhost", 11311, 100);
2310 memcached_server_add_with_weight(m
, "localhost", 11312, 100);
2312 s
= memcached_server_by_key(m
, "a", 1, &res
);
2313 memcached_server_free(s
);
2320 /* CAS test from Andei */
2321 test_return
user_supplied_bug20(memcached_st
*memc
)
2323 memcached_return status
;
2324 memcached_result_st
*result
, result_obj
;
2326 size_t key_len
= strlen("abc");
2327 char *value
= "foobar";
2328 size_t value_len
= strlen(value
);
2330 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_SUPPORT_CAS
, 1);
2332 status
= memcached_set(memc
, key
, key_len
, value
, value_len
, (time_t)0, (uint32_t)0);
2333 assert(status
== MEMCACHED_SUCCESS
);
2335 status
= memcached_mget(memc
, &key
, &key_len
, 1);
2336 assert(status
== MEMCACHED_SUCCESS
);
2338 result
= memcached_result_create(memc
, &result_obj
);
2341 memcached_result_create(memc
, &result_obj
);
2342 result
= memcached_fetch_result(memc
, &result_obj
, &status
);
2345 assert(status
== MEMCACHED_SUCCESS
);
2347 memcached_result_free(result
);
2352 #include "ketama_test_cases.h"
2353 test_return
user_supplied_bug18(memcached_st
*trash
)
2355 memcached_return rc
;
2358 memcached_server_st
*server_pool
;
2363 memc
= memcached_create(NULL
);
2366 rc
= memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_KETAMA_WEIGHTED
, 1);
2367 assert(rc
== MEMCACHED_SUCCESS
);
2369 value
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_KETAMA_WEIGHTED
);
2372 rc
= memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_KETAMA_HASH
, MEMCACHED_HASH_MD5
);
2373 assert(rc
== MEMCACHED_SUCCESS
);
2375 value
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_KETAMA_HASH
);
2376 assert(value
== MEMCACHED_HASH_MD5
);
2378 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");
2379 memcached_server_push(memc
, server_pool
);
2381 /* verify that the server list was parsed okay. */
2382 assert(memc
->number_of_hosts
== 8);
2383 assert(strcmp(server_pool
[0].hostname
, "10.0.1.1") == 0);
2384 assert(server_pool
[0].port
== 11211);
2385 assert(server_pool
[0].weight
== 600);
2386 assert(strcmp(server_pool
[2].hostname
, "10.0.1.3") == 0);
2387 assert(server_pool
[2].port
== 11211);
2388 assert(server_pool
[2].weight
== 200);
2389 assert(strcmp(server_pool
[7].hostname
, "10.0.1.8") == 0);
2390 assert(server_pool
[7].port
== 11211);
2391 assert(server_pool
[7].weight
== 100);
2393 /* VDEAAAAA hashes to fffcd1b5, after the last continuum point, and lets
2394 * us test the boundary wraparound.
2396 assert(memcached_generate_hash(memc
, (char *)"VDEAAAAA", 8) == memc
->continuum
[0].index
);
2398 /* verify the standard ketama set. */
2399 for (x
= 0; x
< 99; x
++)
2401 uint32_t server_idx
= memcached_generate_hash(memc
, test_cases
[x
].key
, strlen(test_cases
[x
].key
));
2402 char *hostname
= memc
->hosts
[server_idx
].hostname
;
2403 assert(strcmp(hostname
, test_cases
[x
].server
) == 0);
2406 memcached_server_list_free(server_pool
);
2407 memcached_free(memc
);
2412 test_return
auto_eject_hosts(memcached_st
*trash
)
2414 memcached_return rc
;
2415 memcached_st
*memc
= memcached_create(NULL
);
2418 rc
= memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_KETAMA_WEIGHTED
, 1);
2419 assert(rc
== MEMCACHED_SUCCESS
);
2421 uint64_t value
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_KETAMA_WEIGHTED
);
2424 rc
= memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_KETAMA_HASH
, MEMCACHED_HASH_MD5
);
2425 assert(rc
== MEMCACHED_SUCCESS
);
2427 value
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_KETAMA_HASH
);
2428 assert(value
== MEMCACHED_HASH_MD5
);
2430 /* server should be removed when in delay */
2431 rc
= memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_AUTO_EJECT_HOSTS
, 1);
2432 assert(rc
== MEMCACHED_SUCCESS
);
2434 value
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_AUTO_EJECT_HOSTS
);
2437 memcached_server_st
*server_pool
;
2438 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");
2439 memcached_server_push(memc
, server_pool
);
2441 /* verify that the server list was parsed okay. */
2442 assert(memc
->number_of_hosts
== 8);
2443 assert(strcmp(server_pool
[0].hostname
, "10.0.1.1") == 0);
2444 assert(server_pool
[0].port
== 11211);
2445 assert(server_pool
[0].weight
== 600);
2446 assert(strcmp(server_pool
[2].hostname
, "10.0.1.3") == 0);
2447 assert(server_pool
[2].port
== 11211);
2448 assert(server_pool
[2].weight
== 200);
2449 assert(strcmp(server_pool
[7].hostname
, "10.0.1.8") == 0);
2450 assert(server_pool
[7].port
== 11211);
2451 assert(server_pool
[7].weight
== 100);
2453 memc
->hosts
[2].next_retry
= time(NULL
) + 15;
2454 memc
->next_distribution_rebuild
= time(NULL
) - 1;
2456 for (int x
= 0; x
< 99; x
++)
2458 uint32_t server_idx
= memcached_generate_hash(memc
, test_cases
[x
].key
, strlen(test_cases
[x
].key
));
2459 assert(server_idx
!= 2);
2462 /* and re-added when it's back. */
2463 memc
->hosts
[2].next_retry
= time(NULL
) - 1;
2464 memc
->next_distribution_rebuild
= time(NULL
) - 1;
2465 run_distribution(memc
);
2466 for (int x
= 0; x
< 99; x
++)
2468 uint32_t server_idx
= memcached_generate_hash(memc
, test_cases
[x
].key
, strlen(test_cases
[x
].key
));
2469 char *hostname
= memc
->hosts
[server_idx
].hostname
;
2470 assert(strcmp(hostname
, test_cases
[x
].server
) == 0);
2473 memcached_server_list_free(server_pool
);
2474 memcached_free(memc
);
2476 return TEST_SUCCESS
;
2479 static test_return
result_static(memcached_st
*memc
)
2481 memcached_result_st result
;
2482 memcached_result_st
*result_ptr
;
2484 result_ptr
= memcached_result_create(memc
, &result
);
2485 assert(result
.is_allocated
== false);
2487 memcached_result_free(&result
);
2492 static test_return
result_alloc(memcached_st
*memc
)
2494 memcached_result_st
*result
;
2496 result
= memcached_result_create(memc
, NULL
);
2498 memcached_result_free(result
);
2503 static test_return
string_static_null(memcached_st
*memc
)
2505 memcached_string_st string
;
2506 memcached_string_st
*string_ptr
;
2508 string_ptr
= memcached_string_create(memc
, &string
, 0);
2509 assert(string
.is_allocated
== false);
2511 memcached_string_free(&string
);
2516 static test_return
string_alloc_null(memcached_st
*memc
)
2518 memcached_string_st
*string
;
2520 string
= memcached_string_create(memc
, NULL
, 0);
2522 memcached_string_free(string
);
2527 static test_return
string_alloc_with_size(memcached_st
*memc
)
2529 memcached_string_st
*string
;
2531 string
= memcached_string_create(memc
, NULL
, 1024);
2533 memcached_string_free(string
);
2538 static test_return
string_alloc_with_size_toobig(memcached_st
*memc
)
2540 memcached_string_st
*string
;
2542 string
= memcached_string_create(memc
, NULL
, INT64_MAX
);
2543 assert(string
== NULL
);
2548 static test_return
string_alloc_append(memcached_st
*memc
)
2551 char buffer
[SMALL_STRING_LEN
];
2552 memcached_string_st
*string
;
2554 /* Ring the bell! */
2555 memset(buffer
, 6, SMALL_STRING_LEN
);
2557 string
= memcached_string_create(memc
, NULL
, 100);
2560 for (x
= 0; x
< 1024; x
++)
2562 memcached_return rc
;
2563 rc
= memcached_string_append(string
, buffer
, SMALL_STRING_LEN
);
2564 assert(rc
== MEMCACHED_SUCCESS
);
2566 memcached_string_free(string
);
2571 static test_return
string_alloc_append_toobig(memcached_st
*memc
)
2573 memcached_return rc
;
2575 char buffer
[SMALL_STRING_LEN
];
2576 memcached_string_st
*string
;
2578 /* Ring the bell! */
2579 memset(buffer
, 6, SMALL_STRING_LEN
);
2581 string
= memcached_string_create(memc
, NULL
, 100);
2584 for (x
= 0; x
< 1024; x
++)
2586 rc
= memcached_string_append(string
, buffer
, SMALL_STRING_LEN
);
2587 assert(rc
== MEMCACHED_SUCCESS
);
2589 rc
= memcached_string_append(string
, buffer
, INT64_MAX
);
2590 assert(rc
== MEMCACHED_MEMORY_ALLOCATION_FAILURE
);
2591 memcached_string_free(string
);
2596 static test_return
cleanup_pairs(memcached_st
*memc
__attribute__((unused
)))
2598 pairs_free(global_pairs
);
2603 static test_return
generate_pairs(memcached_st
*memc
__attribute__((unused
)))
2605 unsigned long long x
;
2606 global_pairs
= pairs_generate(GLOBAL_COUNT
, 400);
2607 global_count
= GLOBAL_COUNT
;
2609 for (x
= 0; x
< global_count
; x
++)
2611 global_keys
[x
]= global_pairs
[x
].key
;
2612 global_keys_length
[x
]= global_pairs
[x
].key_length
;
2618 static test_return
generate_large_pairs(memcached_st
*memc
__attribute__((unused
)))
2620 unsigned long long x
;
2621 global_pairs
= pairs_generate(GLOBAL2_COUNT
, MEMCACHED_MAX_BUFFER
+10);
2622 global_count
= GLOBAL2_COUNT
;
2624 for (x
= 0; x
< global_count
; x
++)
2626 global_keys
[x
]= global_pairs
[x
].key
;
2627 global_keys_length
[x
]= global_pairs
[x
].key_length
;
2633 static test_return
generate_data(memcached_st
*memc
)
2635 execute_set(memc
, global_pairs
, global_count
);
2640 static test_return
generate_data_with_stats(memcached_st
*memc
)
2642 memcached_stat_st
*stat_p
;
2643 memcached_return rc
;
2644 uint32_t host_index
= 0;
2645 execute_set(memc
, global_pairs
, global_count
);
2647 //TODO: hosts used size stats
2648 stat_p
= memcached_stat(memc
, NULL
, &rc
);
2651 for (host_index
= 0; host_index
< SERVERS_TO_CREATE
; host_index
++)
2653 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
);
2656 memcached_stat_free(NULL
, stat_p
);
2660 static test_return
generate_buffer_data(memcached_st
*memc
)
2665 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_BUFFER_REQUESTS
, latch
);
2666 generate_data(memc
);
2671 static test_return
get_read_count(memcached_st
*memc
)
2674 memcached_return rc
;
2675 memcached_st
*clone
;
2677 clone
= memcached_clone(NULL
, memc
);
2680 memcached_server_add_with_weight(clone
, "localhost", 6666, 0);
2684 size_t return_value_length
;
2688 for (x
= count
= 0; x
< global_count
; x
++)
2690 return_value
= memcached_get(clone
, global_keys
[x
], global_keys_length
[x
],
2691 &return_value_length
, &flags
, &rc
);
2692 if (rc
== MEMCACHED_SUCCESS
)
2699 fprintf(stderr
, "\t%u -> %u", global_count
, count
);
2702 memcached_free(clone
);
2707 static test_return
get_read(memcached_st
*memc
)
2710 memcached_return rc
;
2714 size_t return_value_length
;
2717 for (x
= 0; x
< global_count
; x
++)
2719 return_value
= memcached_get(memc
, global_keys
[x
], global_keys_length
[x
],
2720 &return_value_length
, &flags
, &rc
);
2722 assert(return_value);
2723 assert(rc == MEMCACHED_SUCCESS);
2725 if (rc
== MEMCACHED_SUCCESS
&& return_value
)
2733 static test_return
mget_read(memcached_st
*memc
)
2735 memcached_return rc
;
2737 rc
= memcached_mget(memc
, global_keys
, global_keys_length
, global_count
);
2738 assert(rc
== MEMCACHED_SUCCESS
);
2739 /* Turn this into a help function */
2741 char return_key
[MEMCACHED_MAX_KEY
];
2742 size_t return_key_length
;
2744 size_t return_value_length
;
2747 while ((return_value
= memcached_fetch(memc
, return_key
, &return_key_length
,
2748 &return_value_length
, &flags
, &rc
)))
2750 assert(return_value
);
2751 assert(rc
== MEMCACHED_SUCCESS
);
2759 static test_return
mget_read_result(memcached_st
*memc
)
2761 memcached_return rc
;
2763 rc
= memcached_mget(memc
, global_keys
, global_keys_length
, global_count
);
2764 assert(rc
== MEMCACHED_SUCCESS
);
2765 /* Turn this into a help function */
2767 memcached_result_st results_obj
;
2768 memcached_result_st
*results
;
2770 results
= memcached_result_create(memc
, &results_obj
);
2772 while ((results
= memcached_fetch_result(memc
, &results_obj
, &rc
)))
2775 assert(rc
== MEMCACHED_SUCCESS
);
2778 memcached_result_free(&results_obj
);
2784 static test_return
mget_read_function(memcached_st
*memc
)
2786 memcached_return rc
;
2787 unsigned int counter
;
2788 memcached_execute_function callbacks
[1];
2790 rc
= memcached_mget(memc
, global_keys
, global_keys_length
, global_count
);
2791 assert(rc
== MEMCACHED_SUCCESS
);
2793 callbacks
[0]= &callback_counter
;
2795 rc
= memcached_fetch_execute(memc
, callbacks
, (void *)&counter
, 1);
2800 static test_return
delete_generate(memcached_st
*memc
)
2804 for (x
= 0; x
< global_count
; x
++)
2806 (void)memcached_delete(memc
, global_keys
[x
], global_keys_length
[x
], (time_t)0);
2812 static test_return
delete_buffer_generate(memcached_st
*memc
)
2818 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_BUFFER_REQUESTS
, latch
);
2820 for (x
= 0; x
< global_count
; x
++)
2822 (void)memcached_delete(memc
, global_keys
[x
], global_keys_length
[x
], (time_t)0);
2828 static test_return
free_data(memcached_st
*memc
__attribute__((unused
)))
2830 pairs_free(global_pairs
);
2835 static test_return
add_host_test1(memcached_st
*memc
)
2838 memcached_return rc
;
2839 char servername
[]= "0.example.com";
2840 memcached_server_st
*servers
;
2842 servers
= memcached_server_list_append_with_weight(NULL
, servername
, 400, 0, &rc
);
2844 assert(1 == memcached_server_list_count(servers
));
2846 for (x
= 2; x
< 20; x
++)
2848 char buffer
[SMALL_STRING_LEN
];
2850 snprintf(buffer
, SMALL_STRING_LEN
, "%u.example.com", 400+x
);
2851 servers
= memcached_server_list_append_with_weight(servers
, buffer
, 401, 0,
2853 assert(rc
== MEMCACHED_SUCCESS
);
2854 assert(x
== memcached_server_list_count(servers
));
2857 rc
= memcached_server_push(memc
, servers
);
2858 assert(rc
== MEMCACHED_SUCCESS
);
2859 rc
= memcached_server_push(memc
, servers
);
2860 assert(rc
== MEMCACHED_SUCCESS
);
2862 memcached_server_list_free(servers
);
2867 static memcached_return
pre_nonblock(memcached_st
*memc
)
2869 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NO_BLOCK
, 0);
2871 return MEMCACHED_SUCCESS
;
2874 static memcached_return
pre_nonblock_binary(memcached_st
*memc
)
2876 memcached_return rc
= MEMCACHED_FAILURE
;
2877 memcached_st
*clone
;
2879 clone
= memcached_clone(NULL
, memc
);
2881 // The memcached_version needs to be done on a clone, because the server
2882 // will not toggle protocol on an connection.
2883 memcached_version(clone
);
2885 if (clone
->hosts
[0].major_version
>= 1 && clone
->hosts
[0].minor_version
> 2)
2887 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NO_BLOCK
, 0);
2888 rc
= memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
, 1);
2889 assert(rc
== MEMCACHED_SUCCESS
);
2890 assert(memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
) == 1);
2893 memcached_free(clone
);
2897 static memcached_return
pre_murmur(memcached_st
*memc
)
2899 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_HASH
, (uint64_t)MEMCACHED_HASH_MURMUR
);
2901 return MEMCACHED_SUCCESS
;
2904 static memcached_return
pre_jenkins(memcached_st
*memc
)
2906 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_HASH
, (uint64_t)MEMCACHED_HASH_JENKINS
);
2908 return MEMCACHED_SUCCESS
;
2912 static memcached_return
pre_md5(memcached_st
*memc
)
2914 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_HASH
, (uint64_t)MEMCACHED_HASH_MD5
);
2916 return MEMCACHED_SUCCESS
;
2919 static memcached_return
pre_crc(memcached_st
*memc
)
2921 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_HASH
, (uint64_t)MEMCACHED_HASH_CRC
);
2923 return MEMCACHED_SUCCESS
;
2926 static memcached_return
pre_hsieh(memcached_st
*memc
)
2928 #ifdef HAVE_HSIEH_HASH
2929 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_HASH
, (uint64_t)MEMCACHED_HASH_HSIEH
);
2930 return MEMCACHED_SUCCESS
;
2932 return MEMCACHED_FAILURE
;
2936 static memcached_return
pre_hash_fnv1_64(memcached_st
*memc
)
2938 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_HASH
, (uint64_t)MEMCACHED_HASH_FNV1_64
);
2940 return MEMCACHED_SUCCESS
;
2943 static memcached_return
pre_hash_fnv1a_64(memcached_st
*memc
)
2945 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_HASH
, (uint64_t)MEMCACHED_HASH_FNV1A_64
);
2947 return MEMCACHED_SUCCESS
;
2950 static memcached_return
pre_hash_fnv1_32(memcached_st
*memc
)
2952 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_HASH
, (uint64_t)MEMCACHED_HASH_FNV1_32
);
2954 return MEMCACHED_SUCCESS
;
2957 static memcached_return
pre_hash_fnv1a_32(memcached_st
*memc
)
2959 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_HASH
, (uint64_t)MEMCACHED_HASH_FNV1A_32
);
2961 return MEMCACHED_SUCCESS
;
2964 static memcached_return
pre_behavior_ketama(memcached_st
*memc
)
2966 memcached_return rc
;
2969 rc
= memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_KETAMA
, 1);
2970 assert(rc
== MEMCACHED_SUCCESS
);
2972 value
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_KETAMA
);
2975 return MEMCACHED_SUCCESS
;
2978 static memcached_return
pre_behavior_ketama_weighted(memcached_st
*memc
)
2980 memcached_return rc
;
2983 rc
= memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_KETAMA_WEIGHTED
, 1);
2984 assert(rc
== MEMCACHED_SUCCESS
);
2986 value
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_KETAMA_WEIGHTED
);
2989 rc
= memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_KETAMA_HASH
, MEMCACHED_HASH_MD5
);
2990 assert(rc
== MEMCACHED_SUCCESS
);
2992 value
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_KETAMA_HASH
);
2993 assert(value
== MEMCACHED_HASH_MD5
);
2994 return MEMCACHED_SUCCESS
;
2997 static memcached_return
pre_binary(memcached_st
*memc
)
2999 memcached_return rc
= MEMCACHED_FAILURE
;
3000 memcached_st
*clone
;
3002 clone
= memcached_clone(NULL
, memc
);
3004 // The memcached_version needs to be done on a clone, because the server
3005 // will not toggle protocol on an connection.
3006 memcached_version(clone
);
3008 if (clone
->hosts
[0].major_version
>= 1 && clone
->hosts
[0].minor_version
> 2)
3010 rc
= memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
, 1);
3011 assert(rc
== MEMCACHED_SUCCESS
);
3012 assert(memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
) == 1);
3015 memcached_free(clone
);
3019 static void my_free(memcached_st
*ptr
__attribute__((unused
)), void *mem
)
3024 static void *my_malloc(memcached_st
*ptr
__attribute__((unused
)), const size_t size
)
3026 return malloc(size
);
3029 static void *my_realloc(memcached_st
*ptr
__attribute__((unused
)), void *mem
, const size_t size
)
3031 return realloc(mem
, size
);
3034 static memcached_return
set_prefix(memcached_st
*memc
)
3036 memcached_return rc
;
3037 const char *key
= "mine";
3040 /* Make sure be default none exists */
3041 value
= memcached_callback_get(memc
, MEMCACHED_CALLBACK_PREFIX_KEY
, &rc
);
3042 assert(rc
== MEMCACHED_FAILURE
);
3044 /* Test a clean set */
3045 rc
= memcached_callback_set(memc
, MEMCACHED_CALLBACK_PREFIX_KEY
, (void *)key
);
3046 assert(rc
== MEMCACHED_SUCCESS
);
3048 value
= memcached_callback_get(memc
, MEMCACHED_CALLBACK_PREFIX_KEY
, &rc
);
3049 assert(memcmp(value
, key
, 4) == 0);
3050 assert(rc
== MEMCACHED_SUCCESS
);
3052 /* Test that we can turn it off */
3053 rc
= memcached_callback_set(memc
, MEMCACHED_CALLBACK_PREFIX_KEY
, NULL
);
3054 assert(rc
== MEMCACHED_SUCCESS
);
3056 value
= memcached_callback_get(memc
, MEMCACHED_CALLBACK_PREFIX_KEY
, &rc
);
3057 assert(rc
== MEMCACHED_FAILURE
);
3059 /* Now setup for main test */
3060 rc
= memcached_callback_set(memc
, MEMCACHED_CALLBACK_PREFIX_KEY
, (void *)key
);
3061 assert(rc
== MEMCACHED_SUCCESS
);
3063 value
= memcached_callback_get(memc
, MEMCACHED_CALLBACK_PREFIX_KEY
, &rc
);
3064 assert(rc
== MEMCACHED_SUCCESS
);
3065 assert(memcmp(value
, key
, 4) == 0);
3067 /* Set to Zero, and then Set to something too large */
3070 rc
= memcached_callback_set(memc
, MEMCACHED_CALLBACK_PREFIX_KEY
, NULL
);
3071 assert(rc
== MEMCACHED_SUCCESS
);
3073 value
= memcached_callback_get(memc
, MEMCACHED_CALLBACK_PREFIX_KEY
, &rc
);
3074 assert(rc
== MEMCACHED_FAILURE
);
3075 assert(value
== NULL
);
3077 /* Test a long key for failure */
3078 /* TODO, extend test to determine based on setting, what result should be */
3079 long_key
= "Thisismorethentheallottednumberofcharacters";
3080 rc
= memcached_callback_set(memc
, MEMCACHED_CALLBACK_PREFIX_KEY
, long_key
);
3081 //assert(rc == MEMCACHED_BAD_KEY_PROVIDED);
3082 assert(rc
== MEMCACHED_SUCCESS
);
3084 /* Now test a key with spaces (which will fail from long key, since bad key is not set) */
3085 long_key
= "This is more then the allotted number of characters";
3086 rc
= memcached_callback_set(memc
, MEMCACHED_CALLBACK_PREFIX_KEY
, long_key
);
3087 assert(rc
== MEMCACHED_BAD_KEY_PROVIDED
);
3089 /* Test for a bad prefix, but with a short key */
3090 rc
= memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_VERIFY_KEY
, 1);
3091 assert(rc
== MEMCACHED_SUCCESS
);
3093 long_key
= "dog cat";
3094 rc
= memcached_callback_set(memc
, MEMCACHED_CALLBACK_PREFIX_KEY
, long_key
);
3095 assert(rc
== MEMCACHED_BAD_KEY_PROVIDED
);
3098 return MEMCACHED_SUCCESS
;
3101 static memcached_return
set_memory_alloc(memcached_st
*memc
)
3104 memcached_malloc_function test_ptr
;
3105 memcached_return rc
;
3107 rc
= memcached_callback_set(memc
, MEMCACHED_CALLBACK_MALLOC_FUNCTION
, (void*)&my_malloc
);
3108 assert(rc
== MEMCACHED_SUCCESS
);
3109 test_ptr
= (memcached_malloc_function
)memcached_callback_get(memc
, MEMCACHED_CALLBACK_MALLOC_FUNCTION
, &rc
);
3110 assert(rc
== MEMCACHED_SUCCESS
);
3111 assert(test_ptr
== my_malloc
);
3115 memcached_realloc_function test_ptr
;
3116 memcached_return rc
;
3118 rc
= memcached_callback_set(memc
, MEMCACHED_CALLBACK_REALLOC_FUNCTION
, (void*)&my_realloc
);
3119 assert(rc
== MEMCACHED_SUCCESS
);
3120 test_ptr
= (memcached_realloc_function
)memcached_callback_get(memc
, MEMCACHED_CALLBACK_REALLOC_FUNCTION
, &rc
);
3121 assert(rc
== MEMCACHED_SUCCESS
);
3122 assert(test_ptr
== my_realloc
);
3126 memcached_free_function test_ptr
;
3127 memcached_return rc
;
3129 rc
= memcached_callback_set(memc
, MEMCACHED_CALLBACK_FREE_FUNCTION
, (void*)my_free
);
3130 assert(rc
== MEMCACHED_SUCCESS
);
3131 test_ptr
= (memcached_free_function
)memcached_callback_get(memc
, MEMCACHED_CALLBACK_FREE_FUNCTION
, &rc
);
3132 assert(rc
== MEMCACHED_SUCCESS
);
3133 assert(test_ptr
== my_free
);
3136 return MEMCACHED_SUCCESS
;
3139 static memcached_return
enable_consistent(memcached_st
*memc
)
3141 memcached_server_distribution value
= MEMCACHED_DISTRIBUTION_CONSISTENT
;
3142 memcached_hash hash
;
3143 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_DISTRIBUTION
, value
);
3144 if (pre_hsieh(memc
) != MEMCACHED_SUCCESS
)
3145 return MEMCACHED_FAILURE
;
3147 value
= (memcached_server_distribution
)memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_DISTRIBUTION
);
3148 assert(value
== MEMCACHED_DISTRIBUTION_CONSISTENT
);
3150 hash
= (memcached_hash
)memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_HASH
);
3151 assert(hash
== MEMCACHED_HASH_HSIEH
);
3154 return MEMCACHED_SUCCESS
;
3157 static memcached_return
enable_cas(memcached_st
*memc
)
3159 unsigned int set
= 1;
3161 memcached_version(memc
);
3163 if ((memc
->hosts
[0].major_version
>= 1 && (memc
->hosts
[0].minor_version
== 2 && memc
->hosts
[0].micro_version
>= 4))
3164 || memc
->hosts
[0].minor_version
> 2)
3166 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_SUPPORT_CAS
, set
);
3168 return MEMCACHED_SUCCESS
;
3171 return MEMCACHED_FAILURE
;
3174 static memcached_return
check_for_1_2_3(memcached_st
*memc
)
3176 memcached_version(memc
);
3178 if ((memc
->hosts
[0].major_version
>= 1 && (memc
->hosts
[0].minor_version
== 2 && memc
->hosts
[0].micro_version
>= 4))
3179 || memc
->hosts
[0].minor_version
> 2)
3180 return MEMCACHED_SUCCESS
;
3182 return MEMCACHED_FAILURE
;
3185 static memcached_return
pre_unix_socket(memcached_st
*memc
)
3187 memcached_return rc
;
3190 memcached_server_list_free(memc
->hosts
);
3192 memc
->number_of_hosts
= 0;
3194 if (stat("/tmp/memcached.socket", &buf
))
3195 return MEMCACHED_FAILURE
;
3197 rc
= memcached_server_add_unix_socket_with_weight(memc
, "/tmp/memcached.socket", 0);
3202 static memcached_return
pre_nodelay(memcached_st
*memc
)
3204 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NO_BLOCK
, 0);
3205 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_TCP_NODELAY
, 0);
3207 return MEMCACHED_SUCCESS
;
3210 static memcached_return
pre_settimer(memcached_st
*memc
)
3212 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_SND_TIMEOUT
, 1000);
3213 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_RCV_TIMEOUT
, 1000);
3215 return MEMCACHED_SUCCESS
;
3218 static memcached_return
poll_timeout(memcached_st
*memc
)
3224 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_POLL_TIMEOUT
, timeout
);
3226 timeout
= (int32_t)memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_POLL_TIMEOUT
);
3228 assert(timeout
== 100);
3230 return MEMCACHED_SUCCESS
;
3233 static test_return
noreply_test(memcached_st
*memc
)
3235 memcached_return ret
;
3236 ret
= memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NOREPLY
, 1);
3237 assert(ret
== MEMCACHED_SUCCESS
);
3238 ret
= memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_BUFFER_REQUESTS
, 1);
3239 assert(ret
== MEMCACHED_SUCCESS
);
3240 ret
= memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_SUPPORT_CAS
, 1);
3241 assert(ret
== MEMCACHED_SUCCESS
);
3242 assert(memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_NOREPLY
) == 1);
3243 assert(memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_BUFFER_REQUESTS
) == 1);
3244 assert(memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_SUPPORT_CAS
) == 1);
3246 for (int count
=0; count
< 5; ++count
)
3248 for (int x
=0; x
< 100; ++x
)
3251 size_t len
=sprintf(key
, "%d", x
);
3255 ret
=memcached_add(memc
, key
, len
, key
, len
, 0, 0);
3258 ret
=memcached_replace(memc
, key
, len
, key
, len
, 0, 0);
3261 ret
=memcached_set(memc
, key
, len
, key
, len
, 0, 0);
3264 ret
=memcached_append(memc
, key
, len
, key
, len
, 0, 0);
3267 ret
=memcached_prepend(memc
, key
, len
, key
, len
, 0, 0);
3270 assert(ret
== MEMCACHED_SUCCESS
|| ret
== MEMCACHED_BUFFERED
);
3274 ** NOTE: Don't ever do this in your code! this is not a supported use of the
3275 ** API and is _ONLY_ done this way to verify that the library works the
3276 ** way it is supposed to do!!!!
3279 for (int x
=0; x
< memc
->number_of_hosts
; ++x
)
3280 no_msg
+=memc
->hosts
[x
].cursor_active
;
3282 assert(no_msg
== 0);
3283 assert(memcached_flush_buffers(memc
) == MEMCACHED_SUCCESS
);
3286 ** Now validate that all items was set properly!
3288 for (int x
=0; x
< 100; ++x
)
3291 size_t len
=sprintf(key
, "%d", x
);
3294 char* value
=memcached_get(memc
, key
, strlen(key
),
3295 &length
, &flags
, &ret
);
3296 assert(ret
== MEMCACHED_SUCCESS
&& value
!= NULL
);
3299 case 0: /* FALLTHROUGH */
3300 case 1: /* FALLTHROUGH */
3302 assert(strncmp(value
, key
, len
) == 0);
3303 assert(len
== length
);
3306 assert(length
== len
* 2);
3309 assert(length
== len
* 3);
3316 /* Try setting an illegal cas value (should not return an error to
3317 * the caller (because we don't expect a return message from the server)
3319 char* keys
[]= {"0"};
3320 size_t lengths
[]= {1};
3323 memcached_result_st results_obj
;
3324 memcached_result_st
*results
;
3325 ret
=memcached_mget(memc
, keys
, lengths
, 1);
3326 assert(ret
== MEMCACHED_SUCCESS
);
3328 results
=memcached_result_create(memc
, &results_obj
);
3330 results
=memcached_fetch_result(memc
, &results_obj
, &ret
);
3332 assert(ret
== MEMCACHED_SUCCESS
);
3333 uint64_t cas
= memcached_result_cas(results
);
3334 memcached_result_free(&results_obj
);
3336 ret
= memcached_cas(memc
, keys
[0], lengths
[0], keys
[0], lengths
[0], 0, 0, cas
);
3337 assert(ret
== MEMCACHED_SUCCESS
);
3340 * The item will have a new cas value, so try to set it again with the old
3341 * value. This should fail!
3343 ret
= memcached_cas(memc
, keys
[0], lengths
[0], keys
[0], lengths
[0], 0, 0, cas
);
3344 assert(ret
== MEMCACHED_SUCCESS
);
3345 assert(memcached_flush_buffers(memc
) == MEMCACHED_SUCCESS
);
3346 char* value
=memcached_get(memc
, keys
[0], lengths
[0], &length
, &flags
, &ret
);
3347 assert(ret
== MEMCACHED_SUCCESS
&& value
!= NULL
);
3350 return TEST_SUCCESS
;
3353 static test_return
analyzer_test(memcached_st
*memc
)
3355 memcached_return rc
;
3356 memcached_stat_st
*stat
;
3357 memcached_analysis_st
*report
;
3359 stat
= memcached_stat(memc
, NULL
, &rc
);
3360 assert(rc
== MEMCACHED_SUCCESS
);
3363 report
= memcached_analyze(memc
, stat
, &rc
);
3364 assert(rc
== MEMCACHED_SUCCESS
);
3368 memcached_stat_free(NULL
, stat
);
3370 return TEST_SUCCESS
;
3373 static void increment_request_id(uint16_t *id
)
3376 if ((*id
& UDP_REQUEST_ID_THREAD_MASK
) != 0)
3380 static uint16_t *get_udp_request_ids(memcached_st
*memc
)
3382 uint16_t *ids
= malloc(sizeof(uint16_t) * memc
->number_of_hosts
);
3383 assert(ids
!= NULL
);
3385 for (x
= 0; x
< memc
->number_of_hosts
; x
++)
3386 ids
[x
]= get_udp_datagram_request_id((struct udp_datagram_header_st
*) memc
->hosts
[x
].write_buffer
);
3391 static test_return
post_udp_op_check(memcached_st
*memc
, uint16_t *expected_req_ids
)
3394 memcached_server_st
*cur_server
= memc
->hosts
;
3395 uint16_t *cur_req_ids
= get_udp_request_ids(memc
);
3396 for (x
= 0; x
< memc
->number_of_hosts
; x
++)
3398 assert(cur_server
[x
].cursor_active
== 0);
3399 assert(cur_req_ids
[x
] == expected_req_ids
[x
]);
3401 free(expected_req_ids
);
3403 return TEST_SUCCESS
;
3407 ** There is a little bit of a hack here, instead of removing
3408 ** the servers, I just set num host to 0 and them add then new udp servers
3410 static memcached_return
init_udp(memcached_st
*memc
)
3412 memcached_version(memc
);
3413 /* For the time being, only support udp test for >= 1.2.6 && < 1.3 */
3414 if (memc
->hosts
[0].major_version
!= 1 || memc
->hosts
[0].minor_version
!= 2
3415 || memc
->hosts
[0].micro_version
< 6)
3416 return MEMCACHED_FAILURE
;
3418 uint32_t num_hosts
= memc
->number_of_hosts
;
3420 memcached_server_st servers
[num_hosts
];
3421 memcpy(servers
, memc
->hosts
, sizeof(memcached_server_st
) * num_hosts
);
3422 for (x
= 0; x
< num_hosts
; x
++)
3423 memcached_server_free(&memc
->hosts
[x
]);
3424 memc
->number_of_hosts
= 0;
3425 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_USE_UDP
, 1);
3426 for (x
= 0; x
< num_hosts
; x
++)
3428 assert(memcached_server_add_udp(memc
, servers
[x
].hostname
, servers
[x
].port
) == MEMCACHED_SUCCESS
);
3429 assert(memc
->hosts
[x
].write_buffer_offset
== UDP_DATAGRAM_HEADER_LENGTH
);
3431 return MEMCACHED_SUCCESS
;
3434 static memcached_return
binary_init_udp(memcached_st
*memc
)
3437 return init_udp(memc
);
3440 /* Make sure that I cant add a tcp server to a udp client */
3441 static test_return
add_tcp_server_udp_client_test(memcached_st
*memc
)
3443 memcached_server_st server
;
3444 memcached_server_clone(&server
, &memc
->hosts
[0]);
3445 assert(memcached_server_remove(&(memc
->hosts
[0])) == MEMCACHED_SUCCESS
);
3446 assert(memcached_server_add(memc
, server
.hostname
, server
.port
) == MEMCACHED_INVALID_HOST_PROTOCOL
);
3447 return TEST_SUCCESS
;
3450 /* Make sure that I cant add a udp server to a tcp client */
3451 static test_return
add_udp_server_tcp_client_test(memcached_st
*memc
)
3453 memcached_server_st server
;
3454 memcached_server_clone(&server
, &memc
->hosts
[0]);
3455 assert(memcached_server_remove(&(memc
->hosts
[0])) == MEMCACHED_SUCCESS
);
3457 memcached_st tcp_client
;
3458 memcached_create(&tcp_client
);
3459 assert(memcached_server_add_udp(&tcp_client
, server
.hostname
, server
.port
) == MEMCACHED_INVALID_HOST_PROTOCOL
);
3460 return TEST_SUCCESS
;
3463 static test_return
set_udp_behavior_test(memcached_st
*memc
)
3466 memcached_quit(memc
);
3467 memc
->number_of_hosts
= 0;
3468 run_distribution(memc
);
3469 assert(memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_USE_UDP
, 1) == MEMCACHED_SUCCESS
);
3470 assert(memc
->flags
& MEM_USE_UDP
);
3471 assert(memc
->flags
& MEM_NOREPLY
);;
3473 assert(memc
->number_of_hosts
== 0);
3475 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_USE_UDP
,0);
3476 assert(!(memc
->flags
& MEM_USE_UDP
));
3477 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NOREPLY
,0);
3478 assert(!(memc
->flags
& MEM_NOREPLY
));
3479 return TEST_SUCCESS
;
3482 static test_return
udp_set_test(memcached_st
*memc
)
3485 unsigned int num_iters
= 1025; //request id rolls over at 1024
3486 for (x
= 0; x
< num_iters
;x
++)
3488 memcached_return rc
;
3490 char *value
= "when we sanitize";
3491 uint16_t *expected_ids
= get_udp_request_ids(memc
);
3492 unsigned int server_key
= memcached_generate_hash(memc
,key
,strlen(key
));
3493 size_t init_offset
= memc
->hosts
[server_key
].write_buffer_offset
;
3494 rc
= memcached_set(memc
, key
, strlen(key
),
3495 value
, strlen(value
),
3496 (time_t)0, (uint32_t)0);
3497 assert(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
);
3498 /** NB, the check below assumes that if new write_ptr is less than
3499 * the original write_ptr that we have flushed. For large payloads, this
3500 * maybe an invalid assumption, but for the small payload we have it is OK
3502 if (rc
== MEMCACHED_SUCCESS
||
3503 memc
->hosts
[server_key
].write_buffer_offset
< init_offset
)
3504 increment_request_id(&expected_ids
[server_key
]);
3506 if (rc
== MEMCACHED_SUCCESS
)
3508 assert(memc
->hosts
[server_key
].write_buffer_offset
== UDP_DATAGRAM_HEADER_LENGTH
);
3512 assert(memc
->hosts
[server_key
].write_buffer_offset
!= UDP_DATAGRAM_HEADER_LENGTH
);
3513 assert(memc
->hosts
[server_key
].write_buffer_offset
<= MAX_UDP_DATAGRAM_LENGTH
);
3515 assert(post_udp_op_check(memc
,expected_ids
) == TEST_SUCCESS
);
3517 return TEST_SUCCESS
;
3520 static test_return
udp_buffered_set_test(memcached_st
*memc
)
3522 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_BUFFER_REQUESTS
, 1);
3523 return udp_set_test(memc
);
3526 static test_return
udp_set_too_big_test(memcached_st
*memc
)
3528 memcached_return rc
;
3530 char value
[MAX_UDP_DATAGRAM_LENGTH
];
3531 uint16_t *expected_ids
= get_udp_request_ids(memc
);
3532 rc
= memcached_set(memc
, key
, strlen(key
),
3533 value
, MAX_UDP_DATAGRAM_LENGTH
,
3534 (time_t)0, (uint32_t)0);
3535 assert(rc
== MEMCACHED_WRITE_FAILURE
);
3536 return post_udp_op_check(memc
,expected_ids
);
3539 test_return
udp_delete_test(memcached_st
*memc
)
3542 unsigned int num_iters
= 1025; //request id rolls over at 1024
3543 for (x
= 0; x
< num_iters
;x
++)
3545 memcached_return rc
;
3547 uint16_t *expected_ids
=get_udp_request_ids(memc
);
3548 unsigned int server_key
= memcached_generate_hash(memc
, key
, strlen(key
));
3549 size_t init_offset
= memc
->hosts
[server_key
].write_buffer_offset
;
3550 rc
= memcached_delete(memc
, key
, strlen(key
), 0);
3551 assert(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
);
3552 if (rc
== MEMCACHED_SUCCESS
|| memc
->hosts
[server_key
].write_buffer_offset
< init_offset
)
3553 increment_request_id(&expected_ids
[server_key
]);
3554 if (rc
== MEMCACHED_SUCCESS
)
3555 assert(memc
->hosts
[server_key
].write_buffer_offset
== UDP_DATAGRAM_HEADER_LENGTH
);
3558 assert(memc
->hosts
[server_key
].write_buffer_offset
!= UDP_DATAGRAM_HEADER_LENGTH
);
3559 assert(memc
->hosts
[server_key
].write_buffer_offset
<= MAX_UDP_DATAGRAM_LENGTH
);
3561 assert(post_udp_op_check(memc
,expected_ids
) == TEST_SUCCESS
);
3563 return TEST_SUCCESS
;
3566 static test_return
udp_buffered_delete_test(memcached_st
*memc
)
3568 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_BUFFER_REQUESTS
, 1);
3569 return udp_delete_test(memc
);
3572 test_return
udp_verbosity_test(memcached_st
*memc
)
3574 memcached_return rc
;
3575 uint16_t *expected_ids
= get_udp_request_ids(memc
);
3577 for (x
= 0; x
< memc
->number_of_hosts
;x
++)
3578 increment_request_id(&expected_ids
[x
]);
3580 rc
= memcached_verbosity(memc
,3);
3581 assert(rc
== MEMCACHED_SUCCESS
);
3582 return post_udp_op_check(memc
,expected_ids
);
3585 test_return
udp_quit_test(memcached_st
*memc
)
3587 uint16_t *expected_ids
= get_udp_request_ids(memc
);
3588 memcached_quit(memc
);
3589 return post_udp_op_check(memc
, expected_ids
);
3592 test_return
udp_flush_test(memcached_st
*memc
)
3594 memcached_return rc
;
3595 uint16_t *expected_ids
= get_udp_request_ids(memc
);
3597 for (x
= 0; x
< memc
->number_of_hosts
;x
++)
3598 increment_request_id(&expected_ids
[x
]);
3600 rc
= memcached_flush(memc
,0);
3601 assert(rc
== MEMCACHED_SUCCESS
);
3602 return post_udp_op_check(memc
,expected_ids
);
3605 test_return
udp_incr_test(memcached_st
*memc
)
3607 memcached_return rc
;
3610 rc
= memcached_set(memc
, key
, strlen(key
),
3611 value
, strlen(value
),
3612 (time_t)0, (uint32_t)0);
3614 assert(rc
== MEMCACHED_SUCCESS
);
3615 uint16_t *expected_ids
= get_udp_request_ids(memc
);
3616 unsigned int server_key
= memcached_generate_hash(memc
, key
, strlen(key
));
3617 increment_request_id(&expected_ids
[server_key
]);
3619 rc
= memcached_increment(memc
, key
, strlen(key
), 1, &newvalue
);
3620 assert(rc
== MEMCACHED_SUCCESS
);
3621 return post_udp_op_check(memc
, expected_ids
);
3624 test_return
udp_decr_test(memcached_st
*memc
)
3626 memcached_return rc
;
3629 rc
= memcached_set(memc
, key
, strlen(key
),
3630 value
, strlen(value
),
3631 (time_t)0, (uint32_t)0);
3633 assert(rc
== MEMCACHED_SUCCESS
);
3634 uint16_t *expected_ids
= get_udp_request_ids(memc
);
3635 unsigned int server_key
= memcached_generate_hash(memc
, key
, strlen(key
));
3636 increment_request_id(&expected_ids
[server_key
]);
3638 rc
= memcached_decrement(memc
, key
, strlen(key
), 1, &newvalue
);
3639 assert(rc
== MEMCACHED_SUCCESS
);
3640 return post_udp_op_check(memc
, expected_ids
);
3644 test_return
udp_stat_test(memcached_st
*memc
)
3646 memcached_stat_st
* rv
= NULL
;
3647 memcached_return rc
;
3649 uint16_t *expected_ids
= get_udp_request_ids(memc
);
3650 rv
= memcached_stat(memc
, args
, &rc
);
3652 assert(rc
== MEMCACHED_NOT_SUPPORTED
);
3653 return post_udp_op_check(memc
, expected_ids
);
3656 test_return
udp_version_test(memcached_st
*memc
)
3658 memcached_return rc
;
3659 uint16_t *expected_ids
= get_udp_request_ids(memc
);
3660 rc
= memcached_version(memc
);
3661 assert(rc
== MEMCACHED_NOT_SUPPORTED
);
3662 return post_udp_op_check(memc
, expected_ids
);
3665 test_return
udp_get_test(memcached_st
*memc
)
3667 memcached_return rc
;
3670 uint16_t *expected_ids
= get_udp_request_ids(memc
);
3671 char *val
= memcached_get(memc
, key
, strlen(key
), &vlen
, (uint32_t)0, &rc
);
3672 assert(rc
== MEMCACHED_NOT_SUPPORTED
);
3673 assert(val
== NULL
);
3674 return post_udp_op_check(memc
, expected_ids
);
3677 test_return
udp_mixed_io_test(memcached_st
*memc
)
3680 test_st mixed_io_ops
[] ={
3681 {"udp_set_test", 0, udp_set_test
},
3682 {"udp_set_too_big_test", 0, udp_set_too_big_test
},
3683 {"udp_delete_test", 0, udp_delete_test
},
3684 {"udp_verbosity_test", 0, udp_verbosity_test
},
3685 {"udp_quit_test", 0, udp_quit_test
},
3686 {"udp_flush_test", 0, udp_flush_test
},
3687 {"udp_incr_test", 0, udp_incr_test
},
3688 {"udp_decr_test", 0, udp_decr_test
},
3689 {"udp_version_test", 0, udp_version_test
}
3692 for (x
= 0; x
< 500; x
++)
3694 current_op
= mixed_io_ops
[random() % 9];
3695 assert(current_op
.function(memc
) == TEST_SUCCESS
);
3697 return TEST_SUCCESS
;
3700 test_return
hsieh_avaibility_test (memcached_st
*memc
)
3702 memcached_return expected_rc
= MEMCACHED_FAILURE
;
3703 #ifdef HAVE_HSIEH_HASH
3704 expected_rc
= MEMCACHED_SUCCESS
;
3706 memcached_return rc
= memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_HASH
,
3707 (uint64_t)MEMCACHED_HASH_HSIEH
);
3708 assert(rc
== expected_rc
);
3709 return TEST_SUCCESS
;
3712 test_st udp_setup_server_tests
[] ={
3713 {"set_udp_behavior_test", 0, set_udp_behavior_test
},
3714 {"add_tcp_server_udp_client_test", 0, add_tcp_server_udp_client_test
},
3715 {"add_udp_server_tcp_client_test", 0, add_udp_server_tcp_client_test
},
3719 test_st upd_io_tests
[] ={
3720 {"udp_set_test", 0, udp_set_test
},
3721 {"udp_buffered_set_test", 0, udp_buffered_set_test
},
3722 {"udp_set_too_big_test", 0, udp_set_too_big_test
},
3723 {"udp_delete_test", 0, udp_delete_test
},
3724 {"udp_buffered_delete_test", 0, udp_buffered_delete_test
},
3725 {"udp_verbosity_test", 0, udp_verbosity_test
},
3726 {"udp_quit_test", 0, udp_quit_test
},
3727 {"udp_flush_test", 0, udp_flush_test
},
3728 {"udp_incr_test", 0, udp_incr_test
},
3729 {"udp_decr_test", 0, udp_decr_test
},
3730 {"udp_stat_test", 0, udp_stat_test
},
3731 {"udp_version_test", 0, udp_version_test
},
3732 {"udp_get_test", 0, udp_get_test
},
3733 {"udp_mixed_io_test", 0, udp_mixed_io_test
},
3737 /* Clean the server before beginning testing */
3739 {"flush", 0, flush_test
},
3740 {"init", 0, init_test
},
3741 {"allocation", 0, allocation_test
},
3742 {"server_list_null_test", 0, server_list_null_test
},
3743 {"server_unsort", 0, server_unsort_test
},
3744 {"server_sort", 0, server_sort_test
},
3745 {"server_sort2", 0, server_sort2_test
},
3746 {"clone_test", 0, clone_test
},
3747 {"error", 0, error_test
},
3748 {"set", 0, set_test
},
3749 {"set2", 0, set_test2
},
3750 {"set3", 0, set_test3
},
3751 {"add", 1, add_test
},
3752 {"replace", 1, replace_test
},
3753 {"delete", 1, delete_test
},
3754 {"get", 1, get_test
},
3755 {"get2", 0, get_test2
},
3756 {"get3", 0, get_test3
},
3757 {"get4", 0, get_test4
},
3758 {"partial mget", 0, get_test5
},
3759 {"stats_servername", 0, stats_servername_test
},
3760 {"increment", 0, increment_test
},
3761 {"increment_with_initial", 1, increment_with_initial_test
},
3762 {"decrement", 0, decrement_test
},
3763 {"decrement_with_initial", 1, decrement_with_initial_test
},
3764 {"quit", 0, quit_test
},
3765 {"mget", 1, mget_test
},
3766 {"mget_result", 1, mget_result_test
},
3767 {"mget_result_alloc", 1, mget_result_alloc_test
},
3768 {"mget_result_function", 1, mget_result_function
},
3769 {"get_stats", 0, get_stats
},
3770 {"add_host_test", 0, add_host_test
},
3771 {"add_host_test_1", 0, add_host_test1
},
3772 {"get_stats_keys", 0, get_stats_keys
},
3773 {"behavior_test", 0, get_stats_keys
},
3774 {"callback_test", 0, get_stats_keys
},
3775 {"version_string_test", 0, version_string_test
},
3776 {"bad_key", 1, bad_key_test
},
3777 {"memcached_server_cursor", 1, memcached_server_cursor_test
},
3778 {"read_through", 1, read_through
},
3779 {"delete_through", 1, delete_through
},
3780 {"noreply", 1, noreply_test
},
3781 {"analyzer", 1, analyzer_test
},
3785 test_st async_tests
[] ={
3786 {"add", 1, add_wrapper
},
3790 test_st string_tests
[] ={
3791 {"string static with null", 0, string_static_null
},
3792 {"string alloc with null", 0, string_alloc_null
},
3793 {"string alloc with 1K", 0, string_alloc_with_size
},
3794 {"string alloc with malloc failure", 0, string_alloc_with_size_toobig
},
3795 {"string append", 0, string_alloc_append
},
3796 {"string append failure (too big)", 0, string_alloc_append_toobig
},
3800 test_st result_tests
[] ={
3801 {"result static", 0, result_static
},
3802 {"result alloc", 0, result_alloc
},
3806 test_st version_1_2_3
[] ={
3807 {"append", 0, append_test
},
3808 {"prepend", 0, prepend_test
},
3809 {"cas", 0, cas_test
},
3810 {"cas2", 0, cas2_test
},
3811 {"append_binary", 0, append_binary_test
},
3815 test_st user_tests
[] ={
3816 {"user_supplied_bug1", 0, user_supplied_bug1
},
3817 {"user_supplied_bug2", 0, user_supplied_bug2
},
3818 {"user_supplied_bug3", 0, user_supplied_bug3
},
3819 {"user_supplied_bug4", 0, user_supplied_bug4
},
3820 {"user_supplied_bug5", 1, user_supplied_bug5
},
3821 {"user_supplied_bug6", 1, user_supplied_bug6
},
3822 {"user_supplied_bug7", 1, user_supplied_bug7
},
3823 {"user_supplied_bug8", 1, user_supplied_bug8
},
3824 {"user_supplied_bug9", 1, user_supplied_bug9
},
3825 {"user_supplied_bug10", 1, user_supplied_bug10
},
3826 {"user_supplied_bug11", 1, user_supplied_bug11
},
3827 {"user_supplied_bug12", 1, user_supplied_bug12
},
3828 {"user_supplied_bug13", 1, user_supplied_bug13
},
3829 {"user_supplied_bug14", 1, user_supplied_bug14
},
3830 {"user_supplied_bug15", 1, user_supplied_bug15
},
3831 {"user_supplied_bug16", 1, user_supplied_bug16
},
3834 ** It seems to be something weird with the character sets..
3835 ** value_fetch is unable to parse the value line (iscntrl "fails"), so I
3836 ** guess I need to find out how this is supposed to work.. Perhaps I need
3837 ** to run the test in a specific locale (I tried zh_CN.UTF-8 without success,
3838 ** so just disable the code for now...).
3840 {"user_supplied_bug17", 1, user_supplied_bug17
},
3842 {"user_supplied_bug18", 1, user_supplied_bug18
},
3843 {"user_supplied_bug19", 1, user_supplied_bug19
},
3844 {"user_supplied_bug20", 1, user_supplied_bug20
},
3848 test_st generate_tests
[] ={
3849 {"generate_pairs", 1, generate_pairs
},
3850 {"generate_data", 1, generate_data
},
3851 {"get_read", 0, get_read
},
3852 {"delete_generate", 0, delete_generate
},
3853 {"generate_buffer_data", 1, generate_buffer_data
},
3854 {"delete_buffer", 0, delete_buffer_generate
},
3855 {"generate_data", 1, generate_data
},
3856 {"mget_read", 0, mget_read
},
3857 {"mget_read_result", 0, mget_read_result
},
3858 {"mget_read_function", 0, mget_read_function
},
3859 {"cleanup", 1, cleanup_pairs
},
3860 {"generate_large_pairs", 1, generate_large_pairs
},
3861 {"generate_data", 1, generate_data
},
3862 {"generate_buffer_data", 1, generate_buffer_data
},
3863 {"cleanup", 1, cleanup_pairs
},
3867 test_st consistent_tests
[] ={
3868 {"generate_pairs", 1, generate_pairs
},
3869 {"generate_data", 1, generate_data
},
3870 {"get_read", 0, get_read_count
},
3871 {"cleanup", 1, cleanup_pairs
},
3875 test_st consistent_weighted_tests
[] ={
3876 {"generate_pairs", 1, generate_pairs
},
3877 {"generate_data", 1, generate_data_with_stats
},
3878 {"get_read", 0, get_read_count
},
3879 {"cleanup", 1, cleanup_pairs
},
3883 test_st hsieh_availability
[] ={
3884 {"hsieh_avaibility_test",0,hsieh_avaibility_test
},
3888 test_st ketama_auto_eject_hosts
[] ={
3889 {"auto_eject_hosts", 1, auto_eject_hosts
},
3893 collection_st collection
[] ={
3894 {"hsieh_availability",0,0,hsieh_availability
},
3895 {"udp_setup", init_udp
, 0, udp_setup_server_tests
},
3896 {"udp_io", init_udp
, 0, upd_io_tests
},
3897 {"udp_binary_io", binary_init_udp
, 0, upd_io_tests
},
3898 {"block", 0, 0, tests
},
3899 {"binary", pre_binary
, 0, tests
},
3900 {"nonblock", pre_nonblock
, 0, tests
},
3901 {"nodelay", pre_nodelay
, 0, tests
},
3902 {"settimer", pre_settimer
, 0, tests
},
3903 {"md5", pre_md5
, 0, tests
},
3904 {"crc", pre_crc
, 0, tests
},
3905 {"hsieh", pre_hsieh
, 0, tests
},
3906 {"jenkins", pre_jenkins
, 0, tests
},
3907 {"fnv1_64", pre_hash_fnv1_64
, 0, tests
},
3908 {"fnv1a_64", pre_hash_fnv1a_64
, 0, tests
},
3909 {"fnv1_32", pre_hash_fnv1_32
, 0, tests
},
3910 {"fnv1a_32", pre_hash_fnv1a_32
, 0, tests
},
3911 {"ketama", pre_behavior_ketama
, 0, tests
},
3912 {"ketama_auto_eject_hosts", pre_behavior_ketama
, 0, ketama_auto_eject_hosts
},
3913 {"unix_socket", pre_unix_socket
, 0, tests
},
3914 {"unix_socket_nodelay", pre_nodelay
, 0, tests
},
3915 {"poll_timeout", poll_timeout
, 0, tests
},
3916 {"gets", enable_cas
, 0, tests
},
3917 {"consistent", enable_consistent
, 0, tests
},
3918 {"memory_allocators", set_memory_alloc
, 0, tests
},
3919 {"prefix", set_prefix
, 0, tests
},
3920 {"version_1_2_3", check_for_1_2_3
, 0, version_1_2_3
},
3921 {"string", 0, 0, string_tests
},
3922 {"result", 0, 0, result_tests
},
3923 {"async", pre_nonblock
, 0, async_tests
},
3924 {"async_binary", pre_nonblock_binary
, 0, async_tests
},
3925 {"user", 0, 0, user_tests
},
3926 {"generate", 0, 0, generate_tests
},
3927 {"generate_hsieh", pre_hsieh
, 0, generate_tests
},
3928 {"generate_ketama", pre_behavior_ketama
, 0, generate_tests
},
3929 {"generate_hsieh_consistent", enable_consistent
, 0, generate_tests
},
3930 {"generate_md5", pre_md5
, 0, generate_tests
},
3931 {"generate_murmur", pre_murmur
, 0, generate_tests
},
3932 {"generate_jenkins", pre_jenkins
, 0, generate_tests
},
3933 {"generate_nonblock", pre_nonblock
, 0, generate_tests
},
3934 {"consistent_not", 0, 0, consistent_tests
},
3935 {"consistent_ketama", pre_behavior_ketama
, 0, consistent_tests
},
3936 {"consistent_ketama_weighted", pre_behavior_ketama_weighted
, 0, consistent_weighted_tests
},
3940 #define SERVERS_TO_CREATE 5
3942 /* Prototypes for functions we will pass to test framework */
3943 void *world_create(void);
3944 void world_destroy(void *p
);
3946 void *world_create(void)
3948 server_startup_st
*construct
;
3950 construct
= (server_startup_st
*)malloc(sizeof(server_startup_st
));
3951 memset(construct
, 0, sizeof(server_startup_st
));
3952 construct
->count
= SERVERS_TO_CREATE
;
3954 server_startup(construct
);
3960 void world_destroy(void *p
)
3962 server_startup_st
*construct
= (server_startup_st
*)p
;
3963 memcached_server_st
*servers
= (memcached_server_st
*)construct
->servers
;
3964 memcached_server_list_free(servers
);
3966 server_shutdown(construct
);
3970 void get_world(world_st
*world
)
3972 world
->collections
= collection
;
3973 world
->create
= world_create
;
3974 world
->destroy
= world_destroy
;