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
MEMCACHED_BEHAVIOR_CORK_test(memcached_st
*memc
)
1863 memcached_return_t rc
;
1867 rc
= memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_CORK
, set
);
1869 test_truth(rc
== MEMCACHED_SUCCESS
);
1871 test_truth(rc
== MEMCACHED_NOT_SUPPORTED
);
1874 value
= (bool)memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_CORK
);
1876 test_truth((bool)value
== set
);
1878 test_false((bool)value
== set
);
1881 return TEST_SUCCESS
;
1884 static test_return_t
fetch_all_results(memcached_st
*memc
)
1886 memcached_return_t rc
= MEMCACHED_SUCCESS
;
1887 char return_key
[MEMCACHED_MAX_KEY
];
1888 size_t return_key_length
;
1890 size_t return_value_length
;
1893 while ((return_value
= memcached_fetch(memc
, return_key
, &return_key_length
,
1894 &return_value_length
, &flags
, &rc
)))
1896 test_truth(return_value
);
1897 test_truth(rc
== MEMCACHED_SUCCESS
);
1901 return ((rc
== MEMCACHED_END
) || (rc
== MEMCACHED_SUCCESS
)) ? TEST_SUCCESS
: TEST_FAILURE
;
1904 /* Test case provided by Cal Haldenbrand */
1905 static test_return_t
user_supplied_bug1(memcached_st
*memc
)
1907 unsigned int setter
= 1;
1909 unsigned long long total
= 0;
1912 char randomstuff
[6 * 1024];
1913 memcached_return_t rc
;
1915 memset(randomstuff
, 0, 6 * 1024);
1917 /* We just keep looking at the same values over and over */
1920 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NO_BLOCK
, setter
);
1921 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_TCP_NODELAY
, setter
);
1925 for (uint32_t x
= 0 ; total
< 20 * 1024576 ; x
++ )
1929 size
= (uint32_t)(rand() % ( 5 * 1024 ) ) + 400;
1930 memset(randomstuff
, 0, 6 * 1024);
1931 test_truth(size
< 6 * 1024); /* Being safe here */
1933 for (j
= 0 ; j
< size
;j
++)
1934 randomstuff
[j
] = (signed char) ((rand() % 26) + 97);
1937 snprintf(key
, sizeof(key
), "%u", x
);
1938 rc
= memcached_set(memc
, key
, strlen(key
),
1939 randomstuff
, strlen(randomstuff
), 10, 0);
1940 test_truth(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
);
1941 /* If we fail, lets try again */
1942 if (rc
!= MEMCACHED_SUCCESS
&& rc
!= MEMCACHED_BUFFERED
)
1943 rc
= memcached_set(memc
, key
, strlen(key
),
1944 randomstuff
, strlen(randomstuff
), 10, 0);
1945 test_truth(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
);
1948 return TEST_SUCCESS
;
1951 /* Test case provided by Cal Haldenbrand */
1952 static test_return_t
user_supplied_bug2(memcached_st
*memc
)
1954 unsigned int setter
;
1958 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NO_BLOCK
, setter
);
1959 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_TCP_NODELAY
, setter
);
1961 setter
= 20 * 1024576;
1962 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_SOCKET_SEND_SIZE
, setter
);
1963 setter
= 20 * 1024576;
1964 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_SOCKET_RECV_SIZE
, setter
);
1965 getter
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_SOCKET_SEND_SIZE
);
1966 getter
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_SOCKET_RECV_SIZE
);
1968 for (x
= 0, errors
= 0; total
< 20 * 1024576 ; x
++)
1971 for (uint32_t x
= 0, errors
= 0; total
< 24576 ; x
++)
1973 memcached_return_t rc
= MEMCACHED_SUCCESS
;
1974 char buffer
[SMALL_STRING_LEN
];
1979 memset(buffer
, 0, SMALL_STRING_LEN
);
1981 snprintf(buffer
, sizeof(buffer
), "%u", x
);
1982 getval
= memcached_get(memc
, buffer
, strlen(buffer
),
1983 &val_len
, &flags
, &rc
);
1984 if (rc
!= MEMCACHED_SUCCESS
)
1986 if (rc
== MEMCACHED_NOTFOUND
)
2000 return TEST_SUCCESS
;
2003 /* Do a large mget() over all the keys we think exist */
2004 #define KEY_COUNT 3000 // * 1024576
2005 static test_return_t
user_supplied_bug3(memcached_st
*memc
)
2007 memcached_return_t rc
;
2008 unsigned int setter
;
2011 size_t key_lengths
[KEY_COUNT
];
2014 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NO_BLOCK
, setter
);
2015 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_TCP_NODELAY
, setter
);
2017 setter
= 20 * 1024576;
2018 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_SOCKET_SEND_SIZE
, setter
);
2019 setter
= 20 * 1024576;
2020 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_SOCKET_RECV_SIZE
, setter
);
2021 getter
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_SOCKET_SEND_SIZE
);
2022 getter
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_SOCKET_RECV_SIZE
);
2025 keys
= calloc(KEY_COUNT
, sizeof(char *));
2027 for (x
= 0; x
< KEY_COUNT
; x
++)
2031 snprintf(buffer
, 30, "%u", x
);
2032 keys
[x
]= strdup(buffer
);
2033 key_lengths
[x
]= strlen(keys
[x
]);
2036 rc
= memcached_mget(memc
, (const char **)keys
, key_lengths
, KEY_COUNT
);
2037 test_truth(rc
== MEMCACHED_SUCCESS
);
2039 test_truth(fetch_all_results(memc
) == TEST_SUCCESS
);
2041 for (x
= 0; x
< KEY_COUNT
; x
++)
2045 return TEST_SUCCESS
;
2048 /* Make sure we behave properly if server list has no values */
2049 static test_return_t
user_supplied_bug4(memcached_st
*memc
)
2051 memcached_return_t rc
;
2052 const char *keys
[]= {"fudge", "son", "food"};
2053 size_t key_length
[]= {5, 3, 4};
2056 char return_key
[MEMCACHED_MAX_KEY
];
2057 size_t return_key_length
;
2059 size_t return_value_length
;
2061 /* Here we free everything before running a bunch of mget tests */
2062 memcached_servers_reset(memc
);
2065 /* We need to empty the server before continueing test */
2066 rc
= memcached_flush(memc
, 0);
2067 test_truth(rc
== MEMCACHED_NO_SERVERS
);
2069 rc
= memcached_mget(memc
, keys
, key_length
, 3);
2070 test_truth(rc
== MEMCACHED_NO_SERVERS
);
2072 while ((return_value
= memcached_fetch(memc
, return_key
, &return_key_length
,
2073 &return_value_length
, &flags
, &rc
)) != NULL
)
2075 test_truth(return_value
);
2077 test_truth(!return_value
);
2078 test_truth(return_value_length
== 0);
2079 test_truth(rc
== MEMCACHED_NO_SERVERS
);
2081 for (x
= 0; x
< 3; x
++)
2083 rc
= memcached_set(memc
, keys
[x
], key_length
[x
],
2084 keys
[x
], key_length
[x
],
2085 (time_t)50, (uint32_t)9);
2086 test_truth(rc
== MEMCACHED_NO_SERVERS
);
2089 rc
= memcached_mget(memc
, keys
, key_length
, 3);
2090 test_truth(rc
== MEMCACHED_NO_SERVERS
);
2093 while ((return_value
= memcached_fetch(memc
, return_key
, &return_key_length
,
2094 &return_value_length
, &flags
, &rc
)))
2096 test_truth(return_value
);
2097 test_truth(rc
== MEMCACHED_SUCCESS
);
2098 test_truth(return_key_length
== return_value_length
);
2099 test_truth(!memcmp(return_value
, return_key
, return_value_length
));
2104 return TEST_SUCCESS
;
2107 #define VALUE_SIZE_BUG5 1048064
2108 static test_return_t
user_supplied_bug5(memcached_st
*memc
)
2110 memcached_return_t rc
;
2111 const char *keys
[]= {"036790384900", "036790384902", "036790384904", "036790384906"};
2112 size_t key_length
[]= {strlen("036790384900"), strlen("036790384902"), strlen("036790384904"), strlen("036790384906")};
2113 char return_key
[MEMCACHED_MAX_KEY
];
2114 size_t return_key_length
;
2116 size_t value_length
;
2120 char insert_data
[VALUE_SIZE_BUG5
];
2122 for (x
= 0; x
< VALUE_SIZE_BUG5
; x
++)
2123 insert_data
[x
]= (signed char)rand();
2125 memcached_flush(memc
, 0);
2126 value
= memcached_get(memc
, keys
[0], key_length
[0],
2127 &value_length
, &flags
, &rc
);
2128 test_truth(value
== NULL
);
2129 rc
= memcached_mget(memc
, keys
, key_length
, 4);
2132 while ((value
= memcached_fetch(memc
, return_key
, &return_key_length
,
2133 &value_length
, &flags
, &rc
)))
2135 test_truth(count
== 0);
2137 for (x
= 0; x
< 4; x
++)
2139 rc
= memcached_set(memc
, keys
[x
], key_length
[x
],
2140 insert_data
, VALUE_SIZE_BUG5
,
2141 (time_t)0, (uint32_t)0);
2142 test_truth(rc
== MEMCACHED_SUCCESS
);
2145 for (x
= 0; x
< 10; x
++)
2147 value
= memcached_get(memc
, keys
[0], key_length
[0],
2148 &value_length
, &flags
, &rc
);
2152 rc
= memcached_mget(memc
, keys
, key_length
, 4);
2154 while ((value
= memcached_fetch(memc
, return_key
, &return_key_length
,
2155 &value_length
, &flags
, &rc
)))
2160 test_truth(count
== 4);
2163 return TEST_SUCCESS
;
2166 static test_return_t
user_supplied_bug6(memcached_st
*memc
)
2168 memcached_return_t rc
;
2169 const char *keys
[]= {"036790384900", "036790384902", "036790384904", "036790384906"};
2170 size_t key_length
[]= {strlen("036790384900"), strlen("036790384902"), strlen("036790384904"), strlen("036790384906")};
2171 char return_key
[MEMCACHED_MAX_KEY
];
2172 size_t return_key_length
;
2174 size_t value_length
;
2178 char insert_data
[VALUE_SIZE_BUG5
];
2180 for (x
= 0; x
< VALUE_SIZE_BUG5
; x
++)
2181 insert_data
[x
]= (signed char)rand();
2183 memcached_flush(memc
, 0);
2184 value
= memcached_get(memc
, keys
[0], key_length
[0],
2185 &value_length
, &flags
, &rc
);
2186 test_truth(value
== NULL
);
2187 test_truth(rc
== MEMCACHED_NOTFOUND
);
2188 rc
= memcached_mget(memc
, keys
, key_length
, 4);
2189 test_truth(rc
== MEMCACHED_SUCCESS
);
2192 while ((value
= memcached_fetch(memc
, return_key
, &return_key_length
,
2193 &value_length
, &flags
, &rc
)))
2195 test_truth(count
== 0);
2196 test_truth(rc
== MEMCACHED_END
);
2198 for (x
= 0; x
< 4; x
++)
2200 rc
= memcached_set(memc
, keys
[x
], key_length
[x
],
2201 insert_data
, VALUE_SIZE_BUG5
,
2202 (time_t)0, (uint32_t)0);
2203 test_truth(rc
== MEMCACHED_SUCCESS
);
2206 for (x
= 0; x
< 2; x
++)
2208 value
= memcached_get(memc
, keys
[0], key_length
[0],
2209 &value_length
, &flags
, &rc
);
2213 rc
= memcached_mget(memc
, keys
, key_length
, 4);
2214 test_truth(rc
== MEMCACHED_SUCCESS
);
2216 /* We test for purge of partial complete fetches */
2217 for (count
= 3; count
; count
--)
2219 value
= memcached_fetch(memc
, return_key
, &return_key_length
,
2220 &value_length
, &flags
, &rc
);
2221 test_truth(rc
== MEMCACHED_SUCCESS
);
2222 test_truth(!(memcmp(value
, insert_data
, value_length
)));
2223 test_truth(value_length
);
2228 return TEST_SUCCESS
;
2231 static test_return_t
user_supplied_bug8(memcached_st
*memc
__attribute__((unused
)))
2233 memcached_return_t rc
;
2235 memcached_st
*memc_clone
;
2237 memcached_server_st
*servers
;
2238 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";
2240 servers
= memcached_servers_parse(server_list
);
2241 test_truth(servers
);
2243 mine
= memcached_create(NULL
);
2244 rc
= memcached_server_push(mine
, servers
);
2245 test_truth(rc
== MEMCACHED_SUCCESS
);
2246 memcached_server_list_free(servers
);
2249 memc_clone
= memcached_clone(NULL
, mine
);
2251 memcached_quit(mine
);
2252 memcached_quit(memc_clone
);
2255 memcached_free(mine
);
2256 memcached_free(memc_clone
);
2258 return TEST_SUCCESS
;
2261 /* Test flag store/retrieve */
2262 static test_return_t
user_supplied_bug7(memcached_st
*memc
)
2264 memcached_return_t rc
;
2265 const char *keys
= "036790384900";
2266 size_t key_length
= strlen(keys
);
2267 char return_key
[MEMCACHED_MAX_KEY
];
2268 size_t return_key_length
;
2270 size_t value_length
;
2273 char insert_data
[VALUE_SIZE_BUG5
];
2275 for (x
= 0; x
< VALUE_SIZE_BUG5
; x
++)
2276 insert_data
[x
]= (signed char)rand();
2278 memcached_flush(memc
, 0);
2281 rc
= memcached_set(memc
, keys
, key_length
,
2282 insert_data
, VALUE_SIZE_BUG5
,
2284 test_truth(rc
== MEMCACHED_SUCCESS
);
2287 value
= memcached_get(memc
, keys
, key_length
,
2288 &value_length
, &flags
, &rc
);
2289 test_truth(flags
== 245);
2293 rc
= memcached_mget(memc
, &keys
, &key_length
, 1);
2296 value
= memcached_fetch(memc
, return_key
, &return_key_length
,
2297 &value_length
, &flags
, &rc
);
2298 test_truth(flags
== 245);
2303 return TEST_SUCCESS
;
2306 static test_return_t
user_supplied_bug9(memcached_st
*memc
)
2308 memcached_return_t rc
;
2309 const char *keys
[]= {"UDATA:edevil@sapo.pt", "fudge&*@#", "for^#@&$not"};
2310 size_t key_length
[3];
2315 char return_key
[MEMCACHED_MAX_KEY
];
2316 size_t return_key_length
;
2318 size_t return_value_length
;
2321 key_length
[0]= strlen("UDATA:edevil@sapo.pt");
2322 key_length
[1]= strlen("fudge&*@#");
2323 key_length
[2]= strlen("for^#@&$not");
2326 for (x
= 0; x
< 3; x
++)
2328 rc
= memcached_set(memc
, keys
[x
], key_length
[x
],
2329 keys
[x
], key_length
[x
],
2330 (time_t)50, (uint32_t)9);
2331 test_truth(rc
== MEMCACHED_SUCCESS
);
2334 rc
= memcached_mget(memc
, keys
, key_length
, 3);
2335 test_truth(rc
== MEMCACHED_SUCCESS
);
2337 /* We need to empty the server before continueing test */
2338 while ((return_value
= memcached_fetch(memc
, return_key
, &return_key_length
,
2339 &return_value_length
, &flags
, &rc
)) != NULL
)
2341 test_truth(return_value
);
2345 test_truth(count
== 3);
2347 return TEST_SUCCESS
;
2350 /* We are testing with aggressive timeout to get failures */
2351 static test_return_t
user_supplied_bug10(memcached_st
*memc
)
2353 const char *key
= "foo";
2355 size_t value_length
= 512;
2358 memcached_return_t rc
;
2359 unsigned int set
= 1;
2360 memcached_st
*mclone
= memcached_clone(NULL
, memc
);
2363 memcached_behavior_set(mclone
, MEMCACHED_BEHAVIOR_NO_BLOCK
, set
);
2364 memcached_behavior_set(mclone
, MEMCACHED_BEHAVIOR_TCP_NODELAY
, set
);
2366 memcached_behavior_set(mclone
, MEMCACHED_BEHAVIOR_POLL_TIMEOUT
,
2369 value
= (char*)malloc(value_length
* sizeof(char));
2371 for (x
= 0; x
< value_length
; x
++)
2372 value
[x
]= (char) (x
% 127);
2374 for (x
= 1; x
<= 100000; ++x
)
2376 rc
= memcached_set(mclone
, key
, key_len
,value
, value_length
, 0, 0);
2378 test_truth(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_WRITE_FAILURE
||
2379 rc
== MEMCACHED_BUFFERED
|| rc
== MEMCACHED_TIMEOUT
);
2381 if (rc
== MEMCACHED_WRITE_FAILURE
|| rc
== MEMCACHED_TIMEOUT
)
2386 memcached_free(mclone
);
2388 return TEST_SUCCESS
;
2392 We are looking failures in the async protocol
2394 static test_return_t
user_supplied_bug11(memcached_st
*memc
)
2396 const char *key
= "foo";
2398 size_t value_length
= 512;
2401 memcached_return_t rc
;
2402 unsigned int set
= 1;
2404 memcached_st
*mclone
= memcached_clone(NULL
, memc
);
2406 memcached_behavior_set(mclone
, MEMCACHED_BEHAVIOR_NO_BLOCK
, set
);
2407 memcached_behavior_set(mclone
, MEMCACHED_BEHAVIOR_TCP_NODELAY
, set
);
2409 memcached_behavior_set(mclone
, MEMCACHED_BEHAVIOR_POLL_TIMEOUT
,
2412 timeout
= (int32_t)memcached_behavior_get(mclone
, MEMCACHED_BEHAVIOR_POLL_TIMEOUT
);
2414 test_truth(timeout
== -1);
2416 value
= (char*)malloc(value_length
* sizeof(char));
2418 for (x
= 0; x
< value_length
; x
++)
2419 value
[x
]= (char) (x
% 127);
2421 for (x
= 1; x
<= 100000; ++x
)
2423 rc
= memcached_set(mclone
, key
, key_len
,value
, value_length
, 0, 0);
2427 memcached_free(mclone
);
2429 return TEST_SUCCESS
;
2433 Bug found where incr was not returning MEMCACHED_NOTFOUND when object did not exist.
2435 static test_return_t
user_supplied_bug12(memcached_st
*memc
)
2437 memcached_return_t rc
;
2439 size_t value_length
;
2441 uint64_t number_value
;
2443 value
= memcached_get(memc
, "autoincrement", strlen("autoincrement"),
2444 &value_length
, &flags
, &rc
);
2445 test_truth(value
== NULL
);
2446 test_truth(rc
== MEMCACHED_NOTFOUND
);
2448 rc
= memcached_increment(memc
, "autoincrement", strlen("autoincrement"),
2451 test_truth(value
== NULL
);
2452 /* The binary protocol will set the key if it doesn't exist */
2453 if (memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
) == 1)
2455 test_truth(rc
== MEMCACHED_SUCCESS
);
2459 test_truth(rc
== MEMCACHED_NOTFOUND
);
2462 rc
= memcached_set(memc
, "autoincrement", strlen("autoincrement"), "1", 1, 0, 0);
2464 value
= memcached_get(memc
, "autoincrement", strlen("autoincrement"),
2465 &value_length
, &flags
, &rc
);
2467 test_truth(rc
== MEMCACHED_SUCCESS
);
2470 rc
= memcached_increment(memc
, "autoincrement", strlen("autoincrement"),
2472 test_truth(number_value
== 2);
2473 test_truth(rc
== MEMCACHED_SUCCESS
);
2475 return TEST_SUCCESS
;
2479 Bug found where command total one more than MEMCACHED_MAX_BUFFER
2480 set key34567890 0 0 8169 \r\n is sent followed by buffer of size 8169, followed by 8169
2482 static test_return_t
user_supplied_bug13(memcached_st
*memc
)
2484 char key
[] = "key34567890";
2486 memcached_return_t rc
;
2487 size_t overflowSize
;
2489 char commandFirst
[]= "set key34567890 0 0 ";
2490 char commandLast
[] = " \r\n"; /* first line of command sent to server */
2491 size_t commandLength
;
2494 commandLength
= strlen(commandFirst
) + strlen(commandLast
) + 4; /* 4 is number of characters in size, probably 8196 */
2496 overflowSize
= MEMCACHED_MAX_BUFFER
- commandLength
;
2498 for (testSize
= overflowSize
- 1; testSize
< overflowSize
+ 1; testSize
++)
2500 overflow
= malloc(testSize
);
2501 test_truth(overflow
!= NULL
);
2503 memset(overflow
, 'x', testSize
);
2504 rc
= memcached_set(memc
, key
, strlen(key
),
2505 overflow
, testSize
, 0, 0);
2506 test_truth(rc
== MEMCACHED_SUCCESS
);
2510 return TEST_SUCCESS
;
2515 Test values of many different sizes
2516 Bug found where command total one more than MEMCACHED_MAX_BUFFER
2517 set key34567890 0 0 8169 \r\n
2518 is sent followed by buffer of size 8169, followed by 8169
2520 static test_return_t
user_supplied_bug14(memcached_st
*memc
)
2523 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_TCP_NODELAY
, setter
);
2524 memcached_return_t rc
;
2525 const char *key
= "foo";
2527 size_t value_length
= 18000;
2529 size_t string_length
;
2532 size_t current_length
;
2534 value
= (char*)malloc(value_length
);
2537 for (x
= 0; x
< value_length
; x
++)
2538 value
[x
] = (char) (x
% 127);
2540 for (current_length
= 0; current_length
< value_length
; current_length
++)
2542 rc
= memcached_set(memc
, key
, strlen(key
),
2543 value
, current_length
,
2544 (time_t)0, (uint32_t)0);
2545 test_truth(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
);
2547 string
= memcached_get(memc
, key
, strlen(key
),
2548 &string_length
, &flags
, &rc
);
2550 test_truth(rc
== MEMCACHED_SUCCESS
);
2551 test_truth(string_length
== current_length
);
2552 test_truth(!memcmp(string
, value
, string_length
));
2559 return TEST_SUCCESS
;
2563 Look for zero length value problems
2565 static test_return_t
user_supplied_bug15(memcached_st
*memc
)
2568 memcached_return_t rc
;
2569 const char *key
= "mykey";
2574 for (x
= 0; x
< 2; x
++)
2576 rc
= memcached_set(memc
, key
, strlen(key
),
2578 (time_t)0, (uint32_t)0);
2580 test_truth(rc
== MEMCACHED_SUCCESS
);
2582 value
= memcached_get(memc
, key
, strlen(key
),
2583 &length
, &flags
, &rc
);
2585 test_truth(rc
== MEMCACHED_SUCCESS
);
2586 test_truth(value
== NULL
);
2587 test_truth(length
== 0);
2588 test_truth(flags
== 0);
2590 value
= memcached_get(memc
, key
, strlen(key
),
2591 &length
, &flags
, &rc
);
2593 test_truth(rc
== MEMCACHED_SUCCESS
);
2594 test_truth(value
== NULL
);
2595 test_truth(length
== 0);
2596 test_truth(flags
== 0);
2599 return TEST_SUCCESS
;
2602 /* Check the return sizes on FLAGS to make sure it stores 32bit unsigned values correctly */
2603 static test_return_t
user_supplied_bug16(memcached_st
*memc
)
2605 memcached_return_t rc
;
2606 const char *key
= "mykey";
2611 rc
= memcached_set(memc
, key
, strlen(key
),
2613 (time_t)0, UINT32_MAX
);
2615 test_truth(rc
== MEMCACHED_SUCCESS
);
2617 value
= memcached_get(memc
, key
, strlen(key
),
2618 &length
, &flags
, &rc
);
2620 test_truth(rc
== MEMCACHED_SUCCESS
);
2621 test_truth(value
== NULL
);
2622 test_truth(length
== 0);
2623 test_truth(flags
== UINT32_MAX
);
2625 return TEST_SUCCESS
;
2629 /* Check the validity of chinese key*/
2630 static test_return_t
user_supplied_bug17(memcached_st
*memc
)
2632 memcached_return_t rc
;
2633 const char *key
= "豆瓣";
2634 const char *value
="我们在炎热抑郁的夏天无法停止豆瓣";
2639 rc
= memcached_set(memc
, key
, strlen(key
),
2640 value
, strlen(value
),
2643 test_truth(rc
== MEMCACHED_SUCCESS
);
2645 value2
= memcached_get(memc
, key
, strlen(key
),
2646 &length
, &flags
, &rc
);
2648 test_truth(length
==strlen(value
));
2649 test_truth(rc
== MEMCACHED_SUCCESS
);
2650 test_truth(memcmp(value
, value2
, length
)==0);
2653 return TEST_SUCCESS
;
2661 static test_return_t
user_supplied_bug19(memcached_st
*memc
)
2664 memcached_server_st
*s
;
2665 memcached_return_t res
;
2669 m
= memcached_create(NULL
);
2670 memcached_server_add_with_weight(m
, "localhost", 11311, 100);
2671 memcached_server_add_with_weight(m
, "localhost", 11312, 100);
2673 s
= memcached_server_by_key(m
, "a", 1, &res
);
2674 memcached_server_free(s
);
2678 return TEST_SUCCESS
;
2681 /* CAS test from Andei */
2682 static test_return_t
user_supplied_bug20(memcached_st
*memc
)
2684 memcached_return_t status
;
2685 memcached_result_st
*result
, result_obj
;
2686 const char *key
= "abc";
2687 size_t key_len
= strlen("abc");
2688 const char *value
= "foobar";
2689 size_t value_len
= strlen(value
);
2691 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_SUPPORT_CAS
, 1);
2693 status
= memcached_set(memc
, key
, key_len
, value
, value_len
, (time_t)0, (uint32_t)0);
2694 test_truth(status
== MEMCACHED_SUCCESS
);
2696 status
= memcached_mget(memc
, &key
, &key_len
, 1);
2697 test_truth(status
== MEMCACHED_SUCCESS
);
2699 result
= memcached_result_create(memc
, &result_obj
);
2702 memcached_result_create(memc
, &result_obj
);
2703 result
= memcached_fetch_result(memc
, &result_obj
, &status
);
2706 test_truth(status
== MEMCACHED_SUCCESS
);
2708 memcached_result_free(result
);
2710 return TEST_SUCCESS
;
2713 #include "ketama_test_cases.h"
2714 static test_return_t
user_supplied_bug18(memcached_st
*trash
)
2716 memcached_return_t rc
;
2719 memcached_server_st
*server_pool
;
2724 memc
= memcached_create(NULL
);
2727 rc
= memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_KETAMA_WEIGHTED
, 1);
2728 test_truth(rc
== MEMCACHED_SUCCESS
);
2730 value
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_KETAMA_WEIGHTED
);
2731 test_truth(value
== 1);
2733 rc
= memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_KETAMA_HASH
, MEMCACHED_HASH_MD5
);
2734 test_truth(rc
== MEMCACHED_SUCCESS
);
2736 value
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_KETAMA_HASH
);
2737 test_truth(value
== MEMCACHED_HASH_MD5
);
2739 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");
2740 memcached_server_push(memc
, server_pool
);
2742 /* verify that the server list was parsed okay. */
2743 test_truth(memcached_server_count(memc
) == 8);
2744 test_truth(strcmp(server_pool
[0].hostname
, "10.0.1.1") == 0);
2745 test_truth(server_pool
[0].port
== 11211);
2746 test_truth(server_pool
[0].weight
== 600);
2747 test_truth(strcmp(server_pool
[2].hostname
, "10.0.1.3") == 0);
2748 test_truth(server_pool
[2].port
== 11211);
2749 test_truth(server_pool
[2].weight
== 200);
2750 test_truth(strcmp(server_pool
[7].hostname
, "10.0.1.8") == 0);
2751 test_truth(server_pool
[7].port
== 11211);
2752 test_truth(server_pool
[7].weight
== 100);
2754 /* VDEAAAAA hashes to fffcd1b5, after the last continuum point, and lets
2755 * us test the boundary wraparound.
2757 test_truth(memcached_generate_hash(memc
, (char *)"VDEAAAAA", 8) == memc
->continuum
[0].index
);
2759 /* verify the standard ketama set. */
2760 for (x
= 0; x
< 99; x
++)
2762 uint32_t server_idx
= memcached_generate_hash(memc
, ketama_test_cases
[x
].key
, strlen(ketama_test_cases
[x
].key
));
2763 memcached_server_instance_st
*instance
=
2764 memcached_server_instance_fetch(memc
, server_idx
);
2765 char *hostname
= instance
->hostname
;
2766 test_strcmp(hostname
, ketama_test_cases
[x
].server
);
2769 memcached_server_list_free(server_pool
);
2770 memcached_free(memc
);
2772 return TEST_SUCCESS
;
2775 /* Large mget() of missing keys with binary proto
2777 * If many binary quiet commands (such as getq's in an mget) fill the output
2778 * buffer and the server chooses not to respond, memcached_flush hangs. See
2779 * http://lists.tangent.org/pipermail/libmemcached/2009-August/000918.html
2782 /* sighandler_t function that always asserts false */
2783 static void fail(int unused
__attribute__((unused
)))
2789 static test_return_t
_user_supplied_bug21(memcached_st
* memc
, size_t key_count
)
2791 memcached_return_t rc
;
2794 size_t* key_lengths
;
2795 void (*oldalarm
)(int);
2796 memcached_st
*memc_clone
;
2798 memc_clone
= memcached_clone(NULL
, memc
);
2799 test_truth(memc_clone
);
2801 /* only binproto uses getq for mget */
2802 memcached_behavior_set(memc_clone
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
, 1);
2804 /* empty the cache to ensure misses (hence non-responses) */
2805 rc
= memcached_flush(memc_clone
, 0);
2806 test_truth(rc
== MEMCACHED_SUCCESS
);
2808 key_lengths
= calloc(key_count
, sizeof(size_t));
2809 keys
= calloc(key_count
, sizeof(char *));
2811 for (x
= 0; x
< key_count
; x
++)
2815 snprintf(buffer
, 30, "%u", x
);
2816 keys
[x
]= strdup(buffer
);
2817 key_lengths
[x
]= strlen(keys
[x
]);
2820 oldalarm
= signal(SIGALRM
, fail
);
2823 rc
= memcached_mget(memc_clone
, (const char **)keys
, key_lengths
, key_count
);
2824 test_truth(rc
== MEMCACHED_SUCCESS
);
2827 signal(SIGALRM
, oldalarm
);
2829 test_truth(fetch_all_results(memc
) == TEST_SUCCESS
);
2831 for (x
= 0; x
< key_count
; x
++)
2836 memcached_free(memc_clone
);
2838 return TEST_SUCCESS
;
2841 static test_return_t
pre_binary(memcached_st
*memc
);
2843 static test_return_t
user_supplied_bug21(memcached_st
*memc
)
2845 test_return_t test_rc
;
2846 test_rc
= pre_binary(memc
);
2848 if (test_rc
!= TEST_SUCCESS
)
2853 /* should work as of r580 */
2854 rc
= _user_supplied_bug21(memc
, 10);
2855 test_truth(rc
== TEST_SUCCESS
);
2857 /* should fail as of r580 */
2858 rc
= _user_supplied_bug21(memc
, 1000);
2859 test_truth(rc
== TEST_SUCCESS
);
2861 return TEST_SUCCESS
;
2864 static test_return_t
auto_eject_hosts(memcached_st
*trash
)
2867 memcached_server_instance_st
*instance
;
2869 memcached_return_t rc
;
2870 memcached_st
*memc
= memcached_create(NULL
);
2873 rc
= memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_KETAMA_WEIGHTED
, 1);
2874 test_truth(rc
== MEMCACHED_SUCCESS
);
2876 uint64_t value
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_KETAMA_WEIGHTED
);
2877 test_truth(value
== 1);
2879 rc
= memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_KETAMA_HASH
, MEMCACHED_HASH_MD5
);
2880 test_truth(rc
== MEMCACHED_SUCCESS
);
2882 value
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_KETAMA_HASH
);
2883 test_truth(value
== MEMCACHED_HASH_MD5
);
2885 /* server should be removed when in delay */
2886 rc
= memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_AUTO_EJECT_HOSTS
, 1);
2887 test_truth(rc
== MEMCACHED_SUCCESS
);
2889 value
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_AUTO_EJECT_HOSTS
);
2890 test_truth(value
== 1);
2892 memcached_server_st
*server_pool
;
2893 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");
2894 memcached_server_push(memc
, server_pool
);
2896 /* verify that the server list was parsed okay. */
2897 test_truth(memcached_server_count(memc
) == 8);
2898 test_truth(strcmp(server_pool
[0].hostname
, "10.0.1.1") == 0);
2899 test_truth(server_pool
[0].port
== 11211);
2900 test_truth(server_pool
[0].weight
== 600);
2901 test_truth(strcmp(server_pool
[2].hostname
, "10.0.1.3") == 0);
2902 test_truth(server_pool
[2].port
== 11211);
2903 test_truth(server_pool
[2].weight
== 200);
2904 test_truth(strcmp(server_pool
[7].hostname
, "10.0.1.8") == 0);
2905 test_truth(server_pool
[7].port
== 11211);
2906 test_truth(server_pool
[7].weight
== 100);
2908 instance
= memcached_server_instance_fetch(memc
, 2);
2909 instance
->next_retry
= time(NULL
) + 15;
2910 memc
->next_distribution_rebuild
= time(NULL
) - 1;
2912 for (size_t x
= 0; x
< 99; x
++)
2914 uint32_t server_idx
= memcached_generate_hash(memc
, ketama_test_cases
[x
].key
, strlen(ketama_test_cases
[x
].key
));
2915 test_truth(server_idx
!= 2);
2918 /* and re-added when it's back. */
2919 instance
->next_retry
= time(NULL
) - 1;
2920 memc
->next_distribution_rebuild
= time(NULL
) - 1;
2921 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_DISTRIBUTION
,
2922 memc
->distribution
);
2923 for (size_t x
= 0; x
< 99; x
++)
2925 uint32_t server_idx
= memcached_generate_hash(memc
, ketama_test_cases
[x
].key
, strlen(ketama_test_cases
[x
].key
));
2926 // We re-use instance from above.
2928 memcached_server_instance_fetch(memc
, server_idx
);
2929 char *hostname
= instance
->hostname
;
2930 test_truth(strcmp(hostname
, ketama_test_cases
[x
].server
) == 0);
2933 memcached_server_list_free(server_pool
);
2934 memcached_free(memc
);
2936 return TEST_SUCCESS
;
2939 static test_return_t
output_ketama_weighted_keys(memcached_st
*trash
)
2943 memcached_return_t rc
;
2944 memcached_st
*memc
= memcached_create(NULL
);
2948 rc
= memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_KETAMA_WEIGHTED
, 1);
2949 test_truth(rc
== MEMCACHED_SUCCESS
);
2951 uint64_t value
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_KETAMA_WEIGHTED
);
2952 test_truth(value
== 1);
2954 rc
= memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_KETAMA_HASH
, MEMCACHED_HASH_MD5
);
2955 test_truth(rc
== MEMCACHED_SUCCESS
);
2957 value
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_KETAMA_HASH
);
2958 test_truth(value
== MEMCACHED_HASH_MD5
);
2961 test_truth(memcached_behavior_set_distribution(memc
, MEMCACHED_DISTRIBUTION_CONSISTENT_KETAMA_SPY
) == MEMCACHED_SUCCESS
);
2963 memcached_server_st
*server_pool
;
2964 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");
2965 memcached_server_push(memc
, server_pool
);
2967 // @todo this needs to be refactored to actually test something.
2970 if ((fp
= fopen("ketama_keys.txt", "w")))
2974 printf("cannot write to file ketama_keys.txt");
2975 return TEST_FAILURE
;
2978 for (int x
= 0; x
< 10000; x
++)
2981 sprintf(key
, "%d", x
);
2983 uint32_t server_idx
= memcached_generate_hash(memc
, key
, strlen(key
));
2984 char *hostname
= memc
->hosts
[server_idx
].hostname
;
2985 in_port_t port
= memc
->hosts
[server_idx
].port
;
2986 fprintf(fp
, "key %s is on host /%s:%u\n", key
, hostname
, port
);
2990 memcached_server_list_free(server_pool
);
2991 memcached_free(memc
);
2993 return TEST_SUCCESS
;
2997 static test_return_t
result_static(memcached_st
*memc
)
2999 memcached_result_st result
;
3000 memcached_result_st
*result_ptr
;
3002 result_ptr
= memcached_result_create(memc
, &result
);
3003 test_truth(result
.options
.is_allocated
== false);
3004 test_truth(memcached_is_initialized(&result
) == true);
3005 test_truth(result_ptr
);
3006 test_truth(result_ptr
== &result
);
3008 memcached_result_free(&result
);
3010 test_truth(result
.options
.is_allocated
== false);
3011 test_truth(memcached_is_initialized(&result
) == false);
3013 return TEST_SUCCESS
;
3016 static test_return_t
result_alloc(memcached_st
*memc
)
3018 memcached_result_st
*result_ptr
;
3020 result_ptr
= memcached_result_create(memc
, NULL
);
3021 test_truth(result_ptr
);
3022 test_truth(result_ptr
->options
.is_allocated
== true);
3023 test_truth(memcached_is_initialized(result_ptr
) == true);
3024 memcached_result_free(result_ptr
);
3026 return TEST_SUCCESS
;
3029 static test_return_t
string_static_null(memcached_st
*memc
)
3031 memcached_string_st string
;
3032 memcached_string_st
*string_ptr
;
3034 string_ptr
= memcached_string_create(memc
, &string
, 0);
3035 test_truth(string
.options
.is_initialized
== true);
3036 test_truth(string_ptr
);
3038 /* The following two better be the same! */
3039 test_truth(memcached_is_allocated(string_ptr
) == false);
3040 test_truth(memcached_is_allocated(&string
) == false);
3041 test_truth(&string
== string_ptr
);
3043 test_truth(string
.options
.is_initialized
== true);
3044 test_truth(memcached_is_initialized(&string
) == true);
3045 memcached_string_free(&string
);
3046 test_truth(memcached_is_initialized(&string
) == false);
3048 return TEST_SUCCESS
;
3051 static test_return_t
string_alloc_null(memcached_st
*memc
)
3053 memcached_string_st
*string
;
3055 string
= memcached_string_create(memc
, NULL
, 0);
3057 test_truth(memcached_is_allocated(string
) == true);
3058 test_truth(memcached_is_initialized(string
) == true);
3059 memcached_string_free(string
);
3061 return TEST_SUCCESS
;
3064 static test_return_t
string_alloc_with_size(memcached_st
*memc
)
3066 memcached_string_st
*string
;
3068 string
= memcached_string_create(memc
, NULL
, 1024);
3070 test_truth(memcached_is_allocated(string
) == true);
3071 test_truth(memcached_is_initialized(string
) == true);
3072 memcached_string_free(string
);
3074 return TEST_SUCCESS
;
3077 static test_return_t
string_alloc_with_size_toobig(memcached_st
*memc
)
3079 memcached_string_st
*string
;
3081 string
= memcached_string_create(memc
, NULL
, SIZE_MAX
);
3082 test_truth(string
== NULL
);
3084 return TEST_SUCCESS
;
3087 static test_return_t
string_alloc_append(memcached_st
*memc
)
3090 char buffer
[SMALL_STRING_LEN
];
3091 memcached_string_st
*string
;
3093 /* Ring the bell! */
3094 memset(buffer
, 6, SMALL_STRING_LEN
);
3096 string
= memcached_string_create(memc
, NULL
, 100);
3098 test_truth(memcached_is_allocated(string
) == true);
3099 test_truth(memcached_is_initialized(string
) == true);
3101 for (x
= 0; x
< 1024; x
++)
3103 memcached_return_t rc
;
3104 rc
= memcached_string_append(string
, buffer
, SMALL_STRING_LEN
);
3105 test_truth(rc
== MEMCACHED_SUCCESS
);
3107 test_truth(memcached_is_allocated(string
) == true);
3108 memcached_string_free(string
);
3110 return TEST_SUCCESS
;
3113 static test_return_t
string_alloc_append_toobig(memcached_st
*memc
)
3115 memcached_return_t rc
;
3117 char buffer
[SMALL_STRING_LEN
];
3118 memcached_string_st
*string
;
3120 /* Ring the bell! */
3121 memset(buffer
, 6, SMALL_STRING_LEN
);
3123 string
= memcached_string_create(memc
, NULL
, 100);
3125 test_truth(memcached_is_allocated(string
) == true);
3126 test_truth(memcached_is_initialized(string
) == true);
3128 for (x
= 0; x
< 1024; x
++)
3130 rc
= memcached_string_append(string
, buffer
, SMALL_STRING_LEN
);
3131 test_truth(rc
== MEMCACHED_SUCCESS
);
3133 rc
= memcached_string_append(string
, buffer
, SIZE_MAX
);
3134 test_truth(rc
== MEMCACHED_MEMORY_ALLOCATION_FAILURE
);
3135 test_truth(memcached_is_allocated(string
) == true);
3136 memcached_string_free(string
);
3138 return TEST_SUCCESS
;
3141 static test_return_t
cleanup_pairs(memcached_st
*memc
__attribute__((unused
)))
3143 pairs_free(global_pairs
);
3145 return TEST_SUCCESS
;
3148 static test_return_t
generate_pairs(memcached_st
*memc
__attribute__((unused
)))
3150 global_pairs
= pairs_generate(GLOBAL_COUNT
, 400);
3151 global_count
= GLOBAL_COUNT
;
3153 for (size_t x
= 0; x
< global_count
; x
++)
3155 global_keys
[x
]= global_pairs
[x
].key
;
3156 global_keys_length
[x
]= global_pairs
[x
].key_length
;
3159 return TEST_SUCCESS
;
3162 static test_return_t
generate_large_pairs(memcached_st
*memc
__attribute__((unused
)))
3164 global_pairs
= pairs_generate(GLOBAL2_COUNT
, MEMCACHED_MAX_BUFFER
+10);
3165 global_count
= GLOBAL2_COUNT
;
3167 for (size_t x
= 0; x
< global_count
; x
++)
3169 global_keys
[x
]= global_pairs
[x
].key
;
3170 global_keys_length
[x
]= global_pairs
[x
].key_length
;
3173 return TEST_SUCCESS
;
3176 static test_return_t
generate_data(memcached_st
*memc
)
3178 execute_set(memc
, global_pairs
, global_count
);
3180 return TEST_SUCCESS
;
3183 static test_return_t
generate_data_with_stats(memcached_st
*memc
)
3185 memcached_stat_st
*stat_p
;
3186 memcached_return_t rc
;
3187 uint32_t host_index
= 0;
3188 execute_set(memc
, global_pairs
, global_count
);
3190 //TODO: hosts used size stats
3191 stat_p
= memcached_stat(memc
, NULL
, &rc
);
3194 for (host_index
= 0; host_index
< SERVERS_TO_CREATE
; host_index
++)
3196 /* This test was changes so that "make test" would work properlly */
3198 memcached_server_instance_st
*instance
=
3199 memcached_server_instance_fetch(memc
, host_index
);
3201 printf("\nserver %u|%s|%u bytes: %llu\n", host_index
, instance
->hostname
, instance
->port
, (unsigned long long)(stat_p
+ host_index
)->bytes
);
3203 test_truth((unsigned long long)(stat_p
+ host_index
)->bytes
);
3206 memcached_stat_free(NULL
, stat_p
);
3208 return TEST_SUCCESS
;
3210 static test_return_t
generate_buffer_data(memcached_st
*memc
)
3215 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_BUFFER_REQUESTS
, latch
);
3216 generate_data(memc
);
3218 return TEST_SUCCESS
;
3221 static test_return_t
get_read_count(memcached_st
*memc
)
3223 memcached_return_t rc
;
3224 memcached_st
*memc_clone
;
3226 memc_clone
= memcached_clone(NULL
, memc
);
3227 test_truth(memc_clone
);
3229 memcached_server_add_with_weight(memc_clone
, "localhost", 6666, 0);
3233 size_t return_value_length
;
3237 for (size_t x
= count
= 0; x
< global_count
; x
++)
3239 return_value
= memcached_get(memc_clone
, global_keys
[x
], global_keys_length
[x
],
3240 &return_value_length
, &flags
, &rc
);
3241 if (rc
== MEMCACHED_SUCCESS
)
3250 memcached_free(memc_clone
);
3252 return TEST_SUCCESS
;
3255 static test_return_t
get_read(memcached_st
*memc
)
3257 memcached_return_t rc
;
3261 size_t return_value_length
;
3264 for (size_t x
= 0; x
< global_count
; x
++)
3266 return_value
= memcached_get(memc
, global_keys
[x
], global_keys_length
[x
],
3267 &return_value_length
, &flags
, &rc
);
3269 test_truth(return_value);
3270 test_truth(rc == MEMCACHED_SUCCESS);
3272 if (rc
== MEMCACHED_SUCCESS
&& return_value
)
3277 return TEST_SUCCESS
;
3280 static test_return_t
mget_read(memcached_st
*memc
)
3282 memcached_return_t rc
;
3284 rc
= memcached_mget(memc
, global_keys
, global_keys_length
, global_count
);
3285 test_truth(rc
== MEMCACHED_SUCCESS
);
3286 test_truth(fetch_all_results(memc
) == TEST_SUCCESS
);
3288 return TEST_SUCCESS
;
3291 static test_return_t
mget_read_result(memcached_st
*memc
)
3293 memcached_return_t rc
;
3295 rc
= memcached_mget(memc
, global_keys
, global_keys_length
, global_count
);
3296 test_truth(rc
== MEMCACHED_SUCCESS
);
3297 /* Turn this into a help function */
3299 memcached_result_st results_obj
;
3300 memcached_result_st
*results
;
3302 results
= memcached_result_create(memc
, &results_obj
);
3304 while ((results
= memcached_fetch_result(memc
, &results_obj
, &rc
)))
3306 test_truth(results
);
3307 test_truth(rc
== MEMCACHED_SUCCESS
);
3310 memcached_result_free(&results_obj
);
3313 return TEST_SUCCESS
;
3316 static test_return_t
mget_read_function(memcached_st
*memc
)
3318 memcached_return_t rc
;
3320 memcached_execute_fn callbacks
[1];
3322 rc
= memcached_mget(memc
, global_keys
, global_keys_length
, global_count
);
3323 test_truth(rc
== MEMCACHED_SUCCESS
);
3325 callbacks
[0]= &callback_counter
;
3327 rc
= memcached_fetch_execute(memc
, callbacks
, (void *)&counter
, 1);
3329 return TEST_SUCCESS
;
3332 static test_return_t
delete_generate(memcached_st
*memc
)
3334 for (size_t x
= 0; x
< global_count
; x
++)
3336 (void)memcached_delete(memc
, global_keys
[x
], global_keys_length
[x
], (time_t)0);
3339 return TEST_SUCCESS
;
3342 static test_return_t
delete_buffer_generate(memcached_st
*memc
)
3347 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_BUFFER_REQUESTS
, latch
);
3349 for (size_t x
= 0; x
< global_count
; x
++)
3351 (void)memcached_delete(memc
, global_keys
[x
], global_keys_length
[x
], (time_t)0);
3354 return TEST_SUCCESS
;
3357 static test_return_t
add_host_test1(memcached_st
*memc
)
3359 memcached_return_t rc
;
3360 char servername
[]= "0.example.com";
3361 memcached_server_st
*servers
;
3363 servers
= memcached_server_list_append_with_weight(NULL
, servername
, 400, 0, &rc
);
3364 test_truth(servers
);
3365 test_truth(1 == memcached_server_list_count(servers
));
3367 for (size_t x
= 2; x
< 20; x
++)
3369 char buffer
[SMALL_STRING_LEN
];
3371 snprintf(buffer
, SMALL_STRING_LEN
, "%zu.example.com", 400+x
);
3372 servers
= memcached_server_list_append_with_weight(servers
, buffer
, 401, 0,
3374 test_truth(rc
== MEMCACHED_SUCCESS
);
3375 test_truth(x
== memcached_server_list_count(servers
));
3378 rc
= memcached_server_push(memc
, servers
);
3379 test_truth(rc
== MEMCACHED_SUCCESS
);
3380 rc
= memcached_server_push(memc
, servers
);
3381 test_truth(rc
== MEMCACHED_SUCCESS
);
3383 memcached_server_list_free(servers
);
3385 return TEST_SUCCESS
;
3388 static test_return_t
pre_nonblock(memcached_st
*memc
)
3390 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NO_BLOCK
, 0);
3392 return TEST_SUCCESS
;
3395 static test_return_t
pre_cork(memcached_st
*memc
)
3397 memcached_return_t rc
;
3399 rc
= memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_CORK
, set
);
3401 if (rc
== MEMCACHED_SUCCESS
)
3402 return TEST_SUCCESS
;
3404 return TEST_SKIPPED
;
3407 static test_return_t
pre_cork_and_nonblock(memcached_st
*memc
)
3413 if (rc
!= TEST_SUCCESS
)
3416 return pre_nonblock(memc
);
3419 static test_return_t
pre_nonblock_binary(memcached_st
*memc
)
3421 memcached_return_t rc
= MEMCACHED_FAILURE
;
3422 memcached_st
*memc_clone
;
3423 memcached_server_instance_st
*instance
;
3425 memc_clone
= memcached_clone(NULL
, memc
);
3426 test_truth(memc_clone
);
3427 // The memcached_version needs to be done on a clone, because the server
3428 // will not toggle protocol on an connection.
3429 memcached_version(memc_clone
);
3431 instance
= memcached_server_instance_fetch(memc_clone
, 0);
3433 if (instance
->major_version
>= 1 && instance
->minor_version
> 2)
3435 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NO_BLOCK
, 0);
3436 rc
= memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
, 1);
3437 test_truth(rc
== MEMCACHED_SUCCESS
);
3438 test_truth(memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
) == 1);
3442 return TEST_SKIPPED
;
3445 memcached_free(memc_clone
);
3447 return rc
== MEMCACHED_SUCCESS
? TEST_SUCCESS
: TEST_SKIPPED
;
3450 static test_return_t
pre_murmur(memcached_st
*memc
)
3452 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_HASH
, (uint64_t)MEMCACHED_HASH_MURMUR
);
3454 return TEST_SUCCESS
;
3457 static test_return_t
pre_jenkins(memcached_st
*memc
)
3459 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_HASH
, (uint64_t)MEMCACHED_HASH_JENKINS
);
3461 return TEST_SUCCESS
;
3465 static test_return_t
pre_md5(memcached_st
*memc
)
3467 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_HASH
, (uint64_t)MEMCACHED_HASH_MD5
);
3469 return TEST_SUCCESS
;
3472 static test_return_t
pre_crc(memcached_st
*memc
)
3474 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_HASH
, (uint64_t)MEMCACHED_HASH_CRC
);
3476 return TEST_SUCCESS
;
3479 static test_return_t
pre_hsieh(memcached_st
*memc
)
3481 #ifdef HAVE_HSIEH_HASH
3482 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_HASH
, (uint64_t)MEMCACHED_HASH_HSIEH
);
3483 return TEST_SUCCESS
;
3486 return TEST_SKIPPED
;
3490 static test_return_t
pre_hash_fnv1_64(memcached_st
*memc
)
3492 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_HASH
, (uint64_t)MEMCACHED_HASH_MURMUR
);
3494 return TEST_SUCCESS
;
3497 static test_return_t
pre_hash_fnv1a_64(memcached_st
*memc
)
3499 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_HASH
, (uint64_t)MEMCACHED_HASH_FNV1A_64
);
3501 return TEST_SUCCESS
;
3504 static test_return_t
pre_hash_fnv1_32(memcached_st
*memc
)
3506 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_HASH
, (uint64_t)MEMCACHED_HASH_FNV1_32
);
3508 return TEST_SUCCESS
;
3511 static test_return_t
pre_hash_fnv1a_32(memcached_st
*memc
)
3513 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_HASH
, (uint64_t)MEMCACHED_HASH_FNV1A_32
);
3515 return TEST_SUCCESS
;
3518 static test_return_t
pre_behavior_ketama(memcached_st
*memc
)
3520 memcached_return_t rc
;
3523 rc
= memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_KETAMA
, 1);
3524 test_truth(rc
== MEMCACHED_SUCCESS
);
3526 value
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_KETAMA
);
3527 test_truth(value
== 1);
3529 return TEST_SUCCESS
;
3532 static test_return_t
pre_behavior_ketama_weighted(memcached_st
*memc
)
3534 memcached_return_t rc
;
3537 rc
= memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_KETAMA_WEIGHTED
, 1);
3538 test_truth(rc
== MEMCACHED_SUCCESS
);
3540 value
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_KETAMA_WEIGHTED
);
3541 test_truth(value
== 1);
3543 rc
= memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_KETAMA_HASH
, MEMCACHED_HASH_MD5
);
3544 test_truth(rc
== MEMCACHED_SUCCESS
);
3546 value
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_KETAMA_HASH
);
3547 test_truth(value
== MEMCACHED_HASH_MD5
);
3549 return TEST_SUCCESS
;
3553 @note This should be testing to see if the server really supports the binary protocol.
3555 static test_return_t
pre_binary(memcached_st
*memc
)
3557 memcached_return_t rc
= MEMCACHED_FAILURE
;
3558 memcached_st
*memc_clone
;
3559 memcached_server_instance_st
*instance
;
3561 memc_clone
= memcached_clone(NULL
, memc
);
3562 test_truth(memc_clone
);
3563 // The memcached_version needs to be done on a clone, because the server
3564 // will not toggle protocol on an connection.
3565 memcached_version(memc_clone
);
3567 instance
= memcached_server_instance_fetch(memc_clone
, 0);
3569 if (instance
->major_version
>= 1 && instance
->minor_version
> 2)
3571 rc
= memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
, 1);
3572 test_truth(rc
== MEMCACHED_SUCCESS
);
3573 test_truth(memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
) == 1);
3576 memcached_free(memc_clone
);
3578 return rc
== MEMCACHED_SUCCESS
? TEST_SUCCESS
: TEST_SKIPPED
;
3582 static test_return_t
pre_replication(memcached_st
*memc
)
3584 test_return_t test_rc
;
3585 test_rc
= pre_binary(memc
);
3587 if (test_rc
!= TEST_SUCCESS
)
3591 * Make sure that we store the item on all servers
3592 * (master + replicas == number of servers)
3594 memcached_return_t rc
;
3595 rc
= memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NUMBER_OF_REPLICAS
,
3596 memcached_server_count(memc
) - 1);
3597 test_truth(rc
== MEMCACHED_SUCCESS
);
3598 test_truth(memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_NUMBER_OF_REPLICAS
) == memcached_server_count(memc
) - 1);
3600 return rc
== MEMCACHED_SUCCESS
? TEST_SUCCESS
: TEST_SKIPPED
;
3604 static test_return_t
pre_replication_noblock(memcached_st
*memc
)
3608 rc
= pre_replication(memc
);
3609 if (rc
!= TEST_SUCCESS
)
3612 rc
= pre_nonblock(memc
);
3618 static void my_free(memcached_st
*ptr
__attribute__((unused
)), void *mem
)
3620 #ifdef HARD_MALLOC_TESTS
3621 void *real_ptr
= (mem
== NULL
) ? mem
: (void*)((caddr_t
)mem
- 8);
3629 static void *my_malloc(memcached_st
*ptr
__attribute__((unused
)), const size_t size
)
3631 #ifdef HARD_MALLOC_TESTS
3632 void *ret
= malloc(size
+ 8);
3635 ret
= (void*)((caddr_t
)ret
+ 8);
3638 void *ret
= malloc(size
);
3643 memset(ret
, 0xff, size
);
3650 static void *my_realloc(memcached_st
*ptr
__attribute__((unused
)), void *mem
, const size_t size
)
3652 #ifdef HARD_MALLOC_TESTS
3653 void *real_ptr
= (mem
== NULL
) ? NULL
: (void*)((caddr_t
)mem
- 8);
3654 void *nmem
= realloc(real_ptr
, size
+ 8);
3659 ret
= (void*)((caddr_t
)nmem
+ 8);
3664 return realloc(mem
, size
);
3669 static void *my_calloc(memcached_st
*ptr
__attribute__((unused
)), size_t nelem
, const size_t size
)
3671 #ifdef HARD_MALLOC_TESTS
3672 void *mem
= my_malloc(ptr
, nelem
* size
);
3675 memset(mem
, 0, nelem
* size
);
3680 return calloc(nelem
, size
);
3685 static test_return_t
set_prefix(memcached_st
*memc
)
3687 memcached_return_t rc
;
3688 const char *key
= "mine";
3691 /* Make sure be default none exists */
3692 value
= memcached_callback_get(memc
, MEMCACHED_CALLBACK_PREFIX_KEY
, &rc
);
3693 test_truth(rc
== MEMCACHED_FAILURE
);
3695 /* Test a clean set */
3696 rc
= memcached_callback_set(memc
, MEMCACHED_CALLBACK_PREFIX_KEY
, (void *)key
);
3697 test_truth(rc
== MEMCACHED_SUCCESS
);
3699 value
= memcached_callback_get(memc
, MEMCACHED_CALLBACK_PREFIX_KEY
, &rc
);
3700 test_truth(memcmp(value
, key
, 4) == 0);
3701 test_truth(rc
== MEMCACHED_SUCCESS
);
3703 /* Test that we can turn it off */
3704 rc
= memcached_callback_set(memc
, MEMCACHED_CALLBACK_PREFIX_KEY
, NULL
);
3705 test_truth(rc
== MEMCACHED_SUCCESS
);
3707 value
= memcached_callback_get(memc
, MEMCACHED_CALLBACK_PREFIX_KEY
, &rc
);
3708 test_truth(rc
== MEMCACHED_FAILURE
);
3710 /* Now setup for main test */
3711 rc
= memcached_callback_set(memc
, MEMCACHED_CALLBACK_PREFIX_KEY
, (void *)key
);
3712 test_truth(rc
== MEMCACHED_SUCCESS
);
3714 value
= memcached_callback_get(memc
, MEMCACHED_CALLBACK_PREFIX_KEY
, &rc
);
3715 test_truth(rc
== MEMCACHED_SUCCESS
);
3716 test_truth(memcmp(value
, key
, 4) == 0);
3718 /* Set to Zero, and then Set to something too large */
3721 memset(long_key
, 0, 255);
3723 rc
= memcached_callback_set(memc
, MEMCACHED_CALLBACK_PREFIX_KEY
, NULL
);
3724 test_truth(rc
== MEMCACHED_SUCCESS
);
3726 value
= memcached_callback_get(memc
, MEMCACHED_CALLBACK_PREFIX_KEY
, &rc
);
3727 test_truth(rc
== MEMCACHED_FAILURE
);
3728 test_truth(value
== NULL
);
3730 /* Test a long key for failure */
3731 /* TODO, extend test to determine based on setting, what result should be */
3732 strcpy(long_key
, "Thisismorethentheallottednumberofcharacters");
3733 rc
= memcached_callback_set(memc
, MEMCACHED_CALLBACK_PREFIX_KEY
, long_key
);
3734 //test_truth(rc == MEMCACHED_BAD_KEY_PROVIDED);
3735 test_truth(rc
== MEMCACHED_SUCCESS
);
3737 /* Now test a key with spaces (which will fail from long key, since bad key is not set) */
3738 strcpy(long_key
, "This is more then the allotted number of characters");
3739 rc
= memcached_callback_set(memc
, MEMCACHED_CALLBACK_PREFIX_KEY
, long_key
);
3740 test_truth(rc
== MEMCACHED_BAD_KEY_PROVIDED
);
3742 /* Test for a bad prefix, but with a short key */
3743 rc
= memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_VERIFY_KEY
, 1);
3744 test_truth(rc
== MEMCACHED_SUCCESS
);
3746 strcpy(long_key
, "dog cat");
3747 rc
= memcached_callback_set(memc
, MEMCACHED_CALLBACK_PREFIX_KEY
, long_key
);
3748 test_truth(rc
== MEMCACHED_BAD_KEY_PROVIDED
);
3751 return TEST_SUCCESS
;
3755 #ifdef MEMCACHED_ENABLE_DEPRECATED
3756 static test_return_t
deprecated_set_memory_alloc(memcached_st
*memc
)
3758 void *test_ptr
= NULL
;
3761 memcached_malloc_fn malloc_cb
=
3762 (memcached_malloc_fn
)my_malloc
;
3763 cb_ptr
= *(void **)&malloc_cb
;
3764 memcached_return_t rc
;
3766 rc
= memcached_callback_set(memc
, MEMCACHED_CALLBACK_MALLOC_FUNCTION
, cb_ptr
);
3767 test_truth(rc
== MEMCACHED_SUCCESS
);
3768 test_ptr
= memcached_callback_get(memc
, MEMCACHED_CALLBACK_MALLOC_FUNCTION
, &rc
);
3769 test_truth(rc
== MEMCACHED_SUCCESS
);
3770 test_truth(test_ptr
== cb_ptr
);
3774 memcached_realloc_fn realloc_cb
=
3775 (memcached_realloc_fn
)my_realloc
;
3776 cb_ptr
= *(void **)&realloc_cb
;
3777 memcached_return_t rc
;
3779 rc
= memcached_callback_set(memc
, MEMCACHED_CALLBACK_REALLOC_FUNCTION
, cb_ptr
);
3780 test_truth(rc
== MEMCACHED_SUCCESS
);
3781 test_ptr
= memcached_callback_get(memc
, MEMCACHED_CALLBACK_REALLOC_FUNCTION
, &rc
);
3782 test_truth(rc
== MEMCACHED_SUCCESS
);
3783 test_truth(test_ptr
== cb_ptr
);
3787 memcached_free_fn free_cb
=
3788 (memcached_free_fn
)my_free
;
3789 cb_ptr
= *(void **)&free_cb
;
3790 memcached_return_t rc
;
3792 rc
= memcached_callback_set(memc
, MEMCACHED_CALLBACK_FREE_FUNCTION
, cb_ptr
);
3793 test_truth(rc
== MEMCACHED_SUCCESS
);
3794 test_ptr
= memcached_callback_get(memc
, MEMCACHED_CALLBACK_FREE_FUNCTION
, &rc
);
3795 test_truth(rc
== MEMCACHED_SUCCESS
);
3796 test_truth(test_ptr
== cb_ptr
);
3799 return TEST_SUCCESS
;
3804 static test_return_t
set_memory_alloc(memcached_st
*memc
)
3806 memcached_return_t rc
;
3807 rc
= memcached_set_memory_allocators(memc
, NULL
, my_free
,
3808 my_realloc
, my_calloc
);
3809 test_truth(rc
== MEMCACHED_FAILURE
);
3811 rc
= memcached_set_memory_allocators(memc
, my_malloc
, my_free
,
3812 my_realloc
, my_calloc
);
3814 memcached_malloc_fn mem_malloc
;
3815 memcached_free_fn mem_free
;
3816 memcached_realloc_fn mem_realloc
;
3817 memcached_calloc_fn mem_calloc
;
3818 memcached_get_memory_allocators(memc
, &mem_malloc
, &mem_free
,
3819 &mem_realloc
, &mem_calloc
);
3821 test_truth(mem_malloc
== my_malloc
);
3822 test_truth(mem_realloc
== my_realloc
);
3823 test_truth(mem_calloc
== my_calloc
);
3824 test_truth(mem_free
== my_free
);
3826 return TEST_SUCCESS
;
3829 static test_return_t
enable_consistent_crc(memcached_st
*memc
)
3832 memcached_server_distribution_t value
= MEMCACHED_DISTRIBUTION_CONSISTENT
;
3833 memcached_hash_t hash
;
3834 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_DISTRIBUTION
, value
);
3835 if ((rc
= pre_crc(memc
)) != TEST_SUCCESS
)
3838 value
= (memcached_server_distribution_t
)memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_DISTRIBUTION
);
3839 test_truth(value
== MEMCACHED_DISTRIBUTION_CONSISTENT
);
3841 hash
= (memcached_hash_t
)memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_HASH
);
3843 if (hash
!= MEMCACHED_HASH_CRC
)
3844 return TEST_SKIPPED
;
3846 return TEST_SUCCESS
;
3849 static test_return_t
enable_consistent_hsieh(memcached_st
*memc
)
3852 memcached_server_distribution_t value
= MEMCACHED_DISTRIBUTION_CONSISTENT
;
3853 memcached_hash_t hash
;
3854 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_DISTRIBUTION
, value
);
3855 if ((rc
= pre_hsieh(memc
)) != TEST_SUCCESS
)
3858 value
= (memcached_server_distribution_t
)memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_DISTRIBUTION
);
3859 test_truth(value
== MEMCACHED_DISTRIBUTION_CONSISTENT
);
3861 hash
= (memcached_hash_t
)memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_HASH
);
3863 if (hash
!= MEMCACHED_HASH_HSIEH
)
3864 return TEST_SKIPPED
;
3867 return TEST_SUCCESS
;
3870 static test_return_t
enable_cas(memcached_st
*memc
)
3872 unsigned int set
= 1;
3874 memcached_server_instance_st
*instance
=
3875 memcached_server_instance_fetch(memc
, 0);
3877 memcached_version(memc
);
3879 if ((instance
->major_version
>= 1 && (instance
->minor_version
== 2 && instance
->micro_version
>= 4))
3880 || instance
->minor_version
> 2)
3882 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_SUPPORT_CAS
, set
);
3884 return TEST_SUCCESS
;
3887 return TEST_SKIPPED
;
3890 static test_return_t
check_for_1_2_3(memcached_st
*memc
)
3892 memcached_version(memc
);
3893 memcached_server_instance_st
*instance
=
3894 memcached_server_instance_fetch(memc
, 0);
3896 if ((instance
->major_version
>= 1 && (instance
->minor_version
== 2 && instance
->micro_version
>= 4))
3897 || instance
->minor_version
> 2)
3898 return TEST_SUCCESS
;
3900 return TEST_SKIPPED
;
3903 static test_return_t
pre_unix_socket(memcached_st
*memc
)
3905 memcached_return_t rc
;
3908 memcached_servers_reset(memc
);
3910 if (stat("/tmp/memcached.socket", &buf
))
3911 return TEST_SKIPPED
;
3913 rc
= memcached_server_add_unix_socket_with_weight(memc
, "/tmp/memcached.socket", 0);
3915 return ( rc
== MEMCACHED_SUCCESS
? TEST_SUCCESS
: TEST_FAILURE
);
3918 static test_return_t
pre_nodelay(memcached_st
*memc
)
3920 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NO_BLOCK
, 0);
3921 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_TCP_NODELAY
, 0);
3923 return TEST_SUCCESS
;
3926 static test_return_t
pre_settimer(memcached_st
*memc
)
3928 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_SND_TIMEOUT
, 1000);
3929 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_RCV_TIMEOUT
, 1000);
3931 return TEST_SUCCESS
;
3934 static test_return_t
poll_timeout(memcached_st
*memc
)
3940 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_POLL_TIMEOUT
, timeout
);
3942 timeout
= (size_t)memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_POLL_TIMEOUT
);
3944 test_truth(timeout
== 100);
3946 return TEST_SUCCESS
;
3949 static test_return_t
noreply_test(memcached_st
*memc
)
3951 memcached_return_t ret
;
3952 ret
= memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NOREPLY
, 1);
3953 test_truth(ret
== MEMCACHED_SUCCESS
);
3954 ret
= memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_BUFFER_REQUESTS
, 1);
3955 test_truth(ret
== MEMCACHED_SUCCESS
);
3956 ret
= memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_SUPPORT_CAS
, 1);
3957 test_truth(ret
== MEMCACHED_SUCCESS
);
3958 test_truth(memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_NOREPLY
) == 1);
3959 test_truth(memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_BUFFER_REQUESTS
) == 1);
3960 test_truth(memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_SUPPORT_CAS
) == 1);
3962 for (int count
=0; count
< 5; ++count
)
3964 for (size_t x
= 0; x
< 100; ++x
)
3967 size_t len
= (size_t)sprintf(key
, "%zu", x
);
3971 ret
= memcached_add(memc
, key
, len
, key
, len
, 0, 0);
3974 ret
= memcached_replace(memc
, key
, len
, key
, len
, 0, 0);
3977 ret
= memcached_set(memc
, key
, len
, key
, len
, 0, 0);
3980 ret
= memcached_append(memc
, key
, len
, key
, len
, 0, 0);
3983 ret
= memcached_prepend(memc
, key
, len
, key
, len
, 0, 0);
3989 test_truth(ret
== MEMCACHED_SUCCESS
|| ret
== MEMCACHED_BUFFERED
);
3993 ** NOTE: Don't ever do this in your code! this is not a supported use of the
3994 ** API and is _ONLY_ done this way to verify that the library works the
3995 ** way it is supposed to do!!!!
3998 for (uint32_t x
= 0; x
< memcached_server_count(memc
); ++x
)
4000 memcached_server_instance_st
*instance
=
4001 memcached_server_instance_fetch(memc
, x
);
4002 no_msg
+=(int)(instance
->cursor_active
);
4005 test_truth(no_msg
== 0);
4006 test_truth(memcached_flush_buffers(memc
) == MEMCACHED_SUCCESS
);
4009 ** Now validate that all items was set properly!
4011 for (size_t x
= 0; x
< 100; ++x
)
4015 size_t len
= (size_t)sprintf(key
, "%zu", x
);
4018 char* value
=memcached_get(memc
, key
, strlen(key
),
4019 &length
, &flags
, &ret
);
4020 test_truth(ret
== MEMCACHED_SUCCESS
&& value
!= NULL
);
4023 case 0: /* FALLTHROUGH */
4024 case 1: /* FALLTHROUGH */
4026 test_truth(strncmp(value
, key
, len
) == 0);
4027 test_truth(len
== length
);
4030 test_truth(length
== len
* 2);
4033 test_truth(length
== len
* 3);
4043 /* Try setting an illegal cas value (should not return an error to
4044 * the caller (because we don't expect a return message from the server)
4046 const char* keys
[]= {"0"};
4047 size_t lengths
[]= {1};
4050 memcached_result_st results_obj
;
4051 memcached_result_st
*results
;
4052 ret
= memcached_mget(memc
, keys
, lengths
, 1);
4053 test_truth(ret
== MEMCACHED_SUCCESS
);
4055 results
= memcached_result_create(memc
, &results_obj
);
4056 test_truth(results
);
4057 results
= memcached_fetch_result(memc
, &results_obj
, &ret
);
4058 test_truth(results
);
4059 test_truth(ret
== MEMCACHED_SUCCESS
);
4060 uint64_t cas
= memcached_result_cas(results
);
4061 memcached_result_free(&results_obj
);
4063 ret
= memcached_cas(memc
, keys
[0], lengths
[0], keys
[0], lengths
[0], 0, 0, cas
);
4064 test_truth(ret
== MEMCACHED_SUCCESS
);
4067 * The item will have a new cas value, so try to set it again with the old
4068 * value. This should fail!
4070 ret
= memcached_cas(memc
, keys
[0], lengths
[0], keys
[0], lengths
[0], 0, 0, cas
);
4071 test_truth(ret
== MEMCACHED_SUCCESS
);
4072 test_truth(memcached_flush_buffers(memc
) == MEMCACHED_SUCCESS
);
4073 char* value
=memcached_get(memc
, keys
[0], lengths
[0], &length
, &flags
, &ret
);
4074 test_truth(ret
== MEMCACHED_SUCCESS
&& value
!= NULL
);
4077 return TEST_SUCCESS
;
4080 static test_return_t
analyzer_test(memcached_st
*memc
)
4082 memcached_return_t rc
;
4083 memcached_stat_st
*memc_stat
;
4084 memcached_analysis_st
*report
;
4086 memc_stat
= memcached_stat(memc
, NULL
, &rc
);
4087 test_truth(rc
== MEMCACHED_SUCCESS
);
4088 test_truth(memc_stat
);
4090 report
= memcached_analyze(memc
, memc_stat
, &rc
);
4091 test_truth(rc
== MEMCACHED_SUCCESS
);
4095 memcached_stat_free(NULL
, memc_stat
);
4097 return TEST_SUCCESS
;
4100 /* Count the objects */
4101 static memcached_return_t
callback_dump_counter(memcached_st
*ptr
__attribute__((unused
)),
4102 const char *key
__attribute__((unused
)),
4103 size_t key_length
__attribute__((unused
)),
4106 size_t *counter
= (size_t *)context
;
4108 *counter
= *counter
+ 1;
4110 return MEMCACHED_SUCCESS
;
4113 static test_return_t
dump_test(memcached_st
*memc
)
4115 memcached_return_t rc
;
4117 memcached_dump_fn callbacks
[1];
4118 test_return_t main_rc
;
4120 callbacks
[0]= &callback_dump_counter
;
4122 /* No support for Binary protocol yet */
4123 if (memc
->flags
.binary_protocol
)
4124 return TEST_SUCCESS
;
4126 main_rc
= set_test3(memc
);
4128 test_truth (main_rc
== TEST_SUCCESS
);
4130 rc
= memcached_dump(memc
, callbacks
, (void *)&counter
, 1);
4131 test_truth(rc
== MEMCACHED_SUCCESS
);
4133 /* We may have more then 32 if our previous flush has not completed */
4134 test_truth(counter
>= 32);
4136 return TEST_SUCCESS
;
4139 #ifdef HAVE_LIBMEMCACHEDUTIL
4140 static void* connection_release(void *arg
)
4143 memcached_pool_st
* pool
;
4148 assert(memcached_pool_push(resource
->pool
, resource
->mmc
) == MEMCACHED_SUCCESS
);
4152 static test_return_t
connection_pool_test(memcached_st
*memc
)
4154 memcached_pool_st
* pool
= memcached_pool_create(memc
, 5, 10);
4155 test_truth(pool
!= NULL
);
4156 memcached_st
* mmc
[10];
4157 memcached_return_t rc
;
4159 for (size_t x
= 0; x
< 10; ++x
)
4161 mmc
[x
]= memcached_pool_pop(pool
, false, &rc
);
4162 test_truth(mmc
[x
] != NULL
);
4163 test_truth(rc
== MEMCACHED_SUCCESS
);
4166 test_truth(memcached_pool_pop(pool
, false, &rc
) == NULL
);
4167 test_truth(rc
== MEMCACHED_SUCCESS
);
4171 memcached_pool_st
* pool
;
4173 } item
= { .pool
= pool
, .mmc
= mmc
[9] };
4174 pthread_create(&tid
, NULL
, connection_release
, &item
);
4175 mmc
[9]= memcached_pool_pop(pool
, true, &rc
);
4176 test_truth(rc
== MEMCACHED_SUCCESS
);
4177 pthread_join(tid
, NULL
);
4178 test_truth(mmc
[9] == item
.mmc
);
4179 const char *key
= "key";
4180 size_t keylen
= strlen(key
);
4182 // verify that I can do ops with all connections
4183 rc
= memcached_set(mmc
[0], key
, keylen
, "0", 1, 0, 0);
4184 test_truth(rc
== MEMCACHED_SUCCESS
);
4186 for (size_t x
= 0; x
< 10; ++x
)
4188 uint64_t number_value
;
4189 rc
= memcached_increment(mmc
[x
], key
, keylen
, 1, &number_value
);
4190 test_truth(rc
== MEMCACHED_SUCCESS
);
4191 test_truth(number_value
== (x
+1));
4195 for (size_t x
= 0; x
< 10; ++x
)
4197 test_truth(memcached_pool_push(pool
, mmc
[x
]) == MEMCACHED_SUCCESS
);
4201 /* verify that I can set behaviors on the pool when I don't have all
4202 * of the connections in the pool. It should however be enabled
4203 * when I push the item into the pool
4205 mmc
[0]= memcached_pool_pop(pool
, false, &rc
);
4206 test_truth(mmc
[0] != NULL
);
4208 rc
= memcached_pool_behavior_set(pool
, MEMCACHED_BEHAVIOR_IO_MSG_WATERMARK
, 9999);
4209 test_truth(rc
== MEMCACHED_SUCCESS
);
4211 mmc
[1]= memcached_pool_pop(pool
, false, &rc
);
4212 test_truth(mmc
[1] != NULL
);
4214 test_truth(memcached_behavior_get(mmc
[1], MEMCACHED_BEHAVIOR_IO_MSG_WATERMARK
) == 9999);
4215 test_truth(memcached_pool_push(pool
, mmc
[1]) == MEMCACHED_SUCCESS
);
4216 test_truth(memcached_pool_push(pool
, mmc
[0]) == MEMCACHED_SUCCESS
);
4218 mmc
[0]= memcached_pool_pop(pool
, false, &rc
);
4219 test_truth(memcached_behavior_get(mmc
[0], MEMCACHED_BEHAVIOR_IO_MSG_WATERMARK
) == 9999);
4220 test_truth(memcached_pool_push(pool
, mmc
[0]) == MEMCACHED_SUCCESS
);
4223 test_truth(memcached_pool_destroy(pool
) == memc
);
4224 return TEST_SUCCESS
;
4228 static test_return_t
replication_set_test(memcached_st
*memc
)
4230 memcached_return_t rc
;
4231 memcached_st
*memc_clone
= memcached_clone(NULL
, memc
);
4232 memcached_behavior_set(memc_clone
, MEMCACHED_BEHAVIOR_NUMBER_OF_REPLICAS
, 0);
4234 rc
= memcached_set(memc
, "bubba", 5, "0", 1, 0, 0);
4235 test_truth(rc
== MEMCACHED_SUCCESS
);
4238 ** We are using the quiet commands to store the replicas, so we need
4239 ** to ensure that all of them are processed before we can continue.
4240 ** In the test we go directly from storing the object to trying to
4241 ** receive the object from all of the different servers, so we
4242 ** could end up in a race condition (the memcached server hasn't yet
4243 ** processed the quiet command from the replication set when it process
4244 ** the request from the other client (created by the clone)). As a
4245 ** workaround for that we call memcached_quit to send the quit command
4246 ** to the server and wait for the response ;-) If you use the test code
4247 ** as an example for your own code, please note that you shouldn't need
4250 memcached_quit(memc
);
4253 ** "bubba" should now be stored on all of our servers. We don't have an
4254 ** easy to use API to address each individual server, so I'll just iterate
4255 ** through a bunch of "master keys" and I should most likely hit all of the
4258 for (int x
= 'a'; x
<= 'z'; ++x
)
4260 char key
[2]= { [0]= (char)x
};
4263 char *val
= memcached_get_by_key(memc_clone
, key
, 1, "bubba", 5,
4265 test_truth(rc
== MEMCACHED_SUCCESS
);
4266 test_truth(val
!= NULL
);
4270 memcached_free(memc_clone
);
4272 return TEST_SUCCESS
;
4275 static test_return_t
replication_get_test(memcached_st
*memc
)
4277 memcached_return_t rc
;
4280 * Don't do the following in your code. I am abusing the internal details
4281 * within the library, and this is not a supported interface.
4282 * This is to verify correct behavior in the library
4284 for (uint32_t host
= 0; host
< memcached_server_count(memc
); ++host
)
4286 memcached_st
*memc_clone
= memcached_clone(NULL
, memc
);
4287 memcached_server_instance_st
*instance
=
4288 memcached_server_instance_fetch(memc_clone
, host
);
4292 for (int x
= 'a'; x
<= 'z'; ++x
)
4294 char key
[2]= { [0]= (char)x
};
4297 char *val
= memcached_get_by_key(memc_clone
, key
, 1, "bubba", 5,
4299 test_truth(rc
== MEMCACHED_SUCCESS
);
4300 test_truth(val
!= NULL
);
4304 memcached_free(memc_clone
);
4307 return TEST_SUCCESS
;
4310 static test_return_t
replication_mget_test(memcached_st
*memc
)
4312 memcached_return_t rc
;
4313 memcached_st
*memc_clone
= memcached_clone(NULL
, memc
);
4314 memcached_behavior_set(memc_clone
, MEMCACHED_BEHAVIOR_NUMBER_OF_REPLICAS
, 0);
4316 const char *keys
[]= { "bubba", "key1", "key2", "key3" };
4317 size_t len
[]= { 5, 4, 4, 4 };
4319 for (size_t x
= 0; x
< 4; ++x
)
4321 rc
= memcached_set(memc
, keys
[x
], len
[x
], "0", 1, 0, 0);
4322 test_truth(rc
== MEMCACHED_SUCCESS
);
4326 ** We are using the quiet commands to store the replicas, so we need
4327 ** to ensure that all of them are processed before we can continue.
4328 ** In the test we go directly from storing the object to trying to
4329 ** receive the object from all of the different servers, so we
4330 ** could end up in a race condition (the memcached server hasn't yet
4331 ** processed the quiet command from the replication set when it process
4332 ** the request from the other client (created by the clone)). As a
4333 ** workaround for that we call memcached_quit to send the quit command
4334 ** to the server and wait for the response ;-) If you use the test code
4335 ** as an example for your own code, please note that you shouldn't need
4338 memcached_quit(memc
);
4341 * Don't do the following in your code. I am abusing the internal details
4342 * within the library, and this is not a supported interface.
4343 * This is to verify correct behavior in the library
4345 memcached_result_st result_obj
;
4346 for (uint32_t host
= 0; host
< memc_clone
->number_of_hosts
; host
++)
4348 memcached_st
*new_clone
= memcached_clone(NULL
, memc
);
4349 memcached_server_instance_st
*instance
=
4350 memcached_server_instance_fetch(new_clone
, host
);
4353 for (int x
= 'a'; x
<= 'z'; ++x
)
4355 char key
[2]= { [0]= (char)x
, [1]= 0 };
4357 rc
= memcached_mget_by_key(new_clone
, key
, 1, keys
, len
, 4);
4358 test_truth(rc
== MEMCACHED_SUCCESS
);
4360 memcached_result_st
*results
= memcached_result_create(new_clone
, &result_obj
);
4361 test_truth(results
);
4364 while ((results
= memcached_fetch_result(new_clone
, &result_obj
, &rc
)) != NULL
)
4368 test_truth(hits
== 4);
4369 memcached_result_free(&result_obj
);
4372 memcached_free(new_clone
);
4375 memcached_free(memc_clone
);
4377 return TEST_SUCCESS
;
4380 static test_return_t
replication_randomize_mget_test(memcached_st
*memc
)
4382 memcached_result_st result_obj
;
4383 memcached_return_t rc
;
4384 memcached_st
*memc_clone
= memcached_clone(NULL
, memc
);
4385 memcached_behavior_set(memc_clone
, MEMCACHED_BEHAVIOR_NUMBER_OF_REPLICAS
, 3);
4386 memcached_behavior_set(memc_clone
, MEMCACHED_BEHAVIOR_RANDOMIZE_REPLICA_READ
, 1);
4388 const char *keys
[]= { "key1", "key2", "key3", "key4", "key5", "key6", "key7" };
4389 size_t len
[]= { 4, 4, 4, 4, 4, 4, 4 };
4391 for (int x
=0; x
< 7; ++x
)
4393 rc
= memcached_set(memc
, keys
[x
], len
[x
], "1", 1, 0, 0);
4394 test_truth(rc
== MEMCACHED_SUCCESS
);
4397 memcached_quit(memc
);
4399 for (size_t x
= 0; x
< 7; ++x
)
4401 const char key
[2]= { [0]= (const char)x
};
4403 rc
= memcached_mget_by_key(memc_clone
, key
, 1, keys
, len
, 7);
4404 test_truth(rc
== MEMCACHED_SUCCESS
);
4406 memcached_result_st
*results
= memcached_result_create(memc_clone
, &result_obj
);
4407 test_truth(results
);
4410 while ((results
= memcached_fetch_result(memc_clone
, &result_obj
, &rc
)) != NULL
)
4414 test_truth(hits
== 7);
4415 memcached_result_free(&result_obj
);
4417 memcached_free(memc_clone
);
4418 return TEST_SUCCESS
;
4421 static test_return_t
replication_delete_test(memcached_st
*memc
)
4423 memcached_return_t rc
;
4424 memcached_st
*memc_clone
= memcached_clone(NULL
, memc
);
4425 /* Delete the items from all of the servers except 1 */
4426 uint64_t repl
= memcached_behavior_get(memc
,
4427 MEMCACHED_BEHAVIOR_NUMBER_OF_REPLICAS
);
4428 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NUMBER_OF_REPLICAS
, --repl
);
4430 const char *keys
[]= { "bubba", "key1", "key2", "key3" };
4431 size_t len
[]= { 5, 4, 4, 4 };
4433 for (size_t x
= 0; x
< 4; ++x
)
4435 rc
= memcached_delete_by_key(memc
, keys
[0], len
[0], keys
[x
], len
[x
], 0);
4436 test_truth(rc
== MEMCACHED_SUCCESS
);
4440 * Don't do the following in your code. I am abusing the internal details
4441 * within the library, and this is not a supported interface.
4442 * This is to verify correct behavior in the library
4444 uint32_t hash
= memcached_generate_hash(memc
, keys
[0], len
[0]);
4445 for (uint32_t x
= 0; x
< (repl
+ 1); ++x
)
4447 memcached_server_instance_st
*instance
=
4448 memcached_server_instance_fetch(memc_clone
, x
);
4451 if (++hash
== memc_clone
->number_of_hosts
)
4455 memcached_result_st result_obj
;
4456 for (uint32_t host
= 0; host
< memc_clone
->number_of_hosts
; ++host
)
4458 for (size_t x
= 'a'; x
<= 'z'; ++x
)
4460 const char key
[2]= { [0]= (const char)x
};
4462 rc
= memcached_mget_by_key(memc_clone
, key
, 1, keys
, len
, 4);
4463 test_truth(rc
== MEMCACHED_SUCCESS
);
4465 memcached_result_st
*results
= memcached_result_create(memc_clone
, &result_obj
);
4466 test_truth(results
);
4469 while ((results
= memcached_fetch_result(memc_clone
, &result_obj
, &rc
)) != NULL
)
4473 test_truth(hits
== 4);
4474 memcached_result_free(&result_obj
);
4477 memcached_free(memc_clone
);
4479 return TEST_SUCCESS
;
4482 static void increment_request_id(uint16_t *id
)
4485 if ((*id
& UDP_REQUEST_ID_THREAD_MASK
) != 0)
4489 static uint16_t *get_udp_request_ids(memcached_st
*memc
)
4491 uint16_t *ids
= malloc(sizeof(uint16_t) * memcached_server_count(memc
));
4492 assert(ids
!= NULL
);
4494 for (uint32_t x
= 0; x
< memcached_server_count(memc
); x
++)
4496 memcached_server_instance_st
*instance
=
4497 memcached_server_instance_fetch(memc
, x
);
4499 ids
[x
]= get_udp_datagram_request_id((struct udp_datagram_header_st
*) instance
->write_buffer
);
4505 static test_return_t
post_udp_op_check(memcached_st
*memc
, uint16_t *expected_req_ids
)
4507 memcached_server_st
*cur_server
= memcached_server_list(memc
);
4508 uint16_t *cur_req_ids
= get_udp_request_ids(memc
);
4510 for (size_t x
= 0; x
< memcached_server_count(memc
); x
++)
4512 test_truth(cur_server
[x
].cursor_active
== 0);
4513 test_truth(cur_req_ids
[x
] == expected_req_ids
[x
]);
4515 free(expected_req_ids
);
4518 return TEST_SUCCESS
;
4522 ** There is a little bit of a hack here, instead of removing
4523 ** the servers, I just set num host to 0 and them add then new udp servers
4525 static test_return_t
init_udp(memcached_st
*memc
)
4527 memcached_version(memc
);
4528 memcached_server_instance_st
*instance
=
4529 memcached_server_instance_fetch(memc
, 0);
4531 /* For the time being, only support udp test for >= 1.2.6 && < 1.3 */
4532 if (instance
->major_version
!= 1 || instance
->minor_version
!= 2
4533 || instance
->micro_version
< 6)
4534 return TEST_SKIPPED
;
4536 uint32_t num_hosts
= memcached_server_count(memc
);
4537 memcached_server_st servers
[num_hosts
];
4538 memcpy(servers
, memcached_server_list(memc
), sizeof(memcached_server_st
) * num_hosts
);
4539 for (uint32_t x
= 0; x
< num_hosts
; x
++)
4541 memcached_server_instance_st
*set_instance
=
4542 memcached_server_instance_fetch(memc
, x
);
4544 memcached_server_free(set_instance
);
4547 memc
->number_of_hosts
= 0;
4548 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_USE_UDP
, 1);
4549 for (uint32_t x
= 0; x
< num_hosts
; x
++)
4551 memcached_server_instance_st
*set_instance
=
4552 memcached_server_instance_fetch(memc
, x
);
4554 test_truth(memcached_server_add_udp(memc
, servers
[x
].hostname
, servers
[x
].port
) == MEMCACHED_SUCCESS
);
4555 test_truth(set_instance
->write_buffer_offset
== UDP_DATAGRAM_HEADER_LENGTH
);
4558 return TEST_SUCCESS
;
4561 static test_return_t
binary_init_udp(memcached_st
*memc
)
4563 test_return_t test_rc
;
4564 test_rc
= pre_binary(memc
);
4566 if (test_rc
!= TEST_SUCCESS
)
4569 return init_udp(memc
);
4572 /* Make sure that I cant add a tcp server to a udp client */
4573 static test_return_t
add_tcp_server_udp_client_test(memcached_st
*memc
)
4577 memcached_server_st server
;
4578 memcached_server_instance_st
*instance
=
4579 memcached_server_instance_fetch(memc
, 0);
4580 memcached_server_clone(&server
, &memc
->hosts
[0]);
4581 test_truth(memcached_server_remove(&(memc
->hosts
[0])) == MEMCACHED_SUCCESS
);
4582 test_truth(memcached_server_add(memc
, server
.hostname
, server
.port
) == MEMCACHED_INVALID_HOST_PROTOCOL
);
4584 return TEST_SUCCESS
;
4587 /* Make sure that I cant add a udp server to a tcp client */
4588 static test_return_t
add_udp_server_tcp_client_test(memcached_st
*memc
)
4592 memcached_server_st server
;
4593 memcached_server_instance_st
*instance
=
4594 memcached_server_instance_fetch(memc
, 0);
4595 memcached_server_clone(&server
, &memc
->hosts
[0]);
4596 test_truth(memcached_server_remove(&(memc
->hosts
[0])) == MEMCACHED_SUCCESS
);
4598 memcached_st tcp_client
;
4599 memcached_create(&tcp_client
);
4600 test_truth(memcached_server_add_udp(&tcp_client
, server
.hostname
, server
.port
) == MEMCACHED_INVALID_HOST_PROTOCOL
);
4603 return TEST_SUCCESS
;
4606 static test_return_t
set_udp_behavior_test(memcached_st
*memc
)
4609 memcached_quit(memc
);
4610 memc
->number_of_hosts
= 0;
4611 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_DISTRIBUTION
, memc
->distribution
);
4612 test_truth(memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_USE_UDP
, 1) == MEMCACHED_SUCCESS
);
4613 test_truth(memc
->flags
.use_udp
);
4614 test_truth(memc
->flags
.no_reply
);
4616 test_truth(memcached_server_count(memc
) == 0);
4618 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_USE_UDP
,0);
4619 test_truth(! (memc
->flags
.use_udp
));
4620 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NOREPLY
,0);
4621 test_truth(! (memc
->flags
.no_reply
));
4623 return TEST_SUCCESS
;
4626 static test_return_t
udp_set_test(memcached_st
*memc
)
4628 unsigned int num_iters
= 1025; //request id rolls over at 1024
4630 for (size_t x
= 0; x
< num_iters
;x
++)
4632 memcached_return_t rc
;
4633 const char *key
= "foo";
4634 const char *value
= "when we sanitize";
4635 uint16_t *expected_ids
= get_udp_request_ids(memc
);
4636 unsigned int server_key
= memcached_generate_hash(memc
, key
, strlen(key
));
4637 memcached_server_instance_st
*instance
=
4638 memcached_server_instance_fetch(memc
, server_key
);
4639 size_t init_offset
= instance
->write_buffer_offset
;
4641 rc
= memcached_set(memc
, key
, strlen(key
),
4642 value
, strlen(value
),
4643 (time_t)0, (uint32_t)0);
4644 test_truth(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
);
4645 /** NB, the check below assumes that if new write_ptr is less than
4646 * the original write_ptr that we have flushed. For large payloads, this
4647 * maybe an invalid assumption, but for the small payload we have it is OK
4649 if (rc
== MEMCACHED_SUCCESS
||
4650 instance
->write_buffer_offset
< init_offset
)
4651 increment_request_id(&expected_ids
[server_key
]);
4653 if (rc
== MEMCACHED_SUCCESS
)
4655 test_truth(instance
->write_buffer_offset
== UDP_DATAGRAM_HEADER_LENGTH
);
4659 test_truth(instance
->write_buffer_offset
!= UDP_DATAGRAM_HEADER_LENGTH
);
4660 test_truth(instance
->write_buffer_offset
<= MAX_UDP_DATAGRAM_LENGTH
);
4662 test_truth(post_udp_op_check(memc
, expected_ids
) == TEST_SUCCESS
);
4664 return TEST_SUCCESS
;
4667 static test_return_t
udp_buffered_set_test(memcached_st
*memc
)
4669 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_BUFFER_REQUESTS
, 1);
4670 return udp_set_test(memc
);
4673 static test_return_t
udp_set_too_big_test(memcached_st
*memc
)
4675 memcached_return_t rc
;
4676 const char *key
= "bar";
4677 char value
[MAX_UDP_DATAGRAM_LENGTH
];
4678 uint16_t *expected_ids
= get_udp_request_ids(memc
);
4679 rc
= memcached_set(memc
, key
, strlen(key
),
4680 value
, MAX_UDP_DATAGRAM_LENGTH
,
4681 (time_t)0, (uint32_t)0);
4682 test_truth(rc
== MEMCACHED_WRITE_FAILURE
);
4684 return post_udp_op_check(memc
,expected_ids
);
4687 static test_return_t
udp_delete_test(memcached_st
*memc
)
4689 unsigned int num_iters
= 1025; //request id rolls over at 1024
4691 for (size_t x
= 0; x
< num_iters
;x
++)
4693 memcached_return_t rc
;
4694 const char *key
= "foo";
4695 uint16_t *expected_ids
=get_udp_request_ids(memc
);
4696 unsigned int server_key
= memcached_generate_hash(memc
, key
, strlen(key
));
4697 memcached_server_instance_st
*instance
=
4698 memcached_server_instance_fetch(memc
, server_key
);
4699 size_t init_offset
= instance
->write_buffer_offset
;
4701 rc
= memcached_delete(memc
, key
, strlen(key
), 0);
4702 test_truth(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
);
4704 if (rc
== MEMCACHED_SUCCESS
|| instance
->write_buffer_offset
< init_offset
)
4705 increment_request_id(&expected_ids
[server_key
]);
4706 if (rc
== MEMCACHED_SUCCESS
)
4708 test_truth(instance
->write_buffer_offset
== UDP_DATAGRAM_HEADER_LENGTH
);
4712 test_truth(instance
->write_buffer_offset
!= UDP_DATAGRAM_HEADER_LENGTH
);
4713 test_truth(instance
->write_buffer_offset
<= MAX_UDP_DATAGRAM_LENGTH
);
4715 test_truth(post_udp_op_check(memc
,expected_ids
) == TEST_SUCCESS
);
4717 return TEST_SUCCESS
;
4720 static test_return_t
udp_buffered_delete_test(memcached_st
*memc
)
4722 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_BUFFER_REQUESTS
, 1);
4723 return udp_delete_test(memc
);
4726 static test_return_t
udp_verbosity_test(memcached_st
*memc
)
4728 memcached_return_t rc
;
4729 uint16_t *expected_ids
= get_udp_request_ids(memc
);
4731 for (size_t x
= 0; x
< memcached_server_count(memc
); x
++)
4733 increment_request_id(&expected_ids
[x
]);
4736 rc
= memcached_verbosity(memc
,3);
4737 test_truth(rc
== MEMCACHED_SUCCESS
);
4738 return post_udp_op_check(memc
,expected_ids
);
4741 static test_return_t
udp_quit_test(memcached_st
*memc
)
4743 uint16_t *expected_ids
= get_udp_request_ids(memc
);
4744 memcached_quit(memc
);
4745 return post_udp_op_check(memc
, expected_ids
);
4748 static test_return_t
udp_flush_test(memcached_st
*memc
)
4750 memcached_return_t rc
;
4751 uint16_t *expected_ids
= get_udp_request_ids(memc
);
4753 for (size_t x
= 0; x
< memcached_server_count(memc
); x
++)
4755 increment_request_id(&expected_ids
[x
]);
4758 rc
= memcached_flush(memc
,0);
4759 test_truth(rc
== MEMCACHED_SUCCESS
);
4760 return post_udp_op_check(memc
,expected_ids
);
4763 static test_return_t
udp_incr_test(memcached_st
*memc
)
4765 memcached_return_t rc
;
4766 const char *key
= "incr";
4767 const char *value
= "1";
4768 rc
= memcached_set(memc
, key
, strlen(key
),
4769 value
, strlen(value
),
4770 (time_t)0, (uint32_t)0);
4772 test_truth(rc
== MEMCACHED_SUCCESS
);
4773 uint16_t *expected_ids
= get_udp_request_ids(memc
);
4774 unsigned int server_key
= memcached_generate_hash(memc
, key
, strlen(key
));
4775 increment_request_id(&expected_ids
[server_key
]);
4777 rc
= memcached_increment(memc
, key
, strlen(key
), 1, &newvalue
);
4778 test_truth(rc
== MEMCACHED_SUCCESS
);
4779 return post_udp_op_check(memc
, expected_ids
);
4782 static test_return_t
udp_decr_test(memcached_st
*memc
)
4784 memcached_return_t rc
;
4785 const char *key
= "decr";
4786 const char *value
= "1";
4787 rc
= memcached_set(memc
, key
, strlen(key
),
4788 value
, strlen(value
),
4789 (time_t)0, (uint32_t)0);
4791 test_truth(rc
== MEMCACHED_SUCCESS
);
4792 uint16_t *expected_ids
= get_udp_request_ids(memc
);
4793 unsigned int server_key
= memcached_generate_hash(memc
, key
, strlen(key
));
4794 increment_request_id(&expected_ids
[server_key
]);
4796 rc
= memcached_decrement(memc
, key
, strlen(key
), 1, &newvalue
);
4797 test_truth(rc
== MEMCACHED_SUCCESS
);
4798 return post_udp_op_check(memc
, expected_ids
);
4802 static test_return_t
udp_stat_test(memcached_st
*memc
)
4804 memcached_stat_st
* rv
= NULL
;
4805 memcached_return_t rc
;
4807 uint16_t *expected_ids
= get_udp_request_ids(memc
);
4808 rv
= memcached_stat(memc
, args
, &rc
);
4810 test_truth(rc
== MEMCACHED_NOT_SUPPORTED
);
4811 return post_udp_op_check(memc
, expected_ids
);
4814 static test_return_t
udp_version_test(memcached_st
*memc
)
4816 memcached_return_t rc
;
4817 uint16_t *expected_ids
= get_udp_request_ids(memc
);
4818 rc
= memcached_version(memc
);
4819 test_truth(rc
== MEMCACHED_NOT_SUPPORTED
);
4820 return post_udp_op_check(memc
, expected_ids
);
4823 static test_return_t
udp_get_test(memcached_st
*memc
)
4825 memcached_return_t rc
;
4826 const char *key
= "foo";
4828 uint16_t *expected_ids
= get_udp_request_ids(memc
);
4829 char *val
= memcached_get(memc
, key
, strlen(key
), &vlen
, (uint32_t)0, &rc
);
4830 test_truth(rc
== MEMCACHED_NOT_SUPPORTED
);
4831 test_truth(val
== NULL
);
4832 return post_udp_op_check(memc
, expected_ids
);
4835 static test_return_t
udp_mixed_io_test(memcached_st
*memc
)
4838 test_st mixed_io_ops
[] ={
4840 (test_callback_fn
)udp_set_test
},
4841 {"udp_set_too_big_test", 0,
4842 (test_callback_fn
)udp_set_too_big_test
},
4843 {"udp_delete_test", 0,
4844 (test_callback_fn
)udp_delete_test
},
4845 {"udp_verbosity_test", 0,
4846 (test_callback_fn
)udp_verbosity_test
},
4847 {"udp_quit_test", 0,
4848 (test_callback_fn
)udp_quit_test
},
4849 {"udp_flush_test", 0,
4850 (test_callback_fn
)udp_flush_test
},
4851 {"udp_incr_test", 0,
4852 (test_callback_fn
)udp_incr_test
},
4853 {"udp_decr_test", 0,
4854 (test_callback_fn
)udp_decr_test
},
4855 {"udp_version_test", 0,
4856 (test_callback_fn
)udp_version_test
}
4858 for (size_t x
= 0; x
< 500; x
++)
4860 current_op
= mixed_io_ops
[random() % 9];
4861 test_truth(current_op
.test_fn(memc
) == TEST_SUCCESS
);
4863 return TEST_SUCCESS
;
4867 static test_return_t
hash_sanity_test (memcached_st
*memc
)
4871 assert(MEMCACHED_HASH_DEFAULT
== MEMCACHED_HASH_DEFAULT
);
4872 assert(MEMCACHED_HASH_MD5
== MEMCACHED_HASH_MD5
);
4873 assert(MEMCACHED_HASH_CRC
== MEMCACHED_HASH_CRC
);
4874 assert(MEMCACHED_HASH_FNV1_64
== MEMCACHED_HASH_FNV1_64
);
4875 assert(MEMCACHED_HASH_FNV1A_64
== MEMCACHED_HASH_FNV1A_64
);
4876 assert(MEMCACHED_HASH_FNV1_32
== MEMCACHED_HASH_FNV1_32
);
4877 assert(MEMCACHED_HASH_FNV1A_32
== MEMCACHED_HASH_FNV1A_32
);
4878 #ifdef HAVE_HSIEH_HASH
4879 assert(MEMCACHED_HASH_HSIEH
== MEMCACHED_HASH_HSIEH
);
4881 assert(MEMCACHED_HASH_MURMUR
== MEMCACHED_HASH_MURMUR
);
4882 assert(MEMCACHED_HASH_JENKINS
== MEMCACHED_HASH_JENKINS
);
4883 assert(MEMCACHED_HASH_MAX
== MEMCACHED_HASH_MAX
);
4885 return TEST_SUCCESS
;
4889 static test_return_t
hsieh_avaibility_test (memcached_st
*memc
)
4891 memcached_return_t expected_rc
= MEMCACHED_FAILURE
;
4892 #ifdef HAVE_HSIEH_HASH
4893 expected_rc
= MEMCACHED_SUCCESS
;
4895 memcached_return_t rc
= memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_HASH
,
4896 (uint64_t)MEMCACHED_HASH_HSIEH
);
4897 test_truth(rc
== expected_rc
);
4898 return TEST_SUCCESS
;
4901 static test_return_t
md5_run (memcached_st
*memc
__attribute__((unused
)))
4906 for (ptr
= list_to_hash
, x
= 0; *ptr
; ptr
++, x
++)
4910 hash_val
= memcached_generate_hash_value(*ptr
, strlen(*ptr
), MEMCACHED_HASH_MD5
);
4911 test_truth(md5_values
[x
] == hash_val
);
4914 return TEST_SUCCESS
;
4917 static test_return_t
crc_run (memcached_st
*memc
__attribute__((unused
)))
4922 for (ptr
= list_to_hash
, x
= 0; *ptr
; ptr
++, x
++)
4926 hash_val
= memcached_generate_hash_value(*ptr
, strlen(*ptr
), MEMCACHED_HASH_CRC
);
4927 test_truth(crc_values
[x
] == hash_val
);
4930 return TEST_SUCCESS
;
4933 static test_return_t
fnv1_64_run (memcached_st
*memc
__attribute__((unused
)))
4938 for (ptr
= list_to_hash
, x
= 0; *ptr
; ptr
++, x
++)
4942 hash_val
= memcached_generate_hash_value(*ptr
, strlen(*ptr
), MEMCACHED_HASH_FNV1_64
);
4943 test_truth(fnv1_64_values
[x
] == hash_val
);
4946 return TEST_SUCCESS
;
4949 static test_return_t
fnv1a_64_run (memcached_st
*memc
__attribute__((unused
)))
4954 for (ptr
= list_to_hash
, x
= 0; *ptr
; ptr
++, x
++)
4958 hash_val
= memcached_generate_hash_value(*ptr
, strlen(*ptr
), MEMCACHED_HASH_FNV1A_64
);
4959 test_truth(fnv1a_64_values
[x
] == hash_val
);
4962 return TEST_SUCCESS
;
4965 static test_return_t
fnv1_32_run (memcached_st
*memc
__attribute__((unused
)))
4971 for (ptr
= list_to_hash
, x
= 0; *ptr
; ptr
++, x
++)
4975 hash_val
= memcached_generate_hash_value(*ptr
, strlen(*ptr
), MEMCACHED_HASH_FNV1_32
);
4976 test_truth(fnv1_32_values
[x
] == hash_val
);
4979 return TEST_SUCCESS
;
4982 static test_return_t
fnv1a_32_run (memcached_st
*memc
__attribute__((unused
)))
4987 for (ptr
= list_to_hash
, x
= 0; *ptr
; ptr
++, x
++)
4991 hash_val
= memcached_generate_hash_value(*ptr
, strlen(*ptr
), MEMCACHED_HASH_FNV1A_32
);
4992 test_truth(fnv1a_32_values
[x
] == hash_val
);
4995 return TEST_SUCCESS
;
4998 static test_return_t
hsieh_run (memcached_st
*memc
__attribute__((unused
)))
5003 for (ptr
= list_to_hash
, x
= 0; *ptr
; ptr
++, x
++)
5007 hash_val
= memcached_generate_hash_value(*ptr
, strlen(*ptr
), MEMCACHED_HASH_HSIEH
);
5008 test_truth(hsieh_values
[x
] == hash_val
);
5011 return TEST_SUCCESS
;
5014 static test_return_t
murmur_run (memcached_st
*memc
__attribute__((unused
)))
5017 return TEST_SKIPPED
;
5022 for (ptr
= list_to_hash
, x
= 0; *ptr
; ptr
++, x
++)
5026 hash_val
= memcached_generate_hash_value(*ptr
, strlen(*ptr
), MEMCACHED_HASH_MURMUR
);
5027 test_truth(murmur_values
[x
] == hash_val
);
5030 return TEST_SUCCESS
;
5034 static test_return_t
jenkins_run (memcached_st
*memc
__attribute__((unused
)))
5040 for (ptr
= list_to_hash
, x
= 0; *ptr
; ptr
++, x
++)
5044 hash_val
= memcached_generate_hash_value(*ptr
, strlen(*ptr
), MEMCACHED_HASH_JENKINS
);
5045 test_truth(jenkins_values
[x
] == hash_val
);
5048 return TEST_SUCCESS
;
5052 static test_return_t
ketama_compatibility_libmemcached(memcached_st
*trash
)
5054 memcached_return_t rc
;
5057 memcached_server_st
*server_pool
;
5062 memc
= memcached_create(NULL
);
5065 rc
= memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_KETAMA_WEIGHTED
, 1);
5066 test_truth(rc
== MEMCACHED_SUCCESS
);
5068 value
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_KETAMA_WEIGHTED
);
5069 test_truth(value
== 1);
5071 test_truth(memcached_behavior_set_distribution(memc
, MEMCACHED_DISTRIBUTION_CONSISTENT_KETAMA
) == MEMCACHED_SUCCESS
);
5072 test_truth(memcached_behavior_get_distribution(memc
) == MEMCACHED_DISTRIBUTION_CONSISTENT_KETAMA
);
5075 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");
5076 memcached_server_push(memc
, server_pool
);
5078 /* verify that the server list was parsed okay. */
5079 test_truth(memcached_server_count(memc
) == 8);
5080 test_strcmp(server_pool
[0].hostname
, "10.0.1.1");
5081 test_truth(server_pool
[0].port
== 11211);
5082 test_truth(server_pool
[0].weight
== 600);
5083 test_strcmp(server_pool
[2].hostname
, "10.0.1.3");
5084 test_truth(server_pool
[2].port
== 11211);
5085 test_truth(server_pool
[2].weight
== 200);
5086 test_strcmp(server_pool
[7].hostname
, "10.0.1.8");
5087 test_truth(server_pool
[7].port
== 11211);
5088 test_truth(server_pool
[7].weight
== 100);
5090 /* VDEAAAAA hashes to fffcd1b5, after the last continuum point, and lets
5091 * us test the boundary wraparound.
5093 test_truth(memcached_generate_hash(memc
, (char *)"VDEAAAAA", 8) == memc
->continuum
[0].index
);
5095 /* verify the standard ketama set. */
5096 for (x
= 0; x
< 99; x
++)
5098 uint32_t server_idx
= memcached_generate_hash(memc
, ketama_test_cases
[x
].key
, strlen(ketama_test_cases
[x
].key
));
5099 memcached_server_instance_st
*instance
=
5100 memcached_server_instance_fetch(memc
, server_idx
);
5101 char *hostname
= instance
->hostname
;
5103 test_strcmp(hostname
, ketama_test_cases
[x
].server
);
5106 memcached_server_list_free(server_pool
);
5107 memcached_free(memc
);
5109 return TEST_SUCCESS
;
5112 static test_return_t
ketama_compatibility_spymemcached(memcached_st
*trash
)
5114 memcached_return_t rc
;
5117 memcached_server_st
*server_pool
;
5122 memc
= memcached_create(NULL
);
5125 rc
= memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_KETAMA_WEIGHTED
, 1);
5126 test_truth(rc
== MEMCACHED_SUCCESS
);
5128 value
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_KETAMA_WEIGHTED
);
5129 test_truth(value
== 1);
5131 test_truth(memcached_behavior_set_distribution(memc
, MEMCACHED_DISTRIBUTION_CONSISTENT_KETAMA_SPY
) == MEMCACHED_SUCCESS
);
5132 test_truth(memcached_behavior_get_distribution(memc
) == MEMCACHED_DISTRIBUTION_CONSISTENT_KETAMA_SPY
);
5134 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");
5135 memcached_server_push(memc
, server_pool
);
5137 /* verify that the server list was parsed okay. */
5138 test_truth(memcached_server_count(memc
) == 8);
5139 test_strcmp(server_pool
[0].hostname
, "10.0.1.1");
5140 test_truth(server_pool
[0].port
== 11211);
5141 test_truth(server_pool
[0].weight
== 600);
5142 test_strcmp(server_pool
[2].hostname
, "10.0.1.3");
5143 test_truth(server_pool
[2].port
== 11211);
5144 test_truth(server_pool
[2].weight
== 200);
5145 test_strcmp(server_pool
[7].hostname
, "10.0.1.8");
5146 test_truth(server_pool
[7].port
== 11211);
5147 test_truth(server_pool
[7].weight
== 100);
5149 /* VDEAAAAA hashes to fffcd1b5, after the last continuum point, and lets
5150 * us test the boundary wraparound.
5152 test_truth(memcached_generate_hash(memc
, (char *)"VDEAAAAA", 8) == memc
->continuum
[0].index
);
5154 /* verify the standard ketama set. */
5155 for (x
= 0; x
< 99; x
++)
5157 uint32_t server_idx
= memcached_generate_hash(memc
, ketama_test_cases_spy
[x
].key
, strlen(ketama_test_cases_spy
[x
].key
));
5158 memcached_server_instance_st
*instance
=
5159 memcached_server_instance_fetch(memc
, server_idx
);
5160 char *hostname
= instance
->hostname
;
5161 test_strcmp(hostname
, ketama_test_cases_spy
[x
].server
);
5164 memcached_server_list_free(server_pool
);
5165 memcached_free(memc
);
5167 return TEST_SUCCESS
;
5170 static test_return_t
regression_bug_434484(memcached_st
*memc
)
5172 test_return_t test_rc
;
5173 test_rc
= pre_binary(memc
);
5175 if (test_rc
!= TEST_SUCCESS
)
5178 memcached_return_t ret
;
5179 const char *key
= "regression_bug_434484";
5180 size_t keylen
= strlen(key
);
5182 ret
= memcached_append(memc
, key
, keylen
, key
, keylen
, 0, 0);
5183 test_truth(ret
== MEMCACHED_NOTSTORED
);
5185 size_t size
= 2048 * 1024;
5186 void *data
= calloc(1, size
);
5187 test_truth(data
!= NULL
);
5188 ret
= memcached_set(memc
, key
, keylen
, data
, size
, 0, 0);
5189 test_truth(ret
== MEMCACHED_E2BIG
);
5192 return TEST_SUCCESS
;
5195 static test_return_t
regression_bug_434843(memcached_st
*memc
)
5197 test_return_t test_rc
;
5198 test_rc
= pre_binary(memc
);
5200 if (test_rc
!= TEST_SUCCESS
)
5203 memcached_return_t rc
;
5205 memcached_execute_fn callbacks
[1]= { [0]= &callback_counter
};
5208 * I only want to hit only _one_ server so I know the number of requests I'm
5209 * sending in the pipleine to the server. Let's try to do a multiget of
5210 * 1024 (that should satisfy most users don't you think?). Future versions
5211 * will include a mget_execute function call if you need a higher number.
5213 uint32_t number_of_hosts
= memcached_server_count(memc
);
5214 memc
->number_of_hosts
= 1;
5215 const size_t max_keys
= 1024;
5216 char **keys
= calloc(max_keys
, sizeof(char*));
5217 size_t *key_length
=calloc(max_keys
, sizeof(size_t));
5219 for (size_t x
= 0; x
< max_keys
; ++x
)
5223 key_length
[x
]= (size_t)snprintf(k
, sizeof(k
), "0200%zu", x
);
5225 test_truth(keys
[x
] != NULL
);
5229 * Run two times.. the first time we should have 100% cache miss,
5230 * and the second time we should have 100% cache hits
5232 for (size_t y
= 0; y
< 2; y
++)
5234 rc
= memcached_mget(memc
, (const char**)keys
, key_length
, max_keys
);
5235 test_truth(rc
== MEMCACHED_SUCCESS
);
5236 rc
= memcached_fetch_execute(memc
, callbacks
, (void *)&counter
, 1);
5240 /* The first iteration should give me a 100% cache miss. verify that*/
5241 char blob
[1024]= { 0 };
5243 test_truth(counter
== 0);
5245 for (size_t x
= 0; x
< max_keys
; ++x
)
5247 rc
= memcached_add(memc
, keys
[x
], key_length
[x
],
5248 blob
, sizeof(blob
), 0, 0);
5249 test_truth(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
);
5254 /* Verify that we received all of the key/value pairs */
5255 test_truth(counter
== max_keys
);
5259 /* Release allocated resources */
5260 for (size_t x
= 0; x
< max_keys
; ++x
)
5267 memc
->number_of_hosts
= number_of_hosts
;
5269 return TEST_SUCCESS
;
5272 static test_return_t
regression_bug_434843_buffered(memcached_st
*memc
)
5274 memcached_return_t rc
;
5275 rc
= memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_BUFFER_REQUESTS
, 1);
5276 test_truth(rc
== MEMCACHED_SUCCESS
);
5278 return regression_bug_434843(memc
);
5281 static test_return_t
regression_bug_421108(memcached_st
*memc
)
5283 memcached_return_t rc
;
5284 memcached_stat_st
*memc_stat
= memcached_stat(memc
, NULL
, &rc
);
5285 test_truth(rc
== MEMCACHED_SUCCESS
);
5287 char *bytes
= memcached_stat_get_value(memc
, memc_stat
, "bytes", &rc
);
5288 test_truth(rc
== MEMCACHED_SUCCESS
);
5289 test_truth(bytes
!= NULL
);
5290 char *bytes_read
= memcached_stat_get_value(memc
, memc_stat
,
5292 test_truth(rc
== MEMCACHED_SUCCESS
);
5293 test_truth(bytes_read
!= NULL
);
5295 char *bytes_written
= memcached_stat_get_value(memc
, memc_stat
,
5296 "bytes_written", &rc
);
5297 test_truth(rc
== MEMCACHED_SUCCESS
);
5298 test_truth(bytes_written
!= NULL
);
5300 test_truth(strcmp(bytes
, bytes_read
) != 0);
5301 test_truth(strcmp(bytes
, bytes_written
) != 0);
5303 /* Release allocated resources */
5306 free(bytes_written
);
5307 memcached_stat_free(NULL
, memc_stat
);
5309 return TEST_SUCCESS
;
5313 * The test case isn't obvious so I should probably document why
5314 * it works the way it does. Bug 442914 was caused by a bug
5315 * in the logic in memcached_purge (it did not handle the case
5316 * where the number of bytes sent was equal to the watermark).
5317 * In this test case, create messages so that we hit that case
5318 * and then disable noreply mode and issue a new command to
5319 * verify that it isn't stuck. If we change the format for the
5320 * delete command or the watermarks, we need to update this
5323 static test_return_t
regression_bug_442914(memcached_st
*memc
)
5325 memcached_return_t rc
;
5326 rc
= memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NOREPLY
, 1);
5327 test_truth(rc
== MEMCACHED_SUCCESS
);
5328 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_TCP_NODELAY
, 1);
5330 uint32_t number_of_hosts
= memcached_server_count(memc
);
5331 memc
->number_of_hosts
= 1;
5336 for (uint32_t x
= 0; x
< 250; ++x
)
5338 len
= (size_t)snprintf(k
, sizeof(k
), "%0250u", x
);
5339 rc
= memcached_delete(memc
, k
, len
, 0);
5340 test_truth(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
);
5343 (void)snprintf(k
, sizeof(k
), "%037u", 251U);
5346 rc
= memcached_delete(memc
, k
, len
, 0);
5347 test_truth(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
);
5349 rc
= memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NOREPLY
, 0);
5350 test_truth(rc
== MEMCACHED_SUCCESS
);
5351 rc
= memcached_delete(memc
, k
, len
, 0);
5352 test_truth(rc
== MEMCACHED_NOTFOUND
);
5354 memc
->number_of_hosts
= number_of_hosts
;
5356 return TEST_SUCCESS
;
5359 static test_return_t
regression_bug_447342(memcached_st
*memc
)
5361 memcached_server_instance_st
*instance_one
;
5362 memcached_server_instance_st
*instance_two
;
5364 if (memcached_server_count(memc
) < 3 || pre_replication(memc
) != MEMCACHED_SUCCESS
)
5365 return TEST_SKIPPED
;
5367 memcached_return_t rc
;
5369 rc
= memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NUMBER_OF_REPLICAS
, 2);
5370 test_truth(rc
== MEMCACHED_SUCCESS
);
5372 const size_t max_keys
= 100;
5373 char **keys
= calloc(max_keys
, sizeof(char*));
5374 size_t *key_length
= calloc(max_keys
, sizeof(size_t));
5376 for (size_t x
= 0; x
< max_keys
; ++x
)
5380 key_length
[x
]= (size_t)snprintf(k
, sizeof(k
), "0200%zu", x
);
5382 test_truth(keys
[x
] != NULL
);
5383 rc
= memcached_set(memc
, k
, key_length
[x
], k
, key_length
[x
], 0, 0);
5384 test_truth(rc
== MEMCACHED_SUCCESS
);
5388 ** We are using the quiet commands to store the replicas, so we need
5389 ** to ensure that all of them are processed before we can continue.
5390 ** In the test we go directly from storing the object to trying to
5391 ** receive the object from all of the different servers, so we
5392 ** could end up in a race condition (the memcached server hasn't yet
5393 ** processed the quiet command from the replication set when it process
5394 ** the request from the other client (created by the clone)). As a
5395 ** workaround for that we call memcached_quit to send the quit command
5396 ** to the server and wait for the response ;-) If you use the test code
5397 ** as an example for your own code, please note that you shouldn't need
5400 memcached_quit(memc
);
5402 /* Verify that all messages are stored, and we didn't stuff too much
5405 rc
= memcached_mget(memc
, (const char* const *)keys
, key_length
, max_keys
);
5406 test_truth(rc
== MEMCACHED_SUCCESS
);
5409 memcached_execute_fn callbacks
[1]= { [0]= &callback_counter
};
5410 rc
= memcached_fetch_execute(memc
, callbacks
, (void *)&counter
, 1);
5411 /* Verify that we received all of the key/value pairs */
5412 test_truth(counter
== max_keys
);
5414 memcached_quit(memc
);
5416 * Don't do the following in your code. I am abusing the internal details
5417 * within the library, and this is not a supported interface.
5418 * This is to verify correct behavior in the library. Fake that two servers
5421 instance_one
= memcached_server_instance_fetch(memc
, 0);
5422 instance_two
= memcached_server_instance_fetch(memc
, 2);
5423 in_port_t port0
= instance_one
->port
;
5424 in_port_t port2
= instance_two
->port
;
5426 instance_one
->port
= 0;
5427 instance_two
->port
= 0;
5429 rc
= memcached_mget(memc
, (const char* const *)keys
, key_length
, max_keys
);
5430 test_truth(rc
== MEMCACHED_SUCCESS
);
5433 rc
= memcached_fetch_execute(memc
, callbacks
, (void *)&counter
, 1);
5434 test_truth(counter
== (unsigned int)max_keys
);
5436 /* restore the memc handle */
5437 instance_one
->port
= port0
;
5438 instance_two
->port
= port2
;
5440 memcached_quit(memc
);
5442 /* Remove half of the objects */
5443 for (size_t x
= 0; x
< max_keys
; ++x
)
5447 rc
= memcached_delete(memc
, keys
[x
], key_length
[x
], 0);
5448 test_truth(rc
== MEMCACHED_SUCCESS
);
5452 memcached_quit(memc
);
5453 instance_one
->port
= 0;
5454 instance_two
->port
= 0;
5456 /* now retry the command, this time we should have cache misses */
5457 rc
= memcached_mget(memc
, (const char* const *)keys
, key_length
, max_keys
);
5458 test_truth(rc
== MEMCACHED_SUCCESS
);
5461 rc
= memcached_fetch_execute(memc
, callbacks
, (void *)&counter
, 1);
5462 test_truth(counter
== (unsigned int)(max_keys
>> 1));
5464 /* Release allocated resources */
5465 for (size_t x
= 0; x
< max_keys
; ++x
)
5472 /* restore the memc handle */
5473 instance_one
->port
= port0
;
5474 instance_two
->port
= port2
;
5476 return TEST_SUCCESS
;
5479 static test_return_t
regression_bug_463297(memcached_st
*memc
)
5481 memcached_st
*memc_clone
= memcached_clone(NULL
, memc
);
5482 test_truth(memc_clone
!= NULL
);
5483 test_truth(memcached_version(memc_clone
) == MEMCACHED_SUCCESS
);
5485 memcached_server_instance_st
*instance
=
5486 memcached_server_instance_fetch(memc_clone
, 0);
5488 if (instance
->major_version
> 1 ||
5489 (instance
->major_version
== 1 &&
5490 instance
->minor_version
> 2))
5492 /* Binary protocol doesn't support deferred delete */
5493 memcached_st
*bin_clone
= memcached_clone(NULL
, memc
);
5494 test_truth(bin_clone
!= NULL
);
5495 test_truth(memcached_behavior_set(bin_clone
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
, 1) == MEMCACHED_SUCCESS
);
5496 test_truth(memcached_delete(bin_clone
, "foo", 3, 1) == MEMCACHED_INVALID_ARGUMENTS
);
5497 memcached_free(bin_clone
);
5499 memcached_quit(memc_clone
);
5501 /* If we know the server version, deferred delete should fail
5502 * with invalid arguments */
5503 test_truth(memcached_delete(memc_clone
, "foo", 3, 1) == MEMCACHED_INVALID_ARGUMENTS
);
5505 /* If we don't know the server version, we should get a protocol error */
5506 memcached_return_t rc
= memcached_delete(memc
, "foo", 3, 1);
5508 /* but there is a bug in some of the memcached servers (1.4) that treats
5509 * the counter as noreply so it doesn't send the proper error message
5511 test_truth(rc
== MEMCACHED_PROTOCOL_ERROR
|| rc
== MEMCACHED_NOTFOUND
|| rc
== MEMCACHED_CLIENT_ERROR
);
5513 /* And buffered mode should be disabled and we should get protocol error */
5514 test_truth(memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_BUFFER_REQUESTS
, 1) == MEMCACHED_SUCCESS
);
5515 rc
= memcached_delete(memc
, "foo", 3, 1);
5516 test_truth(rc
== MEMCACHED_PROTOCOL_ERROR
|| rc
== MEMCACHED_NOTFOUND
|| rc
== MEMCACHED_CLIENT_ERROR
);
5518 /* Same goes for noreply... */
5519 test_truth(memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NOREPLY
, 1) == MEMCACHED_SUCCESS
);
5520 rc
= memcached_delete(memc
, "foo", 3, 1);
5521 test_truth(rc
== MEMCACHED_PROTOCOL_ERROR
|| rc
== MEMCACHED_NOTFOUND
|| rc
== MEMCACHED_CLIENT_ERROR
);
5523 /* but a normal request should go through (and be buffered) */
5524 test_truth((rc
= memcached_delete(memc
, "foo", 3, 0)) == MEMCACHED_BUFFERED
);
5525 test_truth(memcached_flush_buffers(memc
) == MEMCACHED_SUCCESS
);
5527 test_truth(memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_BUFFER_REQUESTS
, 0) == MEMCACHED_SUCCESS
);
5528 /* unbuffered noreply should be success */
5529 test_truth(memcached_delete(memc
, "foo", 3, 0) == MEMCACHED_SUCCESS
);
5530 /* unbuffered with reply should be not found... */
5531 test_truth(memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NOREPLY
, 0) == MEMCACHED_SUCCESS
);
5532 test_truth(memcached_delete(memc
, "foo", 3, 0) == MEMCACHED_NOTFOUND
);
5535 memcached_free(memc_clone
);
5536 return TEST_SUCCESS
;
5540 /* Test memcached_server_get_last_disconnect
5541 * For a working server set, shall be NULL
5542 * For a set of non existing server, shall not be NULL
5544 static test_return_t
test_get_last_disconnect(memcached_st
*memc
)
5546 memcached_return_t rc
;
5547 memcached_server_st
*disconnected_server
;
5549 /* With the working set of server */
5550 const char *key
= "marmotte";
5551 const char *value
= "milka";
5553 rc
= memcached_set(memc
, key
, strlen(key
),
5554 value
, strlen(value
),
5555 (time_t)0, (uint32_t)0);
5556 test_truth(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
);
5558 disconnected_server
= memcached_server_get_last_disconnect(memc
);
5559 test_truth(disconnected_server
== NULL
);
5561 /* With a non existing server */
5563 memcached_server_st
*servers
;
5565 const char *server_list
= "localhost:9";
5567 servers
= memcached_servers_parse(server_list
);
5568 test_truth(servers
);
5569 mine
= memcached_create(NULL
);
5570 rc
= memcached_server_push(mine
, servers
);
5571 test_truth(rc
== MEMCACHED_SUCCESS
);
5572 memcached_server_list_free(servers
);
5575 rc
= memcached_set(mine
, key
, strlen(key
),
5576 value
, strlen(value
),
5577 (time_t)0, (uint32_t)0);
5578 test_truth(rc
!= MEMCACHED_SUCCESS
);
5580 disconnected_server
= memcached_server_get_last_disconnect(mine
);
5581 test_truth(disconnected_server
!= NULL
);
5582 test_truth(disconnected_server
->port
== 9);
5583 test_truth(strncmp(disconnected_server
->hostname
,"localhost",9) == 0);
5585 memcached_quit(mine
);
5586 memcached_free(mine
);
5588 return TEST_SUCCESS
;
5592 * This test ensures that the failure counter isn't incremented during
5593 * normal termination of the memcached instance.
5595 static test_return_t
wrong_failure_counter_test(memcached_st
*memc
)
5597 memcached_return_t rc
;
5598 memcached_server_instance_st
*instance
;
5600 /* Set value to force connection to the server */
5601 const char *key
= "marmotte";
5602 const char *value
= "milka";
5605 * Please note that I'm abusing the internal structures in libmemcached
5606 * in a non-portable way and you shouldn't be doing this. I'm only
5607 * doing this in order to verify that the library works the way it should
5609 uint32_t number_of_hosts
= memcached_server_count(memc
);
5610 memc
->number_of_hosts
= 1;
5612 /* Ensure that we are connected to the server by setting a value */
5613 rc
= memcached_set(memc
, key
, strlen(key
),
5614 value
, strlen(value
),
5615 (time_t)0, (uint32_t)0);
5616 test_truth(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
);
5619 instance
= memcached_server_instance_fetch(memc
, 0);
5620 /* The test is to see that the memcached_quit doesn't increase the
5621 * the server failure conter, so let's ensure that it is zero
5622 * before sending quit
5624 instance
->server_failure_counter
= 0;
5626 memcached_quit(memc
);
5628 /* Verify that it memcached_quit didn't increment the failure counter
5629 * Please note that this isn't bullet proof, because an error could
5632 test_truth(instance
->server_failure_counter
== 0);
5634 /* restore the instance */
5635 memc
->number_of_hosts
= number_of_hosts
;
5637 return TEST_SUCCESS
;
5644 * Test that ensures mget_execute does not end into recursive calls that finally fails
5646 static test_return_t
regression_bug_490486(memcached_st
*memc
)
5648 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
, 1);
5649 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NO_BLOCK
, 1);
5650 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_POLL_TIMEOUT
, 1000);
5651 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_SERVER_FAILURE_LIMIT
, 1);
5652 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_RETRY_TIMEOUT
, 3600);
5655 * I only want to hit _one_ server so I know the number of requests I'm
5656 * sending in the pipeline.
5658 uint32_t number_of_hosts
= memc
->number_of_hosts
;
5659 memc
->number_of_hosts
= 1;
5660 size_t max_keys
= 20480;
5663 char **keys
= calloc(max_keys
, sizeof(char*));
5664 size_t *key_length
=calloc(max_keys
, sizeof(size_t));
5666 /* First add all of the items.. */
5667 char blob
[1024]= { 0 };
5668 memcached_return rc
;
5669 for (size_t x
= 0; x
< max_keys
; ++x
)
5672 key_length
[x
]= (size_t)snprintf(k
, sizeof(k
), "0200%zu", x
);
5674 assert(keys
[x
] != NULL
);
5675 rc
= memcached_set(memc
, keys
[x
], key_length
[x
], blob
, sizeof(blob
), 0, 0);
5676 assert(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
);
5679 /* Try to get all of them with a large multiget */
5681 memcached_execute_function callbacks
[1]= { [0]= &callback_counter
};
5682 rc
= memcached_mget_execute(memc
, (const char**)keys
, key_length
,
5683 (size_t)max_keys
, callbacks
, &counter
, 1);
5685 assert(rc
== MEMCACHED_SUCCESS
);
5686 char* the_value
= NULL
;
5687 char the_key
[MEMCACHED_MAX_KEY
];
5688 size_t the_key_length
;
5689 size_t the_value_length
;
5693 the_value
= memcached_fetch(memc
, the_key
, &the_key_length
, &the_value_length
, &the_flags
, &rc
);
5695 if ((the_value
!= NULL
) && (rc
== MEMCACHED_SUCCESS
))
5701 } while ( (the_value
!= NULL
) && (rc
== MEMCACHED_SUCCESS
));
5704 assert(rc
== MEMCACHED_END
);
5706 /* Verify that we got all of the items */
5707 assert(counter
== max_keys
);
5709 /* Release all allocated resources */
5710 for (size_t x
= 0; x
< max_keys
; ++x
)
5717 memc
->number_of_hosts
= number_of_hosts
;
5719 return TEST_SUCCESS
;
5725 test_st udp_setup_server_tests
[] ={
5726 {"set_udp_behavior_test", 0, (test_callback_fn
)set_udp_behavior_test
},
5727 {"add_tcp_server_udp_client_test", 0, (test_callback_fn
)add_tcp_server_udp_client_test
},
5728 {"add_udp_server_tcp_client_test", 0, (test_callback_fn
)add_udp_server_tcp_client_test
},
5732 test_st upd_io_tests
[] ={
5733 {"udp_set_test", 0, (test_callback_fn
)udp_set_test
},
5734 {"udp_buffered_set_test", 0, (test_callback_fn
)udp_buffered_set_test
},
5735 {"udp_set_too_big_test", 0, (test_callback_fn
)udp_set_too_big_test
},
5736 {"udp_delete_test", 0, (test_callback_fn
)udp_delete_test
},
5737 {"udp_buffered_delete_test", 0, (test_callback_fn
)udp_buffered_delete_test
},
5738 {"udp_verbosity_test", 0, (test_callback_fn
)udp_verbosity_test
},
5739 {"udp_quit_test", 0, (test_callback_fn
)udp_quit_test
},
5740 {"udp_flush_test", 0, (test_callback_fn
)udp_flush_test
},
5741 {"udp_incr_test", 0, (test_callback_fn
)udp_incr_test
},
5742 {"udp_decr_test", 0, (test_callback_fn
)udp_decr_test
},
5743 {"udp_stat_test", 0, (test_callback_fn
)udp_stat_test
},
5744 {"udp_version_test", 0, (test_callback_fn
)udp_version_test
},
5745 {"udp_get_test", 0, (test_callback_fn
)udp_get_test
},
5746 {"udp_mixed_io_test", 0, (test_callback_fn
)udp_mixed_io_test
},
5750 /* Clean the server before beginning testing */
5752 {"flush", 0, (test_callback_fn
)flush_test
},
5753 {"init", 0, (test_callback_fn
)init_test
},
5754 {"allocation", 0, (test_callback_fn
)allocation_test
},
5755 {"server_list_null_test", 0, (test_callback_fn
)server_list_null_test
},
5756 {"server_unsort", 0, (test_callback_fn
)server_unsort_test
},
5757 {"server_sort", 0, (test_callback_fn
)server_sort_test
},
5758 {"server_sort2", 0, (test_callback_fn
)server_sort2_test
},
5759 {"clone_test", 0, (test_callback_fn
)clone_test
},
5760 {"connection_test", 0, (test_callback_fn
)connection_test
},
5761 {"callback_test", 0, (test_callback_fn
)callback_test
},
5762 {"userdata_test", 0, (test_callback_fn
)userdata_test
},
5763 {"error", 0, (test_callback_fn
)error_test
},
5764 {"set", 0, (test_callback_fn
)set_test
},
5765 {"set2", 0, (test_callback_fn
)set_test2
},
5766 {"set3", 0, (test_callback_fn
)set_test3
},
5767 {"dump", 1, (test_callback_fn
)dump_test
},
5768 {"add", 1, (test_callback_fn
)add_test
},
5769 {"replace", 1, (test_callback_fn
)replace_test
},
5770 {"delete", 1, (test_callback_fn
)delete_test
},
5771 {"get", 1, (test_callback_fn
)get_test
},
5772 {"get2", 0, (test_callback_fn
)get_test2
},
5773 {"get3", 0, (test_callback_fn
)get_test3
},
5774 {"get4", 0, (test_callback_fn
)get_test4
},
5775 {"partial mget", 0, (test_callback_fn
)get_test5
},
5776 {"stats_servername", 0, (test_callback_fn
)stats_servername_test
},
5777 {"increment", 0, (test_callback_fn
)increment_test
},
5778 {"increment_with_initial", 1, (test_callback_fn
)increment_with_initial_test
},
5779 {"decrement", 0, (test_callback_fn
)decrement_test
},
5780 {"decrement_with_initial", 1, (test_callback_fn
)decrement_with_initial_test
},
5781 {"increment_by_key", 0, (test_callback_fn
)increment_by_key_test
},
5782 {"increment_with_initial_by_key", 1, (test_callback_fn
)increment_with_initial_by_key_test
},
5783 {"decrement_by_key", 0, (test_callback_fn
)decrement_by_key_test
},
5784 {"decrement_with_initial_by_key", 1, (test_callback_fn
)decrement_with_initial_by_key_test
},
5785 {"quit", 0, (test_callback_fn
)quit_test
},
5786 {"mget", 1, (test_callback_fn
)mget_test
},
5787 {"mget_result", 1, (test_callback_fn
)mget_result_test
},
5788 {"mget_result_alloc", 1, (test_callback_fn
)mget_result_alloc_test
},
5789 {"mget_result_function", 1, (test_callback_fn
)mget_result_function
},
5790 {"mget_execute", 1, (test_callback_fn
)mget_execute
},
5791 {"mget_end", 0, (test_callback_fn
)mget_end
},
5792 {"get_stats", 0, (test_callback_fn
)get_stats
},
5793 {"add_host_test", 0, (test_callback_fn
)add_host_test
},
5794 {"add_host_test_1", 0, (test_callback_fn
)add_host_test1
},
5795 {"get_stats_keys", 0, (test_callback_fn
)get_stats_keys
},
5796 {"version_string_test", 0, (test_callback_fn
)version_string_test
},
5797 {"bad_key", 1, (test_callback_fn
)bad_key_test
},
5798 {"memcached_server_cursor", 1, (test_callback_fn
)memcached_server_cursor_test
},
5799 {"read_through", 1, (test_callback_fn
)read_through
},
5800 {"delete_through", 1, (test_callback_fn
)delete_through
},
5801 {"noreply", 1, (test_callback_fn
)noreply_test
},
5802 {"analyzer", 1, (test_callback_fn
)analyzer_test
},
5803 #ifdef HAVE_LIBMEMCACHEDUTIL
5804 {"connectionpool", 1, (test_callback_fn
)connection_pool_test
},
5806 {"test_get_last_disconnect", 1, (test_callback_fn
)test_get_last_disconnect
},
5810 test_st behavior_tests
[] ={
5811 {"behavior_test", 0, (test_callback_fn
)behavior_test
},
5812 {"MEMCACHED_BEHAVIOR_CORK", 0, (test_callback_fn
)MEMCACHED_BEHAVIOR_CORK_test
},
5816 test_st async_tests
[] ={
5817 {"add", 1, (test_callback_fn
)add_wrapper
},
5821 test_st string_tests
[] ={
5822 {"string static with null", 0, (test_callback_fn
)string_static_null
},
5823 {"string alloc with null", 0, (test_callback_fn
)string_alloc_null
},
5824 {"string alloc with 1K", 0, (test_callback_fn
)string_alloc_with_size
},
5825 {"string alloc with malloc failure", 0, (test_callback_fn
)string_alloc_with_size_toobig
},
5826 {"string append", 0, (test_callback_fn
)string_alloc_append
},
5827 {"string append failure (too big)", 0, (test_callback_fn
)string_alloc_append_toobig
},
5828 {0, 0, (test_callback_fn
)0}
5831 test_st result_tests
[] ={
5832 {"result static", 0, (test_callback_fn
)result_static
},
5833 {"result alloc", 0, (test_callback_fn
)result_alloc
},
5834 {0, 0, (test_callback_fn
)0}
5837 test_st version_1_2_3
[] ={
5838 {"append", 0, (test_callback_fn
)append_test
},
5839 {"prepend", 0, (test_callback_fn
)prepend_test
},
5840 {"cas", 0, (test_callback_fn
)cas_test
},
5841 {"cas2", 0, (test_callback_fn
)cas2_test
},
5842 {"append_binary", 0, (test_callback_fn
)append_binary_test
},
5843 {0, 0, (test_callback_fn
)0}
5846 test_st user_tests
[] ={
5847 {"user_supplied_bug1", 0, (test_callback_fn
)user_supplied_bug1
},
5848 {"user_supplied_bug2", 0, (test_callback_fn
)user_supplied_bug2
},
5849 {"user_supplied_bug3", 0, (test_callback_fn
)user_supplied_bug3
},
5850 {"user_supplied_bug4", 0, (test_callback_fn
)user_supplied_bug4
},
5851 {"user_supplied_bug5", 1, (test_callback_fn
)user_supplied_bug5
},
5852 {"user_supplied_bug6", 1, (test_callback_fn
)user_supplied_bug6
},
5853 {"user_supplied_bug7", 1, (test_callback_fn
)user_supplied_bug7
},
5854 {"user_supplied_bug8", 1, (test_callback_fn
)user_supplied_bug8
},
5855 {"user_supplied_bug9", 1, (test_callback_fn
)user_supplied_bug9
},
5856 {"user_supplied_bug10", 1, (test_callback_fn
)user_supplied_bug10
},
5857 {"user_supplied_bug11", 1, (test_callback_fn
)user_supplied_bug11
},
5858 {"user_supplied_bug12", 1, (test_callback_fn
)user_supplied_bug12
},
5859 {"user_supplied_bug13", 1, (test_callback_fn
)user_supplied_bug13
},
5860 {"user_supplied_bug14", 1, (test_callback_fn
)user_supplied_bug14
},
5861 {"user_supplied_bug15", 1, (test_callback_fn
)user_supplied_bug15
},
5862 {"user_supplied_bug16", 1, (test_callback_fn
)user_supplied_bug16
},
5865 ** It seems to be something weird with the character sets..
5866 ** value_fetch is unable to parse the value line (iscntrl "fails"), so I
5867 ** guess I need to find out how this is supposed to work.. Perhaps I need
5868 ** to run the test in a specific locale (I tried zh_CN.UTF-8 without success,
5869 ** so just disable the code for now...).
5871 {"user_supplied_bug17", 1, (test_callback_fn
)user_supplied_bug17
},
5873 {"user_supplied_bug18", 1, (test_callback_fn
)user_supplied_bug18
},
5874 {"user_supplied_bug19", 1, (test_callback_fn
)user_supplied_bug19
},
5875 {"user_supplied_bug20", 1, (test_callback_fn
)user_supplied_bug20
},
5876 {"user_supplied_bug21", 1, (test_callback_fn
)user_supplied_bug21
},
5877 {"wrong_failure_counter_test", 1, (test_callback_fn
)wrong_failure_counter_test
},
5878 {0, 0, (test_callback_fn
)0}
5881 test_st replication_tests
[]= {
5882 {"set", 1, (test_callback_fn
)replication_set_test
},
5883 {"get", 0, (test_callback_fn
)replication_get_test
},
5884 {"mget", 0, (test_callback_fn
)replication_mget_test
},
5885 {"delete", 0, (test_callback_fn
)replication_delete_test
},
5886 {"rand_mget", 0, (test_callback_fn
)replication_randomize_mget_test
},
5887 {0, 0, (test_callback_fn
)0}
5891 * The following test suite is used to verify that we don't introduce
5892 * regression bugs. If you want more information about the bug / test,
5893 * you should look in the bug report at
5894 * http://bugs.launchpad.net/libmemcached
5896 test_st regression_tests
[]= {
5897 {"lp:434484", 1, (test_callback_fn
)regression_bug_434484
},
5898 {"lp:434843", 1, (test_callback_fn
)regression_bug_434843
},
5899 {"lp:434843 buffered", 1, (test_callback_fn
)regression_bug_434843_buffered
},
5900 {"lp:421108", 1, (test_callback_fn
)regression_bug_421108
},
5901 {"lp:442914", 1, (test_callback_fn
)regression_bug_442914
},
5902 {"lp:447342", 1, (test_callback_fn
)regression_bug_447342
},
5903 {"lp:463297", 1, (test_callback_fn
)regression_bug_463297
},
5904 {"lp:490486", 1, (test_callback_fn
)regression_bug_490486
},
5905 {0, 0, (test_callback_fn
)0}
5908 test_st ketama_compatibility
[]= {
5909 {"libmemcached", 1, (test_callback_fn
)ketama_compatibility_libmemcached
},
5910 {"spymemcached", 1, (test_callback_fn
)ketama_compatibility_spymemcached
},
5911 {0, 0, (test_callback_fn
)0}
5914 test_st generate_tests
[] ={
5915 {"generate_pairs", 1, (test_callback_fn
)generate_pairs
},
5916 {"generate_data", 1, (test_callback_fn
)generate_data
},
5917 {"get_read", 0, (test_callback_fn
)get_read
},
5918 {"delete_generate", 0, (test_callback_fn
)delete_generate
},
5919 {"generate_buffer_data", 1, (test_callback_fn
)generate_buffer_data
},
5920 {"delete_buffer", 0, (test_callback_fn
)delete_buffer_generate
},
5921 {"generate_data", 1, (test_callback_fn
)generate_data
},
5922 {"mget_read", 0, (test_callback_fn
)mget_read
},
5923 {"mget_read_result", 0, (test_callback_fn
)mget_read_result
},
5924 {"mget_read_function", 0, (test_callback_fn
)mget_read_function
},
5925 {"cleanup", 1, (test_callback_fn
)cleanup_pairs
},
5926 {"generate_large_pairs", 1, (test_callback_fn
)generate_large_pairs
},
5927 {"generate_data", 1, (test_callback_fn
)generate_data
},
5928 {"generate_buffer_data", 1, (test_callback_fn
)generate_buffer_data
},
5929 {"cleanup", 1, (test_callback_fn
)cleanup_pairs
},
5930 {0, 0, (test_callback_fn
)0}
5933 test_st consistent_tests
[] ={
5934 {"generate_pairs", 1, (test_callback_fn
)generate_pairs
},
5935 {"generate_data", 1, (test_callback_fn
)generate_data
},
5936 {"get_read", 0, (test_callback_fn
)get_read_count
},
5937 {"cleanup", 1, (test_callback_fn
)cleanup_pairs
},
5938 {0, 0, (test_callback_fn
)0}
5941 test_st consistent_weighted_tests
[] ={
5942 {"generate_pairs", 1, (test_callback_fn
)generate_pairs
},
5943 {"generate_data", 1, (test_callback_fn
)generate_data_with_stats
},
5944 {"get_read", 0, (test_callback_fn
)get_read_count
},
5945 {"cleanup", 1, (test_callback_fn
)cleanup_pairs
},
5946 {0, 0, (test_callback_fn
)0}
5949 test_st hsieh_availability
[] ={
5950 {"hsieh_avaibility_test", 0, (test_callback_fn
)hsieh_avaibility_test
},
5951 {0, 0, (test_callback_fn
)0}
5955 test_st hash_sanity
[] ={
5956 {"hash sanity", 0, (test_callback_fn
)hash_sanity_test
},
5957 {0, 0, (test_callback_fn
)0}
5961 test_st ketama_auto_eject_hosts
[] ={
5962 {"auto_eject_hosts", 1, (test_callback_fn
)auto_eject_hosts
},
5963 {"output_ketama_weighted_keys", 1, (test_callback_fn
)output_ketama_weighted_keys
},
5964 {0, 0, (test_callback_fn
)0}
5967 test_st hash_tests
[] ={
5968 {"md5", 0, (test_callback_fn
)md5_run
},
5969 {"crc", 0, (test_callback_fn
)crc_run
},
5970 {"fnv1_64", 0, (test_callback_fn
)fnv1_64_run
},
5971 {"fnv1a_64", 0, (test_callback_fn
)fnv1a_64_run
},
5972 {"fnv1_32", 0, (test_callback_fn
)fnv1_32_run
},
5973 {"fnv1a_32", 0, (test_callback_fn
)fnv1a_32_run
},
5974 {"hsieh", 0, (test_callback_fn
)hsieh_run
},
5975 {"murmur", 0, (test_callback_fn
)murmur_run
},
5976 {"jenkis", 0, (test_callback_fn
)jenkins_run
},
5977 {0, 0, (test_callback_fn
)0}
5980 collection_st collection
[] ={
5982 {"hash_sanity", 0, 0, hash_sanity
},
5984 {"hsieh_availability", 0, 0, hsieh_availability
},
5985 {"udp_setup", (test_callback_fn
)init_udp
, 0, udp_setup_server_tests
},
5986 {"udp_io", (test_callback_fn
)init_udp
, 0, upd_io_tests
},
5987 {"udp_binary_io", (test_callback_fn
)binary_init_udp
, 0, upd_io_tests
},
5988 {"block", 0, 0, tests
},
5989 {"binary", (test_callback_fn
)pre_binary
, 0, tests
},
5990 {"nonblock", (test_callback_fn
)pre_nonblock
, 0, tests
},
5991 {"nodelay", (test_callback_fn
)pre_nodelay
, 0, tests
},
5992 {"settimer", (test_callback_fn
)pre_settimer
, 0, tests
},
5993 {"md5", (test_callback_fn
)pre_md5
, 0, tests
},
5994 {"crc", (test_callback_fn
)pre_crc
, 0, tests
},
5995 {"hsieh", (test_callback_fn
)pre_hsieh
, 0, tests
},
5996 {"jenkins", (test_callback_fn
)pre_jenkins
, 0, tests
},
5997 {"fnv1_64", (test_callback_fn
)pre_hash_fnv1_64
, 0, tests
},
5998 {"fnv1a_64", (test_callback_fn
)pre_hash_fnv1a_64
, 0, tests
},
5999 {"fnv1_32", (test_callback_fn
)pre_hash_fnv1_32
, 0, tests
},
6000 {"fnv1a_32", (test_callback_fn
)pre_hash_fnv1a_32
, 0, tests
},
6001 {"ketama", (test_callback_fn
)pre_behavior_ketama
, 0, tests
},
6002 {"ketama_auto_eject_hosts", (test_callback_fn
)pre_behavior_ketama
, 0, ketama_auto_eject_hosts
},
6003 {"unix_socket", (test_callback_fn
)pre_unix_socket
, 0, tests
},
6004 {"unix_socket_nodelay", (test_callback_fn
)pre_nodelay
, 0, tests
},
6005 {"poll_timeout", (test_callback_fn
)poll_timeout
, 0, tests
},
6006 {"gets", (test_callback_fn
)enable_cas
, 0, tests
},
6007 {"consistent_crc", (test_callback_fn
)enable_consistent_crc
, 0, tests
},
6008 {"consistent_hsieh", (test_callback_fn
)enable_consistent_hsieh
, 0, tests
},
6009 #ifdef MEMCACHED_ENABLE_DEPRECATED
6010 {"deprecated_memory_allocators", (test_callback_fn
)deprecated_set_memory_alloc
, 0, tests
},
6012 {"memory_allocators", (test_callback_fn
)set_memory_alloc
, 0, tests
},
6013 {"prefix", (test_callback_fn
)set_prefix
, 0, tests
},
6014 {"version_1_2_3", (test_callback_fn
)check_for_1_2_3
, 0, version_1_2_3
},
6015 {"string", 0, 0, string_tests
},
6016 {"result", 0, 0, result_tests
},
6017 {"async", (test_callback_fn
)pre_nonblock
, 0, async_tests
},
6018 {"async_binary", (test_callback_fn
)pre_nonblock_binary
, 0, async_tests
},
6019 {"user", 0, 0, user_tests
},
6020 {"generate", 0, 0, generate_tests
},
6021 {"generate_hsieh", (test_callback_fn
)pre_hsieh
, 0, generate_tests
},
6022 {"generate_ketama", (test_callback_fn
)pre_behavior_ketama
, 0, generate_tests
},
6023 {"generate_hsieh_consistent", (test_callback_fn
)enable_consistent_hsieh
, 0, generate_tests
},
6024 {"generate_md5", (test_callback_fn
)pre_md5
, 0, generate_tests
},
6025 {"generate_murmur", (test_callback_fn
)pre_murmur
, 0, generate_tests
},
6026 {"generate_jenkins", (test_callback_fn
)pre_jenkins
, 0, generate_tests
},
6027 {"generate_nonblock", (test_callback_fn
)pre_nonblock
, 0, generate_tests
},
6028 {"generate_corked", (test_callback_fn
)pre_cork
, 0, generate_tests
},
6029 {"generate_corked_and_nonblock", (test_callback_fn
)pre_cork_and_nonblock
, 0, generate_tests
},
6030 {"consistent_not", 0, 0, consistent_tests
},
6031 {"consistent_ketama", (test_callback_fn
)pre_behavior_ketama
, 0, consistent_tests
},
6032 {"consistent_ketama_weighted", (test_callback_fn
)pre_behavior_ketama_weighted
, 0, consistent_weighted_tests
},
6033 {"ketama_compat", 0, 0, ketama_compatibility
},
6034 {"test_hashes", 0, 0, hash_tests
},
6035 {"replication", (test_callback_fn
)pre_replication
, 0, replication_tests
},
6036 {"replication_noblock", (test_callback_fn
)pre_replication_noblock
, 0, replication_tests
},
6037 {"regression", 0, 0, regression_tests
},
6038 {"behaviors", 0, 0, behavior_tests
},
6042 #define SERVERS_TO_CREATE 5
6044 #include "libmemcached_world.h"
6046 void get_world(world_st
*world
)
6048 world
->collections
= collection
;
6050 world
->create
= (test_callback_create_fn
)world_create
;
6051 world
->destroy
= (test_callback_fn
)world_destroy
;
6053 world
->test
.startup
= (test_callback_fn
)world_test_startup
;
6054 world
->test
.flush
= (test_callback_fn
)world_flush
;
6055 world
->test
.pre_run
= (test_callback_fn
)world_pre_run
;
6056 world
->test
.post_run
= (test_callback_fn
)world_post_run
;
6057 world
->test
.on_error
= (test_callback_error_fn
)world_on_error
;
6059 world
->collection
.startup
= (test_callback_fn
)world_container_startup
;
6060 world
->collection
.shutdown
= (test_callback_fn
)world_container_shutdown
;
6062 world
->runner
= &defualt_libmemcached_runner
;