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_truth(server_list
== NULL
);
73 server_list
= memcached_server_list_append_with_weight(NULL
, "localhost", 0, 0, NULL
);
74 test_truth(server_list
== NULL
);
76 server_list
= memcached_server_list_append_with_weight(NULL
, NULL
, 0, 0, &rc
);
77 test_truth(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(memcached_st
*ptr
__attribute__((unused
)), memcached_server_st
*server
, void *context
)
88 size_t bigger
= *((size_t *)(context
));
89 assert(bigger
<= server
->port
);
90 *((size_t *)(context
))= server
->port
;
92 return MEMCACHED_SUCCESS
;
95 static test_return_t
server_sort_test(memcached_st
*ptr
__attribute__((unused
)))
97 size_t bigger
= 0; /* Prime the value for the test_truth in server_display_function */
99 memcached_return_t rc
;
100 memcached_server_fn callbacks
[1];
101 memcached_st
*local_memc
;
103 local_memc
= memcached_create(NULL
);
104 test_truth(local_memc
);
105 memcached_behavior_set(local_memc
, MEMCACHED_BEHAVIOR_SORT_HOSTS
, 1);
107 for (size_t x
= 0; x
< TEST_PORT_COUNT
; x
++)
109 test_ports
[x
]= (in_port_t
)random() % 64000;
110 rc
= memcached_server_add_with_weight(local_memc
, "localhost", test_ports
[x
], 0);
111 test_truth(memcached_server_count(local_memc
) == x
+ 1);
112 test_truth(memcached_servers_count(memcached_server_list(local_memc
)) == x
+1);
113 test_truth(rc
== MEMCACHED_SUCCESS
);
116 callbacks
[0]= server_display_function
;
117 memcached_server_cursor(local_memc
, callbacks
, (void *)&bigger
, 1);
120 memcached_free(local_memc
);
125 static test_return_t
server_sort2_test(memcached_st
*ptr
__attribute__((unused
)))
127 size_t bigger
= 0; /* Prime the value for the test_truth in server_display_function */
128 memcached_return_t rc
;
129 memcached_server_fn callbacks
[1];
130 memcached_st
*local_memc
;
131 memcached_server_instance_st
*instance
;
133 local_memc
= memcached_create(NULL
);
134 test_truth(local_memc
);
135 rc
= memcached_behavior_set(local_memc
, MEMCACHED_BEHAVIOR_SORT_HOSTS
, 1);
136 test_truth(rc
== MEMCACHED_SUCCESS
);
138 rc
= memcached_server_add_with_weight(local_memc
, "MEMCACHED_BEHAVIOR_SORT_HOSTS", 43043, 0);
139 test_truth(rc
== MEMCACHED_SUCCESS
);
140 instance
= memcached_server_instance_fetch(local_memc
, 0);
141 test_truth(instance
->port
== 43043);
143 rc
= memcached_server_add_with_weight(local_memc
, "MEMCACHED_BEHAVIOR_SORT_HOSTS", 43042, 0);
144 test_truth(rc
== MEMCACHED_SUCCESS
);
146 instance
= memcached_server_instance_fetch(local_memc
, 0);
147 test_truth(instance
->port
== 43042);
149 instance
= memcached_server_instance_fetch(local_memc
, 1);
150 test_truth(instance
->port
== 43043);
152 callbacks
[0]= server_display_function
;
153 memcached_server_cursor(local_memc
, callbacks
, (void *)&bigger
, 1);
156 memcached_free(local_memc
);
161 static memcached_return_t
server_display_unsort_function(memcached_st
*ptr
__attribute__((unused
)), memcached_server_st
*server
, void *context
)
164 uint32_t x
= *((uint32_t *)(context
));
166 assert(test_ports
[x
] == server
->port
);
167 *((uint32_t *)(context
))= ++x
;
169 return MEMCACHED_SUCCESS
;
172 static test_return_t
server_unsort_test(memcached_st
*ptr
__attribute__((unused
)))
174 size_t counter
= 0; /* Prime the value for the test_truth in server_display_function */
175 size_t bigger
= 0; /* Prime the value for the test_truth in server_display_function */
176 memcached_return_t rc
;
177 memcached_server_fn callbacks
[1];
178 memcached_st
*local_memc
;
180 local_memc
= memcached_create(NULL
);
181 test_truth(local_memc
);
183 for (size_t x
= 0; x
< TEST_PORT_COUNT
; x
++)
185 test_ports
[x
]= (in_port_t
)(random() % 64000);
186 rc
= memcached_server_add_with_weight(local_memc
, "localhost", test_ports
[x
], 0);
187 test_truth(memcached_server_count(local_memc
) == x
+1);
188 test_truth(memcached_servers_count(memcached_server_list(local_memc
)) == x
+1);
189 test_truth(rc
== MEMCACHED_SUCCESS
);
192 callbacks
[0]= server_display_unsort_function
;
193 memcached_server_cursor(local_memc
, callbacks
, (void *)&counter
, 1);
195 /* Now we sort old data! */
196 memcached_behavior_set(local_memc
, MEMCACHED_BEHAVIOR_SORT_HOSTS
, 1);
197 callbacks
[0]= server_display_function
;
198 memcached_server_cursor(local_memc
, callbacks
, (void *)&bigger
, 1);
201 memcached_free(local_memc
);
206 static test_return_t
allocation_test(memcached_st
*not_used
__attribute__((unused
)))
209 memc
= memcached_create(NULL
);
211 memcached_free(memc
);
216 static test_return_t
clone_test(memcached_st
*memc
)
220 memcached_st
*memc_clone
;
221 memc_clone
= memcached_clone(NULL
, NULL
);
222 test_truth(memc_clone
);
223 memcached_free(memc_clone
);
226 /* Can we init from null? */
228 memcached_st
*memc_clone
;
229 memc_clone
= memcached_clone(NULL
, memc
);
230 test_truth(memc_clone
);
232 test_truth(memc_clone
->call_free
== memc
->call_free
);
233 test_truth(memc_clone
->call_malloc
== memc
->call_malloc
);
234 test_truth(memc_clone
->call_realloc
== memc
->call_realloc
);
235 test_truth(memc_clone
->call_calloc
== memc
->call_calloc
);
236 test_truth(memc_clone
->connect_timeout
== memc
->connect_timeout
);
237 test_truth(memc_clone
->delete_trigger
== memc
->delete_trigger
);
238 test_truth(memc_clone
->distribution
== memc
->distribution
);
239 { // Test all of the flags
240 test_truth(memc_clone
->flags
.no_block
== memc
->flags
.no_block
);
241 test_truth(memc_clone
->flags
.tcp_nodelay
== memc
->flags
.tcp_nodelay
);
242 test_truth(memc_clone
->flags
.reuse_memory
== memc
->flags
.reuse_memory
);
243 test_truth(memc_clone
->flags
.use_cache_lookups
== memc
->flags
.use_cache_lookups
);
244 test_truth(memc_clone
->flags
.support_cas
== memc
->flags
.support_cas
);
245 test_truth(memc_clone
->flags
.buffer_requests
== memc
->flags
.buffer_requests
);
246 test_truth(memc_clone
->flags
.use_sort_hosts
== memc
->flags
.use_sort_hosts
);
247 test_truth(memc_clone
->flags
.verify_key
== memc
->flags
.verify_key
);
248 test_truth(memc_clone
->flags
.ketama_weighted
== memc
->flags
.ketama_weighted
);
249 test_truth(memc_clone
->flags
.binary_protocol
== memc
->flags
.binary_protocol
);
250 test_truth(memc_clone
->flags
.hash_with_prefix_key
== memc
->flags
.hash_with_prefix_key
);
251 test_truth(memc_clone
->flags
.no_reply
== memc
->flags
.no_reply
);
252 test_truth(memc_clone
->flags
.use_udp
== memc
->flags
.use_udp
);
253 test_truth(memc_clone
->flags
.auto_eject_hosts
== memc
->flags
.auto_eject_hosts
);
254 test_truth(memc_clone
->flags
.randomize_replica_read
== memc
->flags
.randomize_replica_read
);
256 test_truth(memc_clone
->get_key_failure
== memc
->get_key_failure
);
257 test_truth(memc_clone
->hash
== memc
->hash
);
258 test_truth(memc_clone
->distribution_hash
== memc
->distribution_hash
);
259 test_truth(memc_clone
->io_bytes_watermark
== memc
->io_bytes_watermark
);
260 test_truth(memc_clone
->io_msg_watermark
== memc
->io_msg_watermark
);
261 test_truth(memc_clone
->io_key_prefetch
== memc
->io_key_prefetch
);
262 test_truth(memc_clone
->on_cleanup
== memc
->on_cleanup
);
263 test_truth(memc_clone
->on_clone
== memc
->on_clone
);
264 test_truth(memc_clone
->poll_timeout
== memc
->poll_timeout
);
265 test_truth(memc_clone
->rcv_timeout
== memc
->rcv_timeout
);
266 test_truth(memc_clone
->recv_size
== memc
->recv_size
);
267 test_truth(memc_clone
->retry_timeout
== memc
->retry_timeout
);
268 test_truth(memc_clone
->send_size
== memc
->send_size
);
269 test_truth(memc_clone
->server_failure_limit
== memc
->server_failure_limit
);
270 test_truth(memc_clone
->snd_timeout
== memc
->snd_timeout
);
271 test_truth(memc_clone
->user_data
== memc
->user_data
);
273 memcached_free(memc_clone
);
276 /* Can we init from struct? */
278 memcached_st declared_clone
;
279 memcached_st
*memc_clone
;
280 memset(&declared_clone
, 0 , sizeof(memcached_st
));
281 memc_clone
= memcached_clone(&declared_clone
, NULL
);
282 test_truth(memc_clone
);
283 memcached_free(memc_clone
);
286 /* Can we init from struct? */
288 memcached_st declared_clone
;
289 memcached_st
*memc_clone
;
290 memset(&declared_clone
, 0 , sizeof(memcached_st
));
291 memc_clone
= memcached_clone(&declared_clone
, memc
);
292 test_truth(memc_clone
);
293 memcached_free(memc_clone
);
299 static test_return_t
userdata_test(memcached_st
*memc
)
302 test_truth(memcached_set_user_data(memc
, foo
) == NULL
);
303 test_truth(memcached_get_user_data(memc
) == foo
);
304 test_truth(memcached_set_user_data(memc
, NULL
) == foo
);
309 static test_return_t
connection_test(memcached_st
*memc
)
311 memcached_return_t rc
;
313 rc
= memcached_server_add_with_weight(memc
, "localhost", 0, 0);
314 test_truth(rc
== MEMCACHED_SUCCESS
);
319 static test_return_t
error_test(memcached_st
*memc
)
321 memcached_return_t rc
;
322 uint32_t values
[] = { 851992627U, 2337886783U, 3196981036U, 4001849190U,
323 982370485U, 1263635348U, 4242906218U, 3829656100U,
324 1891735253U, 334139633U, 2257084983U, 3088286104U,
325 13199785U, 2542027183U, 1097051614U, 199566778U,
326 2748246961U, 2465192557U, 1664094137U, 2405439045U,
327 1842224848U, 692413798U, 3479807801U, 919913813U,
328 4269430871U, 610793021U, 527273862U, 1437122909U,
329 2300930706U, 2943759320U, 674306647U, 2400528935U,
330 54481931U, 4186304426U, 1741088401U, 2979625118U,
331 4159057246U, 3425930182U, 2593724503U};
333 // You have updated the memcache_error messages but not updated docs/tests.
334 test_truth(MEMCACHED_MAXIMUM_RETURN
== 39);
335 for (rc
= MEMCACHED_SUCCESS
; rc
< MEMCACHED_MAXIMUM_RETURN
; rc
++)
338 const char *msg
= memcached_strerror(memc
, rc
);
339 hash_val
= memcached_generate_hash_value(msg
, strlen(msg
),
340 MEMCACHED_HASH_JENKINS
);
341 test_truth(values
[rc
] == hash_val
);
347 static test_return_t
set_test(memcached_st
*memc
)
349 memcached_return_t rc
;
350 const char *key
= "foo";
351 const char *value
= "when we sanitize";
353 rc
= memcached_set(memc
, key
, strlen(key
),
354 value
, strlen(value
),
355 (time_t)0, (uint32_t)0);
356 test_truth(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
);
361 static test_return_t
append_test(memcached_st
*memc
)
363 memcached_return_t rc
;
364 const char *key
= "fig";
365 const char *in_value
= "we";
366 char *out_value
= NULL
;
370 rc
= memcached_flush(memc
, 0);
371 test_truth(rc
== MEMCACHED_SUCCESS
);
373 rc
= memcached_set(memc
, key
, strlen(key
),
374 in_value
, strlen(in_value
),
375 (time_t)0, (uint32_t)0);
376 test_truth(rc
== MEMCACHED_SUCCESS
);
378 rc
= memcached_append(memc
, key
, strlen(key
),
379 " the", strlen(" the"),
380 (time_t)0, (uint32_t)0);
381 test_truth(rc
== MEMCACHED_SUCCESS
);
383 rc
= memcached_append(memc
, key
, strlen(key
),
384 " people", strlen(" people"),
385 (time_t)0, (uint32_t)0);
386 test_truth(rc
== MEMCACHED_SUCCESS
);
388 out_value
= memcached_get(memc
, key
, strlen(key
),
389 &value_length
, &flags
, &rc
);
390 test_truth(!memcmp(out_value
, "we the people", strlen("we the people")));
391 test_truth(strlen("we the people") == value_length
);
392 test_truth(rc
== MEMCACHED_SUCCESS
);
398 static test_return_t
append_binary_test(memcached_st
*memc
)
400 memcached_return_t rc
;
401 const char *key
= "numbers";
402 uint32_t store_list
[] = { 23, 56, 499, 98, 32847, 0 };
408 rc
= memcached_flush(memc
, 0);
409 test_truth(rc
== MEMCACHED_SUCCESS
);
411 rc
= memcached_set(memc
,
414 (time_t)0, (uint32_t)0);
415 test_truth(rc
== MEMCACHED_SUCCESS
);
417 for (x
= 0; store_list
[x
] ; x
++)
419 rc
= memcached_append(memc
,
421 (char *)&store_list
[x
], sizeof(uint32_t),
422 (time_t)0, (uint32_t)0);
423 test_truth(rc
== MEMCACHED_SUCCESS
);
426 value
= (uint32_t *)memcached_get(memc
, key
, strlen(key
),
427 &value_length
, &flags
, &rc
);
428 test_truth((value_length
== (sizeof(uint32_t) * x
)));
429 test_truth(rc
== MEMCACHED_SUCCESS
);
431 for (uint32_t counter
= x
, *ptr
= value
; counter
; counter
--)
433 test_truth(*ptr
== store_list
[x
- counter
]);
441 static test_return_t
cas2_test(memcached_st
*memc
)
443 memcached_return_t rc
;
444 const char *keys
[]= {"fudge", "son", "food"};
445 size_t key_length
[]= {5, 3, 4};
446 const char *value
= "we the people";
447 size_t value_length
= strlen("we the people");
449 memcached_result_st results_obj
;
450 memcached_result_st
*results
;
453 rc
= memcached_flush(memc
, 0);
454 test_truth(rc
== MEMCACHED_SUCCESS
);
456 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_SUPPORT_CAS
, set
);
458 for (x
= 0; x
< 3; x
++)
460 rc
= memcached_set(memc
, keys
[x
], key_length
[x
],
461 keys
[x
], key_length
[x
],
462 (time_t)50, (uint32_t)9);
463 test_truth(rc
== MEMCACHED_SUCCESS
);
466 rc
= memcached_mget(memc
, keys
, key_length
, 3);
468 results
= memcached_result_create(memc
, &results_obj
);
470 results
= memcached_fetch_result(memc
, &results_obj
, &rc
);
472 test_truth(results
->cas
);
473 test_truth(rc
== MEMCACHED_SUCCESS
);
474 test_truth(memcached_result_cas(results
));
476 test_truth(!memcmp(value
, "we the people", strlen("we the people")));
477 test_truth(strlen("we the people") == value_length
);
478 test_truth(rc
== MEMCACHED_SUCCESS
);
480 memcached_result_free(&results_obj
);
485 static test_return_t
cas_test(memcached_st
*memc
)
487 memcached_return_t rc
;
488 const char *key
= "fun";
489 size_t key_length
= strlen(key
);
490 const char *value
= "we the people";
491 const char* keys
[2] = { key
, NULL
};
492 size_t keylengths
[2] = { strlen(key
), 0 };
493 size_t value_length
= strlen(value
);
494 const char *value2
= "change the value";
495 size_t value2_length
= strlen(value2
);
497 memcached_result_st results_obj
;
498 memcached_result_st
*results
;
501 rc
= memcached_flush(memc
, 0);
502 test_truth(rc
== MEMCACHED_SUCCESS
);
504 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_SUPPORT_CAS
, set
);
506 rc
= memcached_set(memc
, key
, strlen(key
),
507 value
, strlen(value
),
508 (time_t)0, (uint32_t)0);
509 test_truth(rc
== MEMCACHED_SUCCESS
);
511 rc
= memcached_mget(memc
, keys
, keylengths
, 1);
513 results
= memcached_result_create(memc
, &results_obj
);
515 results
= memcached_fetch_result(memc
, &results_obj
, &rc
);
517 test_truth(rc
== MEMCACHED_SUCCESS
);
518 test_truth(memcached_result_cas(results
));
519 test_truth(!memcmp(value
, memcached_result_value(results
), value_length
));
520 test_truth(strlen(memcached_result_value(results
)) == value_length
);
521 test_truth(rc
== MEMCACHED_SUCCESS
);
522 uint64_t cas
= memcached_result_cas(results
);
525 results
= memcached_fetch_result(memc
, &results_obj
, &rc
);
526 test_truth(rc
== MEMCACHED_END
);
527 test_truth(results
== NULL
);
530 rc
= memcached_cas(memc
, key
, key_length
, value2
, value2_length
, 0, 0, cas
);
531 test_truth(rc
== MEMCACHED_SUCCESS
);
534 * The item will have a new cas value, so try to set it again with the old
535 * value. This should fail!
537 rc
= memcached_cas(memc
, key
, key_length
, value2
, value2_length
, 0, 0, cas
);
538 test_truth(rc
== MEMCACHED_DATA_EXISTS
);
540 memcached_result_free(&results_obj
);
545 static test_return_t
prepend_test(memcached_st
*memc
)
547 memcached_return_t rc
;
548 const char *key
= "fig";
549 const char *value
= "people";
550 char *out_value
= NULL
;
554 rc
= memcached_flush(memc
, 0);
555 test_truth(rc
== MEMCACHED_SUCCESS
);
557 rc
= memcached_set(memc
, key
, strlen(key
),
558 value
, strlen(value
),
559 (time_t)0, (uint32_t)0);
560 test_truth(rc
== MEMCACHED_SUCCESS
);
562 rc
= memcached_prepend(memc
, key
, strlen(key
),
563 "the ", strlen("the "),
564 (time_t)0, (uint32_t)0);
565 test_truth(rc
== MEMCACHED_SUCCESS
);
567 rc
= memcached_prepend(memc
, key
, strlen(key
),
568 "we ", strlen("we "),
569 (time_t)0, (uint32_t)0);
570 test_truth(rc
== MEMCACHED_SUCCESS
);
572 out_value
= memcached_get(memc
, key
, strlen(key
),
573 &value_length
, &flags
, &rc
);
574 test_truth(!memcmp(out_value
, "we the people", strlen("we the people")));
575 test_truth(strlen("we the people") == value_length
);
576 test_truth(rc
== MEMCACHED_SUCCESS
);
583 Set the value, then quit to make sure it is flushed.
584 Come back in and test that add fails.
586 static test_return_t
add_test(memcached_st
*memc
)
588 memcached_return_t rc
;
589 const char *key
= "foo";
590 const char *value
= "when we sanitize";
591 unsigned long long setting_value
;
593 setting_value
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_NO_BLOCK
);
595 rc
= memcached_set(memc
, key
, strlen(key
),
596 value
, strlen(value
),
597 (time_t)0, (uint32_t)0);
598 test_truth(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
);
599 memcached_quit(memc
);
600 rc
= memcached_add(memc
, key
, strlen(key
),
601 value
, strlen(value
),
602 (time_t)0, (uint32_t)0);
604 /* Too many broken OS'es have broken loopback in async, so we can't be sure of the result */
607 test_truth(rc
== MEMCACHED_NOTSTORED
|| rc
== MEMCACHED_STORED
);
611 test_truth(rc
== MEMCACHED_NOTSTORED
|| rc
== MEMCACHED_DATA_EXISTS
);
618 ** There was a problem of leaking filedescriptors in the initial release
619 ** of MacOSX 10.5. This test case triggers the problem. On some Solaris
620 ** systems it seems that the kernel is slow on reclaiming the resources
621 ** because the connects starts to time out (the test doesn't do much
622 ** anyway, so just loop 10 iterations)
624 static test_return_t
add_wrapper(memcached_st
*memc
)
627 unsigned int max
= 10000;
635 for (x
= 0; x
< max
; x
++)
641 static test_return_t
replace_test(memcached_st
*memc
)
643 memcached_return_t rc
;
644 const char *key
= "foo";
645 const char *value
= "when we sanitize";
646 const char *original
= "first we insert some data";
648 rc
= memcached_set(memc
, key
, strlen(key
),
649 original
, strlen(original
),
650 (time_t)0, (uint32_t)0);
651 test_truth(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
);
653 rc
= memcached_replace(memc
, key
, strlen(key
),
654 value
, strlen(value
),
655 (time_t)0, (uint32_t)0);
656 test_truth(rc
== MEMCACHED_SUCCESS
);
661 static test_return_t
delete_test(memcached_st
*memc
)
663 memcached_return_t rc
;
664 const char *key
= "foo";
665 const char *value
= "when we sanitize";
667 rc
= memcached_set(memc
, key
, strlen(key
),
668 value
, strlen(value
),
669 (time_t)0, (uint32_t)0);
670 test_truth(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
);
672 rc
= memcached_delete(memc
, key
, strlen(key
), (time_t)0);
673 test_truth(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
);
678 static test_return_t
flush_test(memcached_st
*memc
)
680 memcached_return_t rc
;
682 rc
= memcached_flush(memc
, 0);
683 test_truth(rc
== MEMCACHED_SUCCESS
);
688 static memcached_return_t
server_function(memcached_st
*ptr
__attribute__((unused
)),
689 memcached_server_st
*server
__attribute__((unused
)),
690 void *context
__attribute__((unused
)))
694 return MEMCACHED_SUCCESS
;
697 static test_return_t
memcached_server_cursor_test(memcached_st
*memc
)
700 strcpy(context
, "foo bad");
701 memcached_server_fn callbacks
[1];
703 callbacks
[0]= server_function
;
704 memcached_server_cursor(memc
, callbacks
, context
, 1);
708 static test_return_t
bad_key_test(memcached_st
*memc
)
710 memcached_return_t rc
;
711 const char *key
= "foo bad";
713 size_t string_length
;
715 memcached_st
*memc_clone
;
717 size_t max_keylen
= 0xffff;
719 // Just skip if we are in binary mode.
720 if (memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
))
723 memc_clone
= memcached_clone(NULL
, memc
);
724 test_truth(memc_clone
);
726 rc
= memcached_behavior_set(memc_clone
, MEMCACHED_BEHAVIOR_VERIFY_KEY
, set
);
727 test_truth(rc
== MEMCACHED_SUCCESS
);
729 /* All keys are valid in the binary protocol (except for length) */
730 if (memcached_behavior_get(memc_clone
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
) == 0)
732 string
= memcached_get(memc_clone
, key
, strlen(key
),
733 &string_length
, &flags
, &rc
);
734 test_truth(rc
== MEMCACHED_BAD_KEY_PROVIDED
);
735 test_truth(string_length
== 0);
739 rc
= memcached_behavior_set(memc_clone
, MEMCACHED_BEHAVIOR_VERIFY_KEY
, set
);
740 test_truth(rc
== MEMCACHED_SUCCESS
);
741 string
= memcached_get(memc_clone
, key
, strlen(key
),
742 &string_length
, &flags
, &rc
);
743 test_truth(rc
== MEMCACHED_NOTFOUND
);
744 test_truth(string_length
== 0);
747 /* Test multi key for bad keys */
748 const char *keys
[] = { "GoodKey", "Bad Key", "NotMine" };
749 size_t key_lengths
[] = { 7, 7, 7 };
751 rc
= memcached_behavior_set(memc_clone
, MEMCACHED_BEHAVIOR_VERIFY_KEY
, set
);
752 test_truth(rc
== MEMCACHED_SUCCESS
);
754 rc
= memcached_mget(memc_clone
, keys
, key_lengths
, 3);
755 test_truth(rc
== MEMCACHED_BAD_KEY_PROVIDED
);
757 rc
= memcached_mget_by_key(memc_clone
, "foo daddy", 9, keys
, key_lengths
, 1);
758 test_truth(rc
== MEMCACHED_BAD_KEY_PROVIDED
);
762 /* The following test should be moved to the end of this function when the
763 memcached server is updated to allow max size length of the keys in the
766 rc
= memcached_callback_set(memc_clone
, MEMCACHED_CALLBACK_PREFIX_KEY
, NULL
);
767 test_truth(rc
== MEMCACHED_SUCCESS
);
769 char *longkey
= malloc(max_keylen
+ 1);
772 memset(longkey
, 'a', max_keylen
+ 1);
773 string
= memcached_get(memc_clone
, longkey
, max_keylen
,
774 &string_length
, &flags
, &rc
);
775 test_truth(rc
== MEMCACHED_NOTFOUND
);
776 test_truth(string_length
== 0);
779 string
= memcached_get(memc_clone
, longkey
, max_keylen
+ 1,
780 &string_length
, &flags
, &rc
);
781 test_truth(rc
== MEMCACHED_BAD_KEY_PROVIDED
);
782 test_truth(string_length
== 0);
789 /* Make sure zero length keys are marked as bad */
791 rc
= memcached_behavior_set(memc_clone
, MEMCACHED_BEHAVIOR_VERIFY_KEY
, set
);
792 test_truth(rc
== MEMCACHED_SUCCESS
);
793 string
= memcached_get(memc_clone
, key
, 0,
794 &string_length
, &flags
, &rc
);
795 test_truth(rc
== MEMCACHED_BAD_KEY_PROVIDED
);
796 test_truth(string_length
== 0);
799 memcached_free(memc_clone
);
804 #define READ_THROUGH_VALUE "set for me"
805 static memcached_return_t
read_through_trigger(memcached_st
*memc
__attribute__((unused
)),
806 char *key
__attribute__((unused
)),
807 size_t key_length
__attribute__((unused
)),
808 memcached_result_st
*result
)
811 return memcached_result_set_value(result
, READ_THROUGH_VALUE
, strlen(READ_THROUGH_VALUE
));
814 static test_return_t
read_through(memcached_st
*memc
)
816 memcached_return_t rc
;
817 const char *key
= "foo";
819 size_t string_length
;
821 memcached_trigger_key_fn cb
= (memcached_trigger_key_fn
)read_through_trigger
;
823 string
= memcached_get(memc
, key
, strlen(key
),
824 &string_length
, &flags
, &rc
);
826 test_truth(rc
== MEMCACHED_NOTFOUND
);
827 test_false(string_length
);
830 rc
= memcached_callback_set(memc
, MEMCACHED_CALLBACK_GET_FAILURE
,
832 test_truth(rc
== MEMCACHED_SUCCESS
);
834 string
= memcached_get(memc
, key
, strlen(key
),
835 &string_length
, &flags
, &rc
);
837 test_truth(rc
== MEMCACHED_SUCCESS
);
838 test_truth(string_length
== strlen(READ_THROUGH_VALUE
));
839 test_strcmp(READ_THROUGH_VALUE
, string
);
842 string
= memcached_get(memc
, key
, strlen(key
),
843 &string_length
, &flags
, &rc
);
845 test_truth(rc
== MEMCACHED_SUCCESS
);
846 test_truth(string_length
== strlen(READ_THROUGH_VALUE
));
847 test_truth(!strcmp(READ_THROUGH_VALUE
, string
));
853 static memcached_return_t
delete_trigger(memcached_st
*ptr
__attribute__((unused
)),
855 size_t key_length
__attribute__((unused
)))
859 return MEMCACHED_SUCCESS
;
862 static test_return_t
delete_through(memcached_st
*memc
)
864 memcached_trigger_delete_key_fn callback
;
865 memcached_return_t rc
;
867 callback
= (memcached_trigger_delete_key_fn
)delete_trigger
;
869 rc
= memcached_callback_set(memc
, MEMCACHED_CALLBACK_DELETE_TRIGGER
, *(void**)&callback
);
870 test_truth(rc
== MEMCACHED_SUCCESS
);
875 static test_return_t
get_test(memcached_st
*memc
)
877 memcached_return_t rc
;
878 const char *key
= "foo";
880 size_t string_length
;
883 rc
= memcached_delete(memc
, key
, strlen(key
), (time_t)0);
884 test_truth(rc
== MEMCACHED_BUFFERED
|| rc
== MEMCACHED_NOTFOUND
);
886 string
= memcached_get(memc
, key
, strlen(key
),
887 &string_length
, &flags
, &rc
);
889 test_truth(rc
== MEMCACHED_NOTFOUND
);
890 test_false(string_length
);
896 static test_return_t
get_test2(memcached_st
*memc
)
898 memcached_return_t rc
;
899 const char *key
= "foo";
900 const char *value
= "when we sanitize";
902 size_t string_length
;
905 rc
= memcached_set(memc
, key
, strlen(key
),
906 value
, strlen(value
),
907 (time_t)0, (uint32_t)0);
908 test_truth(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
);
910 string
= memcached_get(memc
, key
, strlen(key
),
911 &string_length
, &flags
, &rc
);
914 test_truth(rc
== MEMCACHED_SUCCESS
);
915 test_truth(string_length
== strlen(value
));
916 test_truth(!memcmp(string
, value
, string_length
));
923 static test_return_t
set_test2(memcached_st
*memc
)
925 memcached_return_t rc
;
926 const char *key
= "foo";
927 const char *value
= "train in the brain";
928 size_t value_length
= strlen(value
);
931 for (x
= 0; x
< 10; x
++)
933 rc
= memcached_set(memc
, key
, strlen(key
),
935 (time_t)0, (uint32_t)0);
936 test_truth(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
);
942 static test_return_t
set_test3(memcached_st
*memc
)
944 memcached_return_t rc
;
946 size_t value_length
= 8191;
949 value
= (char*)malloc(value_length
);
952 for (x
= 0; x
< value_length
; x
++)
953 value
[x
] = (char) (x
% 127);
955 /* The dump test relies on there being at least 32 items in memcached */
956 for (x
= 0; x
< 32; x
++)
960 sprintf(key
, "foo%u", x
);
962 rc
= memcached_set(memc
, key
, strlen(key
),
964 (time_t)0, (uint32_t)0);
965 test_truth(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
);
973 static test_return_t
get_test3(memcached_st
*memc
)
975 memcached_return_t rc
;
976 const char *key
= "foo";
978 size_t value_length
= 8191;
980 size_t string_length
;
984 value
= (char*)malloc(value_length
);
987 for (x
= 0; x
< value_length
; x
++)
988 value
[x
] = (char) (x
% 127);
990 rc
= memcached_set(memc
, key
, strlen(key
),
992 (time_t)0, (uint32_t)0);
993 test_truth(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
);
995 string
= memcached_get(memc
, key
, strlen(key
),
996 &string_length
, &flags
, &rc
);
998 test_truth(rc
== MEMCACHED_SUCCESS
);
1000 test_truth(string_length
== value_length
);
1001 test_truth(!memcmp(string
, value
, string_length
));
1006 return TEST_SUCCESS
;
1009 static test_return_t
get_test4(memcached_st
*memc
)
1011 memcached_return_t rc
;
1012 const char *key
= "foo";
1014 size_t value_length
= 8191;
1016 size_t string_length
;
1020 value
= (char*)malloc(value_length
);
1023 for (x
= 0; x
< value_length
; x
++)
1024 value
[x
] = (char) (x
% 127);
1026 rc
= memcached_set(memc
, key
, strlen(key
),
1027 value
, value_length
,
1028 (time_t)0, (uint32_t)0);
1029 test_truth(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
);
1031 for (x
= 0; x
< 10; x
++)
1033 string
= memcached_get(memc
, key
, strlen(key
),
1034 &string_length
, &flags
, &rc
);
1036 test_truth(rc
== MEMCACHED_SUCCESS
);
1038 test_truth(string_length
== value_length
);
1039 test_truth(!memcmp(string
, value
, string_length
));
1045 return TEST_SUCCESS
;
1049 * This test verifies that memcached_read_one_response doesn't try to
1050 * dereference a NIL-pointer if you issue a multi-get and don't read out all
1051 * responses before you execute a storage command.
1053 static test_return_t
get_test5(memcached_st
*memc
)
1056 ** Request the same key twice, to ensure that we hash to the same server
1057 ** (so that we have multiple response values queued up) ;-)
1059 const char *keys
[]= { "key", "key" };
1060 size_t lengths
[]= { 3, 3 };
1064 memcached_return_t rc
= memcached_set(memc
, keys
[0], lengths
[0],
1065 keys
[0], lengths
[0], 0, 0);
1066 test_truth(rc
== MEMCACHED_SUCCESS
);
1067 rc
= memcached_mget(memc
, keys
, lengths
, 2);
1069 memcached_result_st results_obj
;
1070 memcached_result_st
*results
;
1071 results
=memcached_result_create(memc
, &results_obj
);
1072 test_truth(results
);
1073 results
=memcached_fetch_result(memc
, &results_obj
, &rc
);
1074 test_truth(results
);
1075 memcached_result_free(&results_obj
);
1077 /* Don't read out the second result, but issue a set instead.. */
1078 rc
= memcached_set(memc
, keys
[0], lengths
[0], keys
[0], lengths
[0], 0, 0);
1079 test_truth(rc
== MEMCACHED_SUCCESS
);
1081 char *val
= memcached_get_by_key(memc
, keys
[0], lengths
[0], "yek", 3,
1082 &rlen
, &flags
, &rc
);
1083 test_truth(val
== NULL
);
1084 test_truth(rc
== MEMCACHED_NOTFOUND
);
1085 val
= memcached_get(memc
, keys
[0], lengths
[0], &rlen
, &flags
, &rc
);
1086 test_truth(val
!= NULL
);
1087 test_truth(rc
== MEMCACHED_SUCCESS
);
1090 return TEST_SUCCESS
;
1093 static test_return_t
mget_end(memcached_st
*memc
)
1095 const char *keys
[]= { "foo", "foo2" };
1096 size_t lengths
[]= { 3, 4 };
1097 const char *values
[]= { "fjord", "41" };
1099 memcached_return_t rc
;
1102 for (int i
= 0; i
< 2; i
++)
1104 rc
= memcached_set(memc
, keys
[i
], lengths
[i
], values
[i
], strlen(values
[i
]),
1105 (time_t)0, (uint32_t)0);
1106 test_truth(rc
== MEMCACHED_SUCCESS
);
1110 size_t string_length
;
1113 // retrieve both via mget
1114 rc
= memcached_mget(memc
, keys
, lengths
, 2);
1115 test_truth(rc
== MEMCACHED_SUCCESS
);
1117 char key
[MEMCACHED_MAX_KEY
];
1120 // this should get both
1121 for (int i
= 0; i
< 2; i
++)
1123 string
= memcached_fetch(memc
, key
, &key_length
, &string_length
,
1125 test_truth(rc
== MEMCACHED_SUCCESS
);
1127 if (key_length
== 4)
1129 test_truth(string_length
== strlen(values
[val
]));
1130 test_truth(strncmp(values
[val
], string
, string_length
) == 0);
1134 // this should indicate end
1135 string
= memcached_fetch(memc
, key
, &key_length
, &string_length
, &flags
, &rc
);
1136 test_truth(rc
== MEMCACHED_END
);
1139 rc
= memcached_mget(memc
, keys
, lengths
, 1);
1140 test_truth(rc
== MEMCACHED_SUCCESS
);
1142 string
= memcached_fetch(memc
, key
, &key_length
, &string_length
, &flags
, &rc
);
1143 test_truth(key_length
== lengths
[0]);
1144 test_truth(strncmp(keys
[0], key
, key_length
) == 0);
1145 test_truth(string_length
== strlen(values
[0]));
1146 test_truth(strncmp(values
[0], string
, string_length
) == 0);
1147 test_truth(rc
== MEMCACHED_SUCCESS
);
1150 // this should indicate end
1151 string
= memcached_fetch(memc
, key
, &key_length
, &string_length
, &flags
, &rc
);
1152 test_truth(rc
== MEMCACHED_END
);
1154 return TEST_SUCCESS
;
1157 /* Do not copy the style of this code, I just access hosts to testthis function */
1158 static test_return_t
stats_servername_test(memcached_st
*memc
)
1160 memcached_return_t rc
;
1161 memcached_stat_st memc_stat
;
1162 memcached_server_instance_st
*instance
=
1163 memcached_server_instance_fetch(memc
, 0);
1165 rc
= memcached_stat_servername(&memc_stat
, NULL
,
1169 return TEST_SUCCESS
;
1172 static test_return_t
increment_test(memcached_st
*memc
)
1174 uint64_t new_number
;
1175 memcached_return_t rc
;
1176 const char *key
= "number";
1177 const char *value
= "0";
1179 rc
= memcached_set(memc
, key
, strlen(key
),
1180 value
, strlen(value
),
1181 (time_t)0, (uint32_t)0);
1182 test_truth(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
);
1184 rc
= memcached_increment(memc
, key
, strlen(key
),
1186 test_truth(rc
== MEMCACHED_SUCCESS
);
1187 test_truth(new_number
== 1);
1189 rc
= memcached_increment(memc
, key
, strlen(key
),
1191 test_truth(rc
== MEMCACHED_SUCCESS
);
1192 test_truth(new_number
== 2);
1194 return TEST_SUCCESS
;
1197 static test_return_t
increment_with_initial_test(memcached_st
*memc
)
1199 if (memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
) != 0)
1201 uint64_t new_number
;
1202 memcached_return_t rc
;
1203 const char *key
= "number";
1204 uint64_t initial
= 0;
1206 rc
= memcached_increment_with_initial(memc
, key
, strlen(key
),
1207 1, initial
, 0, &new_number
);
1208 test_truth(rc
== MEMCACHED_SUCCESS
);
1209 test_truth(new_number
== initial
);
1211 rc
= memcached_increment_with_initial(memc
, key
, strlen(key
),
1212 1, initial
, 0, &new_number
);
1213 test_truth(rc
== MEMCACHED_SUCCESS
);
1214 test_truth(new_number
== (initial
+ 1));
1216 return TEST_SUCCESS
;
1219 static test_return_t
decrement_test(memcached_st
*memc
)
1221 uint64_t new_number
;
1222 memcached_return_t rc
;
1223 const char *key
= "number";
1224 const char *value
= "3";
1226 rc
= memcached_set(memc
, key
, strlen(key
),
1227 value
, strlen(value
),
1228 (time_t)0, (uint32_t)0);
1229 test_truth(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
);
1231 rc
= memcached_decrement(memc
, key
, strlen(key
),
1233 test_truth(rc
== MEMCACHED_SUCCESS
);
1234 test_truth(new_number
== 2);
1236 rc
= memcached_decrement(memc
, key
, strlen(key
),
1238 test_truth(rc
== MEMCACHED_SUCCESS
);
1239 test_truth(new_number
== 1);
1241 return TEST_SUCCESS
;
1244 static test_return_t
decrement_with_initial_test(memcached_st
*memc
)
1246 if (memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
) != 0)
1248 uint64_t new_number
;
1249 memcached_return_t rc
;
1250 const char *key
= "number";
1251 uint64_t initial
= 3;
1253 rc
= memcached_decrement_with_initial(memc
, key
, strlen(key
),
1254 1, initial
, 0, &new_number
);
1255 test_truth(rc
== MEMCACHED_SUCCESS
);
1256 test_truth(new_number
== initial
);
1258 rc
= memcached_decrement_with_initial(memc
, key
, strlen(key
),
1259 1, initial
, 0, &new_number
);
1260 test_truth(rc
== MEMCACHED_SUCCESS
);
1261 test_truth(new_number
== (initial
- 1));
1263 return TEST_SUCCESS
;
1266 static test_return_t
increment_by_key_test(memcached_st
*memc
)
1268 uint64_t new_number
;
1269 memcached_return_t rc
;
1270 const char *master_key
= "foo";
1271 const char *key
= "number";
1272 const char *value
= "0";
1274 rc
= memcached_set_by_key(memc
, master_key
, strlen(master_key
),
1276 value
, strlen(value
),
1277 (time_t)0, (uint32_t)0);
1278 test_truth(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
);
1280 rc
= memcached_increment_by_key(memc
, master_key
, strlen(master_key
), key
, strlen(key
),
1282 test_truth(rc
== MEMCACHED_SUCCESS
);
1283 test_truth(new_number
== 1);
1285 rc
= memcached_increment_by_key(memc
, master_key
, strlen(master_key
), key
, strlen(key
),
1287 test_truth(rc
== MEMCACHED_SUCCESS
);
1288 test_truth(new_number
== 2);
1290 return TEST_SUCCESS
;
1293 static test_return_t
increment_with_initial_by_key_test(memcached_st
*memc
)
1295 if (memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
) != 0)
1297 uint64_t new_number
;
1298 memcached_return_t rc
;
1299 const char *master_key
= "foo";
1300 const char *key
= "number";
1301 uint64_t initial
= 0;
1303 rc
= memcached_increment_with_initial_by_key(memc
, master_key
, strlen(master_key
),
1305 1, initial
, 0, &new_number
);
1306 test_truth(rc
== MEMCACHED_SUCCESS
);
1307 test_truth(new_number
== initial
);
1309 rc
= memcached_increment_with_initial_by_key(memc
, master_key
, strlen(master_key
),
1311 1, initial
, 0, &new_number
);
1312 test_truth(rc
== MEMCACHED_SUCCESS
);
1313 test_truth(new_number
== (initial
+ 1));
1315 return TEST_SUCCESS
;
1318 static test_return_t
decrement_by_key_test(memcached_st
*memc
)
1320 uint64_t new_number
;
1321 memcached_return_t rc
;
1322 const char *master_key
= "foo";
1323 const char *key
= "number";
1324 const char *value
= "3";
1326 rc
= memcached_set_by_key(memc
, master_key
, strlen(master_key
),
1328 value
, strlen(value
),
1329 (time_t)0, (uint32_t)0);
1330 test_truth(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
);
1332 rc
= memcached_decrement_by_key(memc
, master_key
, strlen(master_key
),
1335 test_truth(rc
== MEMCACHED_SUCCESS
);
1336 test_truth(new_number
== 2);
1338 rc
= memcached_decrement_by_key(memc
, master_key
, strlen(master_key
),
1341 test_truth(rc
== MEMCACHED_SUCCESS
);
1342 test_truth(new_number
== 1);
1344 return TEST_SUCCESS
;
1347 static test_return_t
decrement_with_initial_by_key_test(memcached_st
*memc
)
1349 if (memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
) != 0)
1351 uint64_t new_number
;
1352 memcached_return_t rc
;
1353 const char *master_key
= "foo";
1354 const char *key
= "number";
1355 uint64_t initial
= 3;
1357 rc
= memcached_decrement_with_initial_by_key(memc
, master_key
, strlen(master_key
),
1359 1, initial
, 0, &new_number
);
1360 test_truth(rc
== MEMCACHED_SUCCESS
);
1361 test_truth(new_number
== initial
);
1363 rc
= memcached_decrement_with_initial_by_key(memc
, master_key
, strlen(master_key
),
1365 1, initial
, 0, &new_number
);
1366 test_truth(rc
== MEMCACHED_SUCCESS
);
1367 test_truth(new_number
== (initial
- 1));
1369 return TEST_SUCCESS
;
1372 static test_return_t
quit_test(memcached_st
*memc
)
1374 memcached_return_t rc
;
1375 const char *key
= "fudge";
1376 const char *value
= "sanford and sun";
1378 rc
= memcached_set(memc
, key
, strlen(key
),
1379 value
, strlen(value
),
1380 (time_t)10, (uint32_t)3);
1381 test_truth(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
);
1382 memcached_quit(memc
);
1384 rc
= memcached_set(memc
, key
, strlen(key
),
1385 value
, strlen(value
),
1386 (time_t)50, (uint32_t)9);
1387 test_truth(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
);
1389 return TEST_SUCCESS
;
1392 static test_return_t
mget_result_test(memcached_st
*memc
)
1394 memcached_return_t rc
;
1395 const char *keys
[]= {"fudge", "son", "food"};
1396 size_t key_length
[]= {5, 3, 4};
1399 memcached_result_st results_obj
;
1400 memcached_result_st
*results
;
1402 results
= memcached_result_create(memc
, &results_obj
);
1403 test_truth(results
);
1404 test_truth(&results_obj
== results
);
1406 /* We need to empty the server before continueing test */
1407 rc
= memcached_flush(memc
, 0);
1408 test_truth(rc
== MEMCACHED_SUCCESS
);
1410 rc
= memcached_mget(memc
, keys
, key_length
, 3);
1411 test_truth(rc
== MEMCACHED_SUCCESS
);
1413 while ((results
= memcached_fetch_result(memc
, &results_obj
, &rc
)) != NULL
)
1415 test_truth(results
);
1418 while ((results
= memcached_fetch_result(memc
, &results_obj
, &rc
)) != NULL
)
1419 test_truth(!results
);
1420 test_truth(rc
== MEMCACHED_END
);
1422 for (x
= 0; x
< 3; x
++)
1424 rc
= memcached_set(memc
, keys
[x
], key_length
[x
],
1425 keys
[x
], key_length
[x
],
1426 (time_t)50, (uint32_t)9);
1427 test_truth(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
);
1430 rc
= memcached_mget(memc
, keys
, key_length
, 3);
1431 test_truth(rc
== MEMCACHED_SUCCESS
);
1433 while ((results
= memcached_fetch_result(memc
, &results_obj
, &rc
)))
1435 test_truth(results
);
1436 test_truth(&results_obj
== results
);
1437 test_truth(rc
== MEMCACHED_SUCCESS
);
1438 test_truth(memcached_result_key_length(results
) == memcached_result_length(results
));
1439 test_truth(!memcmp(memcached_result_key_value(results
),
1440 memcached_result_value(results
),
1441 memcached_result_length(results
)));
1444 memcached_result_free(&results_obj
);
1446 return TEST_SUCCESS
;
1449 static test_return_t
mget_result_alloc_test(memcached_st
*memc
)
1451 memcached_return_t rc
;
1452 const char *keys
[]= {"fudge", "son", "food"};
1453 size_t key_length
[]= {5, 3, 4};
1456 memcached_result_st
*results
;
1458 /* We need to empty the server before continueing test */
1459 rc
= memcached_flush(memc
, 0);
1460 test_truth(rc
== MEMCACHED_SUCCESS
);
1462 rc
= memcached_mget(memc
, keys
, key_length
, 3);
1463 test_truth(rc
== MEMCACHED_SUCCESS
);
1465 while ((results
= memcached_fetch_result(memc
, NULL
, &rc
)) != NULL
)
1467 test_truth(results
);
1469 test_truth(!results
);
1470 test_truth(rc
== MEMCACHED_END
);
1472 for (x
= 0; x
< 3; x
++)
1474 rc
= memcached_set(memc
, keys
[x
], key_length
[x
],
1475 keys
[x
], key_length
[x
],
1476 (time_t)50, (uint32_t)9);
1477 test_truth(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
);
1480 rc
= memcached_mget(memc
, keys
, key_length
, 3);
1481 test_truth(rc
== MEMCACHED_SUCCESS
);
1484 while ((results
= memcached_fetch_result(memc
, NULL
, &rc
)))
1486 test_truth(results
);
1487 test_truth(rc
== MEMCACHED_SUCCESS
);
1488 test_truth(memcached_result_key_length(results
) == memcached_result_length(results
));
1489 test_truth(!memcmp(memcached_result_key_value(results
),
1490 memcached_result_value(results
),
1491 memcached_result_length(results
)));
1492 memcached_result_free(results
);
1496 return TEST_SUCCESS
;
1499 /* Count the results */
1500 static memcached_return_t
callback_counter(memcached_st
*ptr
__attribute__((unused
)),
1501 memcached_result_st
*result
__attribute__((unused
)),
1504 size_t *counter
= (size_t *)context
;
1506 *counter
= *counter
+ 1;
1508 return MEMCACHED_SUCCESS
;
1511 static test_return_t
mget_result_function(memcached_st
*memc
)
1513 memcached_return_t rc
;
1514 const char *keys
[]= {"fudge", "son", "food"};
1515 size_t key_length
[]= {5, 3, 4};
1518 memcached_execute_fn callbacks
[1];
1520 /* We need to empty the server before continueing test */
1521 rc
= memcached_flush(memc
, 0);
1522 for (x
= 0; x
< 3; x
++)
1524 rc
= memcached_set(memc
, keys
[x
], key_length
[x
],
1525 keys
[x
], key_length
[x
],
1526 (time_t)50, (uint32_t)9);
1527 test_truth(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
);
1530 rc
= memcached_mget(memc
, keys
, key_length
, 3);
1531 test_truth(rc
== MEMCACHED_SUCCESS
);
1533 callbacks
[0]= &callback_counter
;
1535 rc
= memcached_fetch_execute(memc
, callbacks
, (void *)&counter
, 1);
1537 test_truth(counter
== 3);
1539 return TEST_SUCCESS
;
1542 static test_return_t
mget_test(memcached_st
*memc
)
1544 memcached_return_t rc
;
1545 const char *keys
[]= {"fudge", "son", "food"};
1546 size_t key_length
[]= {5, 3, 4};
1550 char return_key
[MEMCACHED_MAX_KEY
];
1551 size_t return_key_length
;
1553 size_t return_value_length
;
1555 /* We need to empty the server before continueing test */
1556 rc
= memcached_flush(memc
, 0);
1557 test_truth(rc
== MEMCACHED_SUCCESS
);
1559 rc
= memcached_mget(memc
, keys
, key_length
, 3);
1560 test_truth(rc
== MEMCACHED_SUCCESS
);
1562 while ((return_value
= memcached_fetch(memc
, return_key
, &return_key_length
,
1563 &return_value_length
, &flags
, &rc
)) != NULL
)
1565 test_truth(return_value
);
1567 test_truth(!return_value
);
1568 test_truth(return_value_length
== 0);
1569 test_truth(rc
== MEMCACHED_END
);
1571 for (x
= 0; x
< 3; x
++)
1573 rc
= memcached_set(memc
, keys
[x
], key_length
[x
],
1574 keys
[x
], key_length
[x
],
1575 (time_t)50, (uint32_t)9);
1576 test_truth(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
);
1579 rc
= memcached_mget(memc
, keys
, key_length
, 3);
1580 test_truth(rc
== MEMCACHED_SUCCESS
);
1583 while ((return_value
= memcached_fetch(memc
, return_key
, &return_key_length
,
1584 &return_value_length
, &flags
, &rc
)))
1586 test_truth(return_value
);
1587 test_truth(rc
== MEMCACHED_SUCCESS
);
1588 test_truth(return_key_length
== return_value_length
);
1589 test_truth(!memcmp(return_value
, return_key
, return_value_length
));
1594 return TEST_SUCCESS
;
1597 static test_return_t
mget_execute(memcached_st
*memc
)
1601 if (memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
) != 0)
1605 * I only want to hit _one_ server so I know the number of requests I'm
1606 * sending in the pipeline.
1608 uint32_t number_of_hosts
= memc
->number_of_hosts
;
1609 memc
->number_of_hosts
= 1;
1611 size_t max_keys
= binary
? 20480 : 1;
1614 char **keys
= calloc(max_keys
, sizeof(char*));
1615 size_t *key_length
=calloc(max_keys
, sizeof(size_t));
1617 /* First add all of the items.. */
1618 char blob
[1024] = {0};
1619 memcached_return_t rc
;
1620 for (size_t x
= 0; x
< max_keys
; ++x
)
1624 key_length
[x
]= (size_t)snprintf(k
, sizeof(k
), "0200%zu", x
);
1626 test_truth(keys
[x
] != NULL
);
1627 rc
= memcached_add(memc
, keys
[x
], key_length
[x
], blob
, sizeof(blob
), 0, 0);
1628 test_truth(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
);
1631 /* Try to get all of them with a large multiget */
1633 memcached_execute_fn callbacks
[1]= { [0]= &callback_counter
};
1634 rc
= memcached_mget_execute(memc
, (const char**)keys
, key_length
,
1635 max_keys
, callbacks
, &counter
, 1);
1639 test_truth(rc
== MEMCACHED_SUCCESS
);
1641 rc
= memcached_fetch_execute(memc
, callbacks
, (void *)&counter
, 1);
1642 test_truth(rc
== MEMCACHED_END
);
1644 /* Verify that we got all of the items */
1645 test_truth(counter
== max_keys
);
1649 test_truth(rc
== MEMCACHED_NOT_SUPPORTED
);
1650 test_truth(counter
== 0);
1653 /* Release all allocated resources */
1654 for (size_t x
= 0; x
< max_keys
; ++x
)
1661 memc
->number_of_hosts
= number_of_hosts
;
1662 return TEST_SUCCESS
;
1665 static test_return_t
get_stats_keys(memcached_st
*memc
)
1669 memcached_stat_st memc_stat
;
1670 memcached_return_t rc
;
1672 stat_list
= memcached_stat_get_keys(memc
, &memc_stat
, &rc
);
1673 test_truth(rc
== MEMCACHED_SUCCESS
);
1674 for (ptr
= stat_list
; *ptr
; ptr
++)
1679 return TEST_SUCCESS
;
1682 static test_return_t
version_string_test(memcached_st
*memc
__attribute__((unused
)))
1684 const char *version_string
;
1686 version_string
= memcached_lib_version();
1688 test_truth(!strcmp(version_string
, LIBMEMCACHED_VERSION_STRING
));
1690 return TEST_SUCCESS
;
1693 static test_return_t
get_stats(memcached_st
*memc
)
1698 memcached_return_t rc
;
1699 memcached_stat_st
*memc_stat
;
1701 memc_stat
= memcached_stat(memc
, NULL
, &rc
);
1702 test_truth(rc
== MEMCACHED_SUCCESS
);
1704 test_truth(rc
== MEMCACHED_SUCCESS
);
1705 test_truth(memc_stat
);
1707 for (x
= 0; x
< memcached_server_count(memc
); x
++)
1709 stat_list
= memcached_stat_get_keys(memc
, memc_stat
+x
, &rc
);
1710 test_truth(rc
== MEMCACHED_SUCCESS
);
1711 for (ptr
= stat_list
; *ptr
; ptr
++);
1716 memcached_stat_free(NULL
, memc_stat
);
1718 return TEST_SUCCESS
;
1721 static test_return_t
add_host_test(memcached_st
*memc
)
1724 memcached_server_st
*servers
;
1725 memcached_return_t rc
;
1726 char servername
[]= "0.example.com";
1728 servers
= memcached_server_list_append_with_weight(NULL
, servername
, 400, 0, &rc
);
1729 test_truth(servers
);
1730 test_truth(1 == memcached_server_list_count(servers
));
1732 for (x
= 2; x
< 20; x
++)
1734 char buffer
[SMALL_STRING_LEN
];
1736 snprintf(buffer
, SMALL_STRING_LEN
, "%u.example.com", 400+x
);
1737 servers
= memcached_server_list_append_with_weight(servers
, buffer
, 401, 0,
1739 test_truth(rc
== MEMCACHED_SUCCESS
);
1740 test_truth(x
== memcached_server_list_count(servers
));
1743 rc
= memcached_server_push(memc
, servers
);
1744 test_truth(rc
== MEMCACHED_SUCCESS
);
1745 rc
= memcached_server_push(memc
, servers
);
1746 test_truth(rc
== MEMCACHED_SUCCESS
);
1748 memcached_server_list_free(servers
);
1750 return TEST_SUCCESS
;
1753 static memcached_return_t
clone_test_callback(memcached_st
*parent
__attribute__((unused
)), memcached_st
*memc_clone
__attribute__((unused
)))
1755 return MEMCACHED_SUCCESS
;
1758 static memcached_return_t
cleanup_test_callback(memcached_st
*ptr
__attribute__((unused
)))
1760 return MEMCACHED_SUCCESS
;
1763 static test_return_t
callback_test(memcached_st
*memc
)
1765 /* Test User Data */
1769 memcached_return_t rc
;
1771 rc
= memcached_callback_set(memc
, MEMCACHED_CALLBACK_USER_DATA
, &x
);
1772 test_truth(rc
== MEMCACHED_SUCCESS
);
1773 test_ptr
= (int *)memcached_callback_get(memc
, MEMCACHED_CALLBACK_USER_DATA
, &rc
);
1774 test_truth(*test_ptr
== x
);
1777 /* Test Clone Callback */
1779 memcached_clone_fn clone_cb
= (memcached_clone_fn
)clone_test_callback
;
1780 void *clone_cb_ptr
= *(void **)&clone_cb
;
1781 void *temp_function
= NULL
;
1782 memcached_return_t rc
;
1784 rc
= memcached_callback_set(memc
, MEMCACHED_CALLBACK_CLONE_FUNCTION
,
1786 test_truth(rc
== MEMCACHED_SUCCESS
);
1787 temp_function
= memcached_callback_get(memc
, MEMCACHED_CALLBACK_CLONE_FUNCTION
, &rc
);
1788 test_truth(temp_function
== clone_cb_ptr
);
1791 /* Test Cleanup Callback */
1793 memcached_cleanup_fn cleanup_cb
=
1794 (memcached_cleanup_fn
)cleanup_test_callback
;
1795 void *cleanup_cb_ptr
= *(void **)&cleanup_cb
;
1796 void *temp_function
= NULL
;
1797 memcached_return_t rc
;
1799 rc
= memcached_callback_set(memc
, MEMCACHED_CALLBACK_CLONE_FUNCTION
,
1801 test_truth(rc
== MEMCACHED_SUCCESS
);
1802 temp_function
= memcached_callback_get(memc
, MEMCACHED_CALLBACK_CLONE_FUNCTION
, &rc
);
1803 test_truth(temp_function
== cleanup_cb_ptr
);
1806 return TEST_SUCCESS
;
1809 /* We don't test the behavior itself, we test the switches */
1810 static test_return_t
behavior_test(memcached_st
*memc
)
1815 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NO_BLOCK
, set
);
1816 value
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_NO_BLOCK
);
1817 test_truth(value
== 1);
1819 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_TCP_NODELAY
, set
);
1820 value
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_TCP_NODELAY
);
1821 test_truth(value
== 1);
1823 set
= MEMCACHED_HASH_MD5
;
1824 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_HASH
, set
);
1825 value
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_HASH
);
1826 test_truth(value
== MEMCACHED_HASH_MD5
);
1830 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NO_BLOCK
, set
);
1831 value
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_NO_BLOCK
);
1832 test_truth(value
== 0);
1834 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_TCP_NODELAY
, set
);
1835 value
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_TCP_NODELAY
);
1836 test_truth(value
== 0);
1838 set
= MEMCACHED_HASH_DEFAULT
;
1839 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_HASH
, set
);
1840 value
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_HASH
);
1841 test_truth(value
== MEMCACHED_HASH_DEFAULT
);
1843 set
= MEMCACHED_HASH_CRC
;
1844 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_HASH
, set
);
1845 value
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_HASH
);
1846 test_truth(value
== MEMCACHED_HASH_CRC
);
1848 value
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_SOCKET_SEND_SIZE
);
1849 test_truth(value
> 0);
1851 value
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_SOCKET_RECV_SIZE
);
1852 test_truth(value
> 0);
1854 value
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_NUMBER_OF_REPLICAS
);
1855 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NUMBER_OF_REPLICAS
, value
+ 1);
1856 test_truth((value
+ 1) == memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_NUMBER_OF_REPLICAS
));
1858 return TEST_SUCCESS
;
1861 static test_return_t
fetch_all_results(memcached_st
*memc
)
1863 memcached_return_t rc
= MEMCACHED_SUCCESS
;
1864 char return_key
[MEMCACHED_MAX_KEY
];
1865 size_t return_key_length
;
1867 size_t return_value_length
;
1870 while ((return_value
= memcached_fetch(memc
, return_key
, &return_key_length
,
1871 &return_value_length
, &flags
, &rc
)))
1873 test_truth(return_value
);
1874 test_truth(rc
== MEMCACHED_SUCCESS
);
1878 return ((rc
== MEMCACHED_END
) || (rc
== MEMCACHED_SUCCESS
)) ? TEST_SUCCESS
: TEST_FAILURE
;
1881 /* Test case provided by Cal Haldenbrand */
1882 static test_return_t
user_supplied_bug1(memcached_st
*memc
)
1884 unsigned int setter
= 1;
1886 unsigned long long total
= 0;
1889 char randomstuff
[6 * 1024];
1890 memcached_return_t rc
;
1892 memset(randomstuff
, 0, 6 * 1024);
1894 /* We just keep looking at the same values over and over */
1897 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NO_BLOCK
, setter
);
1898 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_TCP_NODELAY
, setter
);
1902 for (uint32_t x
= 0 ; total
< 20 * 1024576 ; x
++ )
1906 size
= (uint32_t)(rand() % ( 5 * 1024 ) ) + 400;
1907 memset(randomstuff
, 0, 6 * 1024);
1908 test_truth(size
< 6 * 1024); /* Being safe here */
1910 for (j
= 0 ; j
< size
;j
++)
1911 randomstuff
[j
] = (signed char) ((rand() % 26) + 97);
1914 snprintf(key
, sizeof(key
), "%u", x
);
1915 rc
= memcached_set(memc
, key
, strlen(key
),
1916 randomstuff
, strlen(randomstuff
), 10, 0);
1917 test_truth(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
);
1918 /* If we fail, lets try again */
1919 if (rc
!= MEMCACHED_SUCCESS
&& rc
!= MEMCACHED_BUFFERED
)
1920 rc
= memcached_set(memc
, key
, strlen(key
),
1921 randomstuff
, strlen(randomstuff
), 10, 0);
1922 test_truth(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
);
1925 return TEST_SUCCESS
;
1928 /* Test case provided by Cal Haldenbrand */
1929 static test_return_t
user_supplied_bug2(memcached_st
*memc
)
1931 unsigned int setter
;
1935 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NO_BLOCK
, setter
);
1936 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_TCP_NODELAY
, setter
);
1938 setter
= 20 * 1024576;
1939 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_SOCKET_SEND_SIZE
, setter
);
1940 setter
= 20 * 1024576;
1941 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_SOCKET_RECV_SIZE
, setter
);
1942 getter
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_SOCKET_SEND_SIZE
);
1943 getter
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_SOCKET_RECV_SIZE
);
1945 for (x
= 0, errors
= 0; total
< 20 * 1024576 ; x
++)
1948 for (uint32_t x
= 0, errors
= 0; total
< 24576 ; x
++)
1950 memcached_return_t rc
= MEMCACHED_SUCCESS
;
1951 char buffer
[SMALL_STRING_LEN
];
1956 memset(buffer
, 0, SMALL_STRING_LEN
);
1958 snprintf(buffer
, sizeof(buffer
), "%u", x
);
1959 getval
= memcached_get(memc
, buffer
, strlen(buffer
),
1960 &val_len
, &flags
, &rc
);
1961 if (rc
!= MEMCACHED_SUCCESS
)
1963 if (rc
== MEMCACHED_NOTFOUND
)
1977 return TEST_SUCCESS
;
1980 /* Do a large mget() over all the keys we think exist */
1981 #define KEY_COUNT 3000 // * 1024576
1982 static test_return_t
user_supplied_bug3(memcached_st
*memc
)
1984 memcached_return_t rc
;
1985 unsigned int setter
;
1988 size_t key_lengths
[KEY_COUNT
];
1991 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NO_BLOCK
, setter
);
1992 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_TCP_NODELAY
, setter
);
1994 setter
= 20 * 1024576;
1995 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_SOCKET_SEND_SIZE
, setter
);
1996 setter
= 20 * 1024576;
1997 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_SOCKET_RECV_SIZE
, setter
);
1998 getter
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_SOCKET_SEND_SIZE
);
1999 getter
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_SOCKET_RECV_SIZE
);
2002 keys
= calloc(KEY_COUNT
, sizeof(char *));
2004 for (x
= 0; x
< KEY_COUNT
; x
++)
2008 snprintf(buffer
, 30, "%u", x
);
2009 keys
[x
]= strdup(buffer
);
2010 key_lengths
[x
]= strlen(keys
[x
]);
2013 rc
= memcached_mget(memc
, (const char **)keys
, key_lengths
, KEY_COUNT
);
2014 test_truth(rc
== MEMCACHED_SUCCESS
);
2016 test_truth(fetch_all_results(memc
) == TEST_SUCCESS
);
2018 for (x
= 0; x
< KEY_COUNT
; x
++)
2022 return TEST_SUCCESS
;
2025 /* Make sure we behave properly if server list has no values */
2026 static test_return_t
user_supplied_bug4(memcached_st
*memc
)
2028 memcached_return_t rc
;
2029 const char *keys
[]= {"fudge", "son", "food"};
2030 size_t key_length
[]= {5, 3, 4};
2033 char return_key
[MEMCACHED_MAX_KEY
];
2034 size_t return_key_length
;
2036 size_t return_value_length
;
2038 /* Here we free everything before running a bunch of mget tests */
2039 memcached_servers_reset(memc
);
2042 /* We need to empty the server before continueing test */
2043 rc
= memcached_flush(memc
, 0);
2044 test_truth(rc
== MEMCACHED_NO_SERVERS
);
2046 rc
= memcached_mget(memc
, keys
, key_length
, 3);
2047 test_truth(rc
== MEMCACHED_NO_SERVERS
);
2049 while ((return_value
= memcached_fetch(memc
, return_key
, &return_key_length
,
2050 &return_value_length
, &flags
, &rc
)) != NULL
)
2052 test_truth(return_value
);
2054 test_truth(!return_value
);
2055 test_truth(return_value_length
== 0);
2056 test_truth(rc
== MEMCACHED_NO_SERVERS
);
2058 for (x
= 0; x
< 3; x
++)
2060 rc
= memcached_set(memc
, keys
[x
], key_length
[x
],
2061 keys
[x
], key_length
[x
],
2062 (time_t)50, (uint32_t)9);
2063 test_truth(rc
== MEMCACHED_NO_SERVERS
);
2066 rc
= memcached_mget(memc
, keys
, key_length
, 3);
2067 test_truth(rc
== MEMCACHED_NO_SERVERS
);
2070 while ((return_value
= memcached_fetch(memc
, return_key
, &return_key_length
,
2071 &return_value_length
, &flags
, &rc
)))
2073 test_truth(return_value
);
2074 test_truth(rc
== MEMCACHED_SUCCESS
);
2075 test_truth(return_key_length
== return_value_length
);
2076 test_truth(!memcmp(return_value
, return_key
, return_value_length
));
2081 return TEST_SUCCESS
;
2084 #define VALUE_SIZE_BUG5 1048064
2085 static test_return_t
user_supplied_bug5(memcached_st
*memc
)
2087 memcached_return_t rc
;
2088 const char *keys
[]= {"036790384900", "036790384902", "036790384904", "036790384906"};
2089 size_t key_length
[]= {strlen("036790384900"), strlen("036790384902"), strlen("036790384904"), strlen("036790384906")};
2090 char return_key
[MEMCACHED_MAX_KEY
];
2091 size_t return_key_length
;
2093 size_t value_length
;
2097 char insert_data
[VALUE_SIZE_BUG5
];
2099 for (x
= 0; x
< VALUE_SIZE_BUG5
; x
++)
2100 insert_data
[x
]= (signed char)rand();
2102 memcached_flush(memc
, 0);
2103 value
= memcached_get(memc
, keys
[0], key_length
[0],
2104 &value_length
, &flags
, &rc
);
2105 test_truth(value
== NULL
);
2106 rc
= memcached_mget(memc
, keys
, key_length
, 4);
2109 while ((value
= memcached_fetch(memc
, return_key
, &return_key_length
,
2110 &value_length
, &flags
, &rc
)))
2112 test_truth(count
== 0);
2114 for (x
= 0; x
< 4; x
++)
2116 rc
= memcached_set(memc
, keys
[x
], key_length
[x
],
2117 insert_data
, VALUE_SIZE_BUG5
,
2118 (time_t)0, (uint32_t)0);
2119 test_truth(rc
== MEMCACHED_SUCCESS
);
2122 for (x
= 0; x
< 10; x
++)
2124 value
= memcached_get(memc
, keys
[0], key_length
[0],
2125 &value_length
, &flags
, &rc
);
2129 rc
= memcached_mget(memc
, keys
, key_length
, 4);
2131 while ((value
= memcached_fetch(memc
, return_key
, &return_key_length
,
2132 &value_length
, &flags
, &rc
)))
2137 test_truth(count
== 4);
2140 return TEST_SUCCESS
;
2143 static test_return_t
user_supplied_bug6(memcached_st
*memc
)
2145 memcached_return_t rc
;
2146 const char *keys
[]= {"036790384900", "036790384902", "036790384904", "036790384906"};
2147 size_t key_length
[]= {strlen("036790384900"), strlen("036790384902"), strlen("036790384904"), strlen("036790384906")};
2148 char return_key
[MEMCACHED_MAX_KEY
];
2149 size_t return_key_length
;
2151 size_t value_length
;
2155 char insert_data
[VALUE_SIZE_BUG5
];
2157 for (x
= 0; x
< VALUE_SIZE_BUG5
; x
++)
2158 insert_data
[x
]= (signed char)rand();
2160 memcached_flush(memc
, 0);
2161 value
= memcached_get(memc
, keys
[0], key_length
[0],
2162 &value_length
, &flags
, &rc
);
2163 test_truth(value
== NULL
);
2164 test_truth(rc
== MEMCACHED_NOTFOUND
);
2165 rc
= memcached_mget(memc
, keys
, key_length
, 4);
2166 test_truth(rc
== MEMCACHED_SUCCESS
);
2169 while ((value
= memcached_fetch(memc
, return_key
, &return_key_length
,
2170 &value_length
, &flags
, &rc
)))
2172 test_truth(count
== 0);
2173 test_truth(rc
== MEMCACHED_END
);
2175 for (x
= 0; x
< 4; x
++)
2177 rc
= memcached_set(memc
, keys
[x
], key_length
[x
],
2178 insert_data
, VALUE_SIZE_BUG5
,
2179 (time_t)0, (uint32_t)0);
2180 test_truth(rc
== MEMCACHED_SUCCESS
);
2183 for (x
= 0; x
< 2; x
++)
2185 value
= memcached_get(memc
, keys
[0], key_length
[0],
2186 &value_length
, &flags
, &rc
);
2190 rc
= memcached_mget(memc
, keys
, key_length
, 4);
2191 test_truth(rc
== MEMCACHED_SUCCESS
);
2193 /* We test for purge of partial complete fetches */
2194 for (count
= 3; count
; count
--)
2196 value
= memcached_fetch(memc
, return_key
, &return_key_length
,
2197 &value_length
, &flags
, &rc
);
2198 test_truth(rc
== MEMCACHED_SUCCESS
);
2199 test_truth(!(memcmp(value
, insert_data
, value_length
)));
2200 test_truth(value_length
);
2205 return TEST_SUCCESS
;
2208 static test_return_t
user_supplied_bug8(memcached_st
*memc
__attribute__((unused
)))
2210 memcached_return_t rc
;
2212 memcached_st
*memc_clone
;
2214 memcached_server_st
*servers
;
2215 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";
2217 servers
= memcached_servers_parse(server_list
);
2218 test_truth(servers
);
2220 mine
= memcached_create(NULL
);
2221 rc
= memcached_server_push(mine
, servers
);
2222 test_truth(rc
== MEMCACHED_SUCCESS
);
2223 memcached_server_list_free(servers
);
2226 memc_clone
= memcached_clone(NULL
, mine
);
2228 memcached_quit(mine
);
2229 memcached_quit(memc_clone
);
2232 memcached_free(mine
);
2233 memcached_free(memc_clone
);
2235 return TEST_SUCCESS
;
2238 /* Test flag store/retrieve */
2239 static test_return_t
user_supplied_bug7(memcached_st
*memc
)
2241 memcached_return_t rc
;
2242 const char *keys
= "036790384900";
2243 size_t key_length
= strlen(keys
);
2244 char return_key
[MEMCACHED_MAX_KEY
];
2245 size_t return_key_length
;
2247 size_t value_length
;
2250 char insert_data
[VALUE_SIZE_BUG5
];
2252 for (x
= 0; x
< VALUE_SIZE_BUG5
; x
++)
2253 insert_data
[x
]= (signed char)rand();
2255 memcached_flush(memc
, 0);
2258 rc
= memcached_set(memc
, keys
, key_length
,
2259 insert_data
, VALUE_SIZE_BUG5
,
2261 test_truth(rc
== MEMCACHED_SUCCESS
);
2264 value
= memcached_get(memc
, keys
, key_length
,
2265 &value_length
, &flags
, &rc
);
2266 test_truth(flags
== 245);
2270 rc
= memcached_mget(memc
, &keys
, &key_length
, 1);
2273 value
= memcached_fetch(memc
, return_key
, &return_key_length
,
2274 &value_length
, &flags
, &rc
);
2275 test_truth(flags
== 245);
2280 return TEST_SUCCESS
;
2283 static test_return_t
user_supplied_bug9(memcached_st
*memc
)
2285 memcached_return_t rc
;
2286 const char *keys
[]= {"UDATA:edevil@sapo.pt", "fudge&*@#", "for^#@&$not"};
2287 size_t key_length
[3];
2292 char return_key
[MEMCACHED_MAX_KEY
];
2293 size_t return_key_length
;
2295 size_t return_value_length
;
2298 key_length
[0]= strlen("UDATA:edevil@sapo.pt");
2299 key_length
[1]= strlen("fudge&*@#");
2300 key_length
[2]= strlen("for^#@&$not");
2303 for (x
= 0; x
< 3; x
++)
2305 rc
= memcached_set(memc
, keys
[x
], key_length
[x
],
2306 keys
[x
], key_length
[x
],
2307 (time_t)50, (uint32_t)9);
2308 test_truth(rc
== MEMCACHED_SUCCESS
);
2311 rc
= memcached_mget(memc
, keys
, key_length
, 3);
2312 test_truth(rc
== MEMCACHED_SUCCESS
);
2314 /* We need to empty the server before continueing test */
2315 while ((return_value
= memcached_fetch(memc
, return_key
, &return_key_length
,
2316 &return_value_length
, &flags
, &rc
)) != NULL
)
2318 test_truth(return_value
);
2322 test_truth(count
== 3);
2324 return TEST_SUCCESS
;
2327 /* We are testing with aggressive timeout to get failures */
2328 static test_return_t
user_supplied_bug10(memcached_st
*memc
)
2330 const char *key
= "foo";
2332 size_t value_length
= 512;
2335 memcached_return_t rc
;
2336 unsigned int set
= 1;
2337 memcached_st
*mclone
= memcached_clone(NULL
, memc
);
2340 memcached_behavior_set(mclone
, MEMCACHED_BEHAVIOR_NO_BLOCK
, set
);
2341 memcached_behavior_set(mclone
, MEMCACHED_BEHAVIOR_TCP_NODELAY
, set
);
2343 memcached_behavior_set(mclone
, MEMCACHED_BEHAVIOR_POLL_TIMEOUT
,
2346 value
= (char*)malloc(value_length
* sizeof(char));
2348 for (x
= 0; x
< value_length
; x
++)
2349 value
[x
]= (char) (x
% 127);
2351 for (x
= 1; x
<= 100000; ++x
)
2353 rc
= memcached_set(mclone
, key
, key_len
,value
, value_length
, 0, 0);
2355 test_truth(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_WRITE_FAILURE
||
2356 rc
== MEMCACHED_BUFFERED
|| rc
== MEMCACHED_TIMEOUT
);
2358 if (rc
== MEMCACHED_WRITE_FAILURE
|| rc
== MEMCACHED_TIMEOUT
)
2363 memcached_free(mclone
);
2365 return TEST_SUCCESS
;
2369 We are looking failures in the async protocol
2371 static test_return_t
user_supplied_bug11(memcached_st
*memc
)
2373 const char *key
= "foo";
2375 size_t value_length
= 512;
2378 memcached_return_t rc
;
2379 unsigned int set
= 1;
2381 memcached_st
*mclone
= memcached_clone(NULL
, memc
);
2383 memcached_behavior_set(mclone
, MEMCACHED_BEHAVIOR_NO_BLOCK
, set
);
2384 memcached_behavior_set(mclone
, MEMCACHED_BEHAVIOR_TCP_NODELAY
, set
);
2386 memcached_behavior_set(mclone
, MEMCACHED_BEHAVIOR_POLL_TIMEOUT
,
2389 timeout
= (int32_t)memcached_behavior_get(mclone
, MEMCACHED_BEHAVIOR_POLL_TIMEOUT
);
2391 test_truth(timeout
== -1);
2393 value
= (char*)malloc(value_length
* sizeof(char));
2395 for (x
= 0; x
< value_length
; x
++)
2396 value
[x
]= (char) (x
% 127);
2398 for (x
= 1; x
<= 100000; ++x
)
2400 rc
= memcached_set(mclone
, key
, key_len
,value
, value_length
, 0, 0);
2404 memcached_free(mclone
);
2406 return TEST_SUCCESS
;
2410 Bug found where incr was not returning MEMCACHED_NOTFOUND when object did not exist.
2412 static test_return_t
user_supplied_bug12(memcached_st
*memc
)
2414 memcached_return_t rc
;
2416 size_t value_length
;
2418 uint64_t number_value
;
2420 value
= memcached_get(memc
, "autoincrement", strlen("autoincrement"),
2421 &value_length
, &flags
, &rc
);
2422 test_truth(value
== NULL
);
2423 test_truth(rc
== MEMCACHED_NOTFOUND
);
2425 rc
= memcached_increment(memc
, "autoincrement", strlen("autoincrement"),
2428 test_truth(value
== NULL
);
2429 /* The binary protocol will set the key if it doesn't exist */
2430 if (memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
) == 1)
2432 test_truth(rc
== MEMCACHED_SUCCESS
);
2436 test_truth(rc
== MEMCACHED_NOTFOUND
);
2439 rc
= memcached_set(memc
, "autoincrement", strlen("autoincrement"), "1", 1, 0, 0);
2441 value
= memcached_get(memc
, "autoincrement", strlen("autoincrement"),
2442 &value_length
, &flags
, &rc
);
2444 test_truth(rc
== MEMCACHED_SUCCESS
);
2447 rc
= memcached_increment(memc
, "autoincrement", strlen("autoincrement"),
2449 test_truth(number_value
== 2);
2450 test_truth(rc
== MEMCACHED_SUCCESS
);
2452 return TEST_SUCCESS
;
2456 Bug found where command total one more than MEMCACHED_MAX_BUFFER
2457 set key34567890 0 0 8169 \r\n is sent followed by buffer of size 8169, followed by 8169
2459 static test_return_t
user_supplied_bug13(memcached_st
*memc
)
2461 char key
[] = "key34567890";
2463 memcached_return_t rc
;
2464 size_t overflowSize
;
2466 char commandFirst
[]= "set key34567890 0 0 ";
2467 char commandLast
[] = " \r\n"; /* first line of command sent to server */
2468 size_t commandLength
;
2471 commandLength
= strlen(commandFirst
) + strlen(commandLast
) + 4; /* 4 is number of characters in size, probably 8196 */
2473 overflowSize
= MEMCACHED_MAX_BUFFER
- commandLength
;
2475 for (testSize
= overflowSize
- 1; testSize
< overflowSize
+ 1; testSize
++)
2477 overflow
= malloc(testSize
);
2478 test_truth(overflow
!= NULL
);
2480 memset(overflow
, 'x', testSize
);
2481 rc
= memcached_set(memc
, key
, strlen(key
),
2482 overflow
, testSize
, 0, 0);
2483 test_truth(rc
== MEMCACHED_SUCCESS
);
2487 return TEST_SUCCESS
;
2492 Test values of many different sizes
2493 Bug found where command total one more than MEMCACHED_MAX_BUFFER
2494 set key34567890 0 0 8169 \r\n
2495 is sent followed by buffer of size 8169, followed by 8169
2497 static test_return_t
user_supplied_bug14(memcached_st
*memc
)
2500 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_TCP_NODELAY
, setter
);
2501 memcached_return_t rc
;
2502 const char *key
= "foo";
2504 size_t value_length
= 18000;
2506 size_t string_length
;
2509 size_t current_length
;
2511 value
= (char*)malloc(value_length
);
2514 for (x
= 0; x
< value_length
; x
++)
2515 value
[x
] = (char) (x
% 127);
2517 for (current_length
= 0; current_length
< value_length
; current_length
++)
2519 rc
= memcached_set(memc
, key
, strlen(key
),
2520 value
, current_length
,
2521 (time_t)0, (uint32_t)0);
2522 test_truth(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
);
2524 string
= memcached_get(memc
, key
, strlen(key
),
2525 &string_length
, &flags
, &rc
);
2527 test_truth(rc
== MEMCACHED_SUCCESS
);
2528 test_truth(string_length
== current_length
);
2529 test_truth(!memcmp(string
, value
, string_length
));
2536 return TEST_SUCCESS
;
2540 Look for zero length value problems
2542 static test_return_t
user_supplied_bug15(memcached_st
*memc
)
2545 memcached_return_t rc
;
2546 const char *key
= "mykey";
2551 for (x
= 0; x
< 2; x
++)
2553 rc
= memcached_set(memc
, key
, strlen(key
),
2555 (time_t)0, (uint32_t)0);
2557 test_truth(rc
== MEMCACHED_SUCCESS
);
2559 value
= memcached_get(memc
, key
, strlen(key
),
2560 &length
, &flags
, &rc
);
2562 test_truth(rc
== MEMCACHED_SUCCESS
);
2563 test_truth(value
== NULL
);
2564 test_truth(length
== 0);
2565 test_truth(flags
== 0);
2567 value
= memcached_get(memc
, key
, strlen(key
),
2568 &length
, &flags
, &rc
);
2570 test_truth(rc
== MEMCACHED_SUCCESS
);
2571 test_truth(value
== NULL
);
2572 test_truth(length
== 0);
2573 test_truth(flags
== 0);
2576 return TEST_SUCCESS
;
2579 /* Check the return sizes on FLAGS to make sure it stores 32bit unsigned values correctly */
2580 static test_return_t
user_supplied_bug16(memcached_st
*memc
)
2582 memcached_return_t rc
;
2583 const char *key
= "mykey";
2588 rc
= memcached_set(memc
, key
, strlen(key
),
2590 (time_t)0, UINT32_MAX
);
2592 test_truth(rc
== MEMCACHED_SUCCESS
);
2594 value
= memcached_get(memc
, key
, strlen(key
),
2595 &length
, &flags
, &rc
);
2597 test_truth(rc
== MEMCACHED_SUCCESS
);
2598 test_truth(value
== NULL
);
2599 test_truth(length
== 0);
2600 test_truth(flags
== UINT32_MAX
);
2602 return TEST_SUCCESS
;
2606 /* Check the validity of chinese key*/
2607 static test_return_t
user_supplied_bug17(memcached_st
*memc
)
2609 memcached_return_t rc
;
2610 const char *key
= "豆瓣";
2611 const char *value
="我们在炎热抑郁的夏天无法停止豆瓣";
2616 rc
= memcached_set(memc
, key
, strlen(key
),
2617 value
, strlen(value
),
2620 test_truth(rc
== MEMCACHED_SUCCESS
);
2622 value2
= memcached_get(memc
, key
, strlen(key
),
2623 &length
, &flags
, &rc
);
2625 test_truth(length
==strlen(value
));
2626 test_truth(rc
== MEMCACHED_SUCCESS
);
2627 test_truth(memcmp(value
, value2
, length
)==0);
2630 return TEST_SUCCESS
;
2638 static test_return_t
user_supplied_bug19(memcached_st
*memc
)
2641 memcached_server_st
*s
;
2642 memcached_return_t res
;
2646 m
= memcached_create(NULL
);
2647 memcached_server_add_with_weight(m
, "localhost", 11311, 100);
2648 memcached_server_add_with_weight(m
, "localhost", 11312, 100);
2650 s
= memcached_server_by_key(m
, "a", 1, &res
);
2651 memcached_server_free(s
);
2655 return TEST_SUCCESS
;
2658 /* CAS test from Andei */
2659 static test_return_t
user_supplied_bug20(memcached_st
*memc
)
2661 memcached_return_t status
;
2662 memcached_result_st
*result
, result_obj
;
2663 const char *key
= "abc";
2664 size_t key_len
= strlen("abc");
2665 const char *value
= "foobar";
2666 size_t value_len
= strlen(value
);
2668 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_SUPPORT_CAS
, 1);
2670 status
= memcached_set(memc
, key
, key_len
, value
, value_len
, (time_t)0, (uint32_t)0);
2671 test_truth(status
== MEMCACHED_SUCCESS
);
2673 status
= memcached_mget(memc
, &key
, &key_len
, 1);
2674 test_truth(status
== MEMCACHED_SUCCESS
);
2676 result
= memcached_result_create(memc
, &result_obj
);
2679 memcached_result_create(memc
, &result_obj
);
2680 result
= memcached_fetch_result(memc
, &result_obj
, &status
);
2683 test_truth(status
== MEMCACHED_SUCCESS
);
2685 memcached_result_free(result
);
2687 return TEST_SUCCESS
;
2690 #include "ketama_test_cases.h"
2691 static test_return_t
user_supplied_bug18(memcached_st
*trash
)
2693 memcached_return_t rc
;
2696 memcached_server_st
*server_pool
;
2701 memc
= memcached_create(NULL
);
2704 rc
= memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_KETAMA_WEIGHTED
, 1);
2705 test_truth(rc
== MEMCACHED_SUCCESS
);
2707 value
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_KETAMA_WEIGHTED
);
2708 test_truth(value
== 1);
2710 rc
= memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_KETAMA_HASH
, MEMCACHED_HASH_MD5
);
2711 test_truth(rc
== MEMCACHED_SUCCESS
);
2713 value
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_KETAMA_HASH
);
2714 test_truth(value
== MEMCACHED_HASH_MD5
);
2716 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");
2717 memcached_server_push(memc
, server_pool
);
2719 /* verify that the server list was parsed okay. */
2720 test_truth(memcached_server_count(memc
) == 8);
2721 test_truth(strcmp(server_pool
[0].hostname
, "10.0.1.1") == 0);
2722 test_truth(server_pool
[0].port
== 11211);
2723 test_truth(server_pool
[0].weight
== 600);
2724 test_truth(strcmp(server_pool
[2].hostname
, "10.0.1.3") == 0);
2725 test_truth(server_pool
[2].port
== 11211);
2726 test_truth(server_pool
[2].weight
== 200);
2727 test_truth(strcmp(server_pool
[7].hostname
, "10.0.1.8") == 0);
2728 test_truth(server_pool
[7].port
== 11211);
2729 test_truth(server_pool
[7].weight
== 100);
2731 /* VDEAAAAA hashes to fffcd1b5, after the last continuum point, and lets
2732 * us test the boundary wraparound.
2734 test_truth(memcached_generate_hash(memc
, (char *)"VDEAAAAA", 8) == memc
->continuum
[0].index
);
2736 /* verify the standard ketama set. */
2737 for (x
= 0; x
< 99; x
++)
2739 uint32_t server_idx
= memcached_generate_hash(memc
, ketama_test_cases
[x
].key
, strlen(ketama_test_cases
[x
].key
));
2740 memcached_server_instance_st
*instance
=
2741 memcached_server_instance_fetch(memc
, server_idx
);
2742 char *hostname
= instance
->hostname
;
2743 test_strcmp(hostname
, ketama_test_cases
[x
].server
);
2746 memcached_server_list_free(server_pool
);
2747 memcached_free(memc
);
2749 return TEST_SUCCESS
;
2752 /* Large mget() of missing keys with binary proto
2754 * If many binary quiet commands (such as getq's in an mget) fill the output
2755 * buffer and the server chooses not to respond, memcached_flush hangs. See
2756 * http://lists.tangent.org/pipermail/libmemcached/2009-August/000918.html
2759 /* sighandler_t function that always asserts false */
2760 static void fail(int unused
__attribute__((unused
)))
2766 static test_return_t
_user_supplied_bug21(memcached_st
* memc
, size_t key_count
)
2768 memcached_return_t rc
;
2771 size_t* key_lengths
;
2772 void (*oldalarm
)(int);
2773 memcached_st
*memc_clone
;
2775 memc_clone
= memcached_clone(NULL
, memc
);
2776 test_truth(memc_clone
);
2778 /* only binproto uses getq for mget */
2779 memcached_behavior_set(memc_clone
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
, 1);
2781 /* empty the cache to ensure misses (hence non-responses) */
2782 rc
= memcached_flush(memc_clone
, 0);
2783 test_truth(rc
== MEMCACHED_SUCCESS
);
2785 key_lengths
= calloc(key_count
, sizeof(size_t));
2786 keys
= calloc(key_count
, sizeof(char *));
2788 for (x
= 0; x
< key_count
; x
++)
2792 snprintf(buffer
, 30, "%u", x
);
2793 keys
[x
]= strdup(buffer
);
2794 key_lengths
[x
]= strlen(keys
[x
]);
2797 oldalarm
= signal(SIGALRM
, fail
);
2800 rc
= memcached_mget(memc_clone
, (const char **)keys
, key_lengths
, key_count
);
2801 test_truth(rc
== MEMCACHED_SUCCESS
);
2804 signal(SIGALRM
, oldalarm
);
2806 test_truth(fetch_all_results(memc
) == TEST_SUCCESS
);
2808 for (x
= 0; x
< key_count
; x
++)
2813 memcached_free(memc_clone
);
2815 return TEST_SUCCESS
;
2818 static test_return_t
pre_binary(memcached_st
*memc
);
2820 static test_return_t
user_supplied_bug21(memcached_st
*memc
)
2822 test_return_t test_rc
;
2823 test_rc
= pre_binary(memc
);
2825 if (test_rc
!= TEST_SUCCESS
)
2830 /* should work as of r580 */
2831 rc
= _user_supplied_bug21(memc
, 10);
2832 test_truth(rc
== TEST_SUCCESS
);
2834 /* should fail as of r580 */
2835 rc
= _user_supplied_bug21(memc
, 1000);
2836 test_truth(rc
== TEST_SUCCESS
);
2838 return TEST_SUCCESS
;
2841 static test_return_t
auto_eject_hosts(memcached_st
*trash
)
2844 memcached_server_instance_st
*instance
;
2846 memcached_return_t rc
;
2847 memcached_st
*memc
= memcached_create(NULL
);
2850 rc
= memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_KETAMA_WEIGHTED
, 1);
2851 test_truth(rc
== MEMCACHED_SUCCESS
);
2853 uint64_t value
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_KETAMA_WEIGHTED
);
2854 test_truth(value
== 1);
2856 rc
= memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_KETAMA_HASH
, MEMCACHED_HASH_MD5
);
2857 test_truth(rc
== MEMCACHED_SUCCESS
);
2859 value
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_KETAMA_HASH
);
2860 test_truth(value
== MEMCACHED_HASH_MD5
);
2862 /* server should be removed when in delay */
2863 rc
= memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_AUTO_EJECT_HOSTS
, 1);
2864 test_truth(rc
== MEMCACHED_SUCCESS
);
2866 value
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_AUTO_EJECT_HOSTS
);
2867 test_truth(value
== 1);
2869 memcached_server_st
*server_pool
;
2870 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");
2871 memcached_server_push(memc
, server_pool
);
2873 /* verify that the server list was parsed okay. */
2874 test_truth(memcached_server_count(memc
) == 8);
2875 test_truth(strcmp(server_pool
[0].hostname
, "10.0.1.1") == 0);
2876 test_truth(server_pool
[0].port
== 11211);
2877 test_truth(server_pool
[0].weight
== 600);
2878 test_truth(strcmp(server_pool
[2].hostname
, "10.0.1.3") == 0);
2879 test_truth(server_pool
[2].port
== 11211);
2880 test_truth(server_pool
[2].weight
== 200);
2881 test_truth(strcmp(server_pool
[7].hostname
, "10.0.1.8") == 0);
2882 test_truth(server_pool
[7].port
== 11211);
2883 test_truth(server_pool
[7].weight
== 100);
2885 instance
= memcached_server_instance_fetch(memc
, 2);
2886 instance
->next_retry
= time(NULL
) + 15;
2887 memc
->next_distribution_rebuild
= time(NULL
) - 1;
2889 for (size_t x
= 0; x
< 99; x
++)
2891 uint32_t server_idx
= memcached_generate_hash(memc
, ketama_test_cases
[x
].key
, strlen(ketama_test_cases
[x
].key
));
2892 test_truth(server_idx
!= 2);
2895 /* and re-added when it's back. */
2896 instance
->next_retry
= time(NULL
) - 1;
2897 memc
->next_distribution_rebuild
= time(NULL
) - 1;
2898 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_DISTRIBUTION
,
2899 memc
->distribution
);
2900 for (size_t x
= 0; x
< 99; x
++)
2902 uint32_t server_idx
= memcached_generate_hash(memc
, ketama_test_cases
[x
].key
, strlen(ketama_test_cases
[x
].key
));
2903 // We re-use instance from above.
2905 memcached_server_instance_fetch(memc
, server_idx
);
2906 char *hostname
= instance
->hostname
;
2907 test_truth(strcmp(hostname
, ketama_test_cases
[x
].server
) == 0);
2910 memcached_server_list_free(server_pool
);
2911 memcached_free(memc
);
2913 return TEST_SUCCESS
;
2916 static test_return_t
output_ketama_weighted_keys(memcached_st
*trash
)
2920 memcached_return_t rc
;
2921 memcached_st
*memc
= memcached_create(NULL
);
2925 rc
= memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_KETAMA_WEIGHTED
, 1);
2926 test_truth(rc
== MEMCACHED_SUCCESS
);
2928 uint64_t value
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_KETAMA_WEIGHTED
);
2929 test_truth(value
== 1);
2931 rc
= memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_KETAMA_HASH
, MEMCACHED_HASH_MD5
);
2932 test_truth(rc
== MEMCACHED_SUCCESS
);
2934 value
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_KETAMA_HASH
);
2935 test_truth(value
== MEMCACHED_HASH_MD5
);
2938 test_truth(memcached_behavior_set_distribution(memc
, MEMCACHED_DISTRIBUTION_CONSISTENT_KETAMA_SPY
) == MEMCACHED_SUCCESS
);
2940 memcached_server_st
*server_pool
;
2941 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");
2942 memcached_server_push(memc
, server_pool
);
2944 // @todo this needs to be refactored to actually test something.
2947 if ((fp
= fopen("ketama_keys.txt", "w")))
2951 printf("cannot write to file ketama_keys.txt");
2952 return TEST_FAILURE
;
2955 for (int x
= 0; x
< 10000; x
++)
2958 sprintf(key
, "%d", x
);
2960 uint32_t server_idx
= memcached_generate_hash(memc
, key
, strlen(key
));
2961 char *hostname
= memc
->hosts
[server_idx
].hostname
;
2962 in_port_t port
= memc
->hosts
[server_idx
].port
;
2963 fprintf(fp
, "key %s is on host /%s:%u\n", key
, hostname
, port
);
2967 memcached_server_list_free(server_pool
);
2968 memcached_free(memc
);
2970 return TEST_SUCCESS
;
2974 static test_return_t
result_static(memcached_st
*memc
)
2976 memcached_result_st result
;
2977 memcached_result_st
*result_ptr
;
2979 result_ptr
= memcached_result_create(memc
, &result
);
2980 test_truth(result
.options
.is_allocated
== false);
2981 test_truth(memcached_is_initialized(&result
) == true);
2982 test_truth(result_ptr
);
2983 test_truth(result_ptr
== &result
);
2985 memcached_result_free(&result
);
2987 test_truth(result
.options
.is_allocated
== false);
2988 test_truth(memcached_is_initialized(&result
) == false);
2990 return TEST_SUCCESS
;
2993 static test_return_t
result_alloc(memcached_st
*memc
)
2995 memcached_result_st
*result_ptr
;
2997 result_ptr
= memcached_result_create(memc
, NULL
);
2998 test_truth(result_ptr
);
2999 test_truth(result_ptr
->options
.is_allocated
== true);
3000 test_truth(memcached_is_initialized(result_ptr
) == true);
3001 memcached_result_free(result_ptr
);
3003 return TEST_SUCCESS
;
3006 static test_return_t
string_static_null(memcached_st
*memc
)
3008 memcached_string_st string
;
3009 memcached_string_st
*string_ptr
;
3011 string_ptr
= memcached_string_create(memc
, &string
, 0);
3012 test_truth(string
.options
.is_initialized
== true);
3013 test_truth(string_ptr
);
3015 /* The following two better be the same! */
3016 test_truth(memcached_is_allocated(string_ptr
) == false);
3017 test_truth(memcached_is_allocated(&string
) == false);
3018 test_truth(&string
== string_ptr
);
3020 test_truth(string
.options
.is_initialized
== true);
3021 test_truth(memcached_is_initialized(&string
) == true);
3022 memcached_string_free(&string
);
3023 test_truth(memcached_is_initialized(&string
) == false);
3025 return TEST_SUCCESS
;
3028 static test_return_t
string_alloc_null(memcached_st
*memc
)
3030 memcached_string_st
*string
;
3032 string
= memcached_string_create(memc
, NULL
, 0);
3034 test_truth(memcached_is_allocated(string
) == true);
3035 test_truth(memcached_is_initialized(string
) == true);
3036 memcached_string_free(string
);
3038 return TEST_SUCCESS
;
3041 static test_return_t
string_alloc_with_size(memcached_st
*memc
)
3043 memcached_string_st
*string
;
3045 string
= memcached_string_create(memc
, NULL
, 1024);
3047 test_truth(memcached_is_allocated(string
) == true);
3048 test_truth(memcached_is_initialized(string
) == true);
3049 memcached_string_free(string
);
3051 return TEST_SUCCESS
;
3054 static test_return_t
string_alloc_with_size_toobig(memcached_st
*memc
)
3056 memcached_string_st
*string
;
3058 string
= memcached_string_create(memc
, NULL
, SIZE_MAX
);
3059 test_truth(string
== NULL
);
3061 return TEST_SUCCESS
;
3064 static test_return_t
string_alloc_append(memcached_st
*memc
)
3067 char buffer
[SMALL_STRING_LEN
];
3068 memcached_string_st
*string
;
3070 /* Ring the bell! */
3071 memset(buffer
, 6, SMALL_STRING_LEN
);
3073 string
= memcached_string_create(memc
, NULL
, 100);
3075 test_truth(memcached_is_allocated(string
) == true);
3076 test_truth(memcached_is_initialized(string
) == true);
3078 for (x
= 0; x
< 1024; x
++)
3080 memcached_return_t rc
;
3081 rc
= memcached_string_append(string
, buffer
, SMALL_STRING_LEN
);
3082 test_truth(rc
== MEMCACHED_SUCCESS
);
3084 test_truth(memcached_is_allocated(string
) == true);
3085 memcached_string_free(string
);
3087 return TEST_SUCCESS
;
3090 static test_return_t
string_alloc_append_toobig(memcached_st
*memc
)
3092 memcached_return_t rc
;
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_truth(memcached_is_allocated(string
) == true);
3103 test_truth(memcached_is_initialized(string
) == true);
3105 for (x
= 0; x
< 1024; x
++)
3107 rc
= memcached_string_append(string
, buffer
, SMALL_STRING_LEN
);
3108 test_truth(rc
== MEMCACHED_SUCCESS
);
3110 rc
= memcached_string_append(string
, buffer
, SIZE_MAX
);
3111 test_truth(rc
== MEMCACHED_MEMORY_ALLOCATION_FAILURE
);
3112 test_truth(memcached_is_allocated(string
) == true);
3113 memcached_string_free(string
);
3115 return TEST_SUCCESS
;
3118 static test_return_t
cleanup_pairs(memcached_st
*memc
__attribute__((unused
)))
3120 pairs_free(global_pairs
);
3122 return TEST_SUCCESS
;
3125 static test_return_t
generate_pairs(memcached_st
*memc
__attribute__((unused
)))
3127 global_pairs
= pairs_generate(GLOBAL_COUNT
, 400);
3128 global_count
= GLOBAL_COUNT
;
3130 for (size_t x
= 0; x
< global_count
; x
++)
3132 global_keys
[x
]= global_pairs
[x
].key
;
3133 global_keys_length
[x
]= global_pairs
[x
].key_length
;
3136 return TEST_SUCCESS
;
3139 static test_return_t
generate_large_pairs(memcached_st
*memc
__attribute__((unused
)))
3141 global_pairs
= pairs_generate(GLOBAL2_COUNT
, MEMCACHED_MAX_BUFFER
+10);
3142 global_count
= GLOBAL2_COUNT
;
3144 for (size_t x
= 0; x
< global_count
; x
++)
3146 global_keys
[x
]= global_pairs
[x
].key
;
3147 global_keys_length
[x
]= global_pairs
[x
].key_length
;
3150 return TEST_SUCCESS
;
3153 static test_return_t
generate_data(memcached_st
*memc
)
3155 execute_set(memc
, global_pairs
, global_count
);
3157 return TEST_SUCCESS
;
3160 static test_return_t
generate_data_with_stats(memcached_st
*memc
)
3162 memcached_stat_st
*stat_p
;
3163 memcached_return_t rc
;
3164 uint32_t host_index
= 0;
3165 execute_set(memc
, global_pairs
, global_count
);
3167 //TODO: hosts used size stats
3168 stat_p
= memcached_stat(memc
, NULL
, &rc
);
3171 for (host_index
= 0; host_index
< SERVERS_TO_CREATE
; host_index
++)
3173 /* This test was changes so that "make test" would work properlly */
3175 memcached_server_instance_st
*instance
=
3176 memcached_server_instance_fetch(memc
, host_index
);
3178 printf("\nserver %u|%s|%u bytes: %llu\n", host_index
, instance
->hostname
, instance
->port
, (unsigned long long)(stat_p
+ host_index
)->bytes
);
3180 test_truth((unsigned long long)(stat_p
+ host_index
)->bytes
);
3183 memcached_stat_free(NULL
, stat_p
);
3185 return TEST_SUCCESS
;
3187 static test_return_t
generate_buffer_data(memcached_st
*memc
)
3192 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_BUFFER_REQUESTS
, latch
);
3193 generate_data(memc
);
3195 return TEST_SUCCESS
;
3198 static test_return_t
get_read_count(memcached_st
*memc
)
3200 memcached_return_t rc
;
3201 memcached_st
*memc_clone
;
3203 memc_clone
= memcached_clone(NULL
, memc
);
3204 test_truth(memc_clone
);
3206 memcached_server_add_with_weight(memc_clone
, "localhost", 6666, 0);
3210 size_t return_value_length
;
3214 for (size_t x
= count
= 0; x
< global_count
; x
++)
3216 return_value
= memcached_get(memc_clone
, global_keys
[x
], global_keys_length
[x
],
3217 &return_value_length
, &flags
, &rc
);
3218 if (rc
== MEMCACHED_SUCCESS
)
3227 memcached_free(memc_clone
);
3229 return TEST_SUCCESS
;
3232 static test_return_t
get_read(memcached_st
*memc
)
3234 memcached_return_t rc
;
3238 size_t return_value_length
;
3241 for (size_t x
= 0; x
< global_count
; x
++)
3243 return_value
= memcached_get(memc
, global_keys
[x
], global_keys_length
[x
],
3244 &return_value_length
, &flags
, &rc
);
3246 test_truth(return_value);
3247 test_truth(rc == MEMCACHED_SUCCESS);
3249 if (rc
== MEMCACHED_SUCCESS
&& return_value
)
3254 return TEST_SUCCESS
;
3257 static test_return_t
mget_read(memcached_st
*memc
)
3259 memcached_return_t rc
;
3261 rc
= memcached_mget(memc
, global_keys
, global_keys_length
, global_count
);
3262 test_truth(rc
== MEMCACHED_SUCCESS
);
3263 test_truth(fetch_all_results(memc
) == TEST_SUCCESS
);
3265 return TEST_SUCCESS
;
3268 static test_return_t
mget_read_result(memcached_st
*memc
)
3270 memcached_return_t rc
;
3272 rc
= memcached_mget(memc
, global_keys
, global_keys_length
, global_count
);
3273 test_truth(rc
== MEMCACHED_SUCCESS
);
3274 /* Turn this into a help function */
3276 memcached_result_st results_obj
;
3277 memcached_result_st
*results
;
3279 results
= memcached_result_create(memc
, &results_obj
);
3281 while ((results
= memcached_fetch_result(memc
, &results_obj
, &rc
)))
3283 test_truth(results
);
3284 test_truth(rc
== MEMCACHED_SUCCESS
);
3287 memcached_result_free(&results_obj
);
3290 return TEST_SUCCESS
;
3293 static test_return_t
mget_read_function(memcached_st
*memc
)
3295 memcached_return_t rc
;
3297 memcached_execute_fn callbacks
[1];
3299 rc
= memcached_mget(memc
, global_keys
, global_keys_length
, global_count
);
3300 test_truth(rc
== MEMCACHED_SUCCESS
);
3302 callbacks
[0]= &callback_counter
;
3304 rc
= memcached_fetch_execute(memc
, callbacks
, (void *)&counter
, 1);
3306 return TEST_SUCCESS
;
3309 static test_return_t
delete_generate(memcached_st
*memc
)
3311 for (size_t x
= 0; x
< global_count
; x
++)
3313 (void)memcached_delete(memc
, global_keys
[x
], global_keys_length
[x
], (time_t)0);
3316 return TEST_SUCCESS
;
3319 static test_return_t
delete_buffer_generate(memcached_st
*memc
)
3324 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_BUFFER_REQUESTS
, latch
);
3326 for (size_t x
= 0; x
< global_count
; x
++)
3328 (void)memcached_delete(memc
, global_keys
[x
], global_keys_length
[x
], (time_t)0);
3331 return TEST_SUCCESS
;
3334 static test_return_t
add_host_test1(memcached_st
*memc
)
3336 memcached_return_t rc
;
3337 char servername
[]= "0.example.com";
3338 memcached_server_st
*servers
;
3340 servers
= memcached_server_list_append_with_weight(NULL
, servername
, 400, 0, &rc
);
3341 test_truth(servers
);
3342 test_truth(1 == memcached_server_list_count(servers
));
3344 for (size_t x
= 2; x
< 20; x
++)
3346 char buffer
[SMALL_STRING_LEN
];
3348 snprintf(buffer
, SMALL_STRING_LEN
, "%zu.example.com", 400+x
);
3349 servers
= memcached_server_list_append_with_weight(servers
, buffer
, 401, 0,
3351 test_truth(rc
== MEMCACHED_SUCCESS
);
3352 test_truth(x
== memcached_server_list_count(servers
));
3355 rc
= memcached_server_push(memc
, servers
);
3356 test_truth(rc
== MEMCACHED_SUCCESS
);
3357 rc
= memcached_server_push(memc
, servers
);
3358 test_truth(rc
== MEMCACHED_SUCCESS
);
3360 memcached_server_list_free(servers
);
3362 return TEST_SUCCESS
;
3365 static test_return_t
pre_nonblock(memcached_st
*memc
)
3367 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NO_BLOCK
, 0);
3369 return TEST_SUCCESS
;
3372 static test_return_t
pre_nonblock_binary(memcached_st
*memc
)
3374 memcached_return_t rc
= MEMCACHED_FAILURE
;
3375 memcached_st
*memc_clone
;
3376 memcached_server_instance_st
*instance
;
3378 memc_clone
= memcached_clone(NULL
, memc
);
3379 test_truth(memc_clone
);
3380 // The memcached_version needs to be done on a clone, because the server
3381 // will not toggle protocol on an connection.
3382 memcached_version(memc_clone
);
3384 instance
= memcached_server_instance_fetch(memc_clone
, 0);
3386 if (instance
->major_version
>= 1 && instance
->minor_version
> 2)
3388 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NO_BLOCK
, 0);
3389 rc
= memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
, 1);
3390 test_truth(rc
== MEMCACHED_SUCCESS
);
3391 test_truth(memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
) == 1);
3395 return TEST_SKIPPED
;
3398 memcached_free(memc_clone
);
3400 return rc
== MEMCACHED_SUCCESS
? TEST_SUCCESS
: TEST_SKIPPED
;
3403 static test_return_t
pre_murmur(memcached_st
*memc
)
3405 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_HASH
, (uint64_t)MEMCACHED_HASH_MURMUR
);
3407 return TEST_SUCCESS
;
3410 static test_return_t
pre_jenkins(memcached_st
*memc
)
3412 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_HASH
, (uint64_t)MEMCACHED_HASH_JENKINS
);
3414 return TEST_SUCCESS
;
3418 static test_return_t
pre_md5(memcached_st
*memc
)
3420 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_HASH
, (uint64_t)MEMCACHED_HASH_MD5
);
3422 return TEST_SUCCESS
;
3425 static test_return_t
pre_crc(memcached_st
*memc
)
3427 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_HASH
, (uint64_t)MEMCACHED_HASH_CRC
);
3429 return TEST_SUCCESS
;
3432 static test_return_t
pre_hsieh(memcached_st
*memc
)
3434 #ifdef HAVE_HSIEH_HASH
3435 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_HASH
, (uint64_t)MEMCACHED_HASH_HSIEH
);
3436 return TEST_SUCCESS
;
3439 return TEST_SKIPPED
;
3443 static test_return_t
pre_hash_fnv1_64(memcached_st
*memc
)
3445 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_HASH
, (uint64_t)MEMCACHED_HASH_MURMUR
);
3447 return TEST_SUCCESS
;
3450 static test_return_t
pre_hash_fnv1a_64(memcached_st
*memc
)
3452 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_HASH
, (uint64_t)MEMCACHED_HASH_FNV1A_64
);
3454 return TEST_SUCCESS
;
3457 static test_return_t
pre_hash_fnv1_32(memcached_st
*memc
)
3459 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_HASH
, (uint64_t)MEMCACHED_HASH_FNV1_32
);
3461 return TEST_SUCCESS
;
3464 static test_return_t
pre_hash_fnv1a_32(memcached_st
*memc
)
3466 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_HASH
, (uint64_t)MEMCACHED_HASH_FNV1A_32
);
3468 return TEST_SUCCESS
;
3471 static test_return_t
pre_behavior_ketama(memcached_st
*memc
)
3473 memcached_return_t rc
;
3476 rc
= memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_KETAMA
, 1);
3477 test_truth(rc
== MEMCACHED_SUCCESS
);
3479 value
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_KETAMA
);
3480 test_truth(value
== 1);
3482 return TEST_SUCCESS
;
3485 static test_return_t
pre_behavior_ketama_weighted(memcached_st
*memc
)
3487 memcached_return_t rc
;
3490 rc
= memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_KETAMA_WEIGHTED
, 1);
3491 test_truth(rc
== MEMCACHED_SUCCESS
);
3493 value
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_KETAMA_WEIGHTED
);
3494 test_truth(value
== 1);
3496 rc
= memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_KETAMA_HASH
, MEMCACHED_HASH_MD5
);
3497 test_truth(rc
== MEMCACHED_SUCCESS
);
3499 value
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_KETAMA_HASH
);
3500 test_truth(value
== MEMCACHED_HASH_MD5
);
3502 return TEST_SUCCESS
;
3506 @note This should be testing to see if the server really supports the binary protocol.
3508 static test_return_t
pre_binary(memcached_st
*memc
)
3510 memcached_return_t rc
= MEMCACHED_FAILURE
;
3511 memcached_st
*memc_clone
;
3512 memcached_server_instance_st
*instance
;
3514 memc_clone
= memcached_clone(NULL
, memc
);
3515 test_truth(memc_clone
);
3516 // The memcached_version needs to be done on a clone, because the server
3517 // will not toggle protocol on an connection.
3518 memcached_version(memc_clone
);
3520 instance
= memcached_server_instance_fetch(memc_clone
, 0);
3522 if (instance
->major_version
>= 1 && instance
->minor_version
> 2)
3524 rc
= memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
, 1);
3525 test_truth(rc
== MEMCACHED_SUCCESS
);
3526 test_truth(memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
) == 1);
3529 memcached_free(memc_clone
);
3531 return rc
== MEMCACHED_SUCCESS
? TEST_SUCCESS
: TEST_SKIPPED
;
3535 static test_return_t
pre_replication(memcached_st
*memc
)
3537 test_return_t test_rc
;
3538 test_rc
= pre_binary(memc
);
3540 if (test_rc
!= TEST_SUCCESS
)
3544 * Make sure that we store the item on all servers
3545 * (master + replicas == number of servers)
3547 memcached_return_t rc
;
3548 rc
= memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NUMBER_OF_REPLICAS
,
3549 memcached_server_count(memc
) - 1);
3550 test_truth(rc
== MEMCACHED_SUCCESS
);
3551 test_truth(memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_NUMBER_OF_REPLICAS
) == memcached_server_count(memc
) - 1);
3553 return rc
== MEMCACHED_SUCCESS
? TEST_SUCCESS
: TEST_SKIPPED
;
3557 static test_return_t
pre_replication_noblock(memcached_st
*memc
)
3561 rc
= pre_replication(memc
);
3562 if (rc
!= TEST_SUCCESS
)
3565 rc
= pre_nonblock(memc
);
3571 static void my_free(memcached_st
*ptr
__attribute__((unused
)), void *mem
)
3573 #ifdef HARD_MALLOC_TESTS
3574 void *real_ptr
= (mem
== NULL
) ? mem
: (void*)((caddr_t
)mem
- 8);
3582 static void *my_malloc(memcached_st
*ptr
__attribute__((unused
)), const size_t size
)
3584 #ifdef HARD_MALLOC_TESTS
3585 void *ret
= malloc(size
+ 8);
3588 ret
= (void*)((caddr_t
)ret
+ 8);
3591 void *ret
= malloc(size
);
3596 memset(ret
, 0xff, size
);
3603 static void *my_realloc(memcached_st
*ptr
__attribute__((unused
)), void *mem
, const size_t size
)
3605 #ifdef HARD_MALLOC_TESTS
3606 void *real_ptr
= (mem
== NULL
) ? NULL
: (void*)((caddr_t
)mem
- 8);
3607 void *nmem
= realloc(real_ptr
, size
+ 8);
3612 ret
= (void*)((caddr_t
)nmem
+ 8);
3617 return realloc(mem
, size
);
3622 static void *my_calloc(memcached_st
*ptr
__attribute__((unused
)), size_t nelem
, const size_t size
)
3624 #ifdef HARD_MALLOC_TESTS
3625 void *mem
= my_malloc(ptr
, nelem
* size
);
3628 memset(mem
, 0, nelem
* size
);
3633 return calloc(nelem
, size
);
3638 static test_return_t
set_prefix(memcached_st
*memc
)
3640 memcached_return_t rc
;
3641 const char *key
= "mine";
3644 /* Make sure be default none exists */
3645 value
= memcached_callback_get(memc
, MEMCACHED_CALLBACK_PREFIX_KEY
, &rc
);
3646 test_truth(rc
== MEMCACHED_FAILURE
);
3648 /* Test a clean set */
3649 rc
= memcached_callback_set(memc
, MEMCACHED_CALLBACK_PREFIX_KEY
, (void *)key
);
3650 test_truth(rc
== MEMCACHED_SUCCESS
);
3652 value
= memcached_callback_get(memc
, MEMCACHED_CALLBACK_PREFIX_KEY
, &rc
);
3653 test_truth(memcmp(value
, key
, 4) == 0);
3654 test_truth(rc
== MEMCACHED_SUCCESS
);
3656 /* Test that we can turn it off */
3657 rc
= memcached_callback_set(memc
, MEMCACHED_CALLBACK_PREFIX_KEY
, NULL
);
3658 test_truth(rc
== MEMCACHED_SUCCESS
);
3660 value
= memcached_callback_get(memc
, MEMCACHED_CALLBACK_PREFIX_KEY
, &rc
);
3661 test_truth(rc
== MEMCACHED_FAILURE
);
3663 /* Now setup for main test */
3664 rc
= memcached_callback_set(memc
, MEMCACHED_CALLBACK_PREFIX_KEY
, (void *)key
);
3665 test_truth(rc
== MEMCACHED_SUCCESS
);
3667 value
= memcached_callback_get(memc
, MEMCACHED_CALLBACK_PREFIX_KEY
, &rc
);
3668 test_truth(rc
== MEMCACHED_SUCCESS
);
3669 test_truth(memcmp(value
, key
, 4) == 0);
3671 /* Set to Zero, and then Set to something too large */
3674 memset(long_key
, 0, 255);
3676 rc
= memcached_callback_set(memc
, MEMCACHED_CALLBACK_PREFIX_KEY
, NULL
);
3677 test_truth(rc
== MEMCACHED_SUCCESS
);
3679 value
= memcached_callback_get(memc
, MEMCACHED_CALLBACK_PREFIX_KEY
, &rc
);
3680 test_truth(rc
== MEMCACHED_FAILURE
);
3681 test_truth(value
== NULL
);
3683 /* Test a long key for failure */
3684 /* TODO, extend test to determine based on setting, what result should be */
3685 strcpy(long_key
, "Thisismorethentheallottednumberofcharacters");
3686 rc
= memcached_callback_set(memc
, MEMCACHED_CALLBACK_PREFIX_KEY
, long_key
);
3687 //test_truth(rc == MEMCACHED_BAD_KEY_PROVIDED);
3688 test_truth(rc
== MEMCACHED_SUCCESS
);
3690 /* Now test a key with spaces (which will fail from long key, since bad key is not set) */
3691 strcpy(long_key
, "This is more then the allotted number of characters");
3692 rc
= memcached_callback_set(memc
, MEMCACHED_CALLBACK_PREFIX_KEY
, long_key
);
3693 test_truth(rc
== MEMCACHED_BAD_KEY_PROVIDED
);
3695 /* Test for a bad prefix, but with a short key */
3696 rc
= memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_VERIFY_KEY
, 1);
3697 test_truth(rc
== MEMCACHED_SUCCESS
);
3699 strcpy(long_key
, "dog cat");
3700 rc
= memcached_callback_set(memc
, MEMCACHED_CALLBACK_PREFIX_KEY
, long_key
);
3701 test_truth(rc
== MEMCACHED_BAD_KEY_PROVIDED
);
3704 return TEST_SUCCESS
;
3708 #ifdef MEMCACHED_ENABLE_DEPRECATED
3709 static test_return_t
deprecated_set_memory_alloc(memcached_st
*memc
)
3711 void *test_ptr
= NULL
;
3714 memcached_malloc_fn malloc_cb
=
3715 (memcached_malloc_fn
)my_malloc
;
3716 cb_ptr
= *(void **)&malloc_cb
;
3717 memcached_return_t rc
;
3719 rc
= memcached_callback_set(memc
, MEMCACHED_CALLBACK_MALLOC_FUNCTION
, cb_ptr
);
3720 test_truth(rc
== MEMCACHED_SUCCESS
);
3721 test_ptr
= memcached_callback_get(memc
, MEMCACHED_CALLBACK_MALLOC_FUNCTION
, &rc
);
3722 test_truth(rc
== MEMCACHED_SUCCESS
);
3723 test_truth(test_ptr
== cb_ptr
);
3727 memcached_realloc_fn realloc_cb
=
3728 (memcached_realloc_fn
)my_realloc
;
3729 cb_ptr
= *(void **)&realloc_cb
;
3730 memcached_return_t rc
;
3732 rc
= memcached_callback_set(memc
, MEMCACHED_CALLBACK_REALLOC_FUNCTION
, cb_ptr
);
3733 test_truth(rc
== MEMCACHED_SUCCESS
);
3734 test_ptr
= memcached_callback_get(memc
, MEMCACHED_CALLBACK_REALLOC_FUNCTION
, &rc
);
3735 test_truth(rc
== MEMCACHED_SUCCESS
);
3736 test_truth(test_ptr
== cb_ptr
);
3740 memcached_free_fn free_cb
=
3741 (memcached_free_fn
)my_free
;
3742 cb_ptr
= *(void **)&free_cb
;
3743 memcached_return_t rc
;
3745 rc
= memcached_callback_set(memc
, MEMCACHED_CALLBACK_FREE_FUNCTION
, cb_ptr
);
3746 test_truth(rc
== MEMCACHED_SUCCESS
);
3747 test_ptr
= memcached_callback_get(memc
, MEMCACHED_CALLBACK_FREE_FUNCTION
, &rc
);
3748 test_truth(rc
== MEMCACHED_SUCCESS
);
3749 test_truth(test_ptr
== cb_ptr
);
3752 return TEST_SUCCESS
;
3757 static test_return_t
set_memory_alloc(memcached_st
*memc
)
3759 memcached_return_t rc
;
3760 rc
= memcached_set_memory_allocators(memc
, NULL
, my_free
,
3761 my_realloc
, my_calloc
);
3762 test_truth(rc
== MEMCACHED_FAILURE
);
3764 rc
= memcached_set_memory_allocators(memc
, my_malloc
, my_free
,
3765 my_realloc
, my_calloc
);
3767 memcached_malloc_fn mem_malloc
;
3768 memcached_free_fn mem_free
;
3769 memcached_realloc_fn mem_realloc
;
3770 memcached_calloc_fn mem_calloc
;
3771 memcached_get_memory_allocators(memc
, &mem_malloc
, &mem_free
,
3772 &mem_realloc
, &mem_calloc
);
3774 test_truth(mem_malloc
== my_malloc
);
3775 test_truth(mem_realloc
== my_realloc
);
3776 test_truth(mem_calloc
== my_calloc
);
3777 test_truth(mem_free
== my_free
);
3779 return TEST_SUCCESS
;
3782 static test_return_t
enable_consistent_crc(memcached_st
*memc
)
3785 memcached_server_distribution_t value
= MEMCACHED_DISTRIBUTION_CONSISTENT
;
3786 memcached_hash_t hash
;
3787 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_DISTRIBUTION
, value
);
3788 if ((rc
= pre_crc(memc
)) != TEST_SUCCESS
)
3791 value
= (memcached_server_distribution_t
)memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_DISTRIBUTION
);
3792 test_truth(value
== MEMCACHED_DISTRIBUTION_CONSISTENT
);
3794 hash
= (memcached_hash_t
)memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_HASH
);
3796 if (hash
!= MEMCACHED_HASH_CRC
)
3797 return TEST_SKIPPED
;
3799 return TEST_SUCCESS
;
3802 static test_return_t
enable_consistent_hsieh(memcached_st
*memc
)
3805 memcached_server_distribution_t value
= MEMCACHED_DISTRIBUTION_CONSISTENT
;
3806 memcached_hash_t hash
;
3807 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_DISTRIBUTION
, value
);
3808 if ((rc
= pre_hsieh(memc
)) != TEST_SUCCESS
)
3811 value
= (memcached_server_distribution_t
)memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_DISTRIBUTION
);
3812 test_truth(value
== MEMCACHED_DISTRIBUTION_CONSISTENT
);
3814 hash
= (memcached_hash_t
)memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_HASH
);
3816 if (hash
!= MEMCACHED_HASH_HSIEH
)
3817 return TEST_SKIPPED
;
3820 return TEST_SUCCESS
;
3823 static test_return_t
enable_cas(memcached_st
*memc
)
3825 unsigned int set
= 1;
3827 memcached_server_instance_st
*instance
=
3828 memcached_server_instance_fetch(memc
, 0);
3830 memcached_version(memc
);
3832 if ((instance
->major_version
>= 1 && (instance
->minor_version
== 2 && instance
->micro_version
>= 4))
3833 || instance
->minor_version
> 2)
3835 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_SUPPORT_CAS
, set
);
3837 return TEST_SUCCESS
;
3840 return TEST_SKIPPED
;
3843 static test_return_t
check_for_1_2_3(memcached_st
*memc
)
3845 memcached_version(memc
);
3846 memcached_server_instance_st
*instance
=
3847 memcached_server_instance_fetch(memc
, 0);
3849 if ((instance
->major_version
>= 1 && (instance
->minor_version
== 2 && instance
->micro_version
>= 4))
3850 || instance
->minor_version
> 2)
3851 return TEST_SUCCESS
;
3853 return TEST_SKIPPED
;
3856 static test_return_t
pre_unix_socket(memcached_st
*memc
)
3858 memcached_return_t rc
;
3861 memcached_servers_reset(memc
);
3863 if (stat("/tmp/memcached.socket", &buf
))
3864 return TEST_SKIPPED
;
3866 rc
= memcached_server_add_unix_socket_with_weight(memc
, "/tmp/memcached.socket", 0);
3868 return ( rc
== MEMCACHED_SUCCESS
? TEST_SUCCESS
: TEST_FAILURE
);
3871 static test_return_t
pre_nodelay(memcached_st
*memc
)
3873 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NO_BLOCK
, 0);
3874 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_TCP_NODELAY
, 0);
3876 return TEST_SUCCESS
;
3879 static test_return_t
pre_settimer(memcached_st
*memc
)
3881 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_SND_TIMEOUT
, 1000);
3882 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_RCV_TIMEOUT
, 1000);
3884 return TEST_SUCCESS
;
3887 static test_return_t
poll_timeout(memcached_st
*memc
)
3893 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_POLL_TIMEOUT
, timeout
);
3895 timeout
= (size_t)memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_POLL_TIMEOUT
);
3897 test_truth(timeout
== 100);
3899 return TEST_SUCCESS
;
3902 static test_return_t
noreply_test(memcached_st
*memc
)
3904 memcached_return_t ret
;
3905 ret
= memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NOREPLY
, 1);
3906 test_truth(ret
== MEMCACHED_SUCCESS
);
3907 ret
= memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_BUFFER_REQUESTS
, 1);
3908 test_truth(ret
== MEMCACHED_SUCCESS
);
3909 ret
= memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_SUPPORT_CAS
, 1);
3910 test_truth(ret
== MEMCACHED_SUCCESS
);
3911 test_truth(memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_NOREPLY
) == 1);
3912 test_truth(memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_BUFFER_REQUESTS
) == 1);
3913 test_truth(memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_SUPPORT_CAS
) == 1);
3915 for (int count
=0; count
< 5; ++count
)
3917 for (size_t x
= 0; x
< 100; ++x
)
3920 size_t len
= (size_t)sprintf(key
, "%zu", x
);
3924 ret
= memcached_add(memc
, key
, len
, key
, len
, 0, 0);
3927 ret
= memcached_replace(memc
, key
, len
, key
, len
, 0, 0);
3930 ret
= memcached_set(memc
, key
, len
, key
, len
, 0, 0);
3933 ret
= memcached_append(memc
, key
, len
, key
, len
, 0, 0);
3936 ret
= memcached_prepend(memc
, key
, len
, key
, len
, 0, 0);
3942 test_truth(ret
== MEMCACHED_SUCCESS
|| ret
== MEMCACHED_BUFFERED
);
3946 ** NOTE: Don't ever do this in your code! this is not a supported use of the
3947 ** API and is _ONLY_ done this way to verify that the library works the
3948 ** way it is supposed to do!!!!
3951 for (uint32_t x
= 0; x
< memcached_server_count(memc
); ++x
)
3953 memcached_server_instance_st
*instance
=
3954 memcached_server_instance_fetch(memc
, x
);
3955 no_msg
+=(int)(instance
->cursor_active
);
3958 test_truth(no_msg
== 0);
3959 test_truth(memcached_flush_buffers(memc
) == MEMCACHED_SUCCESS
);
3962 ** Now validate that all items was set properly!
3964 for (size_t x
= 0; x
< 100; ++x
)
3968 size_t len
= (size_t)sprintf(key
, "%zu", x
);
3971 char* value
=memcached_get(memc
, key
, strlen(key
),
3972 &length
, &flags
, &ret
);
3973 test_truth(ret
== MEMCACHED_SUCCESS
&& value
!= NULL
);
3976 case 0: /* FALLTHROUGH */
3977 case 1: /* FALLTHROUGH */
3979 test_truth(strncmp(value
, key
, len
) == 0);
3980 test_truth(len
== length
);
3983 test_truth(length
== len
* 2);
3986 test_truth(length
== len
* 3);
3996 /* Try setting an illegal cas value (should not return an error to
3997 * the caller (because we don't expect a return message from the server)
3999 const char* keys
[]= {"0"};
4000 size_t lengths
[]= {1};
4003 memcached_result_st results_obj
;
4004 memcached_result_st
*results
;
4005 ret
= memcached_mget(memc
, keys
, lengths
, 1);
4006 test_truth(ret
== MEMCACHED_SUCCESS
);
4008 results
= memcached_result_create(memc
, &results_obj
);
4009 test_truth(results
);
4010 results
= memcached_fetch_result(memc
, &results_obj
, &ret
);
4011 test_truth(results
);
4012 test_truth(ret
== MEMCACHED_SUCCESS
);
4013 uint64_t cas
= memcached_result_cas(results
);
4014 memcached_result_free(&results_obj
);
4016 ret
= memcached_cas(memc
, keys
[0], lengths
[0], keys
[0], lengths
[0], 0, 0, cas
);
4017 test_truth(ret
== MEMCACHED_SUCCESS
);
4020 * The item will have a new cas value, so try to set it again with the old
4021 * value. This should fail!
4023 ret
= memcached_cas(memc
, keys
[0], lengths
[0], keys
[0], lengths
[0], 0, 0, cas
);
4024 test_truth(ret
== MEMCACHED_SUCCESS
);
4025 test_truth(memcached_flush_buffers(memc
) == MEMCACHED_SUCCESS
);
4026 char* value
=memcached_get(memc
, keys
[0], lengths
[0], &length
, &flags
, &ret
);
4027 test_truth(ret
== MEMCACHED_SUCCESS
&& value
!= NULL
);
4030 return TEST_SUCCESS
;
4033 static test_return_t
analyzer_test(memcached_st
*memc
)
4035 memcached_return_t rc
;
4036 memcached_stat_st
*memc_stat
;
4037 memcached_analysis_st
*report
;
4039 memc_stat
= memcached_stat(memc
, NULL
, &rc
);
4040 test_truth(rc
== MEMCACHED_SUCCESS
);
4041 test_truth(memc_stat
);
4043 report
= memcached_analyze(memc
, memc_stat
, &rc
);
4044 test_truth(rc
== MEMCACHED_SUCCESS
);
4048 memcached_stat_free(NULL
, memc_stat
);
4050 return TEST_SUCCESS
;
4053 /* Count the objects */
4054 static memcached_return_t
callback_dump_counter(memcached_st
*ptr
__attribute__((unused
)),
4055 const char *key
__attribute__((unused
)),
4056 size_t key_length
__attribute__((unused
)),
4059 size_t *counter
= (size_t *)context
;
4061 *counter
= *counter
+ 1;
4063 return MEMCACHED_SUCCESS
;
4066 static test_return_t
dump_test(memcached_st
*memc
)
4068 memcached_return_t rc
;
4070 memcached_dump_fn callbacks
[1];
4071 test_return_t main_rc
;
4073 callbacks
[0]= &callback_dump_counter
;
4075 /* No support for Binary protocol yet */
4076 if (memc
->flags
.binary_protocol
)
4077 return TEST_SUCCESS
;
4079 main_rc
= set_test3(memc
);
4081 test_truth (main_rc
== TEST_SUCCESS
);
4083 rc
= memcached_dump(memc
, callbacks
, (void *)&counter
, 1);
4084 test_truth(rc
== MEMCACHED_SUCCESS
);
4086 /* We may have more then 32 if our previous flush has not completed */
4087 test_truth(counter
>= 32);
4089 return TEST_SUCCESS
;
4092 #ifdef HAVE_LIBMEMCACHEDUTIL
4093 static void* connection_release(void *arg
)
4096 memcached_pool_st
* pool
;
4101 assert(memcached_pool_push(resource
->pool
, resource
->mmc
) == MEMCACHED_SUCCESS
);
4105 static test_return_t
connection_pool_test(memcached_st
*memc
)
4107 memcached_pool_st
* pool
= memcached_pool_create(memc
, 5, 10);
4108 test_truth(pool
!= NULL
);
4109 memcached_st
* mmc
[10];
4110 memcached_return_t rc
;
4112 for (size_t x
= 0; x
< 10; ++x
)
4114 mmc
[x
]= memcached_pool_pop(pool
, false, &rc
);
4115 test_truth(mmc
[x
] != NULL
);
4116 test_truth(rc
== MEMCACHED_SUCCESS
);
4119 test_truth(memcached_pool_pop(pool
, false, &rc
) == NULL
);
4120 test_truth(rc
== MEMCACHED_SUCCESS
);
4124 memcached_pool_st
* pool
;
4126 } item
= { .pool
= pool
, .mmc
= mmc
[9] };
4127 pthread_create(&tid
, NULL
, connection_release
, &item
);
4128 mmc
[9]= memcached_pool_pop(pool
, true, &rc
);
4129 test_truth(rc
== MEMCACHED_SUCCESS
);
4130 pthread_join(tid
, NULL
);
4131 test_truth(mmc
[9] == item
.mmc
);
4132 const char *key
= "key";
4133 size_t keylen
= strlen(key
);
4135 // verify that I can do ops with all connections
4136 rc
= memcached_set(mmc
[0], key
, keylen
, "0", 1, 0, 0);
4137 test_truth(rc
== MEMCACHED_SUCCESS
);
4139 for (size_t x
= 0; x
< 10; ++x
)
4141 uint64_t number_value
;
4142 rc
= memcached_increment(mmc
[x
], key
, keylen
, 1, &number_value
);
4143 test_truth(rc
== MEMCACHED_SUCCESS
);
4144 test_truth(number_value
== (x
+1));
4148 for (size_t x
= 0; x
< 10; ++x
)
4150 test_truth(memcached_pool_push(pool
, mmc
[x
]) == MEMCACHED_SUCCESS
);
4154 /* verify that I can set behaviors on the pool when I don't have all
4155 * of the connections in the pool. It should however be enabled
4156 * when I push the item into the pool
4158 mmc
[0]= memcached_pool_pop(pool
, false, &rc
);
4159 test_truth(mmc
[0] != NULL
);
4161 rc
= memcached_pool_behavior_set(pool
, MEMCACHED_BEHAVIOR_IO_MSG_WATERMARK
, 9999);
4162 test_truth(rc
== MEMCACHED_SUCCESS
);
4164 mmc
[1]= memcached_pool_pop(pool
, false, &rc
);
4165 test_truth(mmc
[1] != NULL
);
4167 test_truth(memcached_behavior_get(mmc
[1], MEMCACHED_BEHAVIOR_IO_MSG_WATERMARK
) == 9999);
4168 test_truth(memcached_pool_push(pool
, mmc
[1]) == MEMCACHED_SUCCESS
);
4169 test_truth(memcached_pool_push(pool
, mmc
[0]) == MEMCACHED_SUCCESS
);
4171 mmc
[0]= memcached_pool_pop(pool
, false, &rc
);
4172 test_truth(memcached_behavior_get(mmc
[0], MEMCACHED_BEHAVIOR_IO_MSG_WATERMARK
) == 9999);
4173 test_truth(memcached_pool_push(pool
, mmc
[0]) == MEMCACHED_SUCCESS
);
4176 test_truth(memcached_pool_destroy(pool
) == memc
);
4177 return TEST_SUCCESS
;
4181 static test_return_t
replication_set_test(memcached_st
*memc
)
4183 memcached_return_t rc
;
4184 memcached_st
*memc_clone
= memcached_clone(NULL
, memc
);
4185 memcached_behavior_set(memc_clone
, MEMCACHED_BEHAVIOR_NUMBER_OF_REPLICAS
, 0);
4187 rc
= memcached_set(memc
, "bubba", 5, "0", 1, 0, 0);
4188 test_truth(rc
== MEMCACHED_SUCCESS
);
4191 ** We are using the quiet commands to store the replicas, so we need
4192 ** to ensure that all of them are processed before we can continue.
4193 ** In the test we go directly from storing the object to trying to
4194 ** receive the object from all of the different servers, so we
4195 ** could end up in a race condition (the memcached server hasn't yet
4196 ** processed the quiet command from the replication set when it process
4197 ** the request from the other client (created by the clone)). As a
4198 ** workaround for that we call memcached_quit to send the quit command
4199 ** to the server and wait for the response ;-) If you use the test code
4200 ** as an example for your own code, please note that you shouldn't need
4203 memcached_quit(memc
);
4206 ** "bubba" should now be stored on all of our servers. We don't have an
4207 ** easy to use API to address each individual server, so I'll just iterate
4208 ** through a bunch of "master keys" and I should most likely hit all of the
4211 for (int x
= 'a'; x
<= 'z'; ++x
)
4213 char key
[2]= { [0]= (char)x
};
4216 char *val
= memcached_get_by_key(memc_clone
, key
, 1, "bubba", 5,
4218 test_truth(rc
== MEMCACHED_SUCCESS
);
4219 test_truth(val
!= NULL
);
4223 memcached_free(memc_clone
);
4225 return TEST_SUCCESS
;
4228 static test_return_t
replication_get_test(memcached_st
*memc
)
4230 memcached_return_t rc
;
4233 * Don't do the following in your code. I am abusing the internal details
4234 * within the library, and this is not a supported interface.
4235 * This is to verify correct behavior in the library
4237 for (uint32_t host
= 0; host
< memcached_server_count(memc
); ++host
)
4239 memcached_st
*memc_clone
= memcached_clone(NULL
, memc
);
4240 memcached_server_instance_st
*instance
=
4241 memcached_server_instance_fetch(memc_clone
, host
);
4245 for (int x
= 'a'; x
<= 'z'; ++x
)
4247 char key
[2]= { [0]= (char)x
};
4250 char *val
= memcached_get_by_key(memc_clone
, key
, 1, "bubba", 5,
4252 test_truth(rc
== MEMCACHED_SUCCESS
);
4253 test_truth(val
!= NULL
);
4257 memcached_free(memc_clone
);
4260 return TEST_SUCCESS
;
4263 static test_return_t
replication_mget_test(memcached_st
*memc
)
4265 memcached_return_t rc
;
4266 memcached_st
*memc_clone
= memcached_clone(NULL
, memc
);
4267 memcached_behavior_set(memc_clone
, MEMCACHED_BEHAVIOR_NUMBER_OF_REPLICAS
, 0);
4269 const char *keys
[]= { "bubba", "key1", "key2", "key3" };
4270 size_t len
[]= { 5, 4, 4, 4 };
4272 for (size_t x
= 0; x
< 4; ++x
)
4274 rc
= memcached_set(memc
, keys
[x
], len
[x
], "0", 1, 0, 0);
4275 test_truth(rc
== MEMCACHED_SUCCESS
);
4279 ** We are using the quiet commands to store the replicas, so we need
4280 ** to ensure that all of them are processed before we can continue.
4281 ** In the test we go directly from storing the object to trying to
4282 ** receive the object from all of the different servers, so we
4283 ** could end up in a race condition (the memcached server hasn't yet
4284 ** processed the quiet command from the replication set when it process
4285 ** the request from the other client (created by the clone)). As a
4286 ** workaround for that we call memcached_quit to send the quit command
4287 ** to the server and wait for the response ;-) If you use the test code
4288 ** as an example for your own code, please note that you shouldn't need
4291 memcached_quit(memc
);
4294 * Don't do the following in your code. I am abusing the internal details
4295 * within the library, and this is not a supported interface.
4296 * This is to verify correct behavior in the library
4298 memcached_result_st result_obj
;
4299 for (uint32_t host
= 0; host
< memc_clone
->number_of_hosts
; host
++)
4301 memcached_st
*new_clone
= memcached_clone(NULL
, memc
);
4302 memcached_server_instance_st
*instance
=
4303 memcached_server_instance_fetch(new_clone
, host
);
4306 for (int x
= 'a'; x
<= 'z'; ++x
)
4308 char key
[2]= { [0]= (char)x
, [1]= 0 };
4310 rc
= memcached_mget_by_key(new_clone
, key
, 1, keys
, len
, 4);
4311 test_truth(rc
== MEMCACHED_SUCCESS
);
4313 memcached_result_st
*results
= memcached_result_create(new_clone
, &result_obj
);
4314 test_truth(results
);
4317 while ((results
= memcached_fetch_result(new_clone
, &result_obj
, &rc
)) != NULL
)
4321 test_truth(hits
== 4);
4322 memcached_result_free(&result_obj
);
4325 memcached_free(new_clone
);
4328 memcached_free(memc_clone
);
4330 return TEST_SUCCESS
;
4333 static test_return_t
replication_randomize_mget_test(memcached_st
*memc
)
4335 memcached_result_st result_obj
;
4336 memcached_return_t rc
;
4337 memcached_st
*memc_clone
= memcached_clone(NULL
, memc
);
4338 memcached_behavior_set(memc_clone
, MEMCACHED_BEHAVIOR_NUMBER_OF_REPLICAS
, 3);
4339 memcached_behavior_set(memc_clone
, MEMCACHED_BEHAVIOR_RANDOMIZE_REPLICA_READ
, 1);
4341 const char *keys
[]= { "key1", "key2", "key3", "key4", "key5", "key6", "key7" };
4342 size_t len
[]= { 4, 4, 4, 4, 4, 4, 4 };
4344 for (int x
=0; x
< 7; ++x
)
4346 rc
= memcached_set(memc
, keys
[x
], len
[x
], "1", 1, 0, 0);
4347 test_truth(rc
== MEMCACHED_SUCCESS
);
4350 memcached_quit(memc
);
4352 for (size_t x
= 0; x
< 7; ++x
)
4354 const char key
[2]= { [0]= (const char)x
};
4356 rc
= memcached_mget_by_key(memc_clone
, key
, 1, keys
, len
, 7);
4357 test_truth(rc
== MEMCACHED_SUCCESS
);
4359 memcached_result_st
*results
= memcached_result_create(memc_clone
, &result_obj
);
4360 test_truth(results
);
4363 while ((results
= memcached_fetch_result(memc_clone
, &result_obj
, &rc
)) != NULL
)
4367 test_truth(hits
== 7);
4368 memcached_result_free(&result_obj
);
4370 memcached_free(memc_clone
);
4371 return TEST_SUCCESS
;
4374 static test_return_t
replication_delete_test(memcached_st
*memc
)
4376 memcached_return_t rc
;
4377 memcached_st
*memc_clone
= memcached_clone(NULL
, memc
);
4378 /* Delete the items from all of the servers except 1 */
4379 uint64_t repl
= memcached_behavior_get(memc
,
4380 MEMCACHED_BEHAVIOR_NUMBER_OF_REPLICAS
);
4381 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NUMBER_OF_REPLICAS
, --repl
);
4383 const char *keys
[]= { "bubba", "key1", "key2", "key3" };
4384 size_t len
[]= { 5, 4, 4, 4 };
4386 for (size_t x
= 0; x
< 4; ++x
)
4388 rc
= memcached_delete_by_key(memc
, keys
[0], len
[0], keys
[x
], len
[x
], 0);
4389 test_truth(rc
== MEMCACHED_SUCCESS
);
4393 * Don't do the following in your code. I am abusing the internal details
4394 * within the library, and this is not a supported interface.
4395 * This is to verify correct behavior in the library
4397 uint32_t hash
= memcached_generate_hash(memc
, keys
[0], len
[0]);
4398 for (uint32_t x
= 0; x
< (repl
+ 1); ++x
)
4400 memcached_server_instance_st
*instance
=
4401 memcached_server_instance_fetch(memc_clone
, x
);
4404 if (++hash
== memc_clone
->number_of_hosts
)
4408 memcached_result_st result_obj
;
4409 for (uint32_t host
= 0; host
< memc_clone
->number_of_hosts
; ++host
)
4411 for (size_t x
= 'a'; x
<= 'z'; ++x
)
4413 const char key
[2]= { [0]= (const char)x
};
4415 rc
= memcached_mget_by_key(memc_clone
, key
, 1, keys
, len
, 4);
4416 test_truth(rc
== MEMCACHED_SUCCESS
);
4418 memcached_result_st
*results
= memcached_result_create(memc_clone
, &result_obj
);
4419 test_truth(results
);
4422 while ((results
= memcached_fetch_result(memc_clone
, &result_obj
, &rc
)) != NULL
)
4426 test_truth(hits
== 4);
4427 memcached_result_free(&result_obj
);
4430 memcached_free(memc_clone
);
4432 return TEST_SUCCESS
;
4435 static void increment_request_id(uint16_t *id
)
4438 if ((*id
& UDP_REQUEST_ID_THREAD_MASK
) != 0)
4442 static uint16_t *get_udp_request_ids(memcached_st
*memc
)
4444 uint16_t *ids
= malloc(sizeof(uint16_t) * memcached_server_count(memc
));
4445 assert(ids
!= NULL
);
4447 for (uint32_t x
= 0; x
< memcached_server_count(memc
); x
++)
4449 memcached_server_instance_st
*instance
=
4450 memcached_server_instance_fetch(memc
, x
);
4452 ids
[x
]= get_udp_datagram_request_id((struct udp_datagram_header_st
*) instance
->write_buffer
);
4458 static test_return_t
post_udp_op_check(memcached_st
*memc
, uint16_t *expected_req_ids
)
4460 memcached_server_st
*cur_server
= memcached_server_list(memc
);
4461 uint16_t *cur_req_ids
= get_udp_request_ids(memc
);
4463 for (size_t x
= 0; x
< memcached_server_count(memc
); x
++)
4465 test_truth(cur_server
[x
].cursor_active
== 0);
4466 test_truth(cur_req_ids
[x
] == expected_req_ids
[x
]);
4468 free(expected_req_ids
);
4471 return TEST_SUCCESS
;
4475 ** There is a little bit of a hack here, instead of removing
4476 ** the servers, I just set num host to 0 and them add then new udp servers
4478 static test_return_t
init_udp(memcached_st
*memc
)
4480 memcached_version(memc
);
4481 memcached_server_instance_st
*instance
=
4482 memcached_server_instance_fetch(memc
, 0);
4484 /* For the time being, only support udp test for >= 1.2.6 && < 1.3 */
4485 if (instance
->major_version
!= 1 || instance
->minor_version
!= 2
4486 || instance
->micro_version
< 6)
4487 return TEST_SKIPPED
;
4489 uint32_t num_hosts
= memcached_server_count(memc
);
4490 memcached_server_st servers
[num_hosts
];
4491 memcpy(servers
, memcached_server_list(memc
), sizeof(memcached_server_st
) * num_hosts
);
4492 for (uint32_t x
= 0; x
< num_hosts
; x
++)
4494 memcached_server_instance_st
*set_instance
=
4495 memcached_server_instance_fetch(memc
, x
);
4497 memcached_server_free(set_instance
);
4500 memc
->number_of_hosts
= 0;
4501 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_USE_UDP
, 1);
4502 for (uint32_t x
= 0; x
< num_hosts
; x
++)
4504 memcached_server_instance_st
*set_instance
=
4505 memcached_server_instance_fetch(memc
, x
);
4507 test_truth(memcached_server_add_udp(memc
, servers
[x
].hostname
, servers
[x
].port
) == MEMCACHED_SUCCESS
);
4508 test_truth(set_instance
->write_buffer_offset
== UDP_DATAGRAM_HEADER_LENGTH
);
4511 return TEST_SUCCESS
;
4514 static test_return_t
binary_init_udp(memcached_st
*memc
)
4516 test_return_t test_rc
;
4517 test_rc
= pre_binary(memc
);
4519 if (test_rc
!= TEST_SUCCESS
)
4522 return init_udp(memc
);
4525 /* Make sure that I cant add a tcp server to a udp client */
4526 static test_return_t
add_tcp_server_udp_client_test(memcached_st
*memc
)
4530 memcached_server_st server
;
4531 memcached_server_instance_st
*instance
=
4532 memcached_server_instance_fetch(memc
, 0);
4533 memcached_server_clone(&server
, &memc
->hosts
[0]);
4534 test_truth(memcached_server_remove(&(memc
->hosts
[0])) == MEMCACHED_SUCCESS
);
4535 test_truth(memcached_server_add(memc
, server
.hostname
, server
.port
) == MEMCACHED_INVALID_HOST_PROTOCOL
);
4537 return TEST_SUCCESS
;
4540 /* Make sure that I cant add a udp server to a tcp client */
4541 static test_return_t
add_udp_server_tcp_client_test(memcached_st
*memc
)
4545 memcached_server_st server
;
4546 memcached_server_instance_st
*instance
=
4547 memcached_server_instance_fetch(memc
, 0);
4548 memcached_server_clone(&server
, &memc
->hosts
[0]);
4549 test_truth(memcached_server_remove(&(memc
->hosts
[0])) == MEMCACHED_SUCCESS
);
4551 memcached_st tcp_client
;
4552 memcached_create(&tcp_client
);
4553 test_truth(memcached_server_add_udp(&tcp_client
, server
.hostname
, server
.port
) == MEMCACHED_INVALID_HOST_PROTOCOL
);
4556 return TEST_SUCCESS
;
4559 static test_return_t
set_udp_behavior_test(memcached_st
*memc
)
4562 memcached_quit(memc
);
4563 memc
->number_of_hosts
= 0;
4564 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_DISTRIBUTION
, memc
->distribution
);
4565 test_truth(memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_USE_UDP
, 1) == MEMCACHED_SUCCESS
);
4566 test_truth(memc
->flags
.use_udp
);
4567 test_truth(memc
->flags
.no_reply
);
4569 test_truth(memcached_server_count(memc
) == 0);
4571 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_USE_UDP
,0);
4572 test_truth(! (memc
->flags
.use_udp
));
4573 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NOREPLY
,0);
4574 test_truth(! (memc
->flags
.no_reply
));
4576 return TEST_SUCCESS
;
4579 static test_return_t
udp_set_test(memcached_st
*memc
)
4581 unsigned int num_iters
= 1025; //request id rolls over at 1024
4583 for (size_t x
= 0; x
< num_iters
;x
++)
4585 memcached_return_t rc
;
4586 const char *key
= "foo";
4587 const char *value
= "when we sanitize";
4588 uint16_t *expected_ids
= get_udp_request_ids(memc
);
4589 unsigned int server_key
= memcached_generate_hash(memc
, key
, strlen(key
));
4590 memcached_server_instance_st
*instance
=
4591 memcached_server_instance_fetch(memc
, server_key
);
4592 size_t init_offset
= instance
->write_buffer_offset
;
4594 rc
= memcached_set(memc
, key
, strlen(key
),
4595 value
, strlen(value
),
4596 (time_t)0, (uint32_t)0);
4597 test_truth(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
);
4598 /** NB, the check below assumes that if new write_ptr is less than
4599 * the original write_ptr that we have flushed. For large payloads, this
4600 * maybe an invalid assumption, but for the small payload we have it is OK
4602 if (rc
== MEMCACHED_SUCCESS
||
4603 instance
->write_buffer_offset
< init_offset
)
4604 increment_request_id(&expected_ids
[server_key
]);
4606 if (rc
== MEMCACHED_SUCCESS
)
4608 test_truth(instance
->write_buffer_offset
== UDP_DATAGRAM_HEADER_LENGTH
);
4612 test_truth(instance
->write_buffer_offset
!= UDP_DATAGRAM_HEADER_LENGTH
);
4613 test_truth(instance
->write_buffer_offset
<= MAX_UDP_DATAGRAM_LENGTH
);
4615 test_truth(post_udp_op_check(memc
, expected_ids
) == TEST_SUCCESS
);
4617 return TEST_SUCCESS
;
4620 static test_return_t
udp_buffered_set_test(memcached_st
*memc
)
4622 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_BUFFER_REQUESTS
, 1);
4623 return udp_set_test(memc
);
4626 static test_return_t
udp_set_too_big_test(memcached_st
*memc
)
4628 memcached_return_t rc
;
4629 const char *key
= "bar";
4630 char value
[MAX_UDP_DATAGRAM_LENGTH
];
4631 uint16_t *expected_ids
= get_udp_request_ids(memc
);
4632 rc
= memcached_set(memc
, key
, strlen(key
),
4633 value
, MAX_UDP_DATAGRAM_LENGTH
,
4634 (time_t)0, (uint32_t)0);
4635 test_truth(rc
== MEMCACHED_WRITE_FAILURE
);
4637 return post_udp_op_check(memc
,expected_ids
);
4640 static test_return_t
udp_delete_test(memcached_st
*memc
)
4642 unsigned int num_iters
= 1025; //request id rolls over at 1024
4644 for (size_t x
= 0; x
< num_iters
;x
++)
4646 memcached_return_t rc
;
4647 const char *key
= "foo";
4648 uint16_t *expected_ids
=get_udp_request_ids(memc
);
4649 unsigned int server_key
= memcached_generate_hash(memc
, key
, strlen(key
));
4650 memcached_server_instance_st
*instance
=
4651 memcached_server_instance_fetch(memc
, server_key
);
4652 size_t init_offset
= instance
->write_buffer_offset
;
4654 rc
= memcached_delete(memc
, key
, strlen(key
), 0);
4655 test_truth(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
);
4657 if (rc
== MEMCACHED_SUCCESS
|| instance
->write_buffer_offset
< init_offset
)
4658 increment_request_id(&expected_ids
[server_key
]);
4659 if (rc
== MEMCACHED_SUCCESS
)
4661 test_truth(instance
->write_buffer_offset
== UDP_DATAGRAM_HEADER_LENGTH
);
4665 test_truth(instance
->write_buffer_offset
!= UDP_DATAGRAM_HEADER_LENGTH
);
4666 test_truth(instance
->write_buffer_offset
<= MAX_UDP_DATAGRAM_LENGTH
);
4668 test_truth(post_udp_op_check(memc
,expected_ids
) == TEST_SUCCESS
);
4670 return TEST_SUCCESS
;
4673 static test_return_t
udp_buffered_delete_test(memcached_st
*memc
)
4675 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_BUFFER_REQUESTS
, 1);
4676 return udp_delete_test(memc
);
4679 static test_return_t
udp_verbosity_test(memcached_st
*memc
)
4681 memcached_return_t rc
;
4682 uint16_t *expected_ids
= get_udp_request_ids(memc
);
4684 for (size_t x
= 0; x
< memcached_server_count(memc
); x
++)
4686 increment_request_id(&expected_ids
[x
]);
4689 rc
= memcached_verbosity(memc
,3);
4690 test_truth(rc
== MEMCACHED_SUCCESS
);
4691 return post_udp_op_check(memc
,expected_ids
);
4694 static test_return_t
udp_quit_test(memcached_st
*memc
)
4696 uint16_t *expected_ids
= get_udp_request_ids(memc
);
4697 memcached_quit(memc
);
4698 return post_udp_op_check(memc
, expected_ids
);
4701 static test_return_t
udp_flush_test(memcached_st
*memc
)
4703 memcached_return_t rc
;
4704 uint16_t *expected_ids
= get_udp_request_ids(memc
);
4706 for (size_t x
= 0; x
< memcached_server_count(memc
); x
++)
4708 increment_request_id(&expected_ids
[x
]);
4711 rc
= memcached_flush(memc
,0);
4712 test_truth(rc
== MEMCACHED_SUCCESS
);
4713 return post_udp_op_check(memc
,expected_ids
);
4716 static test_return_t
udp_incr_test(memcached_st
*memc
)
4718 memcached_return_t rc
;
4719 const char *key
= "incr";
4720 const char *value
= "1";
4721 rc
= memcached_set(memc
, key
, strlen(key
),
4722 value
, strlen(value
),
4723 (time_t)0, (uint32_t)0);
4725 test_truth(rc
== MEMCACHED_SUCCESS
);
4726 uint16_t *expected_ids
= get_udp_request_ids(memc
);
4727 unsigned int server_key
= memcached_generate_hash(memc
, key
, strlen(key
));
4728 increment_request_id(&expected_ids
[server_key
]);
4730 rc
= memcached_increment(memc
, key
, strlen(key
), 1, &newvalue
);
4731 test_truth(rc
== MEMCACHED_SUCCESS
);
4732 return post_udp_op_check(memc
, expected_ids
);
4735 static test_return_t
udp_decr_test(memcached_st
*memc
)
4737 memcached_return_t rc
;
4738 const char *key
= "decr";
4739 const char *value
= "1";
4740 rc
= memcached_set(memc
, key
, strlen(key
),
4741 value
, strlen(value
),
4742 (time_t)0, (uint32_t)0);
4744 test_truth(rc
== MEMCACHED_SUCCESS
);
4745 uint16_t *expected_ids
= get_udp_request_ids(memc
);
4746 unsigned int server_key
= memcached_generate_hash(memc
, key
, strlen(key
));
4747 increment_request_id(&expected_ids
[server_key
]);
4749 rc
= memcached_decrement(memc
, key
, strlen(key
), 1, &newvalue
);
4750 test_truth(rc
== MEMCACHED_SUCCESS
);
4751 return post_udp_op_check(memc
, expected_ids
);
4755 static test_return_t
udp_stat_test(memcached_st
*memc
)
4757 memcached_stat_st
* rv
= NULL
;
4758 memcached_return_t rc
;
4760 uint16_t *expected_ids
= get_udp_request_ids(memc
);
4761 rv
= memcached_stat(memc
, args
, &rc
);
4763 test_truth(rc
== MEMCACHED_NOT_SUPPORTED
);
4764 return post_udp_op_check(memc
, expected_ids
);
4767 static test_return_t
udp_version_test(memcached_st
*memc
)
4769 memcached_return_t rc
;
4770 uint16_t *expected_ids
= get_udp_request_ids(memc
);
4771 rc
= memcached_version(memc
);
4772 test_truth(rc
== MEMCACHED_NOT_SUPPORTED
);
4773 return post_udp_op_check(memc
, expected_ids
);
4776 static test_return_t
udp_get_test(memcached_st
*memc
)
4778 memcached_return_t rc
;
4779 const char *key
= "foo";
4781 uint16_t *expected_ids
= get_udp_request_ids(memc
);
4782 char *val
= memcached_get(memc
, key
, strlen(key
), &vlen
, (uint32_t)0, &rc
);
4783 test_truth(rc
== MEMCACHED_NOT_SUPPORTED
);
4784 test_truth(val
== NULL
);
4785 return post_udp_op_check(memc
, expected_ids
);
4788 static test_return_t
udp_mixed_io_test(memcached_st
*memc
)
4791 test_st mixed_io_ops
[] ={
4793 (test_callback_fn
)udp_set_test
},
4794 {"udp_set_too_big_test", 0,
4795 (test_callback_fn
)udp_set_too_big_test
},
4796 {"udp_delete_test", 0,
4797 (test_callback_fn
)udp_delete_test
},
4798 {"udp_verbosity_test", 0,
4799 (test_callback_fn
)udp_verbosity_test
},
4800 {"udp_quit_test", 0,
4801 (test_callback_fn
)udp_quit_test
},
4802 {"udp_flush_test", 0,
4803 (test_callback_fn
)udp_flush_test
},
4804 {"udp_incr_test", 0,
4805 (test_callback_fn
)udp_incr_test
},
4806 {"udp_decr_test", 0,
4807 (test_callback_fn
)udp_decr_test
},
4808 {"udp_version_test", 0,
4809 (test_callback_fn
)udp_version_test
}
4811 for (size_t x
= 0; x
< 500; x
++)
4813 current_op
= mixed_io_ops
[random() % 9];
4814 test_truth(current_op
.test_fn(memc
) == TEST_SUCCESS
);
4816 return TEST_SUCCESS
;
4820 static test_return_t
hash_sanity_test (memcached_st
*memc
)
4824 assert(MEMCACHED_HASH_DEFAULT
== MEMCACHED_HASH_DEFAULT
);
4825 assert(MEMCACHED_HASH_MD5
== MEMCACHED_HASH_MD5
);
4826 assert(MEMCACHED_HASH_CRC
== MEMCACHED_HASH_CRC
);
4827 assert(MEMCACHED_HASH_FNV1_64
== MEMCACHED_HASH_FNV1_64
);
4828 assert(MEMCACHED_HASH_FNV1A_64
== MEMCACHED_HASH_FNV1A_64
);
4829 assert(MEMCACHED_HASH_FNV1_32
== MEMCACHED_HASH_FNV1_32
);
4830 assert(MEMCACHED_HASH_FNV1A_32
== MEMCACHED_HASH_FNV1A_32
);
4831 #ifdef HAVE_HSIEH_HASH
4832 assert(MEMCACHED_HASH_HSIEH
== MEMCACHED_HASH_HSIEH
);
4834 assert(MEMCACHED_HASH_MURMUR
== MEMCACHED_HASH_MURMUR
);
4835 assert(MEMCACHED_HASH_JENKINS
== MEMCACHED_HASH_JENKINS
);
4836 assert(MEMCACHED_HASH_MAX
== MEMCACHED_HASH_MAX
);
4838 return TEST_SUCCESS
;
4842 static test_return_t
hsieh_avaibility_test (memcached_st
*memc
)
4844 memcached_return_t expected_rc
= MEMCACHED_FAILURE
;
4845 #ifdef HAVE_HSIEH_HASH
4846 expected_rc
= MEMCACHED_SUCCESS
;
4848 memcached_return_t rc
= memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_HASH
,
4849 (uint64_t)MEMCACHED_HASH_HSIEH
);
4850 test_truth(rc
== expected_rc
);
4851 return TEST_SUCCESS
;
4854 static test_return_t
md5_run (memcached_st
*memc
__attribute__((unused
)))
4859 for (ptr
= list_to_hash
, x
= 0; *ptr
; ptr
++, x
++)
4863 hash_val
= memcached_generate_hash_value(*ptr
, strlen(*ptr
), MEMCACHED_HASH_MD5
);
4864 test_truth(md5_values
[x
] == hash_val
);
4867 return TEST_SUCCESS
;
4870 static test_return_t
crc_run (memcached_st
*memc
__attribute__((unused
)))
4875 for (ptr
= list_to_hash
, x
= 0; *ptr
; ptr
++, x
++)
4879 hash_val
= memcached_generate_hash_value(*ptr
, strlen(*ptr
), MEMCACHED_HASH_CRC
);
4880 test_truth(crc_values
[x
] == hash_val
);
4883 return TEST_SUCCESS
;
4886 static test_return_t
fnv1_64_run (memcached_st
*memc
__attribute__((unused
)))
4891 for (ptr
= list_to_hash
, x
= 0; *ptr
; ptr
++, x
++)
4895 hash_val
= memcached_generate_hash_value(*ptr
, strlen(*ptr
), MEMCACHED_HASH_FNV1_64
);
4896 test_truth(fnv1_64_values
[x
] == hash_val
);
4899 return TEST_SUCCESS
;
4902 static test_return_t
fnv1a_64_run (memcached_st
*memc
__attribute__((unused
)))
4907 for (ptr
= list_to_hash
, x
= 0; *ptr
; ptr
++, x
++)
4911 hash_val
= memcached_generate_hash_value(*ptr
, strlen(*ptr
), MEMCACHED_HASH_FNV1A_64
);
4912 test_truth(fnv1a_64_values
[x
] == hash_val
);
4915 return TEST_SUCCESS
;
4918 static test_return_t
fnv1_32_run (memcached_st
*memc
__attribute__((unused
)))
4924 for (ptr
= list_to_hash
, x
= 0; *ptr
; ptr
++, x
++)
4928 hash_val
= memcached_generate_hash_value(*ptr
, strlen(*ptr
), MEMCACHED_HASH_FNV1_32
);
4929 test_truth(fnv1_32_values
[x
] == hash_val
);
4932 return TEST_SUCCESS
;
4935 static test_return_t
fnv1a_32_run (memcached_st
*memc
__attribute__((unused
)))
4940 for (ptr
= list_to_hash
, x
= 0; *ptr
; ptr
++, x
++)
4944 hash_val
= memcached_generate_hash_value(*ptr
, strlen(*ptr
), MEMCACHED_HASH_FNV1A_32
);
4945 test_truth(fnv1a_32_values
[x
] == hash_val
);
4948 return TEST_SUCCESS
;
4951 static test_return_t
hsieh_run (memcached_st
*memc
__attribute__((unused
)))
4956 for (ptr
= list_to_hash
, x
= 0; *ptr
; ptr
++, x
++)
4960 hash_val
= memcached_generate_hash_value(*ptr
, strlen(*ptr
), MEMCACHED_HASH_HSIEH
);
4961 test_truth(hsieh_values
[x
] == hash_val
);
4964 return TEST_SUCCESS
;
4967 static test_return_t
murmur_run (memcached_st
*memc
__attribute__((unused
)))
4970 return TEST_SKIPPED
;
4975 for (ptr
= list_to_hash
, x
= 0; *ptr
; ptr
++, x
++)
4979 hash_val
= memcached_generate_hash_value(*ptr
, strlen(*ptr
), MEMCACHED_HASH_MURMUR
);
4980 test_truth(murmur_values
[x
] == hash_val
);
4983 return TEST_SUCCESS
;
4987 static test_return_t
jenkins_run (memcached_st
*memc
__attribute__((unused
)))
4993 for (ptr
= list_to_hash
, x
= 0; *ptr
; ptr
++, x
++)
4997 hash_val
= memcached_generate_hash_value(*ptr
, strlen(*ptr
), MEMCACHED_HASH_JENKINS
);
4998 test_truth(jenkins_values
[x
] == hash_val
);
5001 return TEST_SUCCESS
;
5005 static test_return_t
ketama_compatibility_libmemcached(memcached_st
*trash
)
5007 memcached_return_t rc
;
5010 memcached_server_st
*server_pool
;
5015 memc
= memcached_create(NULL
);
5018 rc
= memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_KETAMA_WEIGHTED
, 1);
5019 test_truth(rc
== MEMCACHED_SUCCESS
);
5021 value
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_KETAMA_WEIGHTED
);
5022 test_truth(value
== 1);
5024 test_truth(memcached_behavior_set_distribution(memc
, MEMCACHED_DISTRIBUTION_CONSISTENT_KETAMA
) == MEMCACHED_SUCCESS
);
5025 test_truth(memcached_behavior_get_distribution(memc
) == MEMCACHED_DISTRIBUTION_CONSISTENT_KETAMA
);
5028 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");
5029 memcached_server_push(memc
, server_pool
);
5031 /* verify that the server list was parsed okay. */
5032 test_truth(memcached_server_count(memc
) == 8);
5033 test_strcmp(server_pool
[0].hostname
, "10.0.1.1");
5034 test_truth(server_pool
[0].port
== 11211);
5035 test_truth(server_pool
[0].weight
== 600);
5036 test_strcmp(server_pool
[2].hostname
, "10.0.1.3");
5037 test_truth(server_pool
[2].port
== 11211);
5038 test_truth(server_pool
[2].weight
== 200);
5039 test_strcmp(server_pool
[7].hostname
, "10.0.1.8");
5040 test_truth(server_pool
[7].port
== 11211);
5041 test_truth(server_pool
[7].weight
== 100);
5043 /* VDEAAAAA hashes to fffcd1b5, after the last continuum point, and lets
5044 * us test the boundary wraparound.
5046 test_truth(memcached_generate_hash(memc
, (char *)"VDEAAAAA", 8) == memc
->continuum
[0].index
);
5048 /* verify the standard ketama set. */
5049 for (x
= 0; x
< 99; x
++)
5051 uint32_t server_idx
= memcached_generate_hash(memc
, ketama_test_cases
[x
].key
, strlen(ketama_test_cases
[x
].key
));
5052 memcached_server_instance_st
*instance
=
5053 memcached_server_instance_fetch(memc
, server_idx
);
5054 char *hostname
= instance
->hostname
;
5056 test_strcmp(hostname
, ketama_test_cases
[x
].server
);
5059 memcached_server_list_free(server_pool
);
5060 memcached_free(memc
);
5062 return TEST_SUCCESS
;
5065 static test_return_t
ketama_compatibility_spymemcached(memcached_st
*trash
)
5067 memcached_return_t rc
;
5070 memcached_server_st
*server_pool
;
5075 memc
= memcached_create(NULL
);
5078 rc
= memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_KETAMA_WEIGHTED
, 1);
5079 test_truth(rc
== MEMCACHED_SUCCESS
);
5081 value
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_KETAMA_WEIGHTED
);
5082 test_truth(value
== 1);
5084 test_truth(memcached_behavior_set_distribution(memc
, MEMCACHED_DISTRIBUTION_CONSISTENT_KETAMA_SPY
) == MEMCACHED_SUCCESS
);
5085 test_truth(memcached_behavior_get_distribution(memc
) == MEMCACHED_DISTRIBUTION_CONSISTENT_KETAMA_SPY
);
5087 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");
5088 memcached_server_push(memc
, server_pool
);
5090 /* verify that the server list was parsed okay. */
5091 test_truth(memcached_server_count(memc
) == 8);
5092 test_strcmp(server_pool
[0].hostname
, "10.0.1.1");
5093 test_truth(server_pool
[0].port
== 11211);
5094 test_truth(server_pool
[0].weight
== 600);
5095 test_strcmp(server_pool
[2].hostname
, "10.0.1.3");
5096 test_truth(server_pool
[2].port
== 11211);
5097 test_truth(server_pool
[2].weight
== 200);
5098 test_strcmp(server_pool
[7].hostname
, "10.0.1.8");
5099 test_truth(server_pool
[7].port
== 11211);
5100 test_truth(server_pool
[7].weight
== 100);
5102 /* VDEAAAAA hashes to fffcd1b5, after the last continuum point, and lets
5103 * us test the boundary wraparound.
5105 test_truth(memcached_generate_hash(memc
, (char *)"VDEAAAAA", 8) == memc
->continuum
[0].index
);
5107 /* verify the standard ketama set. */
5108 for (x
= 0; x
< 99; x
++)
5110 uint32_t server_idx
= memcached_generate_hash(memc
, ketama_test_cases_spy
[x
].key
, strlen(ketama_test_cases_spy
[x
].key
));
5111 memcached_server_instance_st
*instance
=
5112 memcached_server_instance_fetch(memc
, server_idx
);
5113 char *hostname
= instance
->hostname
;
5114 test_strcmp(hostname
, ketama_test_cases_spy
[x
].server
);
5117 memcached_server_list_free(server_pool
);
5118 memcached_free(memc
);
5120 return TEST_SUCCESS
;
5123 static test_return_t
regression_bug_434484(memcached_st
*memc
)
5125 test_return_t test_rc
;
5126 test_rc
= pre_binary(memc
);
5128 if (test_rc
!= TEST_SUCCESS
)
5131 memcached_return_t ret
;
5132 const char *key
= "regression_bug_434484";
5133 size_t keylen
= strlen(key
);
5135 ret
= memcached_append(memc
, key
, keylen
, key
, keylen
, 0, 0);
5136 test_truth(ret
== MEMCACHED_NOTSTORED
);
5138 size_t size
= 2048 * 1024;
5139 void *data
= calloc(1, size
);
5140 test_truth(data
!= NULL
);
5141 ret
= memcached_set(memc
, key
, keylen
, data
, size
, 0, 0);
5142 test_truth(ret
== MEMCACHED_E2BIG
);
5145 return TEST_SUCCESS
;
5148 static test_return_t
regression_bug_434843(memcached_st
*memc
)
5150 test_return_t test_rc
;
5151 test_rc
= pre_binary(memc
);
5153 if (test_rc
!= TEST_SUCCESS
)
5156 memcached_return_t rc
;
5158 memcached_execute_fn callbacks
[1]= { [0]= &callback_counter
};
5161 * I only want to hit only _one_ server so I know the number of requests I'm
5162 * sending in the pipleine to the server. Let's try to do a multiget of
5163 * 1024 (that should satisfy most users don't you think?). Future versions
5164 * will include a mget_execute function call if you need a higher number.
5166 uint32_t number_of_hosts
= memcached_server_count(memc
);
5167 memc
->number_of_hosts
= 1;
5168 const size_t max_keys
= 1024;
5169 char **keys
= calloc(max_keys
, sizeof(char*));
5170 size_t *key_length
=calloc(max_keys
, sizeof(size_t));
5172 for (size_t x
= 0; x
< max_keys
; ++x
)
5176 key_length
[x
]= (size_t)snprintf(k
, sizeof(k
), "0200%zu", x
);
5178 test_truth(keys
[x
] != NULL
);
5182 * Run two times.. the first time we should have 100% cache miss,
5183 * and the second time we should have 100% cache hits
5185 for (size_t y
= 0; y
< 2; y
++)
5187 rc
= memcached_mget(memc
, (const char**)keys
, key_length
, max_keys
);
5188 test_truth(rc
== MEMCACHED_SUCCESS
);
5189 rc
= memcached_fetch_execute(memc
, callbacks
, (void *)&counter
, 1);
5193 /* The first iteration should give me a 100% cache miss. verify that*/
5194 char blob
[1024]= { 0 };
5196 test_truth(counter
== 0);
5198 for (size_t x
= 0; x
< max_keys
; ++x
)
5200 rc
= memcached_add(memc
, keys
[x
], key_length
[x
],
5201 blob
, sizeof(blob
), 0, 0);
5202 test_truth(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
);
5207 /* Verify that we received all of the key/value pairs */
5208 test_truth(counter
== max_keys
);
5212 /* Release allocated resources */
5213 for (size_t x
= 0; x
< max_keys
; ++x
)
5220 memc
->number_of_hosts
= number_of_hosts
;
5222 return TEST_SUCCESS
;
5225 static test_return_t
regression_bug_434843_buffered(memcached_st
*memc
)
5227 memcached_return_t rc
;
5228 rc
= memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_BUFFER_REQUESTS
, 1);
5229 test_truth(rc
== MEMCACHED_SUCCESS
);
5231 return regression_bug_434843(memc
);
5234 static test_return_t
regression_bug_421108(memcached_st
*memc
)
5236 memcached_return_t rc
;
5237 memcached_stat_st
*memc_stat
= memcached_stat(memc
, NULL
, &rc
);
5238 test_truth(rc
== MEMCACHED_SUCCESS
);
5240 char *bytes
= memcached_stat_get_value(memc
, memc_stat
, "bytes", &rc
);
5241 test_truth(rc
== MEMCACHED_SUCCESS
);
5242 test_truth(bytes
!= NULL
);
5243 char *bytes_read
= memcached_stat_get_value(memc
, memc_stat
,
5245 test_truth(rc
== MEMCACHED_SUCCESS
);
5246 test_truth(bytes_read
!= NULL
);
5248 char *bytes_written
= memcached_stat_get_value(memc
, memc_stat
,
5249 "bytes_written", &rc
);
5250 test_truth(rc
== MEMCACHED_SUCCESS
);
5251 test_truth(bytes_written
!= NULL
);
5253 test_truth(strcmp(bytes
, bytes_read
) != 0);
5254 test_truth(strcmp(bytes
, bytes_written
) != 0);
5256 /* Release allocated resources */
5259 free(bytes_written
);
5260 memcached_stat_free(NULL
, memc_stat
);
5262 return TEST_SUCCESS
;
5266 * The test case isn't obvious so I should probably document why
5267 * it works the way it does. Bug 442914 was caused by a bug
5268 * in the logic in memcached_purge (it did not handle the case
5269 * where the number of bytes sent was equal to the watermark).
5270 * In this test case, create messages so that we hit that case
5271 * and then disable noreply mode and issue a new command to
5272 * verify that it isn't stuck. If we change the format for the
5273 * delete command or the watermarks, we need to update this
5276 static test_return_t
regression_bug_442914(memcached_st
*memc
)
5278 memcached_return_t rc
;
5279 rc
= memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NOREPLY
, 1);
5280 test_truth(rc
== MEMCACHED_SUCCESS
);
5281 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_TCP_NODELAY
, 1);
5283 uint32_t number_of_hosts
= memcached_server_count(memc
);
5284 memc
->number_of_hosts
= 1;
5289 for (uint32_t x
= 0; x
< 250; ++x
)
5291 len
= (size_t)snprintf(k
, sizeof(k
), "%0250u", x
);
5292 rc
= memcached_delete(memc
, k
, len
, 0);
5293 test_truth(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
);
5296 (void)snprintf(k
, sizeof(k
), "%037u", 251U);
5299 rc
= memcached_delete(memc
, k
, len
, 0);
5300 test_truth(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
);
5302 rc
= memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NOREPLY
, 0);
5303 test_truth(rc
== MEMCACHED_SUCCESS
);
5304 rc
= memcached_delete(memc
, k
, len
, 0);
5305 test_truth(rc
== MEMCACHED_NOTFOUND
);
5307 memc
->number_of_hosts
= number_of_hosts
;
5309 return TEST_SUCCESS
;
5312 static test_return_t
regression_bug_447342(memcached_st
*memc
)
5314 memcached_server_instance_st
*instance_one
;
5315 memcached_server_instance_st
*instance_two
;
5317 if (memcached_server_count(memc
) < 3 || pre_replication(memc
) != MEMCACHED_SUCCESS
)
5318 return TEST_SKIPPED
;
5320 memcached_return_t rc
;
5322 rc
= memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NUMBER_OF_REPLICAS
, 2);
5323 test_truth(rc
== MEMCACHED_SUCCESS
);
5325 const size_t max_keys
= 100;
5326 char **keys
= calloc(max_keys
, sizeof(char*));
5327 size_t *key_length
= calloc(max_keys
, sizeof(size_t));
5329 for (size_t x
= 0; x
< max_keys
; ++x
)
5333 key_length
[x
]= (size_t)snprintf(k
, sizeof(k
), "0200%zu", x
);
5335 test_truth(keys
[x
] != NULL
);
5336 rc
= memcached_set(memc
, k
, key_length
[x
], k
, key_length
[x
], 0, 0);
5337 test_truth(rc
== MEMCACHED_SUCCESS
);
5341 ** We are using the quiet commands to store the replicas, so we need
5342 ** to ensure that all of them are processed before we can continue.
5343 ** In the test we go directly from storing the object to trying to
5344 ** receive the object from all of the different servers, so we
5345 ** could end up in a race condition (the memcached server hasn't yet
5346 ** processed the quiet command from the replication set when it process
5347 ** the request from the other client (created by the clone)). As a
5348 ** workaround for that we call memcached_quit to send the quit command
5349 ** to the server and wait for the response ;-) If you use the test code
5350 ** as an example for your own code, please note that you shouldn't need
5353 memcached_quit(memc
);
5355 /* Verify that all messages are stored, and we didn't stuff too much
5358 rc
= memcached_mget(memc
, (const char* const *)keys
, key_length
, max_keys
);
5359 test_truth(rc
== MEMCACHED_SUCCESS
);
5362 memcached_execute_fn callbacks
[1]= { [0]= &callback_counter
};
5363 rc
= memcached_fetch_execute(memc
, callbacks
, (void *)&counter
, 1);
5364 /* Verify that we received all of the key/value pairs */
5365 test_truth(counter
== max_keys
);
5367 memcached_quit(memc
);
5369 * Don't do the following in your code. I am abusing the internal details
5370 * within the library, and this is not a supported interface.
5371 * This is to verify correct behavior in the library. Fake that two servers
5374 instance_one
= memcached_server_instance_fetch(memc
, 0);
5375 instance_two
= memcached_server_instance_fetch(memc
, 2);
5376 in_port_t port0
= instance_one
->port
;
5377 in_port_t port2
= instance_two
->port
;
5379 instance_one
->port
= 0;
5380 instance_two
->port
= 0;
5382 rc
= memcached_mget(memc
, (const char* const *)keys
, key_length
, max_keys
);
5383 test_truth(rc
== MEMCACHED_SUCCESS
);
5386 rc
= memcached_fetch_execute(memc
, callbacks
, (void *)&counter
, 1);
5387 test_truth(counter
== (unsigned int)max_keys
);
5389 /* restore the memc handle */
5390 instance_one
->port
= port0
;
5391 instance_two
->port
= port2
;
5393 memcached_quit(memc
);
5395 /* Remove half of the objects */
5396 for (size_t x
= 0; x
< max_keys
; ++x
)
5400 rc
= memcached_delete(memc
, keys
[x
], key_length
[x
], 0);
5401 test_truth(rc
== MEMCACHED_SUCCESS
);
5405 memcached_quit(memc
);
5406 instance_one
->port
= 0;
5407 instance_two
->port
= 0;
5409 /* now retry the command, this time we should have cache misses */
5410 rc
= memcached_mget(memc
, (const char* const *)keys
, key_length
, max_keys
);
5411 test_truth(rc
== MEMCACHED_SUCCESS
);
5414 rc
= memcached_fetch_execute(memc
, callbacks
, (void *)&counter
, 1);
5415 test_truth(counter
== (unsigned int)(max_keys
>> 1));
5417 /* Release allocated resources */
5418 for (size_t x
= 0; x
< max_keys
; ++x
)
5425 /* restore the memc handle */
5426 instance_one
->port
= port0
;
5427 instance_two
->port
= port2
;
5429 return TEST_SUCCESS
;
5432 static test_return_t
regression_bug_463297(memcached_st
*memc
)
5434 memcached_st
*memc_clone
= memcached_clone(NULL
, memc
);
5435 test_truth(memc_clone
!= NULL
);
5436 test_truth(memcached_version(memc_clone
) == MEMCACHED_SUCCESS
);
5438 memcached_server_instance_st
*instance
=
5439 memcached_server_instance_fetch(memc_clone
, 0);
5441 if (instance
->major_version
> 1 ||
5442 (instance
->major_version
== 1 &&
5443 instance
->minor_version
> 2))
5445 /* Binary protocol doesn't support deferred delete */
5446 memcached_st
*bin_clone
= memcached_clone(NULL
, memc
);
5447 test_truth(bin_clone
!= NULL
);
5448 test_truth(memcached_behavior_set(bin_clone
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
, 1) == MEMCACHED_SUCCESS
);
5449 test_truth(memcached_delete(bin_clone
, "foo", 3, 1) == MEMCACHED_INVALID_ARGUMENTS
);
5450 memcached_free(bin_clone
);
5452 memcached_quit(memc_clone
);
5454 /* If we know the server version, deferred delete should fail
5455 * with invalid arguments */
5456 test_truth(memcached_delete(memc_clone
, "foo", 3, 1) == MEMCACHED_INVALID_ARGUMENTS
);
5458 /* If we don't know the server version, we should get a protocol error */
5459 memcached_return_t rc
= memcached_delete(memc
, "foo", 3, 1);
5461 /* but there is a bug in some of the memcached servers (1.4) that treats
5462 * the counter as noreply so it doesn't send the proper error message
5464 test_truth(rc
== MEMCACHED_PROTOCOL_ERROR
|| rc
== MEMCACHED_NOTFOUND
|| rc
== MEMCACHED_CLIENT_ERROR
);
5466 /* And buffered mode should be disabled and we should get protocol error */
5467 test_truth(memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_BUFFER_REQUESTS
, 1) == MEMCACHED_SUCCESS
);
5468 rc
= memcached_delete(memc
, "foo", 3, 1);
5469 test_truth(rc
== MEMCACHED_PROTOCOL_ERROR
|| rc
== MEMCACHED_NOTFOUND
|| rc
== MEMCACHED_CLIENT_ERROR
);
5471 /* Same goes for noreply... */
5472 test_truth(memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NOREPLY
, 1) == MEMCACHED_SUCCESS
);
5473 rc
= memcached_delete(memc
, "foo", 3, 1);
5474 test_truth(rc
== MEMCACHED_PROTOCOL_ERROR
|| rc
== MEMCACHED_NOTFOUND
|| rc
== MEMCACHED_CLIENT_ERROR
);
5476 /* but a normal request should go through (and be buffered) */
5477 test_truth((rc
= memcached_delete(memc
, "foo", 3, 0)) == MEMCACHED_BUFFERED
);
5478 test_truth(memcached_flush_buffers(memc
) == MEMCACHED_SUCCESS
);
5480 test_truth(memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_BUFFER_REQUESTS
, 0) == MEMCACHED_SUCCESS
);
5481 /* unbuffered noreply should be success */
5482 test_truth(memcached_delete(memc
, "foo", 3, 0) == MEMCACHED_SUCCESS
);
5483 /* unbuffered with reply should be not found... */
5484 test_truth(memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NOREPLY
, 0) == MEMCACHED_SUCCESS
);
5485 test_truth(memcached_delete(memc
, "foo", 3, 0) == MEMCACHED_NOTFOUND
);
5488 memcached_free(memc_clone
);
5489 return TEST_SUCCESS
;
5493 /* Test memcached_server_get_last_disconnect
5494 * For a working server set, shall be NULL
5495 * For a set of non existing server, shall not be NULL
5497 static test_return_t
test_get_last_disconnect(memcached_st
*memc
)
5499 memcached_return_t rc
;
5500 memcached_server_st
*disconnected_server
;
5502 /* With the working set of server */
5503 const char *key
= "marmotte";
5504 const char *value
= "milka";
5506 rc
= memcached_set(memc
, key
, strlen(key
),
5507 value
, strlen(value
),
5508 (time_t)0, (uint32_t)0);
5509 test_truth(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
);
5511 disconnected_server
= memcached_server_get_last_disconnect(memc
);
5512 test_truth(disconnected_server
== NULL
);
5514 /* With a non existing server */
5516 memcached_server_st
*servers
;
5518 const char *server_list
= "localhost:9";
5520 servers
= memcached_servers_parse(server_list
);
5521 test_truth(servers
);
5522 mine
= memcached_create(NULL
);
5523 rc
= memcached_server_push(mine
, servers
);
5524 test_truth(rc
== MEMCACHED_SUCCESS
);
5525 memcached_server_list_free(servers
);
5528 rc
= memcached_set(mine
, key
, strlen(key
),
5529 value
, strlen(value
),
5530 (time_t)0, (uint32_t)0);
5531 test_truth(rc
!= MEMCACHED_SUCCESS
);
5533 disconnected_server
= memcached_server_get_last_disconnect(mine
);
5534 test_truth(disconnected_server
!= NULL
);
5535 test_truth(disconnected_server
->port
== 9);
5536 test_truth(strncmp(disconnected_server
->hostname
,"localhost",9) == 0);
5538 memcached_quit(mine
);
5539 memcached_free(mine
);
5541 return TEST_SUCCESS
;
5545 * This test ensures that the failure counter isn't incremented during
5546 * normal termination of the memcached instance.
5548 static test_return_t
wrong_failure_counter_test(memcached_st
*memc
)
5550 memcached_return_t rc
;
5551 memcached_server_instance_st
*instance
;
5553 /* Set value to force connection to the server */
5554 const char *key
= "marmotte";
5555 const char *value
= "milka";
5558 * Please note that I'm abusing the internal structures in libmemcached
5559 * in a non-portable way and you shouldn't be doing this. I'm only
5560 * doing this in order to verify that the library works the way it should
5562 uint32_t number_of_hosts
= memcached_server_count(memc
);
5563 memc
->number_of_hosts
= 1;
5565 /* Ensure that we are connected to the server by setting a value */
5566 rc
= memcached_set(memc
, key
, strlen(key
),
5567 value
, strlen(value
),
5568 (time_t)0, (uint32_t)0);
5569 test_truth(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
);
5572 instance
= memcached_server_instance_fetch(memc
, 0);
5573 /* The test is to see that the memcached_quit doesn't increase the
5574 * the server failure conter, so let's ensure that it is zero
5575 * before sending quit
5577 instance
->server_failure_counter
= 0;
5579 memcached_quit(memc
);
5581 /* Verify that it memcached_quit didn't increment the failure counter
5582 * Please note that this isn't bullet proof, because an error could
5585 test_truth(instance
->server_failure_counter
== 0);
5587 /* restore the instance */
5588 memc
->number_of_hosts
= number_of_hosts
;
5590 return TEST_SUCCESS
;
5597 * Test that ensures mget_execute does not end into recursive calls that finally fails
5599 static test_return_t
regression_bug_490486(memcached_st
*memc
)
5601 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
, 1);
5602 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NO_BLOCK
, 1);
5603 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_POLL_TIMEOUT
, 1000);
5604 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_SERVER_FAILURE_LIMIT
, 1);
5605 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_RETRY_TIMEOUT
, 3600);
5608 * I only want to hit _one_ server so I know the number of requests I'm
5609 * sending in the pipeline.
5611 uint32_t number_of_hosts
= memc
->number_of_hosts
;
5612 memc
->number_of_hosts
= 1;
5613 size_t max_keys
= 20480;
5616 char **keys
= calloc(max_keys
, sizeof(char*));
5617 size_t *key_length
=calloc(max_keys
, sizeof(size_t));
5619 /* First add all of the items.. */
5620 char blob
[1024]= { 0 };
5621 memcached_return rc
;
5622 for (size_t x
= 0; x
< max_keys
; ++x
)
5625 key_length
[x
]= (size_t)snprintf(k
, sizeof(k
), "0200%zu", x
);
5627 assert(keys
[x
] != NULL
);
5628 rc
= memcached_set(memc
, keys
[x
], key_length
[x
], blob
, sizeof(blob
), 0, 0);
5629 assert(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
);
5632 /* Try to get all of them with a large multiget */
5634 memcached_execute_function callbacks
[1]= { [0]= &callback_counter
};
5635 rc
= memcached_mget_execute(memc
, (const char**)keys
, key_length
,
5636 (size_t)max_keys
, callbacks
, &counter
, 1);
5638 assert(rc
== MEMCACHED_SUCCESS
);
5639 char* the_value
= NULL
;
5640 char the_key
[MEMCACHED_MAX_KEY
];
5641 size_t the_key_length
;
5642 size_t the_value_length
;
5646 the_value
= memcached_fetch(memc
, the_key
, &the_key_length
, &the_value_length
, &the_flags
, &rc
);
5648 if ((the_value
!= NULL
) && (rc
== MEMCACHED_SUCCESS
))
5654 } while ( (the_value
!= NULL
) && (rc
== MEMCACHED_SUCCESS
));
5657 assert(rc
== MEMCACHED_END
);
5659 /* Verify that we got all of the items */
5660 assert(counter
== max_keys
);
5662 /* Release all allocated resources */
5663 for (size_t x
= 0; x
< max_keys
; ++x
)
5670 memc
->number_of_hosts
= number_of_hosts
;
5672 return TEST_SUCCESS
;
5678 test_st udp_setup_server_tests
[] ={
5679 {"set_udp_behavior_test", 0, (test_callback_fn
)set_udp_behavior_test
},
5680 {"add_tcp_server_udp_client_test", 0, (test_callback_fn
)add_tcp_server_udp_client_test
},
5681 {"add_udp_server_tcp_client_test", 0, (test_callback_fn
)add_udp_server_tcp_client_test
},
5685 test_st upd_io_tests
[] ={
5686 {"udp_set_test", 0, (test_callback_fn
)udp_set_test
},
5687 {"udp_buffered_set_test", 0, (test_callback_fn
)udp_buffered_set_test
},
5688 {"udp_set_too_big_test", 0, (test_callback_fn
)udp_set_too_big_test
},
5689 {"udp_delete_test", 0, (test_callback_fn
)udp_delete_test
},
5690 {"udp_buffered_delete_test", 0, (test_callback_fn
)udp_buffered_delete_test
},
5691 {"udp_verbosity_test", 0, (test_callback_fn
)udp_verbosity_test
},
5692 {"udp_quit_test", 0, (test_callback_fn
)udp_quit_test
},
5693 {"udp_flush_test", 0, (test_callback_fn
)udp_flush_test
},
5694 {"udp_incr_test", 0, (test_callback_fn
)udp_incr_test
},
5695 {"udp_decr_test", 0, (test_callback_fn
)udp_decr_test
},
5696 {"udp_stat_test", 0, (test_callback_fn
)udp_stat_test
},
5697 {"udp_version_test", 0, (test_callback_fn
)udp_version_test
},
5698 {"udp_get_test", 0, (test_callback_fn
)udp_get_test
},
5699 {"udp_mixed_io_test", 0, (test_callback_fn
)udp_mixed_io_test
},
5703 /* Clean the server before beginning testing */
5705 {"flush", 0, (test_callback_fn
)flush_test
},
5706 {"init", 0, (test_callback_fn
)init_test
},
5707 {"allocation", 0, (test_callback_fn
)allocation_test
},
5708 {"server_list_null_test", 0, (test_callback_fn
)server_list_null_test
},
5709 {"server_unsort", 0, (test_callback_fn
)server_unsort_test
},
5710 {"server_sort", 0, (test_callback_fn
)server_sort_test
},
5711 {"server_sort2", 0, (test_callback_fn
)server_sort2_test
},
5712 {"clone_test", 0, (test_callback_fn
)clone_test
},
5713 {"connection_test", 0, (test_callback_fn
)connection_test
},
5714 {"callback_test", 0, (test_callback_fn
)callback_test
},
5715 {"userdata_test", 0, (test_callback_fn
)userdata_test
},
5716 {"error", 0, (test_callback_fn
)error_test
},
5717 {"set", 0, (test_callback_fn
)set_test
},
5718 {"set2", 0, (test_callback_fn
)set_test2
},
5719 {"set3", 0, (test_callback_fn
)set_test3
},
5720 {"dump", 1, (test_callback_fn
)dump_test
},
5721 {"add", 1, (test_callback_fn
)add_test
},
5722 {"replace", 1, (test_callback_fn
)replace_test
},
5723 {"delete", 1, (test_callback_fn
)delete_test
},
5724 {"get", 1, (test_callback_fn
)get_test
},
5725 {"get2", 0, (test_callback_fn
)get_test2
},
5726 {"get3", 0, (test_callback_fn
)get_test3
},
5727 {"get4", 0, (test_callback_fn
)get_test4
},
5728 {"partial mget", 0, (test_callback_fn
)get_test5
},
5729 {"stats_servername", 0, (test_callback_fn
)stats_servername_test
},
5730 {"increment", 0, (test_callback_fn
)increment_test
},
5731 {"increment_with_initial", 1, (test_callback_fn
)increment_with_initial_test
},
5732 {"decrement", 0, (test_callback_fn
)decrement_test
},
5733 {"decrement_with_initial", 1, (test_callback_fn
)decrement_with_initial_test
},
5734 {"increment_by_key", 0, (test_callback_fn
)increment_by_key_test
},
5735 {"increment_with_initial_by_key", 1, (test_callback_fn
)increment_with_initial_by_key_test
},
5736 {"decrement_by_key", 0, (test_callback_fn
)decrement_by_key_test
},
5737 {"decrement_with_initial_by_key", 1, (test_callback_fn
)decrement_with_initial_by_key_test
},
5738 {"quit", 0, (test_callback_fn
)quit_test
},
5739 {"mget", 1, (test_callback_fn
)mget_test
},
5740 {"mget_result", 1, (test_callback_fn
)mget_result_test
},
5741 {"mget_result_alloc", 1, (test_callback_fn
)mget_result_alloc_test
},
5742 {"mget_result_function", 1, (test_callback_fn
)mget_result_function
},
5743 {"mget_execute", 1, (test_callback_fn
)mget_execute
},
5744 {"mget_end", 0, (test_callback_fn
)mget_end
},
5745 {"get_stats", 0, (test_callback_fn
)get_stats
},
5746 {"add_host_test", 0, (test_callback_fn
)add_host_test
},
5747 {"add_host_test_1", 0, (test_callback_fn
)add_host_test1
},
5748 {"get_stats_keys", 0, (test_callback_fn
)get_stats_keys
},
5749 {"version_string_test", 0, (test_callback_fn
)version_string_test
},
5750 {"bad_key", 1, (test_callback_fn
)bad_key_test
},
5751 {"memcached_server_cursor", 1, (test_callback_fn
)memcached_server_cursor_test
},
5752 {"read_through", 1, (test_callback_fn
)read_through
},
5753 {"delete_through", 1, (test_callback_fn
)delete_through
},
5754 {"noreply", 1, (test_callback_fn
)noreply_test
},
5755 {"analyzer", 1, (test_callback_fn
)analyzer_test
},
5756 #ifdef HAVE_LIBMEMCACHEDUTIL
5757 {"connectionpool", 1, (test_callback_fn
)connection_pool_test
},
5759 {"test_get_last_disconnect", 1, (test_callback_fn
)test_get_last_disconnect
},
5763 test_st behavior_tests
[] ={
5764 {"behavior_test", 0, (test_callback_fn
)behavior_test
},
5768 test_st async_tests
[] ={
5769 {"add", 1, (test_callback_fn
)add_wrapper
},
5773 test_st string_tests
[] ={
5774 {"string static with null", 0, (test_callback_fn
)string_static_null
},
5775 {"string alloc with null", 0, (test_callback_fn
)string_alloc_null
},
5776 {"string alloc with 1K", 0, (test_callback_fn
)string_alloc_with_size
},
5777 {"string alloc with malloc failure", 0, (test_callback_fn
)string_alloc_with_size_toobig
},
5778 {"string append", 0, (test_callback_fn
)string_alloc_append
},
5779 {"string append failure (too big)", 0, (test_callback_fn
)string_alloc_append_toobig
},
5780 {0, 0, (test_callback_fn
)0}
5783 test_st result_tests
[] ={
5784 {"result static", 0, (test_callback_fn
)result_static
},
5785 {"result alloc", 0, (test_callback_fn
)result_alloc
},
5786 {0, 0, (test_callback_fn
)0}
5789 test_st version_1_2_3
[] ={
5790 {"append", 0, (test_callback_fn
)append_test
},
5791 {"prepend", 0, (test_callback_fn
)prepend_test
},
5792 {"cas", 0, (test_callback_fn
)cas_test
},
5793 {"cas2", 0, (test_callback_fn
)cas2_test
},
5794 {"append_binary", 0, (test_callback_fn
)append_binary_test
},
5795 {0, 0, (test_callback_fn
)0}
5798 test_st user_tests
[] ={
5799 {"user_supplied_bug1", 0, (test_callback_fn
)user_supplied_bug1
},
5800 {"user_supplied_bug2", 0, (test_callback_fn
)user_supplied_bug2
},
5801 {"user_supplied_bug3", 0, (test_callback_fn
)user_supplied_bug3
},
5802 {"user_supplied_bug4", 0, (test_callback_fn
)user_supplied_bug4
},
5803 {"user_supplied_bug5", 1, (test_callback_fn
)user_supplied_bug5
},
5804 {"user_supplied_bug6", 1, (test_callback_fn
)user_supplied_bug6
},
5805 {"user_supplied_bug7", 1, (test_callback_fn
)user_supplied_bug7
},
5806 {"user_supplied_bug8", 1, (test_callback_fn
)user_supplied_bug8
},
5807 {"user_supplied_bug9", 1, (test_callback_fn
)user_supplied_bug9
},
5808 {"user_supplied_bug10", 1, (test_callback_fn
)user_supplied_bug10
},
5809 {"user_supplied_bug11", 1, (test_callback_fn
)user_supplied_bug11
},
5810 {"user_supplied_bug12", 1, (test_callback_fn
)user_supplied_bug12
},
5811 {"user_supplied_bug13", 1, (test_callback_fn
)user_supplied_bug13
},
5812 {"user_supplied_bug14", 1, (test_callback_fn
)user_supplied_bug14
},
5813 {"user_supplied_bug15", 1, (test_callback_fn
)user_supplied_bug15
},
5814 {"user_supplied_bug16", 1, (test_callback_fn
)user_supplied_bug16
},
5817 ** It seems to be something weird with the character sets..
5818 ** value_fetch is unable to parse the value line (iscntrl "fails"), so I
5819 ** guess I need to find out how this is supposed to work.. Perhaps I need
5820 ** to run the test in a specific locale (I tried zh_CN.UTF-8 without success,
5821 ** so just disable the code for now...).
5823 {"user_supplied_bug17", 1, (test_callback_fn
)user_supplied_bug17
},
5825 {"user_supplied_bug18", 1, (test_callback_fn
)user_supplied_bug18
},
5826 {"user_supplied_bug19", 1, (test_callback_fn
)user_supplied_bug19
},
5827 {"user_supplied_bug20", 1, (test_callback_fn
)user_supplied_bug20
},
5828 {"user_supplied_bug21", 1, (test_callback_fn
)user_supplied_bug21
},
5829 {"wrong_failure_counter_test", 1, (test_callback_fn
)wrong_failure_counter_test
},
5830 {0, 0, (test_callback_fn
)0}
5833 test_st replication_tests
[]= {
5834 {"set", 1, (test_callback_fn
)replication_set_test
},
5835 {"get", 0, (test_callback_fn
)replication_get_test
},
5836 {"mget", 0, (test_callback_fn
)replication_mget_test
},
5837 {"delete", 0, (test_callback_fn
)replication_delete_test
},
5838 {"rand_mget", 0, (test_callback_fn
)replication_randomize_mget_test
},
5839 {0, 0, (test_callback_fn
)0}
5843 * The following test suite is used to verify that we don't introduce
5844 * regression bugs. If you want more information about the bug / test,
5845 * you should look in the bug report at
5846 * http://bugs.launchpad.net/libmemcached
5848 test_st regression_tests
[]= {
5849 {"lp:434484", 1, (test_callback_fn
)regression_bug_434484
},
5850 {"lp:434843", 1, (test_callback_fn
)regression_bug_434843
},
5851 {"lp:434843 buffered", 1, (test_callback_fn
)regression_bug_434843_buffered
},
5852 {"lp:421108", 1, (test_callback_fn
)regression_bug_421108
},
5853 {"lp:442914", 1, (test_callback_fn
)regression_bug_442914
},
5854 {"lp:447342", 1, (test_callback_fn
)regression_bug_447342
},
5855 {"lp:463297", 1, (test_callback_fn
)regression_bug_463297
},
5856 {"lp:490486", 1, (test_callback_fn
)regression_bug_490486
},
5857 {0, 0, (test_callback_fn
)0}
5860 test_st ketama_compatibility
[]= {
5861 {"libmemcached", 1, (test_callback_fn
)ketama_compatibility_libmemcached
},
5862 {"spymemcached", 1, (test_callback_fn
)ketama_compatibility_spymemcached
},
5863 {0, 0, (test_callback_fn
)0}
5866 test_st generate_tests
[] ={
5867 {"generate_pairs", 1, (test_callback_fn
)generate_pairs
},
5868 {"generate_data", 1, (test_callback_fn
)generate_data
},
5869 {"get_read", 0, (test_callback_fn
)get_read
},
5870 {"delete_generate", 0, (test_callback_fn
)delete_generate
},
5871 {"generate_buffer_data", 1, (test_callback_fn
)generate_buffer_data
},
5872 {"delete_buffer", 0, (test_callback_fn
)delete_buffer_generate
},
5873 {"generate_data", 1, (test_callback_fn
)generate_data
},
5874 {"mget_read", 0, (test_callback_fn
)mget_read
},
5875 {"mget_read_result", 0, (test_callback_fn
)mget_read_result
},
5876 {"mget_read_function", 0, (test_callback_fn
)mget_read_function
},
5877 {"cleanup", 1, (test_callback_fn
)cleanup_pairs
},
5878 {"generate_large_pairs", 1, (test_callback_fn
)generate_large_pairs
},
5879 {"generate_data", 1, (test_callback_fn
)generate_data
},
5880 {"generate_buffer_data", 1, (test_callback_fn
)generate_buffer_data
},
5881 {"cleanup", 1, (test_callback_fn
)cleanup_pairs
},
5882 {0, 0, (test_callback_fn
)0}
5885 test_st consistent_tests
[] ={
5886 {"generate_pairs", 1, (test_callback_fn
)generate_pairs
},
5887 {"generate_data", 1, (test_callback_fn
)generate_data
},
5888 {"get_read", 0, (test_callback_fn
)get_read_count
},
5889 {"cleanup", 1, (test_callback_fn
)cleanup_pairs
},
5890 {0, 0, (test_callback_fn
)0}
5893 test_st consistent_weighted_tests
[] ={
5894 {"generate_pairs", 1, (test_callback_fn
)generate_pairs
},
5895 {"generate_data", 1, (test_callback_fn
)generate_data_with_stats
},
5896 {"get_read", 0, (test_callback_fn
)get_read_count
},
5897 {"cleanup", 1, (test_callback_fn
)cleanup_pairs
},
5898 {0, 0, (test_callback_fn
)0}
5901 test_st hsieh_availability
[] ={
5902 {"hsieh_avaibility_test", 0, (test_callback_fn
)hsieh_avaibility_test
},
5903 {0, 0, (test_callback_fn
)0}
5907 test_st hash_sanity
[] ={
5908 {"hash sanity", 0, (test_callback_fn
)hash_sanity_test
},
5909 {0, 0, (test_callback_fn
)0}
5913 test_st ketama_auto_eject_hosts
[] ={
5914 {"auto_eject_hosts", 1, (test_callback_fn
)auto_eject_hosts
},
5915 {"output_ketama_weighted_keys", 1, (test_callback_fn
)output_ketama_weighted_keys
},
5916 {0, 0, (test_callback_fn
)0}
5919 test_st hash_tests
[] ={
5920 {"md5", 0, (test_callback_fn
)md5_run
},
5921 {"crc", 0, (test_callback_fn
)crc_run
},
5922 {"fnv1_64", 0, (test_callback_fn
)fnv1_64_run
},
5923 {"fnv1a_64", 0, (test_callback_fn
)fnv1a_64_run
},
5924 {"fnv1_32", 0, (test_callback_fn
)fnv1_32_run
},
5925 {"fnv1a_32", 0, (test_callback_fn
)fnv1a_32_run
},
5926 {"hsieh", 0, (test_callback_fn
)hsieh_run
},
5927 {"murmur", 0, (test_callback_fn
)murmur_run
},
5928 {"jenkis", 0, (test_callback_fn
)jenkins_run
},
5929 {0, 0, (test_callback_fn
)0}
5932 collection_st collection
[] ={
5934 {"hash_sanity", 0, 0, hash_sanity
},
5936 {"hsieh_availability", 0, 0, hsieh_availability
},
5937 {"udp_setup", (test_callback_fn
)init_udp
, 0, udp_setup_server_tests
},
5938 {"udp_io", (test_callback_fn
)init_udp
, 0, upd_io_tests
},
5939 {"udp_binary_io", (test_callback_fn
)binary_init_udp
, 0, upd_io_tests
},
5940 {"block", 0, 0, tests
},
5941 {"binary", (test_callback_fn
)pre_binary
, 0, tests
},
5942 {"nonblock", (test_callback_fn
)pre_nonblock
, 0, tests
},
5943 {"nodelay", (test_callback_fn
)pre_nodelay
, 0, tests
},
5944 {"settimer", (test_callback_fn
)pre_settimer
, 0, tests
},
5945 {"md5", (test_callback_fn
)pre_md5
, 0, tests
},
5946 {"crc", (test_callback_fn
)pre_crc
, 0, tests
},
5947 {"hsieh", (test_callback_fn
)pre_hsieh
, 0, tests
},
5948 {"jenkins", (test_callback_fn
)pre_jenkins
, 0, tests
},
5949 {"fnv1_64", (test_callback_fn
)pre_hash_fnv1_64
, 0, tests
},
5950 {"fnv1a_64", (test_callback_fn
)pre_hash_fnv1a_64
, 0, tests
},
5951 {"fnv1_32", (test_callback_fn
)pre_hash_fnv1_32
, 0, tests
},
5952 {"fnv1a_32", (test_callback_fn
)pre_hash_fnv1a_32
, 0, tests
},
5953 {"ketama", (test_callback_fn
)pre_behavior_ketama
, 0, tests
},
5954 {"ketama_auto_eject_hosts", (test_callback_fn
)pre_behavior_ketama
, 0, ketama_auto_eject_hosts
},
5955 {"unix_socket", (test_callback_fn
)pre_unix_socket
, 0, tests
},
5956 {"unix_socket_nodelay", (test_callback_fn
)pre_nodelay
, 0, tests
},
5957 {"poll_timeout", (test_callback_fn
)poll_timeout
, 0, tests
},
5958 {"gets", (test_callback_fn
)enable_cas
, 0, tests
},
5959 {"consistent_crc", (test_callback_fn
)enable_consistent_crc
, 0, tests
},
5960 {"consistent_hsieh", (test_callback_fn
)enable_consistent_hsieh
, 0, tests
},
5961 #ifdef MEMCACHED_ENABLE_DEPRECATED
5962 {"deprecated_memory_allocators", (test_callback_fn
)deprecated_set_memory_alloc
, 0, tests
},
5964 {"memory_allocators", (test_callback_fn
)set_memory_alloc
, 0, tests
},
5965 {"prefix", (test_callback_fn
)set_prefix
, 0, tests
},
5966 {"version_1_2_3", (test_callback_fn
)check_for_1_2_3
, 0, version_1_2_3
},
5967 {"string", 0, 0, string_tests
},
5968 {"result", 0, 0, result_tests
},
5969 {"async", (test_callback_fn
)pre_nonblock
, 0, async_tests
},
5970 {"async_binary", (test_callback_fn
)pre_nonblock_binary
, 0, async_tests
},
5971 {"user", 0, 0, user_tests
},
5972 {"generate", 0, 0, generate_tests
},
5973 {"generate_hsieh", (test_callback_fn
)pre_hsieh
, 0, generate_tests
},
5974 {"generate_ketama", (test_callback_fn
)pre_behavior_ketama
, 0, generate_tests
},
5975 {"generate_hsieh_consistent", (test_callback_fn
)enable_consistent_hsieh
, 0, generate_tests
},
5976 {"generate_md5", (test_callback_fn
)pre_md5
, 0, generate_tests
},
5977 {"generate_murmur", (test_callback_fn
)pre_murmur
, 0, generate_tests
},
5978 {"generate_jenkins", (test_callback_fn
)pre_jenkins
, 0, generate_tests
},
5979 {"generate_nonblock", (test_callback_fn
)pre_nonblock
, 0, generate_tests
},
5980 {"consistent_not", 0, 0, consistent_tests
},
5981 {"consistent_ketama", (test_callback_fn
)pre_behavior_ketama
, 0, consistent_tests
},
5982 {"consistent_ketama_weighted", (test_callback_fn
)pre_behavior_ketama_weighted
, 0, consistent_weighted_tests
},
5983 {"ketama_compat", 0, 0, ketama_compatibility
},
5984 {"test_hashes", 0, 0, hash_tests
},
5985 {"replication", (test_callback_fn
)pre_replication
, 0, replication_tests
},
5986 {"replication_noblock", (test_callback_fn
)pre_replication_noblock
, 0, replication_tests
},
5987 {"regression", 0, 0, regression_tests
},
5988 {"behaviors", 0, 0, behavior_tests
},
5992 #define SERVERS_TO_CREATE 5
5994 #include "libmemcached_world.h"
5996 void get_world(world_st
*world
)
5998 world
->collections
= collection
;
6000 world
->create
= (test_callback_create_fn
)world_create
;
6001 world
->destroy
= (test_callback_fn
)world_destroy
;
6003 world
->test
.startup
= (test_callback_fn
)world_test_startup
;
6004 world
->test
.flush
= (test_callback_fn
)world_flush
;
6005 world
->test
.pre_run
= (test_callback_fn
)world_pre_run
;
6006 world
->test
.post_run
= (test_callback_fn
)world_post_run
;
6007 world
->test
.on_error
= (test_callback_error_fn
)world_on_error
;
6009 world
->collection
.startup
= (test_callback_fn
)world_container_startup
;
6010 world
->collection
.shutdown
= (test_callback_fn
)world_container_shutdown
;
6012 world
->runner
= &defualt_libmemcached_runner
;