1 /* libMemcached Functions Test
2 * Copyright (C) 2006-2009 Brian Aker
5 * Use and distribution licensed under the BSD license. See
6 * the COPYING file in the parent directory for full text.
10 Sample test application.
13 #include "libmemcached/common.h"
20 #include <sys/types.h>
26 #include "clients/generator.h"
27 #include "clients/execute.h"
30 #define INT64_MAX LONG_MAX
33 #define INT32_MAX INT_MAX
39 #ifdef HAVE_LIBMEMCACHEDUTIL
41 #include "libmemcached/memcached_util.h"
44 #include "hash_results.h"
46 #define GLOBAL_COUNT 10000
47 #define GLOBAL2_COUNT 100
48 #define SERVERS_TO_CREATE 5
49 static uint32_t global_count
;
51 static pairs_st
*global_pairs
;
52 static const char *global_keys
[GLOBAL_COUNT
];
53 static size_t global_keys_length
[GLOBAL_COUNT
];
55 static test_return_t
init_test(memcached_st
*not_used
__attribute__((unused
)))
59 (void)memcached_create(&memc
);
60 memcached_free(&memc
);
65 static test_return_t
server_list_null_test(memcached_st
*ptr
__attribute__((unused
)))
67 memcached_server_st
*server_list
;
68 memcached_return_t rc
;
70 server_list
= memcached_server_list_append_with_weight(NULL
, NULL
, 0, 0, NULL
);
71 test_true(server_list
== NULL
);
73 server_list
= memcached_server_list_append_with_weight(NULL
, "localhost", 0, 0, NULL
);
74 test_true(server_list
== NULL
);
76 server_list
= memcached_server_list_append_with_weight(NULL
, NULL
, 0, 0, &rc
);
77 test_true(server_list
== NULL
);
82 #define TEST_PORT_COUNT 7
83 in_port_t test_ports
[TEST_PORT_COUNT
];
85 static memcached_return_t
server_display_function(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_true 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_true(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_true(memcached_server_count(local_memc
) == x
+ 1);
112 test_true(memcached_servers_count(memcached_server_list(local_memc
)) == x
+1);
113 test_true(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_true 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_true(local_memc
);
135 rc
= memcached_behavior_set(local_memc
, MEMCACHED_BEHAVIOR_SORT_HOSTS
, 1);
136 test_true(rc
== MEMCACHED_SUCCESS
);
138 rc
= memcached_server_add_with_weight(local_memc
, "MEMCACHED_BEHAVIOR_SORT_HOSTS", 43043, 0);
139 test_true(rc
== MEMCACHED_SUCCESS
);
140 instance
= memcached_server_instance_fetch(local_memc
, 0);
141 test_true(instance
->port
== 43043);
143 rc
= memcached_server_add_with_weight(local_memc
, "MEMCACHED_BEHAVIOR_SORT_HOSTS", 43042, 0);
144 test_true(rc
== MEMCACHED_SUCCESS
);
146 instance
= memcached_server_instance_fetch(local_memc
, 0);
147 test_true(instance
->port
== 43042);
149 instance
= memcached_server_instance_fetch(local_memc
, 1);
150 test_true(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_true in server_display_function */
175 size_t bigger
= 0; /* Prime the value for the test_true 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_true(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_true(memcached_server_count(local_memc
) == x
+1);
188 test_true(memcached_servers_count(memcached_server_list(local_memc
)) == x
+1);
189 test_true(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_true(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_true(memc_clone
);
232 test_true(memc_clone
->call_free
== memc
->call_free
);
233 test_true(memc_clone
->call_malloc
== memc
->call_malloc
);
234 test_true(memc_clone
->call_realloc
== memc
->call_realloc
);
235 test_true(memc_clone
->call_calloc
== memc
->call_calloc
);
236 test_true(memc_clone
->connect_timeout
== memc
->connect_timeout
);
237 test_true(memc_clone
->delete_trigger
== memc
->delete_trigger
);
238 test_true(memc_clone
->distribution
== memc
->distribution
);
239 { // Test all of the flags
240 test_true(memc_clone
->flags
.no_block
== memc
->flags
.no_block
);
241 test_true(memc_clone
->flags
.tcp_nodelay
== memc
->flags
.tcp_nodelay
);
242 test_true(memc_clone
->flags
.reuse_memory
== memc
->flags
.reuse_memory
);
243 test_true(memc_clone
->flags
.use_cache_lookups
== memc
->flags
.use_cache_lookups
);
244 test_true(memc_clone
->flags
.support_cas
== memc
->flags
.support_cas
);
245 test_true(memc_clone
->flags
.buffer_requests
== memc
->flags
.buffer_requests
);
246 test_true(memc_clone
->flags
.use_sort_hosts
== memc
->flags
.use_sort_hosts
);
247 test_true(memc_clone
->flags
.verify_key
== memc
->flags
.verify_key
);
248 test_true(memc_clone
->flags
.ketama_weighted
== memc
->flags
.ketama_weighted
);
249 test_true(memc_clone
->flags
.binary_protocol
== memc
->flags
.binary_protocol
);
250 test_true(memc_clone
->flags
.hash_with_prefix_key
== memc
->flags
.hash_with_prefix_key
);
251 test_true(memc_clone
->flags
.no_reply
== memc
->flags
.no_reply
);
252 test_true(memc_clone
->flags
.use_udp
== memc
->flags
.use_udp
);
253 test_true(memc_clone
->flags
.auto_eject_hosts
== memc
->flags
.auto_eject_hosts
);
254 test_true(memc_clone
->flags
.randomize_replica_read
== memc
->flags
.randomize_replica_read
);
256 test_true(memc_clone
->get_key_failure
== memc
->get_key_failure
);
257 test_true(memc_clone
->hash
== memc
->hash
);
258 test_true(memc_clone
->distribution_hash
== memc
->distribution_hash
);
259 test_true(memc_clone
->io_bytes_watermark
== memc
->io_bytes_watermark
);
260 test_true(memc_clone
->io_msg_watermark
== memc
->io_msg_watermark
);
261 test_true(memc_clone
->io_key_prefetch
== memc
->io_key_prefetch
);
262 test_true(memc_clone
->on_cleanup
== memc
->on_cleanup
);
263 test_true(memc_clone
->on_clone
== memc
->on_clone
);
264 test_true(memc_clone
->poll_timeout
== memc
->poll_timeout
);
265 test_true(memc_clone
->rcv_timeout
== memc
->rcv_timeout
);
266 test_true(memc_clone
->recv_size
== memc
->recv_size
);
267 test_true(memc_clone
->retry_timeout
== memc
->retry_timeout
);
268 test_true(memc_clone
->send_size
== memc
->send_size
);
269 test_true(memc_clone
->server_failure_limit
== memc
->server_failure_limit
);
270 test_true(memc_clone
->snd_timeout
== memc
->snd_timeout
);
271 test_true(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_true(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_true(memc_clone
);
293 memcached_free(memc_clone
);
299 static test_return_t
userdata_test(memcached_st
*memc
)
302 test_true(memcached_set_user_data(memc
, foo
) == NULL
);
303 test_true(memcached_get_user_data(memc
) == foo
);
304 test_true(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_true(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_true(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_true(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_true(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_true(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_true(rc
== MEMCACHED_SUCCESS
);
378 rc
= memcached_append(memc
, key
, strlen(key
),
379 " the", strlen(" the"),
380 (time_t)0, (uint32_t)0);
381 test_true(rc
== MEMCACHED_SUCCESS
);
383 rc
= memcached_append(memc
, key
, strlen(key
),
384 " people", strlen(" people"),
385 (time_t)0, (uint32_t)0);
386 test_true(rc
== MEMCACHED_SUCCESS
);
388 out_value
= memcached_get(memc
, key
, strlen(key
),
389 &value_length
, &flags
, &rc
);
390 test_true(!memcmp(out_value
, "we the people", strlen("we the people")));
391 test_true(strlen("we the people") == value_length
);
392 test_true(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_true(rc
== MEMCACHED_SUCCESS
);
411 rc
= memcached_set(memc
,
414 (time_t)0, (uint32_t)0);
415 test_true(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_true(rc
== MEMCACHED_SUCCESS
);
426 value
= (uint32_t *)memcached_get(memc
, key
, strlen(key
),
427 &value_length
, &flags
, &rc
);
428 test_true((value_length
== (sizeof(uint32_t) * x
)));
429 test_true(rc
== MEMCACHED_SUCCESS
);
431 for (uint32_t counter
= x
, *ptr
= value
; counter
; counter
--)
433 test_true(*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_true(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_true(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_true(results
->cas
);
473 test_true(rc
== MEMCACHED_SUCCESS
);
474 test_true(memcached_result_cas(results
));
476 test_true(!memcmp(value
, "we the people", strlen("we the people")));
477 test_true(strlen("we the people") == value_length
);
478 test_true(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_true(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_true(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_true(rc
== MEMCACHED_SUCCESS
);
518 test_true(memcached_result_cas(results
));
519 test_true(!memcmp(value
, memcached_result_value(results
), value_length
));
520 test_true(strlen(memcached_result_value(results
)) == value_length
);
521 test_true(rc
== MEMCACHED_SUCCESS
);
522 uint64_t cas
= memcached_result_cas(results
);
525 results
= memcached_fetch_result(memc
, &results_obj
, &rc
);
526 test_true(rc
== MEMCACHED_END
);
527 test_true(results
== NULL
);
530 rc
= memcached_cas(memc
, key
, key_length
, value2
, value2_length
, 0, 0, cas
);
531 test_true(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_true(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_true(rc
== MEMCACHED_SUCCESS
);
557 rc
= memcached_set(memc
, key
, strlen(key
),
558 value
, strlen(value
),
559 (time_t)0, (uint32_t)0);
560 test_true(rc
== MEMCACHED_SUCCESS
);
562 rc
= memcached_prepend(memc
, key
, strlen(key
),
563 "the ", strlen("the "),
564 (time_t)0, (uint32_t)0);
565 test_true(rc
== MEMCACHED_SUCCESS
);
567 rc
= memcached_prepend(memc
, key
, strlen(key
),
568 "we ", strlen("we "),
569 (time_t)0, (uint32_t)0);
570 test_true(rc
== MEMCACHED_SUCCESS
);
572 out_value
= memcached_get(memc
, key
, strlen(key
),
573 &value_length
, &flags
, &rc
);
574 test_true(!memcmp(out_value
, "we the people", strlen("we the people")));
575 test_true(strlen("we the people") == value_length
);
576 test_true(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_true(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_true(rc
== MEMCACHED_NOTSTORED
|| rc
== MEMCACHED_STORED
);
611 test_true(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_true(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_true(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_true(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
);
672 rc
= memcached_delete(memc
, key
, strlen(key
), (time_t)0);
673 test_true(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_true(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_true(memc_clone
);
726 rc
= memcached_behavior_set(memc_clone
, MEMCACHED_BEHAVIOR_VERIFY_KEY
, set
);
727 test_true(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_true(rc
== MEMCACHED_BAD_KEY_PROVIDED
);
735 test_true(string_length
== 0);
739 rc
= memcached_behavior_set(memc_clone
, MEMCACHED_BEHAVIOR_VERIFY_KEY
, set
);
740 test_true(rc
== MEMCACHED_SUCCESS
);
741 string
= memcached_get(memc_clone
, key
, strlen(key
),
742 &string_length
, &flags
, &rc
);
743 test_true(rc
== MEMCACHED_NOTFOUND
);
744 test_true(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_true(rc
== MEMCACHED_SUCCESS
);
754 rc
= memcached_mget(memc_clone
, keys
, key_lengths
, 3);
755 test_true(rc
== MEMCACHED_BAD_KEY_PROVIDED
);
757 rc
= memcached_mget_by_key(memc_clone
, "foo daddy", 9, keys
, key_lengths
, 1);
758 test_true(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_true(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_true(rc
== MEMCACHED_NOTFOUND
);
776 test_true(string_length
== 0);
779 string
= memcached_get(memc_clone
, longkey
, max_keylen
+ 1,
780 &string_length
, &flags
, &rc
);
781 test_true(rc
== MEMCACHED_BAD_KEY_PROVIDED
);
782 test_true(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_true(rc
== MEMCACHED_SUCCESS
);
793 string
= memcached_get(memc_clone
, key
, 0,
794 &string_length
, &flags
, &rc
);
795 test_true(rc
== MEMCACHED_BAD_KEY_PROVIDED
);
796 test_true(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_true(rc
== MEMCACHED_NOTFOUND
);
827 test_false(string_length
);
830 rc
= memcached_callback_set(memc
, MEMCACHED_CALLBACK_GET_FAILURE
,
832 test_true(rc
== MEMCACHED_SUCCESS
);
834 string
= memcached_get(memc
, key
, strlen(key
),
835 &string_length
, &flags
, &rc
);
837 test_true(rc
== MEMCACHED_SUCCESS
);
838 test_true(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_true(rc
== MEMCACHED_SUCCESS
);
846 test_true(string_length
== strlen(READ_THROUGH_VALUE
));
847 test_true(!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_true(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_true(rc
== MEMCACHED_BUFFERED
|| rc
== MEMCACHED_NOTFOUND
);
886 string
= memcached_get(memc
, key
, strlen(key
),
887 &string_length
, &flags
, &rc
);
889 test_true(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_true(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
);
910 string
= memcached_get(memc
, key
, strlen(key
),
911 &string_length
, &flags
, &rc
);
914 test_true(rc
== MEMCACHED_SUCCESS
);
915 test_true(string_length
== strlen(value
));
916 test_true(!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_true(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_true(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_true(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
);
995 string
= memcached_get(memc
, key
, strlen(key
),
996 &string_length
, &flags
, &rc
);
998 test_true(rc
== MEMCACHED_SUCCESS
);
1000 test_true(string_length
== value_length
);
1001 test_true(!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_true(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_true(rc
== MEMCACHED_SUCCESS
);
1038 test_true(string_length
== value_length
);
1039 test_true(!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_true(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
);
1073 results
=memcached_fetch_result(memc
, &results_obj
, &rc
);
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_true(rc
== MEMCACHED_SUCCESS
);
1081 char *val
= memcached_get_by_key(memc
, keys
[0], lengths
[0], "yek", 3,
1082 &rlen
, &flags
, &rc
);
1083 test_true(val
== NULL
);
1084 test_true(rc
== MEMCACHED_NOTFOUND
);
1085 val
= memcached_get(memc
, keys
[0], lengths
[0], &rlen
, &flags
, &rc
);
1086 test_true(val
!= NULL
);
1087 test_true(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_true(rc
== MEMCACHED_SUCCESS
);
1110 size_t string_length
;
1113 // retrieve both via mget
1114 rc
= memcached_mget(memc
, keys
, lengths
, 2);
1115 test_true(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_true(rc
== MEMCACHED_SUCCESS
);
1127 if (key_length
== 4)
1129 test_true(string_length
== strlen(values
[val
]));
1130 test_true(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_true(rc
== MEMCACHED_END
);
1139 rc
= memcached_mget(memc
, keys
, lengths
, 1);
1140 test_true(rc
== MEMCACHED_SUCCESS
);
1142 string
= memcached_fetch(memc
, key
, &key_length
, &string_length
, &flags
, &rc
);
1143 test_true(key_length
== lengths
[0]);
1144 test_true(strncmp(keys
[0], key
, key_length
) == 0);
1145 test_true(string_length
== strlen(values
[0]));
1146 test_true(strncmp(values
[0], string
, string_length
) == 0);
1147 test_true(rc
== MEMCACHED_SUCCESS
);
1150 // this should indicate end
1151 string
= memcached_fetch(memc
, key
, &key_length
, &string_length
, &flags
, &rc
);
1152 test_true(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_true(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
);
1184 rc
= memcached_increment(memc
, key
, strlen(key
),
1186 test_true(rc
== MEMCACHED_SUCCESS
);
1187 test_true(new_number
== 1);
1189 rc
= memcached_increment(memc
, key
, strlen(key
),
1191 test_true(rc
== MEMCACHED_SUCCESS
);
1192 test_true(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_true(rc
== MEMCACHED_SUCCESS
);
1209 test_true(new_number
== initial
);
1211 rc
= memcached_increment_with_initial(memc
, key
, strlen(key
),
1212 1, initial
, 0, &new_number
);
1213 test_true(rc
== MEMCACHED_SUCCESS
);
1214 test_true(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_true(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
);
1231 rc
= memcached_decrement(memc
, key
, strlen(key
),
1233 test_true(rc
== MEMCACHED_SUCCESS
);
1234 test_true(new_number
== 2);
1236 rc
= memcached_decrement(memc
, key
, strlen(key
),
1238 test_true(rc
== MEMCACHED_SUCCESS
);
1239 test_true(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_true(rc
== MEMCACHED_SUCCESS
);
1256 test_true(new_number
== initial
);
1258 rc
= memcached_decrement_with_initial(memc
, key
, strlen(key
),
1259 1, initial
, 0, &new_number
);
1260 test_true(rc
== MEMCACHED_SUCCESS
);
1261 test_true(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_true(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
);
1280 rc
= memcached_increment_by_key(memc
, master_key
, strlen(master_key
), key
, strlen(key
),
1282 test_true(rc
== MEMCACHED_SUCCESS
);
1283 test_true(new_number
== 1);
1285 rc
= memcached_increment_by_key(memc
, master_key
, strlen(master_key
), key
, strlen(key
),
1287 test_true(rc
== MEMCACHED_SUCCESS
);
1288 test_true(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_true(rc
== MEMCACHED_SUCCESS
);
1307 test_true(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_true(rc
== MEMCACHED_SUCCESS
);
1313 test_true(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_true(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
);
1332 rc
= memcached_decrement_by_key(memc
, master_key
, strlen(master_key
),
1335 test_true(rc
== MEMCACHED_SUCCESS
);
1336 test_true(new_number
== 2);
1338 rc
= memcached_decrement_by_key(memc
, master_key
, strlen(master_key
),
1341 test_true(rc
== MEMCACHED_SUCCESS
);
1342 test_true(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_true(rc
== MEMCACHED_SUCCESS
);
1361 test_true(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_true(rc
== MEMCACHED_SUCCESS
);
1367 test_true(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_true(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_true(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
);
1404 test_true(&results_obj
== results
);
1406 /* We need to empty the server before continueing test */
1407 rc
= memcached_flush(memc
, 0);
1408 test_true(rc
== MEMCACHED_SUCCESS
);
1410 rc
= memcached_mget(memc
, keys
, key_length
, 3);
1411 test_true(rc
== MEMCACHED_SUCCESS
);
1413 while ((results
= memcached_fetch_result(memc
, &results_obj
, &rc
)) != NULL
)
1418 while ((results
= memcached_fetch_result(memc
, &results_obj
, &rc
)) != NULL
)
1419 test_true(!results
);
1420 test_true(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_true(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
);
1430 rc
= memcached_mget(memc
, keys
, key_length
, 3);
1431 test_true(rc
== MEMCACHED_SUCCESS
);
1433 while ((results
= memcached_fetch_result(memc
, &results_obj
, &rc
)))
1436 test_true(&results_obj
== results
);
1437 test_true(rc
== MEMCACHED_SUCCESS
);
1438 test_true(memcached_result_key_length(results
) == memcached_result_length(results
));
1439 test_true(!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_true(rc
== MEMCACHED_SUCCESS
);
1462 rc
= memcached_mget(memc
, keys
, key_length
, 3);
1463 test_true(rc
== MEMCACHED_SUCCESS
);
1465 while ((results
= memcached_fetch_result(memc
, NULL
, &rc
)) != NULL
)
1469 test_true(!results
);
1470 test_true(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_true(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
);
1480 rc
= memcached_mget(memc
, keys
, key_length
, 3);
1481 test_true(rc
== MEMCACHED_SUCCESS
);
1484 while ((results
= memcached_fetch_result(memc
, NULL
, &rc
)))
1487 test_true(rc
== MEMCACHED_SUCCESS
);
1488 test_true(memcached_result_key_length(results
) == memcached_result_length(results
));
1489 test_true(!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_true(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
);
1530 rc
= memcached_mget(memc
, keys
, key_length
, 3);
1531 test_true(rc
== MEMCACHED_SUCCESS
);
1533 callbacks
[0]= &callback_counter
;
1535 rc
= memcached_fetch_execute(memc
, callbacks
, (void *)&counter
, 1);
1537 test_true(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_true(rc
== MEMCACHED_SUCCESS
);
1559 rc
= memcached_mget(memc
, keys
, key_length
, 3);
1560 test_true(rc
== MEMCACHED_SUCCESS
);
1562 while ((return_value
= memcached_fetch(memc
, return_key
, &return_key_length
,
1563 &return_value_length
, &flags
, &rc
)) != NULL
)
1565 test_true(return_value
);
1567 test_true(!return_value
);
1568 test_true(return_value_length
== 0);
1569 test_true(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_true(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
);
1579 rc
= memcached_mget(memc
, keys
, key_length
, 3);
1580 test_true(rc
== MEMCACHED_SUCCESS
);
1583 while ((return_value
= memcached_fetch(memc
, return_key
, &return_key_length
,
1584 &return_value_length
, &flags
, &rc
)))
1586 test_true(return_value
);
1587 test_true(rc
== MEMCACHED_SUCCESS
);
1588 test_true(return_key_length
== return_value_length
);
1589 test_true(!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_true(keys
[x
] != NULL
);
1627 rc
= memcached_add(memc
, keys
[x
], key_length
[x
], blob
, sizeof(blob
), 0, 0);
1628 test_true(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_true(rc
== MEMCACHED_SUCCESS
);
1641 rc
= memcached_fetch_execute(memc
, callbacks
, (void *)&counter
, 1);
1642 test_true(rc
== MEMCACHED_END
);
1644 /* Verify that we got all of the items */
1645 test_true(counter
== max_keys
);
1649 test_true(rc
== MEMCACHED_NOT_SUPPORTED
);
1650 test_true(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_true(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_true(!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_true(rc
== MEMCACHED_SUCCESS
);
1704 test_true(rc
== MEMCACHED_SUCCESS
);
1705 test_true(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_true(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
);
1730 test_true(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_true(rc
== MEMCACHED_SUCCESS
);
1740 test_true(x
== memcached_server_list_count(servers
));
1743 rc
= memcached_server_push(memc
, servers
);
1744 test_true(rc
== MEMCACHED_SUCCESS
);
1745 rc
= memcached_server_push(memc
, servers
);
1746 test_true(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_true(rc
== MEMCACHED_SUCCESS
);
1773 test_ptr
= (int *)memcached_callback_get(memc
, MEMCACHED_CALLBACK_USER_DATA
, &rc
);
1774 test_true(*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_true(rc
== MEMCACHED_SUCCESS
);
1787 temp_function
= memcached_callback_get(memc
, MEMCACHED_CALLBACK_CLONE_FUNCTION
, &rc
);
1788 test_true(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_true(rc
== MEMCACHED_SUCCESS
);
1802 temp_function
= memcached_callback_get(memc
, MEMCACHED_CALLBACK_CLONE_FUNCTION
, &rc
);
1803 test_true(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_true(value
== 1);
1819 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_TCP_NODELAY
, set
);
1820 value
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_TCP_NODELAY
);
1821 test_true(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_true(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_true(value
== 0);
1834 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_TCP_NODELAY
, set
);
1835 value
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_TCP_NODELAY
);
1836 test_true(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_true(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_true(value
== MEMCACHED_HASH_CRC
);
1848 value
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_SOCKET_SEND_SIZE
);
1849 test_true(value
> 0);
1851 value
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_SOCKET_RECV_SIZE
);
1852 test_true(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_true((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
);
1868 test_true(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_NOT_SUPPORTED
);
1870 value
= (bool)memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_CORK
);
1872 if (rc
== MEMCACHED_SUCCESS
)
1874 test_true((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_true(return_value
);
1897 test_true(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_true(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_true(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_true(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_true(rc
== MEMCACHED_SUCCESS
);
2039 test_true(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_true(rc
== MEMCACHED_NO_SERVERS
);
2069 rc
= memcached_mget(memc
, keys
, key_length
, 3);
2070 test_true(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_true(return_value
);
2077 test_true(!return_value
);
2078 test_true(return_value_length
== 0);
2079 test_true(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_true(rc
== MEMCACHED_NO_SERVERS
);
2089 rc
= memcached_mget(memc
, keys
, key_length
, 3);
2090 test_true(rc
== MEMCACHED_NO_SERVERS
);
2093 while ((return_value
= memcached_fetch(memc
, return_key
, &return_key_length
,
2094 &return_value_length
, &flags
, &rc
)))
2096 test_true(return_value
);
2097 test_true(rc
== MEMCACHED_SUCCESS
);
2098 test_true(return_key_length
== return_value_length
);
2099 test_true(!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_true(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_true(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_true(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_true(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_true(value
== NULL
);
2187 test_true(rc
== MEMCACHED_NOTFOUND
);
2188 rc
= memcached_mget(memc
, keys
, key_length
, 4);
2189 test_true(rc
== MEMCACHED_SUCCESS
);
2192 while ((value
= memcached_fetch(memc
, return_key
, &return_key_length
,
2193 &value_length
, &flags
, &rc
)))
2195 test_true(count
== 0);
2196 test_true(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_true(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_true(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_true(rc
== MEMCACHED_SUCCESS
);
2222 test_true(!(memcmp(value
, insert_data
, value_length
)));
2223 test_true(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
);
2243 mine
= memcached_create(NULL
);
2244 rc
= memcached_server_push(mine
, servers
);
2245 test_true(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_true(rc
== MEMCACHED_SUCCESS
);
2287 value
= memcached_get(memc
, keys
, key_length
,
2288 &value_length
, &flags
, &rc
);
2289 test_true(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_true(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_true(rc
== MEMCACHED_SUCCESS
);
2334 rc
= memcached_mget(memc
, keys
, key_length
, 3);
2335 test_true(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_true(return_value
);
2345 test_true(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_true(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_true(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_true(value
== NULL
);
2446 test_true(rc
== MEMCACHED_NOTFOUND
);
2448 rc
= memcached_increment(memc
, "autoincrement", strlen("autoincrement"),
2451 test_true(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_true(rc
== MEMCACHED_SUCCESS
);
2459 test_true(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_true(rc
== MEMCACHED_SUCCESS
);
2470 rc
= memcached_increment(memc
, "autoincrement", strlen("autoincrement"),
2472 test_true(number_value
== 2);
2473 test_true(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_true(overflow
!= NULL
);
2503 memset(overflow
, 'x', testSize
);
2504 rc
= memcached_set(memc
, key
, strlen(key
),
2505 overflow
, testSize
, 0, 0);
2506 test_true(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_true(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
);
2547 string
= memcached_get(memc
, key
, strlen(key
),
2548 &string_length
, &flags
, &rc
);
2550 test_true(rc
== MEMCACHED_SUCCESS
);
2551 test_true(string_length
== current_length
);
2552 test_true(!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_true(rc
== MEMCACHED_SUCCESS
);
2582 value
= memcached_get(memc
, key
, strlen(key
),
2583 &length
, &flags
, &rc
);
2585 test_true(rc
== MEMCACHED_SUCCESS
);
2586 test_true(value
== NULL
);
2587 test_true(length
== 0);
2588 test_true(flags
== 0);
2590 value
= memcached_get(memc
, key
, strlen(key
),
2591 &length
, &flags
, &rc
);
2593 test_true(rc
== MEMCACHED_SUCCESS
);
2594 test_true(value
== NULL
);
2595 test_true(length
== 0);
2596 test_true(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_true(rc
== MEMCACHED_SUCCESS
);
2617 value
= memcached_get(memc
, key
, strlen(key
),
2618 &length
, &flags
, &rc
);
2620 test_true(rc
== MEMCACHED_SUCCESS
);
2621 test_true(value
== NULL
);
2622 test_true(length
== 0);
2623 test_true(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_true(rc
== MEMCACHED_SUCCESS
);
2645 value2
= memcached_get(memc
, key
, strlen(key
),
2646 &length
, &flags
, &rc
);
2648 test_true(length
==strlen(value
));
2649 test_true(rc
== MEMCACHED_SUCCESS
);
2650 test_true(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_true(status
== MEMCACHED_SUCCESS
);
2696 status
= memcached_mget(memc
, &key
, &key_len
, 1);
2697 test_true(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_true(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_true(rc
== MEMCACHED_SUCCESS
);
2730 value
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_KETAMA_WEIGHTED
);
2731 test_true(value
== 1);
2733 rc
= memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_KETAMA_HASH
, MEMCACHED_HASH_MD5
);
2734 test_true(rc
== MEMCACHED_SUCCESS
);
2736 value
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_KETAMA_HASH
);
2737 test_true(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_true(memcached_server_count(memc
) == 8);
2744 test_true(strcmp(server_pool
[0].hostname
, "10.0.1.1") == 0);
2745 test_true(server_pool
[0].port
== 11211);
2746 test_true(server_pool
[0].weight
== 600);
2747 test_true(strcmp(server_pool
[2].hostname
, "10.0.1.3") == 0);
2748 test_true(server_pool
[2].port
== 11211);
2749 test_true(server_pool
[2].weight
== 200);
2750 test_true(strcmp(server_pool
[7].hostname
, "10.0.1.8") == 0);
2751 test_true(server_pool
[7].port
== 11211);
2752 test_true(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_true(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_true(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_true(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_true(rc
== MEMCACHED_SUCCESS
);
2827 signal(SIGALRM
, oldalarm
);
2829 test_true(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_true(rc
== TEST_SUCCESS
);
2857 /* should fail as of r580 */
2858 rc
= _user_supplied_bug21(memc
, 1000);
2859 test_true(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_true(rc
== MEMCACHED_SUCCESS
);
2876 uint64_t value
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_KETAMA_WEIGHTED
);
2877 test_true(value
== 1);
2879 rc
= memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_KETAMA_HASH
, MEMCACHED_HASH_MD5
);
2880 test_true(rc
== MEMCACHED_SUCCESS
);
2882 value
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_KETAMA_HASH
);
2883 test_true(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_true(rc
== MEMCACHED_SUCCESS
);
2889 value
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_AUTO_EJECT_HOSTS
);
2890 test_true(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_true(memcached_server_count(memc
) == 8);
2898 test_true(strcmp(server_pool
[0].hostname
, "10.0.1.1") == 0);
2899 test_true(server_pool
[0].port
== 11211);
2900 test_true(server_pool
[0].weight
== 600);
2901 test_true(strcmp(server_pool
[2].hostname
, "10.0.1.3") == 0);
2902 test_true(server_pool
[2].port
== 11211);
2903 test_true(server_pool
[2].weight
== 200);
2904 test_true(strcmp(server_pool
[7].hostname
, "10.0.1.8") == 0);
2905 test_true(server_pool
[7].port
== 11211);
2906 test_true(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_true(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_true(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_true(rc
== MEMCACHED_SUCCESS
);
2951 uint64_t value
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_KETAMA_WEIGHTED
);
2952 test_true(value
== 1);
2954 rc
= memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_KETAMA_HASH
, MEMCACHED_HASH_MD5
);
2955 test_true(rc
== MEMCACHED_SUCCESS
);
2957 value
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_KETAMA_HASH
);
2958 test_true(value
== MEMCACHED_HASH_MD5
);
2961 test_true(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_true(result
.options
.is_allocated
== false);
3004 test_true(memcached_is_initialized(&result
) == true);
3005 test_true(result_ptr
);
3006 test_true(result_ptr
== &result
);
3008 memcached_result_free(&result
);
3010 test_true(result
.options
.is_allocated
== false);
3011 test_true(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_true(result_ptr
);
3022 test_true(result_ptr
->options
.is_allocated
== true);
3023 test_true(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_true(string
.options
.is_initialized
== true);
3036 test_true(string_ptr
);
3038 /* The following two better be the same! */
3039 test_true(memcached_is_allocated(string_ptr
) == false);
3040 test_true(memcached_is_allocated(&string
) == false);
3041 test_true(&string
== string_ptr
);
3043 test_true(string
.options
.is_initialized
== true);
3044 test_true(memcached_is_initialized(&string
) == true);
3045 memcached_string_free(&string
);
3046 test_true(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_true(memcached_is_allocated(string
) == true);
3058 test_true(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_true(memcached_is_allocated(string
) == true);
3071 test_true(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_true(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_true(memcached_is_allocated(string
) == true);
3099 test_true(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_true(rc
== MEMCACHED_SUCCESS
);
3107 test_true(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_true(memcached_is_allocated(string
) == true);
3126 test_true(memcached_is_initialized(string
) == true);
3128 for (x
= 0; x
< 1024; x
++)
3130 rc
= memcached_string_append(string
, buffer
, SMALL_STRING_LEN
);
3131 test_true(rc
== MEMCACHED_SUCCESS
);
3133 rc
= memcached_string_append(string
, buffer
, SIZE_MAX
);
3134 test_true(rc
== MEMCACHED_MEMORY_ALLOCATION_FAILURE
);
3135 test_true(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_true((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_true(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_true(return_value);
3270 test_true(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_true(rc
== MEMCACHED_SUCCESS
);
3286 test_true(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_true(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
)))
3307 test_true(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_true(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
);
3365 test_true(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_true(rc
== MEMCACHED_SUCCESS
);
3375 test_true(x
== memcached_server_list_count(servers
));
3378 rc
= memcached_server_push(memc
, servers
);
3379 test_true(rc
== MEMCACHED_SUCCESS
);
3380 rc
= memcached_server_push(memc
, servers
);
3381 test_true(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_true(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_true(rc
== MEMCACHED_SUCCESS
);
3438 test_true(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_true(rc
== MEMCACHED_SUCCESS
);
3526 value
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_KETAMA
);
3527 test_true(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_true(rc
== MEMCACHED_SUCCESS
);
3540 value
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_KETAMA_WEIGHTED
);
3541 test_true(value
== 1);
3543 rc
= memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_KETAMA_HASH
, MEMCACHED_HASH_MD5
);
3544 test_true(rc
== MEMCACHED_SUCCESS
);
3546 value
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_KETAMA_HASH
);
3547 test_true(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_true(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_true(rc
== MEMCACHED_SUCCESS
);
3573 test_true(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_true(rc
== MEMCACHED_SUCCESS
);
3598 test_true(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_true(rc
== MEMCACHED_FAILURE
);
3695 /* Test a clean set */
3696 rc
= memcached_callback_set(memc
, MEMCACHED_CALLBACK_PREFIX_KEY
, (void *)key
);
3697 test_true(rc
== MEMCACHED_SUCCESS
);
3699 value
= memcached_callback_get(memc
, MEMCACHED_CALLBACK_PREFIX_KEY
, &rc
);
3700 test_true(memcmp(value
, key
, 4) == 0);
3701 test_true(rc
== MEMCACHED_SUCCESS
);
3703 /* Test that we can turn it off */
3704 rc
= memcached_callback_set(memc
, MEMCACHED_CALLBACK_PREFIX_KEY
, NULL
);
3705 test_true(rc
== MEMCACHED_SUCCESS
);
3707 value
= memcached_callback_get(memc
, MEMCACHED_CALLBACK_PREFIX_KEY
, &rc
);
3708 test_true(rc
== MEMCACHED_FAILURE
);
3710 /* Now setup for main test */
3711 rc
= memcached_callback_set(memc
, MEMCACHED_CALLBACK_PREFIX_KEY
, (void *)key
);
3712 test_true(rc
== MEMCACHED_SUCCESS
);
3714 value
= memcached_callback_get(memc
, MEMCACHED_CALLBACK_PREFIX_KEY
, &rc
);
3715 test_true(rc
== MEMCACHED_SUCCESS
);
3716 test_true(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_true(rc
== MEMCACHED_SUCCESS
);
3726 value
= memcached_callback_get(memc
, MEMCACHED_CALLBACK_PREFIX_KEY
, &rc
);
3727 test_true(rc
== MEMCACHED_FAILURE
);
3728 test_true(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_true(rc == MEMCACHED_BAD_KEY_PROVIDED);
3735 test_true(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_true(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_true(rc
== MEMCACHED_SUCCESS
);
3746 strcpy(long_key
, "dog cat");
3747 rc
= memcached_callback_set(memc
, MEMCACHED_CALLBACK_PREFIX_KEY
, long_key
);
3748 test_true(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_true(rc
== MEMCACHED_SUCCESS
);
3768 test_ptr
= memcached_callback_get(memc
, MEMCACHED_CALLBACK_MALLOC_FUNCTION
, &rc
);
3769 test_true(rc
== MEMCACHED_SUCCESS
);
3770 test_true(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_true(rc
== MEMCACHED_SUCCESS
);
3781 test_ptr
= memcached_callback_get(memc
, MEMCACHED_CALLBACK_REALLOC_FUNCTION
, &rc
);
3782 test_true(rc
== MEMCACHED_SUCCESS
);
3783 test_true(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_true(rc
== MEMCACHED_SUCCESS
);
3794 test_ptr
= memcached_callback_get(memc
, MEMCACHED_CALLBACK_FREE_FUNCTION
, &rc
);
3795 test_true(rc
== MEMCACHED_SUCCESS
);
3796 test_true(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_true(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_true(mem_malloc
== my_malloc
);
3822 test_true(mem_realloc
== my_realloc
);
3823 test_true(mem_calloc
== my_calloc
);
3824 test_true(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_true(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_true(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_true(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_true(ret
== MEMCACHED_SUCCESS
);
3954 ret
= memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_BUFFER_REQUESTS
, 1);
3955 test_true(ret
== MEMCACHED_SUCCESS
);
3956 ret
= memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_SUPPORT_CAS
, 1);
3957 test_true(ret
== MEMCACHED_SUCCESS
);
3958 test_true(memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_NOREPLY
) == 1);
3959 test_true(memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_BUFFER_REQUESTS
) == 1);
3960 test_true(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_true(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_true(no_msg
== 0);
4006 test_true(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_true(ret
== MEMCACHED_SUCCESS
&& value
!= NULL
);
4023 case 0: /* FALLTHROUGH */
4024 case 1: /* FALLTHROUGH */
4026 test_true(strncmp(value
, key
, len
) == 0);
4027 test_true(len
== length
);
4030 test_true(length
== len
* 2);
4033 test_true(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_true(ret
== MEMCACHED_SUCCESS
);
4055 results
= memcached_result_create(memc
, &results_obj
);
4057 results
= memcached_fetch_result(memc
, &results_obj
, &ret
);
4059 test_true(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_true(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_true(ret
== MEMCACHED_SUCCESS
);
4072 test_true(memcached_flush_buffers(memc
) == MEMCACHED_SUCCESS
);
4073 char* value
=memcached_get(memc
, keys
[0], lengths
[0], &length
, &flags
, &ret
);
4074 test_true(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_true(rc
== MEMCACHED_SUCCESS
);
4088 test_true(memc_stat
);
4090 report
= memcached_analyze(memc
, memc_stat
, &rc
);
4091 test_true(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_true (main_rc
== TEST_SUCCESS
);
4130 rc
= memcached_dump(memc
, callbacks
, (void *)&counter
, 1);
4131 test_true(rc
== MEMCACHED_SUCCESS
);
4133 /* We may have more then 32 if our previous flush has not completed */
4134 test_true(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_true(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_true(mmc
[x
] != NULL
);
4163 test_true(rc
== MEMCACHED_SUCCESS
);
4166 test_true(memcached_pool_pop(pool
, false, &rc
) == NULL
);
4167 test_true(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_true(rc
== MEMCACHED_SUCCESS
);
4177 pthread_join(tid
, NULL
);
4178 test_true(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_true(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_true(rc
== MEMCACHED_SUCCESS
);
4191 test_true(number_value
== (x
+1));
4195 for (size_t x
= 0; x
< 10; ++x
)
4197 test_true(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_true(mmc
[0] != NULL
);
4208 rc
= memcached_pool_behavior_set(pool
, MEMCACHED_BEHAVIOR_IO_MSG_WATERMARK
, 9999);
4209 test_true(rc
== MEMCACHED_SUCCESS
);
4211 mmc
[1]= memcached_pool_pop(pool
, false, &rc
);
4212 test_true(mmc
[1] != NULL
);
4214 test_true(memcached_behavior_get(mmc
[1], MEMCACHED_BEHAVIOR_IO_MSG_WATERMARK
) == 9999);
4215 test_true(memcached_pool_push(pool
, mmc
[1]) == MEMCACHED_SUCCESS
);
4216 test_true(memcached_pool_push(pool
, mmc
[0]) == MEMCACHED_SUCCESS
);
4218 mmc
[0]= memcached_pool_pop(pool
, false, &rc
);
4219 test_true(memcached_behavior_get(mmc
[0], MEMCACHED_BEHAVIOR_IO_MSG_WATERMARK
) == 9999);
4220 test_true(memcached_pool_push(pool
, mmc
[0]) == MEMCACHED_SUCCESS
);
4223 test_true(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_true(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_true(rc
== MEMCACHED_SUCCESS
);
4266 test_true(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_true(rc
== MEMCACHED_SUCCESS
);
4300 test_true(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_true(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_true(rc
== MEMCACHED_SUCCESS
);
4360 memcached_result_st
*results
= memcached_result_create(new_clone
, &result_obj
);
4364 while ((results
= memcached_fetch_result(new_clone
, &result_obj
, &rc
)) != NULL
)
4368 test_true(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_true(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_true(rc
== MEMCACHED_SUCCESS
);
4406 memcached_result_st
*results
= memcached_result_create(memc_clone
, &result_obj
);
4410 while ((results
= memcached_fetch_result(memc_clone
, &result_obj
, &rc
)) != NULL
)
4414 test_true(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_true(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_true(rc
== MEMCACHED_SUCCESS
);
4465 memcached_result_st
*results
= memcached_result_create(memc_clone
, &result_obj
);
4469 while ((results
= memcached_fetch_result(memc_clone
, &result_obj
, &rc
)) != NULL
)
4473 test_true(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_true(cur_server
[x
].cursor_active
== 0);
4513 test_true(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_true(memcached_server_add_udp(memc
, servers
[x
].hostname
, servers
[x
].port
) == MEMCACHED_SUCCESS
);
4555 test_true(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_true(memcached_server_remove(&(memc
->hosts
[0])) == MEMCACHED_SUCCESS
);
4582 test_true(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_true(memcached_server_remove(&(memc
->hosts
[0])) == MEMCACHED_SUCCESS
);
4598 memcached_st tcp_client
;
4599 memcached_create(&tcp_client
);
4600 test_true(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_true(memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_USE_UDP
, 1) == MEMCACHED_SUCCESS
);
4613 test_true(memc
->flags
.use_udp
);
4614 test_true(memc
->flags
.no_reply
);
4616 test_true(memcached_server_count(memc
) == 0);
4618 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_USE_UDP
,0);
4619 test_true(! (memc
->flags
.use_udp
));
4620 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NOREPLY
,0);
4621 test_true(! (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_true(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_true(instance
->write_buffer_offset
== UDP_DATAGRAM_HEADER_LENGTH
);
4659 test_true(instance
->write_buffer_offset
!= UDP_DATAGRAM_HEADER_LENGTH
);
4660 test_true(instance
->write_buffer_offset
<= MAX_UDP_DATAGRAM_LENGTH
);
4662 test_true(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_true(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_true(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_true(instance
->write_buffer_offset
== UDP_DATAGRAM_HEADER_LENGTH
);
4712 test_true(instance
->write_buffer_offset
!= UDP_DATAGRAM_HEADER_LENGTH
);
4713 test_true(instance
->write_buffer_offset
<= MAX_UDP_DATAGRAM_LENGTH
);
4715 test_true(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_true(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_true(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_true(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_true(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_true(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_true(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_true(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_true(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_true(rc
== MEMCACHED_NOT_SUPPORTED
);
4831 test_true(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_true(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_true(rc
== expected_rc
);
4899 return TEST_SUCCESS
;
4902 static test_return_t
md5_run (memcached_st
*memc
__attribute__((unused
)))
4907 for (ptr
= list_to_hash
, x
= 0; *ptr
; ptr
++, x
++)
4911 hash_val
= memcached_generate_hash_value(*ptr
, strlen(*ptr
), MEMCACHED_HASH_MD5
);
4912 test_true(md5_values
[x
] == hash_val
);
4915 return TEST_SUCCESS
;
4918 static test_return_t
crc_run (memcached_st
*memc
__attribute__((unused
)))
4923 for (ptr
= list_to_hash
, x
= 0; *ptr
; ptr
++, x
++)
4927 hash_val
= memcached_generate_hash_value(*ptr
, strlen(*ptr
), MEMCACHED_HASH_CRC
);
4928 test_true(crc_values
[x
] == hash_val
);
4931 return TEST_SUCCESS
;
4934 static test_return_t
fnv1_64_run (memcached_st
*memc
__attribute__((unused
)))
4939 for (ptr
= list_to_hash
, x
= 0; *ptr
; ptr
++, x
++)
4943 hash_val
= memcached_generate_hash_value(*ptr
, strlen(*ptr
), MEMCACHED_HASH_FNV1_64
);
4944 test_true(fnv1_64_values
[x
] == hash_val
);
4947 return TEST_SUCCESS
;
4950 static test_return_t
fnv1a_64_run (memcached_st
*memc
__attribute__((unused
)))
4955 for (ptr
= list_to_hash
, x
= 0; *ptr
; ptr
++, x
++)
4959 hash_val
= memcached_generate_hash_value(*ptr
, strlen(*ptr
), MEMCACHED_HASH_FNV1A_64
);
4960 test_true(fnv1a_64_values
[x
] == hash_val
);
4963 return TEST_SUCCESS
;
4966 static test_return_t
fnv1_32_run (memcached_st
*memc
__attribute__((unused
)))
4972 for (ptr
= list_to_hash
, x
= 0; *ptr
; ptr
++, x
++)
4976 hash_val
= memcached_generate_hash_value(*ptr
, strlen(*ptr
), MEMCACHED_HASH_FNV1_32
);
4977 test_true(fnv1_32_values
[x
] == hash_val
);
4980 return TEST_SUCCESS
;
4983 static test_return_t
fnv1a_32_run (memcached_st
*memc
__attribute__((unused
)))
4988 for (ptr
= list_to_hash
, x
= 0; *ptr
; ptr
++, x
++)
4992 hash_val
= memcached_generate_hash_value(*ptr
, strlen(*ptr
), MEMCACHED_HASH_FNV1A_32
);
4993 test_true(fnv1a_32_values
[x
] == hash_val
);
4996 return TEST_SUCCESS
;
4999 static test_return_t
hsieh_run (memcached_st
*memc
__attribute__((unused
)))
5004 for (ptr
= list_to_hash
, x
= 0; *ptr
; ptr
++, x
++)
5008 hash_val
= memcached_generate_hash_value(*ptr
, strlen(*ptr
), MEMCACHED_HASH_HSIEH
);
5009 test_true(hsieh_values
[x
] == hash_val
);
5012 return TEST_SUCCESS
;
5015 static test_return_t
murmur_run (memcached_st
*memc
__attribute__((unused
)))
5018 return TEST_SKIPPED
;
5023 for (ptr
= list_to_hash
, x
= 0; *ptr
; ptr
++, x
++)
5027 hash_val
= memcached_generate_hash_value(*ptr
, strlen(*ptr
), MEMCACHED_HASH_MURMUR
);
5028 test_true(murmur_values
[x
] == hash_val
);
5031 return TEST_SUCCESS
;
5035 static test_return_t
jenkins_run (memcached_st
*memc
__attribute__((unused
)))
5041 for (ptr
= list_to_hash
, x
= 0; *ptr
; ptr
++, x
++)
5045 hash_val
= memcached_generate_hash_value(*ptr
, strlen(*ptr
), MEMCACHED_HASH_JENKINS
);
5046 test_true(jenkins_values
[x
] == hash_val
);
5049 return TEST_SUCCESS
;
5053 static test_return_t
ketama_compatibility_libmemcached(memcached_st
*trash
)
5055 memcached_return_t rc
;
5058 memcached_server_st
*server_pool
;
5063 memc
= memcached_create(NULL
);
5066 rc
= memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_KETAMA_WEIGHTED
, 1);
5067 test_true(rc
== MEMCACHED_SUCCESS
);
5069 value
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_KETAMA_WEIGHTED
);
5070 test_true(value
== 1);
5072 test_true(memcached_behavior_set_distribution(memc
, MEMCACHED_DISTRIBUTION_CONSISTENT_KETAMA
) == MEMCACHED_SUCCESS
);
5073 test_true(memcached_behavior_get_distribution(memc
) == MEMCACHED_DISTRIBUTION_CONSISTENT_KETAMA
);
5076 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");
5077 memcached_server_push(memc
, server_pool
);
5079 /* verify that the server list was parsed okay. */
5080 test_true(memcached_server_count(memc
) == 8);
5081 test_strcmp(server_pool
[0].hostname
, "10.0.1.1");
5082 test_true(server_pool
[0].port
== 11211);
5083 test_true(server_pool
[0].weight
== 600);
5084 test_strcmp(server_pool
[2].hostname
, "10.0.1.3");
5085 test_true(server_pool
[2].port
== 11211);
5086 test_true(server_pool
[2].weight
== 200);
5087 test_strcmp(server_pool
[7].hostname
, "10.0.1.8");
5088 test_true(server_pool
[7].port
== 11211);
5089 test_true(server_pool
[7].weight
== 100);
5091 /* VDEAAAAA hashes to fffcd1b5, after the last continuum point, and lets
5092 * us test the boundary wraparound.
5094 test_true(memcached_generate_hash(memc
, (char *)"VDEAAAAA", 8) == memc
->continuum
[0].index
);
5096 /* verify the standard ketama set. */
5097 for (x
= 0; x
< 99; x
++)
5099 uint32_t server_idx
= memcached_generate_hash(memc
, ketama_test_cases
[x
].key
, strlen(ketama_test_cases
[x
].key
));
5100 memcached_server_instance_st
*instance
=
5101 memcached_server_instance_fetch(memc
, server_idx
);
5102 char *hostname
= instance
->hostname
;
5104 test_strcmp(hostname
, ketama_test_cases
[x
].server
);
5107 memcached_server_list_free(server_pool
);
5108 memcached_free(memc
);
5110 return TEST_SUCCESS
;
5113 static test_return_t
ketama_compatibility_spymemcached(memcached_st
*trash
)
5115 memcached_return_t rc
;
5118 memcached_server_st
*server_pool
;
5123 memc
= memcached_create(NULL
);
5126 rc
= memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_KETAMA_WEIGHTED
, 1);
5127 test_true(rc
== MEMCACHED_SUCCESS
);
5129 value
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_KETAMA_WEIGHTED
);
5130 test_true(value
== 1);
5132 test_true(memcached_behavior_set_distribution(memc
, MEMCACHED_DISTRIBUTION_CONSISTENT_KETAMA_SPY
) == MEMCACHED_SUCCESS
);
5133 test_true(memcached_behavior_get_distribution(memc
) == MEMCACHED_DISTRIBUTION_CONSISTENT_KETAMA_SPY
);
5135 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");
5136 memcached_server_push(memc
, server_pool
);
5138 /* verify that the server list was parsed okay. */
5139 test_true(memcached_server_count(memc
) == 8);
5140 test_strcmp(server_pool
[0].hostname
, "10.0.1.1");
5141 test_true(server_pool
[0].port
== 11211);
5142 test_true(server_pool
[0].weight
== 600);
5143 test_strcmp(server_pool
[2].hostname
, "10.0.1.3");
5144 test_true(server_pool
[2].port
== 11211);
5145 test_true(server_pool
[2].weight
== 200);
5146 test_strcmp(server_pool
[7].hostname
, "10.0.1.8");
5147 test_true(server_pool
[7].port
== 11211);
5148 test_true(server_pool
[7].weight
== 100);
5150 /* VDEAAAAA hashes to fffcd1b5, after the last continuum point, and lets
5151 * us test the boundary wraparound.
5153 test_true(memcached_generate_hash(memc
, (char *)"VDEAAAAA", 8) == memc
->continuum
[0].index
);
5155 /* verify the standard ketama set. */
5156 for (x
= 0; x
< 99; x
++)
5158 uint32_t server_idx
= memcached_generate_hash(memc
, ketama_test_cases_spy
[x
].key
, strlen(ketama_test_cases_spy
[x
].key
));
5159 memcached_server_instance_st
*instance
=
5160 memcached_server_instance_fetch(memc
, server_idx
);
5161 char *hostname
= instance
->hostname
;
5162 test_strcmp(hostname
, ketama_test_cases_spy
[x
].server
);
5165 memcached_server_list_free(server_pool
);
5166 memcached_free(memc
);
5168 return TEST_SUCCESS
;
5171 static test_return_t
regression_bug_434484(memcached_st
*memc
)
5173 test_return_t test_rc
;
5174 test_rc
= pre_binary(memc
);
5176 if (test_rc
!= TEST_SUCCESS
)
5179 memcached_return_t ret
;
5180 const char *key
= "regression_bug_434484";
5181 size_t keylen
= strlen(key
);
5183 ret
= memcached_append(memc
, key
, keylen
, key
, keylen
, 0, 0);
5184 test_true(ret
== MEMCACHED_NOTSTORED
);
5186 size_t size
= 2048 * 1024;
5187 void *data
= calloc(1, size
);
5188 test_true(data
!= NULL
);
5189 ret
= memcached_set(memc
, key
, keylen
, data
, size
, 0, 0);
5190 test_true(ret
== MEMCACHED_E2BIG
);
5193 return TEST_SUCCESS
;
5196 static test_return_t
regression_bug_434843(memcached_st
*memc
)
5198 test_return_t test_rc
;
5199 test_rc
= pre_binary(memc
);
5201 if (test_rc
!= TEST_SUCCESS
)
5204 memcached_return_t rc
;
5206 memcached_execute_fn callbacks
[1]= { [0]= &callback_counter
};
5209 * I only want to hit only _one_ server so I know the number of requests I'm
5210 * sending in the pipleine to the server. Let's try to do a multiget of
5211 * 1024 (that should satisfy most users don't you think?). Future versions
5212 * will include a mget_execute function call if you need a higher number.
5214 uint32_t number_of_hosts
= memcached_server_count(memc
);
5215 memc
->number_of_hosts
= 1;
5216 const size_t max_keys
= 1024;
5217 char **keys
= calloc(max_keys
, sizeof(char*));
5218 size_t *key_length
=calloc(max_keys
, sizeof(size_t));
5220 for (size_t x
= 0; x
< max_keys
; ++x
)
5224 key_length
[x
]= (size_t)snprintf(k
, sizeof(k
), "0200%zu", x
);
5226 test_true(keys
[x
] != NULL
);
5230 * Run two times.. the first time we should have 100% cache miss,
5231 * and the second time we should have 100% cache hits
5233 for (size_t y
= 0; y
< 2; y
++)
5235 rc
= memcached_mget(memc
, (const char**)keys
, key_length
, max_keys
);
5236 test_true(rc
== MEMCACHED_SUCCESS
);
5237 rc
= memcached_fetch_execute(memc
, callbacks
, (void *)&counter
, 1);
5241 /* The first iteration should give me a 100% cache miss. verify that*/
5242 char blob
[1024]= { 0 };
5244 test_true(counter
== 0);
5246 for (size_t x
= 0; x
< max_keys
; ++x
)
5248 rc
= memcached_add(memc
, keys
[x
], key_length
[x
],
5249 blob
, sizeof(blob
), 0, 0);
5250 test_true(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
);
5255 /* Verify that we received all of the key/value pairs */
5256 test_true(counter
== max_keys
);
5260 /* Release allocated resources */
5261 for (size_t x
= 0; x
< max_keys
; ++x
)
5268 memc
->number_of_hosts
= number_of_hosts
;
5270 return TEST_SUCCESS
;
5273 static test_return_t
regression_bug_434843_buffered(memcached_st
*memc
)
5275 memcached_return_t rc
;
5276 rc
= memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_BUFFER_REQUESTS
, 1);
5277 test_true(rc
== MEMCACHED_SUCCESS
);
5279 return regression_bug_434843(memc
);
5282 static test_return_t
regression_bug_421108(memcached_st
*memc
)
5284 memcached_return_t rc
;
5285 memcached_stat_st
*memc_stat
= memcached_stat(memc
, NULL
, &rc
);
5286 test_true(rc
== MEMCACHED_SUCCESS
);
5288 char *bytes
= memcached_stat_get_value(memc
, memc_stat
, "bytes", &rc
);
5289 test_true(rc
== MEMCACHED_SUCCESS
);
5290 test_true(bytes
!= NULL
);
5291 char *bytes_read
= memcached_stat_get_value(memc
, memc_stat
,
5293 test_true(rc
== MEMCACHED_SUCCESS
);
5294 test_true(bytes_read
!= NULL
);
5296 char *bytes_written
= memcached_stat_get_value(memc
, memc_stat
,
5297 "bytes_written", &rc
);
5298 test_true(rc
== MEMCACHED_SUCCESS
);
5299 test_true(bytes_written
!= NULL
);
5301 test_true(strcmp(bytes
, bytes_read
) != 0);
5302 test_true(strcmp(bytes
, bytes_written
) != 0);
5304 /* Release allocated resources */
5307 free(bytes_written
);
5308 memcached_stat_free(NULL
, memc_stat
);
5310 return TEST_SUCCESS
;
5314 * The test case isn't obvious so I should probably document why
5315 * it works the way it does. Bug 442914 was caused by a bug
5316 * in the logic in memcached_purge (it did not handle the case
5317 * where the number of bytes sent was equal to the watermark).
5318 * In this test case, create messages so that we hit that case
5319 * and then disable noreply mode and issue a new command to
5320 * verify that it isn't stuck. If we change the format for the
5321 * delete command or the watermarks, we need to update this
5324 static test_return_t
regression_bug_442914(memcached_st
*memc
)
5326 memcached_return_t rc
;
5327 rc
= memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NOREPLY
, 1);
5328 test_true(rc
== MEMCACHED_SUCCESS
);
5329 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_TCP_NODELAY
, 1);
5331 uint32_t number_of_hosts
= memcached_server_count(memc
);
5332 memc
->number_of_hosts
= 1;
5337 for (uint32_t x
= 0; x
< 250; ++x
)
5339 len
= (size_t)snprintf(k
, sizeof(k
), "%0250u", x
);
5340 rc
= memcached_delete(memc
, k
, len
, 0);
5341 test_true(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
);
5344 (void)snprintf(k
, sizeof(k
), "%037u", 251U);
5347 rc
= memcached_delete(memc
, k
, len
, 0);
5348 test_true(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
);
5350 rc
= memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NOREPLY
, 0);
5351 test_true(rc
== MEMCACHED_SUCCESS
);
5352 rc
= memcached_delete(memc
, k
, len
, 0);
5353 test_true(rc
== MEMCACHED_NOTFOUND
);
5355 memc
->number_of_hosts
= number_of_hosts
;
5357 return TEST_SUCCESS
;
5360 static test_return_t
regression_bug_447342(memcached_st
*memc
)
5362 memcached_server_instance_st
*instance_one
;
5363 memcached_server_instance_st
*instance_two
;
5365 if (memcached_server_count(memc
) < 3 || pre_replication(memc
) != MEMCACHED_SUCCESS
)
5366 return TEST_SKIPPED
;
5368 memcached_return_t rc
;
5370 rc
= memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NUMBER_OF_REPLICAS
, 2);
5371 test_true(rc
== MEMCACHED_SUCCESS
);
5373 const size_t max_keys
= 100;
5374 char **keys
= calloc(max_keys
, sizeof(char*));
5375 size_t *key_length
= calloc(max_keys
, sizeof(size_t));
5377 for (size_t x
= 0; x
< max_keys
; ++x
)
5381 key_length
[x
]= (size_t)snprintf(k
, sizeof(k
), "0200%zu", x
);
5383 test_true(keys
[x
] != NULL
);
5384 rc
= memcached_set(memc
, k
, key_length
[x
], k
, key_length
[x
], 0, 0);
5385 test_true(rc
== MEMCACHED_SUCCESS
);
5389 ** We are using the quiet commands to store the replicas, so we need
5390 ** to ensure that all of them are processed before we can continue.
5391 ** In the test we go directly from storing the object to trying to
5392 ** receive the object from all of the different servers, so we
5393 ** could end up in a race condition (the memcached server hasn't yet
5394 ** processed the quiet command from the replication set when it process
5395 ** the request from the other client (created by the clone)). As a
5396 ** workaround for that we call memcached_quit to send the quit command
5397 ** to the server and wait for the response ;-) If you use the test code
5398 ** as an example for your own code, please note that you shouldn't need
5401 memcached_quit(memc
);
5403 /* Verify that all messages are stored, and we didn't stuff too much
5406 rc
= memcached_mget(memc
, (const char* const *)keys
, key_length
, max_keys
);
5407 test_true(rc
== MEMCACHED_SUCCESS
);
5410 memcached_execute_fn callbacks
[1]= { [0]= &callback_counter
};
5411 rc
= memcached_fetch_execute(memc
, callbacks
, (void *)&counter
, 1);
5412 /* Verify that we received all of the key/value pairs */
5413 test_true(counter
== max_keys
);
5415 memcached_quit(memc
);
5417 * Don't do the following in your code. I am abusing the internal details
5418 * within the library, and this is not a supported interface.
5419 * This is to verify correct behavior in the library. Fake that two servers
5422 instance_one
= memcached_server_instance_fetch(memc
, 0);
5423 instance_two
= memcached_server_instance_fetch(memc
, 2);
5424 in_port_t port0
= instance_one
->port
;
5425 in_port_t port2
= instance_two
->port
;
5427 instance_one
->port
= 0;
5428 instance_two
->port
= 0;
5430 rc
= memcached_mget(memc
, (const char* const *)keys
, key_length
, max_keys
);
5431 test_true(rc
== MEMCACHED_SUCCESS
);
5434 rc
= memcached_fetch_execute(memc
, callbacks
, (void *)&counter
, 1);
5435 test_true(counter
== (unsigned int)max_keys
);
5437 /* restore the memc handle */
5438 instance_one
->port
= port0
;
5439 instance_two
->port
= port2
;
5441 memcached_quit(memc
);
5443 /* Remove half of the objects */
5444 for (size_t x
= 0; x
< max_keys
; ++x
)
5448 rc
= memcached_delete(memc
, keys
[x
], key_length
[x
], 0);
5449 test_true(rc
== MEMCACHED_SUCCESS
);
5453 memcached_quit(memc
);
5454 instance_one
->port
= 0;
5455 instance_two
->port
= 0;
5457 /* now retry the command, this time we should have cache misses */
5458 rc
= memcached_mget(memc
, (const char* const *)keys
, key_length
, max_keys
);
5459 test_true(rc
== MEMCACHED_SUCCESS
);
5462 rc
= memcached_fetch_execute(memc
, callbacks
, (void *)&counter
, 1);
5463 test_true(counter
== (unsigned int)(max_keys
>> 1));
5465 /* Release allocated resources */
5466 for (size_t x
= 0; x
< max_keys
; ++x
)
5473 /* restore the memc handle */
5474 instance_one
->port
= port0
;
5475 instance_two
->port
= port2
;
5477 return TEST_SUCCESS
;
5480 static test_return_t
regression_bug_463297(memcached_st
*memc
)
5482 memcached_st
*memc_clone
= memcached_clone(NULL
, memc
);
5483 test_true(memc_clone
!= NULL
);
5484 test_true(memcached_version(memc_clone
) == MEMCACHED_SUCCESS
);
5486 memcached_server_instance_st
*instance
=
5487 memcached_server_instance_fetch(memc_clone
, 0);
5489 if (instance
->major_version
> 1 ||
5490 (instance
->major_version
== 1 &&
5491 instance
->minor_version
> 2))
5493 /* Binary protocol doesn't support deferred delete */
5494 memcached_st
*bin_clone
= memcached_clone(NULL
, memc
);
5495 test_true(bin_clone
!= NULL
);
5496 test_true(memcached_behavior_set(bin_clone
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
, 1) == MEMCACHED_SUCCESS
);
5497 test_true(memcached_delete(bin_clone
, "foo", 3, 1) == MEMCACHED_INVALID_ARGUMENTS
);
5498 memcached_free(bin_clone
);
5500 memcached_quit(memc_clone
);
5502 /* If we know the server version, deferred delete should fail
5503 * with invalid arguments */
5504 test_true(memcached_delete(memc_clone
, "foo", 3, 1) == MEMCACHED_INVALID_ARGUMENTS
);
5506 /* If we don't know the server version, we should get a protocol error */
5507 memcached_return_t rc
= memcached_delete(memc
, "foo", 3, 1);
5509 /* but there is a bug in some of the memcached servers (1.4) that treats
5510 * the counter as noreply so it doesn't send the proper error message
5512 test_true(rc
== MEMCACHED_PROTOCOL_ERROR
|| rc
== MEMCACHED_NOTFOUND
|| rc
== MEMCACHED_CLIENT_ERROR
);
5514 /* And buffered mode should be disabled and we should get protocol error */
5515 test_true(memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_BUFFER_REQUESTS
, 1) == MEMCACHED_SUCCESS
);
5516 rc
= memcached_delete(memc
, "foo", 3, 1);
5517 test_true(rc
== MEMCACHED_PROTOCOL_ERROR
|| rc
== MEMCACHED_NOTFOUND
|| rc
== MEMCACHED_CLIENT_ERROR
);
5519 /* Same goes for noreply... */
5520 test_true(memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NOREPLY
, 1) == MEMCACHED_SUCCESS
);
5521 rc
= memcached_delete(memc
, "foo", 3, 1);
5522 test_true(rc
== MEMCACHED_PROTOCOL_ERROR
|| rc
== MEMCACHED_NOTFOUND
|| rc
== MEMCACHED_CLIENT_ERROR
);
5524 /* but a normal request should go through (and be buffered) */
5525 test_true((rc
= memcached_delete(memc
, "foo", 3, 0)) == MEMCACHED_BUFFERED
);
5526 test_true(memcached_flush_buffers(memc
) == MEMCACHED_SUCCESS
);
5528 test_true(memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_BUFFER_REQUESTS
, 0) == MEMCACHED_SUCCESS
);
5529 /* unbuffered noreply should be success */
5530 test_true(memcached_delete(memc
, "foo", 3, 0) == MEMCACHED_SUCCESS
);
5531 /* unbuffered with reply should be not found... */
5532 test_true(memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NOREPLY
, 0) == MEMCACHED_SUCCESS
);
5533 test_true(memcached_delete(memc
, "foo", 3, 0) == MEMCACHED_NOTFOUND
);
5536 memcached_free(memc_clone
);
5537 return TEST_SUCCESS
;
5541 /* Test memcached_server_get_last_disconnect
5542 * For a working server set, shall be NULL
5543 * For a set of non existing server, shall not be NULL
5545 static test_return_t
test_get_last_disconnect(memcached_st
*memc
)
5547 memcached_return_t rc
;
5548 memcached_server_st
*disconnected_server
;
5550 /* With the working set of server */
5551 const char *key
= "marmotte";
5552 const char *value
= "milka";
5554 rc
= memcached_set(memc
, key
, strlen(key
),
5555 value
, strlen(value
),
5556 (time_t)0, (uint32_t)0);
5557 test_true(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
);
5559 disconnected_server
= memcached_server_get_last_disconnect(memc
);
5560 test_true(disconnected_server
== NULL
);
5562 /* With a non existing server */
5564 memcached_server_st
*servers
;
5566 const char *server_list
= "localhost:9";
5568 servers
= memcached_servers_parse(server_list
);
5570 mine
= memcached_create(NULL
);
5571 rc
= memcached_server_push(mine
, servers
);
5572 test_true(rc
== MEMCACHED_SUCCESS
);
5573 memcached_server_list_free(servers
);
5576 rc
= memcached_set(mine
, key
, strlen(key
),
5577 value
, strlen(value
),
5578 (time_t)0, (uint32_t)0);
5579 test_true(rc
!= MEMCACHED_SUCCESS
);
5581 disconnected_server
= memcached_server_get_last_disconnect(mine
);
5582 test_true(disconnected_server
!= NULL
);
5583 test_true(disconnected_server
->port
== 9);
5584 test_true(strncmp(disconnected_server
->hostname
,"localhost",9) == 0);
5586 memcached_quit(mine
);
5587 memcached_free(mine
);
5589 return TEST_SUCCESS
;
5593 * This test ensures that the failure counter isn't incremented during
5594 * normal termination of the memcached instance.
5596 static test_return_t
wrong_failure_counter_test(memcached_st
*memc
)
5598 memcached_return_t rc
;
5599 memcached_server_instance_st
*instance
;
5601 /* Set value to force connection to the server */
5602 const char *key
= "marmotte";
5603 const char *value
= "milka";
5606 * Please note that I'm abusing the internal structures in libmemcached
5607 * in a non-portable way and you shouldn't be doing this. I'm only
5608 * doing this in order to verify that the library works the way it should
5610 uint32_t number_of_hosts
= memcached_server_count(memc
);
5611 memc
->number_of_hosts
= 1;
5613 /* Ensure that we are connected to the server by setting a value */
5614 rc
= memcached_set(memc
, key
, strlen(key
),
5615 value
, strlen(value
),
5616 (time_t)0, (uint32_t)0);
5617 test_true(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
);
5620 instance
= memcached_server_instance_fetch(memc
, 0);
5621 /* The test is to see that the memcached_quit doesn't increase the
5622 * the server failure conter, so let's ensure that it is zero
5623 * before sending quit
5625 instance
->server_failure_counter
= 0;
5627 memcached_quit(memc
);
5629 /* Verify that it memcached_quit didn't increment the failure counter
5630 * Please note that this isn't bullet proof, because an error could
5633 test_true(instance
->server_failure_counter
== 0);
5635 /* restore the instance */
5636 memc
->number_of_hosts
= number_of_hosts
;
5638 return TEST_SUCCESS
;
5645 * Test that ensures mget_execute does not end into recursive calls that finally fails
5647 static test_return_t
regression_bug_490486(memcached_st
*memc
)
5649 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
, 1);
5650 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NO_BLOCK
, 1);
5651 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_POLL_TIMEOUT
, 1000);
5652 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_SERVER_FAILURE_LIMIT
, 1);
5653 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_RETRY_TIMEOUT
, 3600);
5656 * I only want to hit _one_ server so I know the number of requests I'm
5657 * sending in the pipeline.
5659 uint32_t number_of_hosts
= memc
->number_of_hosts
;
5660 memc
->number_of_hosts
= 1;
5661 size_t max_keys
= 20480;
5664 char **keys
= calloc(max_keys
, sizeof(char*));
5665 size_t *key_length
=calloc(max_keys
, sizeof(size_t));
5667 /* First add all of the items.. */
5668 char blob
[1024]= { 0 };
5669 memcached_return rc
;
5670 for (size_t x
= 0; x
< max_keys
; ++x
)
5673 key_length
[x
]= (size_t)snprintf(k
, sizeof(k
), "0200%zu", x
);
5675 assert(keys
[x
] != NULL
);
5676 rc
= memcached_set(memc
, keys
[x
], key_length
[x
], blob
, sizeof(blob
), 0, 0);
5677 assert(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
);
5680 /* Try to get all of them with a large multiget */
5682 memcached_execute_function callbacks
[1]= { [0]= &callback_counter
};
5683 rc
= memcached_mget_execute(memc
, (const char**)keys
, key_length
,
5684 (size_t)max_keys
, callbacks
, &counter
, 1);
5686 assert(rc
== MEMCACHED_SUCCESS
);
5687 char* the_value
= NULL
;
5688 char the_key
[MEMCACHED_MAX_KEY
];
5689 size_t the_key_length
;
5690 size_t the_value_length
;
5694 the_value
= memcached_fetch(memc
, the_key
, &the_key_length
, &the_value_length
, &the_flags
, &rc
);
5696 if ((the_value
!= NULL
) && (rc
== MEMCACHED_SUCCESS
))
5702 } while ( (the_value
!= NULL
) && (rc
== MEMCACHED_SUCCESS
));
5705 assert(rc
== MEMCACHED_END
);
5707 /* Verify that we got all of the items */
5708 assert(counter
== max_keys
);
5710 /* Release all allocated resources */
5711 for (size_t x
= 0; x
< max_keys
; ++x
)
5718 memc
->number_of_hosts
= number_of_hosts
;
5720 return TEST_SUCCESS
;
5726 test_st udp_setup_server_tests
[] ={
5727 {"set_udp_behavior_test", 0, (test_callback_fn
)set_udp_behavior_test
},
5728 {"add_tcp_server_udp_client_test", 0, (test_callback_fn
)add_tcp_server_udp_client_test
},
5729 {"add_udp_server_tcp_client_test", 0, (test_callback_fn
)add_udp_server_tcp_client_test
},
5733 test_st upd_io_tests
[] ={
5734 {"udp_set_test", 0, (test_callback_fn
)udp_set_test
},
5735 {"udp_buffered_set_test", 0, (test_callback_fn
)udp_buffered_set_test
},
5736 {"udp_set_too_big_test", 0, (test_callback_fn
)udp_set_too_big_test
},
5737 {"udp_delete_test", 0, (test_callback_fn
)udp_delete_test
},
5738 {"udp_buffered_delete_test", 0, (test_callback_fn
)udp_buffered_delete_test
},
5739 {"udp_verbosity_test", 0, (test_callback_fn
)udp_verbosity_test
},
5740 {"udp_quit_test", 0, (test_callback_fn
)udp_quit_test
},
5741 {"udp_flush_test", 0, (test_callback_fn
)udp_flush_test
},
5742 {"udp_incr_test", 0, (test_callback_fn
)udp_incr_test
},
5743 {"udp_decr_test", 0, (test_callback_fn
)udp_decr_test
},
5744 {"udp_stat_test", 0, (test_callback_fn
)udp_stat_test
},
5745 {"udp_version_test", 0, (test_callback_fn
)udp_version_test
},
5746 {"udp_get_test", 0, (test_callback_fn
)udp_get_test
},
5747 {"udp_mixed_io_test", 0, (test_callback_fn
)udp_mixed_io_test
},
5751 /* Clean the server before beginning testing */
5753 {"flush", 0, (test_callback_fn
)flush_test
},
5754 {"init", 0, (test_callback_fn
)init_test
},
5755 {"allocation", 0, (test_callback_fn
)allocation_test
},
5756 {"server_list_null_test", 0, (test_callback_fn
)server_list_null_test
},
5757 {"server_unsort", 0, (test_callback_fn
)server_unsort_test
},
5758 {"server_sort", 0, (test_callback_fn
)server_sort_test
},
5759 {"server_sort2", 0, (test_callback_fn
)server_sort2_test
},
5760 {"clone_test", 0, (test_callback_fn
)clone_test
},
5761 {"connection_test", 0, (test_callback_fn
)connection_test
},
5762 {"callback_test", 0, (test_callback_fn
)callback_test
},
5763 {"userdata_test", 0, (test_callback_fn
)userdata_test
},
5764 {"error", 0, (test_callback_fn
)error_test
},
5765 {"set", 0, (test_callback_fn
)set_test
},
5766 {"set2", 0, (test_callback_fn
)set_test2
},
5767 {"set3", 0, (test_callback_fn
)set_test3
},
5768 {"dump", 1, (test_callback_fn
)dump_test
},
5769 {"add", 1, (test_callback_fn
)add_test
},
5770 {"replace", 1, (test_callback_fn
)replace_test
},
5771 {"delete", 1, (test_callback_fn
)delete_test
},
5772 {"get", 1, (test_callback_fn
)get_test
},
5773 {"get2", 0, (test_callback_fn
)get_test2
},
5774 {"get3", 0, (test_callback_fn
)get_test3
},
5775 {"get4", 0, (test_callback_fn
)get_test4
},
5776 {"partial mget", 0, (test_callback_fn
)get_test5
},
5777 {"stats_servername", 0, (test_callback_fn
)stats_servername_test
},
5778 {"increment", 0, (test_callback_fn
)increment_test
},
5779 {"increment_with_initial", 1, (test_callback_fn
)increment_with_initial_test
},
5780 {"decrement", 0, (test_callback_fn
)decrement_test
},
5781 {"decrement_with_initial", 1, (test_callback_fn
)decrement_with_initial_test
},
5782 {"increment_by_key", 0, (test_callback_fn
)increment_by_key_test
},
5783 {"increment_with_initial_by_key", 1, (test_callback_fn
)increment_with_initial_by_key_test
},
5784 {"decrement_by_key", 0, (test_callback_fn
)decrement_by_key_test
},
5785 {"decrement_with_initial_by_key", 1, (test_callback_fn
)decrement_with_initial_by_key_test
},
5786 {"quit", 0, (test_callback_fn
)quit_test
},
5787 {"mget", 1, (test_callback_fn
)mget_test
},
5788 {"mget_result", 1, (test_callback_fn
)mget_result_test
},
5789 {"mget_result_alloc", 1, (test_callback_fn
)mget_result_alloc_test
},
5790 {"mget_result_function", 1, (test_callback_fn
)mget_result_function
},
5791 {"mget_execute", 1, (test_callback_fn
)mget_execute
},
5792 {"mget_end", 0, (test_callback_fn
)mget_end
},
5793 {"get_stats", 0, (test_callback_fn
)get_stats
},
5794 {"add_host_test", 0, (test_callback_fn
)add_host_test
},
5795 {"add_host_test_1", 0, (test_callback_fn
)add_host_test1
},
5796 {"get_stats_keys", 0, (test_callback_fn
)get_stats_keys
},
5797 {"version_string_test", 0, (test_callback_fn
)version_string_test
},
5798 {"bad_key", 1, (test_callback_fn
)bad_key_test
},
5799 {"memcached_server_cursor", 1, (test_callback_fn
)memcached_server_cursor_test
},
5800 {"read_through", 1, (test_callback_fn
)read_through
},
5801 {"delete_through", 1, (test_callback_fn
)delete_through
},
5802 {"noreply", 1, (test_callback_fn
)noreply_test
},
5803 {"analyzer", 1, (test_callback_fn
)analyzer_test
},
5804 #ifdef HAVE_LIBMEMCACHEDUTIL
5805 {"connectionpool", 1, (test_callback_fn
)connection_pool_test
},
5807 {"test_get_last_disconnect", 1, (test_callback_fn
)test_get_last_disconnect
},
5811 test_st behavior_tests
[] ={
5812 {"behavior_test", 0, (test_callback_fn
)behavior_test
},
5813 {"MEMCACHED_BEHAVIOR_CORK", 0, (test_callback_fn
)MEMCACHED_BEHAVIOR_CORK_test
},
5817 test_st async_tests
[] ={
5818 {"add", 1, (test_callback_fn
)add_wrapper
},
5822 test_st string_tests
[] ={
5823 {"string static with null", 0, (test_callback_fn
)string_static_null
},
5824 {"string alloc with null", 0, (test_callback_fn
)string_alloc_null
},
5825 {"string alloc with 1K", 0, (test_callback_fn
)string_alloc_with_size
},
5826 {"string alloc with malloc failure", 0, (test_callback_fn
)string_alloc_with_size_toobig
},
5827 {"string append", 0, (test_callback_fn
)string_alloc_append
},
5828 {"string append failure (too big)", 0, (test_callback_fn
)string_alloc_append_toobig
},
5829 {0, 0, (test_callback_fn
)0}
5832 test_st result_tests
[] ={
5833 {"result static", 0, (test_callback_fn
)result_static
},
5834 {"result alloc", 0, (test_callback_fn
)result_alloc
},
5835 {0, 0, (test_callback_fn
)0}
5838 test_st version_1_2_3
[] ={
5839 {"append", 0, (test_callback_fn
)append_test
},
5840 {"prepend", 0, (test_callback_fn
)prepend_test
},
5841 {"cas", 0, (test_callback_fn
)cas_test
},
5842 {"cas2", 0, (test_callback_fn
)cas2_test
},
5843 {"append_binary", 0, (test_callback_fn
)append_binary_test
},
5844 {0, 0, (test_callback_fn
)0}
5847 test_st user_tests
[] ={
5848 {"user_supplied_bug1", 0, (test_callback_fn
)user_supplied_bug1
},
5849 {"user_supplied_bug2", 0, (test_callback_fn
)user_supplied_bug2
},
5850 {"user_supplied_bug3", 0, (test_callback_fn
)user_supplied_bug3
},
5851 {"user_supplied_bug4", 0, (test_callback_fn
)user_supplied_bug4
},
5852 {"user_supplied_bug5", 1, (test_callback_fn
)user_supplied_bug5
},
5853 {"user_supplied_bug6", 1, (test_callback_fn
)user_supplied_bug6
},
5854 {"user_supplied_bug7", 1, (test_callback_fn
)user_supplied_bug7
},
5855 {"user_supplied_bug8", 1, (test_callback_fn
)user_supplied_bug8
},
5856 {"user_supplied_bug9", 1, (test_callback_fn
)user_supplied_bug9
},
5857 {"user_supplied_bug10", 1, (test_callback_fn
)user_supplied_bug10
},
5858 {"user_supplied_bug11", 1, (test_callback_fn
)user_supplied_bug11
},
5859 {"user_supplied_bug12", 1, (test_callback_fn
)user_supplied_bug12
},
5860 {"user_supplied_bug13", 1, (test_callback_fn
)user_supplied_bug13
},
5861 {"user_supplied_bug14", 1, (test_callback_fn
)user_supplied_bug14
},
5862 {"user_supplied_bug15", 1, (test_callback_fn
)user_supplied_bug15
},
5863 {"user_supplied_bug16", 1, (test_callback_fn
)user_supplied_bug16
},
5866 ** It seems to be something weird with the character sets..
5867 ** value_fetch is unable to parse the value line (iscntrl "fails"), so I
5868 ** guess I need to find out how this is supposed to work.. Perhaps I need
5869 ** to run the test in a specific locale (I tried zh_CN.UTF-8 without success,
5870 ** so just disable the code for now...).
5872 {"user_supplied_bug17", 1, (test_callback_fn
)user_supplied_bug17
},
5874 {"user_supplied_bug18", 1, (test_callback_fn
)user_supplied_bug18
},
5875 {"user_supplied_bug19", 1, (test_callback_fn
)user_supplied_bug19
},
5876 {"user_supplied_bug20", 1, (test_callback_fn
)user_supplied_bug20
},
5877 {"user_supplied_bug21", 1, (test_callback_fn
)user_supplied_bug21
},
5878 {"wrong_failure_counter_test", 1, (test_callback_fn
)wrong_failure_counter_test
},
5879 {0, 0, (test_callback_fn
)0}
5882 test_st replication_tests
[]= {
5883 {"set", 1, (test_callback_fn
)replication_set_test
},
5884 {"get", 0, (test_callback_fn
)replication_get_test
},
5885 {"mget", 0, (test_callback_fn
)replication_mget_test
},
5886 {"delete", 0, (test_callback_fn
)replication_delete_test
},
5887 {"rand_mget", 0, (test_callback_fn
)replication_randomize_mget_test
},
5888 {0, 0, (test_callback_fn
)0}
5892 * The following test suite is used to verify that we don't introduce
5893 * regression bugs. If you want more information about the bug / test,
5894 * you should look in the bug report at
5895 * http://bugs.launchpad.net/libmemcached
5897 test_st regression_tests
[]= {
5898 {"lp:434484", 1, (test_callback_fn
)regression_bug_434484
},
5899 {"lp:434843", 1, (test_callback_fn
)regression_bug_434843
},
5900 {"lp:434843 buffered", 1, (test_callback_fn
)regression_bug_434843_buffered
},
5901 {"lp:421108", 1, (test_callback_fn
)regression_bug_421108
},
5902 {"lp:442914", 1, (test_callback_fn
)regression_bug_442914
},
5903 {"lp:447342", 1, (test_callback_fn
)regression_bug_447342
},
5904 {"lp:463297", 1, (test_callback_fn
)regression_bug_463297
},
5905 {"lp:490486", 1, (test_callback_fn
)regression_bug_490486
},
5906 {0, 0, (test_callback_fn
)0}
5909 test_st ketama_compatibility
[]= {
5910 {"libmemcached", 1, (test_callback_fn
)ketama_compatibility_libmemcached
},
5911 {"spymemcached", 1, (test_callback_fn
)ketama_compatibility_spymemcached
},
5912 {0, 0, (test_callback_fn
)0}
5915 test_st generate_tests
[] ={
5916 {"generate_pairs", 1, (test_callback_fn
)generate_pairs
},
5917 {"generate_data", 1, (test_callback_fn
)generate_data
},
5918 {"get_read", 0, (test_callback_fn
)get_read
},
5919 {"delete_generate", 0, (test_callback_fn
)delete_generate
},
5920 {"generate_buffer_data", 1, (test_callback_fn
)generate_buffer_data
},
5921 {"delete_buffer", 0, (test_callback_fn
)delete_buffer_generate
},
5922 {"generate_data", 1, (test_callback_fn
)generate_data
},
5923 {"mget_read", 0, (test_callback_fn
)mget_read
},
5924 {"mget_read_result", 0, (test_callback_fn
)mget_read_result
},
5925 {"mget_read_function", 0, (test_callback_fn
)mget_read_function
},
5926 {"cleanup", 1, (test_callback_fn
)cleanup_pairs
},
5927 {"generate_large_pairs", 1, (test_callback_fn
)generate_large_pairs
},
5928 {"generate_data", 1, (test_callback_fn
)generate_data
},
5929 {"generate_buffer_data", 1, (test_callback_fn
)generate_buffer_data
},
5930 {"cleanup", 1, (test_callback_fn
)cleanup_pairs
},
5931 {0, 0, (test_callback_fn
)0}
5934 test_st consistent_tests
[] ={
5935 {"generate_pairs", 1, (test_callback_fn
)generate_pairs
},
5936 {"generate_data", 1, (test_callback_fn
)generate_data
},
5937 {"get_read", 0, (test_callback_fn
)get_read_count
},
5938 {"cleanup", 1, (test_callback_fn
)cleanup_pairs
},
5939 {0, 0, (test_callback_fn
)0}
5942 test_st consistent_weighted_tests
[] ={
5943 {"generate_pairs", 1, (test_callback_fn
)generate_pairs
},
5944 {"generate_data", 1, (test_callback_fn
)generate_data_with_stats
},
5945 {"get_read", 0, (test_callback_fn
)get_read_count
},
5946 {"cleanup", 1, (test_callback_fn
)cleanup_pairs
},
5947 {0, 0, (test_callback_fn
)0}
5950 test_st hsieh_availability
[] ={
5951 {"hsieh_avaibility_test", 0, (test_callback_fn
)hsieh_avaibility_test
},
5952 {0, 0, (test_callback_fn
)0}
5956 test_st hash_sanity
[] ={
5957 {"hash sanity", 0, (test_callback_fn
)hash_sanity_test
},
5958 {0, 0, (test_callback_fn
)0}
5962 test_st ketama_auto_eject_hosts
[] ={
5963 {"auto_eject_hosts", 1, (test_callback_fn
)auto_eject_hosts
},
5964 {"output_ketama_weighted_keys", 1, (test_callback_fn
)output_ketama_weighted_keys
},
5965 {0, 0, (test_callback_fn
)0}
5968 test_st hash_tests
[] ={
5969 {"md5", 0, (test_callback_fn
)md5_run
},
5970 {"crc", 0, (test_callback_fn
)crc_run
},
5971 {"fnv1_64", 0, (test_callback_fn
)fnv1_64_run
},
5972 {"fnv1a_64", 0, (test_callback_fn
)fnv1a_64_run
},
5973 {"fnv1_32", 0, (test_callback_fn
)fnv1_32_run
},
5974 {"fnv1a_32", 0, (test_callback_fn
)fnv1a_32_run
},
5975 {"hsieh", 0, (test_callback_fn
)hsieh_run
},
5976 {"murmur", 0, (test_callback_fn
)murmur_run
},
5977 {"jenkis", 0, (test_callback_fn
)jenkins_run
},
5978 {0, 0, (test_callback_fn
)0}
5981 collection_st collection
[] ={
5983 {"hash_sanity", 0, 0, hash_sanity
},
5985 {"hsieh_availability", 0, 0, hsieh_availability
},
5986 {"udp_setup", (test_callback_fn
)init_udp
, 0, udp_setup_server_tests
},
5987 {"udp_io", (test_callback_fn
)init_udp
, 0, upd_io_tests
},
5988 {"udp_binary_io", (test_callback_fn
)binary_init_udp
, 0, upd_io_tests
},
5989 {"block", 0, 0, tests
},
5990 {"binary", (test_callback_fn
)pre_binary
, 0, tests
},
5991 {"nonblock", (test_callback_fn
)pre_nonblock
, 0, tests
},
5992 {"nodelay", (test_callback_fn
)pre_nodelay
, 0, tests
},
5993 {"settimer", (test_callback_fn
)pre_settimer
, 0, tests
},
5994 {"md5", (test_callback_fn
)pre_md5
, 0, tests
},
5995 {"crc", (test_callback_fn
)pre_crc
, 0, tests
},
5996 {"hsieh", (test_callback_fn
)pre_hsieh
, 0, tests
},
5997 {"jenkins", (test_callback_fn
)pre_jenkins
, 0, tests
},
5998 {"fnv1_64", (test_callback_fn
)pre_hash_fnv1_64
, 0, tests
},
5999 {"fnv1a_64", (test_callback_fn
)pre_hash_fnv1a_64
, 0, tests
},
6000 {"fnv1_32", (test_callback_fn
)pre_hash_fnv1_32
, 0, tests
},
6001 {"fnv1a_32", (test_callback_fn
)pre_hash_fnv1a_32
, 0, tests
},
6002 {"ketama", (test_callback_fn
)pre_behavior_ketama
, 0, tests
},
6003 {"ketama_auto_eject_hosts", (test_callback_fn
)pre_behavior_ketama
, 0, ketama_auto_eject_hosts
},
6004 {"unix_socket", (test_callback_fn
)pre_unix_socket
, 0, tests
},
6005 {"unix_socket_nodelay", (test_callback_fn
)pre_nodelay
, 0, tests
},
6006 {"poll_timeout", (test_callback_fn
)poll_timeout
, 0, tests
},
6007 {"gets", (test_callback_fn
)enable_cas
, 0, tests
},
6008 {"consistent_crc", (test_callback_fn
)enable_consistent_crc
, 0, tests
},
6009 {"consistent_hsieh", (test_callback_fn
)enable_consistent_hsieh
, 0, tests
},
6010 #ifdef MEMCACHED_ENABLE_DEPRECATED
6011 {"deprecated_memory_allocators", (test_callback_fn
)deprecated_set_memory_alloc
, 0, tests
},
6013 {"memory_allocators", (test_callback_fn
)set_memory_alloc
, 0, tests
},
6014 {"prefix", (test_callback_fn
)set_prefix
, 0, tests
},
6015 {"version_1_2_3", (test_callback_fn
)check_for_1_2_3
, 0, version_1_2_3
},
6016 {"string", 0, 0, string_tests
},
6017 {"result", 0, 0, result_tests
},
6018 {"async", (test_callback_fn
)pre_nonblock
, 0, async_tests
},
6019 {"async_binary", (test_callback_fn
)pre_nonblock_binary
, 0, async_tests
},
6020 {"user", 0, 0, user_tests
},
6021 {"generate", 0, 0, generate_tests
},
6022 {"generate_hsieh", (test_callback_fn
)pre_hsieh
, 0, generate_tests
},
6023 {"generate_ketama", (test_callback_fn
)pre_behavior_ketama
, 0, generate_tests
},
6024 {"generate_hsieh_consistent", (test_callback_fn
)enable_consistent_hsieh
, 0, generate_tests
},
6025 {"generate_md5", (test_callback_fn
)pre_md5
, 0, generate_tests
},
6026 {"generate_murmur", (test_callback_fn
)pre_murmur
, 0, generate_tests
},
6027 {"generate_jenkins", (test_callback_fn
)pre_jenkins
, 0, generate_tests
},
6028 {"generate_nonblock", (test_callback_fn
)pre_nonblock
, 0, generate_tests
},
6030 {"generate_corked", (test_callback_fn
)pre_cork
, 0, generate_tests
},
6031 {"generate_corked_and_nonblock", (test_callback_fn
)pre_cork_and_nonblock
, 0, generate_tests
},
6032 {"consistent_not", 0, 0, consistent_tests
},
6033 {"consistent_ketama", (test_callback_fn
)pre_behavior_ketama
, 0, consistent_tests
},
6034 {"consistent_ketama_weighted", (test_callback_fn
)pre_behavior_ketama_weighted
, 0, consistent_weighted_tests
},
6035 {"ketama_compat", 0, 0, ketama_compatibility
},
6036 {"test_hashes", 0, 0, hash_tests
},
6037 {"replication", (test_callback_fn
)pre_replication
, 0, replication_tests
},
6038 {"replication_noblock", (test_callback_fn
)pre_replication_noblock
, 0, replication_tests
},
6039 {"regression", 0, 0, regression_tests
},
6040 {"behaviors", 0, 0, behavior_tests
},
6044 #define SERVERS_TO_CREATE 5
6046 #include "libmemcached_world.h"
6048 void get_world(world_st
*world
)
6050 world
->collections
= collection
;
6052 world
->create
= (test_callback_create_fn
)world_create
;
6053 world
->destroy
= (test_callback_fn
)world_destroy
;
6055 world
->test
.startup
= (test_callback_fn
)world_test_startup
;
6056 world
->test
.flush
= (test_callback_fn
)world_flush
;
6057 world
->test
.pre_run
= (test_callback_fn
)world_pre_run
;
6058 world
->test
.post_run
= (test_callback_fn
)world_post_run
;
6059 world
->test
.on_error
= (test_callback_error_fn
)world_on_error
;
6061 world
->collection
.startup
= (test_callback_fn
)world_container_startup
;
6062 world
->collection
.shutdown
= (test_callback_fn
)world_container_shutdown
;
6064 world
->runner
= &defualt_libmemcached_runner
;