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
)
1702 memcached_return_t rc
;
1703 memcached_stat_st
*memc_stat
;
1705 memc_stat
= memcached_stat(memc
, NULL
, &rc
);
1706 test_true(rc
== MEMCACHED_SUCCESS
);
1708 test_true(rc
== MEMCACHED_SUCCESS
);
1709 test_true(memc_stat
);
1711 for (x
= 0; x
< memcached_server_count(memc
); x
++)
1713 stat_list
= memcached_stat_get_keys(memc
, memc_stat
+x
, &rc
);
1714 test_true(rc
== MEMCACHED_SUCCESS
);
1715 for (ptr
= stat_list
; *ptr
; ptr
++);
1720 memcached_stat_free(NULL
, memc_stat
);
1722 return TEST_SUCCESS
;
1725 static test_return_t
add_host_test(memcached_st
*memc
)
1728 memcached_server_st
*servers
;
1729 memcached_return_t rc
;
1730 char servername
[]= "0.example.com";
1732 servers
= memcached_server_list_append_with_weight(NULL
, servername
, 400, 0, &rc
);
1734 test_true(1 == memcached_server_list_count(servers
));
1736 for (x
= 2; x
< 20; x
++)
1738 char buffer
[SMALL_STRING_LEN
];
1740 snprintf(buffer
, SMALL_STRING_LEN
, "%u.example.com", 400+x
);
1741 servers
= memcached_server_list_append_with_weight(servers
, buffer
, 401, 0,
1743 test_true(rc
== MEMCACHED_SUCCESS
);
1744 test_true(x
== memcached_server_list_count(servers
));
1747 rc
= memcached_server_push(memc
, servers
);
1748 test_true(rc
== MEMCACHED_SUCCESS
);
1749 rc
= memcached_server_push(memc
, servers
);
1750 test_true(rc
== MEMCACHED_SUCCESS
);
1752 memcached_server_list_free(servers
);
1754 return TEST_SUCCESS
;
1757 static memcached_return_t
clone_test_callback(memcached_st
*parent
__attribute__((unused
)), memcached_st
*memc_clone
__attribute__((unused
)))
1759 return MEMCACHED_SUCCESS
;
1762 static memcached_return_t
cleanup_test_callback(memcached_st
*ptr
__attribute__((unused
)))
1764 return MEMCACHED_SUCCESS
;
1767 static test_return_t
callback_test(memcached_st
*memc
)
1769 /* Test User Data */
1773 memcached_return_t rc
;
1775 rc
= memcached_callback_set(memc
, MEMCACHED_CALLBACK_USER_DATA
, &x
);
1776 test_true(rc
== MEMCACHED_SUCCESS
);
1777 test_ptr
= (int *)memcached_callback_get(memc
, MEMCACHED_CALLBACK_USER_DATA
, &rc
);
1778 test_true(*test_ptr
== x
);
1781 /* Test Clone Callback */
1783 memcached_clone_fn clone_cb
= (memcached_clone_fn
)clone_test_callback
;
1784 void *clone_cb_ptr
= *(void **)&clone_cb
;
1785 void *temp_function
= NULL
;
1786 memcached_return_t rc
;
1788 rc
= memcached_callback_set(memc
, MEMCACHED_CALLBACK_CLONE_FUNCTION
,
1790 test_true(rc
== MEMCACHED_SUCCESS
);
1791 temp_function
= memcached_callback_get(memc
, MEMCACHED_CALLBACK_CLONE_FUNCTION
, &rc
);
1792 test_true(temp_function
== clone_cb_ptr
);
1795 /* Test Cleanup Callback */
1797 memcached_cleanup_fn cleanup_cb
=
1798 (memcached_cleanup_fn
)cleanup_test_callback
;
1799 void *cleanup_cb_ptr
= *(void **)&cleanup_cb
;
1800 void *temp_function
= NULL
;
1801 memcached_return_t rc
;
1803 rc
= memcached_callback_set(memc
, MEMCACHED_CALLBACK_CLONE_FUNCTION
,
1805 test_true(rc
== MEMCACHED_SUCCESS
);
1806 temp_function
= memcached_callback_get(memc
, MEMCACHED_CALLBACK_CLONE_FUNCTION
, &rc
);
1807 test_true(temp_function
== cleanup_cb_ptr
);
1810 return TEST_SUCCESS
;
1813 /* We don't test the behavior itself, we test the switches */
1814 static test_return_t
behavior_test(memcached_st
*memc
)
1819 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NO_BLOCK
, set
);
1820 value
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_NO_BLOCK
);
1821 test_true(value
== 1);
1823 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_TCP_NODELAY
, set
);
1824 value
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_TCP_NODELAY
);
1825 test_true(value
== 1);
1827 set
= MEMCACHED_HASH_MD5
;
1828 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_HASH
, set
);
1829 value
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_HASH
);
1830 test_true(value
== MEMCACHED_HASH_MD5
);
1834 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NO_BLOCK
, set
);
1835 value
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_NO_BLOCK
);
1836 test_true(value
== 0);
1838 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_TCP_NODELAY
, set
);
1839 value
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_TCP_NODELAY
);
1840 test_true(value
== 0);
1842 set
= MEMCACHED_HASH_DEFAULT
;
1843 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_HASH
, set
);
1844 value
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_HASH
);
1845 test_true(value
== MEMCACHED_HASH_DEFAULT
);
1847 set
= MEMCACHED_HASH_CRC
;
1848 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_HASH
, set
);
1849 value
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_HASH
);
1850 test_true(value
== MEMCACHED_HASH_CRC
);
1852 value
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_SOCKET_SEND_SIZE
);
1853 test_true(value
> 0);
1855 value
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_SOCKET_RECV_SIZE
);
1856 test_true(value
> 0);
1858 value
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_NUMBER_OF_REPLICAS
);
1859 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NUMBER_OF_REPLICAS
, value
+ 1);
1860 test_true((value
+ 1) == memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_NUMBER_OF_REPLICAS
));
1862 return TEST_SUCCESS
;
1865 static test_return_t
MEMCACHED_BEHAVIOR_CORK_test(memcached_st
*memc
)
1867 memcached_return_t rc
;
1871 rc
= memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_CORK
, set
);
1872 test_true(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_NOT_SUPPORTED
);
1874 value
= (bool)memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_CORK
);
1876 if (rc
== MEMCACHED_SUCCESS
)
1878 test_true((bool)value
== set
);
1882 test_false((bool)value
== set
);
1885 return TEST_SUCCESS
;
1888 static test_return_t
fetch_all_results(memcached_st
*memc
)
1890 memcached_return_t rc
= MEMCACHED_SUCCESS
;
1891 char return_key
[MEMCACHED_MAX_KEY
];
1892 size_t return_key_length
;
1894 size_t return_value_length
;
1897 while ((return_value
= memcached_fetch(memc
, return_key
, &return_key_length
,
1898 &return_value_length
, &flags
, &rc
)))
1900 test_true(return_value
);
1901 test_true(rc
== MEMCACHED_SUCCESS
);
1905 return ((rc
== MEMCACHED_END
) || (rc
== MEMCACHED_SUCCESS
)) ? TEST_SUCCESS
: TEST_FAILURE
;
1908 /* Test case provided by Cal Haldenbrand */
1909 static test_return_t
user_supplied_bug1(memcached_st
*memc
)
1911 unsigned int setter
= 1;
1913 unsigned long long total
= 0;
1916 char randomstuff
[6 * 1024];
1917 memcached_return_t rc
;
1919 memset(randomstuff
, 0, 6 * 1024);
1921 /* We just keep looking at the same values over and over */
1924 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NO_BLOCK
, setter
);
1925 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_TCP_NODELAY
, setter
);
1929 for (uint32_t x
= 0 ; total
< 20 * 1024576 ; x
++ )
1933 size
= (uint32_t)(rand() % ( 5 * 1024 ) ) + 400;
1934 memset(randomstuff
, 0, 6 * 1024);
1935 test_true(size
< 6 * 1024); /* Being safe here */
1937 for (j
= 0 ; j
< size
;j
++)
1938 randomstuff
[j
] = (signed char) ((rand() % 26) + 97);
1941 snprintf(key
, sizeof(key
), "%u", x
);
1942 rc
= memcached_set(memc
, key
, strlen(key
),
1943 randomstuff
, strlen(randomstuff
), 10, 0);
1944 test_true(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
);
1945 /* If we fail, lets try again */
1946 if (rc
!= MEMCACHED_SUCCESS
&& rc
!= MEMCACHED_BUFFERED
)
1947 rc
= memcached_set(memc
, key
, strlen(key
),
1948 randomstuff
, strlen(randomstuff
), 10, 0);
1949 test_true(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
);
1952 return TEST_SUCCESS
;
1955 /* Test case provided by Cal Haldenbrand */
1956 static test_return_t
user_supplied_bug2(memcached_st
*memc
)
1958 unsigned int setter
;
1962 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NO_BLOCK
, setter
);
1963 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_TCP_NODELAY
, setter
);
1965 setter
= 20 * 1024576;
1966 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_SOCKET_SEND_SIZE
, setter
);
1967 setter
= 20 * 1024576;
1968 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_SOCKET_RECV_SIZE
, setter
);
1969 getter
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_SOCKET_SEND_SIZE
);
1970 getter
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_SOCKET_RECV_SIZE
);
1972 for (x
= 0, errors
= 0; total
< 20 * 1024576 ; x
++)
1975 for (uint32_t x
= 0, errors
= 0; total
< 24576 ; x
++)
1977 memcached_return_t rc
= MEMCACHED_SUCCESS
;
1978 char buffer
[SMALL_STRING_LEN
];
1983 memset(buffer
, 0, SMALL_STRING_LEN
);
1985 snprintf(buffer
, sizeof(buffer
), "%u", x
);
1986 getval
= memcached_get(memc
, buffer
, strlen(buffer
),
1987 &val_len
, &flags
, &rc
);
1988 if (rc
!= MEMCACHED_SUCCESS
)
1990 if (rc
== MEMCACHED_NOTFOUND
)
2004 return TEST_SUCCESS
;
2007 /* Do a large mget() over all the keys we think exist */
2008 #define KEY_COUNT 3000 // * 1024576
2009 static test_return_t
user_supplied_bug3(memcached_st
*memc
)
2011 memcached_return_t rc
;
2012 unsigned int setter
;
2015 size_t key_lengths
[KEY_COUNT
];
2018 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NO_BLOCK
, setter
);
2019 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_TCP_NODELAY
, setter
);
2021 setter
= 20 * 1024576;
2022 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_SOCKET_SEND_SIZE
, setter
);
2023 setter
= 20 * 1024576;
2024 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_SOCKET_RECV_SIZE
, setter
);
2025 getter
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_SOCKET_SEND_SIZE
);
2026 getter
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_SOCKET_RECV_SIZE
);
2029 keys
= calloc(KEY_COUNT
, sizeof(char *));
2031 for (x
= 0; x
< KEY_COUNT
; x
++)
2035 snprintf(buffer
, 30, "%u", x
);
2036 keys
[x
]= strdup(buffer
);
2037 key_lengths
[x
]= strlen(keys
[x
]);
2040 rc
= memcached_mget(memc
, (const char **)keys
, key_lengths
, KEY_COUNT
);
2041 test_true(rc
== MEMCACHED_SUCCESS
);
2043 test_true(fetch_all_results(memc
) == TEST_SUCCESS
);
2045 for (x
= 0; x
< KEY_COUNT
; x
++)
2049 return TEST_SUCCESS
;
2052 /* Make sure we behave properly if server list has no values */
2053 static test_return_t
user_supplied_bug4(memcached_st
*memc
)
2055 memcached_return_t rc
;
2056 const char *keys
[]= {"fudge", "son", "food"};
2057 size_t key_length
[]= {5, 3, 4};
2060 char return_key
[MEMCACHED_MAX_KEY
];
2061 size_t return_key_length
;
2063 size_t return_value_length
;
2065 /* Here we free everything before running a bunch of mget tests */
2066 memcached_servers_reset(memc
);
2069 /* We need to empty the server before continueing test */
2070 rc
= memcached_flush(memc
, 0);
2071 test_true(rc
== MEMCACHED_NO_SERVERS
);
2073 rc
= memcached_mget(memc
, keys
, key_length
, 3);
2074 test_true(rc
== MEMCACHED_NO_SERVERS
);
2076 while ((return_value
= memcached_fetch(memc
, return_key
, &return_key_length
,
2077 &return_value_length
, &flags
, &rc
)) != NULL
)
2079 test_true(return_value
);
2081 test_true(!return_value
);
2082 test_true(return_value_length
== 0);
2083 test_true(rc
== MEMCACHED_NO_SERVERS
);
2085 for (x
= 0; x
< 3; x
++)
2087 rc
= memcached_set(memc
, keys
[x
], key_length
[x
],
2088 keys
[x
], key_length
[x
],
2089 (time_t)50, (uint32_t)9);
2090 test_true(rc
== MEMCACHED_NO_SERVERS
);
2093 rc
= memcached_mget(memc
, keys
, key_length
, 3);
2094 test_true(rc
== MEMCACHED_NO_SERVERS
);
2097 while ((return_value
= memcached_fetch(memc
, return_key
, &return_key_length
,
2098 &return_value_length
, &flags
, &rc
)))
2100 test_true(return_value
);
2101 test_true(rc
== MEMCACHED_SUCCESS
);
2102 test_true(return_key_length
== return_value_length
);
2103 test_true(!memcmp(return_value
, return_key
, return_value_length
));
2108 return TEST_SUCCESS
;
2111 #define VALUE_SIZE_BUG5 1048064
2112 static test_return_t
user_supplied_bug5(memcached_st
*memc
)
2114 memcached_return_t rc
;
2115 const char *keys
[]= {"036790384900", "036790384902", "036790384904", "036790384906"};
2116 size_t key_length
[]= {strlen("036790384900"), strlen("036790384902"), strlen("036790384904"), strlen("036790384906")};
2117 char return_key
[MEMCACHED_MAX_KEY
];
2118 size_t return_key_length
;
2120 size_t value_length
;
2124 char insert_data
[VALUE_SIZE_BUG5
];
2126 for (x
= 0; x
< VALUE_SIZE_BUG5
; x
++)
2127 insert_data
[x
]= (signed char)rand();
2129 memcached_flush(memc
, 0);
2130 value
= memcached_get(memc
, keys
[0], key_length
[0],
2131 &value_length
, &flags
, &rc
);
2132 test_true(value
== NULL
);
2133 rc
= memcached_mget(memc
, keys
, key_length
, 4);
2136 while ((value
= memcached_fetch(memc
, return_key
, &return_key_length
,
2137 &value_length
, &flags
, &rc
)))
2139 test_true(count
== 0);
2141 for (x
= 0; x
< 4; x
++)
2143 rc
= memcached_set(memc
, keys
[x
], key_length
[x
],
2144 insert_data
, VALUE_SIZE_BUG5
,
2145 (time_t)0, (uint32_t)0);
2146 test_true(rc
== MEMCACHED_SUCCESS
);
2149 for (x
= 0; x
< 10; x
++)
2151 value
= memcached_get(memc
, keys
[0], key_length
[0],
2152 &value_length
, &flags
, &rc
);
2156 rc
= memcached_mget(memc
, keys
, key_length
, 4);
2158 while ((value
= memcached_fetch(memc
, return_key
, &return_key_length
,
2159 &value_length
, &flags
, &rc
)))
2164 test_true(count
== 4);
2167 return TEST_SUCCESS
;
2170 static test_return_t
user_supplied_bug6(memcached_st
*memc
)
2172 memcached_return_t rc
;
2173 const char *keys
[]= {"036790384900", "036790384902", "036790384904", "036790384906"};
2174 size_t key_length
[]= {strlen("036790384900"), strlen("036790384902"), strlen("036790384904"), strlen("036790384906")};
2175 char return_key
[MEMCACHED_MAX_KEY
];
2176 size_t return_key_length
;
2178 size_t value_length
;
2182 char insert_data
[VALUE_SIZE_BUG5
];
2184 for (x
= 0; x
< VALUE_SIZE_BUG5
; x
++)
2185 insert_data
[x
]= (signed char)rand();
2187 memcached_flush(memc
, 0);
2188 value
= memcached_get(memc
, keys
[0], key_length
[0],
2189 &value_length
, &flags
, &rc
);
2190 test_true(value
== NULL
);
2191 test_true(rc
== MEMCACHED_NOTFOUND
);
2192 rc
= memcached_mget(memc
, keys
, key_length
, 4);
2193 test_true(rc
== MEMCACHED_SUCCESS
);
2196 while ((value
= memcached_fetch(memc
, return_key
, &return_key_length
,
2197 &value_length
, &flags
, &rc
)))
2199 test_true(count
== 0);
2200 test_true(rc
== MEMCACHED_END
);
2202 for (x
= 0; x
< 4; x
++)
2204 rc
= memcached_set(memc
, keys
[x
], key_length
[x
],
2205 insert_data
, VALUE_SIZE_BUG5
,
2206 (time_t)0, (uint32_t)0);
2207 test_true(rc
== MEMCACHED_SUCCESS
);
2210 for (x
= 0; x
< 2; x
++)
2212 value
= memcached_get(memc
, keys
[0], key_length
[0],
2213 &value_length
, &flags
, &rc
);
2217 rc
= memcached_mget(memc
, keys
, key_length
, 4);
2218 test_true(rc
== MEMCACHED_SUCCESS
);
2220 /* We test for purge of partial complete fetches */
2221 for (count
= 3; count
; count
--)
2223 value
= memcached_fetch(memc
, return_key
, &return_key_length
,
2224 &value_length
, &flags
, &rc
);
2225 test_true(rc
== MEMCACHED_SUCCESS
);
2226 test_true(!(memcmp(value
, insert_data
, value_length
)));
2227 test_true(value_length
);
2232 return TEST_SUCCESS
;
2235 static test_return_t
user_supplied_bug8(memcached_st
*memc
__attribute__((unused
)))
2237 memcached_return_t rc
;
2239 memcached_st
*memc_clone
;
2241 memcached_server_st
*servers
;
2242 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";
2244 servers
= memcached_servers_parse(server_list
);
2247 mine
= memcached_create(NULL
);
2248 rc
= memcached_server_push(mine
, servers
);
2249 test_true(rc
== MEMCACHED_SUCCESS
);
2250 memcached_server_list_free(servers
);
2253 memc_clone
= memcached_clone(NULL
, mine
);
2255 memcached_quit(mine
);
2256 memcached_quit(memc_clone
);
2259 memcached_free(mine
);
2260 memcached_free(memc_clone
);
2262 return TEST_SUCCESS
;
2265 /* Test flag store/retrieve */
2266 static test_return_t
user_supplied_bug7(memcached_st
*memc
)
2268 memcached_return_t rc
;
2269 const char *keys
= "036790384900";
2270 size_t key_length
= strlen(keys
);
2271 char return_key
[MEMCACHED_MAX_KEY
];
2272 size_t return_key_length
;
2274 size_t value_length
;
2277 char insert_data
[VALUE_SIZE_BUG5
];
2279 for (x
= 0; x
< VALUE_SIZE_BUG5
; x
++)
2280 insert_data
[x
]= (signed char)rand();
2282 memcached_flush(memc
, 0);
2285 rc
= memcached_set(memc
, keys
, key_length
,
2286 insert_data
, VALUE_SIZE_BUG5
,
2288 test_true(rc
== MEMCACHED_SUCCESS
);
2291 value
= memcached_get(memc
, keys
, key_length
,
2292 &value_length
, &flags
, &rc
);
2293 test_true(flags
== 245);
2297 rc
= memcached_mget(memc
, &keys
, &key_length
, 1);
2300 value
= memcached_fetch(memc
, return_key
, &return_key_length
,
2301 &value_length
, &flags
, &rc
);
2302 test_true(flags
== 245);
2307 return TEST_SUCCESS
;
2310 static test_return_t
user_supplied_bug9(memcached_st
*memc
)
2312 memcached_return_t rc
;
2313 const char *keys
[]= {"UDATA:edevil@sapo.pt", "fudge&*@#", "for^#@&$not"};
2314 size_t key_length
[3];
2319 char return_key
[MEMCACHED_MAX_KEY
];
2320 size_t return_key_length
;
2322 size_t return_value_length
;
2325 key_length
[0]= strlen("UDATA:edevil@sapo.pt");
2326 key_length
[1]= strlen("fudge&*@#");
2327 key_length
[2]= strlen("for^#@&$not");
2330 for (x
= 0; x
< 3; x
++)
2332 rc
= memcached_set(memc
, keys
[x
], key_length
[x
],
2333 keys
[x
], key_length
[x
],
2334 (time_t)50, (uint32_t)9);
2335 test_true(rc
== MEMCACHED_SUCCESS
);
2338 rc
= memcached_mget(memc
, keys
, key_length
, 3);
2339 test_true(rc
== MEMCACHED_SUCCESS
);
2341 /* We need to empty the server before continueing test */
2342 while ((return_value
= memcached_fetch(memc
, return_key
, &return_key_length
,
2343 &return_value_length
, &flags
, &rc
)) != NULL
)
2345 test_true(return_value
);
2349 test_true(count
== 3);
2351 return TEST_SUCCESS
;
2354 /* We are testing with aggressive timeout to get failures */
2355 static test_return_t
user_supplied_bug10(memcached_st
*memc
)
2357 const char *key
= "foo";
2359 size_t value_length
= 512;
2362 memcached_return_t rc
;
2363 unsigned int set
= 1;
2364 memcached_st
*mclone
= memcached_clone(NULL
, memc
);
2367 memcached_behavior_set(mclone
, MEMCACHED_BEHAVIOR_NO_BLOCK
, set
);
2368 memcached_behavior_set(mclone
, MEMCACHED_BEHAVIOR_TCP_NODELAY
, set
);
2370 memcached_behavior_set(mclone
, MEMCACHED_BEHAVIOR_POLL_TIMEOUT
,
2373 value
= (char*)malloc(value_length
* sizeof(char));
2375 for (x
= 0; x
< value_length
; x
++)
2376 value
[x
]= (char) (x
% 127);
2378 for (x
= 1; x
<= 100000; ++x
)
2380 rc
= memcached_set(mclone
, key
, key_len
,value
, value_length
, 0, 0);
2382 test_true(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_WRITE_FAILURE
||
2383 rc
== MEMCACHED_BUFFERED
|| rc
== MEMCACHED_TIMEOUT
);
2385 if (rc
== MEMCACHED_WRITE_FAILURE
|| rc
== MEMCACHED_TIMEOUT
)
2390 memcached_free(mclone
);
2392 return TEST_SUCCESS
;
2396 We are looking failures in the async protocol
2398 static test_return_t
user_supplied_bug11(memcached_st
*memc
)
2400 const char *key
= "foo";
2402 size_t value_length
= 512;
2405 memcached_return_t rc
;
2406 unsigned int set
= 1;
2408 memcached_st
*mclone
= memcached_clone(NULL
, memc
);
2410 memcached_behavior_set(mclone
, MEMCACHED_BEHAVIOR_NO_BLOCK
, set
);
2411 memcached_behavior_set(mclone
, MEMCACHED_BEHAVIOR_TCP_NODELAY
, set
);
2413 memcached_behavior_set(mclone
, MEMCACHED_BEHAVIOR_POLL_TIMEOUT
,
2416 timeout
= (int32_t)memcached_behavior_get(mclone
, MEMCACHED_BEHAVIOR_POLL_TIMEOUT
);
2418 test_true(timeout
== -1);
2420 value
= (char*)malloc(value_length
* sizeof(char));
2422 for (x
= 0; x
< value_length
; x
++)
2423 value
[x
]= (char) (x
% 127);
2425 for (x
= 1; x
<= 100000; ++x
)
2427 rc
= memcached_set(mclone
, key
, key_len
,value
, value_length
, 0, 0);
2431 memcached_free(mclone
);
2433 return TEST_SUCCESS
;
2437 Bug found where incr was not returning MEMCACHED_NOTFOUND when object did not exist.
2439 static test_return_t
user_supplied_bug12(memcached_st
*memc
)
2441 memcached_return_t rc
;
2443 size_t value_length
;
2445 uint64_t number_value
;
2447 value
= memcached_get(memc
, "autoincrement", strlen("autoincrement"),
2448 &value_length
, &flags
, &rc
);
2449 test_true(value
== NULL
);
2450 test_true(rc
== MEMCACHED_NOTFOUND
);
2452 rc
= memcached_increment(memc
, "autoincrement", strlen("autoincrement"),
2455 test_true(value
== NULL
);
2456 /* The binary protocol will set the key if it doesn't exist */
2457 if (memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
) == 1)
2459 test_true(rc
== MEMCACHED_SUCCESS
);
2463 test_true(rc
== MEMCACHED_NOTFOUND
);
2466 rc
= memcached_set(memc
, "autoincrement", strlen("autoincrement"), "1", 1, 0, 0);
2468 value
= memcached_get(memc
, "autoincrement", strlen("autoincrement"),
2469 &value_length
, &flags
, &rc
);
2471 test_true(rc
== MEMCACHED_SUCCESS
);
2474 rc
= memcached_increment(memc
, "autoincrement", strlen("autoincrement"),
2476 test_true(number_value
== 2);
2477 test_true(rc
== MEMCACHED_SUCCESS
);
2479 return TEST_SUCCESS
;
2483 Bug found where command total one more than MEMCACHED_MAX_BUFFER
2484 set key34567890 0 0 8169 \r\n is sent followed by buffer of size 8169, followed by 8169
2486 static test_return_t
user_supplied_bug13(memcached_st
*memc
)
2488 char key
[] = "key34567890";
2490 memcached_return_t rc
;
2491 size_t overflowSize
;
2493 char commandFirst
[]= "set key34567890 0 0 ";
2494 char commandLast
[] = " \r\n"; /* first line of command sent to server */
2495 size_t commandLength
;
2498 commandLength
= strlen(commandFirst
) + strlen(commandLast
) + 4; /* 4 is number of characters in size, probably 8196 */
2500 overflowSize
= MEMCACHED_MAX_BUFFER
- commandLength
;
2502 for (testSize
= overflowSize
- 1; testSize
< overflowSize
+ 1; testSize
++)
2504 overflow
= malloc(testSize
);
2505 test_true(overflow
!= NULL
);
2507 memset(overflow
, 'x', testSize
);
2508 rc
= memcached_set(memc
, key
, strlen(key
),
2509 overflow
, testSize
, 0, 0);
2510 test_true(rc
== MEMCACHED_SUCCESS
);
2514 return TEST_SUCCESS
;
2519 Test values of many different sizes
2520 Bug found where command total one more than MEMCACHED_MAX_BUFFER
2521 set key34567890 0 0 8169 \r\n
2522 is sent followed by buffer of size 8169, followed by 8169
2524 static test_return_t
user_supplied_bug14(memcached_st
*memc
)
2527 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_TCP_NODELAY
, setter
);
2528 memcached_return_t rc
;
2529 const char *key
= "foo";
2531 size_t value_length
= 18000;
2533 size_t string_length
;
2536 size_t current_length
;
2538 value
= (char*)malloc(value_length
);
2541 for (x
= 0; x
< value_length
; x
++)
2542 value
[x
] = (char) (x
% 127);
2544 for (current_length
= 0; current_length
< value_length
; current_length
++)
2546 rc
= memcached_set(memc
, key
, strlen(key
),
2547 value
, current_length
,
2548 (time_t)0, (uint32_t)0);
2549 test_true(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
);
2551 string
= memcached_get(memc
, key
, strlen(key
),
2552 &string_length
, &flags
, &rc
);
2554 test_true(rc
== MEMCACHED_SUCCESS
);
2555 test_true(string_length
== current_length
);
2556 test_true(!memcmp(string
, value
, string_length
));
2563 return TEST_SUCCESS
;
2567 Look for zero length value problems
2569 static test_return_t
user_supplied_bug15(memcached_st
*memc
)
2572 memcached_return_t rc
;
2573 const char *key
= "mykey";
2578 for (x
= 0; x
< 2; x
++)
2580 rc
= memcached_set(memc
, key
, strlen(key
),
2582 (time_t)0, (uint32_t)0);
2584 test_true(rc
== MEMCACHED_SUCCESS
);
2586 value
= memcached_get(memc
, key
, strlen(key
),
2587 &length
, &flags
, &rc
);
2589 test_true(rc
== MEMCACHED_SUCCESS
);
2590 test_true(value
== NULL
);
2591 test_true(length
== 0);
2592 test_true(flags
== 0);
2594 value
= memcached_get(memc
, key
, strlen(key
),
2595 &length
, &flags
, &rc
);
2597 test_true(rc
== MEMCACHED_SUCCESS
);
2598 test_true(value
== NULL
);
2599 test_true(length
== 0);
2600 test_true(flags
== 0);
2603 return TEST_SUCCESS
;
2606 /* Check the return sizes on FLAGS to make sure it stores 32bit unsigned values correctly */
2607 static test_return_t
user_supplied_bug16(memcached_st
*memc
)
2609 memcached_return_t rc
;
2610 const char *key
= "mykey";
2615 rc
= memcached_set(memc
, key
, strlen(key
),
2617 (time_t)0, UINT32_MAX
);
2619 test_true(rc
== MEMCACHED_SUCCESS
);
2621 value
= memcached_get(memc
, key
, strlen(key
),
2622 &length
, &flags
, &rc
);
2624 test_true(rc
== MEMCACHED_SUCCESS
);
2625 test_true(value
== NULL
);
2626 test_true(length
== 0);
2627 test_true(flags
== UINT32_MAX
);
2629 return TEST_SUCCESS
;
2633 /* Check the validity of chinese key*/
2634 static test_return_t
user_supplied_bug17(memcached_st
*memc
)
2636 memcached_return_t rc
;
2637 const char *key
= "豆瓣";
2638 const char *value
="我们在炎热抑郁的夏天无法停止豆瓣";
2643 rc
= memcached_set(memc
, key
, strlen(key
),
2644 value
, strlen(value
),
2647 test_true(rc
== MEMCACHED_SUCCESS
);
2649 value2
= memcached_get(memc
, key
, strlen(key
),
2650 &length
, &flags
, &rc
);
2652 test_true(length
==strlen(value
));
2653 test_true(rc
== MEMCACHED_SUCCESS
);
2654 test_true(memcmp(value
, value2
, length
)==0);
2657 return TEST_SUCCESS
;
2665 static test_return_t
user_supplied_bug19(memcached_st
*memc
)
2668 memcached_server_st
*s
;
2669 memcached_return_t res
;
2673 m
= memcached_create(NULL
);
2674 memcached_server_add_with_weight(m
, "localhost", 11311, 100);
2675 memcached_server_add_with_weight(m
, "localhost", 11312, 100);
2677 s
= memcached_server_by_key(m
, "a", 1, &res
);
2678 memcached_server_free(s
);
2682 return TEST_SUCCESS
;
2685 /* CAS test from Andei */
2686 static test_return_t
user_supplied_bug20(memcached_st
*memc
)
2688 memcached_return_t status
;
2689 memcached_result_st
*result
, result_obj
;
2690 const char *key
= "abc";
2691 size_t key_len
= strlen("abc");
2692 const char *value
= "foobar";
2693 size_t value_len
= strlen(value
);
2695 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_SUPPORT_CAS
, 1);
2697 status
= memcached_set(memc
, key
, key_len
, value
, value_len
, (time_t)0, (uint32_t)0);
2698 test_true(status
== MEMCACHED_SUCCESS
);
2700 status
= memcached_mget(memc
, &key
, &key_len
, 1);
2701 test_true(status
== MEMCACHED_SUCCESS
);
2703 result
= memcached_result_create(memc
, &result_obj
);
2706 memcached_result_create(memc
, &result_obj
);
2707 result
= memcached_fetch_result(memc
, &result_obj
, &status
);
2710 test_true(status
== MEMCACHED_SUCCESS
);
2712 memcached_result_free(result
);
2714 return TEST_SUCCESS
;
2717 #include "ketama_test_cases.h"
2718 static test_return_t
user_supplied_bug18(memcached_st
*trash
)
2720 memcached_return_t rc
;
2723 memcached_server_st
*server_pool
;
2728 memc
= memcached_create(NULL
);
2731 rc
= memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_KETAMA_WEIGHTED
, 1);
2732 test_true(rc
== MEMCACHED_SUCCESS
);
2734 value
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_KETAMA_WEIGHTED
);
2735 test_true(value
== 1);
2737 rc
= memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_KETAMA_HASH
, MEMCACHED_HASH_MD5
);
2738 test_true(rc
== MEMCACHED_SUCCESS
);
2740 value
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_KETAMA_HASH
);
2741 test_true(value
== MEMCACHED_HASH_MD5
);
2743 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");
2744 memcached_server_push(memc
, server_pool
);
2746 /* verify that the server list was parsed okay. */
2747 test_true(memcached_server_count(memc
) == 8);
2748 test_true(strcmp(server_pool
[0].hostname
, "10.0.1.1") == 0);
2749 test_true(server_pool
[0].port
== 11211);
2750 test_true(server_pool
[0].weight
== 600);
2751 test_true(strcmp(server_pool
[2].hostname
, "10.0.1.3") == 0);
2752 test_true(server_pool
[2].port
== 11211);
2753 test_true(server_pool
[2].weight
== 200);
2754 test_true(strcmp(server_pool
[7].hostname
, "10.0.1.8") == 0);
2755 test_true(server_pool
[7].port
== 11211);
2756 test_true(server_pool
[7].weight
== 100);
2758 /* VDEAAAAA hashes to fffcd1b5, after the last continuum point, and lets
2759 * us test the boundary wraparound.
2761 test_true(memcached_generate_hash(memc
, (char *)"VDEAAAAA", 8) == memc
->continuum
[0].index
);
2763 /* verify the standard ketama set. */
2764 for (x
= 0; x
< 99; x
++)
2766 uint32_t server_idx
= memcached_generate_hash(memc
, ketama_test_cases
[x
].key
, strlen(ketama_test_cases
[x
].key
));
2767 memcached_server_instance_st
*instance
=
2768 memcached_server_instance_fetch(memc
, server_idx
);
2769 char *hostname
= instance
->hostname
;
2770 test_strcmp(hostname
, ketama_test_cases
[x
].server
);
2773 memcached_server_list_free(server_pool
);
2774 memcached_free(memc
);
2776 return TEST_SUCCESS
;
2779 /* Large mget() of missing keys with binary proto
2781 * If many binary quiet commands (such as getq's in an mget) fill the output
2782 * buffer and the server chooses not to respond, memcached_flush hangs. See
2783 * http://lists.tangent.org/pipermail/libmemcached/2009-August/000918.html
2786 /* sighandler_t function that always asserts false */
2787 static void fail(int unused
__attribute__((unused
)))
2793 static test_return_t
_user_supplied_bug21(memcached_st
* memc
, size_t key_count
)
2795 memcached_return_t rc
;
2798 size_t* key_lengths
;
2799 void (*oldalarm
)(int);
2800 memcached_st
*memc_clone
;
2802 memc_clone
= memcached_clone(NULL
, memc
);
2803 test_true(memc_clone
);
2805 /* only binproto uses getq for mget */
2806 memcached_behavior_set(memc_clone
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
, 1);
2808 /* empty the cache to ensure misses (hence non-responses) */
2809 rc
= memcached_flush(memc_clone
, 0);
2810 test_true(rc
== MEMCACHED_SUCCESS
);
2812 key_lengths
= calloc(key_count
, sizeof(size_t));
2813 keys
= calloc(key_count
, sizeof(char *));
2815 for (x
= 0; x
< key_count
; x
++)
2819 snprintf(buffer
, 30, "%u", x
);
2820 keys
[x
]= strdup(buffer
);
2821 key_lengths
[x
]= strlen(keys
[x
]);
2824 oldalarm
= signal(SIGALRM
, fail
);
2827 rc
= memcached_mget(memc_clone
, (const char **)keys
, key_lengths
, key_count
);
2828 test_true(rc
== MEMCACHED_SUCCESS
);
2831 signal(SIGALRM
, oldalarm
);
2833 test_true(fetch_all_results(memc
) == TEST_SUCCESS
);
2835 for (x
= 0; x
< key_count
; x
++)
2840 memcached_free(memc_clone
);
2842 return TEST_SUCCESS
;
2845 static test_return_t
pre_binary(memcached_st
*memc
);
2847 static test_return_t
user_supplied_bug21(memcached_st
*memc
)
2849 test_return_t test_rc
;
2850 test_rc
= pre_binary(memc
);
2852 if (test_rc
!= TEST_SUCCESS
)
2857 /* should work as of r580 */
2858 rc
= _user_supplied_bug21(memc
, 10);
2859 test_true(rc
== TEST_SUCCESS
);
2861 /* should fail as of r580 */
2862 rc
= _user_supplied_bug21(memc
, 1000);
2863 test_true(rc
== TEST_SUCCESS
);
2865 return TEST_SUCCESS
;
2868 static test_return_t
auto_eject_hosts(memcached_st
*trash
)
2871 memcached_server_instance_st
*instance
;
2873 memcached_return_t rc
;
2874 memcached_st
*memc
= memcached_create(NULL
);
2877 rc
= memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_KETAMA_WEIGHTED
, 1);
2878 test_true(rc
== MEMCACHED_SUCCESS
);
2880 uint64_t value
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_KETAMA_WEIGHTED
);
2881 test_true(value
== 1);
2883 rc
= memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_KETAMA_HASH
, MEMCACHED_HASH_MD5
);
2884 test_true(rc
== MEMCACHED_SUCCESS
);
2886 value
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_KETAMA_HASH
);
2887 test_true(value
== MEMCACHED_HASH_MD5
);
2889 /* server should be removed when in delay */
2890 rc
= memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_AUTO_EJECT_HOSTS
, 1);
2891 test_true(rc
== MEMCACHED_SUCCESS
);
2893 value
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_AUTO_EJECT_HOSTS
);
2894 test_true(value
== 1);
2896 memcached_server_st
*server_pool
;
2897 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");
2898 memcached_server_push(memc
, server_pool
);
2900 /* verify that the server list was parsed okay. */
2901 test_true(memcached_server_count(memc
) == 8);
2902 test_true(strcmp(server_pool
[0].hostname
, "10.0.1.1") == 0);
2903 test_true(server_pool
[0].port
== 11211);
2904 test_true(server_pool
[0].weight
== 600);
2905 test_true(strcmp(server_pool
[2].hostname
, "10.0.1.3") == 0);
2906 test_true(server_pool
[2].port
== 11211);
2907 test_true(server_pool
[2].weight
== 200);
2908 test_true(strcmp(server_pool
[7].hostname
, "10.0.1.8") == 0);
2909 test_true(server_pool
[7].port
== 11211);
2910 test_true(server_pool
[7].weight
== 100);
2912 instance
= memcached_server_instance_fetch(memc
, 2);
2913 instance
->next_retry
= time(NULL
) + 15;
2914 memc
->next_distribution_rebuild
= time(NULL
) - 1;
2916 for (size_t x
= 0; x
< 99; x
++)
2918 uint32_t server_idx
= memcached_generate_hash(memc
, ketama_test_cases
[x
].key
, strlen(ketama_test_cases
[x
].key
));
2919 test_true(server_idx
!= 2);
2922 /* and re-added when it's back. */
2923 instance
->next_retry
= time(NULL
) - 1;
2924 memc
->next_distribution_rebuild
= time(NULL
) - 1;
2925 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_DISTRIBUTION
,
2926 memc
->distribution
);
2927 for (size_t x
= 0; x
< 99; x
++)
2929 uint32_t server_idx
= memcached_generate_hash(memc
, ketama_test_cases
[x
].key
, strlen(ketama_test_cases
[x
].key
));
2930 // We re-use instance from above.
2932 memcached_server_instance_fetch(memc
, server_idx
);
2933 char *hostname
= instance
->hostname
;
2934 test_true(strcmp(hostname
, ketama_test_cases
[x
].server
) == 0);
2937 memcached_server_list_free(server_pool
);
2938 memcached_free(memc
);
2940 return TEST_SUCCESS
;
2943 static test_return_t
output_ketama_weighted_keys(memcached_st
*trash
)
2947 memcached_return_t rc
;
2948 memcached_st
*memc
= memcached_create(NULL
);
2952 rc
= memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_KETAMA_WEIGHTED
, 1);
2953 test_true(rc
== MEMCACHED_SUCCESS
);
2955 uint64_t value
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_KETAMA_WEIGHTED
);
2956 test_true(value
== 1);
2958 rc
= memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_KETAMA_HASH
, MEMCACHED_HASH_MD5
);
2959 test_true(rc
== MEMCACHED_SUCCESS
);
2961 value
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_KETAMA_HASH
);
2962 test_true(value
== MEMCACHED_HASH_MD5
);
2965 test_true(memcached_behavior_set_distribution(memc
, MEMCACHED_DISTRIBUTION_CONSISTENT_KETAMA_SPY
) == MEMCACHED_SUCCESS
);
2967 memcached_server_st
*server_pool
;
2968 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");
2969 memcached_server_push(memc
, server_pool
);
2971 // @todo this needs to be refactored to actually test something.
2974 if ((fp
= fopen("ketama_keys.txt", "w")))
2978 printf("cannot write to file ketama_keys.txt");
2979 return TEST_FAILURE
;
2982 for (int x
= 0; x
< 10000; x
++)
2985 sprintf(key
, "%d", x
);
2987 uint32_t server_idx
= memcached_generate_hash(memc
, key
, strlen(key
));
2988 char *hostname
= memc
->hosts
[server_idx
].hostname
;
2989 in_port_t port
= memc
->hosts
[server_idx
].port
;
2990 fprintf(fp
, "key %s is on host /%s:%u\n", key
, hostname
, port
);
2994 memcached_server_list_free(server_pool
);
2995 memcached_free(memc
);
2997 return TEST_SUCCESS
;
3001 static test_return_t
result_static(memcached_st
*memc
)
3003 memcached_result_st result
;
3004 memcached_result_st
*result_ptr
;
3006 result_ptr
= memcached_result_create(memc
, &result
);
3007 test_true(result
.options
.is_allocated
== false);
3008 test_true(memcached_is_initialized(&result
) == true);
3009 test_true(result_ptr
);
3010 test_true(result_ptr
== &result
);
3012 memcached_result_free(&result
);
3014 test_true(result
.options
.is_allocated
== false);
3015 test_true(memcached_is_initialized(&result
) == false);
3017 return TEST_SUCCESS
;
3020 static test_return_t
result_alloc(memcached_st
*memc
)
3022 memcached_result_st
*result_ptr
;
3024 result_ptr
= memcached_result_create(memc
, NULL
);
3025 test_true(result_ptr
);
3026 test_true(result_ptr
->options
.is_allocated
== true);
3027 test_true(memcached_is_initialized(result_ptr
) == true);
3028 memcached_result_free(result_ptr
);
3030 return TEST_SUCCESS
;
3033 static test_return_t
string_static_null(memcached_st
*memc
)
3035 memcached_string_st string
;
3036 memcached_string_st
*string_ptr
;
3038 string_ptr
= memcached_string_create(memc
, &string
, 0);
3039 test_true(string
.options
.is_initialized
== true);
3040 test_true(string_ptr
);
3042 /* The following two better be the same! */
3043 test_true(memcached_is_allocated(string_ptr
) == false);
3044 test_true(memcached_is_allocated(&string
) == false);
3045 test_true(&string
== string_ptr
);
3047 test_true(string
.options
.is_initialized
== true);
3048 test_true(memcached_is_initialized(&string
) == true);
3049 memcached_string_free(&string
);
3050 test_true(memcached_is_initialized(&string
) == false);
3052 return TEST_SUCCESS
;
3055 static test_return_t
string_alloc_null(memcached_st
*memc
)
3057 memcached_string_st
*string
;
3059 string
= memcached_string_create(memc
, NULL
, 0);
3061 test_true(memcached_is_allocated(string
) == true);
3062 test_true(memcached_is_initialized(string
) == true);
3063 memcached_string_free(string
);
3065 return TEST_SUCCESS
;
3068 static test_return_t
string_alloc_with_size(memcached_st
*memc
)
3070 memcached_string_st
*string
;
3072 string
= memcached_string_create(memc
, NULL
, 1024);
3074 test_true(memcached_is_allocated(string
) == true);
3075 test_true(memcached_is_initialized(string
) == true);
3076 memcached_string_free(string
);
3078 return TEST_SUCCESS
;
3081 static test_return_t
string_alloc_with_size_toobig(memcached_st
*memc
)
3083 memcached_string_st
*string
;
3085 string
= memcached_string_create(memc
, NULL
, SIZE_MAX
);
3086 test_true(string
== NULL
);
3088 return TEST_SUCCESS
;
3091 static test_return_t
string_alloc_append(memcached_st
*memc
)
3094 char buffer
[SMALL_STRING_LEN
];
3095 memcached_string_st
*string
;
3097 /* Ring the bell! */
3098 memset(buffer
, 6, SMALL_STRING_LEN
);
3100 string
= memcached_string_create(memc
, NULL
, 100);
3102 test_true(memcached_is_allocated(string
) == true);
3103 test_true(memcached_is_initialized(string
) == true);
3105 for (x
= 0; x
< 1024; x
++)
3107 memcached_return_t rc
;
3108 rc
= memcached_string_append(string
, buffer
, SMALL_STRING_LEN
);
3109 test_true(rc
== MEMCACHED_SUCCESS
);
3111 test_true(memcached_is_allocated(string
) == true);
3112 memcached_string_free(string
);
3114 return TEST_SUCCESS
;
3117 static test_return_t
string_alloc_append_toobig(memcached_st
*memc
)
3119 memcached_return_t rc
;
3121 char buffer
[SMALL_STRING_LEN
];
3122 memcached_string_st
*string
;
3124 /* Ring the bell! */
3125 memset(buffer
, 6, SMALL_STRING_LEN
);
3127 string
= memcached_string_create(memc
, NULL
, 100);
3129 test_true(memcached_is_allocated(string
) == true);
3130 test_true(memcached_is_initialized(string
) == true);
3132 for (x
= 0; x
< 1024; x
++)
3134 rc
= memcached_string_append(string
, buffer
, SMALL_STRING_LEN
);
3135 test_true(rc
== MEMCACHED_SUCCESS
);
3137 rc
= memcached_string_append(string
, buffer
, SIZE_MAX
);
3138 test_true(rc
== MEMCACHED_MEMORY_ALLOCATION_FAILURE
);
3139 test_true(memcached_is_allocated(string
) == true);
3140 memcached_string_free(string
);
3142 return TEST_SUCCESS
;
3145 static test_return_t
cleanup_pairs(memcached_st
*memc
__attribute__((unused
)))
3147 pairs_free(global_pairs
);
3149 return TEST_SUCCESS
;
3152 static test_return_t
generate_pairs(memcached_st
*memc
__attribute__((unused
)))
3154 global_pairs
= pairs_generate(GLOBAL_COUNT
, 400);
3155 global_count
= GLOBAL_COUNT
;
3157 for (size_t x
= 0; x
< global_count
; x
++)
3159 global_keys
[x
]= global_pairs
[x
].key
;
3160 global_keys_length
[x
]= global_pairs
[x
].key_length
;
3163 return TEST_SUCCESS
;
3166 static test_return_t
generate_large_pairs(memcached_st
*memc
__attribute__((unused
)))
3168 global_pairs
= pairs_generate(GLOBAL2_COUNT
, MEMCACHED_MAX_BUFFER
+10);
3169 global_count
= GLOBAL2_COUNT
;
3171 for (size_t x
= 0; x
< global_count
; x
++)
3173 global_keys
[x
]= global_pairs
[x
].key
;
3174 global_keys_length
[x
]= global_pairs
[x
].key_length
;
3177 return TEST_SUCCESS
;
3180 static test_return_t
generate_data(memcached_st
*memc
)
3182 execute_set(memc
, global_pairs
, global_count
);
3184 return TEST_SUCCESS
;
3187 static test_return_t
generate_data_with_stats(memcached_st
*memc
)
3189 memcached_stat_st
*stat_p
;
3190 memcached_return_t rc
;
3191 uint32_t host_index
= 0;
3192 execute_set(memc
, global_pairs
, global_count
);
3194 //TODO: hosts used size stats
3195 stat_p
= memcached_stat(memc
, NULL
, &rc
);
3198 for (host_index
= 0; host_index
< SERVERS_TO_CREATE
; host_index
++)
3200 /* This test was changes so that "make test" would work properlly */
3202 memcached_server_instance_st
*instance
=
3203 memcached_server_instance_fetch(memc
, host_index
);
3205 printf("\nserver %u|%s|%u bytes: %llu\n", host_index
, instance
->hostname
, instance
->port
, (unsigned long long)(stat_p
+ host_index
)->bytes
);
3207 test_true((unsigned long long)(stat_p
+ host_index
)->bytes
);
3210 memcached_stat_free(NULL
, stat_p
);
3212 return TEST_SUCCESS
;
3214 static test_return_t
generate_buffer_data(memcached_st
*memc
)
3219 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_BUFFER_REQUESTS
, latch
);
3220 generate_data(memc
);
3222 return TEST_SUCCESS
;
3225 static test_return_t
get_read_count(memcached_st
*memc
)
3227 memcached_return_t rc
;
3228 memcached_st
*memc_clone
;
3230 memc_clone
= memcached_clone(NULL
, memc
);
3231 test_true(memc_clone
);
3233 memcached_server_add_with_weight(memc_clone
, "localhost", 6666, 0);
3237 size_t return_value_length
;
3241 for (size_t x
= count
= 0; x
< global_count
; x
++)
3243 return_value
= memcached_get(memc_clone
, global_keys
[x
], global_keys_length
[x
],
3244 &return_value_length
, &flags
, &rc
);
3245 if (rc
== MEMCACHED_SUCCESS
)
3254 memcached_free(memc_clone
);
3256 return TEST_SUCCESS
;
3259 static test_return_t
get_read(memcached_st
*memc
)
3261 memcached_return_t rc
;
3265 size_t return_value_length
;
3268 for (size_t x
= 0; x
< global_count
; x
++)
3270 return_value
= memcached_get(memc
, global_keys
[x
], global_keys_length
[x
],
3271 &return_value_length
, &flags
, &rc
);
3273 test_true(return_value);
3274 test_true(rc == MEMCACHED_SUCCESS);
3276 if (rc
== MEMCACHED_SUCCESS
&& return_value
)
3281 return TEST_SUCCESS
;
3284 static test_return_t
mget_read(memcached_st
*memc
)
3286 memcached_return_t rc
;
3288 rc
= memcached_mget(memc
, global_keys
, global_keys_length
, global_count
);
3289 test_true(rc
== MEMCACHED_SUCCESS
);
3290 test_true(fetch_all_results(memc
) == TEST_SUCCESS
);
3292 return TEST_SUCCESS
;
3295 static test_return_t
mget_read_result(memcached_st
*memc
)
3297 memcached_return_t rc
;
3299 rc
= memcached_mget(memc
, global_keys
, global_keys_length
, global_count
);
3300 test_true(rc
== MEMCACHED_SUCCESS
);
3301 /* Turn this into a help function */
3303 memcached_result_st results_obj
;
3304 memcached_result_st
*results
;
3306 results
= memcached_result_create(memc
, &results_obj
);
3308 while ((results
= memcached_fetch_result(memc
, &results_obj
, &rc
)))
3311 test_true(rc
== MEMCACHED_SUCCESS
);
3314 memcached_result_free(&results_obj
);
3317 return TEST_SUCCESS
;
3320 static test_return_t
mget_read_function(memcached_st
*memc
)
3322 memcached_return_t rc
;
3324 memcached_execute_fn callbacks
[1];
3326 rc
= memcached_mget(memc
, global_keys
, global_keys_length
, global_count
);
3327 test_true(rc
== MEMCACHED_SUCCESS
);
3329 callbacks
[0]= &callback_counter
;
3331 rc
= memcached_fetch_execute(memc
, callbacks
, (void *)&counter
, 1);
3333 return TEST_SUCCESS
;
3336 static test_return_t
delete_generate(memcached_st
*memc
)
3338 for (size_t x
= 0; x
< global_count
; x
++)
3340 (void)memcached_delete(memc
, global_keys
[x
], global_keys_length
[x
], (time_t)0);
3343 return TEST_SUCCESS
;
3346 static test_return_t
delete_buffer_generate(memcached_st
*memc
)
3351 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_BUFFER_REQUESTS
, latch
);
3353 for (size_t x
= 0; x
< global_count
; x
++)
3355 (void)memcached_delete(memc
, global_keys
[x
], global_keys_length
[x
], (time_t)0);
3358 return TEST_SUCCESS
;
3361 static test_return_t
add_host_test1(memcached_st
*memc
)
3363 memcached_return_t rc
;
3364 char servername
[]= "0.example.com";
3365 memcached_server_st
*servers
;
3367 servers
= memcached_server_list_append_with_weight(NULL
, servername
, 400, 0, &rc
);
3369 test_true(1 == memcached_server_list_count(servers
));
3371 for (size_t x
= 2; x
< 20; x
++)
3373 char buffer
[SMALL_STRING_LEN
];
3375 snprintf(buffer
, SMALL_STRING_LEN
, "%zu.example.com", 400+x
);
3376 servers
= memcached_server_list_append_with_weight(servers
, buffer
, 401, 0,
3378 test_true(rc
== MEMCACHED_SUCCESS
);
3379 test_true(x
== memcached_server_list_count(servers
));
3382 rc
= memcached_server_push(memc
, servers
);
3383 test_true(rc
== MEMCACHED_SUCCESS
);
3384 rc
= memcached_server_push(memc
, servers
);
3385 test_true(rc
== MEMCACHED_SUCCESS
);
3387 memcached_server_list_free(servers
);
3389 return TEST_SUCCESS
;
3392 static test_return_t
pre_nonblock(memcached_st
*memc
)
3394 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NO_BLOCK
, 0);
3396 return TEST_SUCCESS
;
3399 static test_return_t
pre_cork(memcached_st
*memc
)
3401 memcached_return_t rc
;
3403 rc
= memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_CORK
, set
);
3405 if (rc
== MEMCACHED_SUCCESS
)
3406 return TEST_SUCCESS
;
3408 return TEST_SKIPPED
;
3411 static test_return_t
pre_cork_and_nonblock(memcached_st
*memc
)
3417 if (rc
!= TEST_SUCCESS
)
3420 return pre_nonblock(memc
);
3423 static test_return_t
pre_nonblock_binary(memcached_st
*memc
)
3425 memcached_return_t rc
= MEMCACHED_FAILURE
;
3426 memcached_st
*memc_clone
;
3427 memcached_server_instance_st
*instance
;
3429 memc_clone
= memcached_clone(NULL
, memc
);
3430 test_true(memc_clone
);
3431 // The memcached_version needs to be done on a clone, because the server
3432 // will not toggle protocol on an connection.
3433 memcached_version(memc_clone
);
3435 instance
= memcached_server_instance_fetch(memc_clone
, 0);
3437 if (instance
->major_version
>= 1 && instance
->minor_version
> 2)
3439 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NO_BLOCK
, 0);
3440 rc
= memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
, 1);
3441 test_true(rc
== MEMCACHED_SUCCESS
);
3442 test_true(memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
) == 1);
3446 return TEST_SKIPPED
;
3449 memcached_free(memc_clone
);
3451 return rc
== MEMCACHED_SUCCESS
? TEST_SUCCESS
: TEST_SKIPPED
;
3454 static test_return_t
pre_murmur(memcached_st
*memc
)
3456 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_HASH
, (uint64_t)MEMCACHED_HASH_MURMUR
);
3458 return TEST_SUCCESS
;
3461 static test_return_t
pre_jenkins(memcached_st
*memc
)
3463 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_HASH
, (uint64_t)MEMCACHED_HASH_JENKINS
);
3465 return TEST_SUCCESS
;
3469 static test_return_t
pre_md5(memcached_st
*memc
)
3471 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_HASH
, (uint64_t)MEMCACHED_HASH_MD5
);
3473 return TEST_SUCCESS
;
3476 static test_return_t
pre_crc(memcached_st
*memc
)
3478 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_HASH
, (uint64_t)MEMCACHED_HASH_CRC
);
3480 return TEST_SUCCESS
;
3483 static test_return_t
pre_hsieh(memcached_st
*memc
)
3485 #ifdef HAVE_HSIEH_HASH
3486 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_HASH
, (uint64_t)MEMCACHED_HASH_HSIEH
);
3487 return TEST_SUCCESS
;
3490 return TEST_SKIPPED
;
3494 static test_return_t
pre_hash_fnv1_64(memcached_st
*memc
)
3496 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_HASH
, (uint64_t)MEMCACHED_HASH_MURMUR
);
3498 return TEST_SUCCESS
;
3501 static test_return_t
pre_hash_fnv1a_64(memcached_st
*memc
)
3503 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_HASH
, (uint64_t)MEMCACHED_HASH_FNV1A_64
);
3505 return TEST_SUCCESS
;
3508 static test_return_t
pre_hash_fnv1_32(memcached_st
*memc
)
3510 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_HASH
, (uint64_t)MEMCACHED_HASH_FNV1_32
);
3512 return TEST_SUCCESS
;
3515 static test_return_t
pre_hash_fnv1a_32(memcached_st
*memc
)
3517 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_HASH
, (uint64_t)MEMCACHED_HASH_FNV1A_32
);
3519 return TEST_SUCCESS
;
3522 static test_return_t
pre_behavior_ketama(memcached_st
*memc
)
3524 memcached_return_t rc
;
3527 rc
= memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_KETAMA
, 1);
3528 test_true(rc
== MEMCACHED_SUCCESS
);
3530 value
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_KETAMA
);
3531 test_true(value
== 1);
3533 return TEST_SUCCESS
;
3536 static test_return_t
pre_behavior_ketama_weighted(memcached_st
*memc
)
3538 memcached_return_t rc
;
3541 rc
= memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_KETAMA_WEIGHTED
, 1);
3542 test_true(rc
== MEMCACHED_SUCCESS
);
3544 value
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_KETAMA_WEIGHTED
);
3545 test_true(value
== 1);
3547 rc
= memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_KETAMA_HASH
, MEMCACHED_HASH_MD5
);
3548 test_true(rc
== MEMCACHED_SUCCESS
);
3550 value
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_KETAMA_HASH
);
3551 test_true(value
== MEMCACHED_HASH_MD5
);
3553 return TEST_SUCCESS
;
3557 @note This should be testing to see if the server really supports the binary protocol.
3559 static test_return_t
pre_binary(memcached_st
*memc
)
3561 memcached_return_t rc
= MEMCACHED_FAILURE
;
3562 memcached_st
*memc_clone
;
3563 memcached_server_instance_st
*instance
;
3565 memc_clone
= memcached_clone(NULL
, memc
);
3566 test_true(memc_clone
);
3567 // The memcached_version needs to be done on a clone, because the server
3568 // will not toggle protocol on an connection.
3569 memcached_version(memc_clone
);
3571 instance
= memcached_server_instance_fetch(memc_clone
, 0);
3573 if (instance
->major_version
>= 1 && instance
->minor_version
> 2)
3575 rc
= memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
, 1);
3576 test_true(rc
== MEMCACHED_SUCCESS
);
3577 test_true(memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
) == 1);
3580 memcached_free(memc_clone
);
3582 return rc
== MEMCACHED_SUCCESS
? TEST_SUCCESS
: TEST_SKIPPED
;
3586 static test_return_t
pre_replication(memcached_st
*memc
)
3588 test_return_t test_rc
;
3589 test_rc
= pre_binary(memc
);
3591 if (test_rc
!= TEST_SUCCESS
)
3595 * Make sure that we store the item on all servers
3596 * (master + replicas == number of servers)
3598 memcached_return_t rc
;
3599 rc
= memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NUMBER_OF_REPLICAS
,
3600 memcached_server_count(memc
) - 1);
3601 test_true(rc
== MEMCACHED_SUCCESS
);
3602 test_true(memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_NUMBER_OF_REPLICAS
) == memcached_server_count(memc
) - 1);
3604 return rc
== MEMCACHED_SUCCESS
? TEST_SUCCESS
: TEST_SKIPPED
;
3608 static test_return_t
pre_replication_noblock(memcached_st
*memc
)
3612 rc
= pre_replication(memc
);
3613 if (rc
!= TEST_SUCCESS
)
3616 rc
= pre_nonblock(memc
);
3622 static void my_free(const memcached_st
*ptr
__attribute__((unused
)), void *mem
, void *context
)
3625 #ifdef HARD_MALLOC_TESTS
3626 void *real_ptr
= (mem
== NULL
) ? mem
: (void*)((caddr_t
)mem
- 8);
3634 static void *my_malloc(const memcached_st
*ptr
__attribute__((unused
)), const size_t size
, void *context
)
3637 #ifdef HARD_MALLOC_TESTS
3638 void *ret
= malloc(size
+ 8);
3641 ret
= (void*)((caddr_t
)ret
+ 8);
3644 void *ret
= malloc(size
);
3649 memset(ret
, 0xff, size
);
3656 static void *my_realloc(const memcached_st
*ptr
__attribute__((unused
)), void *mem
, const size_t size
, void *context
)
3659 #ifdef HARD_MALLOC_TESTS
3660 void *real_ptr
= (mem
== NULL
) ? NULL
: (void*)((caddr_t
)mem
- 8);
3661 void *nmem
= realloc(real_ptr
, size
+ 8);
3666 ret
= (void*)((caddr_t
)nmem
+ 8);
3671 return realloc(mem
, size
);
3676 static void *my_calloc(const memcached_st
*ptr
__attribute__((unused
)), size_t nelem
, const size_t size
, void *context
)
3679 #ifdef HARD_MALLOC_TESTS
3680 void *mem
= my_malloc(ptr
, nelem
* size
);
3683 memset(mem
, 0, nelem
* size
);
3688 return calloc(nelem
, size
);
3693 static test_return_t
set_prefix(memcached_st
*memc
)
3695 memcached_return_t rc
;
3696 const char *key
= "mine";
3699 /* Make sure be default none exists */
3700 value
= memcached_callback_get(memc
, MEMCACHED_CALLBACK_PREFIX_KEY
, &rc
);
3701 test_true(rc
== MEMCACHED_FAILURE
);
3703 /* Test a clean set */
3704 rc
= memcached_callback_set(memc
, MEMCACHED_CALLBACK_PREFIX_KEY
, (void *)key
);
3705 test_true(rc
== MEMCACHED_SUCCESS
);
3707 value
= memcached_callback_get(memc
, MEMCACHED_CALLBACK_PREFIX_KEY
, &rc
);
3708 test_true(memcmp(value
, key
, 4) == 0);
3709 test_true(rc
== MEMCACHED_SUCCESS
);
3711 /* Test that we can turn it off */
3712 rc
= memcached_callback_set(memc
, MEMCACHED_CALLBACK_PREFIX_KEY
, NULL
);
3713 test_true(rc
== MEMCACHED_SUCCESS
);
3715 value
= memcached_callback_get(memc
, MEMCACHED_CALLBACK_PREFIX_KEY
, &rc
);
3716 test_true(rc
== MEMCACHED_FAILURE
);
3718 /* Now setup for main test */
3719 rc
= memcached_callback_set(memc
, MEMCACHED_CALLBACK_PREFIX_KEY
, (void *)key
);
3720 test_true(rc
== MEMCACHED_SUCCESS
);
3722 value
= memcached_callback_get(memc
, MEMCACHED_CALLBACK_PREFIX_KEY
, &rc
);
3723 test_true(rc
== MEMCACHED_SUCCESS
);
3724 test_true(memcmp(value
, key
, 4) == 0);
3726 /* Set to Zero, and then Set to something too large */
3729 memset(long_key
, 0, 255);
3731 rc
= memcached_callback_set(memc
, MEMCACHED_CALLBACK_PREFIX_KEY
, NULL
);
3732 test_true(rc
== MEMCACHED_SUCCESS
);
3734 value
= memcached_callback_get(memc
, MEMCACHED_CALLBACK_PREFIX_KEY
, &rc
);
3735 test_true(rc
== MEMCACHED_FAILURE
);
3736 test_true(value
== NULL
);
3738 /* Test a long key for failure */
3739 /* TODO, extend test to determine based on setting, what result should be */
3740 strcpy(long_key
, "Thisismorethentheallottednumberofcharacters");
3741 rc
= memcached_callback_set(memc
, MEMCACHED_CALLBACK_PREFIX_KEY
, long_key
);
3742 //test_true(rc == MEMCACHED_BAD_KEY_PROVIDED);
3743 test_true(rc
== MEMCACHED_SUCCESS
);
3745 /* Now test a key with spaces (which will fail from long key, since bad key is not set) */
3746 strcpy(long_key
, "This is more then the allotted number of characters");
3747 rc
= memcached_callback_set(memc
, MEMCACHED_CALLBACK_PREFIX_KEY
, long_key
);
3748 test_true(rc
== MEMCACHED_BAD_KEY_PROVIDED
);
3750 /* Test for a bad prefix, but with a short key */
3751 rc
= memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_VERIFY_KEY
, 1);
3752 test_true(rc
== MEMCACHED_SUCCESS
);
3754 strcpy(long_key
, "dog cat");
3755 rc
= memcached_callback_set(memc
, MEMCACHED_CALLBACK_PREFIX_KEY
, long_key
);
3756 test_true(rc
== MEMCACHED_BAD_KEY_PROVIDED
);
3759 return TEST_SUCCESS
;
3763 #ifdef MEMCACHED_ENABLE_DEPRECATED
3764 static test_return_t
deprecated_set_memory_alloc(memcached_st
*memc
)
3766 void *test_ptr
= NULL
;
3769 memcached_malloc_fn malloc_cb
=
3770 (memcached_malloc_fn
)my_malloc
;
3771 cb_ptr
= *(void **)&malloc_cb
;
3772 memcached_return_t rc
;
3774 rc
= memcached_callback_set(memc
, MEMCACHED_CALLBACK_MALLOC_FUNCTION
, cb_ptr
);
3775 test_true(rc
== MEMCACHED_SUCCESS
);
3776 test_ptr
= memcached_callback_get(memc
, MEMCACHED_CALLBACK_MALLOC_FUNCTION
, &rc
);
3777 test_true(rc
== MEMCACHED_SUCCESS
);
3778 test_true(test_ptr
== cb_ptr
);
3782 memcached_realloc_fn realloc_cb
=
3783 (memcached_realloc_fn
)my_realloc
;
3784 cb_ptr
= *(void **)&realloc_cb
;
3785 memcached_return_t rc
;
3787 rc
= memcached_callback_set(memc
, MEMCACHED_CALLBACK_REALLOC_FUNCTION
, cb_ptr
);
3788 test_true(rc
== MEMCACHED_SUCCESS
);
3789 test_ptr
= memcached_callback_get(memc
, MEMCACHED_CALLBACK_REALLOC_FUNCTION
, &rc
);
3790 test_true(rc
== MEMCACHED_SUCCESS
);
3791 test_true(test_ptr
== cb_ptr
);
3795 memcached_free_fn free_cb
=
3796 (memcached_free_fn
)my_free
;
3797 cb_ptr
= *(void **)&free_cb
;
3798 memcached_return_t rc
;
3800 rc
= memcached_callback_set(memc
, MEMCACHED_CALLBACK_FREE_FUNCTION
, cb_ptr
);
3801 test_true(rc
== MEMCACHED_SUCCESS
);
3802 test_ptr
= memcached_callback_get(memc
, MEMCACHED_CALLBACK_FREE_FUNCTION
, &rc
);
3803 test_true(rc
== MEMCACHED_SUCCESS
);
3804 test_true(test_ptr
== cb_ptr
);
3807 return TEST_SUCCESS
;
3812 static test_return_t
set_memory_alloc(memcached_st
*memc
)
3814 memcached_return_t rc
;
3815 rc
= memcached_set_memory_allocators(memc
, NULL
, my_free
,
3816 my_realloc
, my_calloc
, NULL
);
3817 test_true(rc
== MEMCACHED_FAILURE
);
3819 rc
= memcached_set_memory_allocators(memc
, my_malloc
, my_free
,
3820 my_realloc
, my_calloc
, NULL
);
3822 memcached_malloc_fn mem_malloc
;
3823 memcached_free_fn mem_free
;
3824 memcached_realloc_fn mem_realloc
;
3825 memcached_calloc_fn mem_calloc
;
3826 memcached_get_memory_allocators(memc
, &mem_malloc
, &mem_free
,
3827 &mem_realloc
, &mem_calloc
);
3829 test_true(mem_malloc
== my_malloc
);
3830 test_true(mem_realloc
== my_realloc
);
3831 test_true(mem_calloc
== my_calloc
);
3832 test_true(mem_free
== my_free
);
3834 return TEST_SUCCESS
;
3837 static test_return_t
enable_consistent_crc(memcached_st
*memc
)
3840 memcached_server_distribution_t value
= MEMCACHED_DISTRIBUTION_CONSISTENT
;
3841 memcached_hash_t hash
;
3842 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_DISTRIBUTION
, value
);
3843 if ((rc
= pre_crc(memc
)) != TEST_SUCCESS
)
3846 value
= (memcached_server_distribution_t
)memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_DISTRIBUTION
);
3847 test_true(value
== MEMCACHED_DISTRIBUTION_CONSISTENT
);
3849 hash
= (memcached_hash_t
)memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_HASH
);
3851 if (hash
!= MEMCACHED_HASH_CRC
)
3852 return TEST_SKIPPED
;
3854 return TEST_SUCCESS
;
3857 static test_return_t
enable_consistent_hsieh(memcached_st
*memc
)
3860 memcached_server_distribution_t value
= MEMCACHED_DISTRIBUTION_CONSISTENT
;
3861 memcached_hash_t hash
;
3862 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_DISTRIBUTION
, value
);
3863 if ((rc
= pre_hsieh(memc
)) != TEST_SUCCESS
)
3866 value
= (memcached_server_distribution_t
)memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_DISTRIBUTION
);
3867 test_true(value
== MEMCACHED_DISTRIBUTION_CONSISTENT
);
3869 hash
= (memcached_hash_t
)memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_HASH
);
3871 if (hash
!= MEMCACHED_HASH_HSIEH
)
3872 return TEST_SKIPPED
;
3875 return TEST_SUCCESS
;
3878 static test_return_t
enable_cas(memcached_st
*memc
)
3880 unsigned int set
= 1;
3882 memcached_server_instance_st
*instance
=
3883 memcached_server_instance_fetch(memc
, 0);
3885 memcached_version(memc
);
3887 if ((instance
->major_version
>= 1 && (instance
->minor_version
== 2 && instance
->micro_version
>= 4))
3888 || instance
->minor_version
> 2)
3890 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_SUPPORT_CAS
, set
);
3892 return TEST_SUCCESS
;
3895 return TEST_SKIPPED
;
3898 static test_return_t
check_for_1_2_3(memcached_st
*memc
)
3900 memcached_version(memc
);
3901 memcached_server_instance_st
*instance
=
3902 memcached_server_instance_fetch(memc
, 0);
3904 if ((instance
->major_version
>= 1 && (instance
->minor_version
== 2 && instance
->micro_version
>= 4))
3905 || instance
->minor_version
> 2)
3906 return TEST_SUCCESS
;
3908 return TEST_SKIPPED
;
3911 static test_return_t
pre_unix_socket(memcached_st
*memc
)
3913 memcached_return_t rc
;
3916 memcached_servers_reset(memc
);
3918 if (stat("/tmp/memcached.socket", &buf
))
3919 return TEST_SKIPPED
;
3921 rc
= memcached_server_add_unix_socket_with_weight(memc
, "/tmp/memcached.socket", 0);
3923 return ( rc
== MEMCACHED_SUCCESS
? TEST_SUCCESS
: TEST_FAILURE
);
3926 static test_return_t
pre_nodelay(memcached_st
*memc
)
3928 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NO_BLOCK
, 0);
3929 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_TCP_NODELAY
, 0);
3931 return TEST_SUCCESS
;
3934 static test_return_t
pre_settimer(memcached_st
*memc
)
3936 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_SND_TIMEOUT
, 1000);
3937 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_RCV_TIMEOUT
, 1000);
3939 return TEST_SUCCESS
;
3942 static test_return_t
poll_timeout(memcached_st
*memc
)
3948 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_POLL_TIMEOUT
, timeout
);
3950 timeout
= (size_t)memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_POLL_TIMEOUT
);
3952 test_true(timeout
== 100);
3954 return TEST_SUCCESS
;
3957 static test_return_t
noreply_test(memcached_st
*memc
)
3959 memcached_return_t ret
;
3960 ret
= memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NOREPLY
, 1);
3961 test_true(ret
== MEMCACHED_SUCCESS
);
3962 ret
= memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_BUFFER_REQUESTS
, 1);
3963 test_true(ret
== MEMCACHED_SUCCESS
);
3964 ret
= memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_SUPPORT_CAS
, 1);
3965 test_true(ret
== MEMCACHED_SUCCESS
);
3966 test_true(memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_NOREPLY
) == 1);
3967 test_true(memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_BUFFER_REQUESTS
) == 1);
3968 test_true(memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_SUPPORT_CAS
) == 1);
3970 for (int count
=0; count
< 5; ++count
)
3972 for (size_t x
= 0; x
< 100; ++x
)
3975 size_t len
= (size_t)sprintf(key
, "%zu", x
);
3979 ret
= memcached_add(memc
, key
, len
, key
, len
, 0, 0);
3982 ret
= memcached_replace(memc
, key
, len
, key
, len
, 0, 0);
3985 ret
= memcached_set(memc
, key
, len
, key
, len
, 0, 0);
3988 ret
= memcached_append(memc
, key
, len
, key
, len
, 0, 0);
3991 ret
= memcached_prepend(memc
, key
, len
, key
, len
, 0, 0);
3997 test_true(ret
== MEMCACHED_SUCCESS
|| ret
== MEMCACHED_BUFFERED
);
4001 ** NOTE: Don't ever do this in your code! this is not a supported use of the
4002 ** API and is _ONLY_ done this way to verify that the library works the
4003 ** way it is supposed to do!!!!
4006 for (uint32_t x
= 0; x
< memcached_server_count(memc
); ++x
)
4008 memcached_server_instance_st
*instance
=
4009 memcached_server_instance_fetch(memc
, x
);
4010 no_msg
+=(int)(instance
->cursor_active
);
4013 test_true(no_msg
== 0);
4014 test_true(memcached_flush_buffers(memc
) == MEMCACHED_SUCCESS
);
4017 ** Now validate that all items was set properly!
4019 for (size_t x
= 0; x
< 100; ++x
)
4023 size_t len
= (size_t)sprintf(key
, "%zu", x
);
4026 char* value
=memcached_get(memc
, key
, strlen(key
),
4027 &length
, &flags
, &ret
);
4028 test_true(ret
== MEMCACHED_SUCCESS
&& value
!= NULL
);
4031 case 0: /* FALLTHROUGH */
4032 case 1: /* FALLTHROUGH */
4034 test_true(strncmp(value
, key
, len
) == 0);
4035 test_true(len
== length
);
4038 test_true(length
== len
* 2);
4041 test_true(length
== len
* 3);
4051 /* Try setting an illegal cas value (should not return an error to
4052 * the caller (because we don't expect a return message from the server)
4054 const char* keys
[]= {"0"};
4055 size_t lengths
[]= {1};
4058 memcached_result_st results_obj
;
4059 memcached_result_st
*results
;
4060 ret
= memcached_mget(memc
, keys
, lengths
, 1);
4061 test_true(ret
== MEMCACHED_SUCCESS
);
4063 results
= memcached_result_create(memc
, &results_obj
);
4065 results
= memcached_fetch_result(memc
, &results_obj
, &ret
);
4067 test_true(ret
== MEMCACHED_SUCCESS
);
4068 uint64_t cas
= memcached_result_cas(results
);
4069 memcached_result_free(&results_obj
);
4071 ret
= memcached_cas(memc
, keys
[0], lengths
[0], keys
[0], lengths
[0], 0, 0, cas
);
4072 test_true(ret
== MEMCACHED_SUCCESS
);
4075 * The item will have a new cas value, so try to set it again with the old
4076 * value. This should fail!
4078 ret
= memcached_cas(memc
, keys
[0], lengths
[0], keys
[0], lengths
[0], 0, 0, cas
);
4079 test_true(ret
== MEMCACHED_SUCCESS
);
4080 test_true(memcached_flush_buffers(memc
) == MEMCACHED_SUCCESS
);
4081 char* value
=memcached_get(memc
, keys
[0], lengths
[0], &length
, &flags
, &ret
);
4082 test_true(ret
== MEMCACHED_SUCCESS
&& value
!= NULL
);
4085 return TEST_SUCCESS
;
4088 static test_return_t
analyzer_test(memcached_st
*memc
)
4090 memcached_return_t rc
;
4091 memcached_stat_st
*memc_stat
;
4092 memcached_analysis_st
*report
;
4094 memc_stat
= memcached_stat(memc
, NULL
, &rc
);
4095 test_true(rc
== MEMCACHED_SUCCESS
);
4096 test_true(memc_stat
);
4098 report
= memcached_analyze(memc
, memc_stat
, &rc
);
4099 test_true(rc
== MEMCACHED_SUCCESS
);
4103 memcached_stat_free(NULL
, memc_stat
);
4105 return TEST_SUCCESS
;
4108 /* Count the objects */
4109 static memcached_return_t
callback_dump_counter(const memcached_st
*ptr
__attribute__((unused
)),
4110 const char *key
__attribute__((unused
)),
4111 size_t key_length
__attribute__((unused
)),
4114 size_t *counter
= (size_t *)context
;
4116 *counter
= *counter
+ 1;
4118 return MEMCACHED_SUCCESS
;
4121 static test_return_t
dump_test(memcached_st
*memc
)
4123 memcached_return_t rc
;
4125 memcached_dump_fn callbacks
[1];
4126 test_return_t main_rc
;
4128 callbacks
[0]= &callback_dump_counter
;
4130 /* No support for Binary protocol yet */
4131 if (memc
->flags
.binary_protocol
)
4132 return TEST_SUCCESS
;
4134 main_rc
= set_test3(memc
);
4136 test_true (main_rc
== TEST_SUCCESS
);
4138 rc
= memcached_dump(memc
, callbacks
, (void *)&counter
, 1);
4139 test_true(rc
== MEMCACHED_SUCCESS
);
4141 /* We may have more then 32 if our previous flush has not completed */
4142 test_true(counter
>= 32);
4144 return TEST_SUCCESS
;
4147 #ifdef HAVE_LIBMEMCACHEDUTIL
4148 static void* connection_release(void *arg
)
4151 memcached_pool_st
* pool
;
4156 assert(memcached_pool_push(resource
->pool
, resource
->mmc
) == MEMCACHED_SUCCESS
);
4160 static test_return_t
connection_pool_test(memcached_st
*memc
)
4162 memcached_pool_st
* pool
= memcached_pool_create(memc
, 5, 10);
4163 test_true(pool
!= NULL
);
4164 memcached_st
* mmc
[10];
4165 memcached_return_t rc
;
4167 for (size_t x
= 0; x
< 10; ++x
)
4169 mmc
[x
]= memcached_pool_pop(pool
, false, &rc
);
4170 test_true(mmc
[x
] != NULL
);
4171 test_true(rc
== MEMCACHED_SUCCESS
);
4174 test_true(memcached_pool_pop(pool
, false, &rc
) == NULL
);
4175 test_true(rc
== MEMCACHED_SUCCESS
);
4179 memcached_pool_st
* pool
;
4181 } item
= { .pool
= pool
, .mmc
= mmc
[9] };
4182 pthread_create(&tid
, NULL
, connection_release
, &item
);
4183 mmc
[9]= memcached_pool_pop(pool
, true, &rc
);
4184 test_true(rc
== MEMCACHED_SUCCESS
);
4185 pthread_join(tid
, NULL
);
4186 test_true(mmc
[9] == item
.mmc
);
4187 const char *key
= "key";
4188 size_t keylen
= strlen(key
);
4190 // verify that I can do ops with all connections
4191 rc
= memcached_set(mmc
[0], key
, keylen
, "0", 1, 0, 0);
4192 test_true(rc
== MEMCACHED_SUCCESS
);
4194 for (size_t x
= 0; x
< 10; ++x
)
4196 uint64_t number_value
;
4197 rc
= memcached_increment(mmc
[x
], key
, keylen
, 1, &number_value
);
4198 test_true(rc
== MEMCACHED_SUCCESS
);
4199 test_true(number_value
== (x
+1));
4203 for (size_t x
= 0; x
< 10; ++x
)
4205 test_true(memcached_pool_push(pool
, mmc
[x
]) == MEMCACHED_SUCCESS
);
4209 /* verify that I can set behaviors on the pool when I don't have all
4210 * of the connections in the pool. It should however be enabled
4211 * when I push the item into the pool
4213 mmc
[0]= memcached_pool_pop(pool
, false, &rc
);
4214 test_true(mmc
[0] != NULL
);
4216 rc
= memcached_pool_behavior_set(pool
, MEMCACHED_BEHAVIOR_IO_MSG_WATERMARK
, 9999);
4217 test_true(rc
== MEMCACHED_SUCCESS
);
4219 mmc
[1]= memcached_pool_pop(pool
, false, &rc
);
4220 test_true(mmc
[1] != NULL
);
4222 test_true(memcached_behavior_get(mmc
[1], MEMCACHED_BEHAVIOR_IO_MSG_WATERMARK
) == 9999);
4223 test_true(memcached_pool_push(pool
, mmc
[1]) == MEMCACHED_SUCCESS
);
4224 test_true(memcached_pool_push(pool
, mmc
[0]) == MEMCACHED_SUCCESS
);
4226 mmc
[0]= memcached_pool_pop(pool
, false, &rc
);
4227 test_true(memcached_behavior_get(mmc
[0], MEMCACHED_BEHAVIOR_IO_MSG_WATERMARK
) == 9999);
4228 test_true(memcached_pool_push(pool
, mmc
[0]) == MEMCACHED_SUCCESS
);
4231 test_true(memcached_pool_destroy(pool
) == memc
);
4232 return TEST_SUCCESS
;
4236 static test_return_t
replication_set_test(memcached_st
*memc
)
4238 memcached_return_t rc
;
4239 memcached_st
*memc_clone
= memcached_clone(NULL
, memc
);
4240 memcached_behavior_set(memc_clone
, MEMCACHED_BEHAVIOR_NUMBER_OF_REPLICAS
, 0);
4242 rc
= memcached_set(memc
, "bubba", 5, "0", 1, 0, 0);
4243 test_true(rc
== MEMCACHED_SUCCESS
);
4246 ** We are using the quiet commands to store the replicas, so we need
4247 ** to ensure that all of them are processed before we can continue.
4248 ** In the test we go directly from storing the object to trying to
4249 ** receive the object from all of the different servers, so we
4250 ** could end up in a race condition (the memcached server hasn't yet
4251 ** processed the quiet command from the replication set when it process
4252 ** the request from the other client (created by the clone)). As a
4253 ** workaround for that we call memcached_quit to send the quit command
4254 ** to the server and wait for the response ;-) If you use the test code
4255 ** as an example for your own code, please note that you shouldn't need
4258 memcached_quit(memc
);
4261 ** "bubba" should now be stored on all of our servers. We don't have an
4262 ** easy to use API to address each individual server, so I'll just iterate
4263 ** through a bunch of "master keys" and I should most likely hit all of the
4266 for (int x
= 'a'; x
<= 'z'; ++x
)
4268 char key
[2]= { [0]= (char)x
};
4271 char *val
= memcached_get_by_key(memc_clone
, key
, 1, "bubba", 5,
4273 test_true(rc
== MEMCACHED_SUCCESS
);
4274 test_true(val
!= NULL
);
4278 memcached_free(memc_clone
);
4280 return TEST_SUCCESS
;
4283 static test_return_t
replication_get_test(memcached_st
*memc
)
4285 memcached_return_t rc
;
4288 * Don't do the following in your code. I am abusing the internal details
4289 * within the library, and this is not a supported interface.
4290 * This is to verify correct behavior in the library
4292 for (uint32_t host
= 0; host
< memcached_server_count(memc
); ++host
)
4294 memcached_st
*memc_clone
= memcached_clone(NULL
, memc
);
4295 memcached_server_instance_st
*instance
=
4296 memcached_server_instance_fetch(memc_clone
, host
);
4300 for (int x
= 'a'; x
<= 'z'; ++x
)
4302 char key
[2]= { [0]= (char)x
};
4305 char *val
= memcached_get_by_key(memc_clone
, key
, 1, "bubba", 5,
4307 test_true(rc
== MEMCACHED_SUCCESS
);
4308 test_true(val
!= NULL
);
4312 memcached_free(memc_clone
);
4315 return TEST_SUCCESS
;
4318 static test_return_t
replication_mget_test(memcached_st
*memc
)
4320 memcached_return_t rc
;
4321 memcached_st
*memc_clone
= memcached_clone(NULL
, memc
);
4322 memcached_behavior_set(memc_clone
, MEMCACHED_BEHAVIOR_NUMBER_OF_REPLICAS
, 0);
4324 const char *keys
[]= { "bubba", "key1", "key2", "key3" };
4325 size_t len
[]= { 5, 4, 4, 4 };
4327 for (size_t x
= 0; x
< 4; ++x
)
4329 rc
= memcached_set(memc
, keys
[x
], len
[x
], "0", 1, 0, 0);
4330 test_true(rc
== MEMCACHED_SUCCESS
);
4334 ** We are using the quiet commands to store the replicas, so we need
4335 ** to ensure that all of them are processed before we can continue.
4336 ** In the test we go directly from storing the object to trying to
4337 ** receive the object from all of the different servers, so we
4338 ** could end up in a race condition (the memcached server hasn't yet
4339 ** processed the quiet command from the replication set when it process
4340 ** the request from the other client (created by the clone)). As a
4341 ** workaround for that we call memcached_quit to send the quit command
4342 ** to the server and wait for the response ;-) If you use the test code
4343 ** as an example for your own code, please note that you shouldn't need
4346 memcached_quit(memc
);
4349 * Don't do the following in your code. I am abusing the internal details
4350 * within the library, and this is not a supported interface.
4351 * This is to verify correct behavior in the library
4353 memcached_result_st result_obj
;
4354 for (uint32_t host
= 0; host
< memc_clone
->number_of_hosts
; host
++)
4356 memcached_st
*new_clone
= memcached_clone(NULL
, memc
);
4357 memcached_server_instance_st
*instance
=
4358 memcached_server_instance_fetch(new_clone
, host
);
4361 for (int x
= 'a'; x
<= 'z'; ++x
)
4363 char key
[2]= { [0]= (char)x
, [1]= 0 };
4365 rc
= memcached_mget_by_key(new_clone
, key
, 1, keys
, len
, 4);
4366 test_true(rc
== MEMCACHED_SUCCESS
);
4368 memcached_result_st
*results
= memcached_result_create(new_clone
, &result_obj
);
4372 while ((results
= memcached_fetch_result(new_clone
, &result_obj
, &rc
)) != NULL
)
4376 test_true(hits
== 4);
4377 memcached_result_free(&result_obj
);
4380 memcached_free(new_clone
);
4383 memcached_free(memc_clone
);
4385 return TEST_SUCCESS
;
4388 static test_return_t
replication_randomize_mget_test(memcached_st
*memc
)
4390 memcached_result_st result_obj
;
4391 memcached_return_t rc
;
4392 memcached_st
*memc_clone
= memcached_clone(NULL
, memc
);
4393 memcached_behavior_set(memc_clone
, MEMCACHED_BEHAVIOR_NUMBER_OF_REPLICAS
, 3);
4394 memcached_behavior_set(memc_clone
, MEMCACHED_BEHAVIOR_RANDOMIZE_REPLICA_READ
, 1);
4396 const char *keys
[]= { "key1", "key2", "key3", "key4", "key5", "key6", "key7" };
4397 size_t len
[]= { 4, 4, 4, 4, 4, 4, 4 };
4399 for (int x
=0; x
< 7; ++x
)
4401 rc
= memcached_set(memc
, keys
[x
], len
[x
], "1", 1, 0, 0);
4402 test_true(rc
== MEMCACHED_SUCCESS
);
4405 memcached_quit(memc
);
4407 for (size_t x
= 0; x
< 7; ++x
)
4409 const char key
[2]= { [0]= (const char)x
};
4411 rc
= memcached_mget_by_key(memc_clone
, key
, 1, keys
, len
, 7);
4412 test_true(rc
== MEMCACHED_SUCCESS
);
4414 memcached_result_st
*results
= memcached_result_create(memc_clone
, &result_obj
);
4418 while ((results
= memcached_fetch_result(memc_clone
, &result_obj
, &rc
)) != NULL
)
4422 test_true(hits
== 7);
4423 memcached_result_free(&result_obj
);
4425 memcached_free(memc_clone
);
4426 return TEST_SUCCESS
;
4429 static test_return_t
replication_delete_test(memcached_st
*memc
)
4431 memcached_return_t rc
;
4432 memcached_st
*memc_clone
= memcached_clone(NULL
, memc
);
4433 /* Delete the items from all of the servers except 1 */
4434 uint64_t repl
= memcached_behavior_get(memc
,
4435 MEMCACHED_BEHAVIOR_NUMBER_OF_REPLICAS
);
4436 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NUMBER_OF_REPLICAS
, --repl
);
4438 const char *keys
[]= { "bubba", "key1", "key2", "key3" };
4439 size_t len
[]= { 5, 4, 4, 4 };
4441 for (size_t x
= 0; x
< 4; ++x
)
4443 rc
= memcached_delete_by_key(memc
, keys
[0], len
[0], keys
[x
], len
[x
], 0);
4444 test_true(rc
== MEMCACHED_SUCCESS
);
4448 * Don't do the following in your code. I am abusing the internal details
4449 * within the library, and this is not a supported interface.
4450 * This is to verify correct behavior in the library
4452 uint32_t hash
= memcached_generate_hash(memc
, keys
[0], len
[0]);
4453 for (uint32_t x
= 0; x
< (repl
+ 1); ++x
)
4455 memcached_server_instance_st
*instance
=
4456 memcached_server_instance_fetch(memc_clone
, x
);
4459 if (++hash
== memc_clone
->number_of_hosts
)
4463 memcached_result_st result_obj
;
4464 for (uint32_t host
= 0; host
< memc_clone
->number_of_hosts
; ++host
)
4466 for (size_t x
= 'a'; x
<= 'z'; ++x
)
4468 const char key
[2]= { [0]= (const char)x
};
4470 rc
= memcached_mget_by_key(memc_clone
, key
, 1, keys
, len
, 4);
4471 test_true(rc
== MEMCACHED_SUCCESS
);
4473 memcached_result_st
*results
= memcached_result_create(memc_clone
, &result_obj
);
4477 while ((results
= memcached_fetch_result(memc_clone
, &result_obj
, &rc
)) != NULL
)
4481 test_true(hits
== 4);
4482 memcached_result_free(&result_obj
);
4485 memcached_free(memc_clone
);
4487 return TEST_SUCCESS
;
4490 static void increment_request_id(uint16_t *id
)
4493 if ((*id
& UDP_REQUEST_ID_THREAD_MASK
) != 0)
4497 static uint16_t *get_udp_request_ids(memcached_st
*memc
)
4499 uint16_t *ids
= malloc(sizeof(uint16_t) * memcached_server_count(memc
));
4500 assert(ids
!= NULL
);
4502 for (uint32_t x
= 0; x
< memcached_server_count(memc
); x
++)
4504 memcached_server_instance_st
*instance
=
4505 memcached_server_instance_fetch(memc
, x
);
4507 ids
[x
]= get_udp_datagram_request_id((struct udp_datagram_header_st
*) instance
->write_buffer
);
4513 static test_return_t
post_udp_op_check(memcached_st
*memc
, uint16_t *expected_req_ids
)
4515 memcached_server_st
*cur_server
= memcached_server_list(memc
);
4516 uint16_t *cur_req_ids
= get_udp_request_ids(memc
);
4518 for (size_t x
= 0; x
< memcached_server_count(memc
); x
++)
4520 test_true(cur_server
[x
].cursor_active
== 0);
4521 test_true(cur_req_ids
[x
] == expected_req_ids
[x
]);
4523 free(expected_req_ids
);
4526 return TEST_SUCCESS
;
4530 ** There is a little bit of a hack here, instead of removing
4531 ** the servers, I just set num host to 0 and them add then new udp servers
4533 static test_return_t
init_udp(memcached_st
*memc
)
4535 memcached_version(memc
);
4536 memcached_server_instance_st
*instance
=
4537 memcached_server_instance_fetch(memc
, 0);
4539 /* For the time being, only support udp test for >= 1.2.6 && < 1.3 */
4540 if (instance
->major_version
!= 1 || instance
->minor_version
!= 2
4541 || instance
->micro_version
< 6)
4542 return TEST_SKIPPED
;
4544 uint32_t num_hosts
= memcached_server_count(memc
);
4545 memcached_server_st servers
[num_hosts
];
4546 memcpy(servers
, memcached_server_list(memc
), sizeof(memcached_server_st
) * num_hosts
);
4547 for (uint32_t x
= 0; x
< num_hosts
; x
++)
4549 memcached_server_instance_st
*set_instance
=
4550 memcached_server_instance_fetch(memc
, x
);
4552 memcached_server_free(set_instance
);
4555 memc
->number_of_hosts
= 0;
4556 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_USE_UDP
, 1);
4557 for (uint32_t x
= 0; x
< num_hosts
; x
++)
4559 memcached_server_instance_st
*set_instance
=
4560 memcached_server_instance_fetch(memc
, x
);
4562 test_true(memcached_server_add_udp(memc
, servers
[x
].hostname
, servers
[x
].port
) == MEMCACHED_SUCCESS
);
4563 test_true(set_instance
->write_buffer_offset
== UDP_DATAGRAM_HEADER_LENGTH
);
4566 return TEST_SUCCESS
;
4569 static test_return_t
binary_init_udp(memcached_st
*memc
)
4571 test_return_t test_rc
;
4572 test_rc
= pre_binary(memc
);
4574 if (test_rc
!= TEST_SUCCESS
)
4577 return init_udp(memc
);
4580 /* Make sure that I cant add a tcp server to a udp client */
4581 static test_return_t
add_tcp_server_udp_client_test(memcached_st
*memc
)
4585 memcached_server_st server
;
4586 memcached_server_instance_st
*instance
=
4587 memcached_server_instance_fetch(memc
, 0);
4588 memcached_server_clone(&server
, &memc
->hosts
[0]);
4589 test_true(memcached_server_remove(&(memc
->hosts
[0])) == MEMCACHED_SUCCESS
);
4590 test_true(memcached_server_add(memc
, server
.hostname
, server
.port
) == MEMCACHED_INVALID_HOST_PROTOCOL
);
4592 return TEST_SUCCESS
;
4595 /* Make sure that I cant add a udp server to a tcp client */
4596 static test_return_t
add_udp_server_tcp_client_test(memcached_st
*memc
)
4600 memcached_server_st server
;
4601 memcached_server_instance_st
*instance
=
4602 memcached_server_instance_fetch(memc
, 0);
4603 memcached_server_clone(&server
, &memc
->hosts
[0]);
4604 test_true(memcached_server_remove(&(memc
->hosts
[0])) == MEMCACHED_SUCCESS
);
4606 memcached_st tcp_client
;
4607 memcached_create(&tcp_client
);
4608 test_true(memcached_server_add_udp(&tcp_client
, server
.hostname
, server
.port
) == MEMCACHED_INVALID_HOST_PROTOCOL
);
4611 return TEST_SUCCESS
;
4614 static test_return_t
set_udp_behavior_test(memcached_st
*memc
)
4617 memcached_quit(memc
);
4618 memc
->number_of_hosts
= 0;
4619 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_DISTRIBUTION
, memc
->distribution
);
4620 test_true(memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_USE_UDP
, 1) == MEMCACHED_SUCCESS
);
4621 test_true(memc
->flags
.use_udp
);
4622 test_true(memc
->flags
.no_reply
);
4624 test_true(memcached_server_count(memc
) == 0);
4626 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_USE_UDP
,0);
4627 test_true(! (memc
->flags
.use_udp
));
4628 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NOREPLY
,0);
4629 test_true(! (memc
->flags
.no_reply
));
4631 return TEST_SUCCESS
;
4634 static test_return_t
udp_set_test(memcached_st
*memc
)
4636 unsigned int num_iters
= 1025; //request id rolls over at 1024
4638 for (size_t x
= 0; x
< num_iters
;x
++)
4640 memcached_return_t rc
;
4641 const char *key
= "foo";
4642 const char *value
= "when we sanitize";
4643 uint16_t *expected_ids
= get_udp_request_ids(memc
);
4644 unsigned int server_key
= memcached_generate_hash(memc
, key
, strlen(key
));
4645 memcached_server_instance_st
*instance
=
4646 memcached_server_instance_fetch(memc
, server_key
);
4647 size_t init_offset
= instance
->write_buffer_offset
;
4649 rc
= memcached_set(memc
, key
, strlen(key
),
4650 value
, strlen(value
),
4651 (time_t)0, (uint32_t)0);
4652 test_true(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
);
4653 /** NB, the check below assumes that if new write_ptr is less than
4654 * the original write_ptr that we have flushed. For large payloads, this
4655 * maybe an invalid assumption, but for the small payload we have it is OK
4657 if (rc
== MEMCACHED_SUCCESS
||
4658 instance
->write_buffer_offset
< init_offset
)
4659 increment_request_id(&expected_ids
[server_key
]);
4661 if (rc
== MEMCACHED_SUCCESS
)
4663 test_true(instance
->write_buffer_offset
== UDP_DATAGRAM_HEADER_LENGTH
);
4667 test_true(instance
->write_buffer_offset
!= UDP_DATAGRAM_HEADER_LENGTH
);
4668 test_true(instance
->write_buffer_offset
<= MAX_UDP_DATAGRAM_LENGTH
);
4670 test_true(post_udp_op_check(memc
, expected_ids
) == TEST_SUCCESS
);
4672 return TEST_SUCCESS
;
4675 static test_return_t
udp_buffered_set_test(memcached_st
*memc
)
4677 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_BUFFER_REQUESTS
, 1);
4678 return udp_set_test(memc
);
4681 static test_return_t
udp_set_too_big_test(memcached_st
*memc
)
4683 memcached_return_t rc
;
4684 const char *key
= "bar";
4685 char value
[MAX_UDP_DATAGRAM_LENGTH
];
4686 uint16_t *expected_ids
= get_udp_request_ids(memc
);
4687 rc
= memcached_set(memc
, key
, strlen(key
),
4688 value
, MAX_UDP_DATAGRAM_LENGTH
,
4689 (time_t)0, (uint32_t)0);
4690 test_true(rc
== MEMCACHED_WRITE_FAILURE
);
4692 return post_udp_op_check(memc
,expected_ids
);
4695 static test_return_t
udp_delete_test(memcached_st
*memc
)
4697 unsigned int num_iters
= 1025; //request id rolls over at 1024
4699 for (size_t x
= 0; x
< num_iters
;x
++)
4701 memcached_return_t rc
;
4702 const char *key
= "foo";
4703 uint16_t *expected_ids
=get_udp_request_ids(memc
);
4704 unsigned int server_key
= memcached_generate_hash(memc
, key
, strlen(key
));
4705 memcached_server_instance_st
*instance
=
4706 memcached_server_instance_fetch(memc
, server_key
);
4707 size_t init_offset
= instance
->write_buffer_offset
;
4709 rc
= memcached_delete(memc
, key
, strlen(key
), 0);
4710 test_true(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
);
4712 if (rc
== MEMCACHED_SUCCESS
|| instance
->write_buffer_offset
< init_offset
)
4713 increment_request_id(&expected_ids
[server_key
]);
4714 if (rc
== MEMCACHED_SUCCESS
)
4716 test_true(instance
->write_buffer_offset
== UDP_DATAGRAM_HEADER_LENGTH
);
4720 test_true(instance
->write_buffer_offset
!= UDP_DATAGRAM_HEADER_LENGTH
);
4721 test_true(instance
->write_buffer_offset
<= MAX_UDP_DATAGRAM_LENGTH
);
4723 test_true(post_udp_op_check(memc
,expected_ids
) == TEST_SUCCESS
);
4725 return TEST_SUCCESS
;
4728 static test_return_t
udp_buffered_delete_test(memcached_st
*memc
)
4730 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_BUFFER_REQUESTS
, 1);
4731 return udp_delete_test(memc
);
4734 static test_return_t
udp_verbosity_test(memcached_st
*memc
)
4736 memcached_return_t rc
;
4737 uint16_t *expected_ids
= get_udp_request_ids(memc
);
4739 for (size_t x
= 0; x
< memcached_server_count(memc
); x
++)
4741 increment_request_id(&expected_ids
[x
]);
4744 rc
= memcached_verbosity(memc
,3);
4745 test_true(rc
== MEMCACHED_SUCCESS
);
4746 return post_udp_op_check(memc
,expected_ids
);
4749 static test_return_t
udp_quit_test(memcached_st
*memc
)
4751 uint16_t *expected_ids
= get_udp_request_ids(memc
);
4752 memcached_quit(memc
);
4753 return post_udp_op_check(memc
, expected_ids
);
4756 static test_return_t
udp_flush_test(memcached_st
*memc
)
4758 memcached_return_t rc
;
4759 uint16_t *expected_ids
= get_udp_request_ids(memc
);
4761 for (size_t x
= 0; x
< memcached_server_count(memc
); x
++)
4763 increment_request_id(&expected_ids
[x
]);
4766 rc
= memcached_flush(memc
,0);
4767 test_true(rc
== MEMCACHED_SUCCESS
);
4768 return post_udp_op_check(memc
,expected_ids
);
4771 static test_return_t
udp_incr_test(memcached_st
*memc
)
4773 memcached_return_t rc
;
4774 const char *key
= "incr";
4775 const char *value
= "1";
4776 rc
= memcached_set(memc
, key
, strlen(key
),
4777 value
, strlen(value
),
4778 (time_t)0, (uint32_t)0);
4780 test_true(rc
== MEMCACHED_SUCCESS
);
4781 uint16_t *expected_ids
= get_udp_request_ids(memc
);
4782 unsigned int server_key
= memcached_generate_hash(memc
, key
, strlen(key
));
4783 increment_request_id(&expected_ids
[server_key
]);
4785 rc
= memcached_increment(memc
, key
, strlen(key
), 1, &newvalue
);
4786 test_true(rc
== MEMCACHED_SUCCESS
);
4787 return post_udp_op_check(memc
, expected_ids
);
4790 static test_return_t
udp_decr_test(memcached_st
*memc
)
4792 memcached_return_t rc
;
4793 const char *key
= "decr";
4794 const char *value
= "1";
4795 rc
= memcached_set(memc
, key
, strlen(key
),
4796 value
, strlen(value
),
4797 (time_t)0, (uint32_t)0);
4799 test_true(rc
== MEMCACHED_SUCCESS
);
4800 uint16_t *expected_ids
= get_udp_request_ids(memc
);
4801 unsigned int server_key
= memcached_generate_hash(memc
, key
, strlen(key
));
4802 increment_request_id(&expected_ids
[server_key
]);
4804 rc
= memcached_decrement(memc
, key
, strlen(key
), 1, &newvalue
);
4805 test_true(rc
== MEMCACHED_SUCCESS
);
4806 return post_udp_op_check(memc
, expected_ids
);
4810 static test_return_t
udp_stat_test(memcached_st
*memc
)
4812 memcached_stat_st
* rv
= NULL
;
4813 memcached_return_t rc
;
4815 uint16_t *expected_ids
= get_udp_request_ids(memc
);
4816 rv
= memcached_stat(memc
, args
, &rc
);
4818 test_true(rc
== MEMCACHED_NOT_SUPPORTED
);
4819 return post_udp_op_check(memc
, expected_ids
);
4822 static test_return_t
udp_version_test(memcached_st
*memc
)
4824 memcached_return_t rc
;
4825 uint16_t *expected_ids
= get_udp_request_ids(memc
);
4826 rc
= memcached_version(memc
);
4827 test_true(rc
== MEMCACHED_NOT_SUPPORTED
);
4828 return post_udp_op_check(memc
, expected_ids
);
4831 static test_return_t
udp_get_test(memcached_st
*memc
)
4833 memcached_return_t rc
;
4834 const char *key
= "foo";
4836 uint16_t *expected_ids
= get_udp_request_ids(memc
);
4837 char *val
= memcached_get(memc
, key
, strlen(key
), &vlen
, (uint32_t)0, &rc
);
4838 test_true(rc
== MEMCACHED_NOT_SUPPORTED
);
4839 test_true(val
== NULL
);
4840 return post_udp_op_check(memc
, expected_ids
);
4843 static test_return_t
udp_mixed_io_test(memcached_st
*memc
)
4846 test_st mixed_io_ops
[] ={
4848 (test_callback_fn
)udp_set_test
},
4849 {"udp_set_too_big_test", 0,
4850 (test_callback_fn
)udp_set_too_big_test
},
4851 {"udp_delete_test", 0,
4852 (test_callback_fn
)udp_delete_test
},
4853 {"udp_verbosity_test", 0,
4854 (test_callback_fn
)udp_verbosity_test
},
4855 {"udp_quit_test", 0,
4856 (test_callback_fn
)udp_quit_test
},
4857 {"udp_flush_test", 0,
4858 (test_callback_fn
)udp_flush_test
},
4859 {"udp_incr_test", 0,
4860 (test_callback_fn
)udp_incr_test
},
4861 {"udp_decr_test", 0,
4862 (test_callback_fn
)udp_decr_test
},
4863 {"udp_version_test", 0,
4864 (test_callback_fn
)udp_version_test
}
4866 for (size_t x
= 0; x
< 500; x
++)
4868 current_op
= mixed_io_ops
[random() % 9];
4869 test_true(current_op
.test_fn(memc
) == TEST_SUCCESS
);
4871 return TEST_SUCCESS
;
4875 static test_return_t
hash_sanity_test (memcached_st
*memc
)
4879 assert(MEMCACHED_HASH_DEFAULT
== MEMCACHED_HASH_DEFAULT
);
4880 assert(MEMCACHED_HASH_MD5
== MEMCACHED_HASH_MD5
);
4881 assert(MEMCACHED_HASH_CRC
== MEMCACHED_HASH_CRC
);
4882 assert(MEMCACHED_HASH_FNV1_64
== MEMCACHED_HASH_FNV1_64
);
4883 assert(MEMCACHED_HASH_FNV1A_64
== MEMCACHED_HASH_FNV1A_64
);
4884 assert(MEMCACHED_HASH_FNV1_32
== MEMCACHED_HASH_FNV1_32
);
4885 assert(MEMCACHED_HASH_FNV1A_32
== MEMCACHED_HASH_FNV1A_32
);
4886 #ifdef HAVE_HSIEH_HASH
4887 assert(MEMCACHED_HASH_HSIEH
== MEMCACHED_HASH_HSIEH
);
4889 assert(MEMCACHED_HASH_MURMUR
== MEMCACHED_HASH_MURMUR
);
4890 assert(MEMCACHED_HASH_JENKINS
== MEMCACHED_HASH_JENKINS
);
4891 assert(MEMCACHED_HASH_MAX
== MEMCACHED_HASH_MAX
);
4893 return TEST_SUCCESS
;
4897 static test_return_t
hsieh_avaibility_test (memcached_st
*memc
)
4899 memcached_return_t expected_rc
= MEMCACHED_FAILURE
;
4900 #ifdef HAVE_HSIEH_HASH
4901 expected_rc
= MEMCACHED_SUCCESS
;
4903 memcached_return_t rc
= memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_HASH
,
4904 (uint64_t)MEMCACHED_HASH_HSIEH
);
4905 test_true(rc
== expected_rc
);
4907 return TEST_SUCCESS
;
4910 static test_return_t
md5_run (memcached_st
*memc
__attribute__((unused
)))
4915 for (ptr
= list_to_hash
, x
= 0; *ptr
; ptr
++, x
++)
4919 hash_val
= memcached_generate_hash_value(*ptr
, strlen(*ptr
), MEMCACHED_HASH_MD5
);
4920 test_true(md5_values
[x
] == hash_val
);
4923 return TEST_SUCCESS
;
4926 static test_return_t
crc_run (memcached_st
*memc
__attribute__((unused
)))
4931 for (ptr
= list_to_hash
, x
= 0; *ptr
; ptr
++, x
++)
4935 hash_val
= memcached_generate_hash_value(*ptr
, strlen(*ptr
), MEMCACHED_HASH_CRC
);
4936 test_true(crc_values
[x
] == hash_val
);
4939 return TEST_SUCCESS
;
4942 static test_return_t
fnv1_64_run (memcached_st
*memc
__attribute__((unused
)))
4947 for (ptr
= list_to_hash
, x
= 0; *ptr
; ptr
++, x
++)
4951 hash_val
= memcached_generate_hash_value(*ptr
, strlen(*ptr
), MEMCACHED_HASH_FNV1_64
);
4952 test_true(fnv1_64_values
[x
] == hash_val
);
4955 return TEST_SUCCESS
;
4958 static test_return_t
fnv1a_64_run (memcached_st
*memc
__attribute__((unused
)))
4963 for (ptr
= list_to_hash
, x
= 0; *ptr
; ptr
++, x
++)
4967 hash_val
= memcached_generate_hash_value(*ptr
, strlen(*ptr
), MEMCACHED_HASH_FNV1A_64
);
4968 test_true(fnv1a_64_values
[x
] == hash_val
);
4971 return TEST_SUCCESS
;
4974 static test_return_t
fnv1_32_run (memcached_st
*memc
__attribute__((unused
)))
4980 for (ptr
= list_to_hash
, x
= 0; *ptr
; ptr
++, x
++)
4984 hash_val
= memcached_generate_hash_value(*ptr
, strlen(*ptr
), MEMCACHED_HASH_FNV1_32
);
4985 test_true(fnv1_32_values
[x
] == hash_val
);
4988 return TEST_SUCCESS
;
4991 static test_return_t
fnv1a_32_run (memcached_st
*memc
__attribute__((unused
)))
4996 for (ptr
= list_to_hash
, x
= 0; *ptr
; ptr
++, x
++)
5000 hash_val
= memcached_generate_hash_value(*ptr
, strlen(*ptr
), MEMCACHED_HASH_FNV1A_32
);
5001 test_true(fnv1a_32_values
[x
] == hash_val
);
5004 return TEST_SUCCESS
;
5007 static test_return_t
hsieh_run (memcached_st
*memc
__attribute__((unused
)))
5012 for (ptr
= list_to_hash
, x
= 0; *ptr
; ptr
++, x
++)
5016 hash_val
= memcached_generate_hash_value(*ptr
, strlen(*ptr
), MEMCACHED_HASH_HSIEH
);
5017 test_true(hsieh_values
[x
] == hash_val
);
5020 return TEST_SUCCESS
;
5023 static test_return_t
murmur_run (memcached_st
*memc
__attribute__((unused
)))
5026 return TEST_SKIPPED
;
5031 for (ptr
= list_to_hash
, x
= 0; *ptr
; ptr
++, x
++)
5035 hash_val
= memcached_generate_hash_value(*ptr
, strlen(*ptr
), MEMCACHED_HASH_MURMUR
);
5036 test_true(murmur_values
[x
] == hash_val
);
5039 return TEST_SUCCESS
;
5043 static test_return_t
jenkins_run (memcached_st
*memc
__attribute__((unused
)))
5049 for (ptr
= list_to_hash
, x
= 0; *ptr
; ptr
++, x
++)
5053 hash_val
= memcached_generate_hash_value(*ptr
, strlen(*ptr
), MEMCACHED_HASH_JENKINS
);
5054 test_true(jenkins_values
[x
] == hash_val
);
5057 return TEST_SUCCESS
;
5061 static test_return_t
ketama_compatibility_libmemcached(memcached_st
*trash
)
5063 memcached_return_t rc
;
5066 memcached_server_st
*server_pool
;
5071 memc
= memcached_create(NULL
);
5074 rc
= memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_KETAMA_WEIGHTED
, 1);
5075 test_true(rc
== MEMCACHED_SUCCESS
);
5077 value
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_KETAMA_WEIGHTED
);
5078 test_true(value
== 1);
5080 test_true(memcached_behavior_set_distribution(memc
, MEMCACHED_DISTRIBUTION_CONSISTENT_KETAMA
) == MEMCACHED_SUCCESS
);
5081 test_true(memcached_behavior_get_distribution(memc
) == MEMCACHED_DISTRIBUTION_CONSISTENT_KETAMA
);
5084 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");
5085 memcached_server_push(memc
, server_pool
);
5087 /* verify that the server list was parsed okay. */
5088 test_true(memcached_server_count(memc
) == 8);
5089 test_strcmp(server_pool
[0].hostname
, "10.0.1.1");
5090 test_true(server_pool
[0].port
== 11211);
5091 test_true(server_pool
[0].weight
== 600);
5092 test_strcmp(server_pool
[2].hostname
, "10.0.1.3");
5093 test_true(server_pool
[2].port
== 11211);
5094 test_true(server_pool
[2].weight
== 200);
5095 test_strcmp(server_pool
[7].hostname
, "10.0.1.8");
5096 test_true(server_pool
[7].port
== 11211);
5097 test_true(server_pool
[7].weight
== 100);
5099 /* VDEAAAAA hashes to fffcd1b5, after the last continuum point, and lets
5100 * us test the boundary wraparound.
5102 test_true(memcached_generate_hash(memc
, (char *)"VDEAAAAA", 8) == memc
->continuum
[0].index
);
5104 /* verify the standard ketama set. */
5105 for (x
= 0; x
< 99; x
++)
5107 uint32_t server_idx
= memcached_generate_hash(memc
, ketama_test_cases
[x
].key
, strlen(ketama_test_cases
[x
].key
));
5108 memcached_server_instance_st
*instance
=
5109 memcached_server_instance_fetch(memc
, server_idx
);
5110 char *hostname
= instance
->hostname
;
5112 test_strcmp(hostname
, ketama_test_cases
[x
].server
);
5115 memcached_server_list_free(server_pool
);
5116 memcached_free(memc
);
5118 return TEST_SUCCESS
;
5121 static test_return_t
ketama_compatibility_spymemcached(memcached_st
*trash
)
5123 memcached_return_t rc
;
5126 memcached_server_st
*server_pool
;
5131 memc
= memcached_create(NULL
);
5134 rc
= memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_KETAMA_WEIGHTED
, 1);
5135 test_true(rc
== MEMCACHED_SUCCESS
);
5137 value
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_KETAMA_WEIGHTED
);
5138 test_true(value
== 1);
5140 test_true(memcached_behavior_set_distribution(memc
, MEMCACHED_DISTRIBUTION_CONSISTENT_KETAMA_SPY
) == MEMCACHED_SUCCESS
);
5141 test_true(memcached_behavior_get_distribution(memc
) == MEMCACHED_DISTRIBUTION_CONSISTENT_KETAMA_SPY
);
5143 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");
5144 memcached_server_push(memc
, server_pool
);
5146 /* verify that the server list was parsed okay. */
5147 test_true(memcached_server_count(memc
) == 8);
5148 test_strcmp(server_pool
[0].hostname
, "10.0.1.1");
5149 test_true(server_pool
[0].port
== 11211);
5150 test_true(server_pool
[0].weight
== 600);
5151 test_strcmp(server_pool
[2].hostname
, "10.0.1.3");
5152 test_true(server_pool
[2].port
== 11211);
5153 test_true(server_pool
[2].weight
== 200);
5154 test_strcmp(server_pool
[7].hostname
, "10.0.1.8");
5155 test_true(server_pool
[7].port
== 11211);
5156 test_true(server_pool
[7].weight
== 100);
5158 /* VDEAAAAA hashes to fffcd1b5, after the last continuum point, and lets
5159 * us test the boundary wraparound.
5161 test_true(memcached_generate_hash(memc
, (char *)"VDEAAAAA", 8) == memc
->continuum
[0].index
);
5163 /* verify the standard ketama set. */
5164 for (x
= 0; x
< 99; x
++)
5166 uint32_t server_idx
= memcached_generate_hash(memc
, ketama_test_cases_spy
[x
].key
, strlen(ketama_test_cases_spy
[x
].key
));
5167 memcached_server_instance_st
*instance
=
5168 memcached_server_instance_fetch(memc
, server_idx
);
5169 char *hostname
= instance
->hostname
;
5170 test_strcmp(hostname
, ketama_test_cases_spy
[x
].server
);
5173 memcached_server_list_free(server_pool
);
5174 memcached_free(memc
);
5176 return TEST_SUCCESS
;
5179 static test_return_t
regression_bug_434484(memcached_st
*memc
)
5181 test_return_t test_rc
;
5182 test_rc
= pre_binary(memc
);
5184 if (test_rc
!= TEST_SUCCESS
)
5187 memcached_return_t ret
;
5188 const char *key
= "regression_bug_434484";
5189 size_t keylen
= strlen(key
);
5191 ret
= memcached_append(memc
, key
, keylen
, key
, keylen
, 0, 0);
5192 test_true(ret
== MEMCACHED_NOTSTORED
);
5194 size_t size
= 2048 * 1024;
5195 void *data
= calloc(1, size
);
5196 test_true(data
!= NULL
);
5197 ret
= memcached_set(memc
, key
, keylen
, data
, size
, 0, 0);
5198 test_true(ret
== MEMCACHED_E2BIG
);
5201 return TEST_SUCCESS
;
5204 static test_return_t
regression_bug_434843(memcached_st
*memc
)
5206 test_return_t test_rc
;
5207 test_rc
= pre_binary(memc
);
5209 if (test_rc
!= TEST_SUCCESS
)
5212 memcached_return_t rc
;
5214 memcached_execute_fn callbacks
[1]= { [0]= &callback_counter
};
5217 * I only want to hit only _one_ server so I know the number of requests I'm
5218 * sending in the pipleine to the server. Let's try to do a multiget of
5219 * 1024 (that should satisfy most users don't you think?). Future versions
5220 * will include a mget_execute function call if you need a higher number.
5222 uint32_t number_of_hosts
= memcached_server_count(memc
);
5223 memc
->number_of_hosts
= 1;
5224 const size_t max_keys
= 1024;
5225 char **keys
= calloc(max_keys
, sizeof(char*));
5226 size_t *key_length
=calloc(max_keys
, sizeof(size_t));
5228 for (size_t x
= 0; x
< max_keys
; ++x
)
5232 key_length
[x
]= (size_t)snprintf(k
, sizeof(k
), "0200%zu", x
);
5234 test_true(keys
[x
] != NULL
);
5238 * Run two times.. the first time we should have 100% cache miss,
5239 * and the second time we should have 100% cache hits
5241 for (size_t y
= 0; y
< 2; y
++)
5243 rc
= memcached_mget(memc
, (const char**)keys
, key_length
, max_keys
);
5244 test_true(rc
== MEMCACHED_SUCCESS
);
5245 rc
= memcached_fetch_execute(memc
, callbacks
, (void *)&counter
, 1);
5249 /* The first iteration should give me a 100% cache miss. verify that*/
5250 char blob
[1024]= { 0 };
5252 test_true(counter
== 0);
5254 for (size_t x
= 0; x
< max_keys
; ++x
)
5256 rc
= memcached_add(memc
, keys
[x
], key_length
[x
],
5257 blob
, sizeof(blob
), 0, 0);
5258 test_true(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
);
5263 /* Verify that we received all of the key/value pairs */
5264 test_true(counter
== max_keys
);
5268 /* Release allocated resources */
5269 for (size_t x
= 0; x
< max_keys
; ++x
)
5276 memc
->number_of_hosts
= number_of_hosts
;
5278 return TEST_SUCCESS
;
5281 static test_return_t
regression_bug_434843_buffered(memcached_st
*memc
)
5283 memcached_return_t rc
;
5284 rc
= memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_BUFFER_REQUESTS
, 1);
5285 test_true(rc
== MEMCACHED_SUCCESS
);
5287 return regression_bug_434843(memc
);
5290 static test_return_t
regression_bug_421108(memcached_st
*memc
)
5292 memcached_return_t rc
;
5293 memcached_stat_st
*memc_stat
= memcached_stat(memc
, NULL
, &rc
);
5294 test_true(rc
== MEMCACHED_SUCCESS
);
5296 char *bytes
= memcached_stat_get_value(memc
, memc_stat
, "bytes", &rc
);
5297 test_true(rc
== MEMCACHED_SUCCESS
);
5298 test_true(bytes
!= NULL
);
5299 char *bytes_read
= memcached_stat_get_value(memc
, memc_stat
,
5301 test_true(rc
== MEMCACHED_SUCCESS
);
5302 test_true(bytes_read
!= NULL
);
5304 char *bytes_written
= memcached_stat_get_value(memc
, memc_stat
,
5305 "bytes_written", &rc
);
5306 test_true(rc
== MEMCACHED_SUCCESS
);
5307 test_true(bytes_written
!= NULL
);
5309 test_true(strcmp(bytes
, bytes_read
) != 0);
5310 test_true(strcmp(bytes
, bytes_written
) != 0);
5312 /* Release allocated resources */
5315 free(bytes_written
);
5316 memcached_stat_free(NULL
, memc_stat
);
5318 return TEST_SUCCESS
;
5322 * The test case isn't obvious so I should probably document why
5323 * it works the way it does. Bug 442914 was caused by a bug
5324 * in the logic in memcached_purge (it did not handle the case
5325 * where the number of bytes sent was equal to the watermark).
5326 * In this test case, create messages so that we hit that case
5327 * and then disable noreply mode and issue a new command to
5328 * verify that it isn't stuck. If we change the format for the
5329 * delete command or the watermarks, we need to update this
5332 static test_return_t
regression_bug_442914(memcached_st
*memc
)
5334 memcached_return_t rc
;
5335 rc
= memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NOREPLY
, 1);
5336 test_true(rc
== MEMCACHED_SUCCESS
);
5337 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_TCP_NODELAY
, 1);
5339 uint32_t number_of_hosts
= memcached_server_count(memc
);
5340 memc
->number_of_hosts
= 1;
5345 for (uint32_t x
= 0; x
< 250; ++x
)
5347 len
= (size_t)snprintf(k
, sizeof(k
), "%0250u", x
);
5348 rc
= memcached_delete(memc
, k
, len
, 0);
5349 test_true(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
);
5352 (void)snprintf(k
, sizeof(k
), "%037u", 251U);
5355 rc
= memcached_delete(memc
, k
, len
, 0);
5356 test_true(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
);
5358 rc
= memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NOREPLY
, 0);
5359 test_true(rc
== MEMCACHED_SUCCESS
);
5360 rc
= memcached_delete(memc
, k
, len
, 0);
5361 test_true(rc
== MEMCACHED_NOTFOUND
);
5363 memc
->number_of_hosts
= number_of_hosts
;
5365 return TEST_SUCCESS
;
5368 static test_return_t
regression_bug_447342(memcached_st
*memc
)
5370 memcached_server_instance_st
*instance_one
;
5371 memcached_server_instance_st
*instance_two
;
5373 if (memcached_server_count(memc
) < 3 || pre_replication(memc
) != MEMCACHED_SUCCESS
)
5374 return TEST_SKIPPED
;
5376 memcached_return_t rc
;
5378 rc
= memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NUMBER_OF_REPLICAS
, 2);
5379 test_true(rc
== MEMCACHED_SUCCESS
);
5381 const size_t max_keys
= 100;
5382 char **keys
= calloc(max_keys
, sizeof(char*));
5383 size_t *key_length
= calloc(max_keys
, sizeof(size_t));
5385 for (size_t x
= 0; x
< max_keys
; ++x
)
5389 key_length
[x
]= (size_t)snprintf(k
, sizeof(k
), "0200%zu", x
);
5391 test_true(keys
[x
] != NULL
);
5392 rc
= memcached_set(memc
, k
, key_length
[x
], k
, key_length
[x
], 0, 0);
5393 test_true(rc
== MEMCACHED_SUCCESS
);
5397 ** We are using the quiet commands to store the replicas, so we need
5398 ** to ensure that all of them are processed before we can continue.
5399 ** In the test we go directly from storing the object to trying to
5400 ** receive the object from all of the different servers, so we
5401 ** could end up in a race condition (the memcached server hasn't yet
5402 ** processed the quiet command from the replication set when it process
5403 ** the request from the other client (created by the clone)). As a
5404 ** workaround for that we call memcached_quit to send the quit command
5405 ** to the server and wait for the response ;-) If you use the test code
5406 ** as an example for your own code, please note that you shouldn't need
5409 memcached_quit(memc
);
5411 /* Verify that all messages are stored, and we didn't stuff too much
5414 rc
= memcached_mget(memc
, (const char* const *)keys
, key_length
, max_keys
);
5415 test_true(rc
== MEMCACHED_SUCCESS
);
5418 memcached_execute_fn callbacks
[1]= { [0]= &callback_counter
};
5419 rc
= memcached_fetch_execute(memc
, callbacks
, (void *)&counter
, 1);
5420 /* Verify that we received all of the key/value pairs */
5421 test_true(counter
== max_keys
);
5423 memcached_quit(memc
);
5425 * Don't do the following in your code. I am abusing the internal details
5426 * within the library, and this is not a supported interface.
5427 * This is to verify correct behavior in the library. Fake that two servers
5430 instance_one
= memcached_server_instance_fetch(memc
, 0);
5431 instance_two
= memcached_server_instance_fetch(memc
, 2);
5432 in_port_t port0
= instance_one
->port
;
5433 in_port_t port2
= instance_two
->port
;
5435 instance_one
->port
= 0;
5436 instance_two
->port
= 0;
5438 rc
= memcached_mget(memc
, (const char* const *)keys
, key_length
, max_keys
);
5439 test_true(rc
== MEMCACHED_SUCCESS
);
5442 rc
= memcached_fetch_execute(memc
, callbacks
, (void *)&counter
, 1);
5443 test_true(counter
== (unsigned int)max_keys
);
5445 /* restore the memc handle */
5446 instance_one
->port
= port0
;
5447 instance_two
->port
= port2
;
5449 memcached_quit(memc
);
5451 /* Remove half of the objects */
5452 for (size_t x
= 0; x
< max_keys
; ++x
)
5456 rc
= memcached_delete(memc
, keys
[x
], key_length
[x
], 0);
5457 test_true(rc
== MEMCACHED_SUCCESS
);
5461 memcached_quit(memc
);
5462 instance_one
->port
= 0;
5463 instance_two
->port
= 0;
5465 /* now retry the command, this time we should have cache misses */
5466 rc
= memcached_mget(memc
, (const char* const *)keys
, key_length
, max_keys
);
5467 test_true(rc
== MEMCACHED_SUCCESS
);
5470 rc
= memcached_fetch_execute(memc
, callbacks
, (void *)&counter
, 1);
5471 test_true(counter
== (unsigned int)(max_keys
>> 1));
5473 /* Release allocated resources */
5474 for (size_t x
= 0; x
< max_keys
; ++x
)
5481 /* restore the memc handle */
5482 instance_one
->port
= port0
;
5483 instance_two
->port
= port2
;
5485 return TEST_SUCCESS
;
5488 static test_return_t
regression_bug_463297(memcached_st
*memc
)
5490 memcached_st
*memc_clone
= memcached_clone(NULL
, memc
);
5491 test_true(memc_clone
!= NULL
);
5492 test_true(memcached_version(memc_clone
) == MEMCACHED_SUCCESS
);
5494 memcached_server_instance_st
*instance
=
5495 memcached_server_instance_fetch(memc_clone
, 0);
5497 if (instance
->major_version
> 1 ||
5498 (instance
->major_version
== 1 &&
5499 instance
->minor_version
> 2))
5501 /* Binary protocol doesn't support deferred delete */
5502 memcached_st
*bin_clone
= memcached_clone(NULL
, memc
);
5503 test_true(bin_clone
!= NULL
);
5504 test_true(memcached_behavior_set(bin_clone
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
, 1) == MEMCACHED_SUCCESS
);
5505 test_true(memcached_delete(bin_clone
, "foo", 3, 1) == MEMCACHED_INVALID_ARGUMENTS
);
5506 memcached_free(bin_clone
);
5508 memcached_quit(memc_clone
);
5510 /* If we know the server version, deferred delete should fail
5511 * with invalid arguments */
5512 test_true(memcached_delete(memc_clone
, "foo", 3, 1) == MEMCACHED_INVALID_ARGUMENTS
);
5514 /* If we don't know the server version, we should get a protocol error */
5515 memcached_return_t rc
= memcached_delete(memc
, "foo", 3, 1);
5517 /* but there is a bug in some of the memcached servers (1.4) that treats
5518 * the counter as noreply so it doesn't send the proper error message
5520 test_true(rc
== MEMCACHED_PROTOCOL_ERROR
|| rc
== MEMCACHED_NOTFOUND
|| rc
== MEMCACHED_CLIENT_ERROR
);
5522 /* And buffered mode should be disabled and we should get protocol error */
5523 test_true(memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_BUFFER_REQUESTS
, 1) == MEMCACHED_SUCCESS
);
5524 rc
= memcached_delete(memc
, "foo", 3, 1);
5525 test_true(rc
== MEMCACHED_PROTOCOL_ERROR
|| rc
== MEMCACHED_NOTFOUND
|| rc
== MEMCACHED_CLIENT_ERROR
);
5527 /* Same goes for noreply... */
5528 test_true(memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NOREPLY
, 1) == MEMCACHED_SUCCESS
);
5529 rc
= memcached_delete(memc
, "foo", 3, 1);
5530 test_true(rc
== MEMCACHED_PROTOCOL_ERROR
|| rc
== MEMCACHED_NOTFOUND
|| rc
== MEMCACHED_CLIENT_ERROR
);
5532 /* but a normal request should go through (and be buffered) */
5533 test_true((rc
= memcached_delete(memc
, "foo", 3, 0)) == MEMCACHED_BUFFERED
);
5534 test_true(memcached_flush_buffers(memc
) == MEMCACHED_SUCCESS
);
5536 test_true(memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_BUFFER_REQUESTS
, 0) == MEMCACHED_SUCCESS
);
5537 /* unbuffered noreply should be success */
5538 test_true(memcached_delete(memc
, "foo", 3, 0) == MEMCACHED_SUCCESS
);
5539 /* unbuffered with reply should be not found... */
5540 test_true(memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NOREPLY
, 0) == MEMCACHED_SUCCESS
);
5541 test_true(memcached_delete(memc
, "foo", 3, 0) == MEMCACHED_NOTFOUND
);
5544 memcached_free(memc_clone
);
5545 return TEST_SUCCESS
;
5549 /* Test memcached_server_get_last_disconnect
5550 * For a working server set, shall be NULL
5551 * For a set of non existing server, shall not be NULL
5553 static test_return_t
test_get_last_disconnect(memcached_st
*memc
)
5555 memcached_return_t rc
;
5556 memcached_server_st
*disconnected_server
;
5558 /* With the working set of server */
5559 const char *key
= "marmotte";
5560 const char *value
= "milka";
5562 rc
= memcached_set(memc
, key
, strlen(key
),
5563 value
, strlen(value
),
5564 (time_t)0, (uint32_t)0);
5565 test_true(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
);
5567 disconnected_server
= memcached_server_get_last_disconnect(memc
);
5568 test_true(disconnected_server
== NULL
);
5570 /* With a non existing server */
5572 memcached_server_st
*servers
;
5574 const char *server_list
= "localhost:9";
5576 servers
= memcached_servers_parse(server_list
);
5578 mine
= memcached_create(NULL
);
5579 rc
= memcached_server_push(mine
, servers
);
5580 test_true(rc
== MEMCACHED_SUCCESS
);
5581 memcached_server_list_free(servers
);
5584 rc
= memcached_set(mine
, key
, strlen(key
),
5585 value
, strlen(value
),
5586 (time_t)0, (uint32_t)0);
5587 test_true(rc
!= MEMCACHED_SUCCESS
);
5589 disconnected_server
= memcached_server_get_last_disconnect(mine
);
5590 test_true(disconnected_server
!= NULL
);
5591 test_true(disconnected_server
->port
== 9);
5592 test_true(strncmp(disconnected_server
->hostname
,"localhost",9) == 0);
5594 memcached_quit(mine
);
5595 memcached_free(mine
);
5597 return TEST_SUCCESS
;
5601 * This test ensures that the failure counter isn't incremented during
5602 * normal termination of the memcached instance.
5604 static test_return_t
wrong_failure_counter_test(memcached_st
*memc
)
5606 memcached_return_t rc
;
5607 memcached_server_instance_st
*instance
;
5609 /* Set value to force connection to the server */
5610 const char *key
= "marmotte";
5611 const char *value
= "milka";
5614 * Please note that I'm abusing the internal structures in libmemcached
5615 * in a non-portable way and you shouldn't be doing this. I'm only
5616 * doing this in order to verify that the library works the way it should
5618 uint32_t number_of_hosts
= memcached_server_count(memc
);
5619 memc
->number_of_hosts
= 1;
5621 /* Ensure that we are connected to the server by setting a value */
5622 rc
= memcached_set(memc
, key
, strlen(key
),
5623 value
, strlen(value
),
5624 (time_t)0, (uint32_t)0);
5625 test_true(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
);
5628 instance
= memcached_server_instance_fetch(memc
, 0);
5629 /* The test is to see that the memcached_quit doesn't increase the
5630 * the server failure conter, so let's ensure that it is zero
5631 * before sending quit
5633 instance
->server_failure_counter
= 0;
5635 memcached_quit(memc
);
5637 /* Verify that it memcached_quit didn't increment the failure counter
5638 * Please note that this isn't bullet proof, because an error could
5641 test_true(instance
->server_failure_counter
== 0);
5643 /* restore the instance */
5644 memc
->number_of_hosts
= number_of_hosts
;
5646 return TEST_SUCCESS
;
5653 * Test that ensures mget_execute does not end into recursive calls that finally fails
5655 static test_return_t
regression_bug_490486(memcached_st
*memc
)
5657 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
, 1);
5658 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NO_BLOCK
, 1);
5659 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_POLL_TIMEOUT
, 1000);
5660 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_SERVER_FAILURE_LIMIT
, 1);
5661 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_RETRY_TIMEOUT
, 3600);
5664 * I only want to hit _one_ server so I know the number of requests I'm
5665 * sending in the pipeline.
5667 uint32_t number_of_hosts
= memc
->number_of_hosts
;
5668 memc
->number_of_hosts
= 1;
5669 size_t max_keys
= 20480;
5672 char **keys
= calloc(max_keys
, sizeof(char*));
5673 size_t *key_length
=calloc(max_keys
, sizeof(size_t));
5675 /* First add all of the items.. */
5676 char blob
[1024]= { 0 };
5677 memcached_return rc
;
5678 for (size_t x
= 0; x
< max_keys
; ++x
)
5681 key_length
[x
]= (size_t)snprintf(k
, sizeof(k
), "0200%zu", x
);
5683 assert(keys
[x
] != NULL
);
5684 rc
= memcached_set(memc
, keys
[x
], key_length
[x
], blob
, sizeof(blob
), 0, 0);
5685 assert(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
);
5688 /* Try to get all of them with a large multiget */
5690 memcached_execute_function callbacks
[1]= { [0]= &callback_counter
};
5691 rc
= memcached_mget_execute(memc
, (const char**)keys
, key_length
,
5692 (size_t)max_keys
, callbacks
, &counter
, 1);
5694 assert(rc
== MEMCACHED_SUCCESS
);
5695 char* the_value
= NULL
;
5696 char the_key
[MEMCACHED_MAX_KEY
];
5697 size_t the_key_length
;
5698 size_t the_value_length
;
5702 the_value
= memcached_fetch(memc
, the_key
, &the_key_length
, &the_value_length
, &the_flags
, &rc
);
5704 if ((the_value
!= NULL
) && (rc
== MEMCACHED_SUCCESS
))
5710 } while ( (the_value
!= NULL
) && (rc
== MEMCACHED_SUCCESS
));
5713 assert(rc
== MEMCACHED_END
);
5715 /* Verify that we got all of the items */
5716 assert(counter
== max_keys
);
5718 /* Release all allocated resources */
5719 for (size_t x
= 0; x
< max_keys
; ++x
)
5726 memc
->number_of_hosts
= number_of_hosts
;
5728 return TEST_SUCCESS
;
5734 test_st udp_setup_server_tests
[] ={
5735 {"set_udp_behavior_test", 0, (test_callback_fn
)set_udp_behavior_test
},
5736 {"add_tcp_server_udp_client_test", 0, (test_callback_fn
)add_tcp_server_udp_client_test
},
5737 {"add_udp_server_tcp_client_test", 0, (test_callback_fn
)add_udp_server_tcp_client_test
},
5741 test_st upd_io_tests
[] ={
5742 {"udp_set_test", 0, (test_callback_fn
)udp_set_test
},
5743 {"udp_buffered_set_test", 0, (test_callback_fn
)udp_buffered_set_test
},
5744 {"udp_set_too_big_test", 0, (test_callback_fn
)udp_set_too_big_test
},
5745 {"udp_delete_test", 0, (test_callback_fn
)udp_delete_test
},
5746 {"udp_buffered_delete_test", 0, (test_callback_fn
)udp_buffered_delete_test
},
5747 {"udp_verbosity_test", 0, (test_callback_fn
)udp_verbosity_test
},
5748 {"udp_quit_test", 0, (test_callback_fn
)udp_quit_test
},
5749 {"udp_flush_test", 0, (test_callback_fn
)udp_flush_test
},
5750 {"udp_incr_test", 0, (test_callback_fn
)udp_incr_test
},
5751 {"udp_decr_test", 0, (test_callback_fn
)udp_decr_test
},
5752 {"udp_stat_test", 0, (test_callback_fn
)udp_stat_test
},
5753 {"udp_version_test", 0, (test_callback_fn
)udp_version_test
},
5754 {"udp_get_test", 0, (test_callback_fn
)udp_get_test
},
5755 {"udp_mixed_io_test", 0, (test_callback_fn
)udp_mixed_io_test
},
5759 /* Clean the server before beginning testing */
5761 {"flush", 0, (test_callback_fn
)flush_test
},
5762 {"init", 0, (test_callback_fn
)init_test
},
5763 {"allocation", 0, (test_callback_fn
)allocation_test
},
5764 {"server_list_null_test", 0, (test_callback_fn
)server_list_null_test
},
5765 {"server_unsort", 0, (test_callback_fn
)server_unsort_test
},
5766 {"server_sort", 0, (test_callback_fn
)server_sort_test
},
5767 {"server_sort2", 0, (test_callback_fn
)server_sort2_test
},
5768 {"clone_test", 0, (test_callback_fn
)clone_test
},
5769 {"connection_test", 0, (test_callback_fn
)connection_test
},
5770 {"callback_test", 0, (test_callback_fn
)callback_test
},
5771 {"userdata_test", 0, (test_callback_fn
)userdata_test
},
5772 {"error", 0, (test_callback_fn
)error_test
},
5773 {"set", 0, (test_callback_fn
)set_test
},
5774 {"set2", 0, (test_callback_fn
)set_test2
},
5775 {"set3", 0, (test_callback_fn
)set_test3
},
5776 {"dump", 1, (test_callback_fn
)dump_test
},
5777 {"add", 1, (test_callback_fn
)add_test
},
5778 {"replace", 1, (test_callback_fn
)replace_test
},
5779 {"delete", 1, (test_callback_fn
)delete_test
},
5780 {"get", 1, (test_callback_fn
)get_test
},
5781 {"get2", 0, (test_callback_fn
)get_test2
},
5782 {"get3", 0, (test_callback_fn
)get_test3
},
5783 {"get4", 0, (test_callback_fn
)get_test4
},
5784 {"partial mget", 0, (test_callback_fn
)get_test5
},
5785 {"stats_servername", 0, (test_callback_fn
)stats_servername_test
},
5786 {"increment", 0, (test_callback_fn
)increment_test
},
5787 {"increment_with_initial", 1, (test_callback_fn
)increment_with_initial_test
},
5788 {"decrement", 0, (test_callback_fn
)decrement_test
},
5789 {"decrement_with_initial", 1, (test_callback_fn
)decrement_with_initial_test
},
5790 {"increment_by_key", 0, (test_callback_fn
)increment_by_key_test
},
5791 {"increment_with_initial_by_key", 1, (test_callback_fn
)increment_with_initial_by_key_test
},
5792 {"decrement_by_key", 0, (test_callback_fn
)decrement_by_key_test
},
5793 {"decrement_with_initial_by_key", 1, (test_callback_fn
)decrement_with_initial_by_key_test
},
5794 {"quit", 0, (test_callback_fn
)quit_test
},
5795 {"mget", 1, (test_callback_fn
)mget_test
},
5796 {"mget_result", 1, (test_callback_fn
)mget_result_test
},
5797 {"mget_result_alloc", 1, (test_callback_fn
)mget_result_alloc_test
},
5798 {"mget_result_function", 1, (test_callback_fn
)mget_result_function
},
5799 {"mget_execute", 1, (test_callback_fn
)mget_execute
},
5800 {"mget_end", 0, (test_callback_fn
)mget_end
},
5801 {"get_stats", 0, (test_callback_fn
)get_stats
},
5802 {"add_host_test", 0, (test_callback_fn
)add_host_test
},
5803 {"add_host_test_1", 0, (test_callback_fn
)add_host_test1
},
5804 {"get_stats_keys", 0, (test_callback_fn
)get_stats_keys
},
5805 {"version_string_test", 0, (test_callback_fn
)version_string_test
},
5806 {"bad_key", 1, (test_callback_fn
)bad_key_test
},
5807 {"memcached_server_cursor", 1, (test_callback_fn
)memcached_server_cursor_test
},
5808 {"read_through", 1, (test_callback_fn
)read_through
},
5809 {"delete_through", 1, (test_callback_fn
)delete_through
},
5810 {"noreply", 1, (test_callback_fn
)noreply_test
},
5811 {"analyzer", 1, (test_callback_fn
)analyzer_test
},
5812 #ifdef HAVE_LIBMEMCACHEDUTIL
5813 {"connectionpool", 1, (test_callback_fn
)connection_pool_test
},
5815 {"test_get_last_disconnect", 1, (test_callback_fn
)test_get_last_disconnect
},
5819 test_st behavior_tests
[] ={
5820 {"behavior_test", 0, (test_callback_fn
)behavior_test
},
5821 {"MEMCACHED_BEHAVIOR_CORK", 0, (test_callback_fn
)MEMCACHED_BEHAVIOR_CORK_test
},
5825 test_st async_tests
[] ={
5826 {"add", 1, (test_callback_fn
)add_wrapper
},
5830 test_st string_tests
[] ={
5831 {"string static with null", 0, (test_callback_fn
)string_static_null
},
5832 {"string alloc with null", 0, (test_callback_fn
)string_alloc_null
},
5833 {"string alloc with 1K", 0, (test_callback_fn
)string_alloc_with_size
},
5834 {"string alloc with malloc failure", 0, (test_callback_fn
)string_alloc_with_size_toobig
},
5835 {"string append", 0, (test_callback_fn
)string_alloc_append
},
5836 {"string append failure (too big)", 0, (test_callback_fn
)string_alloc_append_toobig
},
5837 {0, 0, (test_callback_fn
)0}
5840 test_st result_tests
[] ={
5841 {"result static", 0, (test_callback_fn
)result_static
},
5842 {"result alloc", 0, (test_callback_fn
)result_alloc
},
5843 {0, 0, (test_callback_fn
)0}
5846 test_st version_1_2_3
[] ={
5847 {"append", 0, (test_callback_fn
)append_test
},
5848 {"prepend", 0, (test_callback_fn
)prepend_test
},
5849 {"cas", 0, (test_callback_fn
)cas_test
},
5850 {"cas2", 0, (test_callback_fn
)cas2_test
},
5851 {"append_binary", 0, (test_callback_fn
)append_binary_test
},
5852 {0, 0, (test_callback_fn
)0}
5855 test_st user_tests
[] ={
5856 {"user_supplied_bug1", 0, (test_callback_fn
)user_supplied_bug1
},
5857 {"user_supplied_bug2", 0, (test_callback_fn
)user_supplied_bug2
},
5858 {"user_supplied_bug3", 0, (test_callback_fn
)user_supplied_bug3
},
5859 {"user_supplied_bug4", 0, (test_callback_fn
)user_supplied_bug4
},
5860 {"user_supplied_bug5", 1, (test_callback_fn
)user_supplied_bug5
},
5861 {"user_supplied_bug6", 1, (test_callback_fn
)user_supplied_bug6
},
5862 {"user_supplied_bug7", 1, (test_callback_fn
)user_supplied_bug7
},
5863 {"user_supplied_bug8", 1, (test_callback_fn
)user_supplied_bug8
},
5864 {"user_supplied_bug9", 1, (test_callback_fn
)user_supplied_bug9
},
5865 {"user_supplied_bug10", 1, (test_callback_fn
)user_supplied_bug10
},
5866 {"user_supplied_bug11", 1, (test_callback_fn
)user_supplied_bug11
},
5867 {"user_supplied_bug12", 1, (test_callback_fn
)user_supplied_bug12
},
5868 {"user_supplied_bug13", 1, (test_callback_fn
)user_supplied_bug13
},
5869 {"user_supplied_bug14", 1, (test_callback_fn
)user_supplied_bug14
},
5870 {"user_supplied_bug15", 1, (test_callback_fn
)user_supplied_bug15
},
5871 {"user_supplied_bug16", 1, (test_callback_fn
)user_supplied_bug16
},
5874 ** It seems to be something weird with the character sets..
5875 ** value_fetch is unable to parse the value line (iscntrl "fails"), so I
5876 ** guess I need to find out how this is supposed to work.. Perhaps I need
5877 ** to run the test in a specific locale (I tried zh_CN.UTF-8 without success,
5878 ** so just disable the code for now...).
5880 {"user_supplied_bug17", 1, (test_callback_fn
)user_supplied_bug17
},
5882 {"user_supplied_bug18", 1, (test_callback_fn
)user_supplied_bug18
},
5883 {"user_supplied_bug19", 1, (test_callback_fn
)user_supplied_bug19
},
5884 {"user_supplied_bug20", 1, (test_callback_fn
)user_supplied_bug20
},
5885 {"user_supplied_bug21", 1, (test_callback_fn
)user_supplied_bug21
},
5886 {"wrong_failure_counter_test", 1, (test_callback_fn
)wrong_failure_counter_test
},
5887 {0, 0, (test_callback_fn
)0}
5890 test_st replication_tests
[]= {
5891 {"set", 1, (test_callback_fn
)replication_set_test
},
5892 {"get", 0, (test_callback_fn
)replication_get_test
},
5893 {"mget", 0, (test_callback_fn
)replication_mget_test
},
5894 {"delete", 0, (test_callback_fn
)replication_delete_test
},
5895 {"rand_mget", 0, (test_callback_fn
)replication_randomize_mget_test
},
5896 {0, 0, (test_callback_fn
)0}
5900 * The following test suite is used to verify that we don't introduce
5901 * regression bugs. If you want more information about the bug / test,
5902 * you should look in the bug report at
5903 * http://bugs.launchpad.net/libmemcached
5905 test_st regression_tests
[]= {
5906 {"lp:434484", 1, (test_callback_fn
)regression_bug_434484
},
5907 {"lp:434843", 1, (test_callback_fn
)regression_bug_434843
},
5908 {"lp:434843 buffered", 1, (test_callback_fn
)regression_bug_434843_buffered
},
5909 {"lp:421108", 1, (test_callback_fn
)regression_bug_421108
},
5910 {"lp:442914", 1, (test_callback_fn
)regression_bug_442914
},
5911 {"lp:447342", 1, (test_callback_fn
)regression_bug_447342
},
5912 {"lp:463297", 1, (test_callback_fn
)regression_bug_463297
},
5913 {"lp:490486", 1, (test_callback_fn
)regression_bug_490486
},
5914 {0, 0, (test_callback_fn
)0}
5917 test_st ketama_compatibility
[]= {
5918 {"libmemcached", 1, (test_callback_fn
)ketama_compatibility_libmemcached
},
5919 {"spymemcached", 1, (test_callback_fn
)ketama_compatibility_spymemcached
},
5920 {0, 0, (test_callback_fn
)0}
5923 test_st generate_tests
[] ={
5924 {"generate_pairs", 1, (test_callback_fn
)generate_pairs
},
5925 {"generate_data", 1, (test_callback_fn
)generate_data
},
5926 {"get_read", 0, (test_callback_fn
)get_read
},
5927 {"delete_generate", 0, (test_callback_fn
)delete_generate
},
5928 {"generate_buffer_data", 1, (test_callback_fn
)generate_buffer_data
},
5929 {"delete_buffer", 0, (test_callback_fn
)delete_buffer_generate
},
5930 {"generate_data", 1, (test_callback_fn
)generate_data
},
5931 {"mget_read", 0, (test_callback_fn
)mget_read
},
5932 {"mget_read_result", 0, (test_callback_fn
)mget_read_result
},
5933 {"mget_read_function", 0, (test_callback_fn
)mget_read_function
},
5934 {"cleanup", 1, (test_callback_fn
)cleanup_pairs
},
5935 {"generate_large_pairs", 1, (test_callback_fn
)generate_large_pairs
},
5936 {"generate_data", 1, (test_callback_fn
)generate_data
},
5937 {"generate_buffer_data", 1, (test_callback_fn
)generate_buffer_data
},
5938 {"cleanup", 1, (test_callback_fn
)cleanup_pairs
},
5939 {0, 0, (test_callback_fn
)0}
5942 test_st consistent_tests
[] ={
5943 {"generate_pairs", 1, (test_callback_fn
)generate_pairs
},
5944 {"generate_data", 1, (test_callback_fn
)generate_data
},
5945 {"get_read", 0, (test_callback_fn
)get_read_count
},
5946 {"cleanup", 1, (test_callback_fn
)cleanup_pairs
},
5947 {0, 0, (test_callback_fn
)0}
5950 test_st consistent_weighted_tests
[] ={
5951 {"generate_pairs", 1, (test_callback_fn
)generate_pairs
},
5952 {"generate_data", 1, (test_callback_fn
)generate_data_with_stats
},
5953 {"get_read", 0, (test_callback_fn
)get_read_count
},
5954 {"cleanup", 1, (test_callback_fn
)cleanup_pairs
},
5955 {0, 0, (test_callback_fn
)0}
5958 test_st hsieh_availability
[] ={
5959 {"hsieh_avaibility_test", 0, (test_callback_fn
)hsieh_avaibility_test
},
5960 {0, 0, (test_callback_fn
)0}
5964 test_st hash_sanity
[] ={
5965 {"hash sanity", 0, (test_callback_fn
)hash_sanity_test
},
5966 {0, 0, (test_callback_fn
)0}
5970 test_st ketama_auto_eject_hosts
[] ={
5971 {"auto_eject_hosts", 1, (test_callback_fn
)auto_eject_hosts
},
5972 {"output_ketama_weighted_keys", 1, (test_callback_fn
)output_ketama_weighted_keys
},
5973 {0, 0, (test_callback_fn
)0}
5976 test_st hash_tests
[] ={
5977 {"md5", 0, (test_callback_fn
)md5_run
},
5978 {"crc", 0, (test_callback_fn
)crc_run
},
5979 {"fnv1_64", 0, (test_callback_fn
)fnv1_64_run
},
5980 {"fnv1a_64", 0, (test_callback_fn
)fnv1a_64_run
},
5981 {"fnv1_32", 0, (test_callback_fn
)fnv1_32_run
},
5982 {"fnv1a_32", 0, (test_callback_fn
)fnv1a_32_run
},
5983 {"hsieh", 0, (test_callback_fn
)hsieh_run
},
5984 {"murmur", 0, (test_callback_fn
)murmur_run
},
5985 {"jenkis", 0, (test_callback_fn
)jenkins_run
},
5986 {0, 0, (test_callback_fn
)0}
5989 collection_st collection
[] ={
5991 {"hash_sanity", 0, 0, hash_sanity
},
5993 {"hsieh_availability", 0, 0, hsieh_availability
},
5994 {"udp_setup", (test_callback_fn
)init_udp
, 0, udp_setup_server_tests
},
5995 {"udp_io", (test_callback_fn
)init_udp
, 0, upd_io_tests
},
5996 {"udp_binary_io", (test_callback_fn
)binary_init_udp
, 0, upd_io_tests
},
5997 {"block", 0, 0, tests
},
5998 {"binary", (test_callback_fn
)pre_binary
, 0, tests
},
5999 {"nonblock", (test_callback_fn
)pre_nonblock
, 0, tests
},
6000 {"nodelay", (test_callback_fn
)pre_nodelay
, 0, tests
},
6001 {"settimer", (test_callback_fn
)pre_settimer
, 0, tests
},
6002 {"md5", (test_callback_fn
)pre_md5
, 0, tests
},
6003 {"crc", (test_callback_fn
)pre_crc
, 0, tests
},
6004 {"hsieh", (test_callback_fn
)pre_hsieh
, 0, tests
},
6005 {"jenkins", (test_callback_fn
)pre_jenkins
, 0, tests
},
6006 {"fnv1_64", (test_callback_fn
)pre_hash_fnv1_64
, 0, tests
},
6007 {"fnv1a_64", (test_callback_fn
)pre_hash_fnv1a_64
, 0, tests
},
6008 {"fnv1_32", (test_callback_fn
)pre_hash_fnv1_32
, 0, tests
},
6009 {"fnv1a_32", (test_callback_fn
)pre_hash_fnv1a_32
, 0, tests
},
6010 {"ketama", (test_callback_fn
)pre_behavior_ketama
, 0, tests
},
6011 {"ketama_auto_eject_hosts", (test_callback_fn
)pre_behavior_ketama
, 0, ketama_auto_eject_hosts
},
6012 {"unix_socket", (test_callback_fn
)pre_unix_socket
, 0, tests
},
6013 {"unix_socket_nodelay", (test_callback_fn
)pre_nodelay
, 0, tests
},
6014 {"poll_timeout", (test_callback_fn
)poll_timeout
, 0, tests
},
6015 {"gets", (test_callback_fn
)enable_cas
, 0, tests
},
6016 {"consistent_crc", (test_callback_fn
)enable_consistent_crc
, 0, tests
},
6017 {"consistent_hsieh", (test_callback_fn
)enable_consistent_hsieh
, 0, tests
},
6018 #ifdef MEMCACHED_ENABLE_DEPRECATED
6019 {"deprecated_memory_allocators", (test_callback_fn
)deprecated_set_memory_alloc
, 0, tests
},
6021 {"memory_allocators", (test_callback_fn
)set_memory_alloc
, 0, tests
},
6022 {"prefix", (test_callback_fn
)set_prefix
, 0, tests
},
6023 {"version_1_2_3", (test_callback_fn
)check_for_1_2_3
, 0, version_1_2_3
},
6024 {"string", 0, 0, string_tests
},
6025 {"result", 0, 0, result_tests
},
6026 {"async", (test_callback_fn
)pre_nonblock
, 0, async_tests
},
6027 {"async_binary", (test_callback_fn
)pre_nonblock_binary
, 0, async_tests
},
6028 {"user", 0, 0, user_tests
},
6029 {"generate", 0, 0, generate_tests
},
6030 {"generate_hsieh", (test_callback_fn
)pre_hsieh
, 0, generate_tests
},
6031 {"generate_ketama", (test_callback_fn
)pre_behavior_ketama
, 0, generate_tests
},
6032 {"generate_hsieh_consistent", (test_callback_fn
)enable_consistent_hsieh
, 0, generate_tests
},
6033 {"generate_md5", (test_callback_fn
)pre_md5
, 0, generate_tests
},
6034 {"generate_murmur", (test_callback_fn
)pre_murmur
, 0, generate_tests
},
6035 {"generate_jenkins", (test_callback_fn
)pre_jenkins
, 0, generate_tests
},
6036 {"generate_nonblock", (test_callback_fn
)pre_nonblock
, 0, generate_tests
},
6038 {"generate_corked", (test_callback_fn
)pre_cork
, 0, generate_tests
},
6039 {"generate_corked_and_nonblock", (test_callback_fn
)pre_cork_and_nonblock
, 0, generate_tests
},
6040 {"consistent_not", 0, 0, consistent_tests
},
6041 {"consistent_ketama", (test_callback_fn
)pre_behavior_ketama
, 0, consistent_tests
},
6042 {"consistent_ketama_weighted", (test_callback_fn
)pre_behavior_ketama_weighted
, 0, consistent_weighted_tests
},
6043 {"ketama_compat", 0, 0, ketama_compatibility
},
6044 {"test_hashes", 0, 0, hash_tests
},
6045 {"replication", (test_callback_fn
)pre_replication
, 0, replication_tests
},
6046 {"replication_noblock", (test_callback_fn
)pre_replication_noblock
, 0, replication_tests
},
6047 {"regression", 0, 0, regression_tests
},
6048 {"behaviors", 0, 0, behavior_tests
},
6052 #define SERVERS_TO_CREATE 5
6054 #include "libmemcached_world.h"
6056 void get_world(world_st
*world
)
6058 world
->collections
= collection
;
6060 world
->create
= (test_callback_create_fn
)world_create
;
6061 world
->destroy
= (test_callback_fn
)world_destroy
;
6063 world
->test
.startup
= (test_callback_fn
)world_test_startup
;
6064 world
->test
.flush
= (test_callback_fn
)world_flush
;
6065 world
->test
.pre_run
= (test_callback_fn
)world_pre_run
;
6066 world
->test
.post_run
= (test_callback_fn
)world_post_run
;
6067 world
->test
.on_error
= (test_callback_error_fn
)world_on_error
;
6069 world
->collection
.startup
= (test_callback_fn
)world_container_startup
;
6070 world
->collection
.shutdown
= (test_callback_fn
)world_container_shutdown
;
6072 world
->runner
= &defualt_libmemcached_runner
;