1 /* libMemcached Functions Test
2 * Copyright (C) 2006-2009 Brian Aker
5 * Use and distribution licensed under the BSD license. See
6 * the COPYING file in the parent directory for full text.
10 Sample test application.
13 #include "libmemcached/common.h"
20 #include <sys/types.h>
26 #include "clients/generator.h"
27 #include "clients/execute.h"
30 #define INT64_MAX LONG_MAX
33 #define INT32_MAX INT_MAX
39 #ifdef HAVE_LIBMEMCACHEDUTIL
41 #include "libmemcached/memcached_util.h"
44 #include "hash_results.h"
46 #define GLOBAL_COUNT 10000
47 #define GLOBAL2_COUNT 100
48 #define SERVERS_TO_CREATE 5
49 static uint32_t global_count
;
51 static pairs_st
*global_pairs
;
52 static const char *global_keys
[GLOBAL_COUNT
];
53 static size_t global_keys_length
[GLOBAL_COUNT
];
55 static test_return_t
init_test(memcached_st
*not_used
__attribute__((unused
)))
59 (void)memcached_create(&memc
);
60 memcached_free(&memc
);
65 static test_return_t
server_list_null_test(memcached_st
*ptr
__attribute__((unused
)))
67 memcached_server_st
*server_list
;
68 memcached_return_t rc
;
70 server_list
= memcached_server_list_append_with_weight(NULL
, NULL
, 0, 0, NULL
);
71 test_true(server_list
== NULL
);
73 server_list
= memcached_server_list_append_with_weight(NULL
, "localhost", 0, 0, NULL
);
74 test_true(server_list
== NULL
);
76 server_list
= memcached_server_list_append_with_weight(NULL
, NULL
, 0, 0, &rc
);
77 test_true(server_list
== NULL
);
82 #define TEST_PORT_COUNT 7
83 in_port_t test_ports
[TEST_PORT_COUNT
];
85 static memcached_return_t
server_display_function(const memcached_st
*ptr
__attribute__((unused
)),
86 memcached_server_st
*server
, void *context
)
89 size_t bigger
= *((size_t *)(context
));
90 assert(bigger
<= server
->port
);
91 *((size_t *)(context
))= server
->port
;
93 return MEMCACHED_SUCCESS
;
96 static test_return_t
server_sort_test(memcached_st
*ptr
__attribute__((unused
)))
98 size_t bigger
= 0; /* Prime the value for the test_true in server_display_function */
100 memcached_return_t rc
;
101 memcached_server_fn callbacks
[1];
102 memcached_st
*local_memc
;
104 local_memc
= memcached_create(NULL
);
105 test_true(local_memc
);
106 memcached_behavior_set(local_memc
, MEMCACHED_BEHAVIOR_SORT_HOSTS
, 1);
108 for (size_t x
= 0; x
< TEST_PORT_COUNT
; x
++)
110 test_ports
[x
]= (in_port_t
)random() % 64000;
111 rc
= memcached_server_add_with_weight(local_memc
, "localhost", test_ports
[x
], 0);
112 test_true(memcached_server_count(local_memc
) == x
+ 1);
113 test_true(memcached_servers_count(memcached_server_list(local_memc
)) == x
+1);
114 test_true(rc
== MEMCACHED_SUCCESS
);
117 callbacks
[0]= server_display_function
;
118 memcached_server_cursor(local_memc
, callbacks
, (void *)&bigger
, 1);
121 memcached_free(local_memc
);
126 static test_return_t
server_sort2_test(memcached_st
*ptr
__attribute__((unused
)))
128 size_t bigger
= 0; /* Prime the value for the test_true in server_display_function */
129 memcached_return_t rc
;
130 memcached_server_fn callbacks
[1];
131 memcached_st
*local_memc
;
132 memcached_server_instance_st
*instance
;
134 local_memc
= memcached_create(NULL
);
135 test_true(local_memc
);
136 rc
= memcached_behavior_set(local_memc
, MEMCACHED_BEHAVIOR_SORT_HOSTS
, 1);
137 test_true(rc
== MEMCACHED_SUCCESS
);
139 rc
= memcached_server_add_with_weight(local_memc
, "MEMCACHED_BEHAVIOR_SORT_HOSTS", 43043, 0);
140 test_true(rc
== MEMCACHED_SUCCESS
);
141 instance
= memcached_server_instance_fetch(local_memc
, 0);
142 test_true(instance
->port
== 43043);
144 rc
= memcached_server_add_with_weight(local_memc
, "MEMCACHED_BEHAVIOR_SORT_HOSTS", 43042, 0);
145 test_true(rc
== MEMCACHED_SUCCESS
);
147 instance
= memcached_server_instance_fetch(local_memc
, 0);
148 test_true(instance
->port
== 43042);
150 instance
= memcached_server_instance_fetch(local_memc
, 1);
151 test_true(instance
->port
== 43043);
153 callbacks
[0]= server_display_function
;
154 memcached_server_cursor(local_memc
, callbacks
, (void *)&bigger
, 1);
157 memcached_free(local_memc
);
162 static memcached_return_t
server_display_unsort_function(const memcached_st
*ptr
__attribute__((unused
)), memcached_server_st
*server
, void *context
)
165 uint32_t x
= *((uint32_t *)(context
));
167 assert(test_ports
[x
] == server
->port
);
168 *((uint32_t *)(context
))= ++x
;
170 return MEMCACHED_SUCCESS
;
173 static test_return_t
server_unsort_test(memcached_st
*ptr
__attribute__((unused
)))
175 size_t counter
= 0; /* Prime the value for the test_true in server_display_function */
176 size_t bigger
= 0; /* Prime the value for the test_true in server_display_function */
177 memcached_return_t rc
;
178 memcached_server_fn callbacks
[1];
179 memcached_st
*local_memc
;
181 local_memc
= memcached_create(NULL
);
182 test_true(local_memc
);
184 for (size_t x
= 0; x
< TEST_PORT_COUNT
; x
++)
186 test_ports
[x
]= (in_port_t
)(random() % 64000);
187 rc
= memcached_server_add_with_weight(local_memc
, "localhost", test_ports
[x
], 0);
188 test_true(memcached_server_count(local_memc
) == x
+1);
189 test_true(memcached_servers_count(memcached_server_list(local_memc
)) == x
+1);
190 test_true(rc
== MEMCACHED_SUCCESS
);
193 callbacks
[0]= server_display_unsort_function
;
194 memcached_server_cursor(local_memc
, callbacks
, (void *)&counter
, 1);
196 /* Now we sort old data! */
197 memcached_behavior_set(local_memc
, MEMCACHED_BEHAVIOR_SORT_HOSTS
, 1);
198 callbacks
[0]= server_display_function
;
199 memcached_server_cursor(local_memc
, callbacks
, (void *)&bigger
, 1);
202 memcached_free(local_memc
);
207 static test_return_t
allocation_test(memcached_st
*not_used
__attribute__((unused
)))
210 memc
= memcached_create(NULL
);
212 memcached_free(memc
);
217 static test_return_t
clone_test(memcached_st
*memc
)
221 memcached_st
*memc_clone
;
222 memc_clone
= memcached_clone(NULL
, NULL
);
223 test_true(memc_clone
);
224 memcached_free(memc_clone
);
227 /* Can we init from null? */
229 memcached_st
*memc_clone
;
230 memc_clone
= memcached_clone(NULL
, memc
);
231 test_true(memc_clone
);
234 test_true(memc_clone
->allocators
.free
== memc
->allocators
.free
);
235 test_true(memc_clone
->allocators
.malloc
== memc
->allocators
.malloc
);
236 test_true(memc_clone
->allocators
.realloc
== memc
->allocators
.realloc
);
237 test_true(memc_clone
->allocators
.calloc
== memc
->allocators
.calloc
);
240 test_true(memc_clone
->connect_timeout
== memc
->connect_timeout
);
241 test_true(memc_clone
->delete_trigger
== memc
->delete_trigger
);
242 test_true(memc_clone
->distribution
== memc
->distribution
);
243 { // Test all of the flags
244 test_true(memc_clone
->flags
.no_block
== memc
->flags
.no_block
);
245 test_true(memc_clone
->flags
.tcp_nodelay
== memc
->flags
.tcp_nodelay
);
246 test_true(memc_clone
->flags
.reuse_memory
== memc
->flags
.reuse_memory
);
247 test_true(memc_clone
->flags
.use_cache_lookups
== memc
->flags
.use_cache_lookups
);
248 test_true(memc_clone
->flags
.support_cas
== memc
->flags
.support_cas
);
249 test_true(memc_clone
->flags
.buffer_requests
== memc
->flags
.buffer_requests
);
250 test_true(memc_clone
->flags
.use_sort_hosts
== memc
->flags
.use_sort_hosts
);
251 test_true(memc_clone
->flags
.verify_key
== memc
->flags
.verify_key
);
252 test_true(memc_clone
->flags
.ketama_weighted
== memc
->flags
.ketama_weighted
);
253 test_true(memc_clone
->flags
.binary_protocol
== memc
->flags
.binary_protocol
);
254 test_true(memc_clone
->flags
.hash_with_prefix_key
== memc
->flags
.hash_with_prefix_key
);
255 test_true(memc_clone
->flags
.no_reply
== memc
->flags
.no_reply
);
256 test_true(memc_clone
->flags
.use_udp
== memc
->flags
.use_udp
);
257 test_true(memc_clone
->flags
.auto_eject_hosts
== memc
->flags
.auto_eject_hosts
);
258 test_true(memc_clone
->flags
.randomize_replica_read
== memc
->flags
.randomize_replica_read
);
260 test_true(memc_clone
->get_key_failure
== memc
->get_key_failure
);
261 test_true(memc_clone
->hash
== memc
->hash
);
262 test_true(memc_clone
->distribution_hash
== memc
->distribution_hash
);
263 test_true(memc_clone
->io_bytes_watermark
== memc
->io_bytes_watermark
);
264 test_true(memc_clone
->io_msg_watermark
== memc
->io_msg_watermark
);
265 test_true(memc_clone
->io_key_prefetch
== memc
->io_key_prefetch
);
266 test_true(memc_clone
->on_cleanup
== memc
->on_cleanup
);
267 test_true(memc_clone
->on_clone
== memc
->on_clone
);
268 test_true(memc_clone
->poll_timeout
== memc
->poll_timeout
);
269 test_true(memc_clone
->rcv_timeout
== memc
->rcv_timeout
);
270 test_true(memc_clone
->recv_size
== memc
->recv_size
);
271 test_true(memc_clone
->retry_timeout
== memc
->retry_timeout
);
272 test_true(memc_clone
->send_size
== memc
->send_size
);
273 test_true(memc_clone
->server_failure_limit
== memc
->server_failure_limit
);
274 test_true(memc_clone
->snd_timeout
== memc
->snd_timeout
);
275 test_true(memc_clone
->user_data
== memc
->user_data
);
277 memcached_free(memc_clone
);
280 /* Can we init from struct? */
282 memcached_st declared_clone
;
283 memcached_st
*memc_clone
;
284 memset(&declared_clone
, 0 , sizeof(memcached_st
));
285 memc_clone
= memcached_clone(&declared_clone
, NULL
);
286 test_true(memc_clone
);
287 memcached_free(memc_clone
);
290 /* Can we init from struct? */
292 memcached_st declared_clone
;
293 memcached_st
*memc_clone
;
294 memset(&declared_clone
, 0 , sizeof(memcached_st
));
295 memc_clone
= memcached_clone(&declared_clone
, memc
);
296 test_true(memc_clone
);
297 memcached_free(memc_clone
);
303 static test_return_t
userdata_test(memcached_st
*memc
)
306 test_true(memcached_set_user_data(memc
, foo
) == NULL
);
307 test_true(memcached_get_user_data(memc
) == foo
);
308 test_true(memcached_set_user_data(memc
, NULL
) == foo
);
313 static test_return_t
connection_test(memcached_st
*memc
)
315 memcached_return_t rc
;
317 rc
= memcached_server_add_with_weight(memc
, "localhost", 0, 0);
318 test_true(rc
== MEMCACHED_SUCCESS
);
323 static test_return_t
error_test(memcached_st
*memc
)
325 memcached_return_t rc
;
326 uint32_t values
[] = { 851992627U, 2337886783U, 3196981036U, 4001849190U,
327 982370485U, 1263635348U, 4242906218U, 3829656100U,
328 1891735253U, 334139633U, 2257084983U, 3088286104U,
329 13199785U, 2542027183U, 1097051614U, 199566778U,
330 2748246961U, 2465192557U, 1664094137U, 2405439045U,
331 1842224848U, 692413798U, 3479807801U, 919913813U,
332 4269430871U, 610793021U, 527273862U, 1437122909U,
333 2300930706U, 2943759320U, 674306647U, 2400528935U,
334 54481931U, 4186304426U, 1741088401U, 2979625118U,
335 4159057246U, 3425930182U, 2593724503U};
337 // You have updated the memcache_error messages but not updated docs/tests.
338 test_true(MEMCACHED_MAXIMUM_RETURN
== 39);
339 for (rc
= MEMCACHED_SUCCESS
; rc
< MEMCACHED_MAXIMUM_RETURN
; rc
++)
342 const char *msg
= memcached_strerror(memc
, rc
);
343 hash_val
= memcached_generate_hash_value(msg
, strlen(msg
),
344 MEMCACHED_HASH_JENKINS
);
345 test_true(values
[rc
] == hash_val
);
351 static test_return_t
set_test(memcached_st
*memc
)
353 memcached_return_t rc
;
354 const char *key
= "foo";
355 const char *value
= "when we sanitize";
357 rc
= memcached_set(memc
, key
, strlen(key
),
358 value
, strlen(value
),
359 (time_t)0, (uint32_t)0);
360 test_true(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
);
365 static test_return_t
append_test(memcached_st
*memc
)
367 memcached_return_t rc
;
368 const char *key
= "fig";
369 const char *in_value
= "we";
370 char *out_value
= NULL
;
374 rc
= memcached_flush(memc
, 0);
375 test_true(rc
== MEMCACHED_SUCCESS
);
377 rc
= memcached_set(memc
, key
, strlen(key
),
378 in_value
, strlen(in_value
),
379 (time_t)0, (uint32_t)0);
380 test_true(rc
== MEMCACHED_SUCCESS
);
382 rc
= memcached_append(memc
, key
, strlen(key
),
383 " the", strlen(" the"),
384 (time_t)0, (uint32_t)0);
385 test_true(rc
== MEMCACHED_SUCCESS
);
387 rc
= memcached_append(memc
, key
, strlen(key
),
388 " people", strlen(" people"),
389 (time_t)0, (uint32_t)0);
390 test_true(rc
== MEMCACHED_SUCCESS
);
392 out_value
= memcached_get(memc
, key
, strlen(key
),
393 &value_length
, &flags
, &rc
);
394 test_true(!memcmp(out_value
, "we the people", strlen("we the people")));
395 test_true(strlen("we the people") == value_length
);
396 test_true(rc
== MEMCACHED_SUCCESS
);
402 static test_return_t
append_binary_test(memcached_st
*memc
)
404 memcached_return_t rc
;
405 const char *key
= "numbers";
406 uint32_t store_list
[] = { 23, 56, 499, 98, 32847, 0 };
412 rc
= memcached_flush(memc
, 0);
413 test_true(rc
== MEMCACHED_SUCCESS
);
415 rc
= memcached_set(memc
,
418 (time_t)0, (uint32_t)0);
419 test_true(rc
== MEMCACHED_SUCCESS
);
421 for (x
= 0; store_list
[x
] ; x
++)
423 rc
= memcached_append(memc
,
425 (char *)&store_list
[x
], sizeof(uint32_t),
426 (time_t)0, (uint32_t)0);
427 test_true(rc
== MEMCACHED_SUCCESS
);
430 value
= (uint32_t *)memcached_get(memc
, key
, strlen(key
),
431 &value_length
, &flags
, &rc
);
432 test_true((value_length
== (sizeof(uint32_t) * x
)));
433 test_true(rc
== MEMCACHED_SUCCESS
);
435 for (uint32_t counter
= x
, *ptr
= value
; counter
; counter
--)
437 test_true(*ptr
== store_list
[x
- counter
]);
445 static test_return_t
cas2_test(memcached_st
*memc
)
447 memcached_return_t rc
;
448 const char *keys
[]= {"fudge", "son", "food"};
449 size_t key_length
[]= {5, 3, 4};
450 const char *value
= "we the people";
451 size_t value_length
= strlen("we the people");
453 memcached_result_st results_obj
;
454 memcached_result_st
*results
;
457 rc
= memcached_flush(memc
, 0);
458 test_true(rc
== MEMCACHED_SUCCESS
);
460 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_SUPPORT_CAS
, set
);
462 for (x
= 0; x
< 3; x
++)
464 rc
= memcached_set(memc
, keys
[x
], key_length
[x
],
465 keys
[x
], key_length
[x
],
466 (time_t)50, (uint32_t)9);
467 test_true(rc
== MEMCACHED_SUCCESS
);
470 rc
= memcached_mget(memc
, keys
, key_length
, 3);
472 results
= memcached_result_create(memc
, &results_obj
);
474 results
= memcached_fetch_result(memc
, &results_obj
, &rc
);
476 test_true(results
->cas
);
477 test_true(rc
== MEMCACHED_SUCCESS
);
478 test_true(memcached_result_cas(results
));
480 test_true(!memcmp(value
, "we the people", strlen("we the people")));
481 test_true(strlen("we the people") == value_length
);
482 test_true(rc
== MEMCACHED_SUCCESS
);
484 memcached_result_free(&results_obj
);
489 static test_return_t
cas_test(memcached_st
*memc
)
491 memcached_return_t rc
;
492 const char *key
= "fun";
493 size_t key_length
= strlen(key
);
494 const char *value
= "we the people";
495 const char* keys
[2] = { key
, NULL
};
496 size_t keylengths
[2] = { strlen(key
), 0 };
497 size_t value_length
= strlen(value
);
498 const char *value2
= "change the value";
499 size_t value2_length
= strlen(value2
);
501 memcached_result_st results_obj
;
502 memcached_result_st
*results
;
505 rc
= memcached_flush(memc
, 0);
506 test_true(rc
== MEMCACHED_SUCCESS
);
508 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_SUPPORT_CAS
, set
);
510 rc
= memcached_set(memc
, key
, strlen(key
),
511 value
, strlen(value
),
512 (time_t)0, (uint32_t)0);
513 test_true(rc
== MEMCACHED_SUCCESS
);
515 rc
= memcached_mget(memc
, keys
, keylengths
, 1);
517 results
= memcached_result_create(memc
, &results_obj
);
519 results
= memcached_fetch_result(memc
, &results_obj
, &rc
);
521 test_true(rc
== MEMCACHED_SUCCESS
);
522 test_true(memcached_result_cas(results
));
523 test_true(!memcmp(value
, memcached_result_value(results
), value_length
));
524 test_true(strlen(memcached_result_value(results
)) == value_length
);
525 test_true(rc
== MEMCACHED_SUCCESS
);
526 uint64_t cas
= memcached_result_cas(results
);
529 results
= memcached_fetch_result(memc
, &results_obj
, &rc
);
530 test_true(rc
== MEMCACHED_END
);
531 test_true(results
== NULL
);
534 rc
= memcached_cas(memc
, key
, key_length
, value2
, value2_length
, 0, 0, cas
);
535 test_true(rc
== MEMCACHED_SUCCESS
);
538 * The item will have a new cas value, so try to set it again with the old
539 * value. This should fail!
541 rc
= memcached_cas(memc
, key
, key_length
, value2
, value2_length
, 0, 0, cas
);
542 test_true(rc
== MEMCACHED_DATA_EXISTS
);
544 memcached_result_free(&results_obj
);
549 static test_return_t
prepend_test(memcached_st
*memc
)
551 memcached_return_t rc
;
552 const char *key
= "fig";
553 const char *value
= "people";
554 char *out_value
= NULL
;
558 rc
= memcached_flush(memc
, 0);
559 test_true(rc
== MEMCACHED_SUCCESS
);
561 rc
= memcached_set(memc
, key
, strlen(key
),
562 value
, strlen(value
),
563 (time_t)0, (uint32_t)0);
564 test_true(rc
== MEMCACHED_SUCCESS
);
566 rc
= memcached_prepend(memc
, key
, strlen(key
),
567 "the ", strlen("the "),
568 (time_t)0, (uint32_t)0);
569 test_true(rc
== MEMCACHED_SUCCESS
);
571 rc
= memcached_prepend(memc
, key
, strlen(key
),
572 "we ", strlen("we "),
573 (time_t)0, (uint32_t)0);
574 test_true(rc
== MEMCACHED_SUCCESS
);
576 out_value
= memcached_get(memc
, key
, strlen(key
),
577 &value_length
, &flags
, &rc
);
578 test_true(!memcmp(out_value
, "we the people", strlen("we the people")));
579 test_true(strlen("we the people") == value_length
);
580 test_true(rc
== MEMCACHED_SUCCESS
);
587 Set the value, then quit to make sure it is flushed.
588 Come back in and test that add fails.
590 static test_return_t
add_test(memcached_st
*memc
)
592 memcached_return_t rc
;
593 const char *key
= "foo";
594 const char *value
= "when we sanitize";
595 unsigned long long setting_value
;
597 setting_value
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_NO_BLOCK
);
599 rc
= memcached_set(memc
, key
, strlen(key
),
600 value
, strlen(value
),
601 (time_t)0, (uint32_t)0);
602 test_true(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
);
603 memcached_quit(memc
);
604 rc
= memcached_add(memc
, key
, strlen(key
),
605 value
, strlen(value
),
606 (time_t)0, (uint32_t)0);
608 /* Too many broken OS'es have broken loopback in async, so we can't be sure of the result */
611 test_true(rc
== MEMCACHED_NOTSTORED
|| rc
== MEMCACHED_STORED
);
615 test_true(rc
== MEMCACHED_NOTSTORED
|| rc
== MEMCACHED_DATA_EXISTS
);
622 ** There was a problem of leaking filedescriptors in the initial release
623 ** of MacOSX 10.5. This test case triggers the problem. On some Solaris
624 ** systems it seems that the kernel is slow on reclaiming the resources
625 ** because the connects starts to time out (the test doesn't do much
626 ** anyway, so just loop 10 iterations)
628 static test_return_t
add_wrapper(memcached_st
*memc
)
631 unsigned int max
= 10000;
639 for (x
= 0; x
< max
; x
++)
645 static test_return_t
replace_test(memcached_st
*memc
)
647 memcached_return_t rc
;
648 const char *key
= "foo";
649 const char *value
= "when we sanitize";
650 const char *original
= "first we insert some data";
652 rc
= memcached_set(memc
, key
, strlen(key
),
653 original
, strlen(original
),
654 (time_t)0, (uint32_t)0);
655 test_true(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
);
657 rc
= memcached_replace(memc
, key
, strlen(key
),
658 value
, strlen(value
),
659 (time_t)0, (uint32_t)0);
660 test_true(rc
== MEMCACHED_SUCCESS
);
665 static test_return_t
delete_test(memcached_st
*memc
)
667 memcached_return_t rc
;
668 const char *key
= "foo";
669 const char *value
= "when we sanitize";
671 rc
= memcached_set(memc
, key
, strlen(key
),
672 value
, strlen(value
),
673 (time_t)0, (uint32_t)0);
674 test_true(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
);
676 rc
= memcached_delete(memc
, key
, strlen(key
), (time_t)0);
677 test_true(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
);
682 static test_return_t
flush_test(memcached_st
*memc
)
684 memcached_return_t rc
;
686 rc
= memcached_flush(memc
, 0);
687 test_true(rc
== MEMCACHED_SUCCESS
);
692 static memcached_return_t
server_function(const memcached_st
*ptr
__attribute__((unused
)),
693 memcached_server_st
*server
__attribute__((unused
)),
694 void *context
__attribute__((unused
)))
698 return MEMCACHED_SUCCESS
;
701 static test_return_t
memcached_server_cursor_test(memcached_st
*memc
)
704 strcpy(context
, "foo bad");
705 memcached_server_fn callbacks
[1];
707 callbacks
[0]= server_function
;
708 memcached_server_cursor(memc
, callbacks
, context
, 1);
712 static test_return_t
bad_key_test(memcached_st
*memc
)
714 memcached_return_t rc
;
715 const char *key
= "foo bad";
717 size_t string_length
;
719 memcached_st
*memc_clone
;
721 size_t max_keylen
= 0xffff;
723 // Just skip if we are in binary mode.
724 if (memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
))
727 memc_clone
= memcached_clone(NULL
, memc
);
728 test_true(memc_clone
);
730 rc
= memcached_behavior_set(memc_clone
, MEMCACHED_BEHAVIOR_VERIFY_KEY
, set
);
731 test_true(rc
== MEMCACHED_SUCCESS
);
733 /* All keys are valid in the binary protocol (except for length) */
734 if (memcached_behavior_get(memc_clone
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
) == 0)
736 string
= memcached_get(memc_clone
, key
, strlen(key
),
737 &string_length
, &flags
, &rc
);
738 test_true(rc
== MEMCACHED_BAD_KEY_PROVIDED
);
739 test_true(string_length
== 0);
743 rc
= memcached_behavior_set(memc_clone
, MEMCACHED_BEHAVIOR_VERIFY_KEY
, set
);
744 test_true(rc
== MEMCACHED_SUCCESS
);
745 string
= memcached_get(memc_clone
, key
, strlen(key
),
746 &string_length
, &flags
, &rc
);
747 test_true(rc
== MEMCACHED_NOTFOUND
);
748 test_true(string_length
== 0);
751 /* Test multi key for bad keys */
752 const char *keys
[] = { "GoodKey", "Bad Key", "NotMine" };
753 size_t key_lengths
[] = { 7, 7, 7 };
755 rc
= memcached_behavior_set(memc_clone
, MEMCACHED_BEHAVIOR_VERIFY_KEY
, set
);
756 test_true(rc
== MEMCACHED_SUCCESS
);
758 rc
= memcached_mget(memc_clone
, keys
, key_lengths
, 3);
759 test_true(rc
== MEMCACHED_BAD_KEY_PROVIDED
);
761 rc
= memcached_mget_by_key(memc_clone
, "foo daddy", 9, keys
, key_lengths
, 1);
762 test_true(rc
== MEMCACHED_BAD_KEY_PROVIDED
);
766 /* The following test should be moved to the end of this function when the
767 memcached server is updated to allow max size length of the keys in the
770 rc
= memcached_callback_set(memc_clone
, MEMCACHED_CALLBACK_PREFIX_KEY
, NULL
);
771 test_true(rc
== MEMCACHED_SUCCESS
);
773 char *longkey
= malloc(max_keylen
+ 1);
776 memset(longkey
, 'a', max_keylen
+ 1);
777 string
= memcached_get(memc_clone
, longkey
, max_keylen
,
778 &string_length
, &flags
, &rc
);
779 test_true(rc
== MEMCACHED_NOTFOUND
);
780 test_true(string_length
== 0);
783 string
= memcached_get(memc_clone
, longkey
, max_keylen
+ 1,
784 &string_length
, &flags
, &rc
);
785 test_true(rc
== MEMCACHED_BAD_KEY_PROVIDED
);
786 test_true(string_length
== 0);
793 /* Make sure zero length keys are marked as bad */
795 rc
= memcached_behavior_set(memc_clone
, MEMCACHED_BEHAVIOR_VERIFY_KEY
, set
);
796 test_true(rc
== MEMCACHED_SUCCESS
);
797 string
= memcached_get(memc_clone
, key
, 0,
798 &string_length
, &flags
, &rc
);
799 test_true(rc
== MEMCACHED_BAD_KEY_PROVIDED
);
800 test_true(string_length
== 0);
803 memcached_free(memc_clone
);
808 #define READ_THROUGH_VALUE "set for me"
809 static memcached_return_t
read_through_trigger(memcached_st
*memc
__attribute__((unused
)),
810 char *key
__attribute__((unused
)),
811 size_t key_length
__attribute__((unused
)),
812 memcached_result_st
*result
)
815 return memcached_result_set_value(result
, READ_THROUGH_VALUE
, strlen(READ_THROUGH_VALUE
));
818 static test_return_t
read_through(memcached_st
*memc
)
820 memcached_return_t rc
;
821 const char *key
= "foo";
823 size_t string_length
;
825 memcached_trigger_key_fn cb
= (memcached_trigger_key_fn
)read_through_trigger
;
827 string
= memcached_get(memc
, key
, strlen(key
),
828 &string_length
, &flags
, &rc
);
830 test_true(rc
== MEMCACHED_NOTFOUND
);
831 test_false(string_length
);
834 rc
= memcached_callback_set(memc
, MEMCACHED_CALLBACK_GET_FAILURE
,
836 test_true(rc
== MEMCACHED_SUCCESS
);
838 string
= memcached_get(memc
, key
, strlen(key
),
839 &string_length
, &flags
, &rc
);
841 test_true(rc
== MEMCACHED_SUCCESS
);
842 test_true(string_length
== strlen(READ_THROUGH_VALUE
));
843 test_strcmp(READ_THROUGH_VALUE
, string
);
846 string
= memcached_get(memc
, key
, strlen(key
),
847 &string_length
, &flags
, &rc
);
849 test_true(rc
== MEMCACHED_SUCCESS
);
850 test_true(string_length
== strlen(READ_THROUGH_VALUE
));
851 test_true(!strcmp(READ_THROUGH_VALUE
, string
));
857 static memcached_return_t
delete_trigger(memcached_st
*ptr
__attribute__((unused
)),
859 size_t key_length
__attribute__((unused
)))
863 return MEMCACHED_SUCCESS
;
866 static test_return_t
delete_through(memcached_st
*memc
)
868 memcached_trigger_delete_key_fn callback
;
869 memcached_return_t rc
;
871 callback
= (memcached_trigger_delete_key_fn
)delete_trigger
;
873 rc
= memcached_callback_set(memc
, MEMCACHED_CALLBACK_DELETE_TRIGGER
, *(void**)&callback
);
874 test_true(rc
== MEMCACHED_SUCCESS
);
879 static test_return_t
get_test(memcached_st
*memc
)
881 memcached_return_t rc
;
882 const char *key
= "foo";
884 size_t string_length
;
887 rc
= memcached_delete(memc
, key
, strlen(key
), (time_t)0);
888 test_true(rc
== MEMCACHED_BUFFERED
|| rc
== MEMCACHED_NOTFOUND
);
890 string
= memcached_get(memc
, key
, strlen(key
),
891 &string_length
, &flags
, &rc
);
893 test_true(rc
== MEMCACHED_NOTFOUND
);
894 test_false(string_length
);
900 static test_return_t
get_test2(memcached_st
*memc
)
902 memcached_return_t rc
;
903 const char *key
= "foo";
904 const char *value
= "when we sanitize";
906 size_t string_length
;
909 rc
= memcached_set(memc
, key
, strlen(key
),
910 value
, strlen(value
),
911 (time_t)0, (uint32_t)0);
912 test_true(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
);
914 string
= memcached_get(memc
, key
, strlen(key
),
915 &string_length
, &flags
, &rc
);
918 test_true(rc
== MEMCACHED_SUCCESS
);
919 test_true(string_length
== strlen(value
));
920 test_true(!memcmp(string
, value
, string_length
));
927 static test_return_t
set_test2(memcached_st
*memc
)
929 memcached_return_t rc
;
930 const char *key
= "foo";
931 const char *value
= "train in the brain";
932 size_t value_length
= strlen(value
);
935 for (x
= 0; x
< 10; x
++)
937 rc
= memcached_set(memc
, key
, strlen(key
),
939 (time_t)0, (uint32_t)0);
940 test_true(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
);
946 static test_return_t
set_test3(memcached_st
*memc
)
948 memcached_return_t rc
;
950 size_t value_length
= 8191;
953 value
= (char*)malloc(value_length
);
956 for (x
= 0; x
< value_length
; x
++)
957 value
[x
] = (char) (x
% 127);
959 /* The dump test relies on there being at least 32 items in memcached */
960 for (x
= 0; x
< 32; x
++)
964 sprintf(key
, "foo%u", x
);
966 rc
= memcached_set(memc
, key
, strlen(key
),
968 (time_t)0, (uint32_t)0);
969 test_true(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
);
977 static test_return_t
get_test3(memcached_st
*memc
)
979 memcached_return_t rc
;
980 const char *key
= "foo";
982 size_t value_length
= 8191;
984 size_t string_length
;
988 value
= (char*)malloc(value_length
);
991 for (x
= 0; x
< value_length
; x
++)
992 value
[x
] = (char) (x
% 127);
994 rc
= memcached_set(memc
, key
, strlen(key
),
996 (time_t)0, (uint32_t)0);
997 test_true(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
);
999 string
= memcached_get(memc
, key
, strlen(key
),
1000 &string_length
, &flags
, &rc
);
1002 test_true(rc
== MEMCACHED_SUCCESS
);
1004 test_true(string_length
== value_length
);
1005 test_true(!memcmp(string
, value
, string_length
));
1010 return TEST_SUCCESS
;
1013 static test_return_t
get_test4(memcached_st
*memc
)
1015 memcached_return_t rc
;
1016 const char *key
= "foo";
1018 size_t value_length
= 8191;
1020 size_t string_length
;
1024 value
= (char*)malloc(value_length
);
1027 for (x
= 0; x
< value_length
; x
++)
1028 value
[x
] = (char) (x
% 127);
1030 rc
= memcached_set(memc
, key
, strlen(key
),
1031 value
, value_length
,
1032 (time_t)0, (uint32_t)0);
1033 test_true(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
);
1035 for (x
= 0; x
< 10; x
++)
1037 string
= memcached_get(memc
, key
, strlen(key
),
1038 &string_length
, &flags
, &rc
);
1040 test_true(rc
== MEMCACHED_SUCCESS
);
1042 test_true(string_length
== value_length
);
1043 test_true(!memcmp(string
, value
, string_length
));
1049 return TEST_SUCCESS
;
1053 * This test verifies that memcached_read_one_response doesn't try to
1054 * dereference a NIL-pointer if you issue a multi-get and don't read out all
1055 * responses before you execute a storage command.
1057 static test_return_t
get_test5(memcached_st
*memc
)
1060 ** Request the same key twice, to ensure that we hash to the same server
1061 ** (so that we have multiple response values queued up) ;-)
1063 const char *keys
[]= { "key", "key" };
1064 size_t lengths
[]= { 3, 3 };
1068 memcached_return_t rc
= memcached_set(memc
, keys
[0], lengths
[0],
1069 keys
[0], lengths
[0], 0, 0);
1070 test_true(rc
== MEMCACHED_SUCCESS
);
1071 rc
= memcached_mget(memc
, keys
, lengths
, 2);
1073 memcached_result_st results_obj
;
1074 memcached_result_st
*results
;
1075 results
=memcached_result_create(memc
, &results_obj
);
1077 results
=memcached_fetch_result(memc
, &results_obj
, &rc
);
1079 memcached_result_free(&results_obj
);
1081 /* Don't read out the second result, but issue a set instead.. */
1082 rc
= memcached_set(memc
, keys
[0], lengths
[0], keys
[0], lengths
[0], 0, 0);
1083 test_true(rc
== MEMCACHED_SUCCESS
);
1085 char *val
= memcached_get_by_key(memc
, keys
[0], lengths
[0], "yek", 3,
1086 &rlen
, &flags
, &rc
);
1087 test_true(val
== NULL
);
1088 test_true(rc
== MEMCACHED_NOTFOUND
);
1089 val
= memcached_get(memc
, keys
[0], lengths
[0], &rlen
, &flags
, &rc
);
1090 test_true(val
!= NULL
);
1091 test_true(rc
== MEMCACHED_SUCCESS
);
1094 return TEST_SUCCESS
;
1097 static test_return_t
mget_end(memcached_st
*memc
)
1099 const char *keys
[]= { "foo", "foo2" };
1100 size_t lengths
[]= { 3, 4 };
1101 const char *values
[]= { "fjord", "41" };
1103 memcached_return_t rc
;
1106 for (int i
= 0; i
< 2; i
++)
1108 rc
= memcached_set(memc
, keys
[i
], lengths
[i
], values
[i
], strlen(values
[i
]),
1109 (time_t)0, (uint32_t)0);
1110 test_true(rc
== MEMCACHED_SUCCESS
);
1114 size_t string_length
;
1117 // retrieve both via mget
1118 rc
= memcached_mget(memc
, keys
, lengths
, 2);
1119 test_true(rc
== MEMCACHED_SUCCESS
);
1121 char key
[MEMCACHED_MAX_KEY
];
1124 // this should get both
1125 for (int i
= 0; i
< 2; i
++)
1127 string
= memcached_fetch(memc
, key
, &key_length
, &string_length
,
1129 test_true(rc
== MEMCACHED_SUCCESS
);
1131 if (key_length
== 4)
1133 test_true(string_length
== strlen(values
[val
]));
1134 test_true(strncmp(values
[val
], string
, string_length
) == 0);
1138 // this should indicate end
1139 string
= memcached_fetch(memc
, key
, &key_length
, &string_length
, &flags
, &rc
);
1140 test_true(rc
== MEMCACHED_END
);
1143 rc
= memcached_mget(memc
, keys
, lengths
, 1);
1144 test_true(rc
== MEMCACHED_SUCCESS
);
1146 string
= memcached_fetch(memc
, key
, &key_length
, &string_length
, &flags
, &rc
);
1147 test_true(key_length
== lengths
[0]);
1148 test_true(strncmp(keys
[0], key
, key_length
) == 0);
1149 test_true(string_length
== strlen(values
[0]));
1150 test_true(strncmp(values
[0], string
, string_length
) == 0);
1151 test_true(rc
== MEMCACHED_SUCCESS
);
1154 // this should indicate end
1155 string
= memcached_fetch(memc
, key
, &key_length
, &string_length
, &flags
, &rc
);
1156 test_true(rc
== MEMCACHED_END
);
1158 return TEST_SUCCESS
;
1161 /* Do not copy the style of this code, I just access hosts to testthis function */
1162 static test_return_t
stats_servername_test(memcached_st
*memc
)
1164 memcached_return_t rc
;
1165 memcached_stat_st memc_stat
;
1166 memcached_server_instance_st
*instance
=
1167 memcached_server_instance_fetch(memc
, 0);
1169 rc
= memcached_stat_servername(&memc_stat
, NULL
,
1173 return TEST_SUCCESS
;
1176 static test_return_t
increment_test(memcached_st
*memc
)
1178 uint64_t new_number
;
1179 memcached_return_t rc
;
1180 const char *key
= "number";
1181 const char *value
= "0";
1183 rc
= memcached_set(memc
, key
, strlen(key
),
1184 value
, strlen(value
),
1185 (time_t)0, (uint32_t)0);
1186 test_true(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
);
1188 rc
= memcached_increment(memc
, key
, strlen(key
),
1190 test_true(rc
== MEMCACHED_SUCCESS
);
1191 test_true(new_number
== 1);
1193 rc
= memcached_increment(memc
, key
, strlen(key
),
1195 test_true(rc
== MEMCACHED_SUCCESS
);
1196 test_true(new_number
== 2);
1198 return TEST_SUCCESS
;
1201 static test_return_t
increment_with_initial_test(memcached_st
*memc
)
1203 if (memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
) != 0)
1205 uint64_t new_number
;
1206 memcached_return_t rc
;
1207 const char *key
= "number";
1208 uint64_t initial
= 0;
1210 rc
= memcached_increment_with_initial(memc
, key
, strlen(key
),
1211 1, initial
, 0, &new_number
);
1212 test_true(rc
== MEMCACHED_SUCCESS
);
1213 test_true(new_number
== initial
);
1215 rc
= memcached_increment_with_initial(memc
, key
, strlen(key
),
1216 1, initial
, 0, &new_number
);
1217 test_true(rc
== MEMCACHED_SUCCESS
);
1218 test_true(new_number
== (initial
+ 1));
1220 return TEST_SUCCESS
;
1223 static test_return_t
decrement_test(memcached_st
*memc
)
1225 uint64_t new_number
;
1226 memcached_return_t rc
;
1227 const char *key
= "number";
1228 const char *value
= "3";
1230 rc
= memcached_set(memc
, key
, strlen(key
),
1231 value
, strlen(value
),
1232 (time_t)0, (uint32_t)0);
1233 test_true(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
);
1235 rc
= memcached_decrement(memc
, key
, strlen(key
),
1237 test_true(rc
== MEMCACHED_SUCCESS
);
1238 test_true(new_number
== 2);
1240 rc
= memcached_decrement(memc
, key
, strlen(key
),
1242 test_true(rc
== MEMCACHED_SUCCESS
);
1243 test_true(new_number
== 1);
1245 return TEST_SUCCESS
;
1248 static test_return_t
decrement_with_initial_test(memcached_st
*memc
)
1250 if (memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
) != 0)
1252 uint64_t new_number
;
1253 memcached_return_t rc
;
1254 const char *key
= "number";
1255 uint64_t initial
= 3;
1257 rc
= memcached_decrement_with_initial(memc
, key
, strlen(key
),
1258 1, initial
, 0, &new_number
);
1259 test_true(rc
== MEMCACHED_SUCCESS
);
1260 test_true(new_number
== initial
);
1262 rc
= memcached_decrement_with_initial(memc
, key
, strlen(key
),
1263 1, initial
, 0, &new_number
);
1264 test_true(rc
== MEMCACHED_SUCCESS
);
1265 test_true(new_number
== (initial
- 1));
1267 return TEST_SUCCESS
;
1270 static test_return_t
increment_by_key_test(memcached_st
*memc
)
1272 uint64_t new_number
;
1273 memcached_return_t rc
;
1274 const char *master_key
= "foo";
1275 const char *key
= "number";
1276 const char *value
= "0";
1278 rc
= memcached_set_by_key(memc
, master_key
, strlen(master_key
),
1280 value
, strlen(value
),
1281 (time_t)0, (uint32_t)0);
1282 test_true(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
);
1284 rc
= memcached_increment_by_key(memc
, master_key
, strlen(master_key
), key
, strlen(key
),
1286 test_true(rc
== MEMCACHED_SUCCESS
);
1287 test_true(new_number
== 1);
1289 rc
= memcached_increment_by_key(memc
, master_key
, strlen(master_key
), key
, strlen(key
),
1291 test_true(rc
== MEMCACHED_SUCCESS
);
1292 test_true(new_number
== 2);
1294 return TEST_SUCCESS
;
1297 static test_return_t
increment_with_initial_by_key_test(memcached_st
*memc
)
1299 if (memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
) != 0)
1301 uint64_t new_number
;
1302 memcached_return_t rc
;
1303 const char *master_key
= "foo";
1304 const char *key
= "number";
1305 uint64_t initial
= 0;
1307 rc
= memcached_increment_with_initial_by_key(memc
, master_key
, strlen(master_key
),
1309 1, initial
, 0, &new_number
);
1310 test_true(rc
== MEMCACHED_SUCCESS
);
1311 test_true(new_number
== initial
);
1313 rc
= memcached_increment_with_initial_by_key(memc
, master_key
, strlen(master_key
),
1315 1, initial
, 0, &new_number
);
1316 test_true(rc
== MEMCACHED_SUCCESS
);
1317 test_true(new_number
== (initial
+ 1));
1319 return TEST_SUCCESS
;
1322 static test_return_t
decrement_by_key_test(memcached_st
*memc
)
1324 uint64_t new_number
;
1325 memcached_return_t rc
;
1326 const char *master_key
= "foo";
1327 const char *key
= "number";
1328 const char *value
= "3";
1330 rc
= memcached_set_by_key(memc
, master_key
, strlen(master_key
),
1332 value
, strlen(value
),
1333 (time_t)0, (uint32_t)0);
1334 test_true(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
);
1336 rc
= memcached_decrement_by_key(memc
, master_key
, strlen(master_key
),
1339 test_true(rc
== MEMCACHED_SUCCESS
);
1340 test_true(new_number
== 2);
1342 rc
= memcached_decrement_by_key(memc
, master_key
, strlen(master_key
),
1345 test_true(rc
== MEMCACHED_SUCCESS
);
1346 test_true(new_number
== 1);
1348 return TEST_SUCCESS
;
1351 static test_return_t
decrement_with_initial_by_key_test(memcached_st
*memc
)
1353 if (memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
) != 0)
1355 uint64_t new_number
;
1356 memcached_return_t rc
;
1357 const char *master_key
= "foo";
1358 const char *key
= "number";
1359 uint64_t initial
= 3;
1361 rc
= memcached_decrement_with_initial_by_key(memc
, master_key
, strlen(master_key
),
1363 1, initial
, 0, &new_number
);
1364 test_true(rc
== MEMCACHED_SUCCESS
);
1365 test_true(new_number
== initial
);
1367 rc
= memcached_decrement_with_initial_by_key(memc
, master_key
, strlen(master_key
),
1369 1, initial
, 0, &new_number
);
1370 test_true(rc
== MEMCACHED_SUCCESS
);
1371 test_true(new_number
== (initial
- 1));
1373 return TEST_SUCCESS
;
1376 static test_return_t
quit_test(memcached_st
*memc
)
1378 memcached_return_t rc
;
1379 const char *key
= "fudge";
1380 const char *value
= "sanford and sun";
1382 rc
= memcached_set(memc
, key
, strlen(key
),
1383 value
, strlen(value
),
1384 (time_t)10, (uint32_t)3);
1385 test_true(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
);
1386 memcached_quit(memc
);
1388 rc
= memcached_set(memc
, key
, strlen(key
),
1389 value
, strlen(value
),
1390 (time_t)50, (uint32_t)9);
1391 test_true(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
);
1393 return TEST_SUCCESS
;
1396 static test_return_t
mget_result_test(memcached_st
*memc
)
1398 memcached_return_t rc
;
1399 const char *keys
[]= {"fudge", "son", "food"};
1400 size_t key_length
[]= {5, 3, 4};
1403 memcached_result_st results_obj
;
1404 memcached_result_st
*results
;
1406 results
= memcached_result_create(memc
, &results_obj
);
1408 test_true(&results_obj
== results
);
1410 /* We need to empty the server before continueing test */
1411 rc
= memcached_flush(memc
, 0);
1412 test_true(rc
== MEMCACHED_SUCCESS
);
1414 rc
= memcached_mget(memc
, keys
, key_length
, 3);
1415 test_true(rc
== MEMCACHED_SUCCESS
);
1417 while ((results
= memcached_fetch_result(memc
, &results_obj
, &rc
)) != NULL
)
1422 while ((results
= memcached_fetch_result(memc
, &results_obj
, &rc
)) != NULL
)
1423 test_true(!results
);
1424 test_true(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 test_true(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
);
1434 rc
= memcached_mget(memc
, keys
, key_length
, 3);
1435 test_true(rc
== MEMCACHED_SUCCESS
);
1437 while ((results
= memcached_fetch_result(memc
, &results_obj
, &rc
)))
1440 test_true(&results_obj
== results
);
1441 test_true(rc
== MEMCACHED_SUCCESS
);
1442 test_true(memcached_result_key_length(results
) == memcached_result_length(results
));
1443 test_true(!memcmp(memcached_result_key_value(results
),
1444 memcached_result_value(results
),
1445 memcached_result_length(results
)));
1448 memcached_result_free(&results_obj
);
1450 return TEST_SUCCESS
;
1453 static test_return_t
mget_result_alloc_test(memcached_st
*memc
)
1455 memcached_return_t rc
;
1456 const char *keys
[]= {"fudge", "son", "food"};
1457 size_t key_length
[]= {5, 3, 4};
1460 memcached_result_st
*results
;
1462 /* We need to empty the server before continueing test */
1463 rc
= memcached_flush(memc
, 0);
1464 test_true(rc
== MEMCACHED_SUCCESS
);
1466 rc
= memcached_mget(memc
, keys
, key_length
, 3);
1467 test_true(rc
== MEMCACHED_SUCCESS
);
1469 while ((results
= memcached_fetch_result(memc
, NULL
, &rc
)) != NULL
)
1473 test_true(!results
);
1474 test_true(rc
== MEMCACHED_END
);
1476 for (x
= 0; x
< 3; x
++)
1478 rc
= memcached_set(memc
, keys
[x
], key_length
[x
],
1479 keys
[x
], key_length
[x
],
1480 (time_t)50, (uint32_t)9);
1481 test_true(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
);
1484 rc
= memcached_mget(memc
, keys
, key_length
, 3);
1485 test_true(rc
== MEMCACHED_SUCCESS
);
1488 while ((results
= memcached_fetch_result(memc
, NULL
, &rc
)))
1491 test_true(rc
== MEMCACHED_SUCCESS
);
1492 test_true(memcached_result_key_length(results
) == memcached_result_length(results
));
1493 test_true(!memcmp(memcached_result_key_value(results
),
1494 memcached_result_value(results
),
1495 memcached_result_length(results
)));
1496 memcached_result_free(results
);
1500 return TEST_SUCCESS
;
1503 /* Count the results */
1504 static memcached_return_t
callback_counter(const memcached_st
*ptr
__attribute__((unused
)),
1505 memcached_result_st
*result
__attribute__((unused
)),
1508 size_t *counter
= (size_t *)context
;
1510 *counter
= *counter
+ 1;
1512 return MEMCACHED_SUCCESS
;
1515 static test_return_t
mget_result_function(memcached_st
*memc
)
1517 memcached_return_t rc
;
1518 const char *keys
[]= {"fudge", "son", "food"};
1519 size_t key_length
[]= {5, 3, 4};
1522 memcached_execute_fn callbacks
[1];
1524 /* We need to empty the server before continueing test */
1525 rc
= memcached_flush(memc
, 0);
1526 for (x
= 0; x
< 3; x
++)
1528 rc
= memcached_set(memc
, keys
[x
], key_length
[x
],
1529 keys
[x
], key_length
[x
],
1530 (time_t)50, (uint32_t)9);
1531 test_true(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
);
1534 rc
= memcached_mget(memc
, keys
, key_length
, 3);
1535 test_true(rc
== MEMCACHED_SUCCESS
);
1537 callbacks
[0]= &callback_counter
;
1539 rc
= memcached_fetch_execute(memc
, callbacks
, (void *)&counter
, 1);
1541 test_true(counter
== 3);
1543 return TEST_SUCCESS
;
1546 static test_return_t
mget_test(memcached_st
*memc
)
1548 memcached_return_t rc
;
1549 const char *keys
[]= {"fudge", "son", "food"};
1550 size_t key_length
[]= {5, 3, 4};
1554 char return_key
[MEMCACHED_MAX_KEY
];
1555 size_t return_key_length
;
1557 size_t return_value_length
;
1559 /* We need to empty the server before continueing test */
1560 rc
= memcached_flush(memc
, 0);
1561 test_true(rc
== MEMCACHED_SUCCESS
);
1563 rc
= memcached_mget(memc
, keys
, key_length
, 3);
1564 test_true(rc
== MEMCACHED_SUCCESS
);
1566 while ((return_value
= memcached_fetch(memc
, return_key
, &return_key_length
,
1567 &return_value_length
, &flags
, &rc
)) != NULL
)
1569 test_true(return_value
);
1571 test_true(!return_value
);
1572 test_true(return_value_length
== 0);
1573 test_true(rc
== MEMCACHED_END
);
1575 for (x
= 0; x
< 3; x
++)
1577 rc
= memcached_set(memc
, keys
[x
], key_length
[x
],
1578 keys
[x
], key_length
[x
],
1579 (time_t)50, (uint32_t)9);
1580 test_true(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
);
1583 rc
= memcached_mget(memc
, keys
, key_length
, 3);
1584 test_true(rc
== MEMCACHED_SUCCESS
);
1587 while ((return_value
= memcached_fetch(memc
, return_key
, &return_key_length
,
1588 &return_value_length
, &flags
, &rc
)))
1590 test_true(return_value
);
1591 test_true(rc
== MEMCACHED_SUCCESS
);
1592 test_true(return_key_length
== return_value_length
);
1593 test_true(!memcmp(return_value
, return_key
, return_value_length
));
1598 return TEST_SUCCESS
;
1601 static test_return_t
mget_execute(memcached_st
*memc
)
1605 if (memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
) != 0)
1609 * I only want to hit _one_ server so I know the number of requests I'm
1610 * sending in the pipeline.
1612 uint32_t number_of_hosts
= memc
->number_of_hosts
;
1613 memc
->number_of_hosts
= 1;
1615 size_t max_keys
= binary
? 20480 : 1;
1618 char **keys
= calloc(max_keys
, sizeof(char*));
1619 size_t *key_length
=calloc(max_keys
, sizeof(size_t));
1621 /* First add all of the items.. */
1622 char blob
[1024] = {0};
1623 memcached_return_t rc
;
1624 for (size_t x
= 0; x
< max_keys
; ++x
)
1628 key_length
[x
]= (size_t)snprintf(k
, sizeof(k
), "0200%zu", x
);
1630 test_true(keys
[x
] != NULL
);
1631 rc
= memcached_add(memc
, keys
[x
], key_length
[x
], blob
, sizeof(blob
), 0, 0);
1632 test_true(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
);
1635 /* Try to get all of them with a large multiget */
1637 memcached_execute_fn callbacks
[1]= { [0]= &callback_counter
};
1638 rc
= memcached_mget_execute(memc
, (const char**)keys
, key_length
,
1639 max_keys
, callbacks
, &counter
, 1);
1643 test_true(rc
== MEMCACHED_SUCCESS
);
1645 rc
= memcached_fetch_execute(memc
, callbacks
, (void *)&counter
, 1);
1646 test_true(rc
== MEMCACHED_END
);
1648 /* Verify that we got all of the items */
1649 test_true(counter
== max_keys
);
1653 test_true(rc
== MEMCACHED_NOT_SUPPORTED
);
1654 test_true(counter
== 0);
1657 /* Release all allocated resources */
1658 for (size_t x
= 0; x
< max_keys
; ++x
)
1665 memc
->number_of_hosts
= number_of_hosts
;
1666 return TEST_SUCCESS
;
1669 static test_return_t
get_stats_keys(memcached_st
*memc
)
1673 memcached_stat_st memc_stat
;
1674 memcached_return_t rc
;
1676 stat_list
= memcached_stat_get_keys(memc
, &memc_stat
, &rc
);
1677 test_true(rc
== MEMCACHED_SUCCESS
);
1678 for (ptr
= stat_list
; *ptr
; ptr
++)
1683 return TEST_SUCCESS
;
1686 static test_return_t
version_string_test(memcached_st
*memc
__attribute__((unused
)))
1688 const char *version_string
;
1690 version_string
= memcached_lib_version();
1692 test_true(!strcmp(version_string
, LIBMEMCACHED_VERSION_STRING
));
1694 return TEST_SUCCESS
;
1697 static test_return_t
get_stats(memcached_st
*memc
)
1701 memcached_return_t rc
;
1702 memcached_stat_st
*memc_stat
;
1704 memc_stat
= memcached_stat(memc
, NULL
, &rc
);
1705 test_true(rc
== MEMCACHED_SUCCESS
);
1707 test_true(rc
== MEMCACHED_SUCCESS
);
1708 test_true(memc_stat
);
1710 for (uint32_t x
= 0; x
< memcached_server_count(memc
); x
++)
1712 stat_list
= memcached_stat_get_keys(memc
, memc_stat
+x
, &rc
);
1713 test_true(rc
== MEMCACHED_SUCCESS
);
1714 for (ptr
= stat_list
; *ptr
; ptr
++);
1719 memcached_stat_free(NULL
, memc_stat
);
1721 return TEST_SUCCESS
;
1724 static test_return_t
add_host_test(memcached_st
*memc
)
1727 memcached_server_st
*servers
;
1728 memcached_return_t rc
;
1729 char servername
[]= "0.example.com";
1731 servers
= memcached_server_list_append_with_weight(NULL
, servername
, 400, 0, &rc
);
1733 test_true(1 == memcached_server_list_count(servers
));
1735 for (x
= 2; x
< 20; x
++)
1737 char buffer
[SMALL_STRING_LEN
];
1739 snprintf(buffer
, SMALL_STRING_LEN
, "%u.example.com", 400+x
);
1740 servers
= memcached_server_list_append_with_weight(servers
, buffer
, 401, 0,
1742 test_true(rc
== MEMCACHED_SUCCESS
);
1743 test_true(x
== memcached_server_list_count(servers
));
1746 rc
= memcached_server_push(memc
, servers
);
1747 test_true(rc
== MEMCACHED_SUCCESS
);
1748 rc
= memcached_server_push(memc
, servers
);
1749 test_true(rc
== MEMCACHED_SUCCESS
);
1751 memcached_server_list_free(servers
);
1753 return TEST_SUCCESS
;
1756 static memcached_return_t
clone_test_callback(memcached_st
*parent
__attribute__((unused
)), memcached_st
*memc_clone
__attribute__((unused
)))
1758 return MEMCACHED_SUCCESS
;
1761 static memcached_return_t
cleanup_test_callback(memcached_st
*ptr
__attribute__((unused
)))
1763 return MEMCACHED_SUCCESS
;
1766 static test_return_t
callback_test(memcached_st
*memc
)
1768 /* Test User Data */
1772 memcached_return_t rc
;
1774 rc
= memcached_callback_set(memc
, MEMCACHED_CALLBACK_USER_DATA
, &x
);
1775 test_true(rc
== MEMCACHED_SUCCESS
);
1776 test_ptr
= (int *)memcached_callback_get(memc
, MEMCACHED_CALLBACK_USER_DATA
, &rc
);
1777 test_true(*test_ptr
== x
);
1780 /* Test Clone Callback */
1782 memcached_clone_fn clone_cb
= (memcached_clone_fn
)clone_test_callback
;
1783 void *clone_cb_ptr
= *(void **)&clone_cb
;
1784 void *temp_function
= NULL
;
1785 memcached_return_t rc
;
1787 rc
= memcached_callback_set(memc
, MEMCACHED_CALLBACK_CLONE_FUNCTION
,
1789 test_true(rc
== MEMCACHED_SUCCESS
);
1790 temp_function
= memcached_callback_get(memc
, MEMCACHED_CALLBACK_CLONE_FUNCTION
, &rc
);
1791 test_true(temp_function
== clone_cb_ptr
);
1794 /* Test Cleanup Callback */
1796 memcached_cleanup_fn cleanup_cb
=
1797 (memcached_cleanup_fn
)cleanup_test_callback
;
1798 void *cleanup_cb_ptr
= *(void **)&cleanup_cb
;
1799 void *temp_function
= NULL
;
1800 memcached_return_t rc
;
1802 rc
= memcached_callback_set(memc
, MEMCACHED_CALLBACK_CLONE_FUNCTION
,
1804 test_true(rc
== MEMCACHED_SUCCESS
);
1805 temp_function
= memcached_callback_get(memc
, MEMCACHED_CALLBACK_CLONE_FUNCTION
, &rc
);
1806 test_true(temp_function
== cleanup_cb_ptr
);
1809 return TEST_SUCCESS
;
1812 /* We don't test the behavior itself, we test the switches */
1813 static test_return_t
behavior_test(memcached_st
*memc
)
1818 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NO_BLOCK
, set
);
1819 value
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_NO_BLOCK
);
1820 test_true(value
== 1);
1822 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_TCP_NODELAY
, set
);
1823 value
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_TCP_NODELAY
);
1824 test_true(value
== 1);
1826 set
= MEMCACHED_HASH_MD5
;
1827 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_HASH
, set
);
1828 value
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_HASH
);
1829 test_true(value
== MEMCACHED_HASH_MD5
);
1833 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NO_BLOCK
, set
);
1834 value
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_NO_BLOCK
);
1835 test_true(value
== 0);
1837 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_TCP_NODELAY
, set
);
1838 value
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_TCP_NODELAY
);
1839 test_true(value
== 0);
1841 set
= MEMCACHED_HASH_DEFAULT
;
1842 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_HASH
, set
);
1843 value
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_HASH
);
1844 test_true(value
== MEMCACHED_HASH_DEFAULT
);
1846 set
= MEMCACHED_HASH_CRC
;
1847 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_HASH
, set
);
1848 value
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_HASH
);
1849 test_true(value
== MEMCACHED_HASH_CRC
);
1851 value
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_SOCKET_SEND_SIZE
);
1852 test_true(value
> 0);
1854 value
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_SOCKET_RECV_SIZE
);
1855 test_true(value
> 0);
1857 value
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_NUMBER_OF_REPLICAS
);
1858 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NUMBER_OF_REPLICAS
, value
+ 1);
1859 test_true((value
+ 1) == memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_NUMBER_OF_REPLICAS
));
1861 return TEST_SUCCESS
;
1864 static test_return_t
MEMCACHED_BEHAVIOR_CORK_test(memcached_st
*memc
)
1866 memcached_return_t rc
;
1870 rc
= memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_CORK
, set
);
1871 test_true(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_NOT_SUPPORTED
);
1873 value
= (bool)memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_CORK
);
1875 if (rc
== MEMCACHED_SUCCESS
)
1877 test_true((bool)value
== set
);
1881 test_false((bool)value
== set
);
1884 return TEST_SUCCESS
;
1887 static test_return_t
fetch_all_results(memcached_st
*memc
)
1889 memcached_return_t rc
= MEMCACHED_SUCCESS
;
1890 char return_key
[MEMCACHED_MAX_KEY
];
1891 size_t return_key_length
;
1893 size_t return_value_length
;
1896 while ((return_value
= memcached_fetch(memc
, return_key
, &return_key_length
,
1897 &return_value_length
, &flags
, &rc
)))
1899 test_true(return_value
);
1900 test_true(rc
== MEMCACHED_SUCCESS
);
1904 return ((rc
== MEMCACHED_END
) || (rc
== MEMCACHED_SUCCESS
)) ? TEST_SUCCESS
: TEST_FAILURE
;
1907 /* Test case provided by Cal Haldenbrand */
1908 static test_return_t
user_supplied_bug1(memcached_st
*memc
)
1910 unsigned int setter
= 1;
1912 unsigned long long total
= 0;
1915 char randomstuff
[6 * 1024];
1916 memcached_return_t rc
;
1918 memset(randomstuff
, 0, 6 * 1024);
1920 /* We just keep looking at the same values over and over */
1923 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NO_BLOCK
, setter
);
1924 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_TCP_NODELAY
, setter
);
1928 for (uint32_t x
= 0 ; total
< 20 * 1024576 ; x
++ )
1932 size
= (uint32_t)(rand() % ( 5 * 1024 ) ) + 400;
1933 memset(randomstuff
, 0, 6 * 1024);
1934 test_true(size
< 6 * 1024); /* Being safe here */
1936 for (j
= 0 ; j
< size
;j
++)
1937 randomstuff
[j
] = (signed char) ((rand() % 26) + 97);
1940 snprintf(key
, sizeof(key
), "%u", x
);
1941 rc
= memcached_set(memc
, key
, strlen(key
),
1942 randomstuff
, strlen(randomstuff
), 10, 0);
1943 test_true(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
);
1944 /* If we fail, lets try again */
1945 if (rc
!= MEMCACHED_SUCCESS
&& rc
!= MEMCACHED_BUFFERED
)
1946 rc
= memcached_set(memc
, key
, strlen(key
),
1947 randomstuff
, strlen(randomstuff
), 10, 0);
1948 test_true(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
);
1951 return TEST_SUCCESS
;
1954 /* Test case provided by Cal Haldenbrand */
1955 static test_return_t
user_supplied_bug2(memcached_st
*memc
)
1957 unsigned int setter
;
1961 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NO_BLOCK
, setter
);
1962 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_TCP_NODELAY
, setter
);
1964 setter
= 20 * 1024576;
1965 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_SOCKET_SEND_SIZE
, setter
);
1966 setter
= 20 * 1024576;
1967 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_SOCKET_RECV_SIZE
, setter
);
1968 getter
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_SOCKET_SEND_SIZE
);
1969 getter
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_SOCKET_RECV_SIZE
);
1971 for (x
= 0, errors
= 0; total
< 20 * 1024576 ; x
++)
1974 for (uint32_t x
= 0, errors
= 0; total
< 24576 ; x
++)
1976 memcached_return_t rc
= MEMCACHED_SUCCESS
;
1977 char buffer
[SMALL_STRING_LEN
];
1982 memset(buffer
, 0, SMALL_STRING_LEN
);
1984 snprintf(buffer
, sizeof(buffer
), "%u", x
);
1985 getval
= memcached_get(memc
, buffer
, strlen(buffer
),
1986 &val_len
, &flags
, &rc
);
1987 if (rc
!= MEMCACHED_SUCCESS
)
1989 if (rc
== MEMCACHED_NOTFOUND
)
2003 return TEST_SUCCESS
;
2006 /* Do a large mget() over all the keys we think exist */
2007 #define KEY_COUNT 3000 // * 1024576
2008 static test_return_t
user_supplied_bug3(memcached_st
*memc
)
2010 memcached_return_t rc
;
2011 unsigned int setter
;
2014 size_t key_lengths
[KEY_COUNT
];
2017 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NO_BLOCK
, setter
);
2018 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_TCP_NODELAY
, setter
);
2020 setter
= 20 * 1024576;
2021 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_SOCKET_SEND_SIZE
, setter
);
2022 setter
= 20 * 1024576;
2023 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_SOCKET_RECV_SIZE
, setter
);
2024 getter
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_SOCKET_SEND_SIZE
);
2025 getter
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_SOCKET_RECV_SIZE
);
2028 keys
= calloc(KEY_COUNT
, sizeof(char *));
2030 for (x
= 0; x
< KEY_COUNT
; x
++)
2034 snprintf(buffer
, 30, "%u", x
);
2035 keys
[x
]= strdup(buffer
);
2036 key_lengths
[x
]= strlen(keys
[x
]);
2039 rc
= memcached_mget(memc
, (const char **)keys
, key_lengths
, KEY_COUNT
);
2040 test_true(rc
== MEMCACHED_SUCCESS
);
2042 test_true(fetch_all_results(memc
) == TEST_SUCCESS
);
2044 for (x
= 0; x
< KEY_COUNT
; x
++)
2048 return TEST_SUCCESS
;
2051 /* Make sure we behave properly if server list has no values */
2052 static test_return_t
user_supplied_bug4(memcached_st
*memc
)
2054 memcached_return_t rc
;
2055 const char *keys
[]= {"fudge", "son", "food"};
2056 size_t key_length
[]= {5, 3, 4};
2059 char return_key
[MEMCACHED_MAX_KEY
];
2060 size_t return_key_length
;
2062 size_t return_value_length
;
2064 /* Here we free everything before running a bunch of mget tests */
2065 memcached_servers_reset(memc
);
2068 /* We need to empty the server before continueing test */
2069 rc
= memcached_flush(memc
, 0);
2070 test_true(rc
== MEMCACHED_NO_SERVERS
);
2072 rc
= memcached_mget(memc
, keys
, key_length
, 3);
2073 test_true(rc
== MEMCACHED_NO_SERVERS
);
2075 while ((return_value
= memcached_fetch(memc
, return_key
, &return_key_length
,
2076 &return_value_length
, &flags
, &rc
)) != NULL
)
2078 test_true(return_value
);
2080 test_true(!return_value
);
2081 test_true(return_value_length
== 0);
2082 test_true(rc
== MEMCACHED_NO_SERVERS
);
2084 for (x
= 0; x
< 3; x
++)
2086 rc
= memcached_set(memc
, keys
[x
], key_length
[x
],
2087 keys
[x
], key_length
[x
],
2088 (time_t)50, (uint32_t)9);
2089 test_true(rc
== MEMCACHED_NO_SERVERS
);
2092 rc
= memcached_mget(memc
, keys
, key_length
, 3);
2093 test_true(rc
== MEMCACHED_NO_SERVERS
);
2096 while ((return_value
= memcached_fetch(memc
, return_key
, &return_key_length
,
2097 &return_value_length
, &flags
, &rc
)))
2099 test_true(return_value
);
2100 test_true(rc
== MEMCACHED_SUCCESS
);
2101 test_true(return_key_length
== return_value_length
);
2102 test_true(!memcmp(return_value
, return_key
, return_value_length
));
2107 return TEST_SUCCESS
;
2110 #define VALUE_SIZE_BUG5 1048064
2111 static test_return_t
user_supplied_bug5(memcached_st
*memc
)
2113 memcached_return_t rc
;
2114 const char *keys
[]= {"036790384900", "036790384902", "036790384904", "036790384906"};
2115 size_t key_length
[]= {strlen("036790384900"), strlen("036790384902"), strlen("036790384904"), strlen("036790384906")};
2116 char return_key
[MEMCACHED_MAX_KEY
];
2117 size_t return_key_length
;
2119 size_t value_length
;
2123 char insert_data
[VALUE_SIZE_BUG5
];
2125 for (x
= 0; x
< VALUE_SIZE_BUG5
; x
++)
2126 insert_data
[x
]= (signed char)rand();
2128 memcached_flush(memc
, 0);
2129 value
= memcached_get(memc
, keys
[0], key_length
[0],
2130 &value_length
, &flags
, &rc
);
2131 test_true(value
== NULL
);
2132 rc
= memcached_mget(memc
, keys
, key_length
, 4);
2135 while ((value
= memcached_fetch(memc
, return_key
, &return_key_length
,
2136 &value_length
, &flags
, &rc
)))
2138 test_true(count
== 0);
2140 for (x
= 0; x
< 4; x
++)
2142 rc
= memcached_set(memc
, keys
[x
], key_length
[x
],
2143 insert_data
, VALUE_SIZE_BUG5
,
2144 (time_t)0, (uint32_t)0);
2145 test_true(rc
== MEMCACHED_SUCCESS
);
2148 for (x
= 0; x
< 10; x
++)
2150 value
= memcached_get(memc
, keys
[0], key_length
[0],
2151 &value_length
, &flags
, &rc
);
2155 rc
= memcached_mget(memc
, keys
, key_length
, 4);
2157 while ((value
= memcached_fetch(memc
, return_key
, &return_key_length
,
2158 &value_length
, &flags
, &rc
)))
2163 test_true(count
== 4);
2166 return TEST_SUCCESS
;
2169 static test_return_t
user_supplied_bug6(memcached_st
*memc
)
2171 memcached_return_t rc
;
2172 const char *keys
[]= {"036790384900", "036790384902", "036790384904", "036790384906"};
2173 size_t key_length
[]= {strlen("036790384900"), strlen("036790384902"), strlen("036790384904"), strlen("036790384906")};
2174 char return_key
[MEMCACHED_MAX_KEY
];
2175 size_t return_key_length
;
2177 size_t value_length
;
2181 char insert_data
[VALUE_SIZE_BUG5
];
2183 for (x
= 0; x
< VALUE_SIZE_BUG5
; x
++)
2184 insert_data
[x
]= (signed char)rand();
2186 memcached_flush(memc
, 0);
2187 value
= memcached_get(memc
, keys
[0], key_length
[0],
2188 &value_length
, &flags
, &rc
);
2189 test_true(value
== NULL
);
2190 test_true(rc
== MEMCACHED_NOTFOUND
);
2191 rc
= memcached_mget(memc
, keys
, key_length
, 4);
2192 test_true(rc
== MEMCACHED_SUCCESS
);
2195 while ((value
= memcached_fetch(memc
, return_key
, &return_key_length
,
2196 &value_length
, &flags
, &rc
)))
2198 test_true(count
== 0);
2199 test_true(rc
== MEMCACHED_END
);
2201 for (x
= 0; x
< 4; x
++)
2203 rc
= memcached_set(memc
, keys
[x
], key_length
[x
],
2204 insert_data
, VALUE_SIZE_BUG5
,
2205 (time_t)0, (uint32_t)0);
2206 test_true(rc
== MEMCACHED_SUCCESS
);
2209 for (x
= 0; x
< 2; x
++)
2211 value
= memcached_get(memc
, keys
[0], key_length
[0],
2212 &value_length
, &flags
, &rc
);
2216 rc
= memcached_mget(memc
, keys
, key_length
, 4);
2217 test_true(rc
== MEMCACHED_SUCCESS
);
2219 /* We test for purge of partial complete fetches */
2220 for (count
= 3; count
; count
--)
2222 value
= memcached_fetch(memc
, return_key
, &return_key_length
,
2223 &value_length
, &flags
, &rc
);
2224 test_true(rc
== MEMCACHED_SUCCESS
);
2225 test_true(!(memcmp(value
, insert_data
, value_length
)));
2226 test_true(value_length
);
2231 return TEST_SUCCESS
;
2234 static test_return_t
user_supplied_bug8(memcached_st
*memc
__attribute__((unused
)))
2236 memcached_return_t rc
;
2238 memcached_st
*memc_clone
;
2240 memcached_server_st
*servers
;
2241 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";
2243 servers
= memcached_servers_parse(server_list
);
2246 mine
= memcached_create(NULL
);
2247 rc
= memcached_server_push(mine
, servers
);
2248 test_true(rc
== MEMCACHED_SUCCESS
);
2249 memcached_server_list_free(servers
);
2252 memc_clone
= memcached_clone(NULL
, mine
);
2254 memcached_quit(mine
);
2255 memcached_quit(memc_clone
);
2258 memcached_free(mine
);
2259 memcached_free(memc_clone
);
2261 return TEST_SUCCESS
;
2264 /* Test flag store/retrieve */
2265 static test_return_t
user_supplied_bug7(memcached_st
*memc
)
2267 memcached_return_t rc
;
2268 const char *keys
= "036790384900";
2269 size_t key_length
= strlen(keys
);
2270 char return_key
[MEMCACHED_MAX_KEY
];
2271 size_t return_key_length
;
2273 size_t value_length
;
2276 char insert_data
[VALUE_SIZE_BUG5
];
2278 for (x
= 0; x
< VALUE_SIZE_BUG5
; x
++)
2279 insert_data
[x
]= (signed char)rand();
2281 memcached_flush(memc
, 0);
2284 rc
= memcached_set(memc
, keys
, key_length
,
2285 insert_data
, VALUE_SIZE_BUG5
,
2287 test_true(rc
== MEMCACHED_SUCCESS
);
2290 value
= memcached_get(memc
, keys
, key_length
,
2291 &value_length
, &flags
, &rc
);
2292 test_true(flags
== 245);
2296 rc
= memcached_mget(memc
, &keys
, &key_length
, 1);
2299 value
= memcached_fetch(memc
, return_key
, &return_key_length
,
2300 &value_length
, &flags
, &rc
);
2301 test_true(flags
== 245);
2306 return TEST_SUCCESS
;
2309 static test_return_t
user_supplied_bug9(memcached_st
*memc
)
2311 memcached_return_t rc
;
2312 const char *keys
[]= {"UDATA:edevil@sapo.pt", "fudge&*@#", "for^#@&$not"};
2313 size_t key_length
[3];
2318 char return_key
[MEMCACHED_MAX_KEY
];
2319 size_t return_key_length
;
2321 size_t return_value_length
;
2324 key_length
[0]= strlen("UDATA:edevil@sapo.pt");
2325 key_length
[1]= strlen("fudge&*@#");
2326 key_length
[2]= strlen("for^#@&$not");
2329 for (x
= 0; x
< 3; x
++)
2331 rc
= memcached_set(memc
, keys
[x
], key_length
[x
],
2332 keys
[x
], key_length
[x
],
2333 (time_t)50, (uint32_t)9);
2334 test_true(rc
== MEMCACHED_SUCCESS
);
2337 rc
= memcached_mget(memc
, keys
, key_length
, 3);
2338 test_true(rc
== MEMCACHED_SUCCESS
);
2340 /* We need to empty the server before continueing test */
2341 while ((return_value
= memcached_fetch(memc
, return_key
, &return_key_length
,
2342 &return_value_length
, &flags
, &rc
)) != NULL
)
2344 test_true(return_value
);
2348 test_true(count
== 3);
2350 return TEST_SUCCESS
;
2353 /* We are testing with aggressive timeout to get failures */
2354 static test_return_t
user_supplied_bug10(memcached_st
*memc
)
2356 const char *key
= "foo";
2358 size_t value_length
= 512;
2361 memcached_return_t rc
;
2362 unsigned int set
= 1;
2363 memcached_st
*mclone
= memcached_clone(NULL
, memc
);
2366 memcached_behavior_set(mclone
, MEMCACHED_BEHAVIOR_NO_BLOCK
, set
);
2367 memcached_behavior_set(mclone
, MEMCACHED_BEHAVIOR_TCP_NODELAY
, set
);
2369 memcached_behavior_set(mclone
, MEMCACHED_BEHAVIOR_POLL_TIMEOUT
,
2372 value
= (char*)malloc(value_length
* sizeof(char));
2374 for (x
= 0; x
< value_length
; x
++)
2375 value
[x
]= (char) (x
% 127);
2377 for (x
= 1; x
<= 100000; ++x
)
2379 rc
= memcached_set(mclone
, key
, key_len
,value
, value_length
, 0, 0);
2381 test_true(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_WRITE_FAILURE
||
2382 rc
== MEMCACHED_BUFFERED
|| rc
== MEMCACHED_TIMEOUT
);
2384 if (rc
== MEMCACHED_WRITE_FAILURE
|| rc
== MEMCACHED_TIMEOUT
)
2389 memcached_free(mclone
);
2391 return TEST_SUCCESS
;
2395 We are looking failures in the async protocol
2397 static test_return_t
user_supplied_bug11(memcached_st
*memc
)
2399 const char *key
= "foo";
2401 size_t value_length
= 512;
2404 memcached_return_t rc
;
2405 unsigned int set
= 1;
2407 memcached_st
*mclone
= memcached_clone(NULL
, memc
);
2409 memcached_behavior_set(mclone
, MEMCACHED_BEHAVIOR_NO_BLOCK
, set
);
2410 memcached_behavior_set(mclone
, MEMCACHED_BEHAVIOR_TCP_NODELAY
, set
);
2412 memcached_behavior_set(mclone
, MEMCACHED_BEHAVIOR_POLL_TIMEOUT
,
2415 timeout
= (int32_t)memcached_behavior_get(mclone
, MEMCACHED_BEHAVIOR_POLL_TIMEOUT
);
2417 test_true(timeout
== -1);
2419 value
= (char*)malloc(value_length
* sizeof(char));
2421 for (x
= 0; x
< value_length
; x
++)
2422 value
[x
]= (char) (x
% 127);
2424 for (x
= 1; x
<= 100000; ++x
)
2426 rc
= memcached_set(mclone
, key
, key_len
,value
, value_length
, 0, 0);
2430 memcached_free(mclone
);
2432 return TEST_SUCCESS
;
2436 Bug found where incr was not returning MEMCACHED_NOTFOUND when object did not exist.
2438 static test_return_t
user_supplied_bug12(memcached_st
*memc
)
2440 memcached_return_t rc
;
2442 size_t value_length
;
2444 uint64_t number_value
;
2446 value
= memcached_get(memc
, "autoincrement", strlen("autoincrement"),
2447 &value_length
, &flags
, &rc
);
2448 test_true(value
== NULL
);
2449 test_true(rc
== MEMCACHED_NOTFOUND
);
2451 rc
= memcached_increment(memc
, "autoincrement", strlen("autoincrement"),
2454 test_true(value
== NULL
);
2455 /* The binary protocol will set the key if it doesn't exist */
2456 if (memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
) == 1)
2458 test_true(rc
== MEMCACHED_SUCCESS
);
2462 test_true(rc
== MEMCACHED_NOTFOUND
);
2465 rc
= memcached_set(memc
, "autoincrement", strlen("autoincrement"), "1", 1, 0, 0);
2467 value
= memcached_get(memc
, "autoincrement", strlen("autoincrement"),
2468 &value_length
, &flags
, &rc
);
2470 test_true(rc
== MEMCACHED_SUCCESS
);
2473 rc
= memcached_increment(memc
, "autoincrement", strlen("autoincrement"),
2475 test_true(number_value
== 2);
2476 test_true(rc
== MEMCACHED_SUCCESS
);
2478 return TEST_SUCCESS
;
2482 Bug found where command total one more than MEMCACHED_MAX_BUFFER
2483 set key34567890 0 0 8169 \r\n is sent followed by buffer of size 8169, followed by 8169
2485 static test_return_t
user_supplied_bug13(memcached_st
*memc
)
2487 char key
[] = "key34567890";
2489 memcached_return_t rc
;
2490 size_t overflowSize
;
2492 char commandFirst
[]= "set key34567890 0 0 ";
2493 char commandLast
[] = " \r\n"; /* first line of command sent to server */
2494 size_t commandLength
;
2497 commandLength
= strlen(commandFirst
) + strlen(commandLast
) + 4; /* 4 is number of characters in size, probably 8196 */
2499 overflowSize
= MEMCACHED_MAX_BUFFER
- commandLength
;
2501 for (testSize
= overflowSize
- 1; testSize
< overflowSize
+ 1; testSize
++)
2503 overflow
= malloc(testSize
);
2504 test_true(overflow
!= NULL
);
2506 memset(overflow
, 'x', testSize
);
2507 rc
= memcached_set(memc
, key
, strlen(key
),
2508 overflow
, testSize
, 0, 0);
2509 test_true(rc
== MEMCACHED_SUCCESS
);
2513 return TEST_SUCCESS
;
2518 Test values of many different sizes
2519 Bug found where command total one more than MEMCACHED_MAX_BUFFER
2520 set key34567890 0 0 8169 \r\n
2521 is sent followed by buffer of size 8169, followed by 8169
2523 static test_return_t
user_supplied_bug14(memcached_st
*memc
)
2526 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_TCP_NODELAY
, setter
);
2527 memcached_return_t rc
;
2528 const char *key
= "foo";
2530 size_t value_length
= 18000;
2532 size_t string_length
;
2535 size_t current_length
;
2537 value
= (char*)malloc(value_length
);
2540 for (x
= 0; x
< value_length
; x
++)
2541 value
[x
] = (char) (x
% 127);
2543 for (current_length
= 0; current_length
< value_length
; current_length
++)
2545 rc
= memcached_set(memc
, key
, strlen(key
),
2546 value
, current_length
,
2547 (time_t)0, (uint32_t)0);
2548 test_true(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
);
2550 string
= memcached_get(memc
, key
, strlen(key
),
2551 &string_length
, &flags
, &rc
);
2553 test_true(rc
== MEMCACHED_SUCCESS
);
2554 test_true(string_length
== current_length
);
2555 test_true(!memcmp(string
, value
, string_length
));
2562 return TEST_SUCCESS
;
2566 Look for zero length value problems
2568 static test_return_t
user_supplied_bug15(memcached_st
*memc
)
2571 memcached_return_t rc
;
2572 const char *key
= "mykey";
2577 for (x
= 0; x
< 2; x
++)
2579 rc
= memcached_set(memc
, key
, strlen(key
),
2581 (time_t)0, (uint32_t)0);
2583 test_true(rc
== MEMCACHED_SUCCESS
);
2585 value
= memcached_get(memc
, key
, strlen(key
),
2586 &length
, &flags
, &rc
);
2588 test_true(rc
== MEMCACHED_SUCCESS
);
2589 test_true(value
== NULL
);
2590 test_true(length
== 0);
2591 test_true(flags
== 0);
2593 value
= memcached_get(memc
, key
, strlen(key
),
2594 &length
, &flags
, &rc
);
2596 test_true(rc
== MEMCACHED_SUCCESS
);
2597 test_true(value
== NULL
);
2598 test_true(length
== 0);
2599 test_true(flags
== 0);
2602 return TEST_SUCCESS
;
2605 /* Check the return sizes on FLAGS to make sure it stores 32bit unsigned values correctly */
2606 static test_return_t
user_supplied_bug16(memcached_st
*memc
)
2608 memcached_return_t rc
;
2609 const char *key
= "mykey";
2614 rc
= memcached_set(memc
, key
, strlen(key
),
2616 (time_t)0, UINT32_MAX
);
2618 test_true(rc
== MEMCACHED_SUCCESS
);
2620 value
= memcached_get(memc
, key
, strlen(key
),
2621 &length
, &flags
, &rc
);
2623 test_true(rc
== MEMCACHED_SUCCESS
);
2624 test_true(value
== NULL
);
2625 test_true(length
== 0);
2626 test_true(flags
== UINT32_MAX
);
2628 return TEST_SUCCESS
;
2632 /* Check the validity of chinese key*/
2633 static test_return_t
user_supplied_bug17(memcached_st
*memc
)
2635 memcached_return_t rc
;
2636 const char *key
= "豆瓣";
2637 const char *value
="我们在炎热抑郁的夏天无法停止豆瓣";
2642 rc
= memcached_set(memc
, key
, strlen(key
),
2643 value
, strlen(value
),
2646 test_true(rc
== MEMCACHED_SUCCESS
);
2648 value2
= memcached_get(memc
, key
, strlen(key
),
2649 &length
, &flags
, &rc
);
2651 test_true(length
==strlen(value
));
2652 test_true(rc
== MEMCACHED_SUCCESS
);
2653 test_true(memcmp(value
, value2
, length
)==0);
2656 return TEST_SUCCESS
;
2664 static test_return_t
user_supplied_bug19(memcached_st
*memc
)
2667 memcached_server_st
*s
;
2668 memcached_return_t res
;
2672 m
= memcached_create(NULL
);
2673 memcached_server_add_with_weight(m
, "localhost", 11311, 100);
2674 memcached_server_add_with_weight(m
, "localhost", 11312, 100);
2676 s
= memcached_server_by_key(m
, "a", 1, &res
);
2677 memcached_server_free(s
);
2681 return TEST_SUCCESS
;
2684 /* CAS test from Andei */
2685 static test_return_t
user_supplied_bug20(memcached_st
*memc
)
2687 memcached_return_t status
;
2688 memcached_result_st
*result
, result_obj
;
2689 const char *key
= "abc";
2690 size_t key_len
= strlen("abc");
2691 const char *value
= "foobar";
2692 size_t value_len
= strlen(value
);
2694 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_SUPPORT_CAS
, 1);
2696 status
= memcached_set(memc
, key
, key_len
, value
, value_len
, (time_t)0, (uint32_t)0);
2697 test_true(status
== MEMCACHED_SUCCESS
);
2699 status
= memcached_mget(memc
, &key
, &key_len
, 1);
2700 test_true(status
== MEMCACHED_SUCCESS
);
2702 result
= memcached_result_create(memc
, &result_obj
);
2705 memcached_result_create(memc
, &result_obj
);
2706 result
= memcached_fetch_result(memc
, &result_obj
, &status
);
2709 test_true(status
== MEMCACHED_SUCCESS
);
2711 memcached_result_free(result
);
2713 return TEST_SUCCESS
;
2716 #include "ketama_test_cases.h"
2717 static test_return_t
user_supplied_bug18(memcached_st
*trash
)
2719 memcached_return_t rc
;
2722 memcached_server_st
*server_pool
;
2727 memc
= memcached_create(NULL
);
2730 rc
= memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_KETAMA_WEIGHTED
, 1);
2731 test_true(rc
== MEMCACHED_SUCCESS
);
2733 value
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_KETAMA_WEIGHTED
);
2734 test_true(value
== 1);
2736 rc
= memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_KETAMA_HASH
, MEMCACHED_HASH_MD5
);
2737 test_true(rc
== MEMCACHED_SUCCESS
);
2739 value
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_KETAMA_HASH
);
2740 test_true(value
== MEMCACHED_HASH_MD5
);
2742 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");
2743 memcached_server_push(memc
, server_pool
);
2745 /* verify that the server list was parsed okay. */
2746 test_true(memcached_server_count(memc
) == 8);
2747 test_true(strcmp(server_pool
[0].hostname
, "10.0.1.1") == 0);
2748 test_true(server_pool
[0].port
== 11211);
2749 test_true(server_pool
[0].weight
== 600);
2750 test_true(strcmp(server_pool
[2].hostname
, "10.0.1.3") == 0);
2751 test_true(server_pool
[2].port
== 11211);
2752 test_true(server_pool
[2].weight
== 200);
2753 test_true(strcmp(server_pool
[7].hostname
, "10.0.1.8") == 0);
2754 test_true(server_pool
[7].port
== 11211);
2755 test_true(server_pool
[7].weight
== 100);
2757 /* VDEAAAAA hashes to fffcd1b5, after the last continuum point, and lets
2758 * us test the boundary wraparound.
2760 test_true(memcached_generate_hash(memc
, (char *)"VDEAAAAA", 8) == memc
->continuum
[0].index
);
2762 /* verify the standard ketama set. */
2763 for (x
= 0; x
< 99; x
++)
2765 uint32_t server_idx
= memcached_generate_hash(memc
, ketama_test_cases
[x
].key
, strlen(ketama_test_cases
[x
].key
));
2766 memcached_server_instance_st
*instance
=
2767 memcached_server_instance_fetch(memc
, server_idx
);
2768 char *hostname
= instance
->hostname
;
2769 test_strcmp(hostname
, ketama_test_cases
[x
].server
);
2772 memcached_server_list_free(server_pool
);
2773 memcached_free(memc
);
2775 return TEST_SUCCESS
;
2778 /* Large mget() of missing keys with binary proto
2780 * If many binary quiet commands (such as getq's in an mget) fill the output
2781 * buffer and the server chooses not to respond, memcached_flush hangs. See
2782 * http://lists.tangent.org/pipermail/libmemcached/2009-August/000918.html
2785 /* sighandler_t function that always asserts false */
2786 static void fail(int unused
__attribute__((unused
)))
2792 static test_return_t
_user_supplied_bug21(memcached_st
* memc
, size_t key_count
)
2794 memcached_return_t rc
;
2797 size_t* key_lengths
;
2798 void (*oldalarm
)(int);
2799 memcached_st
*memc_clone
;
2801 memc_clone
= memcached_clone(NULL
, memc
);
2802 test_true(memc_clone
);
2804 /* only binproto uses getq for mget */
2805 memcached_behavior_set(memc_clone
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
, 1);
2807 /* empty the cache to ensure misses (hence non-responses) */
2808 rc
= memcached_flush(memc_clone
, 0);
2809 test_true(rc
== MEMCACHED_SUCCESS
);
2811 key_lengths
= calloc(key_count
, sizeof(size_t));
2812 keys
= calloc(key_count
, sizeof(char *));
2814 for (x
= 0; x
< key_count
; x
++)
2818 snprintf(buffer
, 30, "%u", x
);
2819 keys
[x
]= strdup(buffer
);
2820 key_lengths
[x
]= strlen(keys
[x
]);
2823 oldalarm
= signal(SIGALRM
, fail
);
2826 rc
= memcached_mget(memc_clone
, (const char **)keys
, key_lengths
, key_count
);
2827 test_true(rc
== MEMCACHED_SUCCESS
);
2830 signal(SIGALRM
, oldalarm
);
2832 test_true(fetch_all_results(memc
) == TEST_SUCCESS
);
2834 for (x
= 0; x
< key_count
; x
++)
2839 memcached_free(memc_clone
);
2841 return TEST_SUCCESS
;
2844 static test_return_t
pre_binary(memcached_st
*memc
);
2846 static test_return_t
user_supplied_bug21(memcached_st
*memc
)
2848 test_return_t test_rc
;
2849 test_rc
= pre_binary(memc
);
2851 if (test_rc
!= TEST_SUCCESS
)
2856 /* should work as of r580 */
2857 rc
= _user_supplied_bug21(memc
, 10);
2858 test_true(rc
== TEST_SUCCESS
);
2860 /* should fail as of r580 */
2861 rc
= _user_supplied_bug21(memc
, 1000);
2862 test_true(rc
== TEST_SUCCESS
);
2864 return TEST_SUCCESS
;
2867 static test_return_t
auto_eject_hosts(memcached_st
*trash
)
2870 memcached_server_instance_st
*instance
;
2872 memcached_return_t rc
;
2873 memcached_st
*memc
= memcached_create(NULL
);
2876 rc
= memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_KETAMA_WEIGHTED
, 1);
2877 test_true(rc
== MEMCACHED_SUCCESS
);
2879 uint64_t value
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_KETAMA_WEIGHTED
);
2880 test_true(value
== 1);
2882 rc
= memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_KETAMA_HASH
, MEMCACHED_HASH_MD5
);
2883 test_true(rc
== MEMCACHED_SUCCESS
);
2885 value
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_KETAMA_HASH
);
2886 test_true(value
== MEMCACHED_HASH_MD5
);
2888 /* server should be removed when in delay */
2889 rc
= memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_AUTO_EJECT_HOSTS
, 1);
2890 test_true(rc
== MEMCACHED_SUCCESS
);
2892 value
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_AUTO_EJECT_HOSTS
);
2893 test_true(value
== 1);
2895 memcached_server_st
*server_pool
;
2896 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");
2897 memcached_server_push(memc
, server_pool
);
2899 /* verify that the server list was parsed okay. */
2900 test_true(memcached_server_count(memc
) == 8);
2901 test_true(strcmp(server_pool
[0].hostname
, "10.0.1.1") == 0);
2902 test_true(server_pool
[0].port
== 11211);
2903 test_true(server_pool
[0].weight
== 600);
2904 test_true(strcmp(server_pool
[2].hostname
, "10.0.1.3") == 0);
2905 test_true(server_pool
[2].port
== 11211);
2906 test_true(server_pool
[2].weight
== 200);
2907 test_true(strcmp(server_pool
[7].hostname
, "10.0.1.8") == 0);
2908 test_true(server_pool
[7].port
== 11211);
2909 test_true(server_pool
[7].weight
== 100);
2911 instance
= memcached_server_instance_fetch(memc
, 2);
2912 instance
->next_retry
= time(NULL
) + 15;
2913 memc
->next_distribution_rebuild
= time(NULL
) - 1;
2915 for (size_t x
= 0; x
< 99; x
++)
2917 uint32_t server_idx
= memcached_generate_hash(memc
, ketama_test_cases
[x
].key
, strlen(ketama_test_cases
[x
].key
));
2918 test_true(server_idx
!= 2);
2921 /* and re-added when it's back. */
2922 instance
->next_retry
= time(NULL
) - 1;
2923 memc
->next_distribution_rebuild
= time(NULL
) - 1;
2924 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_DISTRIBUTION
,
2925 memc
->distribution
);
2926 for (size_t x
= 0; x
< 99; x
++)
2928 uint32_t server_idx
= memcached_generate_hash(memc
, ketama_test_cases
[x
].key
, strlen(ketama_test_cases
[x
].key
));
2929 // We re-use instance from above.
2931 memcached_server_instance_fetch(memc
, server_idx
);
2932 char *hostname
= instance
->hostname
;
2933 test_true(strcmp(hostname
, ketama_test_cases
[x
].server
) == 0);
2936 memcached_server_list_free(server_pool
);
2937 memcached_free(memc
);
2939 return TEST_SUCCESS
;
2942 static test_return_t
output_ketama_weighted_keys(memcached_st
*trash
)
2946 memcached_return_t rc
;
2947 memcached_st
*memc
= memcached_create(NULL
);
2951 rc
= memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_KETAMA_WEIGHTED
, 1);
2952 test_true(rc
== MEMCACHED_SUCCESS
);
2954 uint64_t value
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_KETAMA_WEIGHTED
);
2955 test_true(value
== 1);
2957 rc
= memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_KETAMA_HASH
, MEMCACHED_HASH_MD5
);
2958 test_true(rc
== MEMCACHED_SUCCESS
);
2960 value
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_KETAMA_HASH
);
2961 test_true(value
== MEMCACHED_HASH_MD5
);
2964 test_true(memcached_behavior_set_distribution(memc
, MEMCACHED_DISTRIBUTION_CONSISTENT_KETAMA_SPY
) == MEMCACHED_SUCCESS
);
2966 memcached_server_st
*server_pool
;
2967 server_pool
= memcached_servers_parse("10.0.1.1:11211,10.0.1.2:11211,10.0.1.3:11211,10.0.1.4:11211,10.0.1.5:11211,10.0.1.6:11211,10.0.1.7:11211,10.0.1.8:11211,192.168.1.1:11211,192.168.100.1:11211");
2968 memcached_server_push(memc
, server_pool
);
2970 // @todo this needs to be refactored to actually test something.
2973 if ((fp
= fopen("ketama_keys.txt", "w")))
2977 printf("cannot write to file ketama_keys.txt");
2978 return TEST_FAILURE
;
2981 for (int x
= 0; x
< 10000; x
++)
2984 sprintf(key
, "%d", x
);
2986 uint32_t server_idx
= memcached_generate_hash(memc
, key
, strlen(key
));
2987 char *hostname
= memc
->hosts
[server_idx
].hostname
;
2988 in_port_t port
= memc
->hosts
[server_idx
].port
;
2989 fprintf(fp
, "key %s is on host /%s:%u\n", key
, hostname
, port
);
2993 memcached_server_list_free(server_pool
);
2994 memcached_free(memc
);
2996 return TEST_SUCCESS
;
3000 static test_return_t
result_static(memcached_st
*memc
)
3002 memcached_result_st result
;
3003 memcached_result_st
*result_ptr
;
3005 result_ptr
= memcached_result_create(memc
, &result
);
3006 test_true(result
.options
.is_allocated
== false);
3007 test_true(memcached_is_initialized(&result
) == true);
3008 test_true(result_ptr
);
3009 test_true(result_ptr
== &result
);
3011 memcached_result_free(&result
);
3013 test_true(result
.options
.is_allocated
== false);
3014 test_true(memcached_is_initialized(&result
) == false);
3016 return TEST_SUCCESS
;
3019 static test_return_t
result_alloc(memcached_st
*memc
)
3021 memcached_result_st
*result_ptr
;
3023 result_ptr
= memcached_result_create(memc
, NULL
);
3024 test_true(result_ptr
);
3025 test_true(result_ptr
->options
.is_allocated
== true);
3026 test_true(memcached_is_initialized(result_ptr
) == true);
3027 memcached_result_free(result_ptr
);
3029 return TEST_SUCCESS
;
3032 static test_return_t
string_static_null(memcached_st
*memc
)
3034 memcached_string_st string
;
3035 memcached_string_st
*string_ptr
;
3037 string_ptr
= memcached_string_create(memc
, &string
, 0);
3038 test_true(string
.options
.is_initialized
== true);
3039 test_true(string_ptr
);
3041 /* The following two better be the same! */
3042 test_true(memcached_is_allocated(string_ptr
) == false);
3043 test_true(memcached_is_allocated(&string
) == false);
3044 test_true(&string
== string_ptr
);
3046 test_true(string
.options
.is_initialized
== true);
3047 test_true(memcached_is_initialized(&string
) == true);
3048 memcached_string_free(&string
);
3049 test_true(memcached_is_initialized(&string
) == false);
3051 return TEST_SUCCESS
;
3054 static test_return_t
string_alloc_null(memcached_st
*memc
)
3056 memcached_string_st
*string
;
3058 string
= memcached_string_create(memc
, NULL
, 0);
3060 test_true(memcached_is_allocated(string
) == true);
3061 test_true(memcached_is_initialized(string
) == true);
3062 memcached_string_free(string
);
3064 return TEST_SUCCESS
;
3067 static test_return_t
string_alloc_with_size(memcached_st
*memc
)
3069 memcached_string_st
*string
;
3071 string
= memcached_string_create(memc
, NULL
, 1024);
3073 test_true(memcached_is_allocated(string
) == true);
3074 test_true(memcached_is_initialized(string
) == true);
3075 memcached_string_free(string
);
3077 return TEST_SUCCESS
;
3080 static test_return_t
string_alloc_with_size_toobig(memcached_st
*memc
)
3082 memcached_string_st
*string
;
3084 string
= memcached_string_create(memc
, NULL
, SIZE_MAX
);
3085 test_true(string
== NULL
);
3087 return TEST_SUCCESS
;
3090 static test_return_t
string_alloc_append(memcached_st
*memc
)
3093 char buffer
[SMALL_STRING_LEN
];
3094 memcached_string_st
*string
;
3096 /* Ring the bell! */
3097 memset(buffer
, 6, SMALL_STRING_LEN
);
3099 string
= memcached_string_create(memc
, NULL
, 100);
3101 test_true(memcached_is_allocated(string
) == true);
3102 test_true(memcached_is_initialized(string
) == true);
3104 for (x
= 0; x
< 1024; x
++)
3106 memcached_return_t rc
;
3107 rc
= memcached_string_append(string
, buffer
, SMALL_STRING_LEN
);
3108 test_true(rc
== MEMCACHED_SUCCESS
);
3110 test_true(memcached_is_allocated(string
) == true);
3111 memcached_string_free(string
);
3113 return TEST_SUCCESS
;
3116 static test_return_t
string_alloc_append_toobig(memcached_st
*memc
)
3118 memcached_return_t rc
;
3120 char buffer
[SMALL_STRING_LEN
];
3121 memcached_string_st
*string
;
3123 /* Ring the bell! */
3124 memset(buffer
, 6, SMALL_STRING_LEN
);
3126 string
= memcached_string_create(memc
, NULL
, 100);
3128 test_true(memcached_is_allocated(string
) == true);
3129 test_true(memcached_is_initialized(string
) == true);
3131 for (x
= 0; x
< 1024; x
++)
3133 rc
= memcached_string_append(string
, buffer
, SMALL_STRING_LEN
);
3134 test_true(rc
== MEMCACHED_SUCCESS
);
3136 rc
= memcached_string_append(string
, buffer
, SIZE_MAX
);
3137 test_true(rc
== MEMCACHED_MEMORY_ALLOCATION_FAILURE
);
3138 test_true(memcached_is_allocated(string
) == true);
3139 memcached_string_free(string
);
3141 return TEST_SUCCESS
;
3144 static test_return_t
cleanup_pairs(memcached_st
*memc
__attribute__((unused
)))
3146 pairs_free(global_pairs
);
3148 return TEST_SUCCESS
;
3151 static test_return_t
generate_pairs(memcached_st
*memc
__attribute__((unused
)))
3153 global_pairs
= pairs_generate(GLOBAL_COUNT
, 400);
3154 global_count
= GLOBAL_COUNT
;
3156 for (size_t x
= 0; x
< global_count
; x
++)
3158 global_keys
[x
]= global_pairs
[x
].key
;
3159 global_keys_length
[x
]= global_pairs
[x
].key_length
;
3162 return TEST_SUCCESS
;
3165 static test_return_t
generate_large_pairs(memcached_st
*memc
__attribute__((unused
)))
3167 global_pairs
= pairs_generate(GLOBAL2_COUNT
, MEMCACHED_MAX_BUFFER
+10);
3168 global_count
= GLOBAL2_COUNT
;
3170 for (size_t x
= 0; x
< global_count
; x
++)
3172 global_keys
[x
]= global_pairs
[x
].key
;
3173 global_keys_length
[x
]= global_pairs
[x
].key_length
;
3176 return TEST_SUCCESS
;
3179 static test_return_t
generate_data(memcached_st
*memc
)
3181 execute_set(memc
, global_pairs
, global_count
);
3183 return TEST_SUCCESS
;
3186 static test_return_t
generate_data_with_stats(memcached_st
*memc
)
3188 memcached_stat_st
*stat_p
;
3189 memcached_return_t rc
;
3190 uint32_t host_index
= 0;
3191 execute_set(memc
, global_pairs
, global_count
);
3193 //TODO: hosts used size stats
3194 stat_p
= memcached_stat(memc
, NULL
, &rc
);
3197 for (host_index
= 0; host_index
< SERVERS_TO_CREATE
; host_index
++)
3199 /* This test was changes so that "make test" would work properlly */
3201 memcached_server_instance_st
*instance
=
3202 memcached_server_instance_fetch(memc
, host_index
);
3204 printf("\nserver %u|%s|%u bytes: %llu\n", host_index
, instance
->hostname
, instance
->port
, (unsigned long long)(stat_p
+ host_index
)->bytes
);
3206 test_true((unsigned long long)(stat_p
+ host_index
)->bytes
);
3209 memcached_stat_free(NULL
, stat_p
);
3211 return TEST_SUCCESS
;
3213 static test_return_t
generate_buffer_data(memcached_st
*memc
)
3218 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_BUFFER_REQUESTS
, latch
);
3219 generate_data(memc
);
3221 return TEST_SUCCESS
;
3224 static test_return_t
get_read_count(memcached_st
*memc
)
3226 memcached_return_t rc
;
3227 memcached_st
*memc_clone
;
3229 memc_clone
= memcached_clone(NULL
, memc
);
3230 test_true(memc_clone
);
3232 memcached_server_add_with_weight(memc_clone
, "localhost", 6666, 0);
3236 size_t return_value_length
;
3240 for (size_t x
= count
= 0; x
< global_count
; x
++)
3242 return_value
= memcached_get(memc_clone
, global_keys
[x
], global_keys_length
[x
],
3243 &return_value_length
, &flags
, &rc
);
3244 if (rc
== MEMCACHED_SUCCESS
)
3253 memcached_free(memc_clone
);
3255 return TEST_SUCCESS
;
3258 static test_return_t
get_read(memcached_st
*memc
)
3260 memcached_return_t rc
;
3264 size_t return_value_length
;
3267 for (size_t x
= 0; x
< global_count
; x
++)
3269 return_value
= memcached_get(memc
, global_keys
[x
], global_keys_length
[x
],
3270 &return_value_length
, &flags
, &rc
);
3272 test_true(return_value);
3273 test_true(rc == MEMCACHED_SUCCESS);
3275 if (rc
== MEMCACHED_SUCCESS
&& return_value
)
3280 return TEST_SUCCESS
;
3283 static test_return_t
mget_read(memcached_st
*memc
)
3285 memcached_return_t rc
;
3287 rc
= memcached_mget(memc
, global_keys
, global_keys_length
, global_count
);
3288 test_true(rc
== MEMCACHED_SUCCESS
);
3289 test_true(fetch_all_results(memc
) == TEST_SUCCESS
);
3291 return TEST_SUCCESS
;
3294 static test_return_t
mget_read_result(memcached_st
*memc
)
3296 memcached_return_t rc
;
3298 rc
= memcached_mget(memc
, global_keys
, global_keys_length
, global_count
);
3299 test_true(rc
== MEMCACHED_SUCCESS
);
3300 /* Turn this into a help function */
3302 memcached_result_st results_obj
;
3303 memcached_result_st
*results
;
3305 results
= memcached_result_create(memc
, &results_obj
);
3307 while ((results
= memcached_fetch_result(memc
, &results_obj
, &rc
)))
3310 test_true(rc
== MEMCACHED_SUCCESS
);
3313 memcached_result_free(&results_obj
);
3316 return TEST_SUCCESS
;
3319 static test_return_t
mget_read_function(memcached_st
*memc
)
3321 memcached_return_t rc
;
3323 memcached_execute_fn callbacks
[1];
3325 rc
= memcached_mget(memc
, global_keys
, global_keys_length
, global_count
);
3326 test_true(rc
== MEMCACHED_SUCCESS
);
3328 callbacks
[0]= &callback_counter
;
3330 rc
= memcached_fetch_execute(memc
, callbacks
, (void *)&counter
, 1);
3332 return TEST_SUCCESS
;
3335 static test_return_t
delete_generate(memcached_st
*memc
)
3337 for (size_t x
= 0; x
< global_count
; x
++)
3339 (void)memcached_delete(memc
, global_keys
[x
], global_keys_length
[x
], (time_t)0);
3342 return TEST_SUCCESS
;
3345 static test_return_t
delete_buffer_generate(memcached_st
*memc
)
3350 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_BUFFER_REQUESTS
, latch
);
3352 for (size_t x
= 0; x
< global_count
; x
++)
3354 (void)memcached_delete(memc
, global_keys
[x
], global_keys_length
[x
], (time_t)0);
3357 return TEST_SUCCESS
;
3360 static test_return_t
add_host_test1(memcached_st
*memc
)
3362 memcached_return_t rc
;
3363 char servername
[]= "0.example.com";
3364 memcached_server_st
*servers
;
3366 servers
= memcached_server_list_append_with_weight(NULL
, servername
, 400, 0, &rc
);
3368 test_true(1 == memcached_server_list_count(servers
));
3370 for (size_t x
= 2; x
< 20; x
++)
3372 char buffer
[SMALL_STRING_LEN
];
3374 snprintf(buffer
, SMALL_STRING_LEN
, "%zu.example.com", 400+x
);
3375 servers
= memcached_server_list_append_with_weight(servers
, buffer
, 401, 0,
3377 test_true(rc
== MEMCACHED_SUCCESS
);
3378 test_true(x
== memcached_server_list_count(servers
));
3381 rc
= memcached_server_push(memc
, servers
);
3382 test_true(rc
== MEMCACHED_SUCCESS
);
3383 rc
= memcached_server_push(memc
, servers
);
3384 test_true(rc
== MEMCACHED_SUCCESS
);
3386 memcached_server_list_free(servers
);
3388 return TEST_SUCCESS
;
3391 static test_return_t
pre_nonblock(memcached_st
*memc
)
3393 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NO_BLOCK
, 0);
3395 return TEST_SUCCESS
;
3398 static test_return_t
pre_cork(memcached_st
*memc
)
3400 memcached_return_t rc
;
3402 rc
= memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_CORK
, set
);
3404 if (rc
== MEMCACHED_SUCCESS
)
3405 return TEST_SUCCESS
;
3407 return TEST_SKIPPED
;
3410 static test_return_t
pre_cork_and_nonblock(memcached_st
*memc
)
3416 if (rc
!= TEST_SUCCESS
)
3419 return pre_nonblock(memc
);
3422 static test_return_t
pre_nonblock_binary(memcached_st
*memc
)
3424 memcached_return_t rc
= MEMCACHED_FAILURE
;
3425 memcached_st
*memc_clone
;
3426 memcached_server_instance_st
*instance
;
3428 memc_clone
= memcached_clone(NULL
, memc
);
3429 test_true(memc_clone
);
3430 // The memcached_version needs to be done on a clone, because the server
3431 // will not toggle protocol on an connection.
3432 memcached_version(memc_clone
);
3434 instance
= memcached_server_instance_fetch(memc_clone
, 0);
3436 if (instance
->major_version
>= 1 && instance
->minor_version
> 2)
3438 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NO_BLOCK
, 0);
3439 rc
= memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
, 1);
3440 test_true(rc
== MEMCACHED_SUCCESS
);
3441 test_true(memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
) == 1);
3445 return TEST_SKIPPED
;
3448 memcached_free(memc_clone
);
3450 return rc
== MEMCACHED_SUCCESS
? TEST_SUCCESS
: TEST_SKIPPED
;
3453 static test_return_t
pre_murmur(memcached_st
*memc
)
3455 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_HASH
, (uint64_t)MEMCACHED_HASH_MURMUR
);
3457 return TEST_SUCCESS
;
3460 static test_return_t
pre_jenkins(memcached_st
*memc
)
3462 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_HASH
, (uint64_t)MEMCACHED_HASH_JENKINS
);
3464 return TEST_SUCCESS
;
3468 static test_return_t
pre_md5(memcached_st
*memc
)
3470 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_HASH
, (uint64_t)MEMCACHED_HASH_MD5
);
3472 return TEST_SUCCESS
;
3475 static test_return_t
pre_crc(memcached_st
*memc
)
3477 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_HASH
, (uint64_t)MEMCACHED_HASH_CRC
);
3479 return TEST_SUCCESS
;
3482 static test_return_t
pre_hsieh(memcached_st
*memc
)
3484 #ifdef HAVE_HSIEH_HASH
3485 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_HASH
, (uint64_t)MEMCACHED_HASH_HSIEH
);
3486 return TEST_SUCCESS
;
3489 return TEST_SKIPPED
;
3493 static test_return_t
pre_hash_fnv1_64(memcached_st
*memc
)
3495 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_HASH
, (uint64_t)MEMCACHED_HASH_MURMUR
);
3497 return TEST_SUCCESS
;
3500 static test_return_t
pre_hash_fnv1a_64(memcached_st
*memc
)
3502 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_HASH
, (uint64_t)MEMCACHED_HASH_FNV1A_64
);
3504 return TEST_SUCCESS
;
3507 static test_return_t
pre_hash_fnv1_32(memcached_st
*memc
)
3509 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_HASH
, (uint64_t)MEMCACHED_HASH_FNV1_32
);
3511 return TEST_SUCCESS
;
3514 static test_return_t
pre_hash_fnv1a_32(memcached_st
*memc
)
3516 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_HASH
, (uint64_t)MEMCACHED_HASH_FNV1A_32
);
3518 return TEST_SUCCESS
;
3521 static test_return_t
pre_behavior_ketama(memcached_st
*memc
)
3523 memcached_return_t rc
;
3526 rc
= memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_KETAMA
, 1);
3527 test_true(rc
== MEMCACHED_SUCCESS
);
3529 value
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_KETAMA
);
3530 test_true(value
== 1);
3532 return TEST_SUCCESS
;
3535 static test_return_t
pre_behavior_ketama_weighted(memcached_st
*memc
)
3537 memcached_return_t rc
;
3540 rc
= memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_KETAMA_WEIGHTED
, 1);
3541 test_true(rc
== MEMCACHED_SUCCESS
);
3543 value
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_KETAMA_WEIGHTED
);
3544 test_true(value
== 1);
3546 rc
= memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_KETAMA_HASH
, MEMCACHED_HASH_MD5
);
3547 test_true(rc
== MEMCACHED_SUCCESS
);
3549 value
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_KETAMA_HASH
);
3550 test_true(value
== MEMCACHED_HASH_MD5
);
3552 return TEST_SUCCESS
;
3556 @note This should be testing to see if the server really supports the binary protocol.
3558 static test_return_t
pre_binary(memcached_st
*memc
)
3560 memcached_return_t rc
= MEMCACHED_FAILURE
;
3561 memcached_st
*memc_clone
;
3562 memcached_server_instance_st
*instance
;
3564 memc_clone
= memcached_clone(NULL
, memc
);
3565 test_true(memc_clone
);
3566 // The memcached_version needs to be done on a clone, because the server
3567 // will not toggle protocol on an connection.
3568 memcached_version(memc_clone
);
3570 instance
= memcached_server_instance_fetch(memc_clone
, 0);
3572 if (instance
->major_version
>= 1 && instance
->minor_version
> 2)
3574 rc
= memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
, 1);
3575 test_true(rc
== MEMCACHED_SUCCESS
);
3576 test_true(memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
) == 1);
3579 memcached_free(memc_clone
);
3581 return rc
== MEMCACHED_SUCCESS
? TEST_SUCCESS
: TEST_SKIPPED
;
3585 static test_return_t
pre_replication(memcached_st
*memc
)
3587 test_return_t test_rc
;
3588 test_rc
= pre_binary(memc
);
3590 if (test_rc
!= TEST_SUCCESS
)
3594 * Make sure that we store the item on all servers
3595 * (master + replicas == number of servers)
3597 memcached_return_t rc
;
3598 rc
= memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NUMBER_OF_REPLICAS
,
3599 memcached_server_count(memc
) - 1);
3600 test_true(rc
== MEMCACHED_SUCCESS
);
3601 test_true(memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_NUMBER_OF_REPLICAS
) == memcached_server_count(memc
) - 1);
3603 return rc
== MEMCACHED_SUCCESS
? TEST_SUCCESS
: TEST_SKIPPED
;
3607 static test_return_t
pre_replication_noblock(memcached_st
*memc
)
3611 rc
= pre_replication(memc
);
3612 if (rc
!= TEST_SUCCESS
)
3615 rc
= pre_nonblock(memc
);
3621 static void my_free(const memcached_st
*ptr
__attribute__((unused
)), void *mem
, void *context
)
3624 #ifdef HARD_MALLOC_TESTS
3625 void *real_ptr
= (mem
== NULL
) ? mem
: (void*)((caddr_t
)mem
- 8);
3633 static void *my_malloc(const memcached_st
*ptr
__attribute__((unused
)), const size_t size
, void *context
)
3636 #ifdef HARD_MALLOC_TESTS
3637 void *ret
= malloc(size
+ 8);
3640 ret
= (void*)((caddr_t
)ret
+ 8);
3643 void *ret
= malloc(size
);
3648 memset(ret
, 0xff, size
);
3655 static void *my_realloc(const memcached_st
*ptr
__attribute__((unused
)), void *mem
, const size_t size
, void *context
)
3658 #ifdef HARD_MALLOC_TESTS
3659 void *real_ptr
= (mem
== NULL
) ? NULL
: (void*)((caddr_t
)mem
- 8);
3660 void *nmem
= realloc(real_ptr
, size
+ 8);
3665 ret
= (void*)((caddr_t
)nmem
+ 8);
3670 return realloc(mem
, size
);
3675 static void *my_calloc(const memcached_st
*ptr
__attribute__((unused
)), size_t nelem
, const size_t size
, void *context
)
3678 #ifdef HARD_MALLOC_TESTS
3679 void *mem
= my_malloc(ptr
, nelem
* size
);
3682 memset(mem
, 0, nelem
* size
);
3687 return calloc(nelem
, size
);
3692 static test_return_t
set_prefix(memcached_st
*memc
)
3694 memcached_return_t rc
;
3695 const char *key
= "mine";
3698 /* Make sure be default none exists */
3699 value
= memcached_callback_get(memc
, MEMCACHED_CALLBACK_PREFIX_KEY
, &rc
);
3700 test_true(rc
== MEMCACHED_FAILURE
);
3702 /* Test a clean set */
3703 rc
= memcached_callback_set(memc
, MEMCACHED_CALLBACK_PREFIX_KEY
, (void *)key
);
3704 test_true(rc
== MEMCACHED_SUCCESS
);
3706 value
= memcached_callback_get(memc
, MEMCACHED_CALLBACK_PREFIX_KEY
, &rc
);
3707 test_true(memcmp(value
, key
, 4) == 0);
3708 test_true(rc
== MEMCACHED_SUCCESS
);
3710 /* Test that we can turn it off */
3711 rc
= memcached_callback_set(memc
, MEMCACHED_CALLBACK_PREFIX_KEY
, NULL
);
3712 test_true(rc
== MEMCACHED_SUCCESS
);
3714 value
= memcached_callback_get(memc
, MEMCACHED_CALLBACK_PREFIX_KEY
, &rc
);
3715 test_true(rc
== MEMCACHED_FAILURE
);
3717 /* Now setup for main test */
3718 rc
= memcached_callback_set(memc
, MEMCACHED_CALLBACK_PREFIX_KEY
, (void *)key
);
3719 test_true(rc
== MEMCACHED_SUCCESS
);
3721 value
= memcached_callback_get(memc
, MEMCACHED_CALLBACK_PREFIX_KEY
, &rc
);
3722 test_true(rc
== MEMCACHED_SUCCESS
);
3723 test_true(memcmp(value
, key
, 4) == 0);
3725 /* Set to Zero, and then Set to something too large */
3728 memset(long_key
, 0, 255);
3730 rc
= memcached_callback_set(memc
, MEMCACHED_CALLBACK_PREFIX_KEY
, NULL
);
3731 test_true(rc
== MEMCACHED_SUCCESS
);
3733 value
= memcached_callback_get(memc
, MEMCACHED_CALLBACK_PREFIX_KEY
, &rc
);
3734 test_true(rc
== MEMCACHED_FAILURE
);
3735 test_true(value
== NULL
);
3737 /* Test a long key for failure */
3738 /* TODO, extend test to determine based on setting, what result should be */
3739 strcpy(long_key
, "Thisismorethentheallottednumberofcharacters");
3740 rc
= memcached_callback_set(memc
, MEMCACHED_CALLBACK_PREFIX_KEY
, long_key
);
3741 //test_true(rc == MEMCACHED_BAD_KEY_PROVIDED);
3742 test_true(rc
== MEMCACHED_SUCCESS
);
3744 /* Now test a key with spaces (which will fail from long key, since bad key is not set) */
3745 strcpy(long_key
, "This is more then the allotted number of characters");
3746 rc
= memcached_callback_set(memc
, MEMCACHED_CALLBACK_PREFIX_KEY
, long_key
);
3747 test_true(rc
== MEMCACHED_BAD_KEY_PROVIDED
);
3749 /* Test for a bad prefix, but with a short key */
3750 rc
= memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_VERIFY_KEY
, 1);
3751 test_true(rc
== MEMCACHED_SUCCESS
);
3753 strcpy(long_key
, "dog cat");
3754 rc
= memcached_callback_set(memc
, MEMCACHED_CALLBACK_PREFIX_KEY
, long_key
);
3755 test_true(rc
== MEMCACHED_BAD_KEY_PROVIDED
);
3758 return TEST_SUCCESS
;
3762 #ifdef MEMCACHED_ENABLE_DEPRECATED
3763 static test_return_t
deprecated_set_memory_alloc(memcached_st
*memc
)
3765 void *test_ptr
= NULL
;
3768 memcached_malloc_fn malloc_cb
=
3769 (memcached_malloc_fn
)my_malloc
;
3770 cb_ptr
= *(void **)&malloc_cb
;
3771 memcached_return_t rc
;
3773 rc
= memcached_callback_set(memc
, MEMCACHED_CALLBACK_MALLOC_FUNCTION
, cb_ptr
);
3774 test_true(rc
== MEMCACHED_SUCCESS
);
3775 test_ptr
= memcached_callback_get(memc
, MEMCACHED_CALLBACK_MALLOC_FUNCTION
, &rc
);
3776 test_true(rc
== MEMCACHED_SUCCESS
);
3777 test_true(test_ptr
== cb_ptr
);
3781 memcached_realloc_fn realloc_cb
=
3782 (memcached_realloc_fn
)my_realloc
;
3783 cb_ptr
= *(void **)&realloc_cb
;
3784 memcached_return_t rc
;
3786 rc
= memcached_callback_set(memc
, MEMCACHED_CALLBACK_REALLOC_FUNCTION
, cb_ptr
);
3787 test_true(rc
== MEMCACHED_SUCCESS
);
3788 test_ptr
= memcached_callback_get(memc
, MEMCACHED_CALLBACK_REALLOC_FUNCTION
, &rc
);
3789 test_true(rc
== MEMCACHED_SUCCESS
);
3790 test_true(test_ptr
== cb_ptr
);
3794 memcached_free_fn free_cb
=
3795 (memcached_free_fn
)my_free
;
3796 cb_ptr
= *(void **)&free_cb
;
3797 memcached_return_t rc
;
3799 rc
= memcached_callback_set(memc
, MEMCACHED_CALLBACK_FREE_FUNCTION
, cb_ptr
);
3800 test_true(rc
== MEMCACHED_SUCCESS
);
3801 test_ptr
= memcached_callback_get(memc
, MEMCACHED_CALLBACK_FREE_FUNCTION
, &rc
);
3802 test_true(rc
== MEMCACHED_SUCCESS
);
3803 test_true(test_ptr
== cb_ptr
);
3806 return TEST_SUCCESS
;
3811 static test_return_t
set_memory_alloc(memcached_st
*memc
)
3813 memcached_return_t rc
;
3814 rc
= memcached_set_memory_allocators(memc
, NULL
, my_free
,
3815 my_realloc
, my_calloc
, NULL
);
3816 test_true(rc
== MEMCACHED_FAILURE
);
3818 rc
= memcached_set_memory_allocators(memc
, my_malloc
, my_free
,
3819 my_realloc
, my_calloc
, NULL
);
3821 memcached_malloc_fn mem_malloc
;
3822 memcached_free_fn mem_free
;
3823 memcached_realloc_fn mem_realloc
;
3824 memcached_calloc_fn mem_calloc
;
3825 memcached_get_memory_allocators(memc
, &mem_malloc
, &mem_free
,
3826 &mem_realloc
, &mem_calloc
);
3828 test_true(mem_malloc
== my_malloc
);
3829 test_true(mem_realloc
== my_realloc
);
3830 test_true(mem_calloc
== my_calloc
);
3831 test_true(mem_free
== my_free
);
3833 return TEST_SUCCESS
;
3836 static test_return_t
enable_consistent_crc(memcached_st
*memc
)
3839 memcached_server_distribution_t value
= MEMCACHED_DISTRIBUTION_CONSISTENT
;
3840 memcached_hash_t hash
;
3841 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_DISTRIBUTION
, value
);
3842 if ((rc
= pre_crc(memc
)) != TEST_SUCCESS
)
3845 value
= (memcached_server_distribution_t
)memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_DISTRIBUTION
);
3846 test_true(value
== MEMCACHED_DISTRIBUTION_CONSISTENT
);
3848 hash
= (memcached_hash_t
)memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_HASH
);
3850 if (hash
!= MEMCACHED_HASH_CRC
)
3851 return TEST_SKIPPED
;
3853 return TEST_SUCCESS
;
3856 static test_return_t
enable_consistent_hsieh(memcached_st
*memc
)
3859 memcached_server_distribution_t value
= MEMCACHED_DISTRIBUTION_CONSISTENT
;
3860 memcached_hash_t hash
;
3861 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_DISTRIBUTION
, value
);
3862 if ((rc
= pre_hsieh(memc
)) != TEST_SUCCESS
)
3865 value
= (memcached_server_distribution_t
)memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_DISTRIBUTION
);
3866 test_true(value
== MEMCACHED_DISTRIBUTION_CONSISTENT
);
3868 hash
= (memcached_hash_t
)memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_HASH
);
3870 if (hash
!= MEMCACHED_HASH_HSIEH
)
3871 return TEST_SKIPPED
;
3874 return TEST_SUCCESS
;
3877 static test_return_t
enable_cas(memcached_st
*memc
)
3879 unsigned int set
= 1;
3881 memcached_server_instance_st
*instance
=
3882 memcached_server_instance_fetch(memc
, 0);
3884 memcached_version(memc
);
3886 if ((instance
->major_version
>= 1 && (instance
->minor_version
== 2 && instance
->micro_version
>= 4))
3887 || instance
->minor_version
> 2)
3889 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_SUPPORT_CAS
, set
);
3891 return TEST_SUCCESS
;
3894 return TEST_SKIPPED
;
3897 static test_return_t
check_for_1_2_3(memcached_st
*memc
)
3899 memcached_version(memc
);
3900 memcached_server_instance_st
*instance
=
3901 memcached_server_instance_fetch(memc
, 0);
3903 if ((instance
->major_version
>= 1 && (instance
->minor_version
== 2 && instance
->micro_version
>= 4))
3904 || instance
->minor_version
> 2)
3905 return TEST_SUCCESS
;
3907 return TEST_SKIPPED
;
3910 static test_return_t
pre_unix_socket(memcached_st
*memc
)
3912 memcached_return_t rc
;
3915 memcached_servers_reset(memc
);
3917 if (stat("/tmp/memcached.socket", &buf
))
3918 return TEST_SKIPPED
;
3920 rc
= memcached_server_add_unix_socket_with_weight(memc
, "/tmp/memcached.socket", 0);
3922 return ( rc
== MEMCACHED_SUCCESS
? TEST_SUCCESS
: TEST_FAILURE
);
3925 static test_return_t
pre_nodelay(memcached_st
*memc
)
3927 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NO_BLOCK
, 0);
3928 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_TCP_NODELAY
, 0);
3930 return TEST_SUCCESS
;
3933 static test_return_t
pre_settimer(memcached_st
*memc
)
3935 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_SND_TIMEOUT
, 1000);
3936 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_RCV_TIMEOUT
, 1000);
3938 return TEST_SUCCESS
;
3941 static test_return_t
poll_timeout(memcached_st
*memc
)
3947 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_POLL_TIMEOUT
, timeout
);
3949 timeout
= (size_t)memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_POLL_TIMEOUT
);
3951 test_true(timeout
== 100);
3953 return TEST_SUCCESS
;
3956 static test_return_t
noreply_test(memcached_st
*memc
)
3958 memcached_return_t ret
;
3959 ret
= memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NOREPLY
, 1);
3960 test_true(ret
== MEMCACHED_SUCCESS
);
3961 ret
= memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_BUFFER_REQUESTS
, 1);
3962 test_true(ret
== MEMCACHED_SUCCESS
);
3963 ret
= memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_SUPPORT_CAS
, 1);
3964 test_true(ret
== MEMCACHED_SUCCESS
);
3965 test_true(memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_NOREPLY
) == 1);
3966 test_true(memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_BUFFER_REQUESTS
) == 1);
3967 test_true(memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_SUPPORT_CAS
) == 1);
3969 for (int count
=0; count
< 5; ++count
)
3971 for (size_t x
= 0; x
< 100; ++x
)
3974 size_t len
= (size_t)sprintf(key
, "%zu", x
);
3978 ret
= memcached_add(memc
, key
, len
, key
, len
, 0, 0);
3981 ret
= memcached_replace(memc
, key
, len
, key
, len
, 0, 0);
3984 ret
= memcached_set(memc
, key
, len
, key
, len
, 0, 0);
3987 ret
= memcached_append(memc
, key
, len
, key
, len
, 0, 0);
3990 ret
= memcached_prepend(memc
, key
, len
, key
, len
, 0, 0);
3996 test_true(ret
== MEMCACHED_SUCCESS
|| ret
== MEMCACHED_BUFFERED
);
4000 ** NOTE: Don't ever do this in your code! this is not a supported use of the
4001 ** API and is _ONLY_ done this way to verify that the library works the
4002 ** way it is supposed to do!!!!
4005 for (uint32_t x
= 0; x
< memcached_server_count(memc
); ++x
)
4007 memcached_server_instance_st
*instance
=
4008 memcached_server_instance_fetch(memc
, x
);
4009 no_msg
+=(int)(instance
->cursor_active
);
4012 test_true(no_msg
== 0);
4013 test_true(memcached_flush_buffers(memc
) == MEMCACHED_SUCCESS
);
4016 ** Now validate that all items was set properly!
4018 for (size_t x
= 0; x
< 100; ++x
)
4022 size_t len
= (size_t)sprintf(key
, "%zu", x
);
4025 char* value
=memcached_get(memc
, key
, strlen(key
),
4026 &length
, &flags
, &ret
);
4027 test_true(ret
== MEMCACHED_SUCCESS
&& value
!= NULL
);
4030 case 0: /* FALLTHROUGH */
4031 case 1: /* FALLTHROUGH */
4033 test_true(strncmp(value
, key
, len
) == 0);
4034 test_true(len
== length
);
4037 test_true(length
== len
* 2);
4040 test_true(length
== len
* 3);
4050 /* Try setting an illegal cas value (should not return an error to
4051 * the caller (because we don't expect a return message from the server)
4053 const char* keys
[]= {"0"};
4054 size_t lengths
[]= {1};
4057 memcached_result_st results_obj
;
4058 memcached_result_st
*results
;
4059 ret
= memcached_mget(memc
, keys
, lengths
, 1);
4060 test_true(ret
== MEMCACHED_SUCCESS
);
4062 results
= memcached_result_create(memc
, &results_obj
);
4064 results
= memcached_fetch_result(memc
, &results_obj
, &ret
);
4066 test_true(ret
== MEMCACHED_SUCCESS
);
4067 uint64_t cas
= memcached_result_cas(results
);
4068 memcached_result_free(&results_obj
);
4070 ret
= memcached_cas(memc
, keys
[0], lengths
[0], keys
[0], lengths
[0], 0, 0, cas
);
4071 test_true(ret
== MEMCACHED_SUCCESS
);
4074 * The item will have a new cas value, so try to set it again with the old
4075 * value. This should fail!
4077 ret
= memcached_cas(memc
, keys
[0], lengths
[0], keys
[0], lengths
[0], 0, 0, cas
);
4078 test_true(ret
== MEMCACHED_SUCCESS
);
4079 test_true(memcached_flush_buffers(memc
) == MEMCACHED_SUCCESS
);
4080 char* value
=memcached_get(memc
, keys
[0], lengths
[0], &length
, &flags
, &ret
);
4081 test_true(ret
== MEMCACHED_SUCCESS
&& value
!= NULL
);
4084 return TEST_SUCCESS
;
4087 static test_return_t
analyzer_test(memcached_st
*memc
)
4089 memcached_return_t rc
;
4090 memcached_stat_st
*memc_stat
;
4091 memcached_analysis_st
*report
;
4093 memc_stat
= memcached_stat(memc
, NULL
, &rc
);
4094 test_true(rc
== MEMCACHED_SUCCESS
);
4095 test_true(memc_stat
);
4097 report
= memcached_analyze(memc
, memc_stat
, &rc
);
4098 test_true(rc
== MEMCACHED_SUCCESS
);
4102 memcached_stat_free(NULL
, memc_stat
);
4104 return TEST_SUCCESS
;
4107 /* Count the objects */
4108 static memcached_return_t
callback_dump_counter(const memcached_st
*ptr
__attribute__((unused
)),
4109 const char *key
__attribute__((unused
)),
4110 size_t key_length
__attribute__((unused
)),
4113 size_t *counter
= (size_t *)context
;
4115 *counter
= *counter
+ 1;
4117 return MEMCACHED_SUCCESS
;
4120 static test_return_t
dump_test(memcached_st
*memc
)
4122 memcached_return_t rc
;
4124 memcached_dump_fn callbacks
[1];
4125 test_return_t main_rc
;
4127 callbacks
[0]= &callback_dump_counter
;
4129 /* No support for Binary protocol yet */
4130 if (memc
->flags
.binary_protocol
)
4131 return TEST_SUCCESS
;
4133 main_rc
= set_test3(memc
);
4135 test_true (main_rc
== TEST_SUCCESS
);
4137 rc
= memcached_dump(memc
, callbacks
, (void *)&counter
, 1);
4138 test_true(rc
== MEMCACHED_SUCCESS
);
4140 /* We may have more then 32 if our previous flush has not completed */
4141 test_true(counter
>= 32);
4143 return TEST_SUCCESS
;
4146 #ifdef HAVE_LIBMEMCACHEDUTIL
4147 static void* connection_release(void *arg
)
4150 memcached_pool_st
* pool
;
4155 assert(memcached_pool_push(resource
->pool
, resource
->mmc
) == MEMCACHED_SUCCESS
);
4159 static test_return_t
connection_pool_test(memcached_st
*memc
)
4161 memcached_pool_st
* pool
= memcached_pool_create(memc
, 5, 10);
4162 test_true(pool
!= NULL
);
4163 memcached_st
* mmc
[10];
4164 memcached_return_t rc
;
4166 for (size_t x
= 0; x
< 10; ++x
)
4168 mmc
[x
]= memcached_pool_pop(pool
, false, &rc
);
4169 test_true(mmc
[x
] != NULL
);
4170 test_true(rc
== MEMCACHED_SUCCESS
);
4173 test_true(memcached_pool_pop(pool
, false, &rc
) == NULL
);
4174 test_true(rc
== MEMCACHED_SUCCESS
);
4178 memcached_pool_st
* pool
;
4180 } item
= { .pool
= pool
, .mmc
= mmc
[9] };
4181 pthread_create(&tid
, NULL
, connection_release
, &item
);
4182 mmc
[9]= memcached_pool_pop(pool
, true, &rc
);
4183 test_true(rc
== MEMCACHED_SUCCESS
);
4184 pthread_join(tid
, NULL
);
4185 test_true(mmc
[9] == item
.mmc
);
4186 const char *key
= "key";
4187 size_t keylen
= strlen(key
);
4189 // verify that I can do ops with all connections
4190 rc
= memcached_set(mmc
[0], key
, keylen
, "0", 1, 0, 0);
4191 test_true(rc
== MEMCACHED_SUCCESS
);
4193 for (size_t x
= 0; x
< 10; ++x
)
4195 uint64_t number_value
;
4196 rc
= memcached_increment(mmc
[x
], key
, keylen
, 1, &number_value
);
4197 test_true(rc
== MEMCACHED_SUCCESS
);
4198 test_true(number_value
== (x
+1));
4202 for (size_t x
= 0; x
< 10; ++x
)
4204 test_true(memcached_pool_push(pool
, mmc
[x
]) == MEMCACHED_SUCCESS
);
4208 /* verify that I can set behaviors on the pool when I don't have all
4209 * of the connections in the pool. It should however be enabled
4210 * when I push the item into the pool
4212 mmc
[0]= memcached_pool_pop(pool
, false, &rc
);
4213 test_true(mmc
[0] != NULL
);
4215 rc
= memcached_pool_behavior_set(pool
, MEMCACHED_BEHAVIOR_IO_MSG_WATERMARK
, 9999);
4216 test_true(rc
== MEMCACHED_SUCCESS
);
4218 mmc
[1]= memcached_pool_pop(pool
, false, &rc
);
4219 test_true(mmc
[1] != NULL
);
4221 test_true(memcached_behavior_get(mmc
[1], MEMCACHED_BEHAVIOR_IO_MSG_WATERMARK
) == 9999);
4222 test_true(memcached_pool_push(pool
, mmc
[1]) == MEMCACHED_SUCCESS
);
4223 test_true(memcached_pool_push(pool
, mmc
[0]) == MEMCACHED_SUCCESS
);
4225 mmc
[0]= memcached_pool_pop(pool
, false, &rc
);
4226 test_true(memcached_behavior_get(mmc
[0], MEMCACHED_BEHAVIOR_IO_MSG_WATERMARK
) == 9999);
4227 test_true(memcached_pool_push(pool
, mmc
[0]) == MEMCACHED_SUCCESS
);
4230 test_true(memcached_pool_destroy(pool
) == memc
);
4231 return TEST_SUCCESS
;
4235 static test_return_t
replication_set_test(memcached_st
*memc
)
4237 memcached_return_t rc
;
4238 memcached_st
*memc_clone
= memcached_clone(NULL
, memc
);
4239 memcached_behavior_set(memc_clone
, MEMCACHED_BEHAVIOR_NUMBER_OF_REPLICAS
, 0);
4241 rc
= memcached_set(memc
, "bubba", 5, "0", 1, 0, 0);
4242 test_true(rc
== MEMCACHED_SUCCESS
);
4245 ** We are using the quiet commands to store the replicas, so we need
4246 ** to ensure that all of them are processed before we can continue.
4247 ** In the test we go directly from storing the object to trying to
4248 ** receive the object from all of the different servers, so we
4249 ** could end up in a race condition (the memcached server hasn't yet
4250 ** processed the quiet command from the replication set when it process
4251 ** the request from the other client (created by the clone)). As a
4252 ** workaround for that we call memcached_quit to send the quit command
4253 ** to the server and wait for the response ;-) If you use the test code
4254 ** as an example for your own code, please note that you shouldn't need
4257 memcached_quit(memc
);
4260 ** "bubba" should now be stored on all of our servers. We don't have an
4261 ** easy to use API to address each individual server, so I'll just iterate
4262 ** through a bunch of "master keys" and I should most likely hit all of the
4265 for (int x
= 'a'; x
<= 'z'; ++x
)
4267 char key
[2]= { [0]= (char)x
};
4270 char *val
= memcached_get_by_key(memc_clone
, key
, 1, "bubba", 5,
4272 test_true(rc
== MEMCACHED_SUCCESS
);
4273 test_true(val
!= NULL
);
4277 memcached_free(memc_clone
);
4279 return TEST_SUCCESS
;
4282 static test_return_t
replication_get_test(memcached_st
*memc
)
4284 memcached_return_t rc
;
4287 * Don't do the following in your code. I am abusing the internal details
4288 * within the library, and this is not a supported interface.
4289 * This is to verify correct behavior in the library
4291 for (uint32_t host
= 0; host
< memcached_server_count(memc
); ++host
)
4293 memcached_st
*memc_clone
= memcached_clone(NULL
, memc
);
4294 memcached_server_instance_st
*instance
=
4295 memcached_server_instance_fetch(memc_clone
, host
);
4299 for (int x
= 'a'; x
<= 'z'; ++x
)
4301 char key
[2]= { [0]= (char)x
};
4304 char *val
= memcached_get_by_key(memc_clone
, key
, 1, "bubba", 5,
4306 test_true(rc
== MEMCACHED_SUCCESS
);
4307 test_true(val
!= NULL
);
4311 memcached_free(memc_clone
);
4314 return TEST_SUCCESS
;
4317 static test_return_t
replication_mget_test(memcached_st
*memc
)
4319 memcached_return_t rc
;
4320 memcached_st
*memc_clone
= memcached_clone(NULL
, memc
);
4321 memcached_behavior_set(memc_clone
, MEMCACHED_BEHAVIOR_NUMBER_OF_REPLICAS
, 0);
4323 const char *keys
[]= { "bubba", "key1", "key2", "key3" };
4324 size_t len
[]= { 5, 4, 4, 4 };
4326 for (size_t x
= 0; x
< 4; ++x
)
4328 rc
= memcached_set(memc
, keys
[x
], len
[x
], "0", 1, 0, 0);
4329 test_true(rc
== MEMCACHED_SUCCESS
);
4333 ** We are using the quiet commands to store the replicas, so we need
4334 ** to ensure that all of them are processed before we can continue.
4335 ** In the test we go directly from storing the object to trying to
4336 ** receive the object from all of the different servers, so we
4337 ** could end up in a race condition (the memcached server hasn't yet
4338 ** processed the quiet command from the replication set when it process
4339 ** the request from the other client (created by the clone)). As a
4340 ** workaround for that we call memcached_quit to send the quit command
4341 ** to the server and wait for the response ;-) If you use the test code
4342 ** as an example for your own code, please note that you shouldn't need
4345 memcached_quit(memc
);
4348 * Don't do the following in your code. I am abusing the internal details
4349 * within the library, and this is not a supported interface.
4350 * This is to verify correct behavior in the library
4352 memcached_result_st result_obj
;
4353 for (uint32_t host
= 0; host
< memc_clone
->number_of_hosts
; host
++)
4355 memcached_st
*new_clone
= memcached_clone(NULL
, memc
);
4356 memcached_server_instance_st
*instance
=
4357 memcached_server_instance_fetch(new_clone
, host
);
4360 for (int x
= 'a'; x
<= 'z'; ++x
)
4362 char key
[2]= { [0]= (char)x
, [1]= 0 };
4364 rc
= memcached_mget_by_key(new_clone
, key
, 1, keys
, len
, 4);
4365 test_true(rc
== MEMCACHED_SUCCESS
);
4367 memcached_result_st
*results
= memcached_result_create(new_clone
, &result_obj
);
4371 while ((results
= memcached_fetch_result(new_clone
, &result_obj
, &rc
)) != NULL
)
4375 test_true(hits
== 4);
4376 memcached_result_free(&result_obj
);
4379 memcached_free(new_clone
);
4382 memcached_free(memc_clone
);
4384 return TEST_SUCCESS
;
4387 static test_return_t
replication_randomize_mget_test(memcached_st
*memc
)
4389 memcached_result_st result_obj
;
4390 memcached_return_t rc
;
4391 memcached_st
*memc_clone
= memcached_clone(NULL
, memc
);
4392 memcached_behavior_set(memc_clone
, MEMCACHED_BEHAVIOR_NUMBER_OF_REPLICAS
, 3);
4393 memcached_behavior_set(memc_clone
, MEMCACHED_BEHAVIOR_RANDOMIZE_REPLICA_READ
, 1);
4395 const char *keys
[]= { "key1", "key2", "key3", "key4", "key5", "key6", "key7" };
4396 size_t len
[]= { 4, 4, 4, 4, 4, 4, 4 };
4398 for (int x
=0; x
< 7; ++x
)
4400 rc
= memcached_set(memc
, keys
[x
], len
[x
], "1", 1, 0, 0);
4401 test_true(rc
== MEMCACHED_SUCCESS
);
4404 memcached_quit(memc
);
4406 for (size_t x
= 0; x
< 7; ++x
)
4408 const char key
[2]= { [0]= (const char)x
};
4410 rc
= memcached_mget_by_key(memc_clone
, key
, 1, keys
, len
, 7);
4411 test_true(rc
== MEMCACHED_SUCCESS
);
4413 memcached_result_st
*results
= memcached_result_create(memc_clone
, &result_obj
);
4417 while ((results
= memcached_fetch_result(memc_clone
, &result_obj
, &rc
)) != NULL
)
4421 test_true(hits
== 7);
4422 memcached_result_free(&result_obj
);
4424 memcached_free(memc_clone
);
4425 return TEST_SUCCESS
;
4428 static test_return_t
replication_delete_test(memcached_st
*memc
)
4430 memcached_return_t rc
;
4431 memcached_st
*memc_clone
= memcached_clone(NULL
, memc
);
4432 /* Delete the items from all of the servers except 1 */
4433 uint64_t repl
= memcached_behavior_get(memc
,
4434 MEMCACHED_BEHAVIOR_NUMBER_OF_REPLICAS
);
4435 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NUMBER_OF_REPLICAS
, --repl
);
4437 const char *keys
[]= { "bubba", "key1", "key2", "key3" };
4438 size_t len
[]= { 5, 4, 4, 4 };
4440 for (size_t x
= 0; x
< 4; ++x
)
4442 rc
= memcached_delete_by_key(memc
, keys
[0], len
[0], keys
[x
], len
[x
], 0);
4443 test_true(rc
== MEMCACHED_SUCCESS
);
4447 * Don't do the following in your code. I am abusing the internal details
4448 * within the library, and this is not a supported interface.
4449 * This is to verify correct behavior in the library
4451 uint32_t hash
= memcached_generate_hash(memc
, keys
[0], len
[0]);
4452 for (uint32_t x
= 0; x
< (repl
+ 1); ++x
)
4454 memcached_server_instance_st
*instance
=
4455 memcached_server_instance_fetch(memc_clone
, x
);
4458 if (++hash
== memc_clone
->number_of_hosts
)
4462 memcached_result_st result_obj
;
4463 for (uint32_t host
= 0; host
< memc_clone
->number_of_hosts
; ++host
)
4465 for (size_t x
= 'a'; x
<= 'z'; ++x
)
4467 const char key
[2]= { [0]= (const char)x
};
4469 rc
= memcached_mget_by_key(memc_clone
, key
, 1, keys
, len
, 4);
4470 test_true(rc
== MEMCACHED_SUCCESS
);
4472 memcached_result_st
*results
= memcached_result_create(memc_clone
, &result_obj
);
4476 while ((results
= memcached_fetch_result(memc_clone
, &result_obj
, &rc
)) != NULL
)
4480 test_true(hits
== 4);
4481 memcached_result_free(&result_obj
);
4484 memcached_free(memc_clone
);
4486 return TEST_SUCCESS
;
4489 static void increment_request_id(uint16_t *id
)
4492 if ((*id
& UDP_REQUEST_ID_THREAD_MASK
) != 0)
4496 static uint16_t *get_udp_request_ids(memcached_st
*memc
)
4498 uint16_t *ids
= malloc(sizeof(uint16_t) * memcached_server_count(memc
));
4499 assert(ids
!= NULL
);
4501 for (uint32_t x
= 0; x
< memcached_server_count(memc
); x
++)
4503 memcached_server_instance_st
*instance
=
4504 memcached_server_instance_fetch(memc
, x
);
4506 ids
[x
]= get_udp_datagram_request_id((struct udp_datagram_header_st
*) instance
->write_buffer
);
4512 static test_return_t
post_udp_op_check(memcached_st
*memc
, uint16_t *expected_req_ids
)
4514 memcached_server_st
*cur_server
= memcached_server_list(memc
);
4515 uint16_t *cur_req_ids
= get_udp_request_ids(memc
);
4517 for (size_t x
= 0; x
< memcached_server_count(memc
); x
++)
4519 test_true(cur_server
[x
].cursor_active
== 0);
4520 test_true(cur_req_ids
[x
] == expected_req_ids
[x
]);
4522 free(expected_req_ids
);
4525 return TEST_SUCCESS
;
4529 ** There is a little bit of a hack here, instead of removing
4530 ** the servers, I just set num host to 0 and them add then new udp servers
4532 static test_return_t
init_udp(memcached_st
*memc
)
4534 memcached_version(memc
);
4535 memcached_server_instance_st
*instance
=
4536 memcached_server_instance_fetch(memc
, 0);
4538 /* For the time being, only support udp test for >= 1.2.6 && < 1.3 */
4539 if (instance
->major_version
!= 1 || instance
->minor_version
!= 2
4540 || instance
->micro_version
< 6)
4541 return TEST_SKIPPED
;
4543 uint32_t num_hosts
= memcached_server_count(memc
);
4544 memcached_server_st servers
[num_hosts
];
4545 memcpy(servers
, memcached_server_list(memc
), sizeof(memcached_server_st
) * num_hosts
);
4546 for (uint32_t x
= 0; x
< num_hosts
; x
++)
4548 memcached_server_instance_st
*set_instance
=
4549 memcached_server_instance_fetch(memc
, x
);
4551 memcached_server_free(set_instance
);
4554 memc
->number_of_hosts
= 0;
4555 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_USE_UDP
, 1);
4556 for (uint32_t x
= 0; x
< num_hosts
; x
++)
4558 memcached_server_instance_st
*set_instance
=
4559 memcached_server_instance_fetch(memc
, x
);
4561 test_true(memcached_server_add_udp(memc
, servers
[x
].hostname
, servers
[x
].port
) == MEMCACHED_SUCCESS
);
4562 test_true(set_instance
->write_buffer_offset
== UDP_DATAGRAM_HEADER_LENGTH
);
4565 return TEST_SUCCESS
;
4568 static test_return_t
binary_init_udp(memcached_st
*memc
)
4570 test_return_t test_rc
;
4571 test_rc
= pre_binary(memc
);
4573 if (test_rc
!= TEST_SUCCESS
)
4576 return init_udp(memc
);
4579 /* Make sure that I cant add a tcp server to a udp client */
4580 static test_return_t
add_tcp_server_udp_client_test(memcached_st
*memc
)
4584 memcached_server_st server
;
4585 memcached_server_instance_st
*instance
=
4586 memcached_server_instance_fetch(memc
, 0);
4587 memcached_server_clone(&server
, &memc
->hosts
[0]);
4588 test_true(memcached_server_remove(&(memc
->hosts
[0])) == MEMCACHED_SUCCESS
);
4589 test_true(memcached_server_add(memc
, server
.hostname
, server
.port
) == MEMCACHED_INVALID_HOST_PROTOCOL
);
4591 return TEST_SUCCESS
;
4594 /* Make sure that I cant add a udp server to a tcp client */
4595 static test_return_t
add_udp_server_tcp_client_test(memcached_st
*memc
)
4599 memcached_server_st server
;
4600 memcached_server_instance_st
*instance
=
4601 memcached_server_instance_fetch(memc
, 0);
4602 memcached_server_clone(&server
, &memc
->hosts
[0]);
4603 test_true(memcached_server_remove(&(memc
->hosts
[0])) == MEMCACHED_SUCCESS
);
4605 memcached_st tcp_client
;
4606 memcached_create(&tcp_client
);
4607 test_true(memcached_server_add_udp(&tcp_client
, server
.hostname
, server
.port
) == MEMCACHED_INVALID_HOST_PROTOCOL
);
4610 return TEST_SUCCESS
;
4613 static test_return_t
set_udp_behavior_test(memcached_st
*memc
)
4616 memcached_quit(memc
);
4617 memc
->number_of_hosts
= 0;
4618 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_DISTRIBUTION
, memc
->distribution
);
4619 test_true(memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_USE_UDP
, 1) == MEMCACHED_SUCCESS
);
4620 test_true(memc
->flags
.use_udp
);
4621 test_true(memc
->flags
.no_reply
);
4623 test_true(memcached_server_count(memc
) == 0);
4625 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_USE_UDP
,0);
4626 test_true(! (memc
->flags
.use_udp
));
4627 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NOREPLY
,0);
4628 test_true(! (memc
->flags
.no_reply
));
4630 return TEST_SUCCESS
;
4633 static test_return_t
udp_set_test(memcached_st
*memc
)
4635 unsigned int num_iters
= 1025; //request id rolls over at 1024
4637 for (size_t x
= 0; x
< num_iters
;x
++)
4639 memcached_return_t rc
;
4640 const char *key
= "foo";
4641 const char *value
= "when we sanitize";
4642 uint16_t *expected_ids
= get_udp_request_ids(memc
);
4643 unsigned int server_key
= memcached_generate_hash(memc
, key
, strlen(key
));
4644 memcached_server_instance_st
*instance
=
4645 memcached_server_instance_fetch(memc
, server_key
);
4646 size_t init_offset
= instance
->write_buffer_offset
;
4648 rc
= memcached_set(memc
, key
, strlen(key
),
4649 value
, strlen(value
),
4650 (time_t)0, (uint32_t)0);
4651 test_true(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
);
4652 /** NB, the check below assumes that if new write_ptr is less than
4653 * the original write_ptr that we have flushed. For large payloads, this
4654 * maybe an invalid assumption, but for the small payload we have it is OK
4656 if (rc
== MEMCACHED_SUCCESS
||
4657 instance
->write_buffer_offset
< init_offset
)
4658 increment_request_id(&expected_ids
[server_key
]);
4660 if (rc
== MEMCACHED_SUCCESS
)
4662 test_true(instance
->write_buffer_offset
== UDP_DATAGRAM_HEADER_LENGTH
);
4666 test_true(instance
->write_buffer_offset
!= UDP_DATAGRAM_HEADER_LENGTH
);
4667 test_true(instance
->write_buffer_offset
<= MAX_UDP_DATAGRAM_LENGTH
);
4669 test_true(post_udp_op_check(memc
, expected_ids
) == TEST_SUCCESS
);
4671 return TEST_SUCCESS
;
4674 static test_return_t
udp_buffered_set_test(memcached_st
*memc
)
4676 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_BUFFER_REQUESTS
, 1);
4677 return udp_set_test(memc
);
4680 static test_return_t
udp_set_too_big_test(memcached_st
*memc
)
4682 memcached_return_t rc
;
4683 const char *key
= "bar";
4684 char value
[MAX_UDP_DATAGRAM_LENGTH
];
4685 uint16_t *expected_ids
= get_udp_request_ids(memc
);
4686 rc
= memcached_set(memc
, key
, strlen(key
),
4687 value
, MAX_UDP_DATAGRAM_LENGTH
,
4688 (time_t)0, (uint32_t)0);
4689 test_true(rc
== MEMCACHED_WRITE_FAILURE
);
4691 return post_udp_op_check(memc
,expected_ids
);
4694 static test_return_t
udp_delete_test(memcached_st
*memc
)
4696 unsigned int num_iters
= 1025; //request id rolls over at 1024
4698 for (size_t x
= 0; x
< num_iters
;x
++)
4700 memcached_return_t rc
;
4701 const char *key
= "foo";
4702 uint16_t *expected_ids
=get_udp_request_ids(memc
);
4703 unsigned int server_key
= memcached_generate_hash(memc
, key
, strlen(key
));
4704 memcached_server_instance_st
*instance
=
4705 memcached_server_instance_fetch(memc
, server_key
);
4706 size_t init_offset
= instance
->write_buffer_offset
;
4708 rc
= memcached_delete(memc
, key
, strlen(key
), 0);
4709 test_true(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
);
4711 if (rc
== MEMCACHED_SUCCESS
|| instance
->write_buffer_offset
< init_offset
)
4712 increment_request_id(&expected_ids
[server_key
]);
4713 if (rc
== MEMCACHED_SUCCESS
)
4715 test_true(instance
->write_buffer_offset
== UDP_DATAGRAM_HEADER_LENGTH
);
4719 test_true(instance
->write_buffer_offset
!= UDP_DATAGRAM_HEADER_LENGTH
);
4720 test_true(instance
->write_buffer_offset
<= MAX_UDP_DATAGRAM_LENGTH
);
4722 test_true(post_udp_op_check(memc
,expected_ids
) == TEST_SUCCESS
);
4724 return TEST_SUCCESS
;
4727 static test_return_t
udp_buffered_delete_test(memcached_st
*memc
)
4729 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_BUFFER_REQUESTS
, 1);
4730 return udp_delete_test(memc
);
4733 static test_return_t
udp_verbosity_test(memcached_st
*memc
)
4735 memcached_return_t rc
;
4736 uint16_t *expected_ids
= get_udp_request_ids(memc
);
4738 for (size_t x
= 0; x
< memcached_server_count(memc
); x
++)
4740 increment_request_id(&expected_ids
[x
]);
4743 rc
= memcached_verbosity(memc
,3);
4744 test_true(rc
== MEMCACHED_SUCCESS
);
4745 return post_udp_op_check(memc
,expected_ids
);
4748 static test_return_t
udp_quit_test(memcached_st
*memc
)
4750 uint16_t *expected_ids
= get_udp_request_ids(memc
);
4751 memcached_quit(memc
);
4752 return post_udp_op_check(memc
, expected_ids
);
4755 static test_return_t
udp_flush_test(memcached_st
*memc
)
4757 memcached_return_t rc
;
4758 uint16_t *expected_ids
= get_udp_request_ids(memc
);
4760 for (size_t x
= 0; x
< memcached_server_count(memc
); x
++)
4762 increment_request_id(&expected_ids
[x
]);
4765 rc
= memcached_flush(memc
,0);
4766 test_true(rc
== MEMCACHED_SUCCESS
);
4767 return post_udp_op_check(memc
,expected_ids
);
4770 static test_return_t
udp_incr_test(memcached_st
*memc
)
4772 memcached_return_t rc
;
4773 const char *key
= "incr";
4774 const char *value
= "1";
4775 rc
= memcached_set(memc
, key
, strlen(key
),
4776 value
, strlen(value
),
4777 (time_t)0, (uint32_t)0);
4779 test_true(rc
== MEMCACHED_SUCCESS
);
4780 uint16_t *expected_ids
= get_udp_request_ids(memc
);
4781 unsigned int server_key
= memcached_generate_hash(memc
, key
, strlen(key
));
4782 increment_request_id(&expected_ids
[server_key
]);
4784 rc
= memcached_increment(memc
, key
, strlen(key
), 1, &newvalue
);
4785 test_true(rc
== MEMCACHED_SUCCESS
);
4786 return post_udp_op_check(memc
, expected_ids
);
4789 static test_return_t
udp_decr_test(memcached_st
*memc
)
4791 memcached_return_t rc
;
4792 const char *key
= "decr";
4793 const char *value
= "1";
4794 rc
= memcached_set(memc
, key
, strlen(key
),
4795 value
, strlen(value
),
4796 (time_t)0, (uint32_t)0);
4798 test_true(rc
== MEMCACHED_SUCCESS
);
4799 uint16_t *expected_ids
= get_udp_request_ids(memc
);
4800 unsigned int server_key
= memcached_generate_hash(memc
, key
, strlen(key
));
4801 increment_request_id(&expected_ids
[server_key
]);
4803 rc
= memcached_decrement(memc
, key
, strlen(key
), 1, &newvalue
);
4804 test_true(rc
== MEMCACHED_SUCCESS
);
4805 return post_udp_op_check(memc
, expected_ids
);
4809 static test_return_t
udp_stat_test(memcached_st
*memc
)
4811 memcached_stat_st
* rv
= NULL
;
4812 memcached_return_t rc
;
4814 uint16_t *expected_ids
= get_udp_request_ids(memc
);
4815 rv
= memcached_stat(memc
, args
, &rc
);
4817 test_true(rc
== MEMCACHED_NOT_SUPPORTED
);
4818 return post_udp_op_check(memc
, expected_ids
);
4821 static test_return_t
udp_version_test(memcached_st
*memc
)
4823 memcached_return_t rc
;
4824 uint16_t *expected_ids
= get_udp_request_ids(memc
);
4825 rc
= memcached_version(memc
);
4826 test_true(rc
== MEMCACHED_NOT_SUPPORTED
);
4827 return post_udp_op_check(memc
, expected_ids
);
4830 static test_return_t
udp_get_test(memcached_st
*memc
)
4832 memcached_return_t rc
;
4833 const char *key
= "foo";
4835 uint16_t *expected_ids
= get_udp_request_ids(memc
);
4836 char *val
= memcached_get(memc
, key
, strlen(key
), &vlen
, (uint32_t)0, &rc
);
4837 test_true(rc
== MEMCACHED_NOT_SUPPORTED
);
4838 test_true(val
== NULL
);
4839 return post_udp_op_check(memc
, expected_ids
);
4842 static test_return_t
udp_mixed_io_test(memcached_st
*memc
)
4845 test_st mixed_io_ops
[] ={
4847 (test_callback_fn
)udp_set_test
},
4848 {"udp_set_too_big_test", 0,
4849 (test_callback_fn
)udp_set_too_big_test
},
4850 {"udp_delete_test", 0,
4851 (test_callback_fn
)udp_delete_test
},
4852 {"udp_verbosity_test", 0,
4853 (test_callback_fn
)udp_verbosity_test
},
4854 {"udp_quit_test", 0,
4855 (test_callback_fn
)udp_quit_test
},
4856 {"udp_flush_test", 0,
4857 (test_callback_fn
)udp_flush_test
},
4858 {"udp_incr_test", 0,
4859 (test_callback_fn
)udp_incr_test
},
4860 {"udp_decr_test", 0,
4861 (test_callback_fn
)udp_decr_test
},
4862 {"udp_version_test", 0,
4863 (test_callback_fn
)udp_version_test
}
4865 for (size_t x
= 0; x
< 500; x
++)
4867 current_op
= mixed_io_ops
[random() % 9];
4868 test_true(current_op
.test_fn(memc
) == TEST_SUCCESS
);
4870 return TEST_SUCCESS
;
4874 static test_return_t
hash_sanity_test (memcached_st
*memc
)
4878 assert(MEMCACHED_HASH_DEFAULT
== MEMCACHED_HASH_DEFAULT
);
4879 assert(MEMCACHED_HASH_MD5
== MEMCACHED_HASH_MD5
);
4880 assert(MEMCACHED_HASH_CRC
== MEMCACHED_HASH_CRC
);
4881 assert(MEMCACHED_HASH_FNV1_64
== MEMCACHED_HASH_FNV1_64
);
4882 assert(MEMCACHED_HASH_FNV1A_64
== MEMCACHED_HASH_FNV1A_64
);
4883 assert(MEMCACHED_HASH_FNV1_32
== MEMCACHED_HASH_FNV1_32
);
4884 assert(MEMCACHED_HASH_FNV1A_32
== MEMCACHED_HASH_FNV1A_32
);
4885 #ifdef HAVE_HSIEH_HASH
4886 assert(MEMCACHED_HASH_HSIEH
== MEMCACHED_HASH_HSIEH
);
4888 assert(MEMCACHED_HASH_MURMUR
== MEMCACHED_HASH_MURMUR
);
4889 assert(MEMCACHED_HASH_JENKINS
== MEMCACHED_HASH_JENKINS
);
4890 assert(MEMCACHED_HASH_MAX
== MEMCACHED_HASH_MAX
);
4892 return TEST_SUCCESS
;
4896 static test_return_t
hsieh_avaibility_test (memcached_st
*memc
)
4898 memcached_return_t expected_rc
= MEMCACHED_FAILURE
;
4899 #ifdef HAVE_HSIEH_HASH
4900 expected_rc
= MEMCACHED_SUCCESS
;
4902 memcached_return_t rc
= memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_HASH
,
4903 (uint64_t)MEMCACHED_HASH_HSIEH
);
4904 test_true(rc
== expected_rc
);
4906 return TEST_SUCCESS
;
4909 static test_return_t
md5_run (memcached_st
*memc
__attribute__((unused
)))
4914 for (ptr
= list_to_hash
, x
= 0; *ptr
; ptr
++, x
++)
4918 hash_val
= memcached_generate_hash_value(*ptr
, strlen(*ptr
), MEMCACHED_HASH_MD5
);
4919 test_true(md5_values
[x
] == hash_val
);
4922 return TEST_SUCCESS
;
4925 static test_return_t
crc_run (memcached_st
*memc
__attribute__((unused
)))
4930 for (ptr
= list_to_hash
, x
= 0; *ptr
; ptr
++, x
++)
4934 hash_val
= memcached_generate_hash_value(*ptr
, strlen(*ptr
), MEMCACHED_HASH_CRC
);
4935 test_true(crc_values
[x
] == hash_val
);
4938 return TEST_SUCCESS
;
4941 static test_return_t
fnv1_64_run (memcached_st
*memc
__attribute__((unused
)))
4946 for (ptr
= list_to_hash
, x
= 0; *ptr
; ptr
++, x
++)
4950 hash_val
= memcached_generate_hash_value(*ptr
, strlen(*ptr
), MEMCACHED_HASH_FNV1_64
);
4951 test_true(fnv1_64_values
[x
] == hash_val
);
4954 return TEST_SUCCESS
;
4957 static test_return_t
fnv1a_64_run (memcached_st
*memc
__attribute__((unused
)))
4962 for (ptr
= list_to_hash
, x
= 0; *ptr
; ptr
++, x
++)
4966 hash_val
= memcached_generate_hash_value(*ptr
, strlen(*ptr
), MEMCACHED_HASH_FNV1A_64
);
4967 test_true(fnv1a_64_values
[x
] == hash_val
);
4970 return TEST_SUCCESS
;
4973 static test_return_t
fnv1_32_run (memcached_st
*memc
__attribute__((unused
)))
4979 for (ptr
= list_to_hash
, x
= 0; *ptr
; ptr
++, x
++)
4983 hash_val
= memcached_generate_hash_value(*ptr
, strlen(*ptr
), MEMCACHED_HASH_FNV1_32
);
4984 test_true(fnv1_32_values
[x
] == hash_val
);
4987 return TEST_SUCCESS
;
4990 static test_return_t
fnv1a_32_run (memcached_st
*memc
__attribute__((unused
)))
4995 for (ptr
= list_to_hash
, x
= 0; *ptr
; ptr
++, x
++)
4999 hash_val
= memcached_generate_hash_value(*ptr
, strlen(*ptr
), MEMCACHED_HASH_FNV1A_32
);
5000 test_true(fnv1a_32_values
[x
] == hash_val
);
5003 return TEST_SUCCESS
;
5006 static test_return_t
hsieh_run (memcached_st
*memc
__attribute__((unused
)))
5011 for (ptr
= list_to_hash
, x
= 0; *ptr
; ptr
++, x
++)
5015 hash_val
= memcached_generate_hash_value(*ptr
, strlen(*ptr
), MEMCACHED_HASH_HSIEH
);
5016 test_true(hsieh_values
[x
] == hash_val
);
5019 return TEST_SUCCESS
;
5022 static test_return_t
murmur_run (memcached_st
*memc
__attribute__((unused
)))
5025 return TEST_SKIPPED
;
5030 for (ptr
= list_to_hash
, x
= 0; *ptr
; ptr
++, x
++)
5034 hash_val
= memcached_generate_hash_value(*ptr
, strlen(*ptr
), MEMCACHED_HASH_MURMUR
);
5035 test_true(murmur_values
[x
] == hash_val
);
5038 return TEST_SUCCESS
;
5042 static test_return_t
jenkins_run (memcached_st
*memc
__attribute__((unused
)))
5048 for (ptr
= list_to_hash
, x
= 0; *ptr
; ptr
++, x
++)
5052 hash_val
= memcached_generate_hash_value(*ptr
, strlen(*ptr
), MEMCACHED_HASH_JENKINS
);
5053 test_true(jenkins_values
[x
] == hash_val
);
5056 return TEST_SUCCESS
;
5060 static test_return_t
ketama_compatibility_libmemcached(memcached_st
*trash
)
5062 memcached_return_t rc
;
5065 memcached_server_st
*server_pool
;
5070 memc
= memcached_create(NULL
);
5073 rc
= memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_KETAMA_WEIGHTED
, 1);
5074 test_true(rc
== MEMCACHED_SUCCESS
);
5076 value
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_KETAMA_WEIGHTED
);
5077 test_true(value
== 1);
5079 test_true(memcached_behavior_set_distribution(memc
, MEMCACHED_DISTRIBUTION_CONSISTENT_KETAMA
) == MEMCACHED_SUCCESS
);
5080 test_true(memcached_behavior_get_distribution(memc
) == MEMCACHED_DISTRIBUTION_CONSISTENT_KETAMA
);
5083 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");
5084 memcached_server_push(memc
, server_pool
);
5086 /* verify that the server list was parsed okay. */
5087 test_true(memcached_server_count(memc
) == 8);
5088 test_strcmp(server_pool
[0].hostname
, "10.0.1.1");
5089 test_true(server_pool
[0].port
== 11211);
5090 test_true(server_pool
[0].weight
== 600);
5091 test_strcmp(server_pool
[2].hostname
, "10.0.1.3");
5092 test_true(server_pool
[2].port
== 11211);
5093 test_true(server_pool
[2].weight
== 200);
5094 test_strcmp(server_pool
[7].hostname
, "10.0.1.8");
5095 test_true(server_pool
[7].port
== 11211);
5096 test_true(server_pool
[7].weight
== 100);
5098 /* VDEAAAAA hashes to fffcd1b5, after the last continuum point, and lets
5099 * us test the boundary wraparound.
5101 test_true(memcached_generate_hash(memc
, (char *)"VDEAAAAA", 8) == memc
->continuum
[0].index
);
5103 /* verify the standard ketama set. */
5104 for (x
= 0; x
< 99; x
++)
5106 uint32_t server_idx
= memcached_generate_hash(memc
, ketama_test_cases
[x
].key
, strlen(ketama_test_cases
[x
].key
));
5107 memcached_server_instance_st
*instance
=
5108 memcached_server_instance_fetch(memc
, server_idx
);
5109 char *hostname
= instance
->hostname
;
5111 test_strcmp(hostname
, ketama_test_cases
[x
].server
);
5114 memcached_server_list_free(server_pool
);
5115 memcached_free(memc
);
5117 return TEST_SUCCESS
;
5120 static test_return_t
ketama_compatibility_spymemcached(memcached_st
*trash
)
5122 memcached_return_t rc
;
5125 memcached_server_st
*server_pool
;
5130 memc
= memcached_create(NULL
);
5133 rc
= memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_KETAMA_WEIGHTED
, 1);
5134 test_true(rc
== MEMCACHED_SUCCESS
);
5136 value
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_KETAMA_WEIGHTED
);
5137 test_true(value
== 1);
5139 test_true(memcached_behavior_set_distribution(memc
, MEMCACHED_DISTRIBUTION_CONSISTENT_KETAMA_SPY
) == MEMCACHED_SUCCESS
);
5140 test_true(memcached_behavior_get_distribution(memc
) == MEMCACHED_DISTRIBUTION_CONSISTENT_KETAMA_SPY
);
5142 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");
5143 memcached_server_push(memc
, server_pool
);
5145 /* verify that the server list was parsed okay. */
5146 test_true(memcached_server_count(memc
) == 8);
5147 test_strcmp(server_pool
[0].hostname
, "10.0.1.1");
5148 test_true(server_pool
[0].port
== 11211);
5149 test_true(server_pool
[0].weight
== 600);
5150 test_strcmp(server_pool
[2].hostname
, "10.0.1.3");
5151 test_true(server_pool
[2].port
== 11211);
5152 test_true(server_pool
[2].weight
== 200);
5153 test_strcmp(server_pool
[7].hostname
, "10.0.1.8");
5154 test_true(server_pool
[7].port
== 11211);
5155 test_true(server_pool
[7].weight
== 100);
5157 /* VDEAAAAA hashes to fffcd1b5, after the last continuum point, and lets
5158 * us test the boundary wraparound.
5160 test_true(memcached_generate_hash(memc
, (char *)"VDEAAAAA", 8) == memc
->continuum
[0].index
);
5162 /* verify the standard ketama set. */
5163 for (x
= 0; x
< 99; x
++)
5165 uint32_t server_idx
= memcached_generate_hash(memc
, ketama_test_cases_spy
[x
].key
, strlen(ketama_test_cases_spy
[x
].key
));
5166 memcached_server_instance_st
*instance
=
5167 memcached_server_instance_fetch(memc
, server_idx
);
5168 char *hostname
= instance
->hostname
;
5169 test_strcmp(hostname
, ketama_test_cases_spy
[x
].server
);
5172 memcached_server_list_free(server_pool
);
5173 memcached_free(memc
);
5175 return TEST_SUCCESS
;
5178 static test_return_t
regression_bug_434484(memcached_st
*memc
)
5180 test_return_t test_rc
;
5181 test_rc
= pre_binary(memc
);
5183 if (test_rc
!= TEST_SUCCESS
)
5186 memcached_return_t ret
;
5187 const char *key
= "regression_bug_434484";
5188 size_t keylen
= strlen(key
);
5190 ret
= memcached_append(memc
, key
, keylen
, key
, keylen
, 0, 0);
5191 test_true(ret
== MEMCACHED_NOTSTORED
);
5193 size_t size
= 2048 * 1024;
5194 void *data
= calloc(1, size
);
5195 test_true(data
!= NULL
);
5196 ret
= memcached_set(memc
, key
, keylen
, data
, size
, 0, 0);
5197 test_true(ret
== MEMCACHED_E2BIG
);
5200 return TEST_SUCCESS
;
5203 static test_return_t
regression_bug_434843(memcached_st
*memc
)
5205 test_return_t test_rc
;
5206 test_rc
= pre_binary(memc
);
5208 if (test_rc
!= TEST_SUCCESS
)
5211 memcached_return_t rc
;
5213 memcached_execute_fn callbacks
[1]= { [0]= &callback_counter
};
5216 * I only want to hit only _one_ server so I know the number of requests I'm
5217 * sending in the pipleine to the server. Let's try to do a multiget of
5218 * 1024 (that should satisfy most users don't you think?). Future versions
5219 * will include a mget_execute function call if you need a higher number.
5221 uint32_t number_of_hosts
= memcached_server_count(memc
);
5222 memc
->number_of_hosts
= 1;
5223 const size_t max_keys
= 1024;
5224 char **keys
= calloc(max_keys
, sizeof(char*));
5225 size_t *key_length
=calloc(max_keys
, sizeof(size_t));
5227 for (size_t x
= 0; x
< max_keys
; ++x
)
5231 key_length
[x
]= (size_t)snprintf(k
, sizeof(k
), "0200%zu", x
);
5233 test_true(keys
[x
] != NULL
);
5237 * Run two times.. the first time we should have 100% cache miss,
5238 * and the second time we should have 100% cache hits
5240 for (size_t y
= 0; y
< 2; y
++)
5242 rc
= memcached_mget(memc
, (const char**)keys
, key_length
, max_keys
);
5243 test_true(rc
== MEMCACHED_SUCCESS
);
5244 rc
= memcached_fetch_execute(memc
, callbacks
, (void *)&counter
, 1);
5248 /* The first iteration should give me a 100% cache miss. verify that*/
5249 char blob
[1024]= { 0 };
5251 test_true(counter
== 0);
5253 for (size_t x
= 0; x
< max_keys
; ++x
)
5255 rc
= memcached_add(memc
, keys
[x
], key_length
[x
],
5256 blob
, sizeof(blob
), 0, 0);
5257 test_true(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
);
5262 /* Verify that we received all of the key/value pairs */
5263 test_true(counter
== max_keys
);
5267 /* Release allocated resources */
5268 for (size_t x
= 0; x
< max_keys
; ++x
)
5275 memc
->number_of_hosts
= number_of_hosts
;
5277 return TEST_SUCCESS
;
5280 static test_return_t
regression_bug_434843_buffered(memcached_st
*memc
)
5282 memcached_return_t rc
;
5283 rc
= memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_BUFFER_REQUESTS
, 1);
5284 test_true(rc
== MEMCACHED_SUCCESS
);
5286 return regression_bug_434843(memc
);
5289 static test_return_t
regression_bug_421108(memcached_st
*memc
)
5291 memcached_return_t rc
;
5292 memcached_stat_st
*memc_stat
= memcached_stat(memc
, NULL
, &rc
);
5293 test_true(rc
== MEMCACHED_SUCCESS
);
5295 char *bytes
= memcached_stat_get_value(memc
, memc_stat
, "bytes", &rc
);
5296 test_true(rc
== MEMCACHED_SUCCESS
);
5297 test_true(bytes
!= NULL
);
5298 char *bytes_read
= memcached_stat_get_value(memc
, memc_stat
,
5300 test_true(rc
== MEMCACHED_SUCCESS
);
5301 test_true(bytes_read
!= NULL
);
5303 char *bytes_written
= memcached_stat_get_value(memc
, memc_stat
,
5304 "bytes_written", &rc
);
5305 test_true(rc
== MEMCACHED_SUCCESS
);
5306 test_true(bytes_written
!= NULL
);
5308 test_true(strcmp(bytes
, bytes_read
) != 0);
5309 test_true(strcmp(bytes
, bytes_written
) != 0);
5311 /* Release allocated resources */
5314 free(bytes_written
);
5315 memcached_stat_free(NULL
, memc_stat
);
5317 return TEST_SUCCESS
;
5321 * The test case isn't obvious so I should probably document why
5322 * it works the way it does. Bug 442914 was caused by a bug
5323 * in the logic in memcached_purge (it did not handle the case
5324 * where the number of bytes sent was equal to the watermark).
5325 * In this test case, create messages so that we hit that case
5326 * and then disable noreply mode and issue a new command to
5327 * verify that it isn't stuck. If we change the format for the
5328 * delete command or the watermarks, we need to update this
5331 static test_return_t
regression_bug_442914(memcached_st
*memc
)
5333 memcached_return_t rc
;
5334 rc
= memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NOREPLY
, 1);
5335 test_true(rc
== MEMCACHED_SUCCESS
);
5336 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_TCP_NODELAY
, 1);
5338 uint32_t number_of_hosts
= memcached_server_count(memc
);
5339 memc
->number_of_hosts
= 1;
5344 for (uint32_t x
= 0; x
< 250; ++x
)
5346 len
= (size_t)snprintf(k
, sizeof(k
), "%0250u", x
);
5347 rc
= memcached_delete(memc
, k
, len
, 0);
5348 test_true(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
);
5351 (void)snprintf(k
, sizeof(k
), "%037u", 251U);
5354 rc
= memcached_delete(memc
, k
, len
, 0);
5355 test_true(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
);
5357 rc
= memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NOREPLY
, 0);
5358 test_true(rc
== MEMCACHED_SUCCESS
);
5359 rc
= memcached_delete(memc
, k
, len
, 0);
5360 test_true(rc
== MEMCACHED_NOTFOUND
);
5362 memc
->number_of_hosts
= number_of_hosts
;
5364 return TEST_SUCCESS
;
5367 static test_return_t
regression_bug_447342(memcached_st
*memc
)
5369 memcached_server_instance_st
*instance_one
;
5370 memcached_server_instance_st
*instance_two
;
5372 if (memcached_server_count(memc
) < 3 || pre_replication(memc
) != MEMCACHED_SUCCESS
)
5373 return TEST_SKIPPED
;
5375 memcached_return_t rc
;
5377 rc
= memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NUMBER_OF_REPLICAS
, 2);
5378 test_true(rc
== MEMCACHED_SUCCESS
);
5380 const size_t max_keys
= 100;
5381 char **keys
= calloc(max_keys
, sizeof(char*));
5382 size_t *key_length
= calloc(max_keys
, sizeof(size_t));
5384 for (size_t x
= 0; x
< max_keys
; ++x
)
5388 key_length
[x
]= (size_t)snprintf(k
, sizeof(k
), "0200%zu", x
);
5390 test_true(keys
[x
] != NULL
);
5391 rc
= memcached_set(memc
, k
, key_length
[x
], k
, key_length
[x
], 0, 0);
5392 test_true(rc
== MEMCACHED_SUCCESS
);
5396 ** We are using the quiet commands to store the replicas, so we need
5397 ** to ensure that all of them are processed before we can continue.
5398 ** In the test we go directly from storing the object to trying to
5399 ** receive the object from all of the different servers, so we
5400 ** could end up in a race condition (the memcached server hasn't yet
5401 ** processed the quiet command from the replication set when it process
5402 ** the request from the other client (created by the clone)). As a
5403 ** workaround for that we call memcached_quit to send the quit command
5404 ** to the server and wait for the response ;-) If you use the test code
5405 ** as an example for your own code, please note that you shouldn't need
5408 memcached_quit(memc
);
5410 /* Verify that all messages are stored, and we didn't stuff too much
5413 rc
= memcached_mget(memc
, (const char* const *)keys
, key_length
, max_keys
);
5414 test_true(rc
== MEMCACHED_SUCCESS
);
5417 memcached_execute_fn callbacks
[1]= { [0]= &callback_counter
};
5418 rc
= memcached_fetch_execute(memc
, callbacks
, (void *)&counter
, 1);
5419 /* Verify that we received all of the key/value pairs */
5420 test_true(counter
== max_keys
);
5422 memcached_quit(memc
);
5424 * Don't do the following in your code. I am abusing the internal details
5425 * within the library, and this is not a supported interface.
5426 * This is to verify correct behavior in the library. Fake that two servers
5429 instance_one
= memcached_server_instance_fetch(memc
, 0);
5430 instance_two
= memcached_server_instance_fetch(memc
, 2);
5431 in_port_t port0
= instance_one
->port
;
5432 in_port_t port2
= instance_two
->port
;
5434 instance_one
->port
= 0;
5435 instance_two
->port
= 0;
5437 rc
= memcached_mget(memc
, (const char* const *)keys
, key_length
, max_keys
);
5438 test_true(rc
== MEMCACHED_SUCCESS
);
5441 rc
= memcached_fetch_execute(memc
, callbacks
, (void *)&counter
, 1);
5442 test_true(counter
== (unsigned int)max_keys
);
5444 /* restore the memc handle */
5445 instance_one
->port
= port0
;
5446 instance_two
->port
= port2
;
5448 memcached_quit(memc
);
5450 /* Remove half of the objects */
5451 for (size_t x
= 0; x
< max_keys
; ++x
)
5455 rc
= memcached_delete(memc
, keys
[x
], key_length
[x
], 0);
5456 test_true(rc
== MEMCACHED_SUCCESS
);
5460 memcached_quit(memc
);
5461 instance_one
->port
= 0;
5462 instance_two
->port
= 0;
5464 /* now retry the command, this time we should have cache misses */
5465 rc
= memcached_mget(memc
, (const char* const *)keys
, key_length
, max_keys
);
5466 test_true(rc
== MEMCACHED_SUCCESS
);
5469 rc
= memcached_fetch_execute(memc
, callbacks
, (void *)&counter
, 1);
5470 test_true(counter
== (unsigned int)(max_keys
>> 1));
5472 /* Release allocated resources */
5473 for (size_t x
= 0; x
< max_keys
; ++x
)
5480 /* restore the memc handle */
5481 instance_one
->port
= port0
;
5482 instance_two
->port
= port2
;
5484 return TEST_SUCCESS
;
5487 static test_return_t
regression_bug_463297(memcached_st
*memc
)
5489 memcached_st
*memc_clone
= memcached_clone(NULL
, memc
);
5490 test_true(memc_clone
!= NULL
);
5491 test_true(memcached_version(memc_clone
) == MEMCACHED_SUCCESS
);
5493 memcached_server_instance_st
*instance
=
5494 memcached_server_instance_fetch(memc_clone
, 0);
5496 if (instance
->major_version
> 1 ||
5497 (instance
->major_version
== 1 &&
5498 instance
->minor_version
> 2))
5500 /* Binary protocol doesn't support deferred delete */
5501 memcached_st
*bin_clone
= memcached_clone(NULL
, memc
);
5502 test_true(bin_clone
!= NULL
);
5503 test_true(memcached_behavior_set(bin_clone
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
, 1) == MEMCACHED_SUCCESS
);
5504 test_true(memcached_delete(bin_clone
, "foo", 3, 1) == MEMCACHED_INVALID_ARGUMENTS
);
5505 memcached_free(bin_clone
);
5507 memcached_quit(memc_clone
);
5509 /* If we know the server version, deferred delete should fail
5510 * with invalid arguments */
5511 test_true(memcached_delete(memc_clone
, "foo", 3, 1) == MEMCACHED_INVALID_ARGUMENTS
);
5513 /* If we don't know the server version, we should get a protocol error */
5514 memcached_return_t rc
= memcached_delete(memc
, "foo", 3, 1);
5516 /* but there is a bug in some of the memcached servers (1.4) that treats
5517 * the counter as noreply so it doesn't send the proper error message
5519 test_true(rc
== MEMCACHED_PROTOCOL_ERROR
|| rc
== MEMCACHED_NOTFOUND
|| rc
== MEMCACHED_CLIENT_ERROR
);
5521 /* And buffered mode should be disabled and we should get protocol error */
5522 test_true(memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_BUFFER_REQUESTS
, 1) == MEMCACHED_SUCCESS
);
5523 rc
= memcached_delete(memc
, "foo", 3, 1);
5524 test_true(rc
== MEMCACHED_PROTOCOL_ERROR
|| rc
== MEMCACHED_NOTFOUND
|| rc
== MEMCACHED_CLIENT_ERROR
);
5526 /* Same goes for noreply... */
5527 test_true(memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NOREPLY
, 1) == MEMCACHED_SUCCESS
);
5528 rc
= memcached_delete(memc
, "foo", 3, 1);
5529 test_true(rc
== MEMCACHED_PROTOCOL_ERROR
|| rc
== MEMCACHED_NOTFOUND
|| rc
== MEMCACHED_CLIENT_ERROR
);
5531 /* but a normal request should go through (and be buffered) */
5532 test_true((rc
= memcached_delete(memc
, "foo", 3, 0)) == MEMCACHED_BUFFERED
);
5533 test_true(memcached_flush_buffers(memc
) == MEMCACHED_SUCCESS
);
5535 test_true(memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_BUFFER_REQUESTS
, 0) == MEMCACHED_SUCCESS
);
5536 /* unbuffered noreply should be success */
5537 test_true(memcached_delete(memc
, "foo", 3, 0) == MEMCACHED_SUCCESS
);
5538 /* unbuffered with reply should be not found... */
5539 test_true(memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NOREPLY
, 0) == MEMCACHED_SUCCESS
);
5540 test_true(memcached_delete(memc
, "foo", 3, 0) == MEMCACHED_NOTFOUND
);
5543 memcached_free(memc_clone
);
5544 return TEST_SUCCESS
;
5548 /* Test memcached_server_get_last_disconnect
5549 * For a working server set, shall be NULL
5550 * For a set of non existing server, shall not be NULL
5552 static test_return_t
test_get_last_disconnect(memcached_st
*memc
)
5554 memcached_return_t rc
;
5555 memcached_server_st
*disconnected_server
;
5557 /* With the working set of server */
5558 const char *key
= "marmotte";
5559 const char *value
= "milka";
5561 rc
= memcached_set(memc
, key
, strlen(key
),
5562 value
, strlen(value
),
5563 (time_t)0, (uint32_t)0);
5564 test_true(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
);
5566 disconnected_server
= memcached_server_get_last_disconnect(memc
);
5567 test_true(disconnected_server
== NULL
);
5569 /* With a non existing server */
5571 memcached_server_st
*servers
;
5573 const char *server_list
= "localhost:9";
5575 servers
= memcached_servers_parse(server_list
);
5577 mine
= memcached_create(NULL
);
5578 rc
= memcached_server_push(mine
, servers
);
5579 test_true(rc
== MEMCACHED_SUCCESS
);
5580 memcached_server_list_free(servers
);
5583 rc
= memcached_set(mine
, key
, strlen(key
),
5584 value
, strlen(value
),
5585 (time_t)0, (uint32_t)0);
5586 test_true(rc
!= MEMCACHED_SUCCESS
);
5588 disconnected_server
= memcached_server_get_last_disconnect(mine
);
5589 test_true(disconnected_server
!= NULL
);
5590 test_true(disconnected_server
->port
== 9);
5591 test_true(strncmp(disconnected_server
->hostname
,"localhost",9) == 0);
5593 memcached_quit(mine
);
5594 memcached_free(mine
);
5596 return TEST_SUCCESS
;
5600 * This test ensures that the failure counter isn't incremented during
5601 * normal termination of the memcached instance.
5603 static test_return_t
wrong_failure_counter_test(memcached_st
*memc
)
5605 memcached_return_t rc
;
5606 memcached_server_instance_st
*instance
;
5608 /* Set value to force connection to the server */
5609 const char *key
= "marmotte";
5610 const char *value
= "milka";
5613 * Please note that I'm abusing the internal structures in libmemcached
5614 * in a non-portable way and you shouldn't be doing this. I'm only
5615 * doing this in order to verify that the library works the way it should
5617 uint32_t number_of_hosts
= memcached_server_count(memc
);
5618 memc
->number_of_hosts
= 1;
5620 /* Ensure that we are connected to the server by setting a value */
5621 rc
= memcached_set(memc
, key
, strlen(key
),
5622 value
, strlen(value
),
5623 (time_t)0, (uint32_t)0);
5624 test_true(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
);
5627 instance
= memcached_server_instance_fetch(memc
, 0);
5628 /* The test is to see that the memcached_quit doesn't increase the
5629 * the server failure conter, so let's ensure that it is zero
5630 * before sending quit
5632 instance
->server_failure_counter
= 0;
5634 memcached_quit(memc
);
5636 /* Verify that it memcached_quit didn't increment the failure counter
5637 * Please note that this isn't bullet proof, because an error could
5640 test_true(instance
->server_failure_counter
== 0);
5642 /* restore the instance */
5643 memc
->number_of_hosts
= number_of_hosts
;
5645 return TEST_SUCCESS
;
5652 * Test that ensures mget_execute does not end into recursive calls that finally fails
5654 static test_return_t
regression_bug_490486(memcached_st
*memc
)
5656 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
, 1);
5657 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NO_BLOCK
, 1);
5658 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_POLL_TIMEOUT
, 1000);
5659 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_SERVER_FAILURE_LIMIT
, 1);
5660 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_RETRY_TIMEOUT
, 3600);
5663 * I only want to hit _one_ server so I know the number of requests I'm
5664 * sending in the pipeline.
5666 uint32_t number_of_hosts
= memc
->number_of_hosts
;
5667 memc
->number_of_hosts
= 1;
5668 size_t max_keys
= 20480;
5671 char **keys
= calloc(max_keys
, sizeof(char*));
5672 size_t *key_length
=calloc(max_keys
, sizeof(size_t));
5674 /* First add all of the items.. */
5675 char blob
[1024]= { 0 };
5676 memcached_return rc
;
5677 for (size_t x
= 0; x
< max_keys
; ++x
)
5680 key_length
[x
]= (size_t)snprintf(k
, sizeof(k
), "0200%zu", x
);
5682 assert(keys
[x
] != NULL
);
5683 rc
= memcached_set(memc
, keys
[x
], key_length
[x
], blob
, sizeof(blob
), 0, 0);
5684 assert(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
);
5687 /* Try to get all of them with a large multiget */
5689 memcached_execute_function callbacks
[1]= { [0]= &callback_counter
};
5690 rc
= memcached_mget_execute(memc
, (const char**)keys
, key_length
,
5691 (size_t)max_keys
, callbacks
, &counter
, 1);
5693 assert(rc
== MEMCACHED_SUCCESS
);
5694 char* the_value
= NULL
;
5695 char the_key
[MEMCACHED_MAX_KEY
];
5696 size_t the_key_length
;
5697 size_t the_value_length
;
5701 the_value
= memcached_fetch(memc
, the_key
, &the_key_length
, &the_value_length
, &the_flags
, &rc
);
5703 if ((the_value
!= NULL
) && (rc
== MEMCACHED_SUCCESS
))
5709 } while ( (the_value
!= NULL
) && (rc
== MEMCACHED_SUCCESS
));
5712 assert(rc
== MEMCACHED_END
);
5714 /* Verify that we got all of the items */
5715 assert(counter
== max_keys
);
5717 /* Release all allocated resources */
5718 for (size_t x
= 0; x
< max_keys
; ++x
)
5725 memc
->number_of_hosts
= number_of_hosts
;
5727 return TEST_SUCCESS
;
5733 test_st udp_setup_server_tests
[] ={
5734 {"set_udp_behavior_test", 0, (test_callback_fn
)set_udp_behavior_test
},
5735 {"add_tcp_server_udp_client_test", 0, (test_callback_fn
)add_tcp_server_udp_client_test
},
5736 {"add_udp_server_tcp_client_test", 0, (test_callback_fn
)add_udp_server_tcp_client_test
},
5740 test_st upd_io_tests
[] ={
5741 {"udp_set_test", 0, (test_callback_fn
)udp_set_test
},
5742 {"udp_buffered_set_test", 0, (test_callback_fn
)udp_buffered_set_test
},
5743 {"udp_set_too_big_test", 0, (test_callback_fn
)udp_set_too_big_test
},
5744 {"udp_delete_test", 0, (test_callback_fn
)udp_delete_test
},
5745 {"udp_buffered_delete_test", 0, (test_callback_fn
)udp_buffered_delete_test
},
5746 {"udp_verbosity_test", 0, (test_callback_fn
)udp_verbosity_test
},
5747 {"udp_quit_test", 0, (test_callback_fn
)udp_quit_test
},
5748 {"udp_flush_test", 0, (test_callback_fn
)udp_flush_test
},
5749 {"udp_incr_test", 0, (test_callback_fn
)udp_incr_test
},
5750 {"udp_decr_test", 0, (test_callback_fn
)udp_decr_test
},
5751 {"udp_stat_test", 0, (test_callback_fn
)udp_stat_test
},
5752 {"udp_version_test", 0, (test_callback_fn
)udp_version_test
},
5753 {"udp_get_test", 0, (test_callback_fn
)udp_get_test
},
5754 {"udp_mixed_io_test", 0, (test_callback_fn
)udp_mixed_io_test
},
5758 /* Clean the server before beginning testing */
5760 {"flush", 0, (test_callback_fn
)flush_test
},
5761 {"init", 0, (test_callback_fn
)init_test
},
5762 {"allocation", 0, (test_callback_fn
)allocation_test
},
5763 {"server_list_null_test", 0, (test_callback_fn
)server_list_null_test
},
5764 {"server_unsort", 0, (test_callback_fn
)server_unsort_test
},
5765 {"server_sort", 0, (test_callback_fn
)server_sort_test
},
5766 {"server_sort2", 0, (test_callback_fn
)server_sort2_test
},
5767 {"clone_test", 0, (test_callback_fn
)clone_test
},
5768 {"connection_test", 0, (test_callback_fn
)connection_test
},
5769 {"callback_test", 0, (test_callback_fn
)callback_test
},
5770 {"userdata_test", 0, (test_callback_fn
)userdata_test
},
5771 {"error", 0, (test_callback_fn
)error_test
},
5772 {"set", 0, (test_callback_fn
)set_test
},
5773 {"set2", 0, (test_callback_fn
)set_test2
},
5774 {"set3", 0, (test_callback_fn
)set_test3
},
5775 {"dump", 1, (test_callback_fn
)dump_test
},
5776 {"add", 1, (test_callback_fn
)add_test
},
5777 {"replace", 1, (test_callback_fn
)replace_test
},
5778 {"delete", 1, (test_callback_fn
)delete_test
},
5779 {"get", 1, (test_callback_fn
)get_test
},
5780 {"get2", 0, (test_callback_fn
)get_test2
},
5781 {"get3", 0, (test_callback_fn
)get_test3
},
5782 {"get4", 0, (test_callback_fn
)get_test4
},
5783 {"partial mget", 0, (test_callback_fn
)get_test5
},
5784 {"stats_servername", 0, (test_callback_fn
)stats_servername_test
},
5785 {"increment", 0, (test_callback_fn
)increment_test
},
5786 {"increment_with_initial", 1, (test_callback_fn
)increment_with_initial_test
},
5787 {"decrement", 0, (test_callback_fn
)decrement_test
},
5788 {"decrement_with_initial", 1, (test_callback_fn
)decrement_with_initial_test
},
5789 {"increment_by_key", 0, (test_callback_fn
)increment_by_key_test
},
5790 {"increment_with_initial_by_key", 1, (test_callback_fn
)increment_with_initial_by_key_test
},
5791 {"decrement_by_key", 0, (test_callback_fn
)decrement_by_key_test
},
5792 {"decrement_with_initial_by_key", 1, (test_callback_fn
)decrement_with_initial_by_key_test
},
5793 {"quit", 0, (test_callback_fn
)quit_test
},
5794 {"mget", 1, (test_callback_fn
)mget_test
},
5795 {"mget_result", 1, (test_callback_fn
)mget_result_test
},
5796 {"mget_result_alloc", 1, (test_callback_fn
)mget_result_alloc_test
},
5797 {"mget_result_function", 1, (test_callback_fn
)mget_result_function
},
5798 {"mget_execute", 1, (test_callback_fn
)mget_execute
},
5799 {"mget_end", 0, (test_callback_fn
)mget_end
},
5800 {"get_stats", 0, (test_callback_fn
)get_stats
},
5801 {"add_host_test", 0, (test_callback_fn
)add_host_test
},
5802 {"add_host_test_1", 0, (test_callback_fn
)add_host_test1
},
5803 {"get_stats_keys", 0, (test_callback_fn
)get_stats_keys
},
5804 {"version_string_test", 0, (test_callback_fn
)version_string_test
},
5805 {"bad_key", 1, (test_callback_fn
)bad_key_test
},
5806 {"memcached_server_cursor", 1, (test_callback_fn
)memcached_server_cursor_test
},
5807 {"read_through", 1, (test_callback_fn
)read_through
},
5808 {"delete_through", 1, (test_callback_fn
)delete_through
},
5809 {"noreply", 1, (test_callback_fn
)noreply_test
},
5810 {"analyzer", 1, (test_callback_fn
)analyzer_test
},
5811 #ifdef HAVE_LIBMEMCACHEDUTIL
5812 {"connectionpool", 1, (test_callback_fn
)connection_pool_test
},
5814 {"test_get_last_disconnect", 1, (test_callback_fn
)test_get_last_disconnect
},
5818 test_st behavior_tests
[] ={
5819 {"behavior_test", 0, (test_callback_fn
)behavior_test
},
5820 {"MEMCACHED_BEHAVIOR_CORK", 0, (test_callback_fn
)MEMCACHED_BEHAVIOR_CORK_test
},
5824 test_st async_tests
[] ={
5825 {"add", 1, (test_callback_fn
)add_wrapper
},
5829 test_st string_tests
[] ={
5830 {"string static with null", 0, (test_callback_fn
)string_static_null
},
5831 {"string alloc with null", 0, (test_callback_fn
)string_alloc_null
},
5832 {"string alloc with 1K", 0, (test_callback_fn
)string_alloc_with_size
},
5833 {"string alloc with malloc failure", 0, (test_callback_fn
)string_alloc_with_size_toobig
},
5834 {"string append", 0, (test_callback_fn
)string_alloc_append
},
5835 {"string append failure (too big)", 0, (test_callback_fn
)string_alloc_append_toobig
},
5836 {0, 0, (test_callback_fn
)0}
5839 test_st result_tests
[] ={
5840 {"result static", 0, (test_callback_fn
)result_static
},
5841 {"result alloc", 0, (test_callback_fn
)result_alloc
},
5842 {0, 0, (test_callback_fn
)0}
5845 test_st version_1_2_3
[] ={
5846 {"append", 0, (test_callback_fn
)append_test
},
5847 {"prepend", 0, (test_callback_fn
)prepend_test
},
5848 {"cas", 0, (test_callback_fn
)cas_test
},
5849 {"cas2", 0, (test_callback_fn
)cas2_test
},
5850 {"append_binary", 0, (test_callback_fn
)append_binary_test
},
5851 {0, 0, (test_callback_fn
)0}
5854 test_st user_tests
[] ={
5855 {"user_supplied_bug1", 0, (test_callback_fn
)user_supplied_bug1
},
5856 {"user_supplied_bug2", 0, (test_callback_fn
)user_supplied_bug2
},
5857 {"user_supplied_bug3", 0, (test_callback_fn
)user_supplied_bug3
},
5858 {"user_supplied_bug4", 0, (test_callback_fn
)user_supplied_bug4
},
5859 {"user_supplied_bug5", 1, (test_callback_fn
)user_supplied_bug5
},
5860 {"user_supplied_bug6", 1, (test_callback_fn
)user_supplied_bug6
},
5861 {"user_supplied_bug7", 1, (test_callback_fn
)user_supplied_bug7
},
5862 {"user_supplied_bug8", 1, (test_callback_fn
)user_supplied_bug8
},
5863 {"user_supplied_bug9", 1, (test_callback_fn
)user_supplied_bug9
},
5864 {"user_supplied_bug10", 1, (test_callback_fn
)user_supplied_bug10
},
5865 {"user_supplied_bug11", 1, (test_callback_fn
)user_supplied_bug11
},
5866 {"user_supplied_bug12", 1, (test_callback_fn
)user_supplied_bug12
},
5867 {"user_supplied_bug13", 1, (test_callback_fn
)user_supplied_bug13
},
5868 {"user_supplied_bug14", 1, (test_callback_fn
)user_supplied_bug14
},
5869 {"user_supplied_bug15", 1, (test_callback_fn
)user_supplied_bug15
},
5870 {"user_supplied_bug16", 1, (test_callback_fn
)user_supplied_bug16
},
5873 ** It seems to be something weird with the character sets..
5874 ** value_fetch is unable to parse the value line (iscntrl "fails"), so I
5875 ** guess I need to find out how this is supposed to work.. Perhaps I need
5876 ** to run the test in a specific locale (I tried zh_CN.UTF-8 without success,
5877 ** so just disable the code for now...).
5879 {"user_supplied_bug17", 1, (test_callback_fn
)user_supplied_bug17
},
5881 {"user_supplied_bug18", 1, (test_callback_fn
)user_supplied_bug18
},
5882 {"user_supplied_bug19", 1, (test_callback_fn
)user_supplied_bug19
},
5883 {"user_supplied_bug20", 1, (test_callback_fn
)user_supplied_bug20
},
5884 {"user_supplied_bug21", 1, (test_callback_fn
)user_supplied_bug21
},
5885 {"wrong_failure_counter_test", 1, (test_callback_fn
)wrong_failure_counter_test
},
5886 {0, 0, (test_callback_fn
)0}
5889 test_st replication_tests
[]= {
5890 {"set", 1, (test_callback_fn
)replication_set_test
},
5891 {"get", 0, (test_callback_fn
)replication_get_test
},
5892 {"mget", 0, (test_callback_fn
)replication_mget_test
},
5893 {"delete", 0, (test_callback_fn
)replication_delete_test
},
5894 {"rand_mget", 0, (test_callback_fn
)replication_randomize_mget_test
},
5895 {0, 0, (test_callback_fn
)0}
5899 * The following test suite is used to verify that we don't introduce
5900 * regression bugs. If you want more information about the bug / test,
5901 * you should look in the bug report at
5902 * http://bugs.launchpad.net/libmemcached
5904 test_st regression_tests
[]= {
5905 {"lp:434484", 1, (test_callback_fn
)regression_bug_434484
},
5906 {"lp:434843", 1, (test_callback_fn
)regression_bug_434843
},
5907 {"lp:434843 buffered", 1, (test_callback_fn
)regression_bug_434843_buffered
},
5908 {"lp:421108", 1, (test_callback_fn
)regression_bug_421108
},
5909 {"lp:442914", 1, (test_callback_fn
)regression_bug_442914
},
5910 {"lp:447342", 1, (test_callback_fn
)regression_bug_447342
},
5911 {"lp:463297", 1, (test_callback_fn
)regression_bug_463297
},
5912 {"lp:490486", 1, (test_callback_fn
)regression_bug_490486
},
5913 {0, 0, (test_callback_fn
)0}
5916 test_st ketama_compatibility
[]= {
5917 {"libmemcached", 1, (test_callback_fn
)ketama_compatibility_libmemcached
},
5918 {"spymemcached", 1, (test_callback_fn
)ketama_compatibility_spymemcached
},
5919 {0, 0, (test_callback_fn
)0}
5922 test_st generate_tests
[] ={
5923 {"generate_pairs", 1, (test_callback_fn
)generate_pairs
},
5924 {"generate_data", 1, (test_callback_fn
)generate_data
},
5925 {"get_read", 0, (test_callback_fn
)get_read
},
5926 {"delete_generate", 0, (test_callback_fn
)delete_generate
},
5927 {"generate_buffer_data", 1, (test_callback_fn
)generate_buffer_data
},
5928 {"delete_buffer", 0, (test_callback_fn
)delete_buffer_generate
},
5929 {"generate_data", 1, (test_callback_fn
)generate_data
},
5930 {"mget_read", 0, (test_callback_fn
)mget_read
},
5931 {"mget_read_result", 0, (test_callback_fn
)mget_read_result
},
5932 {"mget_read_function", 0, (test_callback_fn
)mget_read_function
},
5933 {"cleanup", 1, (test_callback_fn
)cleanup_pairs
},
5934 {"generate_large_pairs", 1, (test_callback_fn
)generate_large_pairs
},
5935 {"generate_data", 1, (test_callback_fn
)generate_data
},
5936 {"generate_buffer_data", 1, (test_callback_fn
)generate_buffer_data
},
5937 {"cleanup", 1, (test_callback_fn
)cleanup_pairs
},
5938 {0, 0, (test_callback_fn
)0}
5941 test_st consistent_tests
[] ={
5942 {"generate_pairs", 1, (test_callback_fn
)generate_pairs
},
5943 {"generate_data", 1, (test_callback_fn
)generate_data
},
5944 {"get_read", 0, (test_callback_fn
)get_read_count
},
5945 {"cleanup", 1, (test_callback_fn
)cleanup_pairs
},
5946 {0, 0, (test_callback_fn
)0}
5949 test_st consistent_weighted_tests
[] ={
5950 {"generate_pairs", 1, (test_callback_fn
)generate_pairs
},
5951 {"generate_data", 1, (test_callback_fn
)generate_data_with_stats
},
5952 {"get_read", 0, (test_callback_fn
)get_read_count
},
5953 {"cleanup", 1, (test_callback_fn
)cleanup_pairs
},
5954 {0, 0, (test_callback_fn
)0}
5957 test_st hsieh_availability
[] ={
5958 {"hsieh_avaibility_test", 0, (test_callback_fn
)hsieh_avaibility_test
},
5959 {0, 0, (test_callback_fn
)0}
5963 test_st hash_sanity
[] ={
5964 {"hash sanity", 0, (test_callback_fn
)hash_sanity_test
},
5965 {0, 0, (test_callback_fn
)0}
5969 test_st ketama_auto_eject_hosts
[] ={
5970 {"auto_eject_hosts", 1, (test_callback_fn
)auto_eject_hosts
},
5971 {"output_ketama_weighted_keys", 1, (test_callback_fn
)output_ketama_weighted_keys
},
5972 {0, 0, (test_callback_fn
)0}
5975 test_st hash_tests
[] ={
5976 {"md5", 0, (test_callback_fn
)md5_run
},
5977 {"crc", 0, (test_callback_fn
)crc_run
},
5978 {"fnv1_64", 0, (test_callback_fn
)fnv1_64_run
},
5979 {"fnv1a_64", 0, (test_callback_fn
)fnv1a_64_run
},
5980 {"fnv1_32", 0, (test_callback_fn
)fnv1_32_run
},
5981 {"fnv1a_32", 0, (test_callback_fn
)fnv1a_32_run
},
5982 {"hsieh", 0, (test_callback_fn
)hsieh_run
},
5983 {"murmur", 0, (test_callback_fn
)murmur_run
},
5984 {"jenkis", 0, (test_callback_fn
)jenkins_run
},
5985 {0, 0, (test_callback_fn
)0}
5988 collection_st collection
[] ={
5990 {"hash_sanity", 0, 0, hash_sanity
},
5992 {"hsieh_availability", 0, 0, hsieh_availability
},
5993 {"udp_setup", (test_callback_fn
)init_udp
, 0, udp_setup_server_tests
},
5994 {"udp_io", (test_callback_fn
)init_udp
, 0, upd_io_tests
},
5995 {"udp_binary_io", (test_callback_fn
)binary_init_udp
, 0, upd_io_tests
},
5996 {"block", 0, 0, tests
},
5997 {"binary", (test_callback_fn
)pre_binary
, 0, tests
},
5998 {"nonblock", (test_callback_fn
)pre_nonblock
, 0, tests
},
5999 {"nodelay", (test_callback_fn
)pre_nodelay
, 0, tests
},
6000 {"settimer", (test_callback_fn
)pre_settimer
, 0, tests
},
6001 {"md5", (test_callback_fn
)pre_md5
, 0, tests
},
6002 {"crc", (test_callback_fn
)pre_crc
, 0, tests
},
6003 {"hsieh", (test_callback_fn
)pre_hsieh
, 0, tests
},
6004 {"jenkins", (test_callback_fn
)pre_jenkins
, 0, tests
},
6005 {"fnv1_64", (test_callback_fn
)pre_hash_fnv1_64
, 0, tests
},
6006 {"fnv1a_64", (test_callback_fn
)pre_hash_fnv1a_64
, 0, tests
},
6007 {"fnv1_32", (test_callback_fn
)pre_hash_fnv1_32
, 0, tests
},
6008 {"fnv1a_32", (test_callback_fn
)pre_hash_fnv1a_32
, 0, tests
},
6009 {"ketama", (test_callback_fn
)pre_behavior_ketama
, 0, tests
},
6010 {"ketama_auto_eject_hosts", (test_callback_fn
)pre_behavior_ketama
, 0, ketama_auto_eject_hosts
},
6011 {"unix_socket", (test_callback_fn
)pre_unix_socket
, 0, tests
},
6012 {"unix_socket_nodelay", (test_callback_fn
)pre_nodelay
, 0, tests
},
6013 {"poll_timeout", (test_callback_fn
)poll_timeout
, 0, tests
},
6014 {"gets", (test_callback_fn
)enable_cas
, 0, tests
},
6015 {"consistent_crc", (test_callback_fn
)enable_consistent_crc
, 0, tests
},
6016 {"consistent_hsieh", (test_callback_fn
)enable_consistent_hsieh
, 0, tests
},
6017 #ifdef MEMCACHED_ENABLE_DEPRECATED
6018 {"deprecated_memory_allocators", (test_callback_fn
)deprecated_set_memory_alloc
, 0, tests
},
6020 {"memory_allocators", (test_callback_fn
)set_memory_alloc
, 0, tests
},
6021 {"prefix", (test_callback_fn
)set_prefix
, 0, tests
},
6022 {"version_1_2_3", (test_callback_fn
)check_for_1_2_3
, 0, version_1_2_3
},
6023 {"string", 0, 0, string_tests
},
6024 {"result", 0, 0, result_tests
},
6025 {"async", (test_callback_fn
)pre_nonblock
, 0, async_tests
},
6026 {"async_binary", (test_callback_fn
)pre_nonblock_binary
, 0, async_tests
},
6027 {"user", 0, 0, user_tests
},
6028 {"generate", 0, 0, generate_tests
},
6029 {"generate_hsieh", (test_callback_fn
)pre_hsieh
, 0, generate_tests
},
6030 {"generate_ketama", (test_callback_fn
)pre_behavior_ketama
, 0, generate_tests
},
6031 {"generate_hsieh_consistent", (test_callback_fn
)enable_consistent_hsieh
, 0, generate_tests
},
6032 {"generate_md5", (test_callback_fn
)pre_md5
, 0, generate_tests
},
6033 {"generate_murmur", (test_callback_fn
)pre_murmur
, 0, generate_tests
},
6034 {"generate_jenkins", (test_callback_fn
)pre_jenkins
, 0, generate_tests
},
6035 {"generate_nonblock", (test_callback_fn
)pre_nonblock
, 0, generate_tests
},
6037 {"generate_corked", (test_callback_fn
)pre_cork
, 0, generate_tests
},
6038 {"generate_corked_and_nonblock", (test_callback_fn
)pre_cork_and_nonblock
, 0, generate_tests
},
6039 {"consistent_not", 0, 0, consistent_tests
},
6040 {"consistent_ketama", (test_callback_fn
)pre_behavior_ketama
, 0, consistent_tests
},
6041 {"consistent_ketama_weighted", (test_callback_fn
)pre_behavior_ketama_weighted
, 0, consistent_weighted_tests
},
6042 {"ketama_compat", 0, 0, ketama_compatibility
},
6043 {"test_hashes", 0, 0, hash_tests
},
6044 {"replication", (test_callback_fn
)pre_replication
, 0, replication_tests
},
6045 {"replication_noblock", (test_callback_fn
)pre_replication_noblock
, 0, replication_tests
},
6046 {"regression", 0, 0, regression_tests
},
6047 {"behaviors", 0, 0, behavior_tests
},
6051 #define SERVERS_TO_CREATE 5
6053 #include "libmemcached_world.h"
6055 void get_world(world_st
*world
)
6057 world
->collections
= collection
;
6059 world
->create
= (test_callback_create_fn
)world_create
;
6060 world
->destroy
= (test_callback_fn
)world_destroy
;
6062 world
->test
.startup
= (test_callback_fn
)world_test_startup
;
6063 world
->test
.flush
= (test_callback_fn
)world_flush
;
6064 world
->test
.pre_run
= (test_callback_fn
)world_pre_run
;
6065 world
->test
.post_run
= (test_callback_fn
)world_post_run
;
6066 world
->test
.on_error
= (test_callback_error_fn
)world_on_error
;
6068 world
->collection
.startup
= (test_callback_fn
)world_container_startup
;
6069 world
->collection
.shutdown
= (test_callback_fn
)world_container_shutdown
;
6071 world
->runner
= &defualt_libmemcached_runner
;