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 if (pre_binary(memc
) != MEMCACHED_SUCCESS
)
3221 return MEMCACHED_FAILURE
;
3224 * Make sure that we store the item on all servers
3225 * (master + replicas == number of servers)
3227 memcached_return rc
;
3228 rc
= memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NUMBER_OF_REPLICAS
,
3229 memc
->number_of_hosts
- 1);
3230 assert(rc
== MEMCACHED_SUCCESS
);
3231 assert(memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_NUMBER_OF_REPLICAS
) == memc
->number_of_hosts
- 1);
3236 static memcached_return
pre_replication_noblock(memcached_st
*memc
)
3238 memcached_return rc
= MEMCACHED_FAILURE
;
3239 if (pre_replication(memc
) == MEMCACHED_SUCCESS
&&
3240 pre_nonblock(memc
) == MEMCACHED_SUCCESS
)
3241 rc
= MEMCACHED_SUCCESS
;
3246 static void my_free(memcached_st
*ptr
__attribute__((unused
)), void *mem
)
3251 static void *my_malloc(memcached_st
*ptr
__attribute__((unused
)), const size_t size
)
3253 void *ret
= malloc(size
);
3255 memset(ret
, 0xff, size
);
3260 static void *my_realloc(memcached_st
*ptr
__attribute__((unused
)), void *mem
, const size_t size
)
3262 return realloc(mem
, size
);
3265 static void *my_calloc(memcached_st
*ptr
__attribute__((unused
)), size_t nelem
, const size_t size
)
3267 return calloc(nelem
, size
);
3270 static memcached_return
set_prefix(memcached_st
*memc
)
3272 memcached_return rc
;
3273 const char *key
= "mine";
3276 /* Make sure be default none exists */
3277 value
= memcached_callback_get(memc
, MEMCACHED_CALLBACK_PREFIX_KEY
, &rc
);
3278 assert(rc
== MEMCACHED_FAILURE
);
3280 /* Test a clean set */
3281 rc
= memcached_callback_set(memc
, MEMCACHED_CALLBACK_PREFIX_KEY
, (void *)key
);
3282 assert(rc
== MEMCACHED_SUCCESS
);
3284 value
= memcached_callback_get(memc
, MEMCACHED_CALLBACK_PREFIX_KEY
, &rc
);
3285 assert(memcmp(value
, key
, 4) == 0);
3286 assert(rc
== MEMCACHED_SUCCESS
);
3288 /* Test that we can turn it off */
3289 rc
= memcached_callback_set(memc
, MEMCACHED_CALLBACK_PREFIX_KEY
, NULL
);
3290 assert(rc
== MEMCACHED_SUCCESS
);
3292 value
= memcached_callback_get(memc
, MEMCACHED_CALLBACK_PREFIX_KEY
, &rc
);
3293 assert(rc
== MEMCACHED_FAILURE
);
3295 /* Now setup for main test */
3296 rc
= memcached_callback_set(memc
, MEMCACHED_CALLBACK_PREFIX_KEY
, (void *)key
);
3297 assert(rc
== MEMCACHED_SUCCESS
);
3299 value
= memcached_callback_get(memc
, MEMCACHED_CALLBACK_PREFIX_KEY
, &rc
);
3300 assert(rc
== MEMCACHED_SUCCESS
);
3301 assert(memcmp(value
, key
, 4) == 0);
3303 /* Set to Zero, and then Set to something too large */
3306 memset(long_key
, 0, 255);
3308 rc
= memcached_callback_set(memc
, MEMCACHED_CALLBACK_PREFIX_KEY
, NULL
);
3309 assert(rc
== MEMCACHED_SUCCESS
);
3311 value
= memcached_callback_get(memc
, MEMCACHED_CALLBACK_PREFIX_KEY
, &rc
);
3312 assert(rc
== MEMCACHED_FAILURE
);
3313 assert(value
== NULL
);
3315 /* Test a long key for failure */
3316 /* TODO, extend test to determine based on setting, what result should be */
3317 strcpy(long_key
, "Thisismorethentheallottednumberofcharacters");
3318 rc
= memcached_callback_set(memc
, MEMCACHED_CALLBACK_PREFIX_KEY
, long_key
);
3319 //assert(rc == MEMCACHED_BAD_KEY_PROVIDED);
3320 assert(rc
== MEMCACHED_SUCCESS
);
3322 /* Now test a key with spaces (which will fail from long key, since bad key is not set) */
3323 strcpy(long_key
, "This is more then the allotted number of characters");
3324 rc
= memcached_callback_set(memc
, MEMCACHED_CALLBACK_PREFIX_KEY
, long_key
);
3325 assert(rc
== MEMCACHED_BAD_KEY_PROVIDED
);
3327 /* Test for a bad prefix, but with a short key */
3328 rc
= memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_VERIFY_KEY
, 1);
3329 assert(rc
== MEMCACHED_SUCCESS
);
3331 strcpy(long_key
, "dog cat");
3332 rc
= memcached_callback_set(memc
, MEMCACHED_CALLBACK_PREFIX_KEY
, long_key
);
3333 assert(rc
== MEMCACHED_BAD_KEY_PROVIDED
);
3336 return MEMCACHED_SUCCESS
;
3339 #ifdef MEMCACHED_ENABLE_DEPRECATED
3340 static memcached_return
deprecated_set_memory_alloc(memcached_st
*memc
)
3342 void *test_ptr
= NULL
;
3345 memcached_malloc_function malloc_cb
=
3346 (memcached_malloc_function
)my_malloc
;
3347 cb_ptr
= *(void **)&malloc_cb
;
3348 memcached_return rc
;
3350 rc
= memcached_callback_set(memc
, MEMCACHED_CALLBACK_MALLOC_FUNCTION
, cb_ptr
);
3351 assert(rc
== MEMCACHED_SUCCESS
);
3352 test_ptr
= memcached_callback_get(memc
, MEMCACHED_CALLBACK_MALLOC_FUNCTION
, &rc
);
3353 assert(rc
== MEMCACHED_SUCCESS
);
3354 assert(test_ptr
== cb_ptr
);
3358 memcached_realloc_function realloc_cb
=
3359 (memcached_realloc_function
)my_realloc
;
3360 cb_ptr
= *(void **)&realloc_cb
;
3361 memcached_return rc
;
3363 rc
= memcached_callback_set(memc
, MEMCACHED_CALLBACK_REALLOC_FUNCTION
, cb_ptr
);
3364 assert(rc
== MEMCACHED_SUCCESS
);
3365 test_ptr
= memcached_callback_get(memc
, MEMCACHED_CALLBACK_REALLOC_FUNCTION
, &rc
);
3366 assert(rc
== MEMCACHED_SUCCESS
);
3367 assert(test_ptr
== cb_ptr
);
3371 memcached_free_function free_cb
=
3372 (memcached_free_function
)my_free
;
3373 cb_ptr
= *(void **)&free_cb
;
3374 memcached_return rc
;
3376 rc
= memcached_callback_set(memc
, MEMCACHED_CALLBACK_FREE_FUNCTION
, cb_ptr
);
3377 assert(rc
== MEMCACHED_SUCCESS
);
3378 test_ptr
= memcached_callback_get(memc
, MEMCACHED_CALLBACK_FREE_FUNCTION
, &rc
);
3379 assert(rc
== MEMCACHED_SUCCESS
);
3380 assert(test_ptr
== cb_ptr
);
3382 return MEMCACHED_SUCCESS
;
3386 static memcached_return
set_memory_alloc(memcached_st
*memc
)
3388 memcached_return rc
;
3389 rc
= memcached_set_memory_allocators(memc
, NULL
, my_free
,
3390 my_realloc
, my_calloc
);
3391 assert(rc
== MEMCACHED_FAILURE
);
3393 rc
= memcached_set_memory_allocators(memc
, my_malloc
, my_free
,
3394 my_realloc
, my_calloc
);
3396 memcached_malloc_function mem_malloc
;
3397 memcached_free_function mem_free
;
3398 memcached_realloc_function mem_realloc
;
3399 memcached_calloc_function mem_calloc
;
3400 memcached_get_memory_allocators(memc
, &mem_malloc
, &mem_free
,
3401 &mem_realloc
, &mem_calloc
);
3403 assert(mem_malloc
== my_malloc
);
3404 assert(mem_realloc
== my_realloc
);
3405 assert(mem_calloc
== my_calloc
);
3406 assert(mem_free
== my_free
);
3408 return MEMCACHED_SUCCESS
;
3411 static memcached_return
enable_consistent(memcached_st
*memc
)
3413 memcached_server_distribution value
= MEMCACHED_DISTRIBUTION_CONSISTENT
;
3414 memcached_hash hash
;
3415 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_DISTRIBUTION
, value
);
3416 if (pre_hsieh(memc
) != MEMCACHED_SUCCESS
)
3417 return MEMCACHED_FAILURE
;
3419 value
= (memcached_server_distribution
)memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_DISTRIBUTION
);
3420 assert(value
== MEMCACHED_DISTRIBUTION_CONSISTENT
);
3422 hash
= (memcached_hash
)memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_HASH
);
3423 assert(hash
== MEMCACHED_HASH_HSIEH
);
3426 return MEMCACHED_SUCCESS
;
3429 static memcached_return
enable_cas(memcached_st
*memc
)
3431 unsigned int set
= 1;
3433 memcached_version(memc
);
3435 if ((memc
->hosts
[0].major_version
>= 1 && (memc
->hosts
[0].minor_version
== 2 && memc
->hosts
[0].micro_version
>= 4))
3436 || memc
->hosts
[0].minor_version
> 2)
3438 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_SUPPORT_CAS
, set
);
3440 return MEMCACHED_SUCCESS
;
3443 return MEMCACHED_FAILURE
;
3446 static memcached_return
check_for_1_2_3(memcached_st
*memc
)
3448 memcached_version(memc
);
3450 if ((memc
->hosts
[0].major_version
>= 1 && (memc
->hosts
[0].minor_version
== 2 && memc
->hosts
[0].micro_version
>= 4))
3451 || memc
->hosts
[0].minor_version
> 2)
3452 return MEMCACHED_SUCCESS
;
3454 return MEMCACHED_FAILURE
;
3457 static memcached_return
pre_unix_socket(memcached_st
*memc
)
3459 memcached_return rc
;
3462 memcached_server_list_free(memc
->hosts
);
3464 memc
->number_of_hosts
= 0;
3466 if (stat("/tmp/memcached.socket", &buf
))
3467 return MEMCACHED_FAILURE
;
3469 rc
= memcached_server_add_unix_socket_with_weight(memc
, "/tmp/memcached.socket", 0);
3474 static memcached_return
pre_nodelay(memcached_st
*memc
)
3476 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NO_BLOCK
, 0);
3477 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_TCP_NODELAY
, 0);
3479 return MEMCACHED_SUCCESS
;
3482 static memcached_return
pre_settimer(memcached_st
*memc
)
3484 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_SND_TIMEOUT
, 1000);
3485 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_RCV_TIMEOUT
, 1000);
3487 return MEMCACHED_SUCCESS
;
3490 static memcached_return
poll_timeout(memcached_st
*memc
)
3496 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_POLL_TIMEOUT
, timeout
);
3498 timeout
= (size_t)memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_POLL_TIMEOUT
);
3500 assert(timeout
== 100);
3502 return MEMCACHED_SUCCESS
;
3505 static test_return_t
noreply_test(memcached_st
*memc
)
3507 memcached_return ret
;
3508 ret
= memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NOREPLY
, 1);
3509 assert(ret
== MEMCACHED_SUCCESS
);
3510 ret
= memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_BUFFER_REQUESTS
, 1);
3511 assert(ret
== MEMCACHED_SUCCESS
);
3512 ret
= memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_SUPPORT_CAS
, 1);
3513 assert(ret
== MEMCACHED_SUCCESS
);
3514 assert(memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_NOREPLY
) == 1);
3515 assert(memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_BUFFER_REQUESTS
) == 1);
3516 assert(memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_SUPPORT_CAS
) == 1);
3518 for (int count
=0; count
< 5; ++count
)
3520 for (int x
=0; x
< 100; ++x
)
3523 size_t len
= (size_t)sprintf(key
, "%d", x
);
3527 ret
=memcached_add(memc
, key
, len
, key
, len
, 0, 0);
3530 ret
=memcached_replace(memc
, key
, len
, key
, len
, 0, 0);
3533 ret
=memcached_set(memc
, key
, len
, key
, len
, 0, 0);
3536 ret
=memcached_append(memc
, key
, len
, key
, len
, 0, 0);
3539 ret
=memcached_prepend(memc
, key
, len
, key
, len
, 0, 0);
3545 assert(ret
== MEMCACHED_SUCCESS
|| ret
== MEMCACHED_BUFFERED
);
3549 ** NOTE: Don't ever do this in your code! this is not a supported use of the
3550 ** API and is _ONLY_ done this way to verify that the library works the
3551 ** way it is supposed to do!!!!
3554 for (uint32_t x
=0; x
< memc
->number_of_hosts
; ++x
)
3555 no_msg
+=(int)(memc
->hosts
[x
].cursor_active
);
3557 assert(no_msg
== 0);
3558 assert(memcached_flush_buffers(memc
) == MEMCACHED_SUCCESS
);
3561 ** Now validate that all items was set properly!
3563 for (int x
=0; x
< 100; ++x
)
3566 size_t len
= (size_t)sprintf(key
, "%d", x
);
3569 char* value
=memcached_get(memc
, key
, strlen(key
),
3570 &length
, &flags
, &ret
);
3571 assert(ret
== MEMCACHED_SUCCESS
&& value
!= NULL
);
3574 case 0: /* FALLTHROUGH */
3575 case 1: /* FALLTHROUGH */
3577 assert(strncmp(value
, key
, len
) == 0);
3578 assert(len
== length
);
3581 assert(length
== len
* 2);
3584 assert(length
== len
* 3);
3594 /* Try setting an illegal cas value (should not return an error to
3595 * the caller (because we don't expect a return message from the server)
3597 const char* keys
[]= {"0"};
3598 size_t lengths
[]= {1};
3601 memcached_result_st results_obj
;
3602 memcached_result_st
*results
;
3603 ret
= memcached_mget(memc
, keys
, lengths
, 1);
3604 assert(ret
== MEMCACHED_SUCCESS
);
3606 results
= memcached_result_create(memc
, &results_obj
);
3608 results
= memcached_fetch_result(memc
, &results_obj
, &ret
);
3610 assert(ret
== MEMCACHED_SUCCESS
);
3611 uint64_t cas
= memcached_result_cas(results
);
3612 memcached_result_free(&results_obj
);
3614 ret
= memcached_cas(memc
, keys
[0], lengths
[0], keys
[0], lengths
[0], 0, 0, cas
);
3615 assert(ret
== MEMCACHED_SUCCESS
);
3618 * The item will have a new cas value, so try to set it again with the old
3619 * value. This should fail!
3621 ret
= memcached_cas(memc
, keys
[0], lengths
[0], keys
[0], lengths
[0], 0, 0, cas
);
3622 assert(ret
== MEMCACHED_SUCCESS
);
3623 assert(memcached_flush_buffers(memc
) == MEMCACHED_SUCCESS
);
3624 char* value
=memcached_get(memc
, keys
[0], lengths
[0], &length
, &flags
, &ret
);
3625 assert(ret
== MEMCACHED_SUCCESS
&& value
!= NULL
);
3628 return TEST_SUCCESS
;
3631 static test_return_t
analyzer_test(memcached_st
*memc
)
3633 memcached_return rc
;
3634 memcached_stat_st
*memc_stat
;
3635 memcached_analysis_st
*report
;
3637 memc_stat
= memcached_stat(memc
, NULL
, &rc
);
3638 assert(rc
== MEMCACHED_SUCCESS
);
3641 report
= memcached_analyze(memc
, memc_stat
, &rc
);
3642 assert(rc
== MEMCACHED_SUCCESS
);
3646 memcached_stat_free(NULL
, memc_stat
);
3648 return TEST_SUCCESS
;
3651 /* Count the objects */
3652 static memcached_return
callback_dump_counter(memcached_st
*ptr
__attribute__((unused
)),
3653 const char *key
__attribute__((unused
)),
3654 size_t key_length
__attribute__((unused
)),
3657 uint32_t *counter
= (uint32_t *)context
;
3659 *counter
= *counter
+ 1;
3661 return MEMCACHED_SUCCESS
;
3664 static test_return_t
dump_test(memcached_st
*memc
)
3666 memcached_return rc
;
3667 uint32_t counter
= 0;
3668 memcached_dump_func callbacks
[1];
3669 test_return_t main_rc
;
3671 callbacks
[0]= &callback_dump_counter
;
3673 /* No support for Binary protocol yet */
3674 if (memc
->flags
& MEM_BINARY_PROTOCOL
)
3675 return TEST_SUCCESS
;
3677 main_rc
= set_test3(memc
);
3679 assert (main_rc
== TEST_SUCCESS
);
3681 rc
= memcached_dump(memc
, callbacks
, (void *)&counter
, 1);
3682 assert(rc
== MEMCACHED_SUCCESS
);
3684 /* We may have more then 32 if our previous flush has not completed */
3685 assert(counter
>= 32);
3687 return TEST_SUCCESS
;
3690 #ifdef HAVE_LIBMEMCACHEDUTIL
3691 static void* connection_release(void *arg
) {
3693 memcached_pool_st
* pool
;
3698 assert(memcached_pool_push(resource
->pool
, resource
->mmc
) == MEMCACHED_SUCCESS
);
3702 static test_return_t
connection_pool_test(memcached_st
*memc
)
3704 memcached_pool_st
* pool
= memcached_pool_create(memc
, 5, 10);
3705 assert(pool
!= NULL
);
3706 memcached_st
* mmc
[10];
3707 memcached_return rc
;
3709 for (int x
= 0; x
< 10; ++x
) {
3710 mmc
[x
]= memcached_pool_pop(pool
, false, &rc
);
3711 assert(mmc
[x
] != NULL
);
3712 assert(rc
== MEMCACHED_SUCCESS
);
3715 assert(memcached_pool_pop(pool
, false, &rc
) == NULL
);
3716 assert(rc
== MEMCACHED_SUCCESS
);
3720 memcached_pool_st
* pool
;
3722 } item
= { .pool
= pool
, .mmc
= mmc
[9] };
3723 pthread_create(&tid
, NULL
, connection_release
, &item
);
3724 mmc
[9]= memcached_pool_pop(pool
, true, &rc
);
3725 assert(rc
== MEMCACHED_SUCCESS
);
3726 pthread_join(tid
, NULL
);
3727 assert(mmc
[9] == item
.mmc
);
3728 const char *key
= "key";
3729 size_t keylen
= strlen(key
);
3731 // verify that I can do ops with all connections
3732 rc
= memcached_set(mmc
[0], key
, keylen
, "0", 1, 0, 0);
3733 assert(rc
== MEMCACHED_SUCCESS
);
3735 for (unsigned int x
= 0; x
< 10; ++x
) {
3736 uint64_t number_value
;
3737 rc
= memcached_increment(mmc
[x
], key
, keylen
, 1, &number_value
);
3738 assert(rc
== MEMCACHED_SUCCESS
);
3739 assert(number_value
== (x
+1));
3743 for (int x
= 0; x
< 10; ++x
)
3744 assert(memcached_pool_push(pool
, mmc
[x
]) == MEMCACHED_SUCCESS
);
3747 /* verify that I can set behaviors on the pool when I don't have all
3748 * of the connections in the pool. It should however be enabled
3749 * when I push the item into the pool
3751 mmc
[0]= memcached_pool_pop(pool
, false, &rc
);
3752 assert(mmc
[0] != NULL
);
3754 rc
= memcached_pool_behavior_set(pool
, MEMCACHED_BEHAVIOR_IO_MSG_WATERMARK
, 9999);
3755 assert(rc
== MEMCACHED_SUCCESS
);
3757 mmc
[1]= memcached_pool_pop(pool
, false, &rc
);
3758 assert(mmc
[1] != NULL
);
3760 assert(memcached_behavior_get(mmc
[1], MEMCACHED_BEHAVIOR_IO_MSG_WATERMARK
) == 9999);
3761 assert(memcached_pool_push(pool
, mmc
[1]) == MEMCACHED_SUCCESS
);
3762 assert(memcached_pool_push(pool
, mmc
[0]) == MEMCACHED_SUCCESS
);
3764 mmc
[0]= memcached_pool_pop(pool
, false, &rc
);
3765 assert(memcached_behavior_get(mmc
[0], MEMCACHED_BEHAVIOR_IO_MSG_WATERMARK
) == 9999);
3766 assert(memcached_pool_push(pool
, mmc
[0]) == MEMCACHED_SUCCESS
);
3769 assert(memcached_pool_destroy(pool
) == memc
);
3770 return TEST_SUCCESS
;
3774 static test_return_t
replication_set_test(memcached_st
*memc
)
3776 memcached_return rc
;
3777 memcached_st
*memc_clone
= memcached_clone(NULL
, memc
);
3778 memcached_behavior_set(memc_clone
, MEMCACHED_BEHAVIOR_NUMBER_OF_REPLICAS
, 0);
3780 rc
= memcached_set(memc
, "bubba", 5, "0", 1, 0, 0);
3781 assert(rc
== MEMCACHED_SUCCESS
);
3784 ** We are using the quiet commands to store the replicas, so we need
3785 ** to ensure that all of them are processed before we can continue.
3786 ** In the test we go directly from storing the object to trying to
3787 ** receive the object from all of the different servers, so we
3788 ** could end up in a race condition (the memcached server hasn't yet
3789 ** processed the quiet command from the replication set when it process
3790 ** the request from the other client (created by the clone)). As a
3791 ** workaround for that we call memcached_quit to send the quit command
3792 ** to the server and wait for the response ;-) If you use the test code
3793 ** as an example for your own code, please note that you shouldn't need
3796 memcached_quit(memc
);
3799 ** "bubba" should now be stored on all of our servers. We don't have an
3800 ** easy to use API to address each individual server, so I'll just iterate
3801 ** through a bunch of "master keys" and I should most likely hit all of the
3804 for (int x
= 'a'; x
<= 'z'; ++x
)
3806 char key
[2]= { [0]= (char)x
};
3809 char *val
= memcached_get_by_key(memc_clone
, key
, 1, "bubba", 5,
3811 assert(rc
== MEMCACHED_SUCCESS
);
3812 assert(val
!= NULL
);
3816 memcached_free(memc_clone
);
3818 return TEST_SUCCESS
;
3821 static test_return_t
replication_get_test(memcached_st
*memc
)
3823 memcached_return rc
;
3826 * Don't do the following in your code. I am abusing the internal details
3827 * within the library, and this is not a supported interface.
3828 * This is to verify correct behavior in the library
3830 for (uint32_t host
= 0; host
< memc
->number_of_hosts
; ++host
)
3832 memcached_st
*memc_clone
= memcached_clone(NULL
, memc
);
3833 memc_clone
->hosts
[host
].port
= 0;
3835 for (int x
= 'a'; x
<= 'z'; ++x
)
3837 char key
[2]= { [0]= (char)x
};
3840 char *val
= memcached_get_by_key(memc_clone
, key
, 1, "bubba", 5,
3842 assert(rc
== MEMCACHED_SUCCESS
);
3843 assert(val
!= NULL
);
3847 memcached_free(memc_clone
);
3850 return TEST_SUCCESS
;
3853 static test_return_t
replication_mget_test(memcached_st
*memc
)
3855 memcached_return rc
;
3856 memcached_st
*memc_clone
= memcached_clone(NULL
, memc
);
3857 memcached_behavior_set(memc_clone
, MEMCACHED_BEHAVIOR_NUMBER_OF_REPLICAS
, 0);
3859 const char *keys
[]= { "bubba", "key1", "key2", "key3" };
3860 size_t len
[]= { 5, 4, 4, 4 };
3862 for (int x
=0; x
< 4; ++x
)
3864 rc
= memcached_set(memc
, keys
[x
], len
[x
], "0", 1, 0, 0);
3865 assert(rc
== MEMCACHED_SUCCESS
);
3869 ** We are using the quiet commands to store the replicas, so we need
3870 ** to ensure that all of them are processed before we can continue.
3871 ** In the test we go directly from storing the object to trying to
3872 ** receive the object from all of the different servers, so we
3873 ** could end up in a race condition (the memcached server hasn't yet
3874 ** processed the quiet command from the replication set when it process
3875 ** the request from the other client (created by the clone)). As a
3876 ** workaround for that we call memcached_quit to send the quit command
3877 ** to the server and wait for the response ;-) If you use the test code
3878 ** as an example for your own code, please note that you shouldn't need
3881 memcached_quit(memc
);
3884 * Don't do the following in your code. I am abusing the internal details
3885 * within the library, and this is not a supported interface.
3886 * This is to verify correct behavior in the library
3888 memcached_result_st result_obj
;
3889 for (uint32_t host
= 0; host
< memc_clone
->number_of_hosts
; host
++)
3891 memcached_st
*new_clone
= memcached_clone(NULL
, memc
);
3892 new_clone
->hosts
[host
].port
= 0;
3894 for (int x
= 'a'; x
<= 'z'; ++x
)
3896 const char key
[2]= { [0]= (const char)x
};
3898 rc
= memcached_mget_by_key(new_clone
, key
, 1, keys
, len
, 4);
3899 assert(rc
== MEMCACHED_SUCCESS
);
3901 memcached_result_st
*results
= memcached_result_create(new_clone
, &result_obj
);
3905 while ((results
= memcached_fetch_result(new_clone
, &result_obj
, &rc
)) != NULL
)
3910 memcached_result_free(&result_obj
);
3913 memcached_free(new_clone
);
3916 memcached_free(memc_clone
);
3918 return TEST_SUCCESS
;
3921 static test_return_t
replication_delete_test(memcached_st
*memc
)
3923 memcached_return rc
;
3924 memcached_st
*memc_clone
= memcached_clone(NULL
, memc
);
3925 /* Delete the items from all of the servers except 1 */
3926 uint64_t repl
= memcached_behavior_get(memc
,
3927 MEMCACHED_BEHAVIOR_NUMBER_OF_REPLICAS
);
3928 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NUMBER_OF_REPLICAS
, --repl
);
3930 const char *keys
[]= { "bubba", "key1", "key2", "key3" };
3931 size_t len
[]= { 5, 4, 4, 4 };
3933 for (int x
=0; x
< 4; ++x
)
3935 rc
= memcached_delete_by_key(memc
, keys
[0], len
[0], keys
[x
], len
[x
], 0);
3936 assert(rc
== MEMCACHED_SUCCESS
);
3940 * Don't do the following in your code. I am abusing the internal details
3941 * within the library, and this is not a supported interface.
3942 * This is to verify correct behavior in the library
3944 uint32_t hash
= memcached_generate_hash(memc
, keys
[0], len
[0]);
3945 for (uint32_t x
= 0; x
< (repl
+ 1); ++x
)
3947 memc_clone
->hosts
[hash
].port
= 0;
3948 if (++hash
== memc_clone
->number_of_hosts
)
3952 memcached_result_st result_obj
;
3953 for (uint32_t host
= 0; host
< memc_clone
->number_of_hosts
; ++host
)
3955 for (int x
= 'a'; x
<= 'z'; ++x
)
3957 const char key
[2]= { [0]= (const char)x
};
3959 rc
= memcached_mget_by_key(memc_clone
, key
, 1, keys
, len
, 4);
3960 assert(rc
== MEMCACHED_SUCCESS
);
3962 memcached_result_st
*results
= memcached_result_create(memc_clone
, &result_obj
);
3966 while ((results
= memcached_fetch_result(memc_clone
, &result_obj
, &rc
)) != NULL
)
3971 memcached_result_free(&result_obj
);
3974 memcached_free(memc_clone
);
3976 return TEST_SUCCESS
;
3979 static void increment_request_id(uint16_t *id
)
3982 if ((*id
& UDP_REQUEST_ID_THREAD_MASK
) != 0)
3986 static uint16_t *get_udp_request_ids(memcached_st
*memc
)
3988 uint16_t *ids
= malloc(sizeof(uint16_t) * memc
->number_of_hosts
);
3989 assert(ids
!= NULL
);
3992 for (x
= 0; x
< memc
->number_of_hosts
; x
++)
3993 ids
[x
]= get_udp_datagram_request_id((struct udp_datagram_header_st
*) memc
->hosts
[x
].write_buffer
);
3998 static test_return_t
post_udp_op_check(memcached_st
*memc
, uint16_t *expected_req_ids
)
4001 memcached_server_st
*cur_server
= memc
->hosts
;
4002 uint16_t *cur_req_ids
= get_udp_request_ids(memc
);
4004 for (x
= 0; x
< memc
->number_of_hosts
; x
++)
4006 assert(cur_server
[x
].cursor_active
== 0);
4007 assert(cur_req_ids
[x
] == expected_req_ids
[x
]);
4009 free(expected_req_ids
);
4012 return TEST_SUCCESS
;
4016 ** There is a little bit of a hack here, instead of removing
4017 ** the servers, I just set num host to 0 and them add then new udp servers
4019 static memcached_return
init_udp(memcached_st
*memc
)
4021 memcached_version(memc
);
4022 /* For the time being, only support udp test for >= 1.2.6 && < 1.3 */
4023 if (memc
->hosts
[0].major_version
!= 1 || memc
->hosts
[0].minor_version
!= 2
4024 || memc
->hosts
[0].micro_version
< 6)
4025 return MEMCACHED_FAILURE
;
4027 uint32_t num_hosts
= memc
->number_of_hosts
;
4029 memcached_server_st servers
[num_hosts
];
4030 memcpy(servers
, memc
->hosts
, sizeof(memcached_server_st
) * num_hosts
);
4031 for (x
= 0; x
< num_hosts
; x
++)
4032 memcached_server_free(&memc
->hosts
[x
]);
4034 memc
->number_of_hosts
= 0;
4035 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_USE_UDP
, 1);
4036 for (x
= 0; x
< num_hosts
; x
++)
4038 assert(memcached_server_add_udp(memc
, servers
[x
].hostname
, servers
[x
].port
) == MEMCACHED_SUCCESS
);
4039 assert(memc
->hosts
[x
].write_buffer_offset
== UDP_DATAGRAM_HEADER_LENGTH
);
4042 return MEMCACHED_SUCCESS
;
4045 static memcached_return
binary_init_udp(memcached_st
*memc
)
4048 return init_udp(memc
);
4051 /* Make sure that I cant add a tcp server to a udp client */
4052 static test_return_t
add_tcp_server_udp_client_test(memcached_st
*memc
)
4054 memcached_server_st server
;
4055 memcached_server_clone(&server
, &memc
->hosts
[0]);
4056 assert(memcached_server_remove(&(memc
->hosts
[0])) == MEMCACHED_SUCCESS
);
4057 assert(memcached_server_add(memc
, server
.hostname
, server
.port
) == MEMCACHED_INVALID_HOST_PROTOCOL
);
4058 return TEST_SUCCESS
;
4061 /* Make sure that I cant add a udp server to a tcp client */
4062 static test_return_t
add_udp_server_tcp_client_test(memcached_st
*memc
)
4064 memcached_server_st server
;
4065 memcached_server_clone(&server
, &memc
->hosts
[0]);
4066 assert(memcached_server_remove(&(memc
->hosts
[0])) == MEMCACHED_SUCCESS
);
4068 memcached_st tcp_client
;
4069 memcached_create(&tcp_client
);
4070 assert(memcached_server_add_udp(&tcp_client
, server
.hostname
, server
.port
) == MEMCACHED_INVALID_HOST_PROTOCOL
);
4071 return TEST_SUCCESS
;
4074 static test_return_t
set_udp_behavior_test(memcached_st
*memc
)
4077 memcached_quit(memc
);
4078 memc
->number_of_hosts
= 0;
4079 run_distribution(memc
);
4080 assert(memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_USE_UDP
, 1) == MEMCACHED_SUCCESS
);
4081 assert(memc
->flags
& MEM_USE_UDP
);
4082 assert(memc
->flags
& MEM_NOREPLY
);;
4084 assert(memc
->number_of_hosts
== 0);
4086 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_USE_UDP
,0);
4087 assert(!(memc
->flags
& MEM_USE_UDP
));
4088 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NOREPLY
,0);
4089 assert(!(memc
->flags
& MEM_NOREPLY
));
4090 return TEST_SUCCESS
;
4093 static test_return_t
udp_set_test(memcached_st
*memc
)
4096 unsigned int num_iters
= 1025; //request id rolls over at 1024
4097 for (x
= 0; x
< num_iters
;x
++)
4099 memcached_return rc
;
4100 const char *key
= "foo";
4101 const char *value
= "when we sanitize";
4102 uint16_t *expected_ids
= get_udp_request_ids(memc
);
4103 unsigned int server_key
= memcached_generate_hash(memc
,key
,strlen(key
));
4104 size_t init_offset
= memc
->hosts
[server_key
].write_buffer_offset
;
4105 rc
= memcached_set(memc
, key
, strlen(key
),
4106 value
, strlen(value
),
4107 (time_t)0, (uint32_t)0);
4108 assert(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
);
4109 /** NB, the check below assumes that if new write_ptr is less than
4110 * the original write_ptr that we have flushed. For large payloads, this
4111 * maybe an invalid assumption, but for the small payload we have it is OK
4113 if (rc
== MEMCACHED_SUCCESS
||
4114 memc
->hosts
[server_key
].write_buffer_offset
< init_offset
)
4115 increment_request_id(&expected_ids
[server_key
]);
4117 if (rc
== MEMCACHED_SUCCESS
)
4119 assert(memc
->hosts
[server_key
].write_buffer_offset
== UDP_DATAGRAM_HEADER_LENGTH
);
4123 assert(memc
->hosts
[server_key
].write_buffer_offset
!= UDP_DATAGRAM_HEADER_LENGTH
);
4124 assert(memc
->hosts
[server_key
].write_buffer_offset
<= MAX_UDP_DATAGRAM_LENGTH
);
4126 assert(post_udp_op_check(memc
,expected_ids
) == TEST_SUCCESS
);
4128 return TEST_SUCCESS
;
4131 static test_return_t
udp_buffered_set_test(memcached_st
*memc
)
4133 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_BUFFER_REQUESTS
, 1);
4134 return udp_set_test(memc
);
4137 static test_return_t
udp_set_too_big_test(memcached_st
*memc
)
4139 memcached_return rc
;
4140 const char *key
= "bar";
4141 char value
[MAX_UDP_DATAGRAM_LENGTH
];
4142 uint16_t *expected_ids
= get_udp_request_ids(memc
);
4143 rc
= memcached_set(memc
, key
, strlen(key
),
4144 value
, MAX_UDP_DATAGRAM_LENGTH
,
4145 (time_t)0, (uint32_t)0);
4146 assert(rc
== MEMCACHED_WRITE_FAILURE
);
4147 return post_udp_op_check(memc
,expected_ids
);
4150 static test_return_t
udp_delete_test(memcached_st
*memc
)
4153 unsigned int num_iters
= 1025; //request id rolls over at 1024
4154 for (x
= 0; x
< num_iters
;x
++)
4156 memcached_return rc
;
4157 const char *key
= "foo";
4158 uint16_t *expected_ids
=get_udp_request_ids(memc
);
4159 unsigned int server_key
= memcached_generate_hash(memc
, key
, strlen(key
));
4160 size_t init_offset
= memc
->hosts
[server_key
].write_buffer_offset
;
4161 rc
= memcached_delete(memc
, key
, strlen(key
), 0);
4162 assert(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
);
4163 if (rc
== MEMCACHED_SUCCESS
|| memc
->hosts
[server_key
].write_buffer_offset
< init_offset
)
4164 increment_request_id(&expected_ids
[server_key
]);
4165 if (rc
== MEMCACHED_SUCCESS
)
4166 assert(memc
->hosts
[server_key
].write_buffer_offset
== UDP_DATAGRAM_HEADER_LENGTH
);
4169 assert(memc
->hosts
[server_key
].write_buffer_offset
!= UDP_DATAGRAM_HEADER_LENGTH
);
4170 assert(memc
->hosts
[server_key
].write_buffer_offset
<= MAX_UDP_DATAGRAM_LENGTH
);
4172 assert(post_udp_op_check(memc
,expected_ids
) == TEST_SUCCESS
);
4174 return TEST_SUCCESS
;
4177 static test_return_t
udp_buffered_delete_test(memcached_st
*memc
)
4179 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_BUFFER_REQUESTS
, 1);
4180 return udp_delete_test(memc
);
4183 static test_return_t
udp_verbosity_test(memcached_st
*memc
)
4185 memcached_return rc
;
4186 uint16_t *expected_ids
= get_udp_request_ids(memc
);
4188 for (x
= 0; x
< memc
->number_of_hosts
;x
++)
4189 increment_request_id(&expected_ids
[x
]);
4191 rc
= memcached_verbosity(memc
,3);
4192 assert(rc
== MEMCACHED_SUCCESS
);
4193 return post_udp_op_check(memc
,expected_ids
);
4196 static test_return_t
udp_quit_test(memcached_st
*memc
)
4198 uint16_t *expected_ids
= get_udp_request_ids(memc
);
4199 memcached_quit(memc
);
4200 return post_udp_op_check(memc
, expected_ids
);
4203 static test_return_t
udp_flush_test(memcached_st
*memc
)
4205 memcached_return rc
;
4206 uint16_t *expected_ids
= get_udp_request_ids(memc
);
4208 for (x
= 0; x
< memc
->number_of_hosts
;x
++)
4209 increment_request_id(&expected_ids
[x
]);
4211 rc
= memcached_flush(memc
,0);
4212 assert(rc
== MEMCACHED_SUCCESS
);
4213 return post_udp_op_check(memc
,expected_ids
);
4216 static test_return_t
udp_incr_test(memcached_st
*memc
)
4218 memcached_return rc
;
4219 const char *key
= "incr";
4220 const char *value
= "1";
4221 rc
= memcached_set(memc
, key
, strlen(key
),
4222 value
, strlen(value
),
4223 (time_t)0, (uint32_t)0);
4225 assert(rc
== MEMCACHED_SUCCESS
);
4226 uint16_t *expected_ids
= get_udp_request_ids(memc
);
4227 unsigned int server_key
= memcached_generate_hash(memc
, key
, strlen(key
));
4228 increment_request_id(&expected_ids
[server_key
]);
4230 rc
= memcached_increment(memc
, key
, strlen(key
), 1, &newvalue
);
4231 assert(rc
== MEMCACHED_SUCCESS
);
4232 return post_udp_op_check(memc
, expected_ids
);
4235 static test_return_t
udp_decr_test(memcached_st
*memc
)
4237 memcached_return rc
;
4238 const char *key
= "decr";
4239 const char *value
= "1";
4240 rc
= memcached_set(memc
, key
, strlen(key
),
4241 value
, strlen(value
),
4242 (time_t)0, (uint32_t)0);
4244 assert(rc
== MEMCACHED_SUCCESS
);
4245 uint16_t *expected_ids
= get_udp_request_ids(memc
);
4246 unsigned int server_key
= memcached_generate_hash(memc
, key
, strlen(key
));
4247 increment_request_id(&expected_ids
[server_key
]);
4249 rc
= memcached_decrement(memc
, key
, strlen(key
), 1, &newvalue
);
4250 assert(rc
== MEMCACHED_SUCCESS
);
4251 return post_udp_op_check(memc
, expected_ids
);
4255 static test_return_t
udp_stat_test(memcached_st
*memc
)
4257 memcached_stat_st
* rv
= NULL
;
4258 memcached_return rc
;
4260 uint16_t *expected_ids
= get_udp_request_ids(memc
);
4261 rv
= memcached_stat(memc
, args
, &rc
);
4263 assert(rc
== MEMCACHED_NOT_SUPPORTED
);
4264 return post_udp_op_check(memc
, expected_ids
);
4267 static test_return_t
udp_version_test(memcached_st
*memc
)
4269 memcached_return rc
;
4270 uint16_t *expected_ids
= get_udp_request_ids(memc
);
4271 rc
= memcached_version(memc
);
4272 assert(rc
== MEMCACHED_NOT_SUPPORTED
);
4273 return post_udp_op_check(memc
, expected_ids
);
4276 static test_return_t
udp_get_test(memcached_st
*memc
)
4278 memcached_return rc
;
4279 const char *key
= "foo";
4281 uint16_t *expected_ids
= get_udp_request_ids(memc
);
4282 char *val
= memcached_get(memc
, key
, strlen(key
), &vlen
, (uint32_t)0, &rc
);
4283 assert(rc
== MEMCACHED_NOT_SUPPORTED
);
4284 assert(val
== NULL
);
4285 return post_udp_op_check(memc
, expected_ids
);
4288 static test_return_t
udp_mixed_io_test(memcached_st
*memc
)
4291 test_st mixed_io_ops
[] ={
4292 {"udp_set_test", 0, udp_set_test
},
4293 {"udp_set_too_big_test", 0, udp_set_too_big_test
},
4294 {"udp_delete_test", 0, udp_delete_test
},
4295 {"udp_verbosity_test", 0, udp_verbosity_test
},
4296 {"udp_quit_test", 0, udp_quit_test
},
4297 {"udp_flush_test", 0, udp_flush_test
},
4298 {"udp_incr_test", 0, udp_incr_test
},
4299 {"udp_decr_test", 0, udp_decr_test
},
4300 {"udp_version_test", 0, udp_version_test
}
4303 for (x
= 0; x
< 500; x
++)
4305 current_op
= mixed_io_ops
[random() % 9];
4306 assert(current_op
.function(memc
) == TEST_SUCCESS
);
4308 return TEST_SUCCESS
;
4311 static test_return_t
hsieh_avaibility_test (memcached_st
*memc
)
4313 memcached_return expected_rc
= MEMCACHED_FAILURE
;
4314 #ifdef HAVE_HSIEH_HASH
4315 expected_rc
= MEMCACHED_SUCCESS
;
4317 memcached_return rc
= memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_HASH
,
4318 (uint64_t)MEMCACHED_HASH_HSIEH
);
4319 assert(rc
== expected_rc
);
4320 return TEST_SUCCESS
;
4323 static const char *list
[]=
4353 static test_return_t
md5_run (memcached_st
*memc
__attribute__((unused
)))
4357 uint32_t values
[]= { 3195025439U, 2556848621U, 3724893440U, 3332385401U,
4358 245758794U, 2550894432U, 121710495U, 3053817768U,
4359 1250994555U, 1862072655U, 2631955953U, 2951528551U,
4360 1451250070U, 2820856945U, 2060845566U, 3646985608U,
4361 2138080750U, 217675895U, 2230934345U, 1234361223U,
4362 3968582726U, 2455685270U, 1293568479U, 199067604U,
4366 for (ptr
= list
, x
= 0; *ptr
; ptr
++, x
++)
4370 hash_val
= memcached_generate_hash_value(*ptr
, strlen(*ptr
), MEMCACHED_HASH_MD5
);
4371 assert(values
[x
] == hash_val
);
4374 return TEST_SUCCESS
;
4377 static test_return_t
crc_run (memcached_st
*memc
__attribute__((unused
)))
4381 uint32_t values
[]= { 10542U, 22009U, 14526U, 19510U, 19432U, 10199U, 20634U,
4382 9369U, 11511U, 10362U, 7893U, 31289U, 11313U, 9354U,
4383 7621U, 30628U, 15218U, 25967U, 2695U, 9380U,
4384 17300U, 28156U, 9192U, 20484U, 16925U };
4386 for (ptr
= list
, x
= 0; *ptr
; ptr
++, x
++)
4390 hash_val
= memcached_generate_hash_value(*ptr
, strlen(*ptr
), MEMCACHED_HASH_CRC
);
4391 assert(values
[x
] == hash_val
);
4394 return TEST_SUCCESS
;
4397 static test_return_t
fnv1_64_run (memcached_st
*memc
__attribute__((unused
)))
4401 uint32_t values
[]= { 473199127U, 4148981457U, 3971873300U, 3257986707U,
4402 1722477987U, 2991193800U, 4147007314U, 3633179701U,
4403 1805162104U, 3503289120U, 3395702895U, 3325073042U,
4404 2345265314U, 3340346032U, 2722964135U, 1173398992U,
4405 2815549194U, 2562818319U, 224996066U, 2680194749U,
4406 3035305390U, 246890365U, 2395624193U, 4145193337U,
4409 for (ptr
= list
, x
= 0; *ptr
; ptr
++, x
++)
4413 hash_val
= memcached_generate_hash_value(*ptr
, strlen(*ptr
), MEMCACHED_HASH_FNV1_64
);
4414 assert(values
[x
] == hash_val
);
4417 return TEST_SUCCESS
;
4420 static test_return_t
fnv1a_64_run (memcached_st
*memc
__attribute__((unused
)))
4424 uint32_t values
[]= { 1488911807U, 2500855813U, 1510099634U, 1390325195U,
4425 3647689787U, 3241528582U, 1669328060U, 2604311949U,
4426 734810122U, 1516407546U, 560948863U, 1767346780U,
4427 561034892U, 4156330026U, 3716417003U, 3475297030U,
4428 1518272172U, 227211583U, 3938128828U, 126112909U,
4429 3043416448U, 3131561933U, 1328739897U, 2455664041U,
4432 for (ptr
= list
, x
= 0; *ptr
; ptr
++, x
++)
4436 hash_val
= memcached_generate_hash_value(*ptr
, strlen(*ptr
), MEMCACHED_HASH_FNV1A_64
);
4437 assert(values
[x
] == hash_val
);
4440 return TEST_SUCCESS
;
4443 static test_return_t
fnv1_32_run (memcached_st
*memc
__attribute__((unused
)))
4447 uint32_t values
[]= { 67176023U, 1190179409U, 2043204404U, 3221866419U,
4448 2567703427U, 3787535528U, 4147287986U, 3500475733U,
4449 344481048U, 3865235296U, 2181839183U, 119581266U,
4450 510234242U, 4248244304U, 1362796839U, 103389328U,
4451 1449620010U, 182962511U, 3554262370U, 3206747549U,
4452 1551306158U, 4127558461U, 1889140833U, 2774173721U,
4456 for (ptr
= list
, x
= 0; *ptr
; ptr
++, x
++)
4460 hash_val
= memcached_generate_hash_value(*ptr
, strlen(*ptr
), MEMCACHED_HASH_FNV1_32
);
4461 assert(values
[x
] == hash_val
);
4464 return TEST_SUCCESS
;
4467 static test_return_t
fnv1a_32_run (memcached_st
*memc
__attribute__((unused
)))
4471 uint32_t values
[]= { 280767167U, 2421315013U, 3072375666U, 855001899U,
4472 459261019U, 3521085446U, 18738364U, 1625305005U,
4473 2162232970U, 777243802U, 3323728671U, 132336572U,
4474 3654473228U, 260679466U, 1169454059U, 2698319462U,
4475 1062177260U, 235516991U, 2218399068U, 405302637U,
4476 1128467232U, 3579622413U, 2138539289U, 96429129U,
4479 for (ptr
= list
, x
= 0; *ptr
; ptr
++, x
++)
4483 hash_val
= memcached_generate_hash_value(*ptr
, strlen(*ptr
), MEMCACHED_HASH_FNV1A_32
);
4484 assert(values
[x
] == hash_val
);
4487 return TEST_SUCCESS
;
4490 static test_return_t
hsieh_run (memcached_st
*memc
__attribute__((unused
)))
4494 #ifdef HAVE_HSIEH_HASH
4495 uint32_t values
[]= { 3738850110, 3636226060, 3821074029, 3489929160, 3485772682, 80540287,
4496 1805464076, 1895033657, 409795758, 979934958, 3634096985, 1284445480,
4497 2265380744, 707972988, 353823508, 1549198350, 1327930172, 9304163,
4498 4220749037, 2493964934, 2777873870, 2057831732, 1510213931, 2027828987,
4501 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 };
4504 for (ptr
= list
, x
= 0; *ptr
; ptr
++, x
++)
4508 hash_val
= memcached_generate_hash_value(*ptr
, strlen(*ptr
), MEMCACHED_HASH_HSIEH
);
4509 assert(values
[x
] == hash_val
);
4512 return TEST_SUCCESS
;
4515 static test_return_t
murmur_run (memcached_st
*memc
__attribute__((unused
)))
4519 uint32_t values
[]= { 473199127U, 4148981457U, 3971873300U, 3257986707U,
4520 1722477987U, 2991193800U, 4147007314U, 3633179701U,
4521 1805162104U, 3503289120U, 3395702895U, 3325073042U,
4522 2345265314U, 3340346032U, 2722964135U, 1173398992U,
4523 2815549194U, 2562818319U, 224996066U, 2680194749U,
4524 3035305390U, 246890365U, 2395624193U, 4145193337U,
4527 for (ptr
= list
, x
= 0; *ptr
; ptr
++, x
++)
4531 hash_val
= memcached_generate_hash_value(*ptr
, strlen(*ptr
), MEMCACHED_HASH_FNV1_64
);
4532 assert(values
[x
] == hash_val
);
4535 return TEST_SUCCESS
;
4538 static test_return_t
jenkins_run (memcached_st
*memc
__attribute__((unused
)))
4542 uint32_t values
[]= { 1442444624U, 4253821186U, 1885058256U, 2120131735U,
4543 3261968576U, 3515188778U, 4232909173U, 4288625128U,
4544 1812047395U, 3689182164U, 2502979932U, 1214050606U,
4545 2415988847U, 1494268927U, 1025545760U, 3920481083U,
4546 4153263658U, 3824871822U, 3072759809U, 798622255U,
4547 3065432577U, 1453328165U, 2691550971U, 3408888387U,
4551 for (ptr
= list
, x
= 0; *ptr
; ptr
++, x
++)
4555 hash_val
= memcached_generate_hash_value(*ptr
, strlen(*ptr
), MEMCACHED_HASH_JENKINS
);
4556 assert(values
[x
] == hash_val
);
4559 return TEST_SUCCESS
;
4562 static test_return_t
regression_bug_434484(memcached_st
*memc
)
4564 if (pre_binary(memc
) != MEMCACHED_SUCCESS
)
4565 return TEST_SKIPPED
;
4567 memcached_return ret
;
4568 const char *key
= "regression_bug_434484";
4569 size_t keylen
= strlen(key
);
4571 ret
= memcached_append(memc
, key
, keylen
, key
, keylen
, 0, 0);
4572 assert(ret
== MEMCACHED_NOTSTORED
);
4574 size_t size
= 2048 * 1024;
4575 void *data
= calloc(1, size
);
4576 assert(data
!= NULL
);
4577 ret
= memcached_set(memc
, key
, keylen
, data
, size
, 0, 0);
4578 assert(ret
== MEMCACHED_E2BIG
);
4581 return TEST_SUCCESS
;
4584 static test_return_t
regression_bug_434843(memcached_st
*memc
)
4586 if (pre_binary(memc
) != MEMCACHED_SUCCESS
)
4587 return TEST_SKIPPED
;
4589 memcached_return rc
;
4590 unsigned int counter
= 0;
4591 memcached_execute_function callbacks
[1]= { [0]= &callback_counter
};
4594 * I only want to hit only _one_ server so I know the number of requests I'm
4595 * sending in the pipleine to the server. Let's try to do a multiget of
4596 * 1024 (that should satisfy most users don't you think?). Future versions
4597 * will include a mget_execute function call if you need a higher number.
4599 uint32_t number_of_hosts
= memc
->number_of_hosts
;
4600 memc
->number_of_hosts
= 1;
4601 const size_t max_keys
= 1024;
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 /* Test memcached_server_get_last_disconnect
4738 * For a working server set, shall be NULL
4739 * For a set of non existing server, shall not be NULL
4741 static test_return_t
test_get_last_disconnect(memcached_st
*memc
)
4743 memcached_return rc
;
4744 memcached_server_st
*disconnected_server
;
4746 /* With the working set of server */
4747 const char *key
= "marmotte";
4748 const char *value
= "milka";
4750 rc
= memcached_set(memc
, key
, strlen(key
),
4751 value
, strlen(value
),
4752 (time_t)0, (uint32_t)0);
4753 assert(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
);
4755 disconnected_server
= memcached_server_get_last_disconnect(memc
);
4756 assert(disconnected_server
== NULL
);
4758 /* With a non existing server */
4760 memcached_server_st
*servers
;
4762 const char *server_list
= "localhost:9";
4764 servers
= memcached_servers_parse(server_list
);
4766 mine
= memcached_create(NULL
);
4767 rc
= memcached_server_push(mine
, servers
);
4768 assert(rc
== MEMCACHED_SUCCESS
);
4769 memcached_server_list_free(servers
);
4772 rc
= memcached_set(mine
, key
, strlen(key
),
4773 value
, strlen(value
),
4774 (time_t)0, (uint32_t)0);
4775 assert(rc
!= MEMCACHED_SUCCESS
);
4777 disconnected_server
= memcached_server_get_last_disconnect(mine
);
4778 assert(disconnected_server
!= NULL
);
4779 assert(disconnected_server
->port
== 9);
4780 assert(strncmp(disconnected_server
->hostname
,"localhost",9) == 0);
4782 memcached_quit(mine
);
4783 memcached_free(mine
);
4785 return TEST_SUCCESS
;
4789 test_st udp_setup_server_tests
[] ={
4790 {"set_udp_behavior_test", 0, set_udp_behavior_test
},
4791 {"add_tcp_server_udp_client_test", 0, add_tcp_server_udp_client_test
},
4792 {"add_udp_server_tcp_client_test", 0, add_udp_server_tcp_client_test
},
4796 test_st upd_io_tests
[] ={
4797 {"udp_set_test", 0, udp_set_test
},
4798 {"udp_buffered_set_test", 0, udp_buffered_set_test
},
4799 {"udp_set_too_big_test", 0, udp_set_too_big_test
},
4800 {"udp_delete_test", 0, udp_delete_test
},
4801 {"udp_buffered_delete_test", 0, udp_buffered_delete_test
},
4802 {"udp_verbosity_test", 0, udp_verbosity_test
},
4803 {"udp_quit_test", 0, udp_quit_test
},
4804 {"udp_flush_test", 0, udp_flush_test
},
4805 {"udp_incr_test", 0, udp_incr_test
},
4806 {"udp_decr_test", 0, udp_decr_test
},
4807 {"udp_stat_test", 0, udp_stat_test
},
4808 {"udp_version_test", 0, udp_version_test
},
4809 {"udp_get_test", 0, udp_get_test
},
4810 {"udp_mixed_io_test", 0, udp_mixed_io_test
},
4814 /* Clean the server before beginning testing */
4816 {"flush", 0, flush_test
},
4817 {"init", 0, init_test
},
4818 {"allocation", 0, allocation_test
},
4819 {"server_list_null_test", 0, server_list_null_test
},
4820 {"server_unsort", 0, server_unsort_test
},
4821 {"server_sort", 0, server_sort_test
},
4822 {"server_sort2", 0, server_sort2_test
},
4823 {"clone_test", 0, clone_test
},
4824 {"connection_test", 0, connection_test
},
4825 {"callback_test", 0, callback_test
},
4826 {"behavior_test", 0, behavior_test
},
4827 {"userdata_test", 0, userdata_test
},
4828 {"error", 0, error_test
},
4829 {"set", 0, set_test
},
4830 {"set2", 0, set_test2
},
4831 {"set3", 0, set_test3
},
4832 {"dump", 1, dump_test
},
4833 {"add", 1, add_test
},
4834 {"replace", 1, replace_test
},
4835 {"delete", 1, delete_test
},
4836 {"get", 1, get_test
},
4837 {"get2", 0, get_test2
},
4838 {"get3", 0, get_test3
},
4839 {"get4", 0, get_test4
},
4840 {"partial mget", 0, get_test5
},
4841 {"stats_servername", 0, stats_servername_test
},
4842 {"increment", 0, increment_test
},
4843 {"increment_with_initial", 1, increment_with_initial_test
},
4844 {"decrement", 0, decrement_test
},
4845 {"decrement_with_initial", 1, decrement_with_initial_test
},
4846 {"quit", 0, quit_test
},
4847 {"mget", 1, mget_test
},
4848 {"mget_result", 1, mget_result_test
},
4849 {"mget_result_alloc", 1, mget_result_alloc_test
},
4850 {"mget_result_function", 1, mget_result_function
},
4851 {"mget_end", 0, mget_end
},
4852 {"get_stats", 0, get_stats
},
4853 {"add_host_test", 0, add_host_test
},
4854 {"add_host_test_1", 0, add_host_test1
},
4855 {"get_stats_keys", 0, get_stats_keys
},
4856 {"behavior_test", 0, get_stats_keys
},
4857 {"callback_test", 0, get_stats_keys
},
4858 {"version_string_test", 0, version_string_test
},
4859 {"bad_key", 1, bad_key_test
},
4860 {"memcached_server_cursor", 1, memcached_server_cursor_test
},
4861 {"read_through", 1, read_through
},
4862 {"delete_through", 1, delete_through
},
4863 {"noreply", 1, noreply_test
},
4864 {"analyzer", 1, analyzer_test
},
4865 #ifdef HAVE_LIBMEMCACHEDUTIL
4866 {"connectionpool", 1, connection_pool_test
},
4868 {"test_get_last_disconnect", 1, test_get_last_disconnect
},
4872 test_st async_tests
[] ={
4873 {"add", 1, add_wrapper
},
4877 test_st string_tests
[] ={
4878 {"string static with null", 0, string_static_null
},
4879 {"string alloc with null", 0, string_alloc_null
},
4880 {"string alloc with 1K", 0, string_alloc_with_size
},
4881 {"string alloc with malloc failure", 0, string_alloc_with_size_toobig
},
4882 {"string append", 0, string_alloc_append
},
4883 {"string append failure (too big)", 0, string_alloc_append_toobig
},
4887 test_st result_tests
[] ={
4888 {"result static", 0, result_static
},
4889 {"result alloc", 0, result_alloc
},
4893 test_st version_1_2_3
[] ={
4894 {"append", 0, append_test
},
4895 {"prepend", 0, prepend_test
},
4896 {"cas", 0, cas_test
},
4897 {"cas2", 0, cas2_test
},
4898 {"append_binary", 0, append_binary_test
},
4902 test_st user_tests
[] ={
4903 {"user_supplied_bug1", 0, user_supplied_bug1
},
4904 {"user_supplied_bug2", 0, user_supplied_bug2
},
4905 {"user_supplied_bug3", 0, user_supplied_bug3
},
4906 {"user_supplied_bug4", 0, user_supplied_bug4
},
4907 {"user_supplied_bug5", 1, user_supplied_bug5
},
4908 {"user_supplied_bug6", 1, user_supplied_bug6
},
4909 {"user_supplied_bug7", 1, user_supplied_bug7
},
4910 {"user_supplied_bug8", 1, user_supplied_bug8
},
4911 {"user_supplied_bug9", 1, user_supplied_bug9
},
4912 {"user_supplied_bug10", 1, user_supplied_bug10
},
4913 {"user_supplied_bug11", 1, user_supplied_bug11
},
4914 {"user_supplied_bug12", 1, user_supplied_bug12
},
4915 {"user_supplied_bug13", 1, user_supplied_bug13
},
4916 {"user_supplied_bug14", 1, user_supplied_bug14
},
4917 {"user_supplied_bug15", 1, user_supplied_bug15
},
4918 {"user_supplied_bug16", 1, user_supplied_bug16
},
4921 ** It seems to be something weird with the character sets..
4922 ** value_fetch is unable to parse the value line (iscntrl "fails"), so I
4923 ** guess I need to find out how this is supposed to work.. Perhaps I need
4924 ** to run the test in a specific locale (I tried zh_CN.UTF-8 without success,
4925 ** so just disable the code for now...).
4927 {"user_supplied_bug17", 1, user_supplied_bug17
},
4929 {"user_supplied_bug18", 1, user_supplied_bug18
},
4930 {"user_supplied_bug19", 1, user_supplied_bug19
},
4931 {"user_supplied_bug20", 1, user_supplied_bug20
},
4932 {"user_supplied_bug21", 1, user_supplied_bug21
},
4936 test_st replication_tests
[]= {
4937 {"set", 1, replication_set_test
},
4938 {"get", 0, replication_get_test
},
4939 {"mget", 0, replication_mget_test
},
4940 {"delete", 0, replication_delete_test
},
4945 * The following test suite is used to verify that we don't introduce
4946 * regression bugs. If you want more information about the bug / test,
4947 * you should look in the bug report at
4948 * http://bugs.launchpad.net/libmemcached
4950 test_st regression_tests
[]= {
4951 {"lp:434484", 1, regression_bug_434484
},
4952 {"lp:434843", 1, regression_bug_434843
},
4953 {"lp:434843 buffered", 1, regression_bug_434843_buffered
},
4954 {"lp:421108", 1, regression_bug_421108
},
4955 {"lp:442914", 1, regression_bug_442914
},
4959 test_st generate_tests
[] ={
4960 {"generate_pairs", 1, generate_pairs
},
4961 {"generate_data", 1, generate_data
},
4962 {"get_read", 0, get_read
},
4963 {"delete_generate", 0, delete_generate
},
4964 {"generate_buffer_data", 1, generate_buffer_data
},
4965 {"delete_buffer", 0, delete_buffer_generate
},
4966 {"generate_data", 1, generate_data
},
4967 {"mget_read", 0, mget_read
},
4968 {"mget_read_result", 0, mget_read_result
},
4969 {"mget_read_function", 0, mget_read_function
},
4970 {"cleanup", 1, cleanup_pairs
},
4971 {"generate_large_pairs", 1, generate_large_pairs
},
4972 {"generate_data", 1, generate_data
},
4973 {"generate_buffer_data", 1, generate_buffer_data
},
4974 {"cleanup", 1, cleanup_pairs
},
4978 test_st consistent_tests
[] ={
4979 {"generate_pairs", 1, generate_pairs
},
4980 {"generate_data", 1, generate_data
},
4981 {"get_read", 0, get_read_count
},
4982 {"cleanup", 1, cleanup_pairs
},
4986 test_st consistent_weighted_tests
[] ={
4987 {"generate_pairs", 1, generate_pairs
},
4988 {"generate_data", 1, generate_data_with_stats
},
4989 {"get_read", 0, get_read_count
},
4990 {"cleanup", 1, cleanup_pairs
},
4994 test_st hsieh_availability
[] ={
4995 {"hsieh_avaibility_test",0,hsieh_avaibility_test
},
4999 test_st ketama_auto_eject_hosts
[] ={
5000 {"auto_eject_hosts", 1, auto_eject_hosts
},
5004 test_st hash_tests
[] ={
5005 {"md5", 0, md5_run
},
5006 {"crc", 0, crc_run
},
5007 {"fnv1_64", 0, fnv1_64_run
},
5008 {"fnv1a_64", 0, fnv1a_64_run
},
5009 {"fnv1_32", 0, fnv1_32_run
},
5010 {"fnv1a_32", 0, fnv1a_32_run
},
5011 {"hsieh", 0, hsieh_run
},
5012 {"murmur", 0, murmur_run
},
5013 {"jenkis", 0, jenkins_run
},
5017 collection_st collection
[] ={
5018 {"hsieh_availability",0,0,hsieh_availability
},
5019 {"udp_setup", init_udp
, 0, udp_setup_server_tests
},
5020 {"udp_io", init_udp
, 0, upd_io_tests
},
5021 {"udp_binary_io", binary_init_udp
, 0, upd_io_tests
},
5022 {"block", 0, 0, tests
},
5023 {"binary", pre_binary
, 0, tests
},
5024 {"nonblock", pre_nonblock
, 0, tests
},
5025 {"nodelay", pre_nodelay
, 0, tests
},
5026 {"settimer", pre_settimer
, 0, tests
},
5027 {"md5", pre_md5
, 0, tests
},
5028 {"crc", pre_crc
, 0, tests
},
5029 {"hsieh", pre_hsieh
, 0, tests
},
5030 {"jenkins", pre_jenkins
, 0, tests
},
5031 {"fnv1_64", pre_hash_fnv1_64
, 0, tests
},
5032 {"fnv1a_64", pre_hash_fnv1a_64
, 0, tests
},
5033 {"fnv1_32", pre_hash_fnv1_32
, 0, tests
},
5034 {"fnv1a_32", pre_hash_fnv1a_32
, 0, tests
},
5035 {"ketama", pre_behavior_ketama
, 0, tests
},
5036 {"ketama_auto_eject_hosts", pre_behavior_ketama
, 0, ketama_auto_eject_hosts
},
5037 {"unix_socket", pre_unix_socket
, 0, tests
},
5038 {"unix_socket_nodelay", pre_nodelay
, 0, tests
},
5039 {"poll_timeout", poll_timeout
, 0, tests
},
5040 {"gets", enable_cas
, 0, tests
},
5041 {"consistent", enable_consistent
, 0, tests
},
5042 #ifdef MEMCACHED_ENABLE_DEPRECATED
5043 {"deprecated_memory_allocators", deprecated_set_memory_alloc
, 0, tests
},
5045 {"memory_allocators", set_memory_alloc
, 0, tests
},
5046 {"prefix", set_prefix
, 0, tests
},
5047 {"version_1_2_3", check_for_1_2_3
, 0, version_1_2_3
},
5048 {"string", 0, 0, string_tests
},
5049 {"result", 0, 0, result_tests
},
5050 {"async", pre_nonblock
, 0, async_tests
},
5051 {"async_binary", pre_nonblock_binary
, 0, async_tests
},
5052 {"user", 0, 0, user_tests
},
5053 {"generate", 0, 0, generate_tests
},
5054 {"generate_hsieh", pre_hsieh
, 0, generate_tests
},
5055 {"generate_ketama", pre_behavior_ketama
, 0, generate_tests
},
5056 {"generate_hsieh_consistent", enable_consistent
, 0, generate_tests
},
5057 {"generate_md5", pre_md5
, 0, generate_tests
},
5058 {"generate_murmur", pre_murmur
, 0, generate_tests
},
5059 {"generate_jenkins", pre_jenkins
, 0, generate_tests
},
5060 {"generate_nonblock", pre_nonblock
, 0, generate_tests
},
5061 {"consistent_not", 0, 0, consistent_tests
},
5062 {"consistent_ketama", pre_behavior_ketama
, 0, consistent_tests
},
5063 {"consistent_ketama_weighted", pre_behavior_ketama_weighted
, 0, consistent_weighted_tests
},
5064 {"test_hashes", 0, 0, hash_tests
},
5065 {"replication", pre_replication
, 0, replication_tests
},
5066 {"replication_noblock", pre_replication_noblock
, 0, replication_tests
},
5067 {"regression", 0, 0, regression_tests
},
5071 #define SERVERS_TO_CREATE 5
5073 /* Prototypes for functions we will pass to test framework */
5074 void *world_create(void);
5075 void world_destroy(void *p
);
5077 void *world_create(void)
5079 server_startup_st
*construct
;
5081 construct
= calloc(sizeof(server_startup_st
), 1);
5082 construct
->count
= SERVERS_TO_CREATE
;
5084 server_startup(construct
);
5090 void world_destroy(void *p
)
5092 server_startup_st
*construct
= (server_startup_st
*)p
;
5093 memcached_server_st
*servers
= (memcached_server_st
*)construct
->servers
;
5094 memcached_server_list_free(servers
);
5096 server_shutdown(construct
);
5100 void get_world(world_st
*world
)
5102 world
->collections
= collection
;
5103 world
->create
= world_create
;
5104 world
->destroy
= world_destroy
;