2 Sample test application.
5 #include "libmemcached/common.h"
12 #include <sys/types.h>
18 #include "clients/generator.h"
19 #include "clients/execute.h"
22 #define INT64_MAX LONG_MAX
25 #define INT32_MAX INT_MAX
31 #ifdef HAVE_LIBMEMCACHEDUTIL
33 #include "libmemcached/memcached_util.h"
36 #define GLOBAL_COUNT 10000
37 #define GLOBAL2_COUNT 100
38 #define SERVERS_TO_CREATE 5
39 static uint32_t global_count
;
41 static pairs_st
*global_pairs
;
42 static const char *global_keys
[GLOBAL_COUNT
];
43 static size_t global_keys_length
[GLOBAL_COUNT
];
45 static test_return_t
init_test(memcached_st
*not_used
__attribute__((unused
)))
49 (void)memcached_create(&memc
);
50 memcached_free(&memc
);
55 static test_return_t
server_list_null_test(memcached_st
*ptr
__attribute__((unused
)))
57 memcached_server_st
*server_list
;
60 server_list
= memcached_server_list_append_with_weight(NULL
, NULL
, 0, 0, NULL
);
61 assert(server_list
== NULL
);
63 server_list
= memcached_server_list_append_with_weight(NULL
, "localhost", 0, 0, NULL
);
64 assert(server_list
== NULL
);
66 server_list
= memcached_server_list_append_with_weight(NULL
, NULL
, 0, 0, &rc
);
67 assert(server_list
== NULL
);
72 #define TEST_PORT_COUNT 7
73 uint32_t test_ports
[TEST_PORT_COUNT
];
75 static memcached_return
server_display_function(memcached_st
*ptr
__attribute__((unused
)), memcached_server_st
*server
, void *context
)
78 uint32_t bigger
= *((uint32_t *)(context
));
79 assert(bigger
<= server
->port
);
80 *((uint32_t *)(context
))= server
->port
;
82 return MEMCACHED_SUCCESS
;
85 static test_return_t
server_sort_test(memcached_st
*ptr
__attribute__((unused
)))
88 uint32_t bigger
= 0; /* Prime the value for the assert in server_display_function */
90 memcached_server_function callbacks
[1];
91 memcached_st
*local_memc
;
93 local_memc
= memcached_create(NULL
);
95 memcached_behavior_set(local_memc
, MEMCACHED_BEHAVIOR_SORT_HOSTS
, 1);
97 for (x
= 0; x
< TEST_PORT_COUNT
; x
++)
99 test_ports
[x
]= (uint32_t)random() % 64000;
100 rc
= memcached_server_add_with_weight(local_memc
, "localhost", test_ports
[x
], 0);
101 assert(local_memc
->number_of_hosts
== x
+ 1);
102 assert(local_memc
->hosts
[0].count
== x
+1);
103 assert(rc
== MEMCACHED_SUCCESS
);
106 callbacks
[0]= server_display_function
;
107 memcached_server_cursor(local_memc
, callbacks
, (void *)&bigger
, 1);
110 memcached_free(local_memc
);
115 static test_return_t
server_sort2_test(memcached_st
*ptr
__attribute__((unused
)))
117 uint32_t bigger
= 0; /* Prime the value for the assert in server_display_function */
119 memcached_server_function callbacks
[1];
120 memcached_st
*local_memc
;
122 local_memc
= memcached_create(NULL
);
124 rc
= memcached_behavior_set(local_memc
, MEMCACHED_BEHAVIOR_SORT_HOSTS
, 1);
125 assert(rc
== MEMCACHED_SUCCESS
);
127 rc
= memcached_server_add_with_weight(local_memc
, "MEMCACHED_BEHAVIOR_SORT_HOSTS", 43043, 0);
128 assert(rc
== MEMCACHED_SUCCESS
);
129 assert(local_memc
->hosts
[0].port
== 43043);
131 rc
= memcached_server_add_with_weight(local_memc
, "MEMCACHED_BEHAVIOR_SORT_HOSTS", 43042, 0);
132 assert(rc
== MEMCACHED_SUCCESS
);
133 assert(local_memc
->hosts
[0].port
== 43042);
134 assert(local_memc
->hosts
[1].port
== 43043);
136 callbacks
[0]= server_display_function
;
137 memcached_server_cursor(local_memc
, callbacks
, (void *)&bigger
, 1);
140 memcached_free(local_memc
);
145 static memcached_return
server_display_unsort_function(memcached_st
*ptr
__attribute__((unused
)), memcached_server_st
*server
, void *context
)
148 uint32_t x
= *((uint32_t *)(context
));
150 assert(test_ports
[x
] == server
->port
);
151 *((uint32_t *)(context
))= ++x
;
153 return MEMCACHED_SUCCESS
;
156 static test_return_t
server_unsort_test(memcached_st
*ptr
__attribute__((unused
)))
159 uint32_t counter
= 0; /* Prime the value for the assert in server_display_function */
160 uint32_t bigger
= 0; /* Prime the value for the assert in server_display_function */
162 memcached_server_function callbacks
[1];
163 memcached_st
*local_memc
;
165 local_memc
= memcached_create(NULL
);
168 for (x
= 0; x
< TEST_PORT_COUNT
; x
++)
170 test_ports
[x
]= (uint32_t)(random() % 64000);
171 rc
= memcached_server_add_with_weight(local_memc
, "localhost", test_ports
[x
], 0);
172 assert(local_memc
->number_of_hosts
== x
+1);
173 assert(local_memc
->hosts
[0].count
== x
+1);
174 assert(rc
== MEMCACHED_SUCCESS
);
177 callbacks
[0]= server_display_unsort_function
;
178 memcached_server_cursor(local_memc
, callbacks
, (void *)&counter
, 1);
180 /* Now we sort old data! */
181 memcached_behavior_set(local_memc
, MEMCACHED_BEHAVIOR_SORT_HOSTS
, 1);
182 callbacks
[0]= server_display_function
;
183 memcached_server_cursor(local_memc
, callbacks
, (void *)&bigger
, 1);
186 memcached_free(local_memc
);
191 static test_return_t
allocation_test(memcached_st
*not_used
__attribute__((unused
)))
194 memc
= memcached_create(NULL
);
196 memcached_free(memc
);
201 static test_return_t
clone_test(memcached_st
*memc
)
205 memcached_st
*memc_clone
;
206 memc_clone
= memcached_clone(NULL
, NULL
);
208 memcached_free(memc_clone
);
211 /* Can we init from null? */
213 memcached_st
*memc_clone
;
214 memc_clone
= memcached_clone(NULL
, memc
);
217 assert(memc_clone
->call_free
== memc
->call_free
);
218 assert(memc_clone
->call_malloc
== memc
->call_malloc
);
219 assert(memc_clone
->call_realloc
== memc
->call_realloc
);
220 assert(memc_clone
->call_calloc
== memc
->call_calloc
);
221 assert(memc_clone
->connect_timeout
== memc
->connect_timeout
);
222 assert(memc_clone
->delete_trigger
== memc
->delete_trigger
);
223 assert(memc_clone
->distribution
== memc
->distribution
);
224 assert(memc_clone
->flags
== memc
->flags
);
225 assert(memc_clone
->get_key_failure
== memc
->get_key_failure
);
226 assert(memc_clone
->hash
== memc
->hash
);
227 assert(memc_clone
->hash_continuum
== memc
->hash_continuum
);
228 assert(memc_clone
->io_bytes_watermark
== memc
->io_bytes_watermark
);
229 assert(memc_clone
->io_msg_watermark
== memc
->io_msg_watermark
);
230 assert(memc_clone
->io_key_prefetch
== memc
->io_key_prefetch
);
231 assert(memc_clone
->on_cleanup
== memc
->on_cleanup
);
232 assert(memc_clone
->on_clone
== memc
->on_clone
);
233 assert(memc_clone
->poll_timeout
== memc
->poll_timeout
);
234 assert(memc_clone
->rcv_timeout
== memc
->rcv_timeout
);
235 assert(memc_clone
->recv_size
== memc
->recv_size
);
236 assert(memc_clone
->retry_timeout
== memc
->retry_timeout
);
237 assert(memc_clone
->send_size
== memc
->send_size
);
238 assert(memc_clone
->server_failure_limit
== memc
->server_failure_limit
);
239 assert(memc_clone
->snd_timeout
== memc
->snd_timeout
);
240 assert(memc_clone
->user_data
== memc
->user_data
);
242 memcached_free(memc_clone
);
245 /* Can we init from struct? */
247 memcached_st declared_clone
;
248 memcached_st
*memc_clone
;
249 memset(&declared_clone
, 0 , sizeof(memcached_st
));
250 memc_clone
= memcached_clone(&declared_clone
, NULL
);
252 memcached_free(memc_clone
);
255 /* Can we init from struct? */
257 memcached_st declared_clone
;
258 memcached_st
*memc_clone
;
259 memset(&declared_clone
, 0 , sizeof(memcached_st
));
260 memc_clone
= memcached_clone(&declared_clone
, memc
);
262 memcached_free(memc_clone
);
268 static test_return_t
userdata_test(memcached_st
*memc
)
271 assert(memcached_set_user_data(memc
, foo
) == NULL
);
272 assert(memcached_get_user_data(memc
) == foo
);
273 assert(memcached_set_user_data(memc
, NULL
) == foo
);
278 static test_return_t
connection_test(memcached_st
*memc
)
282 rc
= memcached_server_add_with_weight(memc
, "localhost", 0, 0);
283 assert(rc
== MEMCACHED_SUCCESS
);
288 static test_return_t
error_test(memcached_st
*memc
)
291 uint32_t values
[] = { 851992627U, 2337886783U, 3196981036U, 4001849190U,
292 982370485U, 1263635348U, 4242906218U, 3829656100U,
293 1891735253U, 334139633U, 2257084983U, 3088286104U,
294 13199785U, 2542027183U, 1097051614U, 199566778U,
295 2748246961U, 2465192557U, 1664094137U, 2405439045U,
296 1842224848U, 692413798U, 3479807801U, 919913813U,
297 4269430871U, 610793021U, 527273862U, 1437122909U,
298 2300930706U, 2943759320U, 674306647U, 2400528935U,
299 54481931U, 4186304426U, 1741088401U, 2979625118U,
300 4159057246U, 3425930182U};
302 // You have updated the memcache_error messages but not updated docs/tests.
303 assert(MEMCACHED_MAXIMUM_RETURN
== 38);
304 for (rc
= MEMCACHED_SUCCESS
; rc
< MEMCACHED_MAXIMUM_RETURN
; rc
++)
307 const char *msg
= memcached_strerror(memc
, rc
);
308 hash_val
= memcached_generate_hash_value(msg
, strlen(msg
),
309 MEMCACHED_HASH_JENKINS
);
310 assert(values
[rc
] == hash_val
);
316 static test_return_t
set_test(memcached_st
*memc
)
319 const char *key
= "foo";
320 const char *value
= "when we sanitize";
322 rc
= memcached_set(memc
, key
, strlen(key
),
323 value
, strlen(value
),
324 (time_t)0, (uint32_t)0);
325 assert(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
);
330 static test_return_t
append_test(memcached_st
*memc
)
333 const char *key
= "fig";
334 const char *in_value
= "we";
335 char *out_value
= NULL
;
339 rc
= memcached_flush(memc
, 0);
340 assert(rc
== MEMCACHED_SUCCESS
);
342 rc
= memcached_set(memc
, key
, strlen(key
),
343 in_value
, strlen(in_value
),
344 (time_t)0, (uint32_t)0);
345 assert(rc
== MEMCACHED_SUCCESS
);
347 rc
= memcached_append(memc
, key
, strlen(key
),
348 " the", strlen(" the"),
349 (time_t)0, (uint32_t)0);
350 assert(rc
== MEMCACHED_SUCCESS
);
352 rc
= memcached_append(memc
, key
, strlen(key
),
353 " people", strlen(" people"),
354 (time_t)0, (uint32_t)0);
355 assert(rc
== MEMCACHED_SUCCESS
);
357 out_value
= memcached_get(memc
, key
, strlen(key
),
358 &value_length
, &flags
, &rc
);
359 assert(!memcmp(out_value
, "we the people", strlen("we the people")));
360 assert(strlen("we the people") == value_length
);
361 assert(rc
== MEMCACHED_SUCCESS
);
367 static test_return_t
append_binary_test(memcached_st
*memc
)
370 const char *key
= "numbers";
371 unsigned int *store_ptr
;
372 unsigned int store_list
[] = { 23, 56, 499, 98, 32847, 0 };
378 rc
= memcached_flush(memc
, 0);
379 assert(rc
== MEMCACHED_SUCCESS
);
381 rc
= memcached_set(memc
,
384 (time_t)0, (uint32_t)0);
385 assert(rc
== MEMCACHED_SUCCESS
);
387 for (x
= 0; store_list
[x
] ; x
++)
389 rc
= memcached_append(memc
,
391 (char *)&store_list
[x
], sizeof(unsigned int),
392 (time_t)0, (uint32_t)0);
393 assert(rc
== MEMCACHED_SUCCESS
);
396 value
= memcached_get(memc
, key
, strlen(key
),
397 &value_length
, &flags
, &rc
);
398 assert((value_length
== (sizeof(unsigned int) * x
)));
399 assert(rc
== MEMCACHED_SUCCESS
);
401 store_ptr
= (unsigned int *)value
;
403 while ((size_t)store_ptr
< (size_t)(value
+ value_length
))
405 assert(*store_ptr
== store_list
[x
++]);
413 static test_return_t
cas2_test(memcached_st
*memc
)
416 const char *keys
[]= {"fudge", "son", "food"};
417 size_t key_length
[]= {5, 3, 4};
418 const char *value
= "we the people";
419 size_t value_length
= strlen("we the people");
421 memcached_result_st results_obj
;
422 memcached_result_st
*results
;
425 rc
= memcached_flush(memc
, 0);
426 assert(rc
== MEMCACHED_SUCCESS
);
428 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_SUPPORT_CAS
, set
);
430 for (x
= 0; x
< 3; x
++)
432 rc
= memcached_set(memc
, keys
[x
], key_length
[x
],
433 keys
[x
], key_length
[x
],
434 (time_t)50, (uint32_t)9);
435 assert(rc
== MEMCACHED_SUCCESS
);
438 rc
= memcached_mget(memc
, keys
, key_length
, 3);
440 results
= memcached_result_create(memc
, &results_obj
);
442 results
= memcached_fetch_result(memc
, &results_obj
, &rc
);
444 assert(results
->cas
);
445 assert(rc
== MEMCACHED_SUCCESS
);
446 assert(memcached_result_cas(results
));
448 assert(!memcmp(value
, "we the people", strlen("we the people")));
449 assert(strlen("we the people") == value_length
);
450 assert(rc
== MEMCACHED_SUCCESS
);
452 memcached_result_free(&results_obj
);
457 static test_return_t
cas_test(memcached_st
*memc
)
460 const char *key
= "fun";
461 size_t key_length
= strlen(key
);
462 const char *value
= "we the people";
463 const char* keys
[2] = { key
, NULL
};
464 size_t keylengths
[2] = { strlen(key
), 0 };
465 size_t value_length
= strlen(value
);
466 const char *value2
= "change the value";
467 size_t value2_length
= strlen(value2
);
469 memcached_result_st results_obj
;
470 memcached_result_st
*results
;
473 rc
= memcached_flush(memc
, 0);
474 assert(rc
== MEMCACHED_SUCCESS
);
476 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_SUPPORT_CAS
, set
);
478 rc
= memcached_set(memc
, key
, strlen(key
),
479 value
, strlen(value
),
480 (time_t)0, (uint32_t)0);
481 assert(rc
== MEMCACHED_SUCCESS
);
483 rc
= memcached_mget(memc
, keys
, keylengths
, 1);
485 results
= memcached_result_create(memc
, &results_obj
);
487 results
= memcached_fetch_result(memc
, &results_obj
, &rc
);
489 assert(rc
== MEMCACHED_SUCCESS
);
490 assert(memcached_result_cas(results
));
491 assert(!memcmp(value
, memcached_result_value(results
), value_length
));
492 assert(strlen(memcached_result_value(results
)) == value_length
);
493 assert(rc
== MEMCACHED_SUCCESS
);
494 uint64_t cas
= memcached_result_cas(results
);
497 results
= memcached_fetch_result(memc
, &results_obj
, &rc
);
498 assert(rc
== MEMCACHED_END
);
499 assert(results
== NULL
);
502 rc
= memcached_cas(memc
, key
, key_length
, value2
, value2_length
, 0, 0, cas
);
503 assert(rc
== MEMCACHED_SUCCESS
);
506 * The item will have a new cas value, so try to set it again with the old
507 * value. This should fail!
509 rc
= memcached_cas(memc
, key
, key_length
, value2
, value2_length
, 0, 0, cas
);
510 assert(rc
== MEMCACHED_DATA_EXISTS
);
512 memcached_result_free(&results_obj
);
517 static test_return_t
prepend_test(memcached_st
*memc
)
520 const char *key
= "fig";
521 const char *value
= "people";
522 char *out_value
= NULL
;
526 rc
= memcached_flush(memc
, 0);
527 assert(rc
== MEMCACHED_SUCCESS
);
529 rc
= memcached_set(memc
, key
, strlen(key
),
530 value
, strlen(value
),
531 (time_t)0, (uint32_t)0);
532 assert(rc
== MEMCACHED_SUCCESS
);
534 rc
= memcached_prepend(memc
, key
, strlen(key
),
535 "the ", strlen("the "),
536 (time_t)0, (uint32_t)0);
537 assert(rc
== MEMCACHED_SUCCESS
);
539 rc
= memcached_prepend(memc
, key
, strlen(key
),
540 "we ", strlen("we "),
541 (time_t)0, (uint32_t)0);
542 assert(rc
== MEMCACHED_SUCCESS
);
544 out_value
= memcached_get(memc
, key
, strlen(key
),
545 &value_length
, &flags
, &rc
);
546 assert(!memcmp(out_value
, "we the people", strlen("we the people")));
547 assert(strlen("we the people") == value_length
);
548 assert(rc
== MEMCACHED_SUCCESS
);
555 Set the value, then quit to make sure it is flushed.
556 Come back in and test that add fails.
558 static test_return_t
add_test(memcached_st
*memc
)
561 const char *key
= "foo";
562 const char *value
= "when we sanitize";
563 unsigned long long setting_value
;
565 setting_value
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_NO_BLOCK
);
567 rc
= memcached_set(memc
, key
, strlen(key
),
568 value
, strlen(value
),
569 (time_t)0, (uint32_t)0);
570 assert(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
);
571 memcached_quit(memc
);
572 rc
= memcached_add(memc
, key
, strlen(key
),
573 value
, strlen(value
),
574 (time_t)0, (uint32_t)0);
576 /* Too many broken OS'es have broken loopback in async, so we can't be sure of the result */
578 assert(rc
== MEMCACHED_NOTSTORED
|| rc
== MEMCACHED_STORED
);
580 assert(rc
== MEMCACHED_NOTSTORED
|| rc
== MEMCACHED_DATA_EXISTS
);
586 ** There was a problem of leaking filedescriptors in the initial release
587 ** of MacOSX 10.5. This test case triggers the problem. On some Solaris
588 ** systems it seems that the kernel is slow on reclaiming the resources
589 ** because the connects starts to time out (the test doesn't do much
590 ** anyway, so just loop 10 iterations)
592 static test_return_t
add_wrapper(memcached_st
*memc
)
595 unsigned int max
= 10000;
603 for (x
= 0; x
< max
; x
++)
609 static test_return_t
replace_test(memcached_st
*memc
)
612 const char *key
= "foo";
613 const char *value
= "when we sanitize";
614 const char *original
= "first we insert some data";
616 rc
= memcached_set(memc
, key
, strlen(key
),
617 original
, strlen(original
),
618 (time_t)0, (uint32_t)0);
619 assert(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
);
621 rc
= memcached_replace(memc
, key
, strlen(key
),
622 value
, strlen(value
),
623 (time_t)0, (uint32_t)0);
624 assert(rc
== MEMCACHED_SUCCESS
);
629 static test_return_t
delete_test(memcached_st
*memc
)
632 const char *key
= "foo";
633 const char *value
= "when we sanitize";
635 rc
= memcached_set(memc
, key
, strlen(key
),
636 value
, strlen(value
),
637 (time_t)0, (uint32_t)0);
638 assert(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
);
640 rc
= memcached_delete(memc
, key
, strlen(key
), (time_t)0);
641 assert(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
);
646 static test_return_t
flush_test(memcached_st
*memc
)
650 rc
= memcached_flush(memc
, 0);
651 assert(rc
== MEMCACHED_SUCCESS
);
656 static memcached_return
server_function(memcached_st
*ptr
__attribute__((unused
)),
657 memcached_server_st
*server
__attribute__((unused
)),
658 void *context
__attribute__((unused
)))
662 return MEMCACHED_SUCCESS
;
665 static test_return_t
memcached_server_cursor_test(memcached_st
*memc
)
668 strcpy(context
, "foo bad");
669 memcached_server_function callbacks
[1];
671 callbacks
[0]= server_function
;
672 memcached_server_cursor(memc
, callbacks
, context
, 1);
676 static test_return_t
bad_key_test(memcached_st
*memc
)
679 const char *key
= "foo bad";
681 size_t string_length
;
683 memcached_st
*memc_clone
;
685 size_t max_keylen
= 0xffff;
687 memc_clone
= memcached_clone(NULL
, memc
);
690 rc
= memcached_behavior_set(memc_clone
, MEMCACHED_BEHAVIOR_VERIFY_KEY
, set
);
691 assert(rc
== MEMCACHED_SUCCESS
);
693 /* All keys are valid in the binary protocol (except for length) */
694 if (memcached_behavior_get(memc_clone
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
) == 0)
696 string
= memcached_get(memc_clone
, key
, strlen(key
),
697 &string_length
, &flags
, &rc
);
698 assert(rc
== MEMCACHED_BAD_KEY_PROVIDED
);
699 assert(string_length
== 0);
703 rc
= memcached_behavior_set(memc_clone
, MEMCACHED_BEHAVIOR_VERIFY_KEY
, set
);
704 assert(rc
== MEMCACHED_SUCCESS
);
705 string
= memcached_get(memc_clone
, key
, strlen(key
),
706 &string_length
, &flags
, &rc
);
707 assert(rc
== MEMCACHED_NOTFOUND
);
708 assert(string_length
== 0);
711 /* Test multi key for bad keys */
712 const char *keys
[] = { "GoodKey", "Bad Key", "NotMine" };
713 size_t key_lengths
[] = { 7, 7, 7 };
715 rc
= memcached_behavior_set(memc_clone
, MEMCACHED_BEHAVIOR_VERIFY_KEY
, set
);
716 assert(rc
== MEMCACHED_SUCCESS
);
718 rc
= memcached_mget(memc_clone
, keys
, key_lengths
, 3);
719 assert(rc
== MEMCACHED_BAD_KEY_PROVIDED
);
721 rc
= memcached_mget_by_key(memc_clone
, "foo daddy", 9, keys
, key_lengths
, 1);
722 assert(rc
== MEMCACHED_BAD_KEY_PROVIDED
);
726 /* The following test should be moved to the end of this function when the
727 memcached server is updated to allow max size length of the keys in the
730 rc
= memcached_callback_set(memc_clone
, MEMCACHED_CALLBACK_PREFIX_KEY
, NULL
);
731 assert(rc
== MEMCACHED_SUCCESS
);
733 char *longkey
= malloc(max_keylen
+ 1);
736 memset(longkey
, 'a', max_keylen
+ 1);
737 string
= memcached_get(memc_clone
, longkey
, max_keylen
,
738 &string_length
, &flags
, &rc
);
739 assert(rc
== MEMCACHED_NOTFOUND
);
740 assert(string_length
== 0);
743 string
= memcached_get(memc_clone
, longkey
, max_keylen
+ 1,
744 &string_length
, &flags
, &rc
);
745 assert(rc
== MEMCACHED_BAD_KEY_PROVIDED
);
746 assert(string_length
== 0);
753 /* Make sure zero length keys are marked as bad */
755 rc
= memcached_behavior_set(memc_clone
, MEMCACHED_BEHAVIOR_VERIFY_KEY
, set
);
756 assert(rc
== MEMCACHED_SUCCESS
);
757 string
= memcached_get(memc_clone
, key
, 0,
758 &string_length
, &flags
, &rc
);
759 assert(rc
== MEMCACHED_BAD_KEY_PROVIDED
);
760 assert(string_length
== 0);
763 memcached_free(memc_clone
);
768 #define READ_THROUGH_VALUE "set for me"
769 static memcached_return
read_through_trigger(memcached_st
*memc
__attribute__((unused
)),
770 char *key
__attribute__((unused
)),
771 size_t key_length
__attribute__((unused
)),
772 memcached_result_st
*result
)
775 return memcached_result_set_value(result
, READ_THROUGH_VALUE
, strlen(READ_THROUGH_VALUE
));
778 static test_return_t
read_through(memcached_st
*memc
)
781 const char *key
= "foo";
783 size_t string_length
;
785 memcached_trigger_key cb
= (memcached_trigger_key
)read_through_trigger
;
787 string
= memcached_get(memc
, key
, strlen(key
),
788 &string_length
, &flags
, &rc
);
790 assert(rc
== MEMCACHED_NOTFOUND
);
791 assert(string_length
== 0);
794 rc
= memcached_callback_set(memc
, MEMCACHED_CALLBACK_GET_FAILURE
,
796 assert(rc
== MEMCACHED_SUCCESS
);
798 string
= memcached_get(memc
, key
, strlen(key
),
799 &string_length
, &flags
, &rc
);
801 assert(rc
== MEMCACHED_SUCCESS
);
802 assert(string_length
== strlen(READ_THROUGH_VALUE
));
803 assert(!strcmp(READ_THROUGH_VALUE
, string
));
806 string
= memcached_get(memc
, key
, strlen(key
),
807 &string_length
, &flags
, &rc
);
809 assert(rc
== MEMCACHED_SUCCESS
);
810 assert(string_length
== strlen(READ_THROUGH_VALUE
));
811 assert(!strcmp(READ_THROUGH_VALUE
, string
));
817 static memcached_return
delete_trigger(memcached_st
*ptr
__attribute__((unused
)),
819 size_t key_length
__attribute__((unused
)))
823 return MEMCACHED_SUCCESS
;
826 static test_return_t
delete_through(memcached_st
*memc
)
828 memcached_trigger_delete_key callback
;
831 callback
= (memcached_trigger_delete_key
)delete_trigger
;
833 rc
= memcached_callback_set(memc
, MEMCACHED_CALLBACK_DELETE_TRIGGER
, *(void**)&callback
);
834 assert(rc
== MEMCACHED_SUCCESS
);
839 static test_return_t
get_test(memcached_st
*memc
)
842 const char *key
= "foo";
844 size_t string_length
;
847 rc
= memcached_delete(memc
, key
, strlen(key
), (time_t)0);
848 assert(rc
== MEMCACHED_BUFFERED
|| rc
== MEMCACHED_NOTFOUND
);
850 string
= memcached_get(memc
, key
, strlen(key
),
851 &string_length
, &flags
, &rc
);
853 assert(rc
== MEMCACHED_NOTFOUND
);
854 assert(string_length
== 0);
860 static test_return_t
get_test2(memcached_st
*memc
)
863 const char *key
= "foo";
864 const char *value
= "when we sanitize";
866 size_t string_length
;
869 rc
= memcached_set(memc
, key
, strlen(key
),
870 value
, strlen(value
),
871 (time_t)0, (uint32_t)0);
872 assert(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
);
874 string
= memcached_get(memc
, key
, strlen(key
),
875 &string_length
, &flags
, &rc
);
878 assert(rc
== MEMCACHED_SUCCESS
);
879 assert(string_length
== strlen(value
));
880 assert(!memcmp(string
, value
, string_length
));
887 static test_return_t
set_test2(memcached_st
*memc
)
890 const char *key
= "foo";
891 const char *value
= "train in the brain";
892 size_t value_length
= strlen(value
);
895 for (x
= 0; x
< 10; x
++)
897 rc
= memcached_set(memc
, key
, strlen(key
),
899 (time_t)0, (uint32_t)0);
900 assert(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
);
906 static test_return_t
set_test3(memcached_st
*memc
)
910 size_t value_length
= 8191;
913 value
= (char*)malloc(value_length
);
916 for (x
= 0; x
< value_length
; x
++)
917 value
[x
] = (char) (x
% 127);
919 /* The dump test relies on there being at least 32 items in memcached */
920 for (x
= 0; x
< 32; x
++)
924 sprintf(key
, "foo%u", x
);
926 rc
= memcached_set(memc
, key
, strlen(key
),
928 (time_t)0, (uint32_t)0);
929 assert(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
);
937 static test_return_t
get_test3(memcached_st
*memc
)
940 const char *key
= "foo";
942 size_t value_length
= 8191;
944 size_t string_length
;
948 value
= (char*)malloc(value_length
);
951 for (x
= 0; x
< value_length
; x
++)
952 value
[x
] = (char) (x
% 127);
954 rc
= memcached_set(memc
, key
, strlen(key
),
956 (time_t)0, (uint32_t)0);
957 assert(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
);
959 string
= memcached_get(memc
, key
, strlen(key
),
960 &string_length
, &flags
, &rc
);
962 assert(rc
== MEMCACHED_SUCCESS
);
964 assert(string_length
== value_length
);
965 assert(!memcmp(string
, value
, string_length
));
973 static test_return_t
get_test4(memcached_st
*memc
)
976 const char *key
= "foo";
978 size_t value_length
= 8191;
980 size_t string_length
;
984 value
= (char*)malloc(value_length
);
987 for (x
= 0; x
< value_length
; x
++)
988 value
[x
] = (char) (x
% 127);
990 rc
= memcached_set(memc
, key
, strlen(key
),
992 (time_t)0, (uint32_t)0);
993 assert(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
);
995 for (x
= 0; x
< 10; x
++)
997 string
= memcached_get(memc
, key
, strlen(key
),
998 &string_length
, &flags
, &rc
);
1000 assert(rc
== MEMCACHED_SUCCESS
);
1002 assert(string_length
== value_length
);
1003 assert(!memcmp(string
, value
, string_length
));
1009 return TEST_SUCCESS
;
1013 * This test verifies that memcached_read_one_response doesn't try to
1014 * dereference a NIL-pointer if you issue a multi-get and don't read out all
1015 * responses before you execute a storage command.
1017 static test_return_t
get_test5(memcached_st
*memc
)
1020 ** Request the same key twice, to ensure that we hash to the same server
1021 ** (so that we have multiple response values queued up) ;-)
1023 const char *keys
[]= { "key", "key" };
1024 size_t lengths
[]= { 3, 3 };
1028 memcached_return rc
= memcached_set(memc
, keys
[0], lengths
[0],
1029 keys
[0], lengths
[0], 0, 0);
1030 assert(rc
== MEMCACHED_SUCCESS
);
1031 rc
= memcached_mget(memc
, keys
, lengths
, 2);
1033 memcached_result_st results_obj
;
1034 memcached_result_st
*results
;
1035 results
=memcached_result_create(memc
, &results_obj
);
1037 results
=memcached_fetch_result(memc
, &results_obj
, &rc
);
1039 memcached_result_free(&results_obj
);
1041 /* Don't read out the second result, but issue a set instead.. */
1042 rc
= memcached_set(memc
, keys
[0], lengths
[0], keys
[0], lengths
[0], 0, 0);
1043 assert(rc
== MEMCACHED_SUCCESS
);
1045 char *val
= memcached_get_by_key(memc
, keys
[0], lengths
[0], "yek", 3,
1046 &rlen
, &flags
, &rc
);
1047 assert(val
== NULL
);
1048 assert(rc
== MEMCACHED_NOTFOUND
);
1049 val
= memcached_get(memc
, keys
[0], lengths
[0], &rlen
, &flags
, &rc
);
1050 assert(val
!= NULL
);
1051 assert(rc
== MEMCACHED_SUCCESS
);
1054 return TEST_SUCCESS
;
1057 static test_return_t
mget_end(memcached_st
*memc
)
1059 const char *keys
[]= { "foo", "foo2" };
1060 size_t lengths
[]= { 3, 4 };
1061 const char *values
[]= { "fjord", "41" };
1063 memcached_return rc
;
1066 for (int i
= 0; i
< 2; i
++)
1068 rc
= memcached_set(memc
, keys
[i
], lengths
[i
], values
[i
], strlen(values
[i
]),
1069 (time_t)0, (uint32_t)0);
1070 assert(rc
== MEMCACHED_SUCCESS
);
1074 size_t string_length
;
1077 // retrieve both via mget
1078 rc
= memcached_mget(memc
, keys
, lengths
, 2);
1079 assert(rc
== MEMCACHED_SUCCESS
);
1081 char key
[MEMCACHED_MAX_KEY
];
1084 // this should get both
1085 for (int i
= 0; i
< 2; i
++)
1087 string
= memcached_fetch(memc
, key
, &key_length
, &string_length
,
1089 assert(rc
== MEMCACHED_SUCCESS
);
1091 if (key_length
== 4)
1093 assert(string_length
== strlen(values
[val
]));
1094 assert(strncmp(values
[val
], string
, string_length
) == 0);
1098 // this should indicate end
1099 string
= memcached_fetch(memc
, key
, &key_length
, &string_length
, &flags
, &rc
);
1100 assert(rc
== MEMCACHED_END
);
1103 rc
= memcached_mget(memc
, keys
, lengths
, 1);
1104 assert(rc
== MEMCACHED_SUCCESS
);
1106 string
= memcached_fetch(memc
, key
, &key_length
, &string_length
, &flags
, &rc
);
1107 assert(key_length
== lengths
[0]);
1108 assert(strncmp(keys
[0], key
, key_length
) == 0);
1109 assert(string_length
== strlen(values
[0]));
1110 assert(strncmp(values
[0], string
, string_length
) == 0);
1111 assert(rc
== MEMCACHED_SUCCESS
);
1114 // this should indicate end
1115 string
= memcached_fetch(memc
, key
, &key_length
, &string_length
, &flags
, &rc
);
1116 assert(rc
== MEMCACHED_END
);
1118 return TEST_SUCCESS
;
1121 /* Do not copy the style of this code, I just access hosts to testthis function */
1122 static test_return_t
stats_servername_test(memcached_st
*memc
)
1124 memcached_return rc
;
1125 memcached_stat_st memc_stat
;
1126 rc
= memcached_stat_servername(&memc_stat
, NULL
,
1127 memc
->hosts
[0].hostname
,
1128 memc
->hosts
[0].port
);
1130 return TEST_SUCCESS
;
1133 static test_return_t
increment_test(memcached_st
*memc
)
1135 uint64_t new_number
;
1136 memcached_return rc
;
1137 const char *key
= "number";
1138 const char *value
= "0";
1140 rc
= memcached_set(memc
, key
, strlen(key
),
1141 value
, strlen(value
),
1142 (time_t)0, (uint32_t)0);
1143 assert(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
);
1145 rc
= memcached_increment(memc
, key
, strlen(key
),
1147 assert(rc
== MEMCACHED_SUCCESS
);
1148 assert(new_number
== 1);
1150 rc
= memcached_increment(memc
, key
, strlen(key
),
1152 assert(rc
== MEMCACHED_SUCCESS
);
1153 assert(new_number
== 2);
1155 return TEST_SUCCESS
;
1158 static test_return_t
increment_with_initial_test(memcached_st
*memc
)
1160 if (memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
) != 0)
1162 uint64_t new_number
;
1163 memcached_return rc
;
1164 const char *key
= "number";
1165 uint64_t initial
= 0;
1167 rc
= memcached_increment_with_initial(memc
, key
, strlen(key
),
1168 1, initial
, 0, &new_number
);
1169 assert(rc
== MEMCACHED_SUCCESS
);
1170 assert(new_number
== initial
);
1172 rc
= memcached_increment_with_initial(memc
, key
, strlen(key
),
1173 1, initial
, 0, &new_number
);
1174 assert(rc
== MEMCACHED_SUCCESS
);
1175 assert(new_number
== (initial
+ 1));
1177 return TEST_SUCCESS
;
1180 static test_return_t
decrement_test(memcached_st
*memc
)
1182 uint64_t new_number
;
1183 memcached_return rc
;
1184 const char *key
= "number";
1185 const char *value
= "3";
1187 rc
= memcached_set(memc
, key
, strlen(key
),
1188 value
, strlen(value
),
1189 (time_t)0, (uint32_t)0);
1190 assert(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
);
1192 rc
= memcached_decrement(memc
, key
, strlen(key
),
1194 assert(rc
== MEMCACHED_SUCCESS
);
1195 assert(new_number
== 2);
1197 rc
= memcached_decrement(memc
, key
, strlen(key
),
1199 assert(rc
== MEMCACHED_SUCCESS
);
1200 assert(new_number
== 1);
1202 return TEST_SUCCESS
;
1205 static test_return_t
decrement_with_initial_test(memcached_st
*memc
)
1207 if (memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
) != 0)
1209 uint64_t new_number
;
1210 memcached_return rc
;
1211 const char *key
= "number";
1212 uint64_t initial
= 3;
1214 rc
= memcached_decrement_with_initial(memc
, key
, strlen(key
),
1215 1, initial
, 0, &new_number
);
1216 assert(rc
== MEMCACHED_SUCCESS
);
1217 assert(new_number
== initial
);
1219 rc
= memcached_decrement_with_initial(memc
, key
, strlen(key
),
1220 1, initial
, 0, &new_number
);
1221 assert(rc
== MEMCACHED_SUCCESS
);
1222 assert(new_number
== (initial
- 1));
1224 return TEST_SUCCESS
;
1227 static test_return_t
quit_test(memcached_st
*memc
)
1229 memcached_return rc
;
1230 const char *key
= "fudge";
1231 const char *value
= "sanford and sun";
1233 rc
= memcached_set(memc
, key
, strlen(key
),
1234 value
, strlen(value
),
1235 (time_t)10, (uint32_t)3);
1236 assert(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
);
1237 memcached_quit(memc
);
1239 rc
= memcached_set(memc
, key
, strlen(key
),
1240 value
, strlen(value
),
1241 (time_t)50, (uint32_t)9);
1242 assert(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
);
1244 return TEST_SUCCESS
;
1247 static test_return_t
mget_result_test(memcached_st
*memc
)
1249 memcached_return rc
;
1250 const char *keys
[]= {"fudge", "son", "food"};
1251 size_t key_length
[]= {5, 3, 4};
1254 memcached_result_st results_obj
;
1255 memcached_result_st
*results
;
1257 results
= memcached_result_create(memc
, &results_obj
);
1259 assert(&results_obj
== results
);
1261 /* We need to empty the server before continueing test */
1262 rc
= memcached_flush(memc
, 0);
1263 assert(rc
== MEMCACHED_SUCCESS
);
1265 rc
= memcached_mget(memc
, keys
, key_length
, 3);
1266 assert(rc
== MEMCACHED_SUCCESS
);
1268 while ((results
= memcached_fetch_result(memc
, &results_obj
, &rc
)) != NULL
)
1273 while ((results
= memcached_fetch_result(memc
, &results_obj
, &rc
)) != NULL
)
1275 assert(rc
== MEMCACHED_END
);
1277 for (x
= 0; x
< 3; x
++)
1279 rc
= memcached_set(memc
, keys
[x
], key_length
[x
],
1280 keys
[x
], key_length
[x
],
1281 (time_t)50, (uint32_t)9);
1282 assert(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
);
1285 rc
= memcached_mget(memc
, keys
, key_length
, 3);
1286 assert(rc
== MEMCACHED_SUCCESS
);
1288 while ((results
= memcached_fetch_result(memc
, &results_obj
, &rc
)))
1291 assert(&results_obj
== results
);
1292 assert(rc
== MEMCACHED_SUCCESS
);
1293 assert(memcached_result_key_length(results
) == memcached_result_length(results
));
1294 assert(!memcmp(memcached_result_key_value(results
),
1295 memcached_result_value(results
),
1296 memcached_result_length(results
)));
1299 memcached_result_free(&results_obj
);
1301 return TEST_SUCCESS
;
1304 static test_return_t
mget_result_alloc_test(memcached_st
*memc
)
1306 memcached_return rc
;
1307 const char *keys
[]= {"fudge", "son", "food"};
1308 size_t key_length
[]= {5, 3, 4};
1311 memcached_result_st
*results
;
1313 /* We need to empty the server before continueing test */
1314 rc
= memcached_flush(memc
, 0);
1315 assert(rc
== MEMCACHED_SUCCESS
);
1317 rc
= memcached_mget(memc
, keys
, key_length
, 3);
1318 assert(rc
== MEMCACHED_SUCCESS
);
1320 while ((results
= memcached_fetch_result(memc
, NULL
, &rc
)) != NULL
)
1325 assert(rc
== MEMCACHED_END
);
1327 for (x
= 0; x
< 3; x
++)
1329 rc
= memcached_set(memc
, keys
[x
], key_length
[x
],
1330 keys
[x
], key_length
[x
],
1331 (time_t)50, (uint32_t)9);
1332 assert(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
);
1335 rc
= memcached_mget(memc
, keys
, key_length
, 3);
1336 assert(rc
== MEMCACHED_SUCCESS
);
1339 while ((results
= memcached_fetch_result(memc
, NULL
, &rc
)))
1342 assert(rc
== MEMCACHED_SUCCESS
);
1343 assert(memcached_result_key_length(results
) == memcached_result_length(results
));
1344 assert(!memcmp(memcached_result_key_value(results
),
1345 memcached_result_value(results
),
1346 memcached_result_length(results
)));
1347 memcached_result_free(results
);
1351 return TEST_SUCCESS
;
1354 /* Count the results */
1355 static memcached_return
callback_counter(memcached_st
*ptr
__attribute__((unused
)),
1356 memcached_result_st
*result
__attribute__((unused
)),
1359 unsigned int *counter
= (unsigned int *)context
;
1361 *counter
= *counter
+ 1;
1363 return MEMCACHED_SUCCESS
;
1366 static test_return_t
mget_result_function(memcached_st
*memc
)
1368 memcached_return rc
;
1369 const char *keys
[]= {"fudge", "son", "food"};
1370 size_t key_length
[]= {5, 3, 4};
1372 unsigned int counter
;
1373 memcached_execute_function callbacks
[1];
1375 /* We need to empty the server before continueing test */
1376 rc
= memcached_flush(memc
, 0);
1377 for (x
= 0; x
< 3; x
++)
1379 rc
= memcached_set(memc
, keys
[x
], key_length
[x
],
1380 keys
[x
], key_length
[x
],
1381 (time_t)50, (uint32_t)9);
1382 assert(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
);
1385 rc
= memcached_mget(memc
, keys
, key_length
, 3);
1386 assert(rc
== MEMCACHED_SUCCESS
);
1388 callbacks
[0]= &callback_counter
;
1390 rc
= memcached_fetch_execute(memc
, callbacks
, (void *)&counter
, 1);
1392 assert(counter
== 3);
1394 return TEST_SUCCESS
;
1397 static test_return_t
mget_test(memcached_st
*memc
)
1399 memcached_return rc
;
1400 const char *keys
[]= {"fudge", "son", "food"};
1401 size_t key_length
[]= {5, 3, 4};
1405 char return_key
[MEMCACHED_MAX_KEY
];
1406 size_t return_key_length
;
1408 size_t return_value_length
;
1410 /* We need to empty the server before continueing test */
1411 rc
= memcached_flush(memc
, 0);
1412 assert(rc
== MEMCACHED_SUCCESS
);
1414 rc
= memcached_mget(memc
, keys
, key_length
, 3);
1415 assert(rc
== MEMCACHED_SUCCESS
);
1417 while ((return_value
= memcached_fetch(memc
, return_key
, &return_key_length
,
1418 &return_value_length
, &flags
, &rc
)) != NULL
)
1420 assert(return_value
);
1422 assert(!return_value
);
1423 assert(return_value_length
== 0);
1424 assert(rc
== MEMCACHED_END
);
1426 for (x
= 0; x
< 3; x
++)
1428 rc
= memcached_set(memc
, keys
[x
], key_length
[x
],
1429 keys
[x
], key_length
[x
],
1430 (time_t)50, (uint32_t)9);
1431 assert(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
);
1434 rc
= memcached_mget(memc
, keys
, key_length
, 3);
1435 assert(rc
== MEMCACHED_SUCCESS
);
1438 while ((return_value
= memcached_fetch(memc
, return_key
, &return_key_length
,
1439 &return_value_length
, &flags
, &rc
)))
1441 assert(return_value
);
1442 assert(rc
== MEMCACHED_SUCCESS
);
1443 assert(return_key_length
== return_value_length
);
1444 assert(!memcmp(return_value
, return_key
, return_value_length
));
1449 return TEST_SUCCESS
;
1452 static test_return_t
get_stats_keys(memcached_st
*memc
)
1456 memcached_stat_st memc_stat
;
1457 memcached_return rc
;
1459 list
= memcached_stat_get_keys(memc
, &memc_stat
, &rc
);
1460 assert(rc
== MEMCACHED_SUCCESS
);
1461 for (ptr
= list
; *ptr
; ptr
++)
1467 return TEST_SUCCESS
;
1470 static test_return_t
version_string_test(memcached_st
*memc
__attribute__((unused
)))
1472 const char *version_string
;
1474 version_string
= memcached_lib_version();
1476 assert(!strcmp(version_string
, LIBMEMCACHED_VERSION_STRING
));
1478 return TEST_SUCCESS
;
1481 static test_return_t
get_stats(memcached_st
*memc
)
1486 memcached_return rc
;
1487 memcached_stat_st
*memc_stat
;
1489 memc_stat
= memcached_stat(memc
, NULL
, &rc
);
1490 assert(rc
== MEMCACHED_SUCCESS
);
1492 assert(rc
== MEMCACHED_SUCCESS
);
1495 for (x
= 0; x
< memcached_server_count(memc
); x
++)
1497 list
= memcached_stat_get_keys(memc
, memc_stat
+x
, &rc
);
1498 assert(rc
== MEMCACHED_SUCCESS
);
1499 for (ptr
= list
; *ptr
; ptr
++);
1504 memcached_stat_free(NULL
, memc_stat
);
1506 return TEST_SUCCESS
;
1509 static test_return_t
add_host_test(memcached_st
*memc
)
1512 memcached_server_st
*servers
;
1513 memcached_return rc
;
1514 char servername
[]= "0.example.com";
1516 servers
= memcached_server_list_append_with_weight(NULL
, servername
, 400, 0, &rc
);
1518 assert(1 == memcached_server_list_count(servers
));
1520 for (x
= 2; x
< 20; x
++)
1522 char buffer
[SMALL_STRING_LEN
];
1524 snprintf(buffer
, SMALL_STRING_LEN
, "%u.example.com", 400+x
);
1525 servers
= memcached_server_list_append_with_weight(servers
, buffer
, 401, 0,
1527 assert(rc
== MEMCACHED_SUCCESS
);
1528 assert(x
== memcached_server_list_count(servers
));
1531 rc
= memcached_server_push(memc
, servers
);
1532 assert(rc
== MEMCACHED_SUCCESS
);
1533 rc
= memcached_server_push(memc
, servers
);
1534 assert(rc
== MEMCACHED_SUCCESS
);
1536 memcached_server_list_free(servers
);
1538 return TEST_SUCCESS
;
1541 static memcached_return
clone_test_callback(memcached_st
*parent
__attribute__((unused
)), memcached_st
*memc_clone
__attribute__((unused
)))
1543 return MEMCACHED_SUCCESS
;
1546 static memcached_return
cleanup_test_callback(memcached_st
*ptr
__attribute__((unused
)))
1548 return MEMCACHED_SUCCESS
;
1551 static test_return_t
callback_test(memcached_st
*memc
)
1553 /* Test User Data */
1557 memcached_return rc
;
1559 rc
= memcached_callback_set(memc
, MEMCACHED_CALLBACK_USER_DATA
, &x
);
1560 assert(rc
== MEMCACHED_SUCCESS
);
1561 test_ptr
= (int *)memcached_callback_get(memc
, MEMCACHED_CALLBACK_USER_DATA
, &rc
);
1562 assert(*test_ptr
== x
);
1565 /* Test Clone Callback */
1567 memcached_clone_func clone_cb
= (memcached_clone_func
)clone_test_callback
;
1568 void *clone_cb_ptr
= *(void **)&clone_cb
;
1569 void *temp_function
= NULL
;
1570 memcached_return rc
;
1572 rc
= memcached_callback_set(memc
, MEMCACHED_CALLBACK_CLONE_FUNCTION
,
1574 assert(rc
== MEMCACHED_SUCCESS
);
1575 temp_function
= memcached_callback_get(memc
, MEMCACHED_CALLBACK_CLONE_FUNCTION
, &rc
);
1576 assert(temp_function
== clone_cb_ptr
);
1579 /* Test Cleanup Callback */
1581 memcached_cleanup_func cleanup_cb
=
1582 (memcached_cleanup_func
)cleanup_test_callback
;
1583 void *cleanup_cb_ptr
= *(void **)&cleanup_cb
;
1584 void *temp_function
= NULL
;
1585 memcached_return rc
;
1587 rc
= memcached_callback_set(memc
, MEMCACHED_CALLBACK_CLONE_FUNCTION
,
1589 assert(rc
== MEMCACHED_SUCCESS
);
1590 temp_function
= memcached_callback_get(memc
, MEMCACHED_CALLBACK_CLONE_FUNCTION
, &rc
);
1591 assert(temp_function
== cleanup_cb_ptr
);
1594 return TEST_SUCCESS
;
1597 /* We don't test the behavior itself, we test the switches */
1598 static test_return_t
behavior_test(memcached_st
*memc
)
1603 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NO_BLOCK
, set
);
1604 value
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_NO_BLOCK
);
1607 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_TCP_NODELAY
, set
);
1608 value
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_TCP_NODELAY
);
1611 set
= MEMCACHED_HASH_MD5
;
1612 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_HASH
, set
);
1613 value
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_HASH
);
1614 assert(value
== MEMCACHED_HASH_MD5
);
1618 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NO_BLOCK
, set
);
1619 value
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_NO_BLOCK
);
1622 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_TCP_NODELAY
, set
);
1623 value
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_TCP_NODELAY
);
1626 set
= MEMCACHED_HASH_DEFAULT
;
1627 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_HASH
, set
);
1628 value
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_HASH
);
1629 assert(value
== MEMCACHED_HASH_DEFAULT
);
1631 set
= MEMCACHED_HASH_CRC
;
1632 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_HASH
, set
);
1633 value
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_HASH
);
1634 assert(value
== MEMCACHED_HASH_CRC
);
1636 value
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_SOCKET_SEND_SIZE
);
1639 value
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_SOCKET_RECV_SIZE
);
1642 value
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_NUMBER_OF_REPLICAS
);
1643 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NUMBER_OF_REPLICAS
, value
+ 1);
1644 assert((value
+ 1) == memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_NUMBER_OF_REPLICAS
));
1645 return TEST_SUCCESS
;
1648 static test_return_t
fetch_all_results(memcached_st
*memc
)
1650 memcached_return rc
= MEMCACHED_SUCCESS
;
1651 char return_key
[MEMCACHED_MAX_KEY
];
1652 size_t return_key_length
;
1654 size_t return_value_length
;
1657 while ((return_value
= memcached_fetch(memc
, return_key
, &return_key_length
,
1658 &return_value_length
, &flags
, &rc
)))
1660 assert(return_value
);
1661 assert(rc
== MEMCACHED_SUCCESS
);
1665 return ((rc
== MEMCACHED_END
) || (rc
== MEMCACHED_SUCCESS
)) ? TEST_SUCCESS
: TEST_FAILURE
;
1668 /* Test case provided by Cal Haldenbrand */
1669 static test_return_t
user_supplied_bug1(memcached_st
*memc
)
1671 unsigned int setter
= 1;
1674 unsigned long long total
= 0;
1677 char randomstuff
[6 * 1024];
1678 memcached_return rc
;
1680 memset(randomstuff
, 0, 6 * 1024);
1682 /* We just keep looking at the same values over and over */
1685 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NO_BLOCK
, setter
);
1686 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_TCP_NODELAY
, setter
);
1690 for (x
= 0 ; total
< 20 * 1024576 ; x
++ )
1694 size
= (uint32_t)(rand() % ( 5 * 1024 ) ) + 400;
1695 memset(randomstuff
, 0, 6 * 1024);
1696 assert(size
< 6 * 1024); /* Being safe here */
1698 for (j
= 0 ; j
< size
;j
++)
1699 randomstuff
[j
] = (signed char) ((rand() % 26) + 97);
1702 sprintf(key
, "%d", x
);
1703 rc
= memcached_set(memc
, key
, strlen(key
),
1704 randomstuff
, strlen(randomstuff
), 10, 0);
1705 assert(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
);
1706 /* If we fail, lets try again */
1707 if (rc
!= MEMCACHED_SUCCESS
&& rc
!= MEMCACHED_BUFFERED
)
1708 rc
= memcached_set(memc
, key
, strlen(key
),
1709 randomstuff
, strlen(randomstuff
), 10, 0);
1710 assert(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
);
1713 return TEST_SUCCESS
;
1716 /* Test case provided by Cal Haldenbrand */
1717 static test_return_t
user_supplied_bug2(memcached_st
*memc
)
1720 unsigned int setter
;
1722 unsigned long long total
;
1725 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NO_BLOCK
, setter
);
1726 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_TCP_NODELAY
, setter
);
1728 setter
= 20 * 1024576;
1729 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_SOCKET_SEND_SIZE
, setter
);
1730 setter
= 20 * 1024576;
1731 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_SOCKET_RECV_SIZE
, setter
);
1732 getter
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_SOCKET_SEND_SIZE
);
1733 getter
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_SOCKET_RECV_SIZE
);
1735 for (x
= 0, errors
= 0, total
= 0 ; total
< 20 * 1024576 ; x
++)
1738 for (x
= 0, errors
= 0, total
= 0 ; total
< 24576 ; x
++)
1740 memcached_return rc
= MEMCACHED_SUCCESS
;
1741 char buffer
[SMALL_STRING_LEN
];
1746 memset(buffer
, 0, SMALL_STRING_LEN
);
1748 snprintf(buffer
, SMALL_STRING_LEN
, "%u", x
);
1749 getval
= memcached_get(memc
, buffer
, strlen(buffer
),
1750 &val_len
, &flags
, &rc
);
1751 if (rc
!= MEMCACHED_SUCCESS
)
1753 if (rc
== MEMCACHED_NOTFOUND
)
1767 return TEST_SUCCESS
;
1770 /* Do a large mget() over all the keys we think exist */
1771 #define KEY_COUNT 3000 // * 1024576
1772 static test_return_t
user_supplied_bug3(memcached_st
*memc
)
1774 memcached_return rc
;
1775 unsigned int setter
;
1778 size_t key_lengths
[KEY_COUNT
];
1781 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NO_BLOCK
, setter
);
1782 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_TCP_NODELAY
, setter
);
1784 setter
= 20 * 1024576;
1785 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_SOCKET_SEND_SIZE
, setter
);
1786 setter
= 20 * 1024576;
1787 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_SOCKET_RECV_SIZE
, setter
);
1788 getter
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_SOCKET_SEND_SIZE
);
1789 getter
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_SOCKET_RECV_SIZE
);
1792 keys
= calloc(KEY_COUNT
, sizeof(char *));
1794 for (x
= 0; x
< KEY_COUNT
; x
++)
1798 snprintf(buffer
, 30, "%u", x
);
1799 keys
[x
]= strdup(buffer
);
1800 key_lengths
[x
]= strlen(keys
[x
]);
1803 rc
= memcached_mget(memc
, (const char **)keys
, key_lengths
, KEY_COUNT
);
1804 assert(rc
== MEMCACHED_SUCCESS
);
1806 assert(fetch_all_results(memc
) == TEST_SUCCESS
);
1808 for (x
= 0; x
< KEY_COUNT
; x
++)
1812 return TEST_SUCCESS
;
1815 /* Make sure we behave properly if server list has no values */
1816 static test_return_t
user_supplied_bug4(memcached_st
*memc
)
1818 memcached_return rc
;
1819 const char *keys
[]= {"fudge", "son", "food"};
1820 size_t key_length
[]= {5, 3, 4};
1823 char return_key
[MEMCACHED_MAX_KEY
];
1824 size_t return_key_length
;
1826 size_t return_value_length
;
1828 /* Here we free everything before running a bunch of mget tests */
1830 memcached_server_list_free(memc
->hosts
);
1832 memc
->number_of_hosts
= 0;
1836 /* We need to empty the server before continueing test */
1837 rc
= memcached_flush(memc
, 0);
1838 assert(rc
== MEMCACHED_NO_SERVERS
);
1840 rc
= memcached_mget(memc
, keys
, key_length
, 3);
1841 assert(rc
== MEMCACHED_NO_SERVERS
);
1843 while ((return_value
= memcached_fetch(memc
, return_key
, &return_key_length
,
1844 &return_value_length
, &flags
, &rc
)) != NULL
)
1846 assert(return_value
);
1848 assert(!return_value
);
1849 assert(return_value_length
== 0);
1850 assert(rc
== MEMCACHED_NO_SERVERS
);
1852 for (x
= 0; x
< 3; x
++)
1854 rc
= memcached_set(memc
, keys
[x
], key_length
[x
],
1855 keys
[x
], key_length
[x
],
1856 (time_t)50, (uint32_t)9);
1857 assert(rc
== MEMCACHED_NO_SERVERS
);
1860 rc
= memcached_mget(memc
, keys
, key_length
, 3);
1861 assert(rc
== MEMCACHED_NO_SERVERS
);
1864 while ((return_value
= memcached_fetch(memc
, return_key
, &return_key_length
,
1865 &return_value_length
, &flags
, &rc
)))
1867 assert(return_value
);
1868 assert(rc
== MEMCACHED_SUCCESS
);
1869 assert(return_key_length
== return_value_length
);
1870 assert(!memcmp(return_value
, return_key
, return_value_length
));
1875 return TEST_SUCCESS
;
1878 #define VALUE_SIZE_BUG5 1048064
1879 static test_return_t
user_supplied_bug5(memcached_st
*memc
)
1881 memcached_return rc
;
1882 const char *keys
[]= {"036790384900", "036790384902", "036790384904", "036790384906"};
1883 size_t key_length
[]= {strlen("036790384900"), strlen("036790384902"), strlen("036790384904"), strlen("036790384906")};
1884 char return_key
[MEMCACHED_MAX_KEY
];
1885 size_t return_key_length
;
1887 size_t value_length
;
1891 char insert_data
[VALUE_SIZE_BUG5
];
1893 for (x
= 0; x
< VALUE_SIZE_BUG5
; x
++)
1894 insert_data
[x
]= (signed char)rand();
1896 memcached_flush(memc
, 0);
1897 value
= memcached_get(memc
, keys
[0], key_length
[0],
1898 &value_length
, &flags
, &rc
);
1899 assert(value
== NULL
);
1900 rc
= memcached_mget(memc
, keys
, key_length
, 4);
1903 while ((value
= memcached_fetch(memc
, return_key
, &return_key_length
,
1904 &value_length
, &flags
, &rc
)))
1908 for (x
= 0; x
< 4; x
++)
1910 rc
= memcached_set(memc
, keys
[x
], key_length
[x
],
1911 insert_data
, VALUE_SIZE_BUG5
,
1912 (time_t)0, (uint32_t)0);
1913 assert(rc
== MEMCACHED_SUCCESS
);
1916 for (x
= 0; x
< 10; x
++)
1918 value
= memcached_get(memc
, keys
[0], key_length
[0],
1919 &value_length
, &flags
, &rc
);
1923 rc
= memcached_mget(memc
, keys
, key_length
, 4);
1925 while ((value
= memcached_fetch(memc
, return_key
, &return_key_length
,
1926 &value_length
, &flags
, &rc
)))
1934 return TEST_SUCCESS
;
1937 static test_return_t
user_supplied_bug6(memcached_st
*memc
)
1939 memcached_return rc
;
1940 const char *keys
[]= {"036790384900", "036790384902", "036790384904", "036790384906"};
1941 size_t key_length
[]= {strlen("036790384900"), strlen("036790384902"), strlen("036790384904"), strlen("036790384906")};
1942 char return_key
[MEMCACHED_MAX_KEY
];
1943 size_t return_key_length
;
1945 size_t value_length
;
1949 char insert_data
[VALUE_SIZE_BUG5
];
1951 for (x
= 0; x
< VALUE_SIZE_BUG5
; x
++)
1952 insert_data
[x
]= (signed char)rand();
1954 memcached_flush(memc
, 0);
1955 value
= memcached_get(memc
, keys
[0], key_length
[0],
1956 &value_length
, &flags
, &rc
);
1957 assert(value
== NULL
);
1958 assert(rc
== MEMCACHED_NOTFOUND
);
1959 rc
= memcached_mget(memc
, keys
, key_length
, 4);
1960 assert(rc
== MEMCACHED_SUCCESS
);
1963 while ((value
= memcached_fetch(memc
, return_key
, &return_key_length
,
1964 &value_length
, &flags
, &rc
)))
1967 assert(rc
== MEMCACHED_END
);
1969 for (x
= 0; x
< 4; x
++)
1971 rc
= memcached_set(memc
, keys
[x
], key_length
[x
],
1972 insert_data
, VALUE_SIZE_BUG5
,
1973 (time_t)0, (uint32_t)0);
1974 assert(rc
== MEMCACHED_SUCCESS
);
1977 for (x
= 0; x
< 2; x
++)
1979 value
= memcached_get(memc
, keys
[0], key_length
[0],
1980 &value_length
, &flags
, &rc
);
1984 rc
= memcached_mget(memc
, keys
, key_length
, 4);
1985 assert(rc
== MEMCACHED_SUCCESS
);
1987 /* We test for purge of partial complete fetches */
1988 for (count
= 3; count
; count
--)
1990 value
= memcached_fetch(memc
, return_key
, &return_key_length
,
1991 &value_length
, &flags
, &rc
);
1992 assert(rc
== MEMCACHED_SUCCESS
);
1993 assert(!(memcmp(value
, insert_data
, value_length
)));
1994 assert(value_length
);
1999 return TEST_SUCCESS
;
2002 static test_return_t
user_supplied_bug8(memcached_st
*memc
__attribute__((unused
)))
2004 memcached_return rc
;
2006 memcached_st
*memc_clone
;
2008 memcached_server_st
*servers
;
2009 const 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";
2011 servers
= memcached_servers_parse(server_list
);
2014 mine
= memcached_create(NULL
);
2015 rc
= memcached_server_push(mine
, servers
);
2016 assert(rc
== MEMCACHED_SUCCESS
);
2017 memcached_server_list_free(servers
);
2020 memc_clone
= memcached_clone(NULL
, mine
);
2022 memcached_quit(mine
);
2023 memcached_quit(memc_clone
);
2026 memcached_free(mine
);
2027 memcached_free(memc_clone
);
2029 return TEST_SUCCESS
;
2032 /* Test flag store/retrieve */
2033 static test_return_t
user_supplied_bug7(memcached_st
*memc
)
2035 memcached_return rc
;
2036 const char *keys
= "036790384900";
2037 size_t key_length
= strlen(keys
);
2038 char return_key
[MEMCACHED_MAX_KEY
];
2039 size_t return_key_length
;
2041 size_t value_length
;
2044 char insert_data
[VALUE_SIZE_BUG5
];
2046 for (x
= 0; x
< VALUE_SIZE_BUG5
; x
++)
2047 insert_data
[x
]= (signed char)rand();
2049 memcached_flush(memc
, 0);
2052 rc
= memcached_set(memc
, keys
, key_length
,
2053 insert_data
, VALUE_SIZE_BUG5
,
2055 assert(rc
== MEMCACHED_SUCCESS
);
2058 value
= memcached_get(memc
, keys
, key_length
,
2059 &value_length
, &flags
, &rc
);
2060 assert(flags
== 245);
2064 rc
= memcached_mget(memc
, &keys
, &key_length
, 1);
2067 value
= memcached_fetch(memc
, return_key
, &return_key_length
,
2068 &value_length
, &flags
, &rc
);
2069 assert(flags
== 245);
2074 return TEST_SUCCESS
;
2077 static test_return_t
user_supplied_bug9(memcached_st
*memc
)
2079 memcached_return rc
;
2080 const char *keys
[]= {"UDATA:edevil@sapo.pt", "fudge&*@#", "for^#@&$not"};
2081 size_t key_length
[3];
2086 char return_key
[MEMCACHED_MAX_KEY
];
2087 size_t return_key_length
;
2089 size_t return_value_length
;
2092 key_length
[0]= strlen("UDATA:edevil@sapo.pt");
2093 key_length
[1]= strlen("fudge&*@#");
2094 key_length
[2]= strlen("for^#@&$not");
2097 for (x
= 0; x
< 3; x
++)
2099 rc
= memcached_set(memc
, keys
[x
], key_length
[x
],
2100 keys
[x
], key_length
[x
],
2101 (time_t)50, (uint32_t)9);
2102 assert(rc
== MEMCACHED_SUCCESS
);
2105 rc
= memcached_mget(memc
, keys
, key_length
, 3);
2106 assert(rc
== MEMCACHED_SUCCESS
);
2108 /* We need to empty the server before continueing test */
2109 while ((return_value
= memcached_fetch(memc
, return_key
, &return_key_length
,
2110 &return_value_length
, &flags
, &rc
)) != NULL
)
2112 assert(return_value
);
2118 return TEST_SUCCESS
;
2121 /* We are testing with aggressive timeout to get failures */
2122 static test_return_t
user_supplied_bug10(memcached_st
*memc
)
2124 const char *key
= "foo";
2126 size_t value_length
= 512;
2129 memcached_return rc
;
2130 unsigned int set
= 1;
2131 memcached_st
*mclone
= memcached_clone(NULL
, memc
);
2134 memcached_behavior_set(mclone
, MEMCACHED_BEHAVIOR_NO_BLOCK
, set
);
2135 memcached_behavior_set(mclone
, MEMCACHED_BEHAVIOR_TCP_NODELAY
, set
);
2137 memcached_behavior_set(mclone
, MEMCACHED_BEHAVIOR_POLL_TIMEOUT
,
2140 value
= (char*)malloc(value_length
* sizeof(char));
2142 for (x
= 0; x
< value_length
; x
++)
2143 value
[x
]= (char) (x
% 127);
2145 for (x
= 1; x
<= 100000; ++x
)
2147 rc
= memcached_set(mclone
, key
, key_len
,value
, value_length
, 0, 0);
2149 assert(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_WRITE_FAILURE
||
2150 rc
== MEMCACHED_BUFFERED
|| rc
== MEMCACHED_TIMEOUT
);
2152 if (rc
== MEMCACHED_WRITE_FAILURE
|| rc
== MEMCACHED_TIMEOUT
)
2157 memcached_free(mclone
);
2159 return TEST_SUCCESS
;
2163 We are looking failures in the async protocol
2165 static test_return_t
user_supplied_bug11(memcached_st
*memc
)
2167 const char *key
= "foo";
2169 size_t value_length
= 512;
2172 memcached_return rc
;
2173 unsigned int set
= 1;
2175 memcached_st
*mclone
= memcached_clone(NULL
, memc
);
2177 memcached_behavior_set(mclone
, MEMCACHED_BEHAVIOR_NO_BLOCK
, set
);
2178 memcached_behavior_set(mclone
, MEMCACHED_BEHAVIOR_TCP_NODELAY
, set
);
2180 memcached_behavior_set(mclone
, MEMCACHED_BEHAVIOR_POLL_TIMEOUT
,
2183 timeout
= (int32_t)memcached_behavior_get(mclone
, MEMCACHED_BEHAVIOR_POLL_TIMEOUT
);
2185 assert(timeout
== -1);
2187 value
= (char*)malloc(value_length
* sizeof(char));
2189 for (x
= 0; x
< value_length
; x
++)
2190 value
[x
]= (char) (x
% 127);
2192 for (x
= 1; x
<= 100000; ++x
)
2194 rc
= memcached_set(mclone
, key
, key_len
,value
, value_length
, 0, 0);
2198 memcached_free(mclone
);
2200 return TEST_SUCCESS
;
2204 Bug found where incr was not returning MEMCACHED_NOTFOUND when object did not exist.
2206 static test_return_t
user_supplied_bug12(memcached_st
*memc
)
2208 memcached_return rc
;
2210 size_t value_length
;
2212 uint64_t number_value
;
2214 value
= memcached_get(memc
, "autoincrement", strlen("autoincrement"),
2215 &value_length
, &flags
, &rc
);
2216 assert(value
== NULL
);
2217 assert(rc
== MEMCACHED_NOTFOUND
);
2219 rc
= memcached_increment(memc
, "autoincrement", strlen("autoincrement"),
2222 assert(value
== NULL
);
2223 /* The binary protocol will set the key if it doesn't exist */
2224 if (memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
) == 1)
2225 assert(rc
== MEMCACHED_SUCCESS
);
2227 assert(rc
== MEMCACHED_NOTFOUND
);
2229 rc
= memcached_set(memc
, "autoincrement", strlen("autoincrement"), "1", 1, 0, 0);
2231 value
= memcached_get(memc
, "autoincrement", strlen("autoincrement"),
2232 &value_length
, &flags
, &rc
);
2234 assert(rc
== MEMCACHED_SUCCESS
);
2237 rc
= memcached_increment(memc
, "autoincrement", strlen("autoincrement"),
2239 assert(number_value
== 2);
2240 assert(rc
== MEMCACHED_SUCCESS
);
2242 return TEST_SUCCESS
;
2246 Bug found where command total one more than MEMCACHED_MAX_BUFFER
2247 set key34567890 0 0 8169 \r\n is sent followed by buffer of size 8169, followed by 8169
2249 static test_return_t
user_supplied_bug13(memcached_st
*memc
)
2251 char key
[] = "key34567890";
2253 memcached_return rc
;
2254 size_t overflowSize
;
2256 char commandFirst
[]= "set key34567890 0 0 ";
2257 char commandLast
[] = " \r\n"; /* first line of command sent to server */
2258 size_t commandLength
;
2261 commandLength
= strlen(commandFirst
) + strlen(commandLast
) + 4; /* 4 is number of characters in size, probably 8196 */
2263 overflowSize
= MEMCACHED_MAX_BUFFER
- commandLength
;
2265 for (testSize
= overflowSize
- 1; testSize
< overflowSize
+ 1; testSize
++)
2267 overflow
= malloc(testSize
);
2268 assert(overflow
!= NULL
);
2270 memset(overflow
, 'x', testSize
);
2271 rc
= memcached_set(memc
, key
, strlen(key
),
2272 overflow
, testSize
, 0, 0);
2273 assert(rc
== MEMCACHED_SUCCESS
);
2277 return TEST_SUCCESS
;
2282 Test values of many different sizes
2283 Bug found where command total one more than MEMCACHED_MAX_BUFFER
2284 set key34567890 0 0 8169 \r\n
2285 is sent followed by buffer of size 8169, followed by 8169
2287 static test_return_t
user_supplied_bug14(memcached_st
*memc
)
2290 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_TCP_NODELAY
, setter
);
2291 memcached_return rc
;
2292 const char *key
= "foo";
2294 size_t value_length
= 18000;
2296 size_t string_length
;
2299 size_t current_length
;
2301 value
= (char*)malloc(value_length
);
2304 for (x
= 0; x
< value_length
; x
++)
2305 value
[x
] = (char) (x
% 127);
2307 for (current_length
= 0; current_length
< value_length
; current_length
++)
2309 rc
= memcached_set(memc
, key
, strlen(key
),
2310 value
, current_length
,
2311 (time_t)0, (uint32_t)0);
2312 assert(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
);
2314 string
= memcached_get(memc
, key
, strlen(key
),
2315 &string_length
, &flags
, &rc
);
2317 assert(rc
== MEMCACHED_SUCCESS
);
2318 assert(string_length
== current_length
);
2319 assert(!memcmp(string
, value
, string_length
));
2326 return TEST_SUCCESS
;
2330 Look for zero length value problems
2332 static test_return_t
user_supplied_bug15(memcached_st
*memc
)
2335 memcached_return rc
;
2336 const char *key
= "mykey";
2341 for (x
= 0; x
< 2; x
++)
2343 rc
= memcached_set(memc
, key
, strlen(key
),
2345 (time_t)0, (uint32_t)0);
2347 assert(rc
== MEMCACHED_SUCCESS
);
2349 value
= memcached_get(memc
, key
, strlen(key
),
2350 &length
, &flags
, &rc
);
2352 assert(rc
== MEMCACHED_SUCCESS
);
2353 assert(value
== NULL
);
2354 assert(length
== 0);
2357 value
= memcached_get(memc
, key
, strlen(key
),
2358 &length
, &flags
, &rc
);
2360 assert(rc
== MEMCACHED_SUCCESS
);
2361 assert(value
== NULL
);
2362 assert(length
== 0);
2366 return TEST_SUCCESS
;
2369 /* Check the return sizes on FLAGS to make sure it stores 32bit unsigned values correctly */
2370 static test_return_t
user_supplied_bug16(memcached_st
*memc
)
2372 memcached_return rc
;
2373 const char *key
= "mykey";
2378 rc
= memcached_set(memc
, key
, strlen(key
),
2380 (time_t)0, UINT32_MAX
);
2382 assert(rc
== MEMCACHED_SUCCESS
);
2384 value
= memcached_get(memc
, key
, strlen(key
),
2385 &length
, &flags
, &rc
);
2387 assert(rc
== MEMCACHED_SUCCESS
);
2388 assert(value
== NULL
);
2389 assert(length
== 0);
2390 assert(flags
== UINT32_MAX
);
2392 return TEST_SUCCESS
;
2396 /* Check the validity of chinese key*/
2397 static test_return_t
user_supplied_bug17(memcached_st
*memc
)
2399 memcached_return rc
;
2400 const char *key
= "豆瓣";
2401 const char *value
="我们在炎热抑郁的夏天无法停止豆瓣";
2406 rc
= memcached_set(memc
, key
, strlen(key
),
2407 value
, strlen(value
),
2410 assert(rc
== MEMCACHED_SUCCESS
);
2412 value2
= memcached_get(memc
, key
, strlen(key
),
2413 &length
, &flags
, &rc
);
2415 assert(length
==strlen(value
));
2416 assert(rc
== MEMCACHED_SUCCESS
);
2417 assert(memcmp(value
, value2
, length
)==0);
2420 return TEST_SUCCESS
;
2428 static test_return_t
user_supplied_bug19(memcached_st
*memc
)
2431 memcached_server_st
*s
;
2432 memcached_return res
;
2436 m
= memcached_create(NULL
);
2437 memcached_server_add_with_weight(m
, "localhost", 11311, 100);
2438 memcached_server_add_with_weight(m
, "localhost", 11312, 100);
2440 s
= memcached_server_by_key(m
, "a", 1, &res
);
2441 memcached_server_free(s
);
2445 return TEST_SUCCESS
;
2448 /* CAS test from Andei */
2449 static test_return_t
user_supplied_bug20(memcached_st
*memc
)
2451 memcached_return status
;
2452 memcached_result_st
*result
, result_obj
;
2453 const char *key
= "abc";
2454 size_t key_len
= strlen("abc");
2455 const char *value
= "foobar";
2456 size_t value_len
= strlen(value
);
2458 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_SUPPORT_CAS
, 1);
2460 status
= memcached_set(memc
, key
, key_len
, value
, value_len
, (time_t)0, (uint32_t)0);
2461 assert(status
== MEMCACHED_SUCCESS
);
2463 status
= memcached_mget(memc
, &key
, &key_len
, 1);
2464 assert(status
== MEMCACHED_SUCCESS
);
2466 result
= memcached_result_create(memc
, &result_obj
);
2469 memcached_result_create(memc
, &result_obj
);
2470 result
= memcached_fetch_result(memc
, &result_obj
, &status
);
2473 assert(status
== MEMCACHED_SUCCESS
);
2475 memcached_result_free(result
);
2477 return TEST_SUCCESS
;
2480 #include "ketama_test_cases.h"
2481 static test_return_t
user_supplied_bug18(memcached_st
*trash
)
2483 memcached_return rc
;
2486 memcached_server_st
*server_pool
;
2491 memc
= memcached_create(NULL
);
2494 rc
= memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_KETAMA_WEIGHTED
, 1);
2495 assert(rc
== MEMCACHED_SUCCESS
);
2497 value
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_KETAMA_WEIGHTED
);
2500 rc
= memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_KETAMA_HASH
, MEMCACHED_HASH_MD5
);
2501 assert(rc
== MEMCACHED_SUCCESS
);
2503 value
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_KETAMA_HASH
);
2504 assert(value
== MEMCACHED_HASH_MD5
);
2506 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");
2507 memcached_server_push(memc
, server_pool
);
2509 /* verify that the server list was parsed okay. */
2510 assert(memc
->number_of_hosts
== 8);
2511 assert(strcmp(server_pool
[0].hostname
, "10.0.1.1") == 0);
2512 assert(server_pool
[0].port
== 11211);
2513 assert(server_pool
[0].weight
== 600);
2514 assert(strcmp(server_pool
[2].hostname
, "10.0.1.3") == 0);
2515 assert(server_pool
[2].port
== 11211);
2516 assert(server_pool
[2].weight
== 200);
2517 assert(strcmp(server_pool
[7].hostname
, "10.0.1.8") == 0);
2518 assert(server_pool
[7].port
== 11211);
2519 assert(server_pool
[7].weight
== 100);
2521 /* VDEAAAAA hashes to fffcd1b5, after the last continuum point, and lets
2522 * us test the boundary wraparound.
2524 assert(memcached_generate_hash(memc
, (char *)"VDEAAAAA", 8) == memc
->continuum
[0].index
);
2526 /* verify the standard ketama set. */
2527 for (x
= 0; x
< 99; x
++)
2529 uint32_t server_idx
= memcached_generate_hash(memc
, test_cases
[x
].key
, strlen(test_cases
[x
].key
));
2530 char *hostname
= memc
->hosts
[server_idx
].hostname
;
2531 assert(strcmp(hostname
, test_cases
[x
].server
) == 0);
2534 memcached_server_list_free(server_pool
);
2535 memcached_free(memc
);
2537 return TEST_SUCCESS
;
2540 /* Large mget() of missing keys with binary proto
2542 * If many binary quiet commands (such as getq's in an mget) fill the output
2543 * buffer and the server chooses not to respond, memcached_flush hangs. See
2544 * http://lists.tangent.org/pipermail/libmemcached/2009-August/000918.html
2547 /* sighandler_t function that always asserts false */
2548 static void fail(int unused
__attribute__((unused
)))
2554 static test_return_t
_user_supplied_bug21(memcached_st
* memc
, size_t key_count
)
2556 memcached_return rc
;
2559 size_t* key_lengths
;
2560 void (*oldalarm
)(int);
2561 memcached_st
*memc_clone
;
2563 memc_clone
= memcached_clone(NULL
, memc
);
2566 /* only binproto uses getq for mget */
2567 memcached_behavior_set(memc_clone
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
, 1);
2569 /* empty the cache to ensure misses (hence non-responses) */
2570 rc
= memcached_flush(memc_clone
, 0);
2571 assert(rc
== MEMCACHED_SUCCESS
);
2573 key_lengths
= calloc(key_count
, sizeof(size_t));
2574 keys
= calloc(key_count
, sizeof(char *));
2576 for (x
= 0; x
< key_count
; x
++)
2580 snprintf(buffer
, 30, "%u", x
);
2581 keys
[x
]= strdup(buffer
);
2582 key_lengths
[x
]= strlen(keys
[x
]);
2585 oldalarm
= signal(SIGALRM
, fail
);
2588 rc
= memcached_mget(memc_clone
, (const char **)keys
, key_lengths
, key_count
);
2589 assert(rc
== MEMCACHED_SUCCESS
);
2592 signal(SIGALRM
, oldalarm
);
2594 assert(fetch_all_results(memc
) == TEST_SUCCESS
);
2596 for (x
= 0; x
< key_count
; x
++)
2601 memcached_free(memc_clone
);
2603 return TEST_SUCCESS
;
2606 static memcached_return
pre_binary(memcached_st
*memc
);
2608 static test_return_t
user_supplied_bug21(memcached_st
*memc
)
2610 if (pre_binary(memc
) != MEMCACHED_SUCCESS
)
2611 return TEST_SKIPPED
;
2615 /* should work as of r580 */
2616 rc
= _user_supplied_bug21(memc
, 10);
2617 assert(rc
== TEST_SUCCESS
);
2619 /* should fail as of r580 */
2620 rc
= _user_supplied_bug21(memc
, 1000);
2621 assert(rc
== TEST_SUCCESS
);
2623 return TEST_SUCCESS
;
2626 static test_return_t
auto_eject_hosts(memcached_st
*trash
)
2630 memcached_return rc
;
2631 memcached_st
*memc
= memcached_create(NULL
);
2634 rc
= memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_KETAMA_WEIGHTED
, 1);
2635 assert(rc
== MEMCACHED_SUCCESS
);
2637 uint64_t value
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_KETAMA_WEIGHTED
);
2640 rc
= memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_KETAMA_HASH
, MEMCACHED_HASH_MD5
);
2641 assert(rc
== MEMCACHED_SUCCESS
);
2643 value
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_KETAMA_HASH
);
2644 assert(value
== MEMCACHED_HASH_MD5
);
2646 /* server should be removed when in delay */
2647 rc
= memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_AUTO_EJECT_HOSTS
, 1);
2648 assert(rc
== MEMCACHED_SUCCESS
);
2650 value
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_AUTO_EJECT_HOSTS
);
2653 memcached_server_st
*server_pool
;
2654 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");
2655 memcached_server_push(memc
, server_pool
);
2657 /* verify that the server list was parsed okay. */
2658 assert(memc
->number_of_hosts
== 8);
2659 assert(strcmp(server_pool
[0].hostname
, "10.0.1.1") == 0);
2660 assert(server_pool
[0].port
== 11211);
2661 assert(server_pool
[0].weight
== 600);
2662 assert(strcmp(server_pool
[2].hostname
, "10.0.1.3") == 0);
2663 assert(server_pool
[2].port
== 11211);
2664 assert(server_pool
[2].weight
== 200);
2665 assert(strcmp(server_pool
[7].hostname
, "10.0.1.8") == 0);
2666 assert(server_pool
[7].port
== 11211);
2667 assert(server_pool
[7].weight
== 100);
2669 memc
->hosts
[2].next_retry
= time(NULL
) + 15;
2670 memc
->next_distribution_rebuild
= time(NULL
) - 1;
2672 for (int x
= 0; x
< 99; x
++)
2674 uint32_t server_idx
= memcached_generate_hash(memc
, test_cases
[x
].key
, strlen(test_cases
[x
].key
));
2675 assert(server_idx
!= 2);
2678 /* and re-added when it's back. */
2679 memc
->hosts
[2].next_retry
= time(NULL
) - 1;
2680 memc
->next_distribution_rebuild
= time(NULL
) - 1;
2681 run_distribution(memc
);
2682 for (int x
= 0; x
< 99; x
++)
2684 uint32_t server_idx
= memcached_generate_hash(memc
, test_cases
[x
].key
, strlen(test_cases
[x
].key
));
2685 char *hostname
= memc
->hosts
[server_idx
].hostname
;
2686 assert(strcmp(hostname
, test_cases
[x
].server
) == 0);
2689 memcached_server_list_free(server_pool
);
2690 memcached_free(memc
);
2692 return TEST_SUCCESS
;
2695 static test_return_t
result_static(memcached_st
*memc
)
2697 memcached_result_st result
;
2698 memcached_result_st
*result_ptr
;
2700 result_ptr
= memcached_result_create(memc
, &result
);
2701 assert(result
.is_allocated
== false);
2703 memcached_result_free(&result
);
2705 return TEST_SUCCESS
;
2708 static test_return_t
result_alloc(memcached_st
*memc
)
2710 memcached_result_st
*result
;
2712 result
= memcached_result_create(memc
, NULL
);
2714 memcached_result_free(result
);
2716 return TEST_SUCCESS
;
2719 static test_return_t
string_static_null(memcached_st
*memc
)
2721 memcached_string_st string
;
2722 memcached_string_st
*string_ptr
;
2724 string_ptr
= memcached_string_create(memc
, &string
, 0);
2725 assert(string
.is_allocated
== false);
2727 memcached_string_free(&string
);
2729 return TEST_SUCCESS
;
2732 static test_return_t
string_alloc_null(memcached_st
*memc
)
2734 memcached_string_st
*string
;
2736 string
= memcached_string_create(memc
, NULL
, 0);
2738 memcached_string_free(string
);
2740 return TEST_SUCCESS
;
2743 static test_return_t
string_alloc_with_size(memcached_st
*memc
)
2745 memcached_string_st
*string
;
2747 string
= memcached_string_create(memc
, NULL
, 1024);
2749 memcached_string_free(string
);
2751 return TEST_SUCCESS
;
2754 static test_return_t
string_alloc_with_size_toobig(memcached_st
*memc
)
2756 memcached_string_st
*string
;
2758 string
= memcached_string_create(memc
, NULL
, SIZE_MAX
);
2759 assert(string
== NULL
);
2761 return TEST_SUCCESS
;
2764 static test_return_t
string_alloc_append(memcached_st
*memc
)
2767 char buffer
[SMALL_STRING_LEN
];
2768 memcached_string_st
*string
;
2770 /* Ring the bell! */
2771 memset(buffer
, 6, SMALL_STRING_LEN
);
2773 string
= memcached_string_create(memc
, NULL
, 100);
2776 for (x
= 0; x
< 1024; x
++)
2778 memcached_return rc
;
2779 rc
= memcached_string_append(string
, buffer
, SMALL_STRING_LEN
);
2780 assert(rc
== MEMCACHED_SUCCESS
);
2782 memcached_string_free(string
);
2784 return TEST_SUCCESS
;
2787 static test_return_t
string_alloc_append_toobig(memcached_st
*memc
)
2789 memcached_return rc
;
2791 char buffer
[SMALL_STRING_LEN
];
2792 memcached_string_st
*string
;
2794 /* Ring the bell! */
2795 memset(buffer
, 6, SMALL_STRING_LEN
);
2797 string
= memcached_string_create(memc
, NULL
, 100);
2800 for (x
= 0; x
< 1024; x
++)
2802 rc
= memcached_string_append(string
, buffer
, SMALL_STRING_LEN
);
2803 assert(rc
== MEMCACHED_SUCCESS
);
2805 rc
= memcached_string_append(string
, buffer
, SIZE_MAX
);
2806 assert(rc
== MEMCACHED_MEMORY_ALLOCATION_FAILURE
);
2807 memcached_string_free(string
);
2809 return TEST_SUCCESS
;
2812 static test_return_t
cleanup_pairs(memcached_st
*memc
__attribute__((unused
)))
2814 pairs_free(global_pairs
);
2816 return TEST_SUCCESS
;
2819 static test_return_t
generate_pairs(memcached_st
*memc
__attribute__((unused
)))
2821 unsigned long long x
;
2822 global_pairs
= pairs_generate(GLOBAL_COUNT
, 400);
2823 global_count
= GLOBAL_COUNT
;
2825 for (x
= 0; x
< global_count
; x
++)
2827 global_keys
[x
]= global_pairs
[x
].key
;
2828 global_keys_length
[x
]= global_pairs
[x
].key_length
;
2831 return TEST_SUCCESS
;
2834 static test_return_t
generate_large_pairs(memcached_st
*memc
__attribute__((unused
)))
2836 unsigned long long x
;
2837 global_pairs
= pairs_generate(GLOBAL2_COUNT
, MEMCACHED_MAX_BUFFER
+10);
2838 global_count
= GLOBAL2_COUNT
;
2840 for (x
= 0; x
< global_count
; x
++)
2842 global_keys
[x
]= global_pairs
[x
].key
;
2843 global_keys_length
[x
]= global_pairs
[x
].key_length
;
2846 return TEST_SUCCESS
;
2849 static test_return_t
generate_data(memcached_st
*memc
)
2851 execute_set(memc
, global_pairs
, global_count
);
2853 return TEST_SUCCESS
;
2856 static test_return_t
generate_data_with_stats(memcached_st
*memc
)
2858 memcached_stat_st
*stat_p
;
2859 memcached_return rc
;
2860 uint32_t host_index
= 0;
2861 execute_set(memc
, global_pairs
, global_count
);
2863 //TODO: hosts used size stats
2864 stat_p
= memcached_stat(memc
, NULL
, &rc
);
2867 for (host_index
= 0; host_index
< SERVERS_TO_CREATE
; host_index
++)
2869 /* This test was changes so that "make test" would work properlly */
2871 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
);
2873 assert((unsigned long long)(stat_p
+ host_index
)->bytes
);
2876 memcached_stat_free(NULL
, stat_p
);
2878 return TEST_SUCCESS
;
2880 static test_return_t
generate_buffer_data(memcached_st
*memc
)
2885 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_BUFFER_REQUESTS
, latch
);
2886 generate_data(memc
);
2888 return TEST_SUCCESS
;
2891 static test_return_t
get_read_count(memcached_st
*memc
)
2894 memcached_return rc
;
2895 memcached_st
*memc_clone
;
2897 memc_clone
= memcached_clone(NULL
, memc
);
2900 memcached_server_add_with_weight(memc_clone
, "localhost", 6666, 0);
2904 size_t return_value_length
;
2908 for (x
= count
= 0; x
< global_count
; x
++)
2910 return_value
= memcached_get(memc_clone
, global_keys
[x
], global_keys_length
[x
],
2911 &return_value_length
, &flags
, &rc
);
2912 if (rc
== MEMCACHED_SUCCESS
)
2921 memcached_free(memc_clone
);
2923 return TEST_SUCCESS
;
2926 static test_return_t
get_read(memcached_st
*memc
)
2929 memcached_return rc
;
2933 size_t return_value_length
;
2936 for (x
= 0; x
< global_count
; x
++)
2938 return_value
= memcached_get(memc
, global_keys
[x
], global_keys_length
[x
],
2939 &return_value_length
, &flags
, &rc
);
2941 assert(return_value);
2942 assert(rc == MEMCACHED_SUCCESS);
2944 if (rc
== MEMCACHED_SUCCESS
&& return_value
)
2949 return TEST_SUCCESS
;
2952 static test_return_t
mget_read(memcached_st
*memc
)
2954 memcached_return rc
;
2956 rc
= memcached_mget(memc
, global_keys
, global_keys_length
, global_count
);
2957 assert(rc
== MEMCACHED_SUCCESS
);
2958 assert(fetch_all_results(memc
) == TEST_SUCCESS
);
2960 return TEST_SUCCESS
;
2963 static test_return_t
mget_read_result(memcached_st
*memc
)
2965 memcached_return rc
;
2967 rc
= memcached_mget(memc
, global_keys
, global_keys_length
, global_count
);
2968 assert(rc
== MEMCACHED_SUCCESS
);
2969 /* Turn this into a help function */
2971 memcached_result_st results_obj
;
2972 memcached_result_st
*results
;
2974 results
= memcached_result_create(memc
, &results_obj
);
2976 while ((results
= memcached_fetch_result(memc
, &results_obj
, &rc
)))
2979 assert(rc
== MEMCACHED_SUCCESS
);
2982 memcached_result_free(&results_obj
);
2985 return TEST_SUCCESS
;
2988 static test_return_t
mget_read_function(memcached_st
*memc
)
2990 memcached_return rc
;
2991 unsigned int counter
;
2992 memcached_execute_function callbacks
[1];
2994 rc
= memcached_mget(memc
, global_keys
, global_keys_length
, global_count
);
2995 assert(rc
== MEMCACHED_SUCCESS
);
2997 callbacks
[0]= &callback_counter
;
2999 rc
= memcached_fetch_execute(memc
, callbacks
, (void *)&counter
, 1);
3001 return TEST_SUCCESS
;
3004 static test_return_t
delete_generate(memcached_st
*memc
)
3008 for (x
= 0; x
< global_count
; x
++)
3010 (void)memcached_delete(memc
, global_keys
[x
], global_keys_length
[x
], (time_t)0);
3013 return TEST_SUCCESS
;
3016 static test_return_t
delete_buffer_generate(memcached_st
*memc
)
3022 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_BUFFER_REQUESTS
, latch
);
3024 for (x
= 0; x
< global_count
; x
++)
3026 (void)memcached_delete(memc
, global_keys
[x
], global_keys_length
[x
], (time_t)0);
3029 return TEST_SUCCESS
;
3032 static test_return_t
add_host_test1(memcached_st
*memc
)
3035 memcached_return rc
;
3036 char servername
[]= "0.example.com";
3037 memcached_server_st
*servers
;
3039 servers
= memcached_server_list_append_with_weight(NULL
, servername
, 400, 0, &rc
);
3041 assert(1 == memcached_server_list_count(servers
));
3043 for (x
= 2; x
< 20; x
++)
3045 char buffer
[SMALL_STRING_LEN
];
3047 snprintf(buffer
, SMALL_STRING_LEN
, "%u.example.com", 400+x
);
3048 servers
= memcached_server_list_append_with_weight(servers
, buffer
, 401, 0,
3050 assert(rc
== MEMCACHED_SUCCESS
);
3051 assert(x
== memcached_server_list_count(servers
));
3054 rc
= memcached_server_push(memc
, servers
);
3055 assert(rc
== MEMCACHED_SUCCESS
);
3056 rc
= memcached_server_push(memc
, servers
);
3057 assert(rc
== MEMCACHED_SUCCESS
);
3059 memcached_server_list_free(servers
);
3061 return TEST_SUCCESS
;
3064 static memcached_return
pre_nonblock(memcached_st
*memc
)
3066 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NO_BLOCK
, 0);
3068 return MEMCACHED_SUCCESS
;
3071 static memcached_return
pre_nonblock_binary(memcached_st
*memc
)
3073 memcached_return rc
= MEMCACHED_FAILURE
;
3074 memcached_st
*memc_clone
;
3076 memc_clone
= memcached_clone(NULL
, memc
);
3078 // The memcached_version needs to be done on a clone, because the server
3079 // will not toggle protocol on an connection.
3080 memcached_version(memc_clone
);
3082 if (memc_clone
->hosts
[0].major_version
>= 1 && memc_clone
->hosts
[0].minor_version
> 2)
3084 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NO_BLOCK
, 0);
3085 rc
= memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
, 1);
3086 assert(rc
== MEMCACHED_SUCCESS
);
3087 assert(memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
) == 1);
3090 memcached_free(memc_clone
);
3094 static memcached_return
pre_murmur(memcached_st
*memc
)
3096 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_HASH
, (uint64_t)MEMCACHED_HASH_MURMUR
);
3098 return MEMCACHED_SUCCESS
;
3101 static memcached_return
pre_jenkins(memcached_st
*memc
)
3103 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_HASH
, (uint64_t)MEMCACHED_HASH_JENKINS
);
3105 return MEMCACHED_SUCCESS
;
3109 static memcached_return
pre_md5(memcached_st
*memc
)
3111 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_HASH
, (uint64_t)MEMCACHED_HASH_MD5
);
3113 return MEMCACHED_SUCCESS
;
3116 static memcached_return
pre_crc(memcached_st
*memc
)
3118 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_HASH
, (uint64_t)MEMCACHED_HASH_CRC
);
3120 return MEMCACHED_SUCCESS
;
3123 static memcached_return
pre_hsieh(memcached_st
*memc
)
3125 #ifdef HAVE_HSIEH_HASH
3126 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_HASH
, (uint64_t)MEMCACHED_HASH_HSIEH
);
3127 return MEMCACHED_SUCCESS
;
3130 return MEMCACHED_FAILURE
;
3134 static memcached_return
pre_hash_fnv1_64(memcached_st
*memc
)
3136 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_HASH
, (uint64_t)MEMCACHED_HASH_FNV1_64
);
3138 return MEMCACHED_SUCCESS
;
3141 static memcached_return
pre_hash_fnv1a_64(memcached_st
*memc
)
3143 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_HASH
, (uint64_t)MEMCACHED_HASH_FNV1A_64
);
3145 return MEMCACHED_SUCCESS
;
3148 static memcached_return
pre_hash_fnv1_32(memcached_st
*memc
)
3150 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_HASH
, (uint64_t)MEMCACHED_HASH_FNV1_32
);
3152 return MEMCACHED_SUCCESS
;
3155 static memcached_return
pre_hash_fnv1a_32(memcached_st
*memc
)
3157 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_HASH
, (uint64_t)MEMCACHED_HASH_FNV1A_32
);
3159 return MEMCACHED_SUCCESS
;
3162 static memcached_return
pre_behavior_ketama(memcached_st
*memc
)
3164 memcached_return rc
;
3167 rc
= memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_KETAMA
, 1);
3168 assert(rc
== MEMCACHED_SUCCESS
);
3170 value
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_KETAMA
);
3173 return MEMCACHED_SUCCESS
;
3176 static memcached_return
pre_behavior_ketama_weighted(memcached_st
*memc
)
3178 memcached_return rc
;
3181 rc
= memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_KETAMA_WEIGHTED
, 1);
3182 assert(rc
== MEMCACHED_SUCCESS
);
3184 value
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_KETAMA_WEIGHTED
);
3187 rc
= memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_KETAMA_HASH
, MEMCACHED_HASH_MD5
);
3188 assert(rc
== MEMCACHED_SUCCESS
);
3190 value
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_KETAMA_HASH
);
3191 assert(value
== MEMCACHED_HASH_MD5
);
3192 return MEMCACHED_SUCCESS
;
3195 static memcached_return
pre_binary(memcached_st
*memc
)
3197 memcached_return rc
= MEMCACHED_FAILURE
;
3198 memcached_st
*memc_clone
;
3200 memc_clone
= memcached_clone(NULL
, memc
);
3202 // The memcached_version needs to be done on a clone, because the server
3203 // will not toggle protocol on an connection.
3204 memcached_version(memc_clone
);
3206 if (memc_clone
->hosts
[0].major_version
>= 1 && memc_clone
->hosts
[0].minor_version
> 2)
3208 rc
= memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
, 1);
3209 assert(rc
== MEMCACHED_SUCCESS
);
3210 assert(memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
) == 1);
3213 memcached_free(memc_clone
);
3218 static memcached_return
pre_replication(memcached_st
*memc
)
3220 memcached_return rc
= MEMCACHED_FAILURE
;
3222 if (pre_binary(memc
) != MEMCACHED_SUCCESS
)
3223 return TEST_SKIPPED
;
3226 * Make sure that we store the item on all servers
3227 * (master + replicas == number of servers)
3229 rc
= memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NUMBER_OF_REPLICAS
,
3230 memc
->number_of_hosts
- 1);
3231 assert(rc
== MEMCACHED_SUCCESS
);
3232 assert(memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_NUMBER_OF_REPLICAS
) == memc
->number_of_hosts
- 1);
3237 static memcached_return
pre_replication_noblock(memcached_st
*memc
)
3239 memcached_return rc
= MEMCACHED_FAILURE
;
3240 if (pre_replication(memc
) == MEMCACHED_SUCCESS
&&
3241 pre_nonblock(memc
) == MEMCACHED_SUCCESS
)
3242 rc
= MEMCACHED_SUCCESS
;
3247 static void my_free(memcached_st
*ptr
__attribute__((unused
)), void *mem
)
3252 static void *my_malloc(memcached_st
*ptr
__attribute__((unused
)), const size_t size
)
3254 void *ret
= malloc(size
);
3256 memset(ret
, 0xff, size
);
3261 static void *my_realloc(memcached_st
*ptr
__attribute__((unused
)), void *mem
, const size_t size
)
3263 return realloc(mem
, size
);
3266 static void *my_calloc(memcached_st
*ptr
__attribute__((unused
)), size_t nelem
, const size_t size
)
3268 return calloc(nelem
, size
);
3271 static memcached_return
set_prefix(memcached_st
*memc
)
3273 memcached_return rc
;
3274 const char *key
= "mine";
3277 /* Make sure be default none exists */
3278 value
= memcached_callback_get(memc
, MEMCACHED_CALLBACK_PREFIX_KEY
, &rc
);
3279 assert(rc
== MEMCACHED_FAILURE
);
3281 /* Test a clean set */
3282 rc
= memcached_callback_set(memc
, MEMCACHED_CALLBACK_PREFIX_KEY
, (void *)key
);
3283 assert(rc
== MEMCACHED_SUCCESS
);
3285 value
= memcached_callback_get(memc
, MEMCACHED_CALLBACK_PREFIX_KEY
, &rc
);
3286 assert(memcmp(value
, key
, 4) == 0);
3287 assert(rc
== MEMCACHED_SUCCESS
);
3289 /* Test that we can turn it off */
3290 rc
= memcached_callback_set(memc
, MEMCACHED_CALLBACK_PREFIX_KEY
, NULL
);
3291 assert(rc
== MEMCACHED_SUCCESS
);
3293 value
= memcached_callback_get(memc
, MEMCACHED_CALLBACK_PREFIX_KEY
, &rc
);
3294 assert(rc
== MEMCACHED_FAILURE
);
3296 /* Now setup for main test */
3297 rc
= memcached_callback_set(memc
, MEMCACHED_CALLBACK_PREFIX_KEY
, (void *)key
);
3298 assert(rc
== MEMCACHED_SUCCESS
);
3300 value
= memcached_callback_get(memc
, MEMCACHED_CALLBACK_PREFIX_KEY
, &rc
);
3301 assert(rc
== MEMCACHED_SUCCESS
);
3302 assert(memcmp(value
, key
, 4) == 0);
3304 /* Set to Zero, and then Set to something too large */
3307 memset(long_key
, 0, 255);
3309 rc
= memcached_callback_set(memc
, MEMCACHED_CALLBACK_PREFIX_KEY
, NULL
);
3310 assert(rc
== MEMCACHED_SUCCESS
);
3312 value
= memcached_callback_get(memc
, MEMCACHED_CALLBACK_PREFIX_KEY
, &rc
);
3313 assert(rc
== MEMCACHED_FAILURE
);
3314 assert(value
== NULL
);
3316 /* Test a long key for failure */
3317 /* TODO, extend test to determine based on setting, what result should be */
3318 strcpy(long_key
, "Thisismorethentheallottednumberofcharacters");
3319 rc
= memcached_callback_set(memc
, MEMCACHED_CALLBACK_PREFIX_KEY
, long_key
);
3320 //assert(rc == MEMCACHED_BAD_KEY_PROVIDED);
3321 assert(rc
== MEMCACHED_SUCCESS
);
3323 /* Now test a key with spaces (which will fail from long key, since bad key is not set) */
3324 strcpy(long_key
, "This is more then the allotted number of characters");
3325 rc
= memcached_callback_set(memc
, MEMCACHED_CALLBACK_PREFIX_KEY
, long_key
);
3326 assert(rc
== MEMCACHED_BAD_KEY_PROVIDED
);
3328 /* Test for a bad prefix, but with a short key */
3329 rc
= memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_VERIFY_KEY
, 1);
3330 assert(rc
== MEMCACHED_SUCCESS
);
3332 strcpy(long_key
, "dog cat");
3333 rc
= memcached_callback_set(memc
, MEMCACHED_CALLBACK_PREFIX_KEY
, long_key
);
3334 assert(rc
== MEMCACHED_BAD_KEY_PROVIDED
);
3337 return MEMCACHED_SUCCESS
;
3340 #ifdef MEMCACHED_ENABLE_DEPRECATED
3341 static memcached_return
deprecated_set_memory_alloc(memcached_st
*memc
)
3343 void *test_ptr
= NULL
;
3346 memcached_malloc_function malloc_cb
=
3347 (memcached_malloc_function
)my_malloc
;
3348 cb_ptr
= *(void **)&malloc_cb
;
3349 memcached_return rc
;
3351 rc
= memcached_callback_set(memc
, MEMCACHED_CALLBACK_MALLOC_FUNCTION
, cb_ptr
);
3352 assert(rc
== MEMCACHED_SUCCESS
);
3353 test_ptr
= memcached_callback_get(memc
, MEMCACHED_CALLBACK_MALLOC_FUNCTION
, &rc
);
3354 assert(rc
== MEMCACHED_SUCCESS
);
3355 assert(test_ptr
== cb_ptr
);
3359 memcached_realloc_function realloc_cb
=
3360 (memcached_realloc_function
)my_realloc
;
3361 cb_ptr
= *(void **)&realloc_cb
;
3362 memcached_return rc
;
3364 rc
= memcached_callback_set(memc
, MEMCACHED_CALLBACK_REALLOC_FUNCTION
, cb_ptr
);
3365 assert(rc
== MEMCACHED_SUCCESS
);
3366 test_ptr
= memcached_callback_get(memc
, MEMCACHED_CALLBACK_REALLOC_FUNCTION
, &rc
);
3367 assert(rc
== MEMCACHED_SUCCESS
);
3368 assert(test_ptr
== cb_ptr
);
3372 memcached_free_function free_cb
=
3373 (memcached_free_function
)my_free
;
3374 cb_ptr
= *(void **)&free_cb
;
3375 memcached_return rc
;
3377 rc
= memcached_callback_set(memc
, MEMCACHED_CALLBACK_FREE_FUNCTION
, cb_ptr
);
3378 assert(rc
== MEMCACHED_SUCCESS
);
3379 test_ptr
= memcached_callback_get(memc
, MEMCACHED_CALLBACK_FREE_FUNCTION
, &rc
);
3380 assert(rc
== MEMCACHED_SUCCESS
);
3381 assert(test_ptr
== cb_ptr
);
3383 return MEMCACHED_SUCCESS
;
3387 static memcached_return
set_memory_alloc(memcached_st
*memc
)
3389 memcached_return rc
;
3390 rc
= memcached_set_memory_allocators(memc
, NULL
, my_free
,
3391 my_realloc
, my_calloc
);
3392 assert(rc
== MEMCACHED_FAILURE
);
3394 rc
= memcached_set_memory_allocators(memc
, my_malloc
, my_free
,
3395 my_realloc
, my_calloc
);
3397 memcached_malloc_function mem_malloc
;
3398 memcached_free_function mem_free
;
3399 memcached_realloc_function mem_realloc
;
3400 memcached_calloc_function mem_calloc
;
3401 memcached_get_memory_allocators(memc
, &mem_malloc
, &mem_free
,
3402 &mem_realloc
, &mem_calloc
);
3404 assert(mem_malloc
== my_malloc
);
3405 assert(mem_realloc
== my_realloc
);
3406 assert(mem_calloc
== my_calloc
);
3407 assert(mem_free
== my_free
);
3409 return MEMCACHED_SUCCESS
;
3412 static memcached_return
enable_consistent(memcached_st
*memc
)
3414 memcached_server_distribution value
= MEMCACHED_DISTRIBUTION_CONSISTENT
;
3415 memcached_hash hash
;
3416 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_DISTRIBUTION
, value
);
3417 if (pre_hsieh(memc
) != MEMCACHED_SUCCESS
)
3418 return MEMCACHED_FAILURE
;
3420 value
= (memcached_server_distribution
)memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_DISTRIBUTION
);
3421 assert(value
== MEMCACHED_DISTRIBUTION_CONSISTENT
);
3423 hash
= (memcached_hash
)memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_HASH
);
3424 assert(hash
== MEMCACHED_HASH_HSIEH
);
3427 return MEMCACHED_SUCCESS
;
3430 static memcached_return
enable_cas(memcached_st
*memc
)
3432 unsigned int set
= 1;
3434 memcached_version(memc
);
3436 if ((memc
->hosts
[0].major_version
>= 1 && (memc
->hosts
[0].minor_version
== 2 && memc
->hosts
[0].micro_version
>= 4))
3437 || memc
->hosts
[0].minor_version
> 2)
3439 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_SUPPORT_CAS
, set
);
3441 return MEMCACHED_SUCCESS
;
3444 return MEMCACHED_FAILURE
;
3447 static memcached_return
check_for_1_2_3(memcached_st
*memc
)
3449 memcached_version(memc
);
3451 if ((memc
->hosts
[0].major_version
>= 1 && (memc
->hosts
[0].minor_version
== 2 && memc
->hosts
[0].micro_version
>= 4))
3452 || memc
->hosts
[0].minor_version
> 2)
3453 return MEMCACHED_SUCCESS
;
3455 return MEMCACHED_FAILURE
;
3458 static memcached_return
pre_unix_socket(memcached_st
*memc
)
3460 memcached_return rc
;
3463 memcached_server_list_free(memc
->hosts
);
3465 memc
->number_of_hosts
= 0;
3467 if (stat("/tmp/memcached.socket", &buf
))
3468 return MEMCACHED_FAILURE
;
3470 rc
= memcached_server_add_unix_socket_with_weight(memc
, "/tmp/memcached.socket", 0);
3475 static memcached_return
pre_nodelay(memcached_st
*memc
)
3477 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NO_BLOCK
, 0);
3478 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_TCP_NODELAY
, 0);
3480 return MEMCACHED_SUCCESS
;
3483 static memcached_return
pre_settimer(memcached_st
*memc
)
3485 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_SND_TIMEOUT
, 1000);
3486 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_RCV_TIMEOUT
, 1000);
3488 return MEMCACHED_SUCCESS
;
3491 static memcached_return
poll_timeout(memcached_st
*memc
)
3497 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_POLL_TIMEOUT
, timeout
);
3499 timeout
= (size_t)memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_POLL_TIMEOUT
);
3501 assert(timeout
== 100);
3503 return MEMCACHED_SUCCESS
;
3506 static test_return_t
noreply_test(memcached_st
*memc
)
3508 memcached_return ret
;
3509 ret
= memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NOREPLY
, 1);
3510 assert(ret
== MEMCACHED_SUCCESS
);
3511 ret
= memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_BUFFER_REQUESTS
, 1);
3512 assert(ret
== MEMCACHED_SUCCESS
);
3513 ret
= memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_SUPPORT_CAS
, 1);
3514 assert(ret
== MEMCACHED_SUCCESS
);
3515 assert(memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_NOREPLY
) == 1);
3516 assert(memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_BUFFER_REQUESTS
) == 1);
3517 assert(memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_SUPPORT_CAS
) == 1);
3519 for (int count
=0; count
< 5; ++count
)
3521 for (int x
=0; x
< 100; ++x
)
3524 size_t len
= (size_t)sprintf(key
, "%d", x
);
3528 ret
=memcached_add(memc
, key
, len
, key
, len
, 0, 0);
3531 ret
=memcached_replace(memc
, key
, len
, key
, len
, 0, 0);
3534 ret
=memcached_set(memc
, key
, len
, key
, len
, 0, 0);
3537 ret
=memcached_append(memc
, key
, len
, key
, len
, 0, 0);
3540 ret
=memcached_prepend(memc
, key
, len
, key
, len
, 0, 0);
3546 assert(ret
== MEMCACHED_SUCCESS
|| ret
== MEMCACHED_BUFFERED
);
3550 ** NOTE: Don't ever do this in your code! this is not a supported use of the
3551 ** API and is _ONLY_ done this way to verify that the library works the
3552 ** way it is supposed to do!!!!
3555 for (uint32_t x
=0; x
< memc
->number_of_hosts
; ++x
)
3556 no_msg
+=(int)(memc
->hosts
[x
].cursor_active
);
3558 assert(no_msg
== 0);
3559 assert(memcached_flush_buffers(memc
) == MEMCACHED_SUCCESS
);
3562 ** Now validate that all items was set properly!
3564 for (int x
=0; x
< 100; ++x
)
3567 size_t len
= (size_t)sprintf(key
, "%d", x
);
3570 char* value
=memcached_get(memc
, key
, strlen(key
),
3571 &length
, &flags
, &ret
);
3572 assert(ret
== MEMCACHED_SUCCESS
&& value
!= NULL
);
3575 case 0: /* FALLTHROUGH */
3576 case 1: /* FALLTHROUGH */
3578 assert(strncmp(value
, key
, len
) == 0);
3579 assert(len
== length
);
3582 assert(length
== len
* 2);
3585 assert(length
== len
* 3);
3595 /* Try setting an illegal cas value (should not return an error to
3596 * the caller (because we don't expect a return message from the server)
3598 const char* keys
[]= {"0"};
3599 size_t lengths
[]= {1};
3602 memcached_result_st results_obj
;
3603 memcached_result_st
*results
;
3604 ret
= memcached_mget(memc
, keys
, lengths
, 1);
3605 assert(ret
== MEMCACHED_SUCCESS
);
3607 results
= memcached_result_create(memc
, &results_obj
);
3609 results
= memcached_fetch_result(memc
, &results_obj
, &ret
);
3611 assert(ret
== MEMCACHED_SUCCESS
);
3612 uint64_t cas
= memcached_result_cas(results
);
3613 memcached_result_free(&results_obj
);
3615 ret
= memcached_cas(memc
, keys
[0], lengths
[0], keys
[0], lengths
[0], 0, 0, cas
);
3616 assert(ret
== MEMCACHED_SUCCESS
);
3619 * The item will have a new cas value, so try to set it again with the old
3620 * value. This should fail!
3622 ret
= memcached_cas(memc
, keys
[0], lengths
[0], keys
[0], lengths
[0], 0, 0, cas
);
3623 assert(ret
== MEMCACHED_SUCCESS
);
3624 assert(memcached_flush_buffers(memc
) == MEMCACHED_SUCCESS
);
3625 char* value
=memcached_get(memc
, keys
[0], lengths
[0], &length
, &flags
, &ret
);
3626 assert(ret
== MEMCACHED_SUCCESS
&& value
!= NULL
);
3629 return TEST_SUCCESS
;
3632 static test_return_t
analyzer_test(memcached_st
*memc
)
3634 memcached_return rc
;
3635 memcached_stat_st
*memc_stat
;
3636 memcached_analysis_st
*report
;
3638 memc_stat
= memcached_stat(memc
, NULL
, &rc
);
3639 assert(rc
== MEMCACHED_SUCCESS
);
3642 report
= memcached_analyze(memc
, memc_stat
, &rc
);
3643 assert(rc
== MEMCACHED_SUCCESS
);
3647 memcached_stat_free(NULL
, memc_stat
);
3649 return TEST_SUCCESS
;
3652 /* Count the objects */
3653 static memcached_return
callback_dump_counter(memcached_st
*ptr
__attribute__((unused
)),
3654 const char *key
__attribute__((unused
)),
3655 size_t key_length
__attribute__((unused
)),
3658 uint32_t *counter
= (uint32_t *)context
;
3660 *counter
= *counter
+ 1;
3662 return MEMCACHED_SUCCESS
;
3665 static test_return_t
dump_test(memcached_st
*memc
)
3667 memcached_return rc
;
3668 uint32_t counter
= 0;
3669 memcached_dump_func callbacks
[1];
3670 test_return_t main_rc
;
3672 callbacks
[0]= &callback_dump_counter
;
3674 /* No support for Binary protocol yet */
3675 if (memc
->flags
& MEM_BINARY_PROTOCOL
)
3676 return TEST_SUCCESS
;
3678 main_rc
= set_test3(memc
);
3680 assert (main_rc
== TEST_SUCCESS
);
3682 rc
= memcached_dump(memc
, callbacks
, (void *)&counter
, 1);
3683 assert(rc
== MEMCACHED_SUCCESS
);
3685 /* We may have more then 32 if our previous flush has not completed */
3686 assert(counter
>= 32);
3688 return TEST_SUCCESS
;
3691 #ifdef HAVE_LIBMEMCACHEDUTIL
3692 static void* connection_release(void *arg
) {
3694 memcached_pool_st
* pool
;
3699 assert(memcached_pool_push(resource
->pool
, resource
->mmc
) == MEMCACHED_SUCCESS
);
3703 static test_return_t
connection_pool_test(memcached_st
*memc
)
3705 memcached_pool_st
* pool
= memcached_pool_create(memc
, 5, 10);
3706 assert(pool
!= NULL
);
3707 memcached_st
* mmc
[10];
3708 memcached_return rc
;
3710 for (int x
= 0; x
< 10; ++x
) {
3711 mmc
[x
]= memcached_pool_pop(pool
, false, &rc
);
3712 assert(mmc
[x
] != NULL
);
3713 assert(rc
== MEMCACHED_SUCCESS
);
3716 assert(memcached_pool_pop(pool
, false, &rc
) == NULL
);
3717 assert(rc
== MEMCACHED_SUCCESS
);
3721 memcached_pool_st
* pool
;
3723 } item
= { .pool
= pool
, .mmc
= mmc
[9] };
3724 pthread_create(&tid
, NULL
, connection_release
, &item
);
3725 mmc
[9]= memcached_pool_pop(pool
, true, &rc
);
3726 assert(rc
== MEMCACHED_SUCCESS
);
3727 pthread_join(tid
, NULL
);
3728 assert(mmc
[9] == item
.mmc
);
3729 const char *key
= "key";
3730 size_t keylen
= strlen(key
);
3732 // verify that I can do ops with all connections
3733 rc
= memcached_set(mmc
[0], key
, keylen
, "0", 1, 0, 0);
3734 assert(rc
== MEMCACHED_SUCCESS
);
3736 for (unsigned int x
= 0; x
< 10; ++x
) {
3737 uint64_t number_value
;
3738 rc
= memcached_increment(mmc
[x
], key
, keylen
, 1, &number_value
);
3739 assert(rc
== MEMCACHED_SUCCESS
);
3740 assert(number_value
== (x
+1));
3744 for (int x
= 0; x
< 10; ++x
)
3745 assert(memcached_pool_push(pool
, mmc
[x
]) == MEMCACHED_SUCCESS
);
3748 /* verify that I can set behaviors on the pool when I don't have all
3749 * of the connections in the pool. It should however be enabled
3750 * when I push the item into the pool
3752 mmc
[0]= memcached_pool_pop(pool
, false, &rc
);
3753 assert(mmc
[0] != NULL
);
3755 rc
= memcached_pool_behavior_set(pool
, MEMCACHED_BEHAVIOR_IO_MSG_WATERMARK
, 9999);
3756 assert(rc
== MEMCACHED_SUCCESS
);
3758 mmc
[1]= memcached_pool_pop(pool
, false, &rc
);
3759 assert(mmc
[1] != NULL
);
3761 assert(memcached_behavior_get(mmc
[1], MEMCACHED_BEHAVIOR_IO_MSG_WATERMARK
) == 9999);
3762 assert(memcached_pool_push(pool
, mmc
[1]) == MEMCACHED_SUCCESS
);
3763 assert(memcached_pool_push(pool
, mmc
[0]) == MEMCACHED_SUCCESS
);
3765 mmc
[0]= memcached_pool_pop(pool
, false, &rc
);
3766 assert(memcached_behavior_get(mmc
[0], MEMCACHED_BEHAVIOR_IO_MSG_WATERMARK
) == 9999);
3767 assert(memcached_pool_push(pool
, mmc
[0]) == MEMCACHED_SUCCESS
);
3770 assert(memcached_pool_destroy(pool
) == memc
);
3771 return TEST_SUCCESS
;
3775 static test_return_t
replication_set_test(memcached_st
*memc
)
3777 memcached_return rc
;
3778 memcached_st
*memc_clone
= memcached_clone(NULL
, memc
);
3779 memcached_behavior_set(memc_clone
, MEMCACHED_BEHAVIOR_NUMBER_OF_REPLICAS
, 0);
3781 rc
= memcached_set(memc
, "bubba", 5, "0", 1, 0, 0);
3782 assert(rc
== MEMCACHED_SUCCESS
);
3785 ** We are using the quiet commands to store the replicas, so we need
3786 ** to ensure that all of them are processed before we can continue.
3787 ** In the test we go directly from storing the object to trying to
3788 ** receive the object from all of the different servers, so we
3789 ** could end up in a race condition (the memcached server hasn't yet
3790 ** processed the quiet command from the replication set when it process
3791 ** the request from the other client (created by the clone)). As a
3792 ** workaround for that we call memcached_quit to send the quit command
3793 ** to the server and wait for the response ;-) If you use the test code
3794 ** as an example for your own code, please note that you shouldn't need
3797 memcached_quit(memc
);
3800 ** "bubba" should now be stored on all of our servers. We don't have an
3801 ** easy to use API to address each individual server, so I'll just iterate
3802 ** through a bunch of "master keys" and I should most likely hit all of the
3805 for (int x
= 'a'; x
<= 'z'; ++x
)
3807 char key
[2]= { [0]= (char)x
};
3810 char *val
= memcached_get_by_key(memc_clone
, key
, 1, "bubba", 5,
3812 assert(rc
== MEMCACHED_SUCCESS
);
3813 assert(val
!= NULL
);
3817 memcached_free(memc_clone
);
3819 return TEST_SUCCESS
;
3822 static test_return_t
replication_get_test(memcached_st
*memc
)
3824 memcached_return rc
;
3827 * Don't do the following in your code. I am abusing the internal details
3828 * within the library, and this is not a supported interface.
3829 * This is to verify correct behavior in the library
3831 for (uint32_t host
= 0; host
< memc
->number_of_hosts
; ++host
)
3833 memcached_st
*memc_clone
= memcached_clone(NULL
, memc
);
3834 memc_clone
->hosts
[host
].port
= 0;
3836 for (int x
= 'a'; x
<= 'z'; ++x
)
3838 char key
[2]= { [0]= (char)x
};
3841 char *val
= memcached_get_by_key(memc_clone
, key
, 1, "bubba", 5,
3843 assert(rc
== MEMCACHED_SUCCESS
);
3844 assert(val
!= NULL
);
3848 memcached_free(memc_clone
);
3851 return TEST_SUCCESS
;
3854 static test_return_t
replication_mget_test(memcached_st
*memc
)
3856 memcached_return rc
;
3857 memcached_st
*memc_clone
= memcached_clone(NULL
, memc
);
3858 memcached_behavior_set(memc_clone
, MEMCACHED_BEHAVIOR_NUMBER_OF_REPLICAS
, 0);
3860 const char *keys
[]= { "bubba", "key1", "key2", "key3" };
3861 size_t len
[]= { 5, 4, 4, 4 };
3863 for (int x
=0; x
< 4; ++x
)
3865 rc
= memcached_set(memc
, keys
[x
], len
[x
], "0", 1, 0, 0);
3866 assert(rc
== MEMCACHED_SUCCESS
);
3870 ** We are using the quiet commands to store the replicas, so we need
3871 ** to ensure that all of them are processed before we can continue.
3872 ** In the test we go directly from storing the object to trying to
3873 ** receive the object from all of the different servers, so we
3874 ** could end up in a race condition (the memcached server hasn't yet
3875 ** processed the quiet command from the replication set when it process
3876 ** the request from the other client (created by the clone)). As a
3877 ** workaround for that we call memcached_quit to send the quit command
3878 ** to the server and wait for the response ;-) If you use the test code
3879 ** as an example for your own code, please note that you shouldn't need
3882 memcached_quit(memc
);
3885 * Don't do the following in your code. I am abusing the internal details
3886 * within the library, and this is not a supported interface.
3887 * This is to verify correct behavior in the library
3889 memcached_result_st result_obj
;
3890 for (uint32_t host
= 0; host
< memc_clone
->number_of_hosts
; host
++)
3892 memcached_st
*new_clone
= memcached_clone(NULL
, memc
);
3893 new_clone
->hosts
[host
].port
= 0;
3895 for (int x
= 'a'; x
<= 'z'; ++x
)
3897 const char key
[2]= { [0]= (const char)x
};
3899 rc
= memcached_mget_by_key(new_clone
, key
, 1, keys
, len
, 4);
3900 assert(rc
== MEMCACHED_SUCCESS
);
3902 memcached_result_st
*results
= memcached_result_create(new_clone
, &result_obj
);
3906 while ((results
= memcached_fetch_result(new_clone
, &result_obj
, &rc
)) != NULL
)
3911 memcached_result_free(&result_obj
);
3914 memcached_free(new_clone
);
3917 memcached_free(memc_clone
);
3919 return TEST_SUCCESS
;
3922 static test_return_t
replication_delete_test(memcached_st
*memc
)
3924 memcached_return rc
;
3925 memcached_st
*memc_clone
= memcached_clone(NULL
, memc
);
3926 /* Delete the items from all of the servers except 1 */
3927 uint64_t repl
= memcached_behavior_get(memc
,
3928 MEMCACHED_BEHAVIOR_NUMBER_OF_REPLICAS
);
3929 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NUMBER_OF_REPLICAS
, --repl
);
3931 const char *keys
[]= { "bubba", "key1", "key2", "key3" };
3932 size_t len
[]= { 5, 4, 4, 4 };
3934 for (int x
=0; x
< 4; ++x
)
3936 rc
= memcached_delete_by_key(memc
, keys
[0], len
[0], keys
[x
], len
[x
], 0);
3937 assert(rc
== MEMCACHED_SUCCESS
);
3941 * Don't do the following in your code. I am abusing the internal details
3942 * within the library, and this is not a supported interface.
3943 * This is to verify correct behavior in the library
3945 uint32_t hash
= memcached_generate_hash(memc
, keys
[0], len
[0]);
3946 for (uint32_t x
= 0; x
< (repl
+ 1); ++x
)
3948 memc_clone
->hosts
[hash
].port
= 0;
3949 if (++hash
== memc_clone
->number_of_hosts
)
3953 memcached_result_st result_obj
;
3954 for (uint32_t host
= 0; host
< memc_clone
->number_of_hosts
; ++host
)
3956 for (int x
= 'a'; x
<= 'z'; ++x
)
3958 const char key
[2]= { [0]= (const char)x
};
3960 rc
= memcached_mget_by_key(memc_clone
, key
, 1, keys
, len
, 4);
3961 assert(rc
== MEMCACHED_SUCCESS
);
3963 memcached_result_st
*results
= memcached_result_create(memc_clone
, &result_obj
);
3967 while ((results
= memcached_fetch_result(memc_clone
, &result_obj
, &rc
)) != NULL
)
3972 memcached_result_free(&result_obj
);
3975 memcached_free(memc_clone
);
3977 return TEST_SUCCESS
;
3980 static void increment_request_id(uint16_t *id
)
3983 if ((*id
& UDP_REQUEST_ID_THREAD_MASK
) != 0)
3987 static uint16_t *get_udp_request_ids(memcached_st
*memc
)
3989 uint16_t *ids
= malloc(sizeof(uint16_t) * memc
->number_of_hosts
);
3990 assert(ids
!= NULL
);
3993 for (x
= 0; x
< memc
->number_of_hosts
; x
++)
3994 ids
[x
]= get_udp_datagram_request_id((struct udp_datagram_header_st
*) memc
->hosts
[x
].write_buffer
);
3999 static test_return_t
post_udp_op_check(memcached_st
*memc
, uint16_t *expected_req_ids
)
4002 memcached_server_st
*cur_server
= memc
->hosts
;
4003 uint16_t *cur_req_ids
= get_udp_request_ids(memc
);
4005 for (x
= 0; x
< memc
->number_of_hosts
; x
++)
4007 assert(cur_server
[x
].cursor_active
== 0);
4008 assert(cur_req_ids
[x
] == expected_req_ids
[x
]);
4010 free(expected_req_ids
);
4013 return TEST_SUCCESS
;
4017 ** There is a little bit of a hack here, instead of removing
4018 ** the servers, I just set num host to 0 and them add then new udp servers
4020 static memcached_return
init_udp(memcached_st
*memc
)
4022 memcached_version(memc
);
4023 /* For the time being, only support udp test for >= 1.2.6 && < 1.3 */
4024 if (memc
->hosts
[0].major_version
!= 1 || memc
->hosts
[0].minor_version
!= 2
4025 || memc
->hosts
[0].micro_version
< 6)
4026 return MEMCACHED_FAILURE
;
4028 uint32_t num_hosts
= memc
->number_of_hosts
;
4030 memcached_server_st servers
[num_hosts
];
4031 memcpy(servers
, memc
->hosts
, sizeof(memcached_server_st
) * num_hosts
);
4032 for (x
= 0; x
< num_hosts
; x
++)
4033 memcached_server_free(&memc
->hosts
[x
]);
4035 memc
->number_of_hosts
= 0;
4036 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_USE_UDP
, 1);
4037 for (x
= 0; x
< num_hosts
; x
++)
4039 assert(memcached_server_add_udp(memc
, servers
[x
].hostname
, servers
[x
].port
) == MEMCACHED_SUCCESS
);
4040 assert(memc
->hosts
[x
].write_buffer_offset
== UDP_DATAGRAM_HEADER_LENGTH
);
4043 return MEMCACHED_SUCCESS
;
4046 static memcached_return
binary_init_udp(memcached_st
*memc
)
4049 return init_udp(memc
);
4052 /* Make sure that I cant add a tcp server to a udp client */
4053 static test_return_t
add_tcp_server_udp_client_test(memcached_st
*memc
)
4055 memcached_server_st server
;
4056 memcached_server_clone(&server
, &memc
->hosts
[0]);
4057 assert(memcached_server_remove(&(memc
->hosts
[0])) == MEMCACHED_SUCCESS
);
4058 assert(memcached_server_add(memc
, server
.hostname
, server
.port
) == MEMCACHED_INVALID_HOST_PROTOCOL
);
4059 return TEST_SUCCESS
;
4062 /* Make sure that I cant add a udp server to a tcp client */
4063 static test_return_t
add_udp_server_tcp_client_test(memcached_st
*memc
)
4065 memcached_server_st server
;
4066 memcached_server_clone(&server
, &memc
->hosts
[0]);
4067 assert(memcached_server_remove(&(memc
->hosts
[0])) == MEMCACHED_SUCCESS
);
4069 memcached_st tcp_client
;
4070 memcached_create(&tcp_client
);
4071 assert(memcached_server_add_udp(&tcp_client
, server
.hostname
, server
.port
) == MEMCACHED_INVALID_HOST_PROTOCOL
);
4072 return TEST_SUCCESS
;
4075 static test_return_t
set_udp_behavior_test(memcached_st
*memc
)
4078 memcached_quit(memc
);
4079 memc
->number_of_hosts
= 0;
4080 run_distribution(memc
);
4081 assert(memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_USE_UDP
, 1) == MEMCACHED_SUCCESS
);
4082 assert(memc
->flags
& MEM_USE_UDP
);
4083 assert(memc
->flags
& MEM_NOREPLY
);;
4085 assert(memc
->number_of_hosts
== 0);
4087 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_USE_UDP
,0);
4088 assert(!(memc
->flags
& MEM_USE_UDP
));
4089 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NOREPLY
,0);
4090 assert(!(memc
->flags
& MEM_NOREPLY
));
4091 return TEST_SUCCESS
;
4094 static test_return_t
udp_set_test(memcached_st
*memc
)
4097 unsigned int num_iters
= 1025; //request id rolls over at 1024
4098 for (x
= 0; x
< num_iters
;x
++)
4100 memcached_return rc
;
4101 const char *key
= "foo";
4102 const char *value
= "when we sanitize";
4103 uint16_t *expected_ids
= get_udp_request_ids(memc
);
4104 unsigned int server_key
= memcached_generate_hash(memc
,key
,strlen(key
));
4105 size_t init_offset
= memc
->hosts
[server_key
].write_buffer_offset
;
4106 rc
= memcached_set(memc
, key
, strlen(key
),
4107 value
, strlen(value
),
4108 (time_t)0, (uint32_t)0);
4109 assert(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
);
4110 /** NB, the check below assumes that if new write_ptr is less than
4111 * the original write_ptr that we have flushed. For large payloads, this
4112 * maybe an invalid assumption, but for the small payload we have it is OK
4114 if (rc
== MEMCACHED_SUCCESS
||
4115 memc
->hosts
[server_key
].write_buffer_offset
< init_offset
)
4116 increment_request_id(&expected_ids
[server_key
]);
4118 if (rc
== MEMCACHED_SUCCESS
)
4120 assert(memc
->hosts
[server_key
].write_buffer_offset
== UDP_DATAGRAM_HEADER_LENGTH
);
4124 assert(memc
->hosts
[server_key
].write_buffer_offset
!= UDP_DATAGRAM_HEADER_LENGTH
);
4125 assert(memc
->hosts
[server_key
].write_buffer_offset
<= MAX_UDP_DATAGRAM_LENGTH
);
4127 assert(post_udp_op_check(memc
,expected_ids
) == TEST_SUCCESS
);
4129 return TEST_SUCCESS
;
4132 static test_return_t
udp_buffered_set_test(memcached_st
*memc
)
4134 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_BUFFER_REQUESTS
, 1);
4135 return udp_set_test(memc
);
4138 static test_return_t
udp_set_too_big_test(memcached_st
*memc
)
4140 memcached_return rc
;
4141 const char *key
= "bar";
4142 char value
[MAX_UDP_DATAGRAM_LENGTH
];
4143 uint16_t *expected_ids
= get_udp_request_ids(memc
);
4144 rc
= memcached_set(memc
, key
, strlen(key
),
4145 value
, MAX_UDP_DATAGRAM_LENGTH
,
4146 (time_t)0, (uint32_t)0);
4147 assert(rc
== MEMCACHED_WRITE_FAILURE
);
4148 return post_udp_op_check(memc
,expected_ids
);
4151 static test_return_t
udp_delete_test(memcached_st
*memc
)
4154 unsigned int num_iters
= 1025; //request id rolls over at 1024
4155 for (x
= 0; x
< num_iters
;x
++)
4157 memcached_return rc
;
4158 const char *key
= "foo";
4159 uint16_t *expected_ids
=get_udp_request_ids(memc
);
4160 unsigned int server_key
= memcached_generate_hash(memc
, key
, strlen(key
));
4161 size_t init_offset
= memc
->hosts
[server_key
].write_buffer_offset
;
4162 rc
= memcached_delete(memc
, key
, strlen(key
), 0);
4163 assert(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
);
4164 if (rc
== MEMCACHED_SUCCESS
|| memc
->hosts
[server_key
].write_buffer_offset
< init_offset
)
4165 increment_request_id(&expected_ids
[server_key
]);
4166 if (rc
== MEMCACHED_SUCCESS
)
4167 assert(memc
->hosts
[server_key
].write_buffer_offset
== UDP_DATAGRAM_HEADER_LENGTH
);
4170 assert(memc
->hosts
[server_key
].write_buffer_offset
!= UDP_DATAGRAM_HEADER_LENGTH
);
4171 assert(memc
->hosts
[server_key
].write_buffer_offset
<= MAX_UDP_DATAGRAM_LENGTH
);
4173 assert(post_udp_op_check(memc
,expected_ids
) == TEST_SUCCESS
);
4175 return TEST_SUCCESS
;
4178 static test_return_t
udp_buffered_delete_test(memcached_st
*memc
)
4180 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_BUFFER_REQUESTS
, 1);
4181 return udp_delete_test(memc
);
4184 static test_return_t
udp_verbosity_test(memcached_st
*memc
)
4186 memcached_return rc
;
4187 uint16_t *expected_ids
= get_udp_request_ids(memc
);
4189 for (x
= 0; x
< memc
->number_of_hosts
;x
++)
4190 increment_request_id(&expected_ids
[x
]);
4192 rc
= memcached_verbosity(memc
,3);
4193 assert(rc
== MEMCACHED_SUCCESS
);
4194 return post_udp_op_check(memc
,expected_ids
);
4197 static test_return_t
udp_quit_test(memcached_st
*memc
)
4199 uint16_t *expected_ids
= get_udp_request_ids(memc
);
4200 memcached_quit(memc
);
4201 return post_udp_op_check(memc
, expected_ids
);
4204 static test_return_t
udp_flush_test(memcached_st
*memc
)
4206 memcached_return rc
;
4207 uint16_t *expected_ids
= get_udp_request_ids(memc
);
4209 for (x
= 0; x
< memc
->number_of_hosts
;x
++)
4210 increment_request_id(&expected_ids
[x
]);
4212 rc
= memcached_flush(memc
,0);
4213 assert(rc
== MEMCACHED_SUCCESS
);
4214 return post_udp_op_check(memc
,expected_ids
);
4217 static test_return_t
udp_incr_test(memcached_st
*memc
)
4219 memcached_return rc
;
4220 const char *key
= "incr";
4221 const char *value
= "1";
4222 rc
= memcached_set(memc
, key
, strlen(key
),
4223 value
, strlen(value
),
4224 (time_t)0, (uint32_t)0);
4226 assert(rc
== MEMCACHED_SUCCESS
);
4227 uint16_t *expected_ids
= get_udp_request_ids(memc
);
4228 unsigned int server_key
= memcached_generate_hash(memc
, key
, strlen(key
));
4229 increment_request_id(&expected_ids
[server_key
]);
4231 rc
= memcached_increment(memc
, key
, strlen(key
), 1, &newvalue
);
4232 assert(rc
== MEMCACHED_SUCCESS
);
4233 return post_udp_op_check(memc
, expected_ids
);
4236 static test_return_t
udp_decr_test(memcached_st
*memc
)
4238 memcached_return rc
;
4239 const char *key
= "decr";
4240 const char *value
= "1";
4241 rc
= memcached_set(memc
, key
, strlen(key
),
4242 value
, strlen(value
),
4243 (time_t)0, (uint32_t)0);
4245 assert(rc
== MEMCACHED_SUCCESS
);
4246 uint16_t *expected_ids
= get_udp_request_ids(memc
);
4247 unsigned int server_key
= memcached_generate_hash(memc
, key
, strlen(key
));
4248 increment_request_id(&expected_ids
[server_key
]);
4250 rc
= memcached_decrement(memc
, key
, strlen(key
), 1, &newvalue
);
4251 assert(rc
== MEMCACHED_SUCCESS
);
4252 return post_udp_op_check(memc
, expected_ids
);
4256 static test_return_t
udp_stat_test(memcached_st
*memc
)
4258 memcached_stat_st
* rv
= NULL
;
4259 memcached_return rc
;
4261 uint16_t *expected_ids
= get_udp_request_ids(memc
);
4262 rv
= memcached_stat(memc
, args
, &rc
);
4264 assert(rc
== MEMCACHED_NOT_SUPPORTED
);
4265 return post_udp_op_check(memc
, expected_ids
);
4268 static test_return_t
udp_version_test(memcached_st
*memc
)
4270 memcached_return rc
;
4271 uint16_t *expected_ids
= get_udp_request_ids(memc
);
4272 rc
= memcached_version(memc
);
4273 assert(rc
== MEMCACHED_NOT_SUPPORTED
);
4274 return post_udp_op_check(memc
, expected_ids
);
4277 static test_return_t
udp_get_test(memcached_st
*memc
)
4279 memcached_return rc
;
4280 const char *key
= "foo";
4282 uint16_t *expected_ids
= get_udp_request_ids(memc
);
4283 char *val
= memcached_get(memc
, key
, strlen(key
), &vlen
, (uint32_t)0, &rc
);
4284 assert(rc
== MEMCACHED_NOT_SUPPORTED
);
4285 assert(val
== NULL
);
4286 return post_udp_op_check(memc
, expected_ids
);
4289 static test_return_t
udp_mixed_io_test(memcached_st
*memc
)
4292 test_st mixed_io_ops
[] ={
4293 {"udp_set_test", 0, udp_set_test
},
4294 {"udp_set_too_big_test", 0, udp_set_too_big_test
},
4295 {"udp_delete_test", 0, udp_delete_test
},
4296 {"udp_verbosity_test", 0, udp_verbosity_test
},
4297 {"udp_quit_test", 0, udp_quit_test
},
4298 {"udp_flush_test", 0, udp_flush_test
},
4299 {"udp_incr_test", 0, udp_incr_test
},
4300 {"udp_decr_test", 0, udp_decr_test
},
4301 {"udp_version_test", 0, udp_version_test
}
4304 for (x
= 0; x
< 500; x
++)
4306 current_op
= mixed_io_ops
[random() % 9];
4307 assert(current_op
.function(memc
) == TEST_SUCCESS
);
4309 return TEST_SUCCESS
;
4312 static test_return_t
hsieh_avaibility_test (memcached_st
*memc
)
4314 memcached_return expected_rc
= MEMCACHED_FAILURE
;
4315 #ifdef HAVE_HSIEH_HASH
4316 expected_rc
= MEMCACHED_SUCCESS
;
4318 memcached_return rc
= memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_HASH
,
4319 (uint64_t)MEMCACHED_HASH_HSIEH
);
4320 assert(rc
== expected_rc
);
4321 return TEST_SUCCESS
;
4324 static const char *list
[]=
4354 static test_return_t
md5_run (memcached_st
*memc
__attribute__((unused
)))
4358 uint32_t values
[]= { 3195025439U, 2556848621U, 3724893440U, 3332385401U,
4359 245758794U, 2550894432U, 121710495U, 3053817768U,
4360 1250994555U, 1862072655U, 2631955953U, 2951528551U,
4361 1451250070U, 2820856945U, 2060845566U, 3646985608U,
4362 2138080750U, 217675895U, 2230934345U, 1234361223U,
4363 3968582726U, 2455685270U, 1293568479U, 199067604U,
4367 for (ptr
= list
, x
= 0; *ptr
; ptr
++, x
++)
4371 hash_val
= memcached_generate_hash_value(*ptr
, strlen(*ptr
), MEMCACHED_HASH_MD5
);
4372 assert(values
[x
] == hash_val
);
4375 return TEST_SUCCESS
;
4378 static test_return_t
crc_run (memcached_st
*memc
__attribute__((unused
)))
4382 uint32_t values
[]= { 10542U, 22009U, 14526U, 19510U, 19432U, 10199U, 20634U,
4383 9369U, 11511U, 10362U, 7893U, 31289U, 11313U, 9354U,
4384 7621U, 30628U, 15218U, 25967U, 2695U, 9380U,
4385 17300U, 28156U, 9192U, 20484U, 16925U };
4387 for (ptr
= list
, x
= 0; *ptr
; ptr
++, x
++)
4391 hash_val
= memcached_generate_hash_value(*ptr
, strlen(*ptr
), MEMCACHED_HASH_CRC
);
4392 assert(values
[x
] == hash_val
);
4395 return TEST_SUCCESS
;
4398 static test_return_t
fnv1_64_run (memcached_st
*memc
__attribute__((unused
)))
4402 uint32_t values
[]= { 473199127U, 4148981457U, 3971873300U, 3257986707U,
4403 1722477987U, 2991193800U, 4147007314U, 3633179701U,
4404 1805162104U, 3503289120U, 3395702895U, 3325073042U,
4405 2345265314U, 3340346032U, 2722964135U, 1173398992U,
4406 2815549194U, 2562818319U, 224996066U, 2680194749U,
4407 3035305390U, 246890365U, 2395624193U, 4145193337U,
4410 for (ptr
= list
, x
= 0; *ptr
; ptr
++, x
++)
4414 hash_val
= memcached_generate_hash_value(*ptr
, strlen(*ptr
), MEMCACHED_HASH_FNV1_64
);
4415 assert(values
[x
] == hash_val
);
4418 return TEST_SUCCESS
;
4421 static test_return_t
fnv1a_64_run (memcached_st
*memc
__attribute__((unused
)))
4425 uint32_t values
[]= { 1488911807U, 2500855813U, 1510099634U, 1390325195U,
4426 3647689787U, 3241528582U, 1669328060U, 2604311949U,
4427 734810122U, 1516407546U, 560948863U, 1767346780U,
4428 561034892U, 4156330026U, 3716417003U, 3475297030U,
4429 1518272172U, 227211583U, 3938128828U, 126112909U,
4430 3043416448U, 3131561933U, 1328739897U, 2455664041U,
4433 for (ptr
= list
, x
= 0; *ptr
; ptr
++, x
++)
4437 hash_val
= memcached_generate_hash_value(*ptr
, strlen(*ptr
), MEMCACHED_HASH_FNV1A_64
);
4438 assert(values
[x
] == hash_val
);
4441 return TEST_SUCCESS
;
4444 static test_return_t
fnv1_32_run (memcached_st
*memc
__attribute__((unused
)))
4448 uint32_t values
[]= { 67176023U, 1190179409U, 2043204404U, 3221866419U,
4449 2567703427U, 3787535528U, 4147287986U, 3500475733U,
4450 344481048U, 3865235296U, 2181839183U, 119581266U,
4451 510234242U, 4248244304U, 1362796839U, 103389328U,
4452 1449620010U, 182962511U, 3554262370U, 3206747549U,
4453 1551306158U, 4127558461U, 1889140833U, 2774173721U,
4457 for (ptr
= list
, x
= 0; *ptr
; ptr
++, x
++)
4461 hash_val
= memcached_generate_hash_value(*ptr
, strlen(*ptr
), MEMCACHED_HASH_FNV1_32
);
4462 assert(values
[x
] == hash_val
);
4465 return TEST_SUCCESS
;
4468 static test_return_t
fnv1a_32_run (memcached_st
*memc
__attribute__((unused
)))
4472 uint32_t values
[]= { 280767167U, 2421315013U, 3072375666U, 855001899U,
4473 459261019U, 3521085446U, 18738364U, 1625305005U,
4474 2162232970U, 777243802U, 3323728671U, 132336572U,
4475 3654473228U, 260679466U, 1169454059U, 2698319462U,
4476 1062177260U, 235516991U, 2218399068U, 405302637U,
4477 1128467232U, 3579622413U, 2138539289U, 96429129U,
4480 for (ptr
= list
, x
= 0; *ptr
; ptr
++, x
++)
4484 hash_val
= memcached_generate_hash_value(*ptr
, strlen(*ptr
), MEMCACHED_HASH_FNV1A_32
);
4485 assert(values
[x
] == hash_val
);
4488 return TEST_SUCCESS
;
4491 static test_return_t
hsieh_run (memcached_st
*memc
__attribute__((unused
)))
4495 #ifdef HAVE_HSIEH_HASH
4496 uint32_t values
[]= { 3738850110, 3636226060, 3821074029, 3489929160, 3485772682, 80540287,
4497 1805464076, 1895033657, 409795758, 979934958, 3634096985, 1284445480,
4498 2265380744, 707972988, 353823508, 1549198350, 1327930172, 9304163,
4499 4220749037, 2493964934, 2777873870, 2057831732, 1510213931, 2027828987,
4502 uint32_t values
[]= { 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1 };
4505 for (ptr
= list
, x
= 0; *ptr
; ptr
++, x
++)
4509 hash_val
= memcached_generate_hash_value(*ptr
, strlen(*ptr
), MEMCACHED_HASH_HSIEH
);
4510 assert(values
[x
] == hash_val
);
4513 return TEST_SUCCESS
;
4516 static test_return_t
murmur_run (memcached_st
*memc
__attribute__((unused
)))
4520 uint32_t values
[]= { 473199127U, 4148981457U, 3971873300U, 3257986707U,
4521 1722477987U, 2991193800U, 4147007314U, 3633179701U,
4522 1805162104U, 3503289120U, 3395702895U, 3325073042U,
4523 2345265314U, 3340346032U, 2722964135U, 1173398992U,
4524 2815549194U, 2562818319U, 224996066U, 2680194749U,
4525 3035305390U, 246890365U, 2395624193U, 4145193337U,
4528 for (ptr
= list
, x
= 0; *ptr
; ptr
++, x
++)
4532 hash_val
= memcached_generate_hash_value(*ptr
, strlen(*ptr
), MEMCACHED_HASH_FNV1_64
);
4533 assert(values
[x
] == hash_val
);
4536 return TEST_SUCCESS
;
4539 static test_return_t
jenkins_run (memcached_st
*memc
__attribute__((unused
)))
4543 uint32_t values
[]= { 1442444624U, 4253821186U, 1885058256U, 2120131735U,
4544 3261968576U, 3515188778U, 4232909173U, 4288625128U,
4545 1812047395U, 3689182164U, 2502979932U, 1214050606U,
4546 2415988847U, 1494268927U, 1025545760U, 3920481083U,
4547 4153263658U, 3824871822U, 3072759809U, 798622255U,
4548 3065432577U, 1453328165U, 2691550971U, 3408888387U,
4552 for (ptr
= list
, x
= 0; *ptr
; ptr
++, x
++)
4556 hash_val
= memcached_generate_hash_value(*ptr
, strlen(*ptr
), MEMCACHED_HASH_JENKINS
);
4557 assert(values
[x
] == hash_val
);
4560 return TEST_SUCCESS
;
4563 static test_return_t
regression_bug_434484(memcached_st
*memc
)
4565 if (pre_binary(memc
) != MEMCACHED_SUCCESS
)
4566 return TEST_SKIPPED
;
4568 memcached_return ret
;
4569 const char *key
= "regression_bug_434484";
4570 size_t keylen
= strlen(key
);
4572 ret
= memcached_append(memc
, key
, keylen
, key
, keylen
, 0, 0);
4573 assert(ret
== MEMCACHED_NOTSTORED
);
4575 size_t size
= 2048 * 1024;
4576 void *data
= calloc(1, size
);
4577 assert(data
!= NULL
);
4578 ret
= memcached_set(memc
, key
, keylen
, data
, size
, 0, 0);
4579 assert(ret
== MEMCACHED_E2BIG
);
4582 return TEST_SUCCESS
;
4585 static test_return_t
regression_bug_434843(memcached_st
*memc
)
4587 if (pre_binary(memc
) != MEMCACHED_SUCCESS
)
4588 return TEST_SKIPPED
;
4590 memcached_return rc
;
4591 unsigned int counter
= 0;
4592 memcached_execute_function callbacks
[1]= { [0]= &callback_counter
};
4595 * I only want to hit only _one_ server so I know the number of requests I'm
4596 * sending in the pipleine to the server. Let's try to do a multiget of
4597 * 10240 (that should satisfy most users don't you tink?)
4599 uint32_t number_of_hosts
= memc
->number_of_hosts
;
4600 memc
->number_of_hosts
= 1;
4601 const size_t max_keys
= 10240;
4602 char **keys
= calloc(max_keys
, sizeof(char*));
4603 size_t *key_length
=calloc(max_keys
, sizeof(size_t));
4605 for (int x
= 0; x
< (int)max_keys
; ++x
)
4608 key_length
[x
]= (size_t)snprintf(k
, sizeof(k
), "0200%u", x
);
4610 assert(keys
[x
] != NULL
);
4614 * Run two times.. the first time we should have 100% cache miss,
4615 * and the second time we should have 100% cache hits
4617 for (int y
= 0; y
< 2; ++y
)
4619 rc
= memcached_mget(memc
, (const char**)keys
, key_length
, max_keys
);
4620 assert(rc
== MEMCACHED_SUCCESS
);
4621 rc
= memcached_fetch_execute(memc
, callbacks
, (void *)&counter
, 1);
4624 /* The first iteration should give me a 100% cache miss. verify that*/
4625 assert(counter
== 0);
4626 char blob
[1024]= { 0 };
4627 for (int x
= 0; x
< (int)max_keys
; ++x
)
4629 rc
= memcached_add(memc
, keys
[x
], key_length
[x
],
4630 blob
, sizeof(blob
), 0, 0);
4631 assert(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
);
4636 /* Verify that we received all of the key/value pairs */
4637 assert(counter
== (unsigned int)max_keys
);
4641 /* Release allocated resources */
4642 for (size_t x
= 0; x
< max_keys
; ++x
)
4647 memc
->number_of_hosts
= number_of_hosts
;
4648 return TEST_SUCCESS
;
4651 static test_return_t
regression_bug_434843_buffered(memcached_st
*memc
)
4653 memcached_return rc
;
4654 rc
= memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_BUFFER_REQUESTS
, 1);
4655 assert(rc
== MEMCACHED_SUCCESS
);
4657 return regression_bug_434843(memc
);
4660 static test_return_t
regression_bug_421108(memcached_st
*memc
)
4662 memcached_return rc
;
4663 memcached_stat_st
*memc_stat
= memcached_stat(memc
, NULL
, &rc
);
4664 assert(rc
== MEMCACHED_SUCCESS
);
4666 char *bytes
= memcached_stat_get_value(memc
, memc_stat
, "bytes", &rc
);
4667 assert(rc
== MEMCACHED_SUCCESS
);
4668 assert(bytes
!= NULL
);
4669 char *bytes_read
= memcached_stat_get_value(memc
, memc_stat
,
4671 assert(rc
== MEMCACHED_SUCCESS
);
4672 assert(bytes_read
!= NULL
);
4674 char *bytes_written
= memcached_stat_get_value(memc
, memc_stat
,
4675 "bytes_written", &rc
);
4676 assert(rc
== MEMCACHED_SUCCESS
);
4677 assert(bytes_written
!= NULL
);
4679 assert(strcmp(bytes
, bytes_read
) != 0);
4680 assert(strcmp(bytes
, bytes_written
) != 0);
4682 /* Release allocated resources */
4685 free(bytes_written
);
4686 memcached_stat_free(NULL
, memc_stat
);
4687 return TEST_SUCCESS
;
4691 * The test case isn't obvious so I should probably document why
4692 * it works the way it does. Bug 442914 was caused by a bug
4693 * in the logic in memcached_purge (it did not handle the case
4694 * where the number of bytes sent was equal to the watermark).
4695 * In this test case, create messages so that we hit that case
4696 * and then disable noreply mode and issue a new command to
4697 * verify that it isn't stuck. If we change the format for the
4698 * delete command or the watermarks, we need to update this
4701 static test_return_t
regression_bug_442914(memcached_st
*memc
)
4703 memcached_return rc
;
4704 rc
= memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NOREPLY
, 1);
4705 assert(rc
== MEMCACHED_SUCCESS
);
4706 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_TCP_NODELAY
, 1);
4708 uint32_t number_of_hosts
= memc
->number_of_hosts
;
4709 memc
->number_of_hosts
= 1;
4714 for (int x
= 0; x
< 250; ++x
)
4716 len
= (size_t)snprintf(k
, sizeof(k
), "%0250u", x
);
4717 rc
= memcached_delete(memc
, k
, len
, 0);
4718 assert(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
);
4721 len
= (size_t)snprintf(k
, sizeof(k
), "%037u", 251);
4722 rc
= memcached_delete(memc
, k
, len
, 0);
4723 assert(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
);
4725 rc
= memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NOREPLY
, 0);
4726 assert(rc
== MEMCACHED_SUCCESS
);
4727 rc
= memcached_delete(memc
, k
, len
, 0);
4728 assert(rc
== MEMCACHED_NOTFOUND
);
4730 memc
->number_of_hosts
= number_of_hosts
;
4732 return TEST_SUCCESS
;
4737 * This tests ensures expected disconnections (for some behavior changes
4738 * for instance) do not wrongly increase failure counter
4740 static test_return_t
wrong_failure_counter_test(memcached_st
*memc
)
4742 memcached_return rc
;
4744 /* Set value to force connection to the server */
4745 const char *key
= "marmotte";
4746 const char *value
= "milka";
4747 char *string
= NULL
;
4748 size_t string_length
;
4751 rc
= memcached_set(memc
, key
, strlen(key
),
4752 value
, strlen(value
),
4753 (time_t)0, (uint32_t)0);
4754 assert(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
);
4757 /* put failure limit to 1 */
4758 rc
= memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_SERVER_FAILURE_LIMIT
, 1);
4759 assert(rc
== MEMCACHED_SUCCESS
);
4760 /* Put a retry timeout to effectively activate failure_limit effect */
4761 rc
= memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_RETRY_TIMEOUT
, 1);
4762 assert(rc
== MEMCACHED_SUCCESS
);
4763 /* change behavior that triggers memcached_quit()*/
4764 rc
= memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_TCP_NODELAY
, 1);
4765 assert(rc
== MEMCACHED_SUCCESS
);
4768 /* Check if we still are connected */
4769 string
= memcached_get(memc
, key
, strlen(key
),
4770 &string_length
, &flags
, &rc
);
4772 assert(rc
== MEMCACHED_SUCCESS
);
4776 return TEST_SUCCESS
;
4781 test_st udp_setup_server_tests
[] ={
4782 {"set_udp_behavior_test", 0, set_udp_behavior_test
},
4783 {"add_tcp_server_udp_client_test", 0, add_tcp_server_udp_client_test
},
4784 {"add_udp_server_tcp_client_test", 0, add_udp_server_tcp_client_test
},
4788 test_st upd_io_tests
[] ={
4789 {"udp_set_test", 0, udp_set_test
},
4790 {"udp_buffered_set_test", 0, udp_buffered_set_test
},
4791 {"udp_set_too_big_test", 0, udp_set_too_big_test
},
4792 {"udp_delete_test", 0, udp_delete_test
},
4793 {"udp_buffered_delete_test", 0, udp_buffered_delete_test
},
4794 {"udp_verbosity_test", 0, udp_verbosity_test
},
4795 {"udp_quit_test", 0, udp_quit_test
},
4796 {"udp_flush_test", 0, udp_flush_test
},
4797 {"udp_incr_test", 0, udp_incr_test
},
4798 {"udp_decr_test", 0, udp_decr_test
},
4799 {"udp_stat_test", 0, udp_stat_test
},
4800 {"udp_version_test", 0, udp_version_test
},
4801 {"udp_get_test", 0, udp_get_test
},
4802 {"udp_mixed_io_test", 0, udp_mixed_io_test
},
4806 /* Clean the server before beginning testing */
4808 {"flush", 0, flush_test
},
4809 {"init", 0, init_test
},
4810 {"allocation", 0, allocation_test
},
4811 {"server_list_null_test", 0, server_list_null_test
},
4812 {"server_unsort", 0, server_unsort_test
},
4813 {"server_sort", 0, server_sort_test
},
4814 {"server_sort2", 0, server_sort2_test
},
4815 {"clone_test", 0, clone_test
},
4816 {"connection_test", 0, connection_test
},
4817 {"callback_test", 0, callback_test
},
4818 {"behavior_test", 0, behavior_test
},
4819 {"userdata_test", 0, userdata_test
},
4820 {"error", 0, error_test
},
4821 {"set", 0, set_test
},
4822 {"set2", 0, set_test2
},
4823 {"set3", 0, set_test3
},
4824 {"dump", 1, dump_test
},
4825 {"add", 1, add_test
},
4826 {"replace", 1, replace_test
},
4827 {"delete", 1, delete_test
},
4828 {"get", 1, get_test
},
4829 {"get2", 0, get_test2
},
4830 {"get3", 0, get_test3
},
4831 {"get4", 0, get_test4
},
4832 {"partial mget", 0, get_test5
},
4833 {"stats_servername", 0, stats_servername_test
},
4834 {"increment", 0, increment_test
},
4835 {"increment_with_initial", 1, increment_with_initial_test
},
4836 {"decrement", 0, decrement_test
},
4837 {"decrement_with_initial", 1, decrement_with_initial_test
},
4838 {"quit", 0, quit_test
},
4839 {"mget", 1, mget_test
},
4840 {"mget_result", 1, mget_result_test
},
4841 {"mget_result_alloc", 1, mget_result_alloc_test
},
4842 {"mget_result_function", 1, mget_result_function
},
4843 {"mget_end", 0, mget_end
},
4844 {"get_stats", 0, get_stats
},
4845 {"add_host_test", 0, add_host_test
},
4846 {"add_host_test_1", 0, add_host_test1
},
4847 {"get_stats_keys", 0, get_stats_keys
},
4848 {"behavior_test", 0, get_stats_keys
},
4849 {"callback_test", 0, get_stats_keys
},
4850 {"version_string_test", 0, version_string_test
},
4851 {"bad_key", 1, bad_key_test
},
4852 {"memcached_server_cursor", 1, memcached_server_cursor_test
},
4853 {"read_through", 1, read_through
},
4854 {"delete_through", 1, delete_through
},
4855 {"noreply", 1, noreply_test
},
4856 {"analyzer", 1, analyzer_test
},
4857 #ifdef HAVE_LIBMEMCACHEDUTIL
4858 {"connectionpool", 1, connection_pool_test
},
4863 test_st async_tests
[] ={
4864 {"add", 1, add_wrapper
},
4868 test_st string_tests
[] ={
4869 {"string static with null", 0, string_static_null
},
4870 {"string alloc with null", 0, string_alloc_null
},
4871 {"string alloc with 1K", 0, string_alloc_with_size
},
4872 {"string alloc with malloc failure", 0, string_alloc_with_size_toobig
},
4873 {"string append", 0, string_alloc_append
},
4874 {"string append failure (too big)", 0, string_alloc_append_toobig
},
4878 test_st result_tests
[] ={
4879 {"result static", 0, result_static
},
4880 {"result alloc", 0, result_alloc
},
4884 test_st version_1_2_3
[] ={
4885 {"append", 0, append_test
},
4886 {"prepend", 0, prepend_test
},
4887 {"cas", 0, cas_test
},
4888 {"cas2", 0, cas2_test
},
4889 {"append_binary", 0, append_binary_test
},
4893 test_st user_tests
[] ={
4894 {"user_supplied_bug1", 0, user_supplied_bug1
},
4895 {"user_supplied_bug2", 0, user_supplied_bug2
},
4896 {"user_supplied_bug3", 0, user_supplied_bug3
},
4897 {"user_supplied_bug4", 0, user_supplied_bug4
},
4898 {"user_supplied_bug5", 1, user_supplied_bug5
},
4899 {"user_supplied_bug6", 1, user_supplied_bug6
},
4900 {"user_supplied_bug7", 1, user_supplied_bug7
},
4901 {"user_supplied_bug8", 1, user_supplied_bug8
},
4902 {"user_supplied_bug9", 1, user_supplied_bug9
},
4903 {"user_supplied_bug10", 1, user_supplied_bug10
},
4904 {"user_supplied_bug11", 1, user_supplied_bug11
},
4905 {"user_supplied_bug12", 1, user_supplied_bug12
},
4906 {"user_supplied_bug13", 1, user_supplied_bug13
},
4907 {"user_supplied_bug14", 1, user_supplied_bug14
},
4908 {"user_supplied_bug15", 1, user_supplied_bug15
},
4909 {"user_supplied_bug16", 1, user_supplied_bug16
},
4912 ** It seems to be something weird with the character sets..
4913 ** value_fetch is unable to parse the value line (iscntrl "fails"), so I
4914 ** guess I need to find out how this is supposed to work.. Perhaps I need
4915 ** to run the test in a specific locale (I tried zh_CN.UTF-8 without success,
4916 ** so just disable the code for now...).
4918 {"user_supplied_bug17", 1, user_supplied_bug17
},
4920 {"user_supplied_bug18", 1, user_supplied_bug18
},
4921 {"user_supplied_bug19", 1, user_supplied_bug19
},
4922 {"user_supplied_bug20", 1, user_supplied_bug20
},
4923 {"user_supplied_bug21", 1, user_supplied_bug21
},
4924 {"wrong_failure_counter_test", 1, wrong_failure_counter_test
},
4928 test_st replication_tests
[]= {
4929 {"set", 1, replication_set_test
},
4930 {"get", 0, replication_get_test
},
4931 {"mget", 0, replication_mget_test
},
4932 {"delete", 0, replication_delete_test
},
4937 * The following test suite is used to verify that we don't introduce
4938 * regression bugs. If you want more information about the bug / test,
4939 * you should look in the bug report at
4940 * http://bugs.launchpad.net/libmemcached
4942 test_st regression_tests
[]= {
4943 {"lp:434484", 1, regression_bug_434484
},
4944 {"lp:434843", 1, regression_bug_434843
},
4945 {"lp:434843 buffered", 1, regression_bug_434843_buffered
},
4946 {"lp:421108", 1, regression_bug_421108
},
4947 {"lp:442914", 1, regression_bug_442914
},
4951 test_st generate_tests
[] ={
4952 {"generate_pairs", 1, generate_pairs
},
4953 {"generate_data", 1, generate_data
},
4954 {"get_read", 0, get_read
},
4955 {"delete_generate", 0, delete_generate
},
4956 {"generate_buffer_data", 1, generate_buffer_data
},
4957 {"delete_buffer", 0, delete_buffer_generate
},
4958 {"generate_data", 1, generate_data
},
4959 {"mget_read", 0, mget_read
},
4960 {"mget_read_result", 0, mget_read_result
},
4961 {"mget_read_function", 0, mget_read_function
},
4962 {"cleanup", 1, cleanup_pairs
},
4963 {"generate_large_pairs", 1, generate_large_pairs
},
4964 {"generate_data", 1, generate_data
},
4965 {"generate_buffer_data", 1, generate_buffer_data
},
4966 {"cleanup", 1, cleanup_pairs
},
4970 test_st consistent_tests
[] ={
4971 {"generate_pairs", 1, generate_pairs
},
4972 {"generate_data", 1, generate_data
},
4973 {"get_read", 0, get_read_count
},
4974 {"cleanup", 1, cleanup_pairs
},
4978 test_st consistent_weighted_tests
[] ={
4979 {"generate_pairs", 1, generate_pairs
},
4980 {"generate_data", 1, generate_data_with_stats
},
4981 {"get_read", 0, get_read_count
},
4982 {"cleanup", 1, cleanup_pairs
},
4986 test_st hsieh_availability
[] ={
4987 {"hsieh_avaibility_test",0,hsieh_avaibility_test
},
4991 test_st ketama_auto_eject_hosts
[] ={
4992 {"auto_eject_hosts", 1, auto_eject_hosts
},
4996 test_st hash_tests
[] ={
4997 {"md5", 0, md5_run
},
4998 {"crc", 0, crc_run
},
4999 {"fnv1_64", 0, fnv1_64_run
},
5000 {"fnv1a_64", 0, fnv1a_64_run
},
5001 {"fnv1_32", 0, fnv1_32_run
},
5002 {"fnv1a_32", 0, fnv1a_32_run
},
5003 {"hsieh", 0, hsieh_run
},
5004 {"murmur", 0, murmur_run
},
5005 {"jenkis", 0, jenkins_run
},
5009 collection_st collection
[] ={
5010 {"hsieh_availability",0,0,hsieh_availability
},
5011 {"udp_setup", init_udp
, 0, udp_setup_server_tests
},
5012 {"udp_io", init_udp
, 0, upd_io_tests
},
5013 {"udp_binary_io", binary_init_udp
, 0, upd_io_tests
},
5014 {"block", 0, 0, tests
},
5015 {"binary", pre_binary
, 0, tests
},
5016 {"nonblock", pre_nonblock
, 0, tests
},
5017 {"nodelay", pre_nodelay
, 0, tests
},
5018 {"settimer", pre_settimer
, 0, tests
},
5019 {"md5", pre_md5
, 0, tests
},
5020 {"crc", pre_crc
, 0, tests
},
5021 {"hsieh", pre_hsieh
, 0, tests
},
5022 {"jenkins", pre_jenkins
, 0, tests
},
5023 {"fnv1_64", pre_hash_fnv1_64
, 0, tests
},
5024 {"fnv1a_64", pre_hash_fnv1a_64
, 0, tests
},
5025 {"fnv1_32", pre_hash_fnv1_32
, 0, tests
},
5026 {"fnv1a_32", pre_hash_fnv1a_32
, 0, tests
},
5027 {"ketama", pre_behavior_ketama
, 0, tests
},
5028 {"ketama_auto_eject_hosts", pre_behavior_ketama
, 0, ketama_auto_eject_hosts
},
5029 {"unix_socket", pre_unix_socket
, 0, tests
},
5030 {"unix_socket_nodelay", pre_nodelay
, 0, tests
},
5031 {"poll_timeout", poll_timeout
, 0, tests
},
5032 {"gets", enable_cas
, 0, tests
},
5033 {"consistent", enable_consistent
, 0, tests
},
5034 #ifdef MEMCACHED_ENABLE_DEPRECATED
5035 {"deprecated_memory_allocators", deprecated_set_memory_alloc
, 0, tests
},
5037 {"memory_allocators", set_memory_alloc
, 0, tests
},
5038 {"prefix", set_prefix
, 0, tests
},
5039 {"version_1_2_3", check_for_1_2_3
, 0, version_1_2_3
},
5040 {"string", 0, 0, string_tests
},
5041 {"result", 0, 0, result_tests
},
5042 {"async", pre_nonblock
, 0, async_tests
},
5043 {"async_binary", pre_nonblock_binary
, 0, async_tests
},
5044 {"user", 0, 0, user_tests
},
5045 {"generate", 0, 0, generate_tests
},
5046 {"generate_hsieh", pre_hsieh
, 0, generate_tests
},
5047 {"generate_ketama", pre_behavior_ketama
, 0, generate_tests
},
5048 {"generate_hsieh_consistent", enable_consistent
, 0, generate_tests
},
5049 {"generate_md5", pre_md5
, 0, generate_tests
},
5050 {"generate_murmur", pre_murmur
, 0, generate_tests
},
5051 {"generate_jenkins", pre_jenkins
, 0, generate_tests
},
5052 {"generate_nonblock", pre_nonblock
, 0, generate_tests
},
5053 {"consistent_not", 0, 0, consistent_tests
},
5054 {"consistent_ketama", pre_behavior_ketama
, 0, consistent_tests
},
5055 {"consistent_ketama_weighted", pre_behavior_ketama_weighted
, 0, consistent_weighted_tests
},
5056 {"test_hashes", 0, 0, hash_tests
},
5057 {"replication", pre_replication
, 0, replication_tests
},
5058 {"replication_noblock", pre_replication_noblock
, 0, replication_tests
},
5059 {"regression", 0, 0, regression_tests
},
5063 #define SERVERS_TO_CREATE 5
5065 /* Prototypes for functions we will pass to test framework */
5066 void *world_create(void);
5067 void world_destroy(void *p
);
5069 void *world_create(void)
5071 server_startup_st
*construct
;
5073 construct
= calloc(sizeof(server_startup_st
), 1);
5074 construct
->count
= SERVERS_TO_CREATE
;
5076 server_startup(construct
);
5082 void world_destroy(void *p
)
5084 server_startup_st
*construct
= (server_startup_st
*)p
;
5085 memcached_server_st
*servers
= (memcached_server_st
*)construct
->servers
;
5086 memcached_server_list_free(servers
);
5088 server_shutdown(construct
);
5092 void get_world(world_st
*world
)
5094 world
->collections
= collection
;
5095 world
->create
= world_create
;
5096 world
->destroy
= world_destroy
;